Adding Comment Annotations to Outlined Functions

[AndrewLitteken]

Summary

To help explain how a function was outlined the way it was, function annotations are adde in the comments of the output assembly to explain the results. This is done by added Metadata to the function, and, when in verbose mode, when the name of the function is put in the comments near the label for the function, how it was outlined is explained next to the name.

[paquette]

Added some comments.

Also, this needs a testcase which shows that the comments are added.

I think it would make sense to get this going properly for AArch64 first, and ignore X86 for now.

llvm/include/llvm/CodeGen/MachineOutliner.h

26

These are target-specific. I don't think we want to pull these in explicitly here. Different targets aren't guaranteed to implement the same types of outlining.

Also some of these things wouldn't make sense on other targets (e.g. NoLRSave)

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

709

clang-format

llvm/lib/CodeGen/MachineOutliner.cpp

78

Do you have to include string here?

1151

Is it possible to use a Twine here?

http://llvm.org/docs/ProgrammersManual.html#the-twine-class

1152–1161

I think that this should be implemented in the target rather than in the generic algorithm.

1152–1161

I think that you want to communicate the FrameID here, not the CallConstructionID?

One outlined function can be called in more than one way. E.g. it's possible to call the same outlined function using the NoLRSave and RegSave modes.

llvm/lib/Target/AArch64/AArch64InstrInfo.cpp

5559–5565

Commented out code in patch?

llvm/lib/Target/X86/X86InstrInfo.cpp

8666–8669

Commented out code in patch?

[AndrewLitteken]

Tests have been updated to look for the annotations.

The checking now happens on the FrameID and occurs in the Target rather than the Outliner.

[paquette]

llvm/lib/Target/AArch64/AArch64InstrInfo.cpp

6377–6378

Can we move this comment into the thunk case?

Having it above the OutlinerString is somewhat out of place IMO.

6395–6396

Can we have this be the first case to make the braces a bit nicer?

if (OF.FrameConstructionID == MachineOutlinerTailCall)
    OutlinerString = "Tail Call";
else if (OF.FrameConstructionID == MachineOutlinerThunk) {
  // .. stuff
}

llvm/test/CodeGen/AArch64/machine-outliner-function-annotate.ll

1 ↗

