Do not skip over fence instructions

crates/polkavm-linker/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "polkavm-linker"
-version = "0.8.1"
+version = "0.8.2"
 authors.workspace = true
 license.workspace = true
 edition.workspace = true

crates/polkavm-linker/src/program_from_elf.rs

@@ -1611,7 +1611,10 @@ fn convert_instruction(
             emit(InstExt::Control(ControlInst::Unimplemented));
             Ok(())
         }
-        Inst::FenceI | Inst::Fence { .. } => Ok(()),
+        Inst::FenceI | Inst::Fence { .. } => {
+            emit(InstExt::Basic(BasicInst::Nop));
+            Ok(())
+        }
         Inst::Load { kind, dst, base, offset } => {
             let Some(dst) = cast_reg_non_zero(dst)? else {
                 return Err(ProgramFromElfError::other("found a load with a zero register as the destination"));
@@ -2046,16 +2049,21 @@ fn parse_code_section(
                 }
             }
 
+            let original_length = output.len();
             convert_instruction(section, current_location, original_inst, |inst| {
                 output.push((source, inst));
-            })?
+            })?;
+
+            // We need to always emit at least one instruction (even if it's a NOP) to handle potential jumps.
+            assert_ne!(output.len(), original_length, "internal error: no instructions were emitted");
         }
     }
 
     Ok(())
 }
 
 fn split_code_into_basic_blocks(
+    elf: &Elf,
     jump_targets: &HashSet<SectionTarget>,
     instructions: Vec<(Source, InstExt<SectionTarget, SectionTarget>)>,
 ) -> Result<Vec<BasicBlock<SectionTarget, SectionTarget>>, ProgramFromElfError> {
@@ -2064,6 +2072,11 @@ fn split_code_into_basic_blocks(
     let mut block_start_opt = None;
     let mut last_source_in_block = None;
     for (source, op) in instructions {
+        log::trace!(
+            "Instruction at {source} (0x{:x}): {op:?}",
+            elf.section_by_index(source.section_index).original_address() + source.offset_range.start
+        );
+
         if let Some(last_source_in_block) = last_source_in_block {
             // Handle the case where we've emitted multiple instructions from a single RISC-V instruction.
             if source == last_source_in_block {
@@ -2228,7 +2241,7 @@ fn resolve_basic_block_references(
         else {
             return Err(ProgramFromElfError::other(format!(
                 "found control instruction at the end of block at {block_source} whose target doesn't resolve to any basic block: {next:?}",
-                block_source = block.source.begin(),
+                block_source = block.source,
                 next = block.next.instruction,
             )));
         };
@@ -6507,7 +6520,7 @@ pub fn program_from_elf(config: Config, data: &[u8]) -> Result<ProgramBlob, Prog
         .collect();
 
     let all_jump_targets = harvest_all_jump_targets(&elf, &data_sections_set, &code_sections_set, &instructions, &relocations, &exports)?;
-    let all_blocks = split_code_into_basic_blocks(&all_jump_targets, instructions)?;
+    let all_blocks = split_code_into_basic_blocks(&elf, &all_jump_targets, instructions)?;
     for block in &all_blocks {
         for source in block.next.source.as_slice() {
             assert!(source.offset_range.start < source.offset_range.end);