[IR/MachineOutliner] Add a "nooutline" function attr and respect it

[paquette]

Summary

Add nooutline + update LangRef to say it exists.

This makes it possible to say "don't outline from this function ever."

We want to be able to toggle whether or not a function should be in the search set regardless of default behaviour.

Add testcases for the IR + Machine outliners.

[paquette]

(somewhat straightforward, but I feel like adding something to the langref requires a LGTM from someone)

[arsenm]

llvm/docs/LangRef.rst

1851

This is documented as a first class enum attribute, but the code is using a string attribute. If it's an enum attribute, the code needs to change. If it's a string attribute, it should go below with the others and be expressed with quotes

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

21

No typed pointers in new tests

[arsenm]

llvm/docs/LangRef.rst

1852

"should ever"

llvm/lib/CodeGen/MachineOutliner.cpp

882–889

Normal check would be skip declaration, F.empty for a defined function is invalid

[paquette]

llvm/docs/LangRef.rst

1851

It doesn't seem like these are grouped by being string attributes/not string attributes.

The last string attribute is "min-legal-vector-width"; should I move it after that?

[nikic]

FWIW, if something affects IR semantics, I'd generally expect it to be a first-class attribute.

[paquette]

In D140438#4010322, @nikic wrote:

FWIW, if something affects IR semantics, I'd generally expect it to be a first-class attribute.

Would it be better for me to move it to Attributes.td, then?

[arsenm]

In D140438#4011132, @paquette wrote:

In D140438#4010322, @nikic wrote:

FWIW, if something affects IR semantics, I'd generally expect it to be a first-class attribute.

Would it be better for me to move it to Attributes.td, then?

I don't have a particularly strong opinion either way. I don't think I'd go so far as to say this changes IR semantics, it just turns off one transform

[paquette]

• Remove typed pointers from IR test
• Move the attribute in the docs and mark it as a string
• Remove unnecessary check for empty function in the MachineOutliner
• Improve wording in docs

[nikic]

In D140438#4011148, @arsenm wrote:

I don't have a particularly strong opinion either way. I don't think I'd go so far as to say this changes IR semantics, it just turns off one transform

Okay, let's go with the string attribute then.

[paquette]

Good to go then?

[nikic]

LGTM

[aaron.ballman]

llvm/docs/LangRef.rst

2235–2237