(On Diff #257177)

Is it possible to write this as a MIR test? In general, MIR tests are better for late passes like the outliner because they let us know exactly which instructions the outliner will work on. With IR tests, we are fragile against other changes in the code generator.

To generate MIR, you can run:

llc (all the flags you want) -stop-before=machine-outliner -simplify-mir

Then you can create a testcase with a RUN line similar to below:

llc (all the flags you want) -run-pass=machine-outliner ...

31 ↗

(On Diff #257177)

Missing newline?

[AndrewLitteken]

llvm/test/CodeGen/AArch64/machine-outliner-function-annotate.ll

1 ↗

(On Diff #257177)

I'm not sure that this works in this case, because the annotations are on the assembly code and don't show up in the MIR. Based on the docs I've found you can't output assembly from MIR.

[paquette]

llvm/test/CodeGen/AArch64/machine-outliner-function-annotate.ll

1 ↗

(On Diff #257177)

Oh, yeah, you're right. :)

To output assembly, you can use

llc (all the flags you want) -start-before=machine-outliner ...

You may also have to add -enable-machine-outliner.

This tells llc to start the pass pipeline at the point where the MachineOutliner should run. It will continue the pass pipeline through until emitting assembly.

[AndrewLitteken]

A lot of changes:

1. Split emitting the comment into its own function and only defined in AArch64ASMPrinter.cpp
2. New MIR test for function annotation
3. Support for the MIR test, so that AArchMachineFunctionInfo hasRedZone attribute is output to the MIR file and is read back in through the YAML parsing

[paquette]

I think this is a better direction than before. Also, I think having the redzone attribute in the MIR is very helpful for outliner tests in general.

I think this should be two separate patches though: one to add the attribute to the MIR, and one to add comments to the outlined functions. Reason being that

1. I think that the attribute in the MIR needs a few standalone test cases
2. This is useful functionality *outside* of the outliner which I think could allow us to simplify future outliner MIR tests

llvm/include/llvm/CodeGen/AsmPrinter.h

680 ↗

(On Diff #257472)

Might want a Doxygen comment here, so that this will have an entry in the AsmPrinter docs.

e.g.

/// Emits a comment for a function header.

llvm/lib/Target/AArch64/AArch64MachineFunctionInfo.h

134 ↗

(On Diff #257472)

This should have a Doxygen comment.

[AndrewLitteken]

What's the best way to split these up? The test for the outlined comments rely on the RedZone Function Info.

[AndrewLitteken]

I updated for Doxygen comments, I created a new revision D78173 that implements the MIR patch, but haven't removed it here yet since the MIR test is dependent on that being in place.

[AndrewLitteken]

Updating the diff after merging the noRedZone function info patch

[paquette]

Added some comments on the testcase.

It'd be nice to just remove the IR entirely if possible, or at the very least simplify it down to a minimal form. Simple testcases are easier to fix +understand when they inevitably break someday. :)

llvm/test/CodeGen/AArch64/machine-outliner-function-annotate.mir

15–18 ↗

(On Diff #258791)

This can be deleted, I think.

21–25 ↗

(On Diff #258791)

If you replace all instances of bb.0.entry with bb.0, you can delete the IR code here.

e.g. replace it with

define void @a() { ret void }

30 ↗

(On Diff #258791)

This can probably just be define void?

In general, 99% of the IR isn't necessary in MIR tests. Only things that are directly referenced in the MIR are necessary (variables, function names, etc.)

32–35 ↗

(On Diff #258791)

This IR code can be deleted as well, if you replace all instances of bb.0.entry in the MIR.

39 ↗

(On Diff #258791)

This can be deleted

41 ↗

(On Diff #258791)

This isn't used anywhere, so it can be deleted.

55–58 ↗

(On Diff #258791)

Can you delete this?

66 ↗

(On Diff #258791)

You can replace (store 8 into %stack.2) with (store 8) to simplify the MIR a bit.

75 ↗

(On Diff #258791)

Is it possible to get this testcase to work without a BL?

If it is, then I think you can delete all of the IR and leave only the MIR.

76 ↗

(On Diff #258791)

Replace (store 4 into %ir.ptr) with (store 4)

(There are a few other places with code like this which can similarly be simplified.)

93–96 ↗

(On Diff #258791)

Can you delete this?

[AndrewLitteken]

Simplified version of the new mir test

[paquette]

LGTM

llvm/include/llvm/CodeGen/MachineOutliner.h

 #include "llvm/CodeGen/LiveRegUnits.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
 #include "llvm/CodeGen/LivePhysRegs.h"
 
 namespace llvm {
 namespace outliner {
 
+enum MachineOutlinerClass {
+  MachineOutlinerDefault,  /// Emit a save, restore, call, and return.
+  MachineOutlinerTailCall, /// Only emit a branch.
+  MachineOutlinerNoLRSave, /// Emit a call and return.
+  MachineOutlinerThunk,    /// Emit a call and tail-call.
+  MachineOutlinerRegSave   /// Same as default, but save to a register.
+};
+
 /// Represents how an instruction should be mapped by the outliner.
 /// \p Legal instructions are those which are safe to outline.
 /// \p LegalTerminator instructions are safe to outline, but only as the
 /// last instruction in a sequence.
 /// \p Illegal instructions are those which cannot be outlined.
 /// \p Invisible instructions are instructions which can be outlined, but
 /// shouldn't actually impact the outlining result.
 enum InstrType { Legal, LegalTerminator, Illegal, Invisible };

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

if (MAI->hasDotTypeDotSizeDirective())
     OutStreamer->emitSymbolAttribute(CurrentFnSym, MCSA_ELF_TypeFunction);
 
   if (F.hasFnAttribute(Attribute::Cold))
     OutStreamer->emitSymbolAttribute(CurrentFnSym, MCSA_Cold);
 
   if (isVerbose()) {
     F.printAsOperand(OutStreamer->GetCommentOS(),
                    /*PrintType=*/false, F.getParent());
+    MDNode *OutlinedMetaData = F.getMetadata("outlined.kind");
+    if (OutlinedMetaData)
+      if(MDString *OutlinedMetaString = dyn_cast<MDString>(OutlinedMetaData->getOperand(0)))
+        OutStreamer->GetCommentOS() << ' ' << OutlinedMetaString->getString();
     OutStreamer->GetCommentOS() << '\n';
   }
 
   // Emit the prefix data.
   if (F.hasPrefixData()) {
     if (MAI->hasSubsectionsViaSymbols()) {
       // Preserving prefix data on platforms which use subsections-via-symbols
       // is a bit tricky. Here we introduce a symbol for the prefix data

llvm/lib/CodeGen/MachineOutliner.cpp

 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <functional>
+#include <string>
 #include <tuple>
 #include <vector>
 
 #define DEBUG_TYPE "machine-outliner"
 
 using namespace llvm;
 using namespace ore;
 using namespace outliner;
MachineFunction *MachineOutliner::createOutlinedFunction(
   // function. This makes sure the outlined function knows what kinds of
   // instructions are going into it. This is fine, since all parent functions
   // must necessarily support the instructions that are in the outlined region.
   Candidate &FirstCand = OF.Candidates.front();
   const Function &ParentFn = FirstCand.getMF()->getFunction();
   if (ParentFn.hasFnAttribute("target-features"))
     F->addFnAttr(ParentFn.getFnAttribute("target-features"));
 
+  std::string OutlineKindString = "; ";
+  if (FirstCand.CallConstructionID == MachineOutlinerTailCall)
+    OutlineKindString += "Tail Call";
+  else if (FirstCand.CallConstructionID == MachineOutlinerThunk)
+    OutlineKindString += "Thunk";
+  else if (FirstCand.CallConstructionID == MachineOutlinerNoLRSave)
+    OutlineKindString += "Function with no Save and Restore";
+  else if (FirstCand.CallConstructionID == MachineOutlinerRegSave)
+    OutlineKindString += "Function saving to register";
+  else
+    OutlineKindString += "Function";
+
   BasicBlock *EntryBB = BasicBlock::Create(C, "entry", F);
   IRBuilder<> Builder(EntryBB);
   Builder.CreateRetVoid();
 
   MachineModuleInfo &MMI = getAnalysis<MachineModuleInfoWrapperPass>().getMMI();
   MachineFunction &MF = MMI.getOrCreateMachineFunction(*F);
   MachineBasicBlock &MBB = *MF.CreateMachineBasicBlock();
   const TargetSubtargetInfo &STI = MF.getSubtarget();
   const TargetInstrInfo &TII = *STI.getInstrInfo();
 
+  MDNode* N = MDNode::get(C, MDString::get(C, OutlineKindString));
+  F->addMetadata("outlined.kind", *N);
+
   // Insert the new function into the module.
   MF.insert(MF.begin(), &MBB);
 
   for (auto I = FirstCand.front(), E = std::next(FirstCand.back()); I != E;
        ++I) {
     MachineInstr *NewMI = MF.CloneMachineInstr(&*I);
     NewMI->dropMemRefs(MF);
 

llvm/lib/Target/AArch64/AArch64InstrInfo.cpp

 /// I2 --> BL OUTLINED_FUNCTION       I1
 /// I3     Restore LR                 I2
 ///                                   I3
 ///                                   RET
 ///
 /// * Call construction overhead: 3 (save + BL + restore)
 /// * Frame construction overhead: 1 (ret)
 /// * Requires stack fixups? No
-enum MachineOutlinerClass {
+/*enum MachineOutlinerClass {
   MachineOutlinerDefault,  /// Emit a save, restore, call, and return.
   MachineOutlinerTailCall, /// Only emit a branch.
   MachineOutlinerNoLRSave, /// Emit a call and return.
   MachineOutlinerThunk,    /// Emit a call and tail-call.
   MachineOutlinerRegSave   /// Same as default, but save to a register.
-};
+};*/
 
 enum MachineOutlinerMBBFlags {
   LRUnavailableSomewhere = 0x2,
   HasCalls = 0x4,
   UnsafeRegsDead = 0x8
 };
 
 unsigned
outliner::OutlinedFunction AArch64InstrInfo::getOutliningCandidateInfo(
 
   // Helper lambda which sets call information for every candidate.
   auto SetCandidateCallInfo =
       [&RepeatedSequenceLocs](unsigned CallID, unsigned NumBytesForCall) {
         for (outliner::Candidate &C : RepeatedSequenceLocs)
           C.setCallInfo(CallID, NumBytesForCall);
       };
 
-  unsigned FrameID = MachineOutlinerDefault;
+  unsigned FrameID = outliner::MachineOutlinerDefault;
   NumBytesToCreateFrame += 4;
 
   bool HasBTI = any_of(RepeatedSequenceLocs, [](outliner::Candidate &C) {
     return C.getMF()->getFunction().hasFnAttribute("branch-target-enforcement");
   });
 
   // Returns true if an instructions is safe to fix up, false otherwise.
   auto IsSafeToFixup = [this, &TRI](MachineInstr &MI) {
outliner::OutlinedFunction AArch64InstrInfo::getOutliningCandidateInfo(
   // True if it's possible to fix up each stack instruction in this sequence.
   // Important for frames/call variants that modify the stack.
   bool AllStackInstrsSafe = std::all_of(
       FirstCand.front(), std::next(FirstCand.back()), IsSafeToFixup);
 
   // If the last instruction in any candidate is a terminator, then we should
   // tail call all of the candidates.
   if (RepeatedSequenceLocs[0].back()->isTerminator()) {
-    FrameID = MachineOutlinerTailCall;
+    FrameID = outliner::MachineOutlinerTailCall;
     NumBytesToCreateFrame = 0;
-    SetCandidateCallInfo(MachineOutlinerTailCall, 4);
+    SetCandidateCallInfo(outliner::MachineOutlinerTailCall, 4);
   }
 
   else if (LastInstrOpcode == AArch64::BL ||
            (LastInstrOpcode == AArch64::BLR && !HasBTI)) {
     // FIXME: Do we need to check if the code after this uses the value of LR?
-    FrameID = MachineOutlinerThunk;
+    FrameID = outliner::MachineOutlinerThunk;
     NumBytesToCreateFrame = 0;
-    SetCandidateCallInfo(MachineOutlinerThunk, 4);
+    SetCandidateCallInfo(outliner::MachineOutlinerThunk, 4);
   }
 
   else {
     // We need to decide how to emit calls + frames. We can always emit the same
     // frame if we don't need to save to the stack. If we have to save to the
     // stack, then we need a different frame.
     unsigned NumBytesNoStackCalls = 0;
     std::vector<outliner::Candidate> CandidatesWithoutStackFixups;
for (outliner::Candidate &C : RepeatedSequenceLocs) {
       // FIXME: We can probably do better than always disabling this in
       // noreturn functions by fixing up the liveness info.
       bool IsNoReturn =
           C.getMF()->getFunction().hasFnAttribute(Attribute::NoReturn);
 
       // Is LR available? If so, we don't need a save.
       if (C.LRU.available(AArch64::LR) && !IsNoReturn) {
         NumBytesNoStackCalls += 4;
-        C.setCallInfo(MachineOutlinerNoLRSave, 4);
+        C.setCallInfo(outliner::MachineOutlinerNoLRSave, 4);
         CandidatesWithoutStackFixups.push_back(C);
       }
 
       // Is an unused register available? If so, we won't modify the stack, so
       // we can outline with the same frame type as those that don't save LR.
       else if (findRegisterToSaveLRTo(C)) {
         NumBytesNoStackCalls += 12;
-        C.setCallInfo(MachineOutlinerRegSave, 12);
+        C.setCallInfo(outliner::MachineOutlinerRegSave, 12);
         CandidatesWithoutStackFixups.push_back(C);
       }
 
       // Is SP used in the sequence at all? If not, we don't have to modify
       // the stack, so we are guaranteed to get the same frame.
       else if (C.UsedInSequence.available(AArch64::SP)) {
         NumBytesNoStackCalls += 12;
-        C.setCallInfo(MachineOutlinerDefault, 12);
+        C.setCallInfo(outliner::MachineOutlinerDefault, 12);
         CandidatesWithoutStackFixups.push_back(C);
       }
 
       // If we outline this, we need to modify the stack. Pretend we don't
       // outline this by saving all of its bytes.
       else {
         NumBytesNoStackCalls += SequenceSize;
       }
     }
 
     // If there are no places where we have to save LR, then note that we
     // don't have to update the stack. Otherwise, give every candidate the
     // default call type, as long as it's safe to do so.
     if (!AllStackInstrsSafe ||
         NumBytesNoStackCalls <= RepeatedSequenceLocs.size() * 12) {
       RepeatedSequenceLocs = CandidatesWithoutStackFixups;
-      FrameID = MachineOutlinerNoLRSave;
+      FrameID = outliner::MachineOutlinerNoLRSave;
     } else {
-      SetCandidateCallInfo(MachineOutlinerDefault, 12);
+      SetCandidateCallInfo(outliner::MachineOutlinerDefault, 12);
     }
 
     // If we dropped all of the candidates, bail out here.
     if (RepeatedSequenceLocs.size() < 2) {
       RepeatedSequenceLocs.clear();
       return outliner::OutlinedFunction();
     }
   }
 
   // Does every candidate's MBB contain a call? If so, then we might have a call
   // in the range.
   if (FlagsSetInAll & MachineOutlinerMBBFlags::HasCalls) {
     // Check if the range contains a call. These require a save + restore of the
     // link register.
     bool ModStackToSaveLR = false;
     if (std::any_of(FirstCand.front(), FirstCand.back(),
                     [](const MachineInstr &MI) { return MI.isCall(); }))
       ModStackToSaveLR = true;
 
     // Handle the last instruction separately. If this is a tail call, then the
     // last instruction is a call. We don't want to save + restore in this case.
     // However, it could be possible that the last instruction is a call without
     // it being valid to tail call this sequence. We should consider this as
     // well.
-    else if (FrameID != MachineOutlinerThunk &&
-             FrameID != MachineOutlinerTailCall && FirstCand.back()->isCall())
+    else if (FrameID != outliner::MachineOutlinerThunk &&
+             FrameID != outliner::MachineOutlinerTailCall &&
+             FirstCand.back()->isCall())
       ModStackToSaveLR = true;
 
     if (ModStackToSaveLR) {
       // We can't fix up the stack. Bail out.
       if (!AllStackInstrsSafe) {
         RepeatedSequenceLocs.clear();
         return outliner::OutlinedFunction();
       }
if (Subtarget.hasV8_3aOps() && MBBAUT != MBB.end() &&
           .setMIFlag(MachineInstr::FrameDestroy);
     }
   }
 }
 
 void AArch64InstrInfo::buildOutlinedFrame(
     MachineBasicBlock &MBB, MachineFunction &MF,
     const outliner::OutlinedFunction &OF) const {
   // For thunk outlining, rewrite the last instruction from a call to a
   // tail-call.
-  if (OF.FrameConstructionID == MachineOutlinerThunk) {
+  if (OF.FrameConstructionID == outliner::MachineOutlinerThunk) {
     MachineInstr *Call = &*--MBB.instr_end();
     unsigned TailOpcode;
     if (Call->getOpcode() == AArch64::BL) {
       TailOpcode = AArch64::TCRETURNdi;
     } else {
       assert(Call->getOpcode() == AArch64::BLR);
       TailOpcode = AArch64::TCRETURNriALL;
     }
     MachineInstr *TC = BuildMI(MF, DebugLoc(), get(TailOpcode))
                            .add(Call->getOperand(0))
                            .addImm(0);
     MBB.insert(MBB.end(), TC);
     Call->eraseFromParent();
   }
 
   bool IsLeafFunction = true;
 
   // Is there a call in the outlined range?
   auto IsNonTailCall = [](const MachineInstr &MI) {
     return MI.isCall() && !MI.isReturn();
   };
 
   if (std::any_of(MBB.instr_begin(), MBB.instr_end(), IsNonTailCall)) {
     // Fix up the instructions in the range, since we're going to modify the
     // stack.
-    assert(OF.FrameConstructionID != MachineOutlinerDefault &&
+    assert(OF.FrameConstructionID != outliner::MachineOutlinerDefault &&
            "Can only fix up stack references once");
     fixupPostOutline(MBB);
 
     IsLeafFunction = false;
 
     // LR has to be a live in so that we can save it.
     MBB.addLiveIn(AArch64::LR);
 
     MachineBasicBlock::iterator It = MBB.begin();
     MachineBasicBlock::iterator Et = MBB.end();
 
-    if (OF.FrameConstructionID == MachineOutlinerTailCall ||
-        OF.FrameConstructionID == MachineOutlinerThunk)
+    if (OF.FrameConstructionID == outliner::MachineOutlinerTailCall ||
+        OF.FrameConstructionID == outliner::MachineOutlinerThunk)
       Et = std::prev(MBB.end());
 
     // Insert a save before the outlined region
     MachineInstr *STRXpre = BuildMI(MF, DebugLoc(), get(AArch64::STRXpre))
                                 .addReg(AArch64::SP, RegState::Define)
                                 .addReg(AArch64::LR)
                                 .addReg(AArch64::SP)
                                 .addImm(-16);
const StringRef Key =
         CF.getFnAttribute("sign-return-address-key").getValueAsString();
     // Key can either be a_key or b_key
     assert((Key.equals_lower("a_key") || Key.equals_lower("b_key")) &&
            "Return address signing key must be either a_key or b_key");
     ShouldSignReturnAddrWithAKey = Key.equals_lower("a_key");
   }
 
   // If this is a tail call outlined function, then there's already a return.
-  if (OF.FrameConstructionID == MachineOutlinerTailCall ||
-      OF.FrameConstructionID == MachineOutlinerThunk) {
+  if (OF.FrameConstructionID == outliner::MachineOutlinerTailCall ||
+      OF.FrameConstructionID == outliner::MachineOutlinerThunk) {
     signOutlinedFunction(MF, MBB, ShouldSignReturnAddr,
                          ShouldSignReturnAddrWithAKey);
     return;
   }
 
   // It's not a tail call, so we have to insert the return ourselves.
   MachineInstr *ret = BuildMI(MF, DebugLoc(), get(AArch64::RET))
                           .addReg(AArch64::LR, RegState::Undef);
   MBB.insert(MBB.end(), ret);
 
   signOutlinedFunction(MF, MBB, ShouldSignReturnAddr,
                        ShouldSignReturnAddrWithAKey);
 
   // Did we have to modify the stack by saving the link register?
-  if (OF.FrameConstructionID != MachineOutlinerDefault)
+  if (OF.FrameConstructionID != outliner::MachineOutlinerDefault)
     return;
 
   // We modified the stack.
   // Walk over the basic block and fix up all the stack accesses.
   fixupPostOutline(MBB);
 }
 
 MachineBasicBlock::iterator AArch64InstrInfo::insertOutlinedCall(
     Module &M, MachineBasicBlock &MBB, MachineBasicBlock::iterator &It,
     MachineFunction &MF, const outliner::Candidate &C) const {
 
   // Are we tail calling?
-  if (C.CallConstructionID == MachineOutlinerTailCall) {
+  if (C.CallConstructionID == outliner::MachineOutlinerTailCall) {
     // If yes, then we can just branch to the label.
     It = MBB.insert(It, BuildMI(MF, DebugLoc(), get(AArch64::TCRETURNdi))
                             .addGlobalAddress(M.getNamedValue(MF.getName()))
                             .addImm(0));
     return It;
   }
 
   // Are we saving the link register?
-  if (C.CallConstructionID == MachineOutlinerNoLRSave ||
-      C.CallConstructionID == MachineOutlinerThunk) {
+  if (C.CallConstructionID == outliner::MachineOutlinerNoLRSave ||
+      C.CallConstructionID == outliner::MachineOutlinerThunk) {
     // No, so just insert the call.
     It = MBB.insert(It, BuildMI(MF, DebugLoc(), get(AArch64::BL))
                             .addGlobalAddress(M.getNamedValue(MF.getName())));
     return It;
   }
 
   // We want to return the spot where we inserted the call.
   MachineBasicBlock::iterator CallPt;
 
   // Instructions for saving and restoring LR around the call instruction we're
   // going to insert.
   MachineInstr *Save;
   MachineInstr *Restore;
   // Can we save to a register?
-  if (C.CallConstructionID == MachineOutlinerRegSave) {
+  if (C.CallConstructionID == outliner::MachineOutlinerRegSave) {
     // FIXME: This logic should be sunk into a target-specific interface so that
     // we don't have to recompute the register.
     unsigned Reg = findRegisterToSaveLRTo(C);
     assert(Reg != 0 && "No callee-saved register available?");
 
     // Save and restore LR from that register.
     Save = BuildMI(MF, DebugLoc(), get(AArch64::ORRXrs), Reg)
                .addReg(AArch64::XZR)

llvm/lib/Target/X86/X86InstrInfo.cpp

 /// I1                                 OUTLINED_FUNCTION:
 /// I2 --> jmp OUTLINED_FUNCTION       I1
 /// ret                                I2
 ///                                    ret
 ///
 /// * Call construction overhead: 1 (jump instruction)
 /// * Frame construction overhead: 0 (don't need to return)
 ///
-enum MachineOutlinerClass {
+/*enum MachineOutlinerClass {
   MachineOutlinerDefault,
   MachineOutlinerTailCall
-};
+};*/
 
 outliner::OutlinedFunction X86InstrInfo::getOutliningCandidateInfo(
     std::vector<outliner::Candidate> &RepeatedSequenceLocs) const {
   unsigned SequenceSize =
       std::accumulate(RepeatedSequenceLocs[0].front(),
                       std::next(RepeatedSequenceLocs[0].back()), 0,
                       [](unsigned Sum, const MachineInstr &MI) {
                         // FIXME: x86 doesn't implement getInstSizeInBytes, so
                         // we can't tell the cost.  Just assume each instruction
                         // is one byte.
                         if (MI.isDebugInstr() || MI.isKill())
                           return Sum;
                         return Sum + 1;
                       });
 
   // FIXME: Use real size in bytes for call and ret instructions.
   if (RepeatedSequenceLocs[0].back()->isTerminator()) {
     for (outliner::Candidate &C : RepeatedSequenceLocs)
-      C.setCallInfo(MachineOutlinerTailCall, 1);
+      C.setCallInfo(outliner::MachineOutlinerTailCall, 1);
 
-    return outliner::OutlinedFunction(RepeatedSequenceLocs, SequenceSize,
-                                      0, // Number of bytes to emit frame.
-                                      MachineOutlinerTailCall // Type of frame.
+    return outliner::OutlinedFunction(
+        RepeatedSequenceLocs, SequenceSize,
+        0,                                // Number of bytes to emit frame.
+        outliner::MachineOutlinerTailCall // Type of frame.
     );
   }
 
   for (outliner::Candidate &C : RepeatedSequenceLocs)
-    C.setCallInfo(MachineOutlinerDefault, 1);
+    C.setCallInfo(outliner::MachineOutlinerDefault, 1);
 
   return outliner::OutlinedFunction(RepeatedSequenceLocs, SequenceSize, 1,
-                                    MachineOutlinerDefault);
+                                    outliner::MachineOutlinerDefault);
 }
 
 bool X86InstrInfo::isFunctionSafeToOutlineFrom(MachineFunction &MF,
                                            bool OutlineFromLinkOnceODRs) const {
   const Function &F = MF.getFunction();
 
   // Does the function use a red zone? If it does, then we can't risk messing
   // with the stack.
X86InstrInfo::getOutliningType(MachineBasicBlock::iterator &MIT,  unsigned Flags) const {
   return outliner::InstrType::Legal;
 }
 
 void X86InstrInfo::buildOutlinedFrame(MachineBasicBlock &MBB,
                                           MachineFunction &MF,
                                           const outliner::OutlinedFunction &OF)
                                           const {
   // If we're a tail call, we already have a return, so don't do anything.
-  if (OF.FrameConstructionID == MachineOutlinerTailCall)
+  if (OF.FrameConstructionID == outliner::MachineOutlinerTailCall)
     return;
 
   // We're a normal call, so our sequence doesn't have a return instruction.
   // Add it in.
   MachineInstr *retq = BuildMI(MF, DebugLoc(), get(X86::RETQ));
   MBB.insert(MBB.end(), retq);
 }
 
 MachineBasicBlock::iterator
 X86InstrInfo::insertOutlinedCall(Module &M, MachineBasicBlock &MBB,
                                  MachineBasicBlock::iterator &It,
                                  MachineFunction &MF,
                                  const outliner::Candidate &C) const {
   // Is it a tail call?
-  if (C.CallConstructionID == MachineOutlinerTailCall) {
+  if (C.CallConstructionID == outliner::MachineOutlinerTailCall) {
     // Yes, just insert a JMP.
     It = MBB.insert(It,
                   BuildMI(MF, DebugLoc(), get(X86::TAILJMPd64))
                       .addGlobalAddress(M.getNamedValue(MF.getName())));
   } else {
     // No, insert a call.
     It = MBB.insert(It,
                   BuildMI(MF, DebugLoc(), get(X86::CALL64pcrel32))
                       .addGlobalAddress(M.getNamedValue(MF.getName())));
   }
 
   return It;
 }
 
 #define GET_INSTRINFO_HELPERS
 #include "X86GenInstrInfo.inc"