diff --git a/libcc2rs-macros/src/goto.rs b/libcc2rs-macros/src/goto.rs
index cb8ece18..03b41ef5 100644
--- a/libcc2rs-macros/src/goto.rs
+++ b/libcc2rs-macros/src/goto.rs
@@ -2,14 +2,16 @@
 // Distributed under the MIT license that can be found in the LICENSE file.
 
 use proc_macro::TokenStream;
+use proc_macro2::Span;
 use syn::parse::{Parse, ParseStream};
-use syn::{Expr, Lifetime, Token, parse_macro_input};
+use syn::{Block, Expr, ExprBlock, Lifetime, Stmt, parse_macro_input};
 
-use crate::state_machine::{Arm, GotoStateMachine, StateMachine};
+use crate::state_machine::{Arm, GotoStateMachine, StateMachine, StateMachineNames};
 
 pub fn expand(input: TokenStream) -> TokenStream {
     let GotoBlockInput { arms } = parse_macro_input!(input as GotoBlockInput);
     GotoStateMachine {
+        names: StateMachineNames::fresh(),
         arms: arms
             .into_iter()
             .map(|a| Arm {
@@ -33,15 +35,29 @@ struct GotoArm {
 
 impl Parse for GotoBlockInput {
     fn parse(input: ParseStream) -> syn::Result<Self> {
+        let block: Block = input.parse()?;
         let mut arms = Vec::new();
-        while !input.is_empty() {
-            let label: Lifetime = input.parse()?;
-            input.parse::<Token![=>]>()?;
-            let body: Expr = input.parse()?;
-            arms.push(GotoArm { label, body });
-            if input.peek(Token![,]) {
-                input.parse::<Token![,]>()?;
-            }
+        for stmt in block.stmts {
+            let Stmt::Expr(Expr::Block(eb), _) = stmt else {
+                return Err(syn::Error::new(
+                    Span::call_site(),
+                    "goto_block! body must be a sequence of labeled blocks",
+                ));
+            };
+            let Some(label) = eb.label else {
+                return Err(syn::Error::new(
+                    Span::call_site(),
+                    "goto_block! arm must be a labeled block",
+                ));
+            };
+            arms.push(GotoArm {
+                label: label.name,
+                body: Expr::Block(ExprBlock {
+                    attrs: eb.attrs,
+                    label: None,
+                    block: eb.block,
+                }),
+            });
         }
         Ok(Self { arms })
     }
diff --git a/libcc2rs-macros/src/lib.rs b/libcc2rs-macros/src/lib.rs
index 10317cf4..31310aff 100644
--- a/libcc2rs-macros/src/lib.rs
+++ b/libcc2rs-macros/src/lib.rs
@@ -36,10 +36,10 @@ pub fn switch(input: TokenStream) -> TokenStream {
     switch::expand(input)
 }
 
-//     goto_block! {
-//         '<label> => { /* body; may contain `break` or `continue` */ },
+//     goto_block!({
+//         '<label>: { /* body; may contain `break`, `continue`, or goto!('other) */ }
 //         ...
-//     };
+//     });
 //
 // Expands to
 //
diff --git a/libcc2rs-macros/src/state_machine.rs b/libcc2rs-macros/src/state_machine.rs
index f313a7a5..c930b25a 100644
--- a/libcc2rs-macros/src/state_machine.rs
+++ b/libcc2rs-macros/src/state_machine.rs
@@ -1,10 +1,13 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicU64, Ordering};
+
 use proc_macro2::{Ident, Span, TokenStream as TokenStream2};
 use quote::{format_ident, quote};
 use syn::visit_mut::{self, VisitMut};
-use syn::{Expr, ExprBreak, ExprContinue, Lifetime, Pat};
+use syn::{Expr, ExprBreak, ExprContinue, Lifetime, Pat, Stmt, parse_quote};
 
 pub struct Arm {
     pub label: String,
@@ -21,12 +24,29 @@ pub trait StateMachine {
     fn emit(self) -> TokenStream2;
 }
 
-fn sm_label() -> Lifetime {
-    Lifetime::new("'__sm", Span::call_site())
+pub(crate) struct StateMachineNames {
+    pub label: Lifetime,
+    pub state: Ident,
+    pub break_flag: Ident,
+    pub cont_flag: Ident,
+}
+
+impl StateMachineNames {
+    pub fn fresh() -> Self {
+        static COUNTER: AtomicU64 = AtomicU64::new(0);
+        let id = COUNTER.fetch_add(1, Ordering::Relaxed);
+        Self {
+            label: Lifetime::new(&format!("'__sm{id}"), Span::call_site()),
+            state: format_ident!("__s{}", id),
+            break_flag: format_ident!("__user_break{}", id),
+            cont_flag: format_ident!("__user_continue{}", id),
+        }
+    }
 }
 
 // Collection of labeled arms that fall-through by default
 pub struct GotoStateMachine {
+    pub names: StateMachineNames,
     pub arms: Vec<Arm>,
 }
 
@@ -87,10 +107,12 @@ impl GotoStateMachine {
 
 impl StateMachine for GotoStateMachine {
     fn emit(self) -> TokenStream2 {
-        let lbl = sm_label();
-        let s = format_ident!("__s");
-        let break_flag = format_ident!("__user_break");
-        let cont_flag = format_ident!("__user_continue");
+        let StateMachineNames {
+            label: lbl,
+            state: s,
+            break_flag,
+            cont_flag,
+        } = self.names;
 
         let n = self.arms.len();
         let mut arms_have_break = false;
@@ -101,6 +123,17 @@ impl StateMachine for GotoStateMachine {
             .enumerate()
             .map(|(i, arm)| {
                 let mut body = arm.body.clone();
+                GotoRewriter {
+                    map: &self
+                        .arms
+                        .iter()
+                        .enumerate()
+                        .map(|(i, a)| (a.label.clone(), i as u32))
+                        .collect(),
+                    state: s.clone(),
+                    sm_label: lbl.clone(),
+                }
+                .visit_expr_mut(&mut body);
                 let (had_br, had_cn) =
                     Self::propagate_rewrite(&mut body, &lbl, &break_flag, &cont_flag);
                 arms_have_break |= had_br;
@@ -131,6 +164,58 @@ impl StateMachine for GotoStateMachine {
     }
 }
 
+// Rewrites `goto!('label)` into `{ __s = <target index>; continue '__sm; }`.
+struct GotoRewriter<'a> {
+    // Map with labels and their indices inside the current state machine. Used to check if the
+    // label the goto jumps to is part of the current state machine. If it is, emit
+    // `__s = map[label]`
+    map: &'a HashMap<String, u32>,
+    state: Ident,
+    sm_label: Lifetime,
+}
+
+impl GotoRewriter<'_> {
+    fn expand_goto_into_state_machine_jump(&self, tokens: &TokenStream2) -> Option<Expr> {
+        let idx = *self.map.get(
+            &syn::parse2::<Lifetime>(tokens.clone())
+                .expect("goto! expects a lifetime label")
+                .ident
+                .to_string(),
+        )?;
+        let state = &self.state;
+        let sm_label = &self.sm_label;
+        Some(parse_quote!({ #state = #idx; continue #sm_label; }))
+    }
+
+    fn recurse_into_inner_goto_block(&mut self, mac: &mut syn::Macro) -> bool {
+        if mac.path.is_ident("switch") || mac.path.is_ident("goto_block") {
+            if let Ok(mut inner) = syn::parse2::<Expr>(mac.tokens.clone()) {
+                self.visit_expr_mut(&mut inner);
+                mac.tokens = quote!(#inner);
+            }
+            return true;
+        }
+        false
+    }
+}
+
+impl VisitMut for GotoRewriter<'_> {
+    fn visit_stmt_mut(&mut self, stmt: &mut Stmt) {
+        if let Stmt::Macro(sm) = stmt {
+            if sm.mac.path.is_ident("goto") {
+                if let Some(jump) = self.expand_goto_into_state_machine_jump(&sm.mac.tokens) {
+                    *stmt = Stmt::Expr(jump, Some(Default::default()));
+                }
+                return;
+            }
+            if self.recurse_into_inner_goto_block(&mut sm.mac) {
+                return;
+            }
+        }
+        visit_mut::visit_stmt_mut(self, stmt);
+    }
+}
+
 // GotoStateMachine(dispatch arm + cases)
 pub struct SwitchStateMachine {
     pub goto: GotoStateMachine,
@@ -186,17 +271,16 @@ impl SwitchStateMachine {
 
 impl StateMachine for SwitchStateMachine {
     fn emit(self) -> TokenStream2 {
-        let lbl = sm_label();
-        let s = format_ident!("__s");
+        let names = StateMachineNames::fresh();
 
-        let user_arms = Self::convert_break_to_switch_exit(&self.goto.arms, &lbl);
-        let dispatch = self.build_dispatch_arm(&user_arms, &lbl, &s);
+        let user_arms = Self::convert_break_to_switch_exit(&self.goto.arms, &names.label);
+        let dispatch = self.build_dispatch_arm(&user_arms, &names.label, &names.state);
 
         let mut arms = Vec::new();
         arms.push(dispatch);
         arms.extend(user_arms);
 
-        GotoStateMachine { arms }.emit()
+        GotoStateMachine { names, arms }.emit()
     }
 }
 
diff --git a/libcc2rs-macros/src/switch.rs b/libcc2rs-macros/src/switch.rs
index cc17ef10..30845113 100644
--- a/libcc2rs-macros/src/switch.rs
+++ b/libcc2rs-macros/src/switch.rs
@@ -5,7 +5,9 @@ use proc_macro::TokenStream;
 use syn::parse::{Parse, ParseStream};
 use syn::{Expr, Pat, parse_macro_input};
 
-use crate::state_machine::{Arm, DispatchCase, GotoStateMachine, StateMachine, SwitchStateMachine};
+use crate::state_machine::{
+    Arm, DispatchCase, GotoStateMachine, StateMachine, StateMachineNames, SwitchStateMachine,
+};
 
 pub fn expand(input: TokenStream) -> TokenStream {
     let SwitchInput { condition, arms } = parse_macro_input!(input as SwitchInput);
@@ -24,7 +26,10 @@ pub fn expand(input: TokenStream) -> TokenStream {
         });
     }
     SwitchStateMachine {
-        goto: GotoStateMachine { arms: cfg_arms },
+        goto: GotoStateMachine {
+            names: StateMachineNames::fresh(),
+            arms: cfg_arms,
+        },
         condition,
         cases,
     }
diff --git a/libcc2rs-macros/tests/control_flow.rs b/libcc2rs-macros/tests/control_flow.rs
index 4549c260..e5dbd156 100644
--- a/libcc2rs-macros/tests/control_flow.rs
+++ b/libcc2rs-macros/tests/control_flow.rs
@@ -229,7 +229,6 @@ fn switch_nested_loop_break_targets_inner() {
 
 #[test]
 fn switch_return_from_case() {
-    #[allow(unreachable_code)]
     fn classify(x: i32) -> &'static str {
         switch!(match x {
             0 => {
@@ -242,7 +241,7 @@ fn switch_return_from_case() {
                 return "other";
             }
         });
-        "unreachable"
+        panic!("ub: non-void function does not return a value");
     }
     assert_eq!(classify(0), "zero");
     assert_eq!(classify(1), "one");
@@ -269,41 +268,211 @@ fn switch_in_loop() {
 #[test]
 fn goto_block_linear_fallthrough() {
     let mut v = 0;
-    goto_block! {
-        'a => { v += 1; },
-        'b => { v += 10; },
-        'c => { v += 100; },
-    };
+    goto_block!({
+        'a: {
+            v += 1;
+        }
+        'b: {
+            v += 10;
+        }
+        'c: {
+            v += 100;
+        }
+    });
     assert_eq!(v, 111);
 }
 
 #[test]
 fn goto_block_return_from_arm() {
-    #[allow(unreachable_code)]
     fn run(start: u32) -> &'static str {
-        goto_block! {
-            'a => { if start == 0 { return "a"; } },
-            'b => { if start == 1 { return "b"; } },
-            'c => { return "c"; },
-        };
-        "fallthrough"
+        goto_block!({
+            'a: {
+                if start == 0 {
+                    return "a";
+                }
+            }
+            'b: {
+                if start == 1 {
+                    return "b";
+                }
+            }
+            'c: {
+                return "c";
+            }
+        });
+        panic!("ub: non-void function does not return a value");
     }
     assert_eq!(run(0), "a");
     assert_eq!(run(1), "b");
     assert_eq!(run(2), "c");
 }
 
+#[test]
+fn goto_block_forward_goto_skips_block() {
+    fn skip(n: i32) -> i32 {
+        let mut x: i32 = 0;
+        goto_block!({
+            '__entry: {
+                x = 0;
+                if n > 0 {
+                    goto!('mid);
+                }
+                x += 10;
+            }
+            'mid: {
+                x += 1;
+            }
+        });
+        x
+    }
+    assert_eq!(skip(1), 1);
+    assert_eq!(skip(-1), 11);
+}
+
+#[test]
+fn goto_block_local_visible_across_label() {
+    fn early(n: i32) -> i32 {
+        let mut ret: i32 = 0;
+        goto_block!({
+            '__entry: {
+                if n < 0 {
+                    ret = -1;
+                    goto!('out);
+                }
+                ret = 100;
+            }
+            'out: {
+                return ret;
+            }
+        });
+        panic!("ub: non-void function does not return a value");
+    }
+    assert_eq!(early(-1), -1);
+    assert_eq!(early(5), 100);
+}
+
+#[test]
+fn goto_block_backward_goto_retry() {
+    fn f() -> i32 {
+        let mut sum: i32 = 0;
+        let mut i: i32 = 0;
+        goto_block!({
+            'again: {
+                let local: i32 = i;
+                sum += local;
+                i += 1;
+                if i < 4 {
+                    goto!('again);
+                }
+                return sum;
+            }
+        });
+        panic!("ub: non-void function does not return a value");
+    }
+    assert_eq!(f(), 6);
+}
+
+#[test]
+fn goto_block_multi_label_fallthrough() {
+    fn classify(n: i32) -> i32 {
+        let mut ret: i32 = 0;
+        goto_block!({
+            '__entry: {
+                if n < 0 {
+                    goto!('error);
+                }
+                if n == 0 {
+                    goto!('out);
+                }
+                ret = n;
+                goto!('out);
+            }
+            'error: {
+                ret = -1;
+            }
+            'out: {
+                return ret;
+            }
+        });
+        panic!("ub: non-void function does not return a value");
+    }
+    assert_eq!(classify(5), 5);
+    assert_eq!(classify(0), 0);
+    assert_eq!(classify(-2), -1);
+}
+
+#[test]
+fn goto_block_goto_out_of_switch() {
+    fn sm(n: i32) -> i32 {
+        let mut ret: i32 = 0;
+        goto_block!({
+            '__entry: {
+                switch!(match n {
+                    0 => {
+                        ret += 1;
+                    }
+                    1 => {
+                        ret += 10;
+                        goto!('out);
+                    }
+                    _ => {
+                        ret += 100;
+                        break;
+                    }
+                });
+                ret += 1000;
+            }
+            'out: {
+                return ret;
+            }
+        });
+        panic!("ub: non-void function does not return a value");
+    }
+    assert_eq!(sm(0), 11);
+    assert_eq!(sm(1), 10);
+    assert_eq!(sm(9), 1100);
+}
+
+#[test]
+fn goto_block_goto_out_of_nested_block() {
+    fn f(n: i32) -> i32 {
+        let mut ret: i32 = 0;
+        goto_block!({
+            '__entry: {
+                goto_block!({
+                    'inner: {
+                        ret = 1;
+                        if n > 0 {
+                            goto!('out);
+                        }
+                        ret = 2;
+                    }
+                });
+                ret += 10;
+            }
+            'out: {
+                return ret;
+            }
+        });
+        panic!("ub: non-void function does not return a value");
+    }
+    assert_eq!(f(1), 1);
+    assert_eq!(f(-1), 12);
+}
+
 #[test]
 fn goto_block_nested_loop_break_targets_inner() {
     let mut sum = 0;
-    goto_block! {
-        'entry => {
+    goto_block!({
+        'entry: {
             for i in 0..10 {
-                if i == 3 { break; } // targets the for loop
+                if i == 3 {
+                    break;
+                } // targets the for loop
                 sum += i;
             }
             sum += 100;
-        },
-    };
+        }
+    });
     assert_eq!(sum, 103);
 }