Allow variables with asm labels in naked functions

[nikola]

Summary

I think the current mode is too restrictive, it will emit error for any statement inside a naked function. Code I'm trying to compile for ARM declares registers as variables to improve readability and passes them as input operands to inline assembly.

register uint32_t Something asm("rax");

[hans]

I think this is reasonable. Just a few comments:

lib/Sema/SemaDecl.cpp

11796

I think we'll need to check for multiple declarators here:

register int x asm("eax"), y asm("ebx");

And do we need to check for an initializer? For example, the following should not be allowed:

register int x asm("eax") = g();

It would also be nice to have a comment explaining why these are Ok but not other declarations.

[rnk]

Won't the mid-level optimizer turn these register variables into undefs, and we'll end up with this kind of IR?

void f() {
  int register var asm ("eax") ;
  asm volatile ("add %%eax, %0\n\tret" : : "r"(var));
}
->
define void @"\01?f@@YAXXZ"() local_unnamed_addr #0 {
entry:
  tail call void asm sideeffect "add %eax, $0\0A\09ret", "{eax},~{dirflag},~{fpsr},~{flags}"(i32 undef) #1, !srcloc !2
  ret void
}

I guess it's OK so long as we don't codegen undef to anything, but it could go badly.

[nikola]

This should address Hans' comments, as for the code get I have no idea. I was hoping someone more knowledgeable would tell me if this made sense or not?

[hans]

lgtm

I'm a little bit worried that we've started down a slippery slope of deciding what is and isn't allowed in naked functions (for example, some initializers could be allowed if we're sure they don't require stack). But I suppose this isn't making anything worse, and if it helps compile real-world code, that's good.

[nikola]

r281298

lib/Sema/SemaDecl.cpp

 
     if (FD && FD->hasAttr<NakedAttr>()) {
       for (const Stmt *S : Body->children()) {
+        // Allow local register variables without initializer as they don't
+        // require prologue.
+        bool RegisterVariables = false;
+        if (auto *DS = dyn_cast<DeclStmt>(S)) {
+          for (const auto *Decl : DS->decls()) {
+            if (const auto *Var = dyn_cast<VarDecl>(Decl)) {
+              RegisterVariables =
+                  Var->hasAttr<AsmLabelAttr>() && !Var->hasInit();
+              if (!RegisterVariables)
+                break;
+            }
+          }
+        }
+        if (RegisterVariables)
+          continue;
         if (!isa<AsmStmt>(S) && !isa<NullStmt>(S)) {
           Diag(S->getLocStart(), diag::err_non_asm_stmt_in_naked_function);
           Diag(FD->getAttr<NakedAttr>()->getLocation(), diag::note_attribute);

test/Sema/attr-naked.c

                "r"(z) // expected-error{{parameter references not allowed in naked functions}}
            );
 }
+
+__attribute__((naked)) void t10() {  // expected-note{{attribute is here}}
+  int a; // expected-error{{non-ASM statement in naked function is not supported}}
+}
+
+__attribute__((naked)) void t11() {  // expected-note{{attribute is here}}
+  register int a asm("eax") = x; // expected-error{{non-ASM statement in naked function is not supported}}
+}
+
+__attribute__((naked)) void t12() {  // expected-note{{attribute is here}}
+  register int a asm("eax"), b asm("ebx") = x; // expected-error{{non-ASM statement in naked function is not supported}}
+}
+
+__attribute__((naked)) void t13() {
+  register int a asm("eax");
+  register int b asm("ebx"), c asm("ecx");
+}
+