Function calls can be inlined in naked functions, leading to crashes / memory corruption

[BinaryWarlock]

Say you have code like:

inline fn f(x: u32) u32 {
    return x;
}

fn testfn() callconv(.Naked) void {
    _ = f(0);

    asm volatile ("ret");
}

If the call f is inlined (as is the case here), it generates code using %rbp assuming there were a stack frame, when there is none.

If it's not inlined, it emits a call instruction which then sets up f's own new stack frame.

Does Zig want to define what behavior happens here? Right now it doesn't even error or warn, it just miscompiles it.

I think there are two ways to approach this:

• Never inline calls in naked functions
• Throw an error when calling functions from a naked function

In either case it should always error if the call involves an argument on the stack (pertinent to #72).

And yes, I ran into this in real code. GCC/Clang doesn't let you call functions from naked functions, but Zig let me so I thought it might work -- until I compiled in release mode and my callee was inlined.

[leecannon]

As part of approach 2 (although I prefer approach 1) the compiler could error unless all calls to non-naked functions from a naked function be invocations of @call() with an explicit stack given.

[andrewrk]

Works with the new inline semantics:

0000000000000000 <testfn>:
   0:	c3                   	ret
   1:	c3                   	ret