How to generate one instruction only when asm! is used in naked functions?

[luojia65]

There's a usage sceneario in Rust for embedded rom bootloader. Some chips use eGON.BT0 format on boot, it has one jump instruction on head and the following should be boot tables.

Bit index	Content
0..4	an instruction j main
5..12	bootloader magic
12..	following boot configurations

It's ideal to write this instruction j main using Rust naked function as follows, in this way we do not require further tools to help with filling this instruction.

#[naked]
#[link_section = ".head.text"]
#[export_name = "head_jump"]
pub unsafe extern "C" fn head_jump() {
    asm!("j {}", sym main, options(noreturn))
}

The options(noreturn) is required in current naked function or it won't compile. I expect this function to generate one instruction j main only, however it generates an unimp which is unexpected:

Disassembly of section .head.text:

0000000000000000 <head_jump>:
       0: 6f 00 60 02   j       0x26 <_ZN18test_d1_flash_bare4main17h5fd8eeda800e7085E>
       4: 00 00         unimp

Disassembly of section .text:

...

I didn't expect this unimp instruction, for it will overlap bootloader magic, making this Rust image not bootable. What should I do?

I looked into RFC 2972, in section Naked Function Definition it shows:

5. emit no additional instructions to the function body before the asm!() statement.

Should we expect that there would be additional instructions after what we have in asm! macro?

Note: I try to remove the option(noreturn), it shows following compile error:

   Compiling test-d1-flash-bare v0.1.0 (D:\RustSBI\test-d1-flash-bare)
error[E0787]: asm in naked functions must use `noreturn` option
  --> src\main.rs:17:5
   |
17 |     asm!("j {}", sym start)
   |     ^^^^^^^^^^^^^^^^^^^^^^^
   |
help: consider specifying that the asm block is responsible for returning from the function
   |
17 |     asm!("j {}", sym start, options(noreturn))
   |                           +++++++++++++++++++

For more information about this error, try `rustc --explain E0787`.
error: could not compile `test-d1-flash-bare` due to previous error

[hellow554]

It could/should work with global_asm!, but sym is currenlty not compatible with that. But there's a PR @ #94468
Maybe you could give it a try.

[jyn514]

Triage: is this still an issue? I'm not sure what --target you're compiling to so I can't check myself locally.

eGON.BT0 seems to be some ARM chip: https://linux-sunxi.org/Main_Page

[jyn514]

Ok, turns out this is a MIPS architecture actually. Minimal reproduction:

#![no_std]
#![feature(naked_functions, asm_experimental_arch, start)]

use core::arch::asm;

#[naked]
#[link_section = ".head.text"]
#[export_name = "head_jump"]
pub unsafe extern "C" fn head_jump() {
    asm!("j {}", sym main, options(noreturn))
}

#[start]
fn start(_: isize, _: *const *const u8) -> isize {
    0
}

fn main() {}

#[panic_handler]
fn panic(_: &core::panic::PanicInfo) -> ! {
    loop {}
}

I'm trying to get access to a linker/version of objdump that actually supports this architecture, I think binutils-mips-linux-gnu is what I want.

[luojia65]

@jyn514 : I'm using RISC-V compiling target. It's riscv64imac-unknown-none-elf.

[jyn514]

Hmm, I'm still having trouble reproducing this. I'm compiling with rustc example.rs -C panic=abort --target riscv64imac-unknown-none-elf and disassembling with riscv64-unknown-elf-objdump -D example, but it doesn't have any .head.text section:

; riscv64-unknown-elf-objdump -D example -j .head.text

example:     file format elf64-littleriscv

riscv64-unknown-elf-objdump: section '.head.text' mentioned in a -j option, but not found in any input file

What am I missing?

[luojia65]

@jyn514 : It looks like that we should provide a linker script to include ".head.text" into output file, or I'll try put it into ".text" instead to see what will happen.

[erikdesjardins]

Godbolt repro: https://godbolt.org/z/d9oebcjhW

This happens because of TrapUnreachable, which tells LLVM to codegen unreachable as a trap instruction instead of nothing:

rust/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp

Lines 451 to 457 in c469197

	if (TrapUnreachable) {
	// Tell LLVM to codegen `unreachable` into an explicit trap instruction.
	// This limits the extent of possible undefined behavior in some cases, as
	// it prevents control flow from "falling through" into whatever code
	// happens to be laid out next in memory.
	Options.TrapUnreachable = true;
	}

Given that TrapUnreachable significantly limits the impact of returning-from-noreturn (and similar "entering unreachable code") UB, and that global_asm! works (see godbolt link above), I don't think we should make any change here.