`naked_asm!` does not accept assembly syntax that is accepted by `asm!`

[Fulgen301]

I tried this code:

extern "C" fn foo() {
    unsafe {
        core::arch::asm!("mov rax, QWORD PTR gs:[60h]");
    }
}

#[unsafe(naked)]
extern "C" fn foo2() {
    core::arch::naked_asm!("mov rax, QWORD PTR gs:[60h]")
}

I expected to see this happen: Both functions assemble correctly, as the only difference between the assembly statements is naked_asm! being used instead of asm!.

Instead, this happened: Assembly error in foo2:

error: <inline asm>:10:27: unknown token in expression
mov rax, QWORD PTR gs:[60h]
                          ^

Meta

rustc --version --verbose:

rustc 1.92.0-nightly (4645a7988 2025-09-17)
binary: rustc
commit-hash: 4645a7988177c286f61609cc667ecae4c571a2e8
commit-date: 2025-09-17
host: x86_64-pc-windows-msvc
release: 1.92.0-nightly
LLVM version: 21.1.1

[MauriceKayser]

Might be something about the syntax. Replacing 60h with 0x60 causes compilation to succeed.

[folkertdev]

A naked function actually uses module-level assembly (similar to global_asm!), which must be where the difference comes from. I'm not sure specifically what the difference is. It might be that LLVM parses and rewrites the standard asm! but doesn't do so for module-level assembly.

In any case, there is little that rust itself can do, this is all handled by LLVM. I'd expect Clang to have the same issue.

[Fulgen301]

I'd expect Clang to have the same issue.

Clang does not..

[folkertdev]

Interesting, so actually rust also accepts this on godbolt: https://godbolt.org/z/8x6TWhPfe. Are you using some non-linux target (windows maybe?)

[Fulgen301]

Yes, x86_64-pc-windows-msvc, however, clang on Windows accepts it as well:

PS> cat test.cpp
[[gnu::naked]] void foo() {
    __asm__("mov rax, QWORD PTR gs:[60h]");
}

int main() {
    return 0;
}
PS> clang++ --version
clang version 21.1.2
Target: x86_64-pc-windows-msvc
Thread model: posix
InstalledDir: C:\Program Files\LLVM\bin
PS> clang++ -masm=intel test.cpp
PS>

[folkertdev]

can you replicate the rust failure in a godbolt? Your original example works fine for msvc https://godbolt.org/z/ef4dMv5bx.

[Fulgen301]

I cannot (Rust on godbolt would be crosscompiling from Linux to Windows), however, I can replicate it by emitting LLVM IR and compiling it with clang without -masm=intel:

PS> rustc test.rs
error: unknown token in expression
   |
note: instantiated into assembly here
  --> <inline asm>:10:27
   |
10 | mov rax, QWORD PTR gs:[60h]
   |                           ^

error: aborting due to 1 previous error

PS> rustc --emit=llvm-ir test.rs
PS> clang test.ll
warning: overriding the module target triple with x86_64-pc-windows-msvc19.44.35217 [-Woverride-module]
<inline asm>:10:27: error: unknown token in expression
mov rax, QWORD PTR gs:[60h]
                          ^
error: cannot compile inline asm
1 warning and 1 error generated

, despite the .intel_syntax in the module asm block; whereas copying the emitted IR into godbolt's llc assembles successfully (https://godbolt.org/z/3fYeTxY49). Seems to be a difference in the way LLVM handles module assembly on Windows / something that -masm=intel force overrides for clang?

Clang also doesn't use module asm - it emits

; Function Attrs: naked noinline nounwind optnone uwtable
define dso_local void @foo() #0 {
  call void asm sideeffect "mov rax, QWORD PTR gs:[60h]", "~{dirflag},~{fpsr},~{flags}"() #2, !srcloc !8
  unreachable
}

[ChrisDenton]

I couldn't directly repo the example in the op. It only errored if I actually use foo2:

F:\Temp\rust> cat naked.rs
extern "C" fn foo() {
    unsafe {
        core::arch::asm!("mov rax, QWORD PTR gs:[60h]");
    }
}

#[unsafe(naked)]
extern "C" fn foo2() {
    core::arch::naked_asm!("mov rax, QWORD PTR gs:[60h]")
}

pub fn doit() {
    foo();
    foo2();
}
F:\Temp\rust> rustc +nightly naked.rs --crate-type=lib
error: unknown token in expression
  |
note: instantiated into assembly here
 --> <inline asm>:9:27
  |
9 | mov rax, QWORD PTR gs:[60h]
  |                           ^

error: unknown token in expression
  |
note: instantiated into assembly here
 --> <inline asm>:9:27
  |
9 | mov rax, QWORD PTR gs:[60h]
  |                           ^

error: aborting due to 2 previous errors

[folkertdev]

Yes for context, clang naked functions are different from rust naked functions. Clang uses the naked llvm function attribute, which, strangely, does not guarantee that no additional instructions are added.

Rust instead desugars to global_asm! and an extern block to define the symbol. So the fair comparison versus clang is to use module-level assembly, because rust has nothing like clang's naked functions.