Labels in asm! macros don't emit symbols

[brian-armstrong]

In the following inline assembly

asm!("movq $0, %rax
          movq $4, %rcx
          loop:
          addq $1, %rax
          cmpq %rax, %rcx
          ja loop" :::);

the label loop won't get a symbol in the output binary (with -g turned on). It feels like an appropriate symbol might be of the format module::struct::function::hash similar to other symbols.

[nagisa]

This is an expected behaviour. You are expected to use relative labels instead:






    asm!("movq $$0, %rax
          movq $$4, %rcx
          1:
          addq $$1, %rax
          cmpq %rax, %rcx
          ja 1b" :::);
    }

Those behave similarly to the similar feature in GCC. You cannot get inline assembly to emit globally named labels.

[nagisa]

Do complain if you think I’m wrong and I’ll reopen.

[brian-armstrong]

@nagisa Thanks for the quick response. However to be clear, I'm arguing for debug symbols, not symbols which can be used as targets in asm. In profilers, these labels just appear as bare memory addresses. Worse, Instruments (the OSX profiler in XCode) seems to get somewhat confused by these addresses and folds some unrelated instructions in under the bare addresses.

[nagisa]

Yeah, I don’t think we will ever bother emitting either debug info or proper symbols for labels introduced by the inline assembly.

[brian-armstrong]

Is that a matter of policy or because it's technically difficult? I might be interested in remediating the latter but can't change the former :)

[nagisa]

We don’t have much policy around inline assembly, other than that we consider it incomplete and not on path of stabilisation in its current form. "Techincal difficulty" could be an apt way to describe the “bother”. If such functionality was implemented in LLVM, we could enable it, however there are multiple complicating factors – emitting debug info does not occur automagically and complicating the debuginfo code with concerns of a fairly obscure component of a feature that has not had due design effort might not be the right way to go about this.

From my minor experiments it seems that having an asm!("label:") will in fact work and should result in an actual symbol (with a verbatim name) although a local one, so that part is working as expected.

Does an equivalent code compiled with clang behave as expected? If so, then that could be a good place to start looking at the differences between what Rust and clang do.

[brian-armstrong]

Good question. Maybe I'm expecting something unreasonable here. I'll take a look at what clang does with inline assembly.

What do you mean re: local symbol? I don't recognize that term. I'm also curious what tool you use to poke at Rust program symbols - I've tried nm but it feels like there are an overwhelming number of symbols and it's hard to tease out which ones are relevant.

[levex]

Clang:

$ cat test.c
#include <stdio.h>

int
main(int argc, char **argvp)
{
    asm volatile("movq $0, %%rax;"
          "movq $4, %%rcx;"
          "a_long_name_that_definitely_doesnt_get_autoinserted:"
          "addq $1, %%rax;"
          "cmpq %%rax, %%rcx;"
          "ja a_long_name_that_definitely_doesnt_get_autoinserted" :::);
    return 0;
}
$ clang --version
clang version 7.0.0 (tags/RELEASE_700/final)
Target: x86_64-pc-linux-gnu
Thread model: posix
InstalledDir: /usr/bin
$ clang test.c -o test
$ nm test | grep definitely
0000000000001140 t a_long_name_that_definitely_doesnt_get_autoinserted
$

(For looking at rust symbols, I use cargo-binutils which works nicely as cargo nm $file.)

[nagisa]

@brian-armstrong a symbol can be local or global. In both cases a symbol exists, but only global symbols can be linked to, for example. This works in a similar fashion as private and public functions in codegen units.

I used nm piped into grep to verify rust’s behaviour.

[steveklabnik]

Triage: asm is being replaced wholesale in #69171 ; I am not sure if it changes this behavior or not.

[joshtriplett]

I would expect that if you want to export a symbol from inline assembly, you'll need to add a .global directive or similar. Though as the sample above shows, in some cases those symbols may be provided even without doing so.