Don't emit prologues/epilogues for naked functions (PR18791, PR20028)

[hans]

Summary

For naked functions with parameters, Clang would emit prologues that end up clobbering the stack because LLVM doesn't set up a stack frame. For example, this function on X86:

attribute((naked)) int f(int x) {

asm("movl $42, %eax");
asm("retl");

}

Results in:

_Z1fi:

movl    12(%esp), %eax
movl    %eax, (%esp)  <--- Oops.
movl    $42, %eax
retl

(This was already reported as PR18791, and PR20028 for the epilogue.)

My patch does three things, which can be committed separately, but I figured it's easier to review them together:

• Don't emit prologues/epilogues for naked functions
• Don't allow non-asm statements in naked functions
• Don't allow asm statements to refer to parameters in naked functions.

Please take a look.

[compnerd]

Is supporting the attribute (( naked )) spelling on x86 intentional? It can certainly be a nice extension, but keep in mind that GCC only permits this on ARM, AVR, MCORE, MSP430, NDS32, RL78, RX and SPU ports. However, we need the __declspec(naked) spelling for MSVC compatibility. It might be nice to document that we support the attribute across the board rather than keep GCC compatibility.

[thakis]

lib/Sema/SemaStmtAsm.cpp

414 ↗

(On Diff #13237)

Do you need to Func->setInvalidDecl(); here too?

[rnk]

lgtm

lib/Sema/SemaStmtAsm.cpp

414 ↗

(On Diff #13237)

Let's do that.

test/CodeGen/attr-naked.c

21 ↗

(On Diff #13237)

This CHECK will fail in a non-asserts build, because the name 'entry' will be elided. I guess I'd just rely on the CHECK-NOT for alloca and store followed by CHECK unreachable.

[hans]

lib/Sema/SemaStmtAsm.cpp

414 ↗

(On Diff #13237)

I commented on the email thread that maybe "return ExprError()" is the right thing to do here. That seems to be how the rest of this function does it.

[hans]

Closed by commit rL217198 (authored by @hans).

cfe/trunk/lib/CodeGen/CGCall.cpp

if (NNAttr->isNonNull(PVD->getFunctionScopeIndex()))
       return true;
   }
   return false;
 }
 
 void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI,
                                          llvm::Function *Fn,
                                          const FunctionArgList &Args) {
+  if (CurCodeDecl && CurCodeDecl->hasAttr<NakedAttr>())
+    // Naked functions don't have prologues.
+    return;
+
   // If this is an implicit-return-zero function, go ahead and
   // initialize the return value.  TODO: it might be nice to have
   // a more general mechanism for this that didn't require synthesized
   // return statements.
   if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurCodeDecl)) {
     if (FD->hasImplicitReturnZero()) {
       QualType RetTy = FD->getReturnType().getUnqualifiedType();
       llvm::Type* LLVMTy = CGM.getTypes().ConvertType(RetTy);
static llvm::StoreInst *findDominatingStoreToReturnValue(CodeGenFunction &CGF) {
   // Okay, the store's basic block dominates the insertion point; we
   // can do our thing.
   return store;
 }
 
 void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI,
                                          bool EmitRetDbgLoc,
                                          SourceLocation EndLoc) {
+  if (CurCodeDecl && CurCodeDecl->hasAttr<NakedAttr>()) {
+    // Naked functions don't have epilogues.
+    Builder.CreateUnreachable();
+    return;
+  }
+
   // Functions with no result always return void.
   if (!ReturnValue) {
     Builder.CreateRetVoid();
     return;
   }
 
   llvm::DebugLoc RetDbgLoc;
   llvm::Value *RV = nullptr;

cfe/trunk/test/CodeGen/attr-naked.c

 // RUN: %clang_cc1 -triple x86_64-apple-macosx10.7.0 %s -emit-llvm -o - | FileCheck %s
 
 void t1() __attribute__((naked));
 
 // Basic functionality check
 // (Note that naked needs to imply noinline to work properly.)
 // CHECK: define void @t1() [[NAKED:#[0-9]+]] {
 void t1()
 {
 }
 
 // Make sure this doesn't explode in the verifier.
 // (It doesn't really make sense, but it isn't invalid.)
 // CHECK: define void @t2() [[NAKED]] {
-__attribute((naked, always_inline)) void t2()  {
+__attribute((naked, always_inline)) void t2() {
 }
 
+// Make sure not to generate prolog or epilog for naked functions.
+__attribute((naked)) void t3(int x) {
+// CHECK: define void @t3(i32)
+// CHECK-NOT: alloca
+// CHECK-NOT: store
+// CHECK: unreachable
+}
+
 // CHECK: attributes [[NAKED]] = { naked noinline nounwind{{.*}} }