This broke the sphinx build (https://lab.llvm.org/buildbot/#/builders/30/builds/30072) and I think you can fix it with this suggested edit.

[paquette]

llvm/docs/LangRef.rst

2235–2237

Oops, should be fixed.

[aaron.ballman]

llvm/docs/LangRef.rst

2235–2237

Thank you! I confirmed everything is good again.

llvm/docs/LangRef.rst

``noimplicitfloat``
     Also inhibits optimizations that create SIMD/vector code and registers from
     scalar code such as vectorization or memcpy/memset optimization. This
     includes integer vectors. Vector instructions present in IR may still cause
     vector code to be generated.
 ``noinline``
     This attribute indicates that the inliner should never inline this
     function in any situation. This attribute may not be used together
     with the ``alwaysinline`` attribute.
 ``nomerge``
     This attribute indicates that calls to this function should never be merged
     during optimization. For example, it will prevent tail merging otherwise
     identical code sequences that raise an exception or terminate the program.
     Tail merging normally reduces the precision of source location information,
     making stack traces less useful for debugging. This attribute gives the
     user control over the tradeoff between code size and debug information
     precision.
 ``nonlazybind``
     This attribute suppresses lazy symbol binding for the function. This
``"warn-stack-size"="<threshold>"``
     than `UINT_MAX`.  It's unspecified which threshold will be used when
     duplicate definitions are linked together with differing values.
 ``vscale_range(<min>[, <max>])``
     This attribute indicates the minimum and maximum vscale value for the given
     function. The min must be greater than 0. A maximum value of 0 means
     unbounded. If the optional max value is omitted then max is set to the
     value of min. If the attribute is not present, no assumptions are made
     about the range of vscale.
+  ``"nooutline"``
+    This attribute indicates that outlining passes should not modify the
+    function.
 
 Call Site Attributes
 ----------------------
 
 In addition to function attributes the following call site only
 attributes are supported:
 
 ``vector-function-abi-variant``

llvm/lib/CodeGen/MachineOutliner.cpp

bool MachineOutliner::outline(Module &M,
   return OutlinedSomething;
 }
 
 void MachineOutliner::populateMapper(InstructionMapper &Mapper, Module &M,
                                      MachineModuleInfo &MMI) {
   // Build instruction mappings for each function in the module. Start by
   // iterating over each Function in M.
   for (Function &F : M) {
 
-    // If there's nothing in F, then there's no reason to try and outline from
-    // it.
-    if (F.empty())
+    if (F.hasFnAttribute("nooutline")) {
+      LLVM_DEBUG({
+        dbgs() << "... Skipping function with nooutline attribute: "
+               << F.getName() << "\n";
+      });
       continue;
+    }
 
     // There's something in F. Check if it has a MachineFunction associated with
     // it.
     MachineFunction *MF = MMI.getMachineFunction(F);
 
     // If it doesn't, then there's nothing to outline from. Move to the next
     // Function.
     if (!MF)

llvm/lib/Transforms/IPO/IROutliner.cpp

if (isa<CallInst>(FirstCandidate.front()->Inst) &&
       return;
   }
 
   unsigned CurrentEndIdx = 0;
   for (IRSimilarityCandidate &IRSC : CandidateVec) {
     PreviouslyOutlined = false;
     unsigned StartIdx = IRSC.getStartIdx();
     unsigned EndIdx = IRSC.getEndIdx();
+    const Function &FnForCurrCand = *IRSC.getFunction();
 
     for (unsigned Idx = StartIdx; Idx <= EndIdx; Idx++)
       if (Outlined.contains(Idx)) {
         PreviouslyOutlined = true;
         break;
       }
 
     if (PreviouslyOutlined)
       continue;
 
     // Check over the instructions, and if the basic block has its address
     // taken for use somewhere else, we do not outline that block.
     bool BBHasAddressTaken = any_of(IRSC, [](IRInstructionData &ID){
       return ID.Inst->getParent()->hasAddressTaken();
     });
 
     if (BBHasAddressTaken)
       continue;
 
-    if (IRSC.getFunction()->hasOptNone())
+    if (FnForCurrCand.hasOptNone())
       continue;
 
+    if (FnForCurrCand.hasFnAttribute("nooutline")) {
+      LLVM_DEBUG({
+        dbgs() << "... Skipping function with nooutline attribute: "
+               << FnForCurrCand.getName() << "\n";
+      });
+      continue;
+    }
+
     if (IRSC.front()->Inst->getFunction()->hasLinkOnceODRLinkage() &&
         !OutlineFromLinkODRs)
       continue;
 
     // Greedily prune out any regions that will overlap with already chosen
     // regions.
     if (CurrentEndIdx != 0 && StartIdx <= CurrentEndIdx)
       continue;

llvm/test/CodeGen/AArch64/machine-outliner-nooutline-attribute.mir

+# RUN: llc -mtriple=aarch64 -debug-only=machine-outliner -run-pass=machine-outliner -verify-machineinstrs %s -o - 2>&1 | FileCheck %s
+# REQUIRES: asserts
+
+# CHECK: ... Skipping function with nooutline attribute: no_outline
+# CHECK-NOT: ... Skipping function with nooutline attribute: baz
+# CHECK-NOT: OUTLINED
+
+--- |
+  define void @no_outline() #0 { unreachable }
+  define void @baz() { unreachable }
+  attributes #0 = { noredzone "nooutline" }
+...
+---
+
+name:            no_outline
+tracksRegLiveness: true
+body:             |
+  bb.0:
+    liveins: $w0, $lr, $w8
+    $sp = frame-setup SUBXri $sp, 32, 0
+    $fp = frame-setup ADDXri $sp, 16, 0
+  bb.1:
+    BL @baz, implicit-def dead $lr, implicit $sp
+    $w17 = ORRWri $wzr, 1
+    $w17 = ORRWri $wzr, 1
+    $w0 = ORRWri $wzr, 4
+    BL @baz, implicit-def dead $lr, implicit $sp
+    $w17 = ORRWri $wzr, 1
+    $w17 = ORRWri $wzr, 1
+    $w0 = ORRWri $wzr, 3
+    BL @baz, implicit-def dead $lr, implicit $sp
+    $w17 = ORRWri $wzr, 1
+    $w17 = ORRWri $wzr, 1
+    $w0 = ORRWri $wzr, 2
+    BL @baz, implicit-def dead $lr, implicit $sp
+    $w17 = ORRWri $wzr, 1
+    $w17 = ORRWri $wzr, 1
+    $w0 = ORRWri $wzr, 1
+  bb.2:
+    $fp, $lr = LDPXi $sp, 2
+    RET undef $lr
+

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

+; RUN: opt -S -debug-only=iroutliner -p=iroutliner -ir-outlining-no-cost %s -o - 2>&1 | FileCheck %s
+; REQUIRES: asserts
+
+; CHECK-NOT: ... Skipping function with nooutline attribute: outlinable
+; CHECK-NOT: @outlined_ir_func
+; CHECK: ... Skipping function with nooutline attribute: nooutline1
+; CHECK: ... Skipping function with nooutline attribute: nooutline2
+
+define void @outlinable() { ret void }
+
+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.p0i8.p0i8.i64(ptr %d, ptr %s, i64 %len, i1 false)
+  %c = add i8 %a, %b
+  %ret = load i8, ptr %s
+  ret i8 %ret
+}
+
+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.p0i8.p0i8.i64(ptr %d, ptr %s, i64 %len, i1 false)
+  %c = add i8 %a, %b
+  %ret = load i8, ptr %s
+  ret i8 %ret
+}
+
+declare void @llvm.memcpy.p0i8.p0i8.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1)
+