Contents from global_asm! leak into other assemblies

[nagisa]

In code like this as noted here

#![feature(global_asm)]
#![feature(asm)]

global_asm!(r"
.macro foo, arg, size
  add \arg, \arg, \size
.endm");

const BAR: u64 = 10;

pub fn bar(mut v: u64) -> u64 {
    unsafe { 
        asm!("foo {v}, {}", const(BAR), v = inout(reg) v);
    }
    v
}

the macro will leak into the inline asm!, but this is likely extremely brittle. For instance, Rust is free to split this module into 2 distinct CGUs, making the code like this mysteriously work or break.

This could probably be mitigated by isolating all the global_asm! into its own CGU – that way none of the inline asm invocations would be able to observe the global_asm! stuff. Alternatively, if we find we want to support this behaviour we would be forced to collect all uses of global_asm! and items containing inline asm in a crate into a single CGU. Supporting this would also have implications to alternative backend support.

cc #35119

[jgouly]

The example code above is mine, and I like it "leaking" as it allows me to use const and sym.

If global_asm was extended to support const and sym too, that would also be a useful alternative, to not leak.

#![feature(global_asm)]

const BAR: u64 = 10;

global_asm!("
.global bar
bar:
  add x0, x0, {bar}
  ret
", bar = const(BAR));

[Amanieu]

We do not want to support this behavior. This only exists in LLVM to support building the Linux kernel which relies on a lot of GCC internal details.

However I'm less sure whether it's worth the trouble of messing with the CGU partitioning to actually enforce this.

[nagisa]

If it is not enforced, people will rely on this and various other non-obvious forms of this unintended feature. It will become stable by convention, even if we say this should not work and people should not rely on it.

The only alternative I see is to keep global_asm! unstable until things we don't want to support are actually enforced, either through the stability system or via compiler's behaviour.

[Amanieu]

The same issue happens with just asm!. This isn't specific to global_asm!.

#![feature(asm)]

const BAR: u64 = 10;

pub fn bar(mut v: u64) -> u64 {
    unsafe { 
        asm!(r"
        .macro foo, arg, size
          add \arg, \size
        .endm");
        asm!("foo {v}, {}", const(BAR), v = inout(reg) v);
    }
    v
}