Emitter now removes unreachable IR blocks, preventing invalid instructions after returning if branches.

src/emit/ebpf/tracepoint.rs

@@ -180,9 +180,13 @@ impl Builder {
 pub fn compile_tracepoint(unit: &UnitIr) -> Result<CompiledProgram, String> {
     let mut b = Builder::new(unit)?;
     let branch_cond_vars = branch_condition_vars(unit);
+    let reachable_blocks = reachable_block_ids(unit);
     b.push(Insn::new(BPF_MOV64_REG, R6, R1, 0, 0));
 
     for block in &unit.blocks {
+        if !reachable_blocks.contains(&block.id.0) {
+            continue;
+        }
         b.block_offsets.insert(block.id.0, b.insns.len());
 
         for inst in &block.instructions {
@@ -322,6 +326,44 @@ pub fn compile_tracepoint(unit: &UnitIr) -> Result<CompiledProgram, String> {
     })
 }
 
+fn reachable_block_ids(unit: &UnitIr) -> HashSet<u32> {
+    let blocks = unit
+        .blocks
+        .iter()
+        .map(|block| (block.id.0, block))
+        .collect::<HashMap<_, _>>();
+    let entry = match unit.blocks.first() {
+        Some(block) => block.id.0,
+        None => return HashSet::new(),
+    };
+
+    let mut reachable = HashSet::new();
+    let mut pending = vec![entry];
+    while let Some(block_id) = pending.pop() {
+        if !reachable.insert(block_id) {
+            continue;
+        }
+
+        let Some(block) = blocks.get(&block_id) else {
+            continue;
+        };
+        match block.terminator {
+            Terminator::Return(_) => {}
+            Terminator::Jump(target) => pending.push(target.0),
+            Terminator::Branch {
+                true_block,
+                false_block,
+                ..
+            } => {
+                pending.push(true_block.0);
+                pending.push(false_block.0);
+            }
+        }
+    }
+
+    reachable
+}
+
 fn branch_condition_vars(unit: &UnitIr) -> HashSet<u32> {
     let mut out = HashSet::new();
     for block in &unit.blocks {

src/parser/unit.rs

@@ -21,7 +21,6 @@ pub fn parse_unit(parser: &mut Parser) -> Result<Unit, ParseError> {
 
     while !parser.check(TokenKind::RBrace) {
         if parser.r#match(TokenKind::KeywordSection) {
-            expect_token(parser, TokenKind::Colon)?;
             let s = parser.expect(TokenKind::StringLiteral)?;
 
             let txt = s.lexeme.trim_matches('"').to_string();
@@ -31,7 +30,6 @@ pub fn parse_unit(parser: &mut Parser) -> Result<Unit, ParseError> {
         }
 
         if parser.r#match(TokenKind::KeywordLicense) {
-            expect_token(parser, TokenKind::Colon)?;
             let s = parser.expect(TokenKind::StringLiteral)?;
 
             let txt = s.lexeme.trim_matches('"').to_string();