[outliners] Turn nooutline into an Enum Attribute

llvm/docs/LangRef.rst

@@ -2738,7 +2738,7 @@ For example:
     to signify an unbounded maximum. The syntax `vscale_range(<val>)` can be
     used to set both `min` and `max` to the same value. Functions that don't
     include this attribute make no assumptions about the value of `vscale`.
-``"nooutline"``
+``nooutline``
     This attribute indicates that outlining passes should not modify the
     function.
 

llvm/docs/ReleaseNotes.md

@@ -63,6 +63,9 @@ Changes to the LLVM IR
   address component of a pointer type variable but unlike `ptrtoint` does not
   capture provenance ([#125687](https://github.com/llvm/llvm-project/pull/125687)).
 
+* The `"nooutline"` attribute is now writen as `nooutline`. Existing IR and
+  bitcode will be automatically updated.
+
 Changes to LLVM infrastructure
 ------------------------------
 

llvm/include/llvm/Bitcode/LLVMBitCodes.h

@@ -801,6 +801,7 @@ enum AttributeKindCodes {
   ATTR_KIND_CAPTURES = 102,
   ATTR_KIND_DEAD_ON_RETURN = 103,
   ATTR_KIND_SANITIZE_ALLOC_TOKEN = 104,
+  ATTR_KIND_NOOUTLINE = 105,
 };
 
 enum ComdatSelectionKindCodes {

llvm/include/llvm/IR/Attributes.td

@@ -207,6 +207,9 @@ def NoImplicitFloat : EnumAttr<"noimplicitfloat", IntersectPreserve, [FnAttr]>;
 /// inline=never.
 def NoInline : EnumAttr<"noinline", IntersectPreserve, [FnAttr]>;
 
+/// nooutline
+def NoOutline : EnumAttr<"nooutline", IntersectPreserve, [FnAttr]>;
+
 /// Function is called early and/or often, so lazy binding isn't worthwhile.
 def NonLazyBind : EnumAttr<"nonlazybind", IntersectPreserve, [FnAttr]>;
 

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

@@ -2257,6 +2257,8 @@ static Attribute::AttrKind getAttrFromCode(uint64_t Code) {
     return Attribute::Captures;
   case bitc::ATTR_KIND_DEAD_ON_RETURN:
     return Attribute::DeadOnReturn;
+  case bitc::ATTR_KIND_NOOUTLINE:
+    return Attribute::NoOutline;
   }
 }
 

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

@@ -956,6 +956,8 @@ static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
     return bitc::ATTR_KIND_CAPTURES;
   case Attribute::DeadOnReturn:
     return bitc::ATTR_KIND_DEAD_ON_RETURN;
+  case Attribute::NoOutline:
+    return bitc::ATTR_KIND_NOOUTLINE;
   case Attribute::EndAttrKinds:
     llvm_unreachable("Can not encode end-attribute kinds marker.");
   case Attribute::None:

llvm/lib/CodeGen/MachineOutliner.cpp

@@ -1257,7 +1257,7 @@ void MachineOutliner::populateMapper(InstructionMapper &Mapper, Module &M) {
   for (Function &F : M) {
     LLVM_DEBUG(dbgs() << "MAPPING FUNCTION: " << F.getName() << "\n");
 
-    if (F.hasFnAttribute("nooutline")) {
+    if (F.hasFnAttribute(Attribute::NoOutline)) {
       LLVM_DEBUG(dbgs() << "SKIP: Function has nooutline attribute\n");
       continue;
     }

llvm/lib/IR/AutoUpgrade.cpp

@@ -5956,6 +5956,12 @@ void llvm::UpgradeFunctionAttributes(Function &F) {
     F.removeFnAttr("implicit-section-name");
   }
 
+  if (Attribute A = F.getFnAttribute("nooutline");
+      A.isValid() && A.isStringAttribute()) {
+    F.removeFnAttr("nooutline");
+    F.addFnAttr(Attribute::NoOutline);
+  }
+
   if (!F.empty()) {
     // For some reason this is called twice, and the first time is before any
     // instructions are loaded into the body.

llvm/lib/Transforms/IPO/IROutliner.cpp

@@ -2419,7 +2419,7 @@ void IROutliner::pruneIncompatibleRegions(
     if (FnForCurrCand.hasOptNone())
       continue;
 
-    if (FnForCurrCand.hasFnAttribute("nooutline")) {
+    if (FnForCurrCand.hasFnAttribute(Attribute::NoOutline)) {
       LLVM_DEBUG({
         dbgs() << "... Skipping function with nooutline attribute: "
                << FnForCurrCand.getName() << "\n";

llvm/lib/Transforms/Utils/CodeExtractor.cpp

@@ -933,6 +933,10 @@ Function *CodeExtractor::constructFunctionDeclaration(
       case Attribute::CoroDestroyOnlyWhenComplete:
       case Attribute::CoroElideSafe:
       case Attribute::NoDivergenceSource:
+      // CodeExtractor is used by the IROutliner, so we should not be extracting
+      // from a function with nooutline, but if we do, we should not be
+      // propagating this attribute.
+      case Attribute::NoOutline:
         continue;
       // Those attributes should be safe to propagate to the extracted function.
       case Attribute::AlwaysInline:

llvm/test/Bitcode/upgrade-nooutline.ll

@@ -0,0 +1,12 @@
+; RUN: llvm-as < %s | llvm-dis - | FileCheck %s
+
+; CHECK: define void @f() [[ATTR:#[0-9]+]]
+; CHECK-NOT: "nooutline"
+; CHECK: attributes [[ATTR]] = {
+; CHECK-NOT: "nooutline"
+; CHECK-SAME: nooutline
+; CHECK-NOT: "nooutline"
+
+define void @f() "nooutline" {
+  ret void
+}

llvm/test/CodeGen/AArch64/machine-outliner-mapper-debug-output.mir

@@ -17,7 +17,7 @@
 
 --- |
   define void @block_too_small() noredzone { unreachable }
-  define void @no_outline() noredzone "nooutline" { unreachable }
+  define void @no_outline() noredzone nooutline { unreachable }
   define void @redzone() { unreachable }
   declare void @no_mf()
   define void @block_addr_fn() noredzone {

llvm/test/Transforms/IROutliner/nooutline-attribute.ll

@@ -8,7 +8,7 @@
 
 define void @outlinable() { ret void }
 
-define i8 @nooutline1(ptr noalias %s, ptr noalias %d, i64 %len) "nooutline" {
+define i8 @nooutline1(ptr noalias %s, ptr noalias %d, i64 %len) nooutline {
   %a = load i8, ptr %s
   %b = load i8, ptr %d
   call void @llvm.memcpy.p0.p0.i64(ptr %d, ptr %s, i64 %len, i1 false)
@@ -17,7 +17,7 @@ define i8 @nooutline1(ptr noalias %s, ptr noalias %d, i64 %len) "nooutline" {
   ret i8 %ret
 }
 
-define i8 @nooutline2(ptr noalias %s, ptr noalias %d, i64 %len) "nooutline" {
+define i8 @nooutline2(ptr noalias %s, ptr noalias %d, i64 %len) nooutline {
   %a = load i8, ptr %s
   %b = load i8, ptr %d
   call void @llvm.memcpy.p0.p0.i64(ptr %d, ptr %s, i64 %len, i1 false)