[PEI] Add basic opt-remarks support

[thegameg]

Summary

Add optimization remarks support to PrologueEpilogueInserter. For now, emit the stack size as an analysis remark, but more additions wrt shrink-wrapping may be added.

[anemet]

Looks good, how hard would be to add a test for this?

[thegameg]

Added MIR tests for both AArch64 and X86.

[anemet]

I am not really familiar with MIR test files but this looks straight-forward. LGTM.

[fhahn]

Would it be possible to inlcude the full context the remarks, using YAML, e.g. as in D35122?

[thegameg]

Included the full YAML in the test cases.

[thegameg]

Committed in r308556: [PEI] Add basic opt-remarks support.

lib/CodeGen/PrologEpilogInserter.cpp

 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/CodeGen/MachineDominators.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineLoopInfo.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/RegisterScavenging.h"
 #include "llvm/CodeGen/StackProtector.h"
 #include "llvm/CodeGen/WinEHFuncInfo.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/LLVMContext.h"
private:
   // frame index materialization registers. Set according to
   // TRI->requiresFrameIndexScavenging() for the current function.
   bool FrameIndexVirtualScavenging;
 
   // Flag to control whether the scavenger should be passed even though
   // FrameIndexVirtualScavenging is used.
   bool FrameIndexEliminationScavenging;
 
+  // Emit remarks.
+  MachineOptimizationRemarkEmitter *ORE = nullptr;
+
   void calculateCallFrameInfo(MachineFunction &Fn);
   void calculateSaveRestoreBlocks(MachineFunction &Fn);
   void doSpillCalleeSavedRegs(MachineFunction &MF);
   void calculateFrameObjectOffsets(MachineFunction &Fn);
   void replaceFrameIndices(MachineFunction &Fn);
   void replaceFrameIndices(MachineBasicBlock *BB, MachineFunction &Fn,
                            int &SPAdj);
   void insertPrologEpilogCode(MachineFunction &Fn);
 };
 } // namespace
 
 char PEI::ID = 0;
 char &llvm::PrologEpilogCodeInserterID = PEI::ID;
 
 static cl::opt<unsigned>
 WarnStackSize("warn-stack-size", cl::Hidden, cl::init((unsigned)-1),
               cl::desc("Warn for stack size bigger than the given"
                        " number"));
 
 INITIALIZE_PASS_BEGIN(PEI, DEBUG_TYPE, "Prologue/Epilogue Insertion", false,
                       false)
 INITIALIZE_PASS_DEPENDENCY(MachineLoopInfo)
 INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree)
 INITIALIZE_PASS_DEPENDENCY(StackProtector)
+INITIALIZE_PASS_DEPENDENCY(MachineOptimizationRemarkEmitterPass)
 INITIALIZE_PASS_END(PEI, DEBUG_TYPE,
                     "Prologue/Epilogue Insertion & Frame Finalization", false,
                     false)
 
 MachineFunctionPass *llvm::createPrologEpilogInserterPass() {
   return new PEI();
 }
 
 STATISTIC(NumBytesStackSpace,
           "Number of bytes used for stack in all functions");
 
 void PEI::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesCFG();
   AU.addPreserved<MachineLoopInfo>();
   AU.addPreserved<MachineDominatorTree>();
   AU.addRequired<StackProtector>();
+  AU.addRequired<MachineOptimizationRemarkEmitterPass>();
   MachineFunctionPass::getAnalysisUsage(AU);
 }
 
 
 /// StackObjSet - A set of stack object indexes
 typedef SmallSetVector<int, 8> StackObjSet;
 
 /// runOnMachineFunction - Insert prolog/epilog code and replace abstract
