[clang] Add `__attribute__((nooutline))`

[paquette]

Summary

Sometimes users want to toggle which functions should be outlined from. Users could be trying to:

1. Debug the compiler and disable outlining in some contexts
2. Control where outlining actually happens in their program

This adds a frontend attribute that will allow users to toggle this behaviour on specific functions.

[jroelofs]

LGTM

clang/include/clang/Basic/Attr.td

1474

does it make sense on Block too?

[paquette]

clang/include/clang/Basic/Attr.td

1474

Oh good idea

[paquette]

Also support blocks

[aaron.ballman]

The changes are missing Sema tests for diagnosing incorrect appertainment, arguments, etc. It would also be good to have a CodeGen test showing the behavior works on an ObjC method and a C++ lambda. This should also come with a release note in clang/docs/ReleaseNotes.rst (there's a section specifically for attributes).

clang/include/clang/Basic/AttrDocs.td

587–588

I'd appreciate a bit more explanation/link to what outlining *is*. These docs don't really help a user understand the feature (the example is especially confusing because it shows typical C code with no explanation as to what happens with the attribute).

[aaron.ballman]

Also, precommit CI found valid test failures that need to be addressed.

clang/include/clang/Basic/Attr.td

 def NoMerge : DeclOrStmtAttr {
   let Spellings = [Clang<"nomerge">];
   let Documentation = [NoMergeDocs];
   let Subjects = SubjectList<[Function, Stmt], ErrorDiag,
                              "functions and statements">;
   let SimpleHandler = 1;
 }
 
+def NoOutline : InheritableAttr {
+  let Spellings = [Clang<"nooutline">];
+  let Subjects = SubjectList<[Function, ObjCMethod, Block]>;
+  let Documentation = [NoOutlineDocs];
+  let SimpleHandler = 1;
+}
+
 def MustTail : StmtAttr {
   let Spellings = [Clang<"musttail">];
   let Documentation = [MustTailDocs];
   let Subjects = SubjectList<[ReturnStmt], ErrorDiag, "return statements">;
 }
 
 def FastCall : DeclOrTypeAttr {
   let Spellings = [GCC<"fastcall">, Keyword<"__fastcall">,

clang/include/clang/Basic/AttrDocs.td

int example(void) {
     [[clang::noinline]] foo();
     [[clang::noinline]] r = bar();
     return r;
   }
 
   }];
 }
 
+def NoOutlineDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+
+Suppresses outlining from a function. Functions with this attribute will not
+be considered for outlining.
+
+.. code-block:: c
+
+  __attribute__((nooutline))
+  int example(void) {
+    int r;
+    foo();
+    bar();
+    return r;
+  }
+
+  }];
+}
+
 def MustTailDocs : Documentation {
   let Category = DocCatStmt;
   let Content = [{
 If a ``return`` statement is marked ``musttail``, this indicates that the
 compiler must generate a tail call for the program to be correct, even when
 optimizations are disabled. This guarantees that the call will not cause
 unbounded stack growth if it is part of a recursive cycle in the call graph.
 

clang/lib/CodeGen/CGCall.cpp

if (TargetDecl->hasAttr<ReturnsNonNullAttr>() &&
         !CodeGenOpts.NullPointerIsValid)
       RetAttrs.addAttribute(llvm::Attribute::NonNull);
     if (TargetDecl->hasAttr<AnyX86NoCallerSavedRegistersAttr>())
       FuncAttrs.addAttribute("no_caller_saved_registers");
     if (TargetDecl->hasAttr<AnyX86NoCfCheckAttr>())
       FuncAttrs.addAttribute(llvm::Attribute::NoCfCheck);
     if (TargetDecl->hasAttr<LeafAttr>())
       FuncAttrs.addAttribute(llvm::Attribute::NoCallback);
+    if (TargetDecl->hasAttr<NoOutlineAttr>())
+      FuncAttrs.addAttribute("nooutline");
 
     HasOptnone = TargetDecl->hasAttr<OptimizeNoneAttr>();
     if (auto *AllocSize = TargetDecl->getAttr<AllocSizeAttr>()) {
       std::optional<unsigned> NumElemsParam;
       if (AllocSize->getNumElemsParam().isValid())
         NumElemsParam = AllocSize->getNumElemsParam().getLLVMIndex();
       FuncAttrs.addAllocSizeAttr(AllocSize->getElemSizeParam().getLLVMIndex(),
                                  NumElemsParam);

clang/lib/CodeGen/CodeGenModule.cpp

if (D->hasAttr<ColdAttr>()) {
         B.addAttribute(llvm::Attribute::OptimizeForSize);
       B.addAttribute(llvm::Attribute::Cold);
     }
     if (D->hasAttr<HotAttr>())
       B.addAttribute(llvm::Attribute::Hot);
     if (D->hasAttr<MinSizeAttr>())
       B.addAttribute(llvm::Attribute::MinSize);
   }
+  if (D->hasAttr<NoOutlineAttr>())
+    B.addAttribute("nooutline");
 
   F->addFnAttrs(B);
 
   unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
   if (alignment)
     F->setAlignment(llvm::Align(alignment));
 
   if (!D->hasAttr<AlignedAttr>())

clang/test/CodeGen/attr-nooutline-blocks.m

+// RUN: %clang_cc1 %s -S -emit-llvm -fblocks /tmp/test.m -o - | FileCheck %s
+
+// CHECK: define internal void @__block_param_block_invoke({{.*}}) [[HAS_ATTR:#[0-9]+]]
+@interface ObjTy @end
+ObjTy *global;
+void escp(void (^)(ObjTy *));
+void block_param() {
+  escp(^(ObjTy *p) __attribute__((nooutline)) {});
+}
+
+// CHECK: attributes [[HAS_ATTR]] = { {{.*}}"nooutline"{{.*}} }

clang/test/CodeGen/attr-nooutline.c

+// RUN: %clang_cc1 %s -S -emit-llvm -o - | FileCheck %s
+
+// CHECK: define i32 @has_attr_2() [[HAS_ATTR_2:#[0-9]+]]
+// CHECK: declare i32 @has_attr_1() [[HAS_ATTR_1:#[0-9]+]]
+
+__attribute__((nooutline)) int has_attr_1(void);
+__attribute__((nooutline)) int has_attr_2(void) { return has_attr_1(); }
+
+// CHECK: attributes [[HAS_ATTR_2]] = { {{.*}}"nooutline"{{.*}} }
+// CHECK: attributes [[HAS_ATTR_1]] = { {{.*}}"nooutline"{{.*}} }