bool PEI::runOnMachineFunction(MachineFunction &Fn) {
   const Function* F = Fn.getFunction();
   const TargetRegisterInfo *TRI = Fn.getSubtarget().getRegisterInfo();
   const TargetFrameLowering *TFI = Fn.getSubtarget().getFrameLowering();
 
   RS = TRI->requiresRegisterScavenging(Fn) ? new RegScavenger() : nullptr;
   FrameIndexVirtualScavenging = TRI->requiresFrameIndexScavenging(Fn);
   FrameIndexEliminationScavenging = (RS && !FrameIndexVirtualScavenging) ||
     TRI->requiresFrameIndexReplacementScavenging(Fn);
+  ORE = &getAnalysis<MachineOptimizationRemarkEmitterPass>().getORE();
 
   // Calculate the MaxCallFrameSize and AdjustsStack variables for the
   // function's frame information. Also eliminates call frame pseudo
   // instructions.
   calculateCallFrameInfo(Fn);
 
   // Determine placement of CSR spill/restore code and prolog/epilog code:
   // place all spills in the entry block, all restores in return blocks.
if (!TFI.targetHandlesStackFrameRounding()) {
     StackAlign = std::max(StackAlign, MaxAlign);
     Offset = alignTo(Offset, StackAlign, Skew);
   }
 
   // Update frame info to pretend that this is part of the stack...
   int64_t StackSize = Offset - LocalAreaOffset;
   MFI.setStackSize(StackSize);
   NumBytesStackSpace += StackSize;
+
+  MachineOptimizationRemarkAnalysis R(
+      DEBUG_TYPE, "StackSize", Fn.getFunction()->getSubprogram(), &Fn.front());
+  R << ore::NV("NumStackBytes", static_cast<unsigned>(StackSize))
+    << " stack bytes in function";
+  ORE->emit(R);
 }
 
 /// insertPrologEpilogCode - Scan the function for modified callee saved
 /// registers, insert spill code for these callee saved registers, then add
 /// prolog and epilog code to the function.
 ///
 void PEI::insertPrologEpilogCode(MachineFunction &Fn) {
   const TargetFrameLowering &TFI = *Fn.getSubtarget().getFrameLowering();

test/CodeGen/AArch64/prologue-epilogue-remarks.mir

+# RUN: llc -mtriple=aarch64-unknown-unknown  -run-pass=prologepilog -pass-remarks-analysis=prologepilog -o /dev/null %s 2>&1 | FileCheck %s
+...
+---
+name:            fun0
+stack:
+  - { id: 0, type: default, offset: 0, size: 8, alignment: 4 }
+# CHECK: 16 stack bytes in function
+constants:
+body:             |
+  bb.0:
+    RET_ReallyLR
+
+...
+---
+name:            fun1
+stack:
+  - { id: 0, type: default, offset: 0, size: 19, alignment: 4 }
+# CHECK: 32 stack bytes in function
+constants:
+body:             |
+  bb.0:
+    RET_ReallyLR
+
+...
+---
+name:            fun2
+stack:
+  - { id: 0, type: default, offset: 0, size: 1024, alignment: 4 }
+# CHECK: 1040 stack bytes in function
+constants:
+body:             |
+  bb.0:
+    RET_ReallyLR
+
+...

test/CodeGen/X86/O0-pipeline.ll

 ; CHECK-NEXT:       Expand ISel Pseudo-instructions
 ; CHECK-NEXT:       Local Stack Slot Allocation
 ; CHECK-NEXT:       X86 WinAlloca Expander
 ; CHECK-NEXT:       Eliminate PHI nodes for register allocation
 ; CHECK-NEXT:       Two-Address instruction pass
 ; CHECK-NEXT:       Fast Register Allocator
 ; CHECK-NEXT:       Bundle Machine CFG Edges
 ; CHECK-NEXT:       X86 FP Stackifier
+; CHECK-NEXT:       Lazy Machine Block Frequency Analysis
+; CHECK-NEXT:       Machine Optimization Remark Emitter
 ; CHECK-NEXT:       Prologue/Epilogue Insertion & Frame Finalization
 ; CHECK-NEXT:       Post-RA pseudo instruction expansion pass
 ; CHECK-NEXT:       X86 pseudo instruction expansion pass
 ; CHECK-NEXT:       Analyze Machine Code For Garbage Collection
 ; CHECK-NEXT:       X86 vzeroupper inserter
 ; CHECK-NEXT:       Contiguously Lay Out Funclets
 ; CHECK-NEXT:       StackMap Liveness Analysis
 ; CHECK-NEXT:       Live DEBUG_VALUE analysis

test/CodeGen/X86/prologue-epilogue-remarks.mir

+# RUN: llc -mtriple=x86_64-unknown-unknown  -run-pass=prologepilog -pass-remarks-analysis=prologepilog -o /dev/null %s 2>&1 | FileCheck %s
+...
+---
+name:            fun0
+stack:
+  - { id: 0, type: default, offset: 0, size: 8, alignment: 4 }
+# CHECK: 8 stack bytes in function
+constants:
+body:             |
+  bb.0:
+    RETQ
+
+...
+---
+name:            fun1
+stack:
+  - { id: 0, type: default, offset: 0, size: 19, alignment: 4 }
+# CHECK: 20 stack bytes in function
+constants:
+body:             |
+  bb.0:
+    RETQ
+
+...
+---
+name:            fun2
+stack:
+  - { id: 0, type: default, offset: 0, size: 1024, alignment: 8 }
+# CHECK: 1024 stack bytes in function
+constants:
+body:             |
+  bb.0:
+    RETQ
+
+...