[ShrinkWrap] Add (a simplified version) of shrink-wrapping.

author Quentin Colombet <qcolombet@apple.com>

Tue, 5 May 2015 17:38:16 +0000 (17:38 +0000)

committer Quentin Colombet <qcolombet@apple.com>

Tue, 5 May 2015 17:38:16 +0000 (17:38 +0000)
author Quentin Colombet <qcolombet@apple.com>
Tue, 5 May 2015 17:38:16 +0000 (17:38 +0000)
committer Quentin Colombet <qcolombet@apple.com>
Tue, 5 May 2015 17:38:16 +0000 (17:38 +0000)
diff --git a/include/llvm/CodeGen/MachineFrameInfo.h b/include/llvm/CodeGen/MachineFrameInfo.h

index 1e7fee666fc9eaa65cf5980db8175fdadf1de748..d4eaaf8ea66f0047c63f92b5ed4dcd553493f589 100644 (file)
--- a/include/llvm/CodeGen/MachineFrameInfo.h
+++ b/include/llvm/CodeGen/MachineFrameInfo.h
@@ -246,6 +246,16 @@ class MachineFrameInfo {
    /// True if this is a varargs function that contains a musttail call.
    bool HasMustTailInVarArgFunc;
  
    /// True if this is a varargs function that contains a musttail call.
    bool HasMustTailInVarArgFunc;
  
+  /// Not null, if shrink-wrapping found a better place for the prologue.
+  MachineBasicBlock *Save;
+  /// Not null, if shrink-wrapping found a better place for the epilogue.
+  MachineBasicBlock *Restore;
+
+  /// Check if it exists a path from \p MBB leading to the basic
+  /// block with a SavePoint (a.k.a. prologue).
+  bool isBeforeSavePoint(const MachineFunction &MF,
+                         const MachineBasicBlock &MBB) const;
+
  public:
    explicit MachineFrameInfo(unsigned StackAlign, bool isStackRealign,
                              bool RealignOpt)
  public:
    explicit MachineFrameInfo(unsigned StackAlign, bool isStackRealign,
                              bool RealignOpt)
@@ -269,6 +279,8 @@ public:
      HasInlineAsmWithSPAdjust = false;
      HasVAStart = false;
      HasMustTailInVarArgFunc = false;
      HasInlineAsmWithSPAdjust = false;
      HasVAStart = false;
      HasMustTailInVarArgFunc = false;
+    Save = nullptr;
+    Restore = nullptr;
    }
  
    /// hasStackObjects - Return true if there are any stack objects in this
    }
  
    /// hasStackObjects - Return true if there are any stack objects in this
@@ -597,6 +609,11 @@ public:
  
    void setCalleeSavedInfoValid(bool v) { CSIValid = v; }
  
  
    void setCalleeSavedInfoValid(bool v) { CSIValid = v; }
  
+  MachineBasicBlock *getSavePoint() const { return Save; }
+  void setSavePoint(MachineBasicBlock *NewSave) { Save = NewSave; }
+  MachineBasicBlock *getRestorePoint() const { return Restore; }
+  void setRestorePoint(MachineBasicBlock *NewRestore) { Restore = NewRestore; }
+
    /// getPristineRegs - Return a set of physical registers that are pristine on
    /// entry to the MBB.
    ///
    /// getPristineRegs - Return a set of physical registers that are pristine on
    /// entry to the MBB.
    ///
diff --git a/include/llvm/CodeGen/Passes.h b/include/llvm/CodeGen/Passes.h

index 2505c04a720a88f6d5fcabecda8e039ad9baaa87..39f69549d7cf30cfa99e51fb95b4c66a213794de 100644 (file)
--- a/include/llvm/CodeGen/Passes.h
+++ b/include/llvm/CodeGen/Passes.h
@@ -120,6 +120,9 @@ protected:
    /// Default setting for -enable-tail-merge on this target.
    bool EnableTailMerge;
  
    /// Default setting for -enable-tail-merge on this target.
    bool EnableTailMerge;
  
+  /// Default setting for -enable-shrink-wrap on this target.
+  bool EnableShrinkWrap;
+
  public:
    TargetPassConfig(TargetMachine *tm, PassManagerBase &pm);
    // Dummy constructor.
  public:
    TargetPassConfig(TargetMachine *tm, PassManagerBase &pm);
    // Dummy constructor.
@@ -179,6 +182,9 @@ public:
    /// Return true if the optimized regalloc pipeline is enabled.
    bool getOptimizeRegAlloc() const;
  
    /// Return true if the optimized regalloc pipeline is enabled.
    bool getOptimizeRegAlloc() const;
  
+  /// Return true if shrink wrapping is enabled.
+  bool getEnableShrinkWrap() const;
+
    /// Return true if the default global register allocator is in use and
    /// has not be overriden on the command line with '-regalloc=...'
    bool usingDefaultRegAlloc() const;
    /// Return true if the default global register allocator is in use and
    /// has not be overriden on the command line with '-regalloc=...'
    bool usingDefaultRegAlloc() const;
@@ -426,6 +432,10 @@ namespace llvm {
    /// basic blocks.
    extern char &SpillPlacementID;
  
    /// basic blocks.
    extern char &SpillPlacementID;
  
+  /// ShrinkWrap pass. Look for the best place to insert save and restore
+  // instruction and update the MachineFunctionInfo with that information.
+  extern char &ShrinkWrapID;
+
    /// VirtRegRewriter pass. Rewrite virtual registers to physical registers as
    /// assigned in VirtRegMap.
    extern char &VirtRegRewriterID;
    /// VirtRegRewriter pass. Rewrite virtual registers to physical registers as
    /// assigned in VirtRegMap.
    extern char &VirtRegRewriterID;
diff --git a/include/llvm/InitializePasses.h b/include/llvm/InitializePasses.h

index 490d814a2ad994ec5bfd6fc6ccaf5118cfe49974..2617a33e720022b58bf730aa7cce7249a67752a2 100644 (file)
--- a/include/llvm/InitializePasses.h
+++ b/include/llvm/InitializePasses.h
@@ -247,6 +247,7 @@ void initializeSROA_DTPass(PassRegistry&);
  void initializeSROA_SSAUpPass(PassRegistry&);
  void initializeScalarEvolutionAliasAnalysisPass(PassRegistry&);
  void initializeScalarEvolutionPass(PassRegistry&);
  void initializeSROA_SSAUpPass(PassRegistry&);
  void initializeScalarEvolutionAliasAnalysisPass(PassRegistry&);
  void initializeScalarEvolutionPass(PassRegistry&);
+void initializeShrinkWrapPass(PassRegistry &);
  void initializeSimpleInlinerPass(PassRegistry&);
  void initializeShadowStackGCLoweringPass(PassRegistry&);  
  void initializeRegisterCoalescerPass(PassRegistry&);
  void initializeSimpleInlinerPass(PassRegistry&);
  void initializeShadowStackGCLoweringPass(PassRegistry&);  
  void initializeRegisterCoalescerPass(PassRegistry&);
diff --git a/include/llvm/Target/TargetFrameLowering.h b/include/llvm/Target/TargetFrameLowering.h

index f17640f71e933d51c332d9c5f2039e95f776e2e9..1250020db235e90c6169c8a0d8ae525e960c8b64 100644 (file)
--- a/include/llvm/Target/TargetFrameLowering.h
+++ b/include/llvm/Target/TargetFrameLowering.h
@@ -130,21 +130,26 @@ public:
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
-  virtual void emitPrologue(MachineFunction &MF) const = 0;
+  virtual void emitPrologue(MachineFunction &MF,
+                            MachineBasicBlock &MBB) const = 0;
    virtual void emitEpilogue(MachineFunction &MF,
                              MachineBasicBlock &MBB) const = 0;
  
    /// Adjust the prologue to have the function use segmented stacks. This works
    /// by adding a check even before the "normal" function prologue.
    virtual void emitEpilogue(MachineFunction &MF,
                              MachineBasicBlock &MBB) const = 0;
  
    /// Adjust the prologue to have the function use segmented stacks. This works
    /// by adding a check even before the "normal" function prologue.
-  virtual void adjustForSegmentedStacks(MachineFunction &MF) const { }
+  virtual void adjustForSegmentedStacks(MachineFunction &MF,
+                                        MachineBasicBlock &PrologueMBB) const {}
  
    /// Adjust the prologue to add Erlang Run-Time System (ERTS) specific code in
    /// the assembly prologue to explicitly handle the stack.
  
    /// Adjust the prologue to add Erlang Run-Time System (ERTS) specific code in
    /// the assembly prologue to explicitly handle the stack.
-  virtual void adjustForHiPEPrologue(MachineFunction &MF) const { }
+  virtual void adjustForHiPEPrologue(MachineFunction &MF,
+                                     MachineBasicBlock &PrologueMBB) const {}
  
    /// Adjust the prologue to add an allocation at a fixed offset from the frame
    /// pointer.
  
    /// Adjust the prologue to add an allocation at a fixed offset from the frame
    /// pointer.
-  virtual void adjustForFrameAllocatePrologue(MachineFunction &MF) const { }
+  virtual void
+  adjustForFrameAllocatePrologue(MachineFunction &MF,
+                                 MachineBasicBlock &PrologueMBB) const {}
  
    /// spillCalleeSavedRegisters - Issues instruction(s) to spill all callee
    /// saved registers and returns true if it isn't possible / profitable to do
  
    /// spillCalleeSavedRegisters - Issues instruction(s) to spill all callee
    /// saved registers and returns true if it isn't possible / profitable to do
diff --git a/lib/CodeGen/CMakeLists.txt b/lib/CodeGen/CMakeLists.txt

index ef5763855a85fc97765d5a3fcee1b863e08ac8d7..6ce5b13ea3938344ff83544bf52dd543d624e031 100644 (file)
--- a/lib/CodeGen/CMakeLists.txt
+++ b/lib/CodeGen/CMakeLists.txt
@@ -93,6 +93,7 @@ add_llvm_library(LLVMCodeGen
    ScheduleDAGInstrs.cpp
    ScheduleDAGPrinter.cpp
    ScoreboardHazardRecognizer.cpp
    ScheduleDAGInstrs.cpp
    ScheduleDAGPrinter.cpp
    ScoreboardHazardRecognizer.cpp
+  ShrinkWrap.cpp
    ShadowStackGC.cpp
    ShadowStackGCLowering.cpp
    SjLjEHPrepare.cpp
    ShadowStackGC.cpp
    ShadowStackGCLowering.cpp
    SjLjEHPrepare.cpp
diff --git a/lib/CodeGen/CodeGen.cpp b/lib/CodeGen/CodeGen.cpp

index da66639d02fe7dd81673170c2ac730727062dc5d..2c6eaf35a257b0b0ede3a1ecfc2e334fef6914d7 100644 (file)
--- a/lib/CodeGen/CodeGen.cpp
+++ b/lib/CodeGen/CodeGen.cpp
@@ -61,6 +61,7 @@ void llvm::initializeCodeGen(PassRegistry &Registry) {
    initializePostRASchedulerPass(Registry);
    initializeProcessImplicitDefsPass(Registry);
    initializeRegisterCoalescerPass(Registry);
    initializePostRASchedulerPass(Registry);
    initializeProcessImplicitDefsPass(Registry);
    initializeRegisterCoalescerPass(Registry);
+  initializeShrinkWrapPass(Registry);
    initializeSlotIndexesPass(Registry);
    initializeStackColoringPass(Registry);
    initializeStackMapLivenessPass(Registry);
    initializeSlotIndexesPass(Registry);
    initializeStackColoringPass(Registry);
    initializeStackMapLivenessPass(Registry);
diff --git a/lib/CodeGen/MachineFunction.cpp b/lib/CodeGen/MachineFunction.cpp

index 448531fb716366bf541e3b91262c9a8f87ceba52..fb0553b9414653549cbc3c3b459902872eaf767b 100644 (file)
--- a/lib/CodeGen/MachineFunction.cpp
+++ b/lib/CodeGen/MachineFunction.cpp
@@ -600,8 +600,8 @@ MachineFrameInfo::getPristineRegs(const MachineBasicBlock *MBB) const {
    for (const MCPhysReg *CSR = TRI->getCalleeSavedRegs(MF); CSR && *CSR; ++CSR)
      BV.set(*CSR);
  
    for (const MCPhysReg *CSR = TRI->getCalleeSavedRegs(MF); CSR && *CSR; ++CSR)
      BV.set(*CSR);
  
-  // The entry MBB always has all CSRs pristine.
-  if (MBB == &MF->front())
+  // Each MBB before the save point has all CSRs pristine.
+  if (isBeforeSavePoint(*MF, *MBB))
      return BV;
  
    // On other MBBs the saved CSRs are not pristine.
      return BV;
  
    // On other MBBs the saved CSRs are not pristine.
@@ -613,6 +613,40 @@ MachineFrameInfo::getPristineRegs(const MachineBasicBlock *MBB) const {
    return BV;
  }
  
    return BV;
  }
  
+// Note: We could use some sort of caching mecanism, but we lack the ability
+// to know when the cache is invalid, i.e., the CFG changed.
+// Assuming we have that, we can simply compute all the set of MBBs
+// that are before the save point.
+bool MachineFrameInfo::isBeforeSavePoint(const MachineFunction &MF,
+                                         const MachineBasicBlock &MBB) const {
+  // Early exit if shrink-wrapping did not kick.
+  if (!Save)
+    return &MBB == &MF.front();
+
+  // Starting from MBB, check if there is a path leading to Save that do
+  // not cross Restore.
+  SmallPtrSet<const MachineBasicBlock *, 8> Visited;
+  SmallVector<const MachineBasicBlock *, 8> WorkList;
+  WorkList.push_back(&MBB);
+  Visited.insert(&MBB);
+  do {
+    const MachineBasicBlock *CurBB = WorkList.pop_back_val();
+    // By construction, the region that is after the save point is
+    // dominated by the Save and post-dominated by the Restore.
+    // If we do not reach Restore and still reach Save, this
+    // means MBB is before Save.
+    if (CurBB == Save)
+      return true;
+    if (CurBB == Restore)
+      continue;
+    // Enqueue all the successors not already visited.
+    for (MachineBasicBlock *SuccBB : CurBB->successors())
+      if (Visited.insert(SuccBB).second)
+        WorkList.push_back(SuccBB);
+  } while (!WorkList.empty());
+  return false;
+}
+
  unsigned MachineFrameInfo::estimateStackSize(const MachineFunction &MF) const {
    const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
    const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
  unsigned MachineFrameInfo::estimateStackSize(const MachineFunction &MF) const {
    const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
    const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
diff --git a/lib/CodeGen/Passes.cpp b/lib/CodeGen/Passes.cpp

index c128414c0b38687196228cffbdf7c36e1163cad1..690224342f6447e833e0d14f448b794ab1fbcfc9 100644 (file)
--- a/lib/CodeGen/Passes.cpp
+++ b/lib/CodeGen/Passes.cpp
@@ -52,7 +52,10 @@ static cl::opt<bool> DisableMachineLICM("disable-machine-licm", cl::Hidden,
  static cl::opt<bool> DisableMachineCSE("disable-machine-cse", cl::Hidden,
      cl::desc("Disable Machine Common Subexpression Elimination"));
  static cl::opt<cl::boolOrDefault>
  static cl::opt<bool> DisableMachineCSE("disable-machine-cse", cl::Hidden,
      cl::desc("Disable Machine Common Subexpression Elimination"));
  static cl::opt<cl::boolOrDefault>
-OptimizeRegAlloc("optimize-regalloc", cl::Hidden,
+    EnableShrinkWrapOpt("enable-shrink-wrap", cl::Hidden,
+                        cl::desc("enable the shrink-wrapping pass"));
+static cl::opt<cl::boolOrDefault> OptimizeRegAlloc(
+    "optimize-regalloc", cl::Hidden,
      cl::desc("Enable optimized register allocation compilation path."));
  static cl::opt<bool> DisablePostRAMachineLICM("disable-postra-machine-licm",
      cl::Hidden,
      cl::desc("Enable optimized register allocation compilation path."));
  static cl::opt<bool> DisablePostRAMachineLICM("disable-postra-machine-licm",
      cl::Hidden,
@@ -206,10 +209,10 @@ TargetPassConfig::~TargetPassConfig() {
  // Out of line constructor provides default values for pass options and
  // registers all common codegen passes.
  TargetPassConfig::TargetPassConfig(TargetMachine *tm, PassManagerBase &pm)
  // Out of line constructor provides default values for pass options and
  // registers all common codegen passes.
  TargetPassConfig::TargetPassConfig(TargetMachine *tm, PassManagerBase &pm)
-  : ImmutablePass(ID), PM(&pm), StartAfter(nullptr), StopAfter(nullptr),
-    Started(true), Stopped(false), AddingMachinePasses(false), TM(tm),
-    Impl(nullptr), Initialized(false), DisableVerify(false),
-    EnableTailMerge(true) {
+    : ImmutablePass(ID), PM(&pm), StartAfter(nullptr), StopAfter(nullptr),
+      Started(true), Stopped(false), AddingMachinePasses(false), TM(tm),
+      Impl(nullptr), Initialized(false), DisableVerify(false),
+      EnableTailMerge(true), EnableShrinkWrap(false) {
  
    Impl = new PassConfigImpl();
  
  
    Impl = new PassConfigImpl();
  
@@ -524,6 +527,8 @@ void TargetPassConfig::addMachinePasses() {
    addPostRegAlloc();
  
    // Insert prolog/epilog code.  Eliminate abstract frame index references...
    addPostRegAlloc();
  
    // Insert prolog/epilog code.  Eliminate abstract frame index references...
+  if (getEnableShrinkWrap())
+    addPass(&ShrinkWrapID);
    addPass(&PrologEpilogCodeInserterID);
  
    /// Add passes that optimize machine instructions after register allocation.
    addPass(&PrologEpilogCodeInserterID);
  
    /// Add passes that optimize machine instructions after register allocation.
@@ -599,6 +604,21 @@ void TargetPassConfig::addMachineSSAOptimization() {
    addPass(&DeadMachineInstructionElimID);
  }
  
    addPass(&DeadMachineInstructionElimID);
  }
  
+bool TargetPassConfig::getEnableShrinkWrap() const {
+  switch (EnableShrinkWrapOpt) {
+  case cl::BOU_UNSET:
+    return EnableShrinkWrap && getOptLevel() != CodeGenOpt::None;
+  // If EnableShrinkWrap is set, it takes precedence on whatever the
+  // target sets. The rational is that we assume we want to test
+  // something related to shrink-wrapping.
+  case cl::BOU_TRUE:
+    return true;
+  case cl::BOU_FALSE:
+    return false;
+  }
+  llvm_unreachable("Invalid shrink-wrapping state");
+}
+
  //===---------------------------------------------------------------------===//
  /// Register Allocation Pass Configuration
  //===---------------------------------------------------------------------===//
  //===---------------------------------------------------------------------===//
  /// Register Allocation Pass Configuration
  //===---------------------------------------------------------------------===//
diff --git a/lib/CodeGen/PrologEpilogInserter.cpp b/lib/CodeGen/PrologEpilogInserter.cpp

index 5334a633ead77c922a9d5ccfb88d8f9bfc7e1b38..e4f359c213c4c201b9264d1ced402d028e70edd7 100644 (file)
--- a/lib/CodeGen/PrologEpilogInserter.cpp
+++ b/lib/CodeGen/PrologEpilogInserter.cpp
@@ -71,9 +71,9 @@ private:
    // stack frame indexes.
    unsigned MinCSFrameIndex, MaxCSFrameIndex;
  
    // stack frame indexes.
    unsigned MinCSFrameIndex, MaxCSFrameIndex;
  
-  // Entry and return blocks of the current function.
-  MachineBasicBlock *EntryBlock;
-  SmallVector<MachineBasicBlock *, 4> ReturnBlocks;
+  // Save and Restore blocks of the current function.
+  MachineBasicBlock *SaveBlock;
+  SmallVector<MachineBasicBlock *, 4> RestoreBlocks;
  
    // Flag to control whether to use the register scavenger to resolve
    // frame index materialization registers. Set according to
  
    // Flag to control whether to use the register scavenger to resolve
    // frame index materialization registers. Set according to
@@ -133,20 +133,26 @@ bool PEI::isReturnBlock(MachineBasicBlock* MBB) {
  
  /// Compute the set of return blocks
  void PEI::calculateSets(MachineFunction &Fn) {
  
  /// Compute the set of return blocks
  void PEI::calculateSets(MachineFunction &Fn) {
-  // Sets used to compute spill, restore placement sets.
-  const std::vector<CalleeSavedInfo> &CSI =
-    Fn.getFrameInfo()->getCalleeSavedInfo();
+  const MachineFrameInfo *MFI = Fn.getFrameInfo();
  
  
-  // If no CSRs used, we are done.
-  if (CSI.empty())
+  // Even when we do not change any CSR, we still want to insert the
+  // prologue and epilogue of the function.
+  // So set the save points for those.
+
+  // Use the points found by shrink-wrapping, if any.
+  if (MFI->getSavePoint()) {
+    SaveBlock = MFI->getSavePoint();
+    assert(MFI->getRestorePoint() && "Both restore and save must be set");
+    RestoreBlocks.push_back(MFI->getRestorePoint());
      return;
      return;
+  }
  
    // Save refs to entry and return blocks.
  
    // Save refs to entry and return blocks.
-  EntryBlock = Fn.begin();
+  SaveBlock = Fn.begin();
    for (MachineFunction::iterator MBB = Fn.begin(), E = Fn.end();
         MBB != E; ++MBB)
      if (isReturnBlock(MBB))
    for (MachineFunction::iterator MBB = Fn.begin(), E = Fn.end();
         MBB != E; ++MBB)
      if (isReturnBlock(MBB))
-      ReturnBlocks.push_back(MBB);
+      RestoreBlocks.push_back(MBB);
  
    return;
  }
  
    return;
  }
@@ -226,7 +232,7 @@ bool PEI::runOnMachineFunction(MachineFunction &Fn) {
    }
  
    delete RS;
    }
  
    delete RS;
-  ReturnBlocks.clear();
+  RestoreBlocks.clear();
    return true;
  }
  
    return true;
  }
  
@@ -372,6 +378,61 @@ void PEI::calculateCalleeSavedRegisters(MachineFunction &F) {
    MFI->setCalleeSavedInfo(CSI);
  }
  
    MFI->setCalleeSavedInfo(CSI);
  }
  
+/// Helper function to update the liveness information for the callee-saved
+/// registers.
+static void updateLiveness(MachineFunction &MF) {
+  MachineFrameInfo *MFI = MF.getFrameInfo();
+  // Visited will contain all the basic blocks that are in the region
+  // where the callee saved registers are alive:
+  // - Anything that is not Save or Restore -> LiveThrough.
+  // - Save -> LiveIn.
+  // - Restore -> LiveOut.
+  // The live-out is not attached to the block, so no need to keep
+  // Restore in this set.
+  SmallPtrSet<MachineBasicBlock *, 8> Visited;
+  SmallVector<MachineBasicBlock *, 8> WorkList;
+  MachineBasicBlock *Entry = &MF.front();
+  MachineBasicBlock *Save = MFI->getSavePoint();
+
+  if (!Save)
+    Save = Entry;
+
+  if (Entry != Save) {
+    WorkList.push_back(Entry);
+    Visited.insert(Entry);
+  }
+  Visited.insert(Save);
+
+  MachineBasicBlock *Restore = MFI->getRestorePoint();
+  if (Restore)
+    // By construction Restore cannot be visited, otherwise it
+    // means there exists a path to Restore that does not go
+    // through Save.
+    WorkList.push_back(Restore);
+
+  while (!WorkList.empty()) {
+    const MachineBasicBlock *CurBB = WorkList.pop_back_val();
+    // By construction, the region that is after the save point is
+    // dominated by the Save and post-dominated by the Restore.
+    if (CurBB == Save)
+      continue;
+    // Enqueue all the successors not already visited.
+    // Those are by construction either before Save or after Restore.
+    for (MachineBasicBlock *SuccBB : CurBB->successors())
+      if (Visited.insert(SuccBB).second)
+        WorkList.push_back(SuccBB);
+  }
+
+  const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo();
+
+  for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
+    for (MachineBasicBlock *MBB : Visited)
+      // Add the callee-saved register as live-in.
+      // It's killed at the spill.
+      MBB->addLiveIn(CSI[i].getReg());
+  }
+}
+
  /// insertCSRSpillsAndRestores - Insert spill and restore code for
  /// callee saved registers used in the function.
  ///
  /// insertCSRSpillsAndRestores - Insert spill and restore code for
  /// callee saved registers used in the function.
  ///
@@ -392,26 +453,22 @@ void PEI::insertCSRSpillsAndRestores(MachineFunction &Fn) {
    MachineBasicBlock::iterator I;
  
    // Spill using target interface.
    MachineBasicBlock::iterator I;
  
    // Spill using target interface.
-  I = EntryBlock->begin();
-  if (!TFI->spillCalleeSavedRegisters(*EntryBlock, I, CSI, TRI)) {
+  I = SaveBlock->begin();
+  if (!TFI->spillCalleeSavedRegisters(*SaveBlock, I, CSI, TRI)) {
      for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
      for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
-      // Add the callee-saved register as live-in.
-      // It's killed at the spill.
-      EntryBlock->addLiveIn(CSI[i].getReg());
-
        // Insert the spill to the stack frame.
        unsigned Reg = CSI[i].getReg();
        const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
        // Insert the spill to the stack frame.
        unsigned Reg = CSI[i].getReg();
        const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
-      TII.storeRegToStackSlot(*EntryBlock, I, Reg, true, CSI[i].getFrameIdx(),
+      TII.storeRegToStackSlot(*SaveBlock, I, Reg, true, CSI[i].getFrameIdx(),
                                RC, TRI);
      }
    }
                                RC, TRI);
      }
    }
+  // Update the live-in information of all the blocks up to the save point.
+  updateLiveness(Fn);
  
    // Restore using target interface.
  
    // Restore using target interface.
-  for (unsigned ri = 0, re = ReturnBlocks.size(); ri != re; ++ri) {
-    MachineBasicBlock *MBB = ReturnBlocks[ri];
+  for (MachineBasicBlock *MBB : RestoreBlocks) {
      I = MBB->end();
      I = MBB->end();
-    --I;
  
      // Skip over all terminator instructions, which are part of the return
      // sequence.
  
      // Skip over all terminator instructions, which are part of the return
      // sequence.
@@ -721,21 +778,18 @@ void PEI::insertPrologEpilogCode(MachineFunction &Fn) {
    const TargetFrameLowering &TFI = *Fn.getSubtarget().getFrameLowering();
  
    // Add prologue to the function...
    const TargetFrameLowering &TFI = *Fn.getSubtarget().getFrameLowering();
  
    // Add prologue to the function...
-  TFI.emitPrologue(Fn);
+  TFI.emitPrologue(Fn, *SaveBlock);
  
  
-  // Add epilogue to restore the callee-save registers in each exiting block
-  for (MachineFunction::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) {
-    // If last instruction is a return instruction, add an epilogue
-    if (!I->empty() && I->back().isReturn())
-      TFI.emitEpilogue(Fn, *I);
-  }
+  // Add epilogue to restore the callee-save registers in each exiting block.
+  for (MachineBasicBlock *RestoreBlock : RestoreBlocks)
+    TFI.emitEpilogue(Fn, *RestoreBlock);
  
    // Emit additional code that is required to support segmented stacks, if
    // we've been asked for it.  This, when linked with a runtime with support
    // for segmented stacks (libgcc is one), will result in allocating stack
    // space in small chunks instead of one large contiguous block.
    if (Fn.shouldSplitStack())
  
    // Emit additional code that is required to support segmented stacks, if
    // we've been asked for it.  This, when linked with a runtime with support
    // for segmented stacks (libgcc is one), will result in allocating stack
    // space in small chunks instead of one large contiguous block.
    if (Fn.shouldSplitStack())
-    TFI.adjustForSegmentedStacks(Fn);
+    TFI.adjustForSegmentedStacks(Fn, *SaveBlock);
  
    // Emit additional code that is required to explicitly handle the stack in
    // HiPE native code (if needed) when loaded in the Erlang/OTP runtime. The
  
    // Emit additional code that is required to explicitly handle the stack in
    // HiPE native code (if needed) when loaded in the Erlang/OTP runtime. The
@@ -743,7 +797,7 @@ void PEI::insertPrologEpilogCode(MachineFunction &Fn) {
    // different conditional check and another BIF for allocating more stack
    // space.
    if (Fn.getFunction()->getCallingConv() == CallingConv::HiPE)
    // different conditional check and another BIF for allocating more stack
    // space.
    if (Fn.getFunction()->getCallingConv() == CallingConv::HiPE)
-    TFI.adjustForHiPEPrologue(Fn);
+    TFI.adjustForHiPEPrologue(Fn, *SaveBlock);
  }
  
  /// replaceFrameIndices - Replace all MO_FrameIndex operands with physical
  }
  
  /// replaceFrameIndices - Replace all MO_FrameIndex operands with physical
diff --git a/lib/CodeGen/ShrinkWrap.cpp b/lib/CodeGen/ShrinkWrap.cpp

new file mode 100644 (file)

index 0000000..56f1200
--- /dev/null
+++ b/lib/CodeGen/ShrinkWrap.cpp
@@ -0,0 +1,383 @@
+//===-- ShrinkWrap.cpp - Compute safe point for prolog/epilog insertion ---===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass looks for safe point where the prologue and epilogue can be
+// inserted.
+// The safe point for the prologue (resp. epilogue) is called Save
+// (resp. Restore).
+// A point is safe for prologue (resp. epilogue) if and only if
+// it 1) dominates (resp. post-dominates) all the frame related operations and
+// between 2) two executions of the Save (resp. Restore) point there is an
+// execution of the Restore (resp. Save) point.
+//
+// For instance, the following points are safe:
+// for (int i = 0; i < 10; ++i) {
+//   Save
+//   ...
+//   Restore
+// }
+// Indeed, the execution looks like Save -> Restore -> Save -> Restore ...
+// And the following points are not:
+// for (int i = 0; i < 10; ++i) {
+//   Save
+//   ...
+// }
+// for (int i = 0; i < 10; ++i) {
+//   ...
+//   Restore
+// }
+// Indeed, the execution looks like Save -> Save -> ... -> Restore -> Restore.
+//
+// This pass also ensures that the safe points are 3) cheaper than the regular
+// entry and exits blocks.
+//
+// Property #1 is ensured via the use of MachineDominatorTree and
+// MachinePostDominatorTree.
+// Property #2 is ensured via property #1 and MachineLoopInfo, i.e., both
+// points must be in the same loop.
+// Property #3 is ensured via the MachineBlockFrequencyInfo.
+//
+// If this pass found points matching all this properties, then
+// MachineFrameInfo is updated this that information.
+//===----------------------------------------------------------------------===//
+#include "llvm/ADT/Statistic.h"
+// To check for profitability.
+#include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
+// For property #1 for Save.
+#include "llvm/CodeGen/MachineDominators.h"
+#include "llvm/CodeGen/MachineFunctionPass.h"
+// To record the result of the analysis.
+#include "llvm/CodeGen/MachineFrameInfo.h"
+// For property #2.
+#include "llvm/CodeGen/MachineLoopInfo.h"
+// For property #1 for Restore.
+#include "llvm/CodeGen/MachinePostDominators.h"
+#include "llvm/CodeGen/Passes.h"
+// To know about callee-saved.
+#include "llvm/CodeGen/RegisterClassInfo.h"
+#include "llvm/Support/Debug.h"
+// To know about frame setup operation.
+#include "llvm/Target/TargetInstrInfo.h"
+// To access TargetInstrInfo.
+#include "llvm/Target/TargetSubtargetInfo.h"
+
+#define DEBUG_TYPE "shrink-wrap"
+
+using namespace llvm;
+
+STATISTIC(NumFunc, "Number of functions");
+STATISTIC(NumCandidates, "Number of shrink-wrapping candidates");
+STATISTIC(NumCandidatesDropped,
+          "Number of shrink-wrapping candidates dropped because of frequency");
+
+namespace {
+/// \brief Class to determine where the safe point to insert the
+/// prologue and epilogue are.
+/// Unlike the paper from Fred C. Chow, PLDI'88, that introduces the
+/// shrink-wrapping term for prologue/epilogue placement, this pass
+/// does not rely on expensive data-flow analysis. Instead we use the
+/// dominance properties and loop information to decide which point
+/// are safe for such insertion.
+class ShrinkWrap : public MachineFunctionPass {
+  /// Hold callee-saved information.
+  RegisterClassInfo RCI;
+  MachineDominatorTree *MDT;
+  MachinePostDominatorTree *MPDT;
+  /// Current safe point found for the prologue.
+  /// The prologue will be inserted before the first instruction
+  /// in this basic block.
+  MachineBasicBlock *Save;
+  /// Current safe point found for the epilogue.
+  /// The epilogue will be inserted before the first terminator instruction
+  /// in this basic block.
+  MachineBasicBlock *Restore;
+  /// Hold the information of the basic block frequency.
+  /// Use to check the profitability of the new points.
+  MachineBlockFrequencyInfo *MBFI;
+  /// Hold the loop information. Used to determine if Save and Restore
+  /// are in the same loop.
+  MachineLoopInfo *MLI;
+  /// Frequency of the Entry block.
+  uint64_t EntryFreq;
+  /// Current opcode for frame setup.
+  int FrameSetupOpcode;
+  /// Current opcode for frame destroy.
+  int FrameDestroyOpcode;
+  /// Entry block.
+  const MachineBasicBlock *Entry;
+
+  /// \brief Check if \p MI uses or defines a callee-saved register or
+  /// a frame index. If this is the case, this means \p MI must happen
+  /// after Save and before Restore.
+  bool useOrDefCSROrFI(const MachineInstr &MI) const;
+
+  /// \brief Update the Save and Restore points such that \p MBB is in
+  /// the region that is dominated by Save and post-dominated by Restore
+  /// and Save and Restore still match the safe point definition.
+  /// Such point may not exist and Save and/or Restore may be null after
+  /// this call.
+  void updateSaveRestorePoints(MachineBasicBlock &MBB);
+
+  /// \brief Initialize the pass for \p MF.
+  void init(MachineFunction &MF) {
+    RCI.runOnMachineFunction(MF);
+    MDT = &getAnalysis<MachineDominatorTree>();
+    MPDT = &getAnalysis<MachinePostDominatorTree>();
+    Save = nullptr;
+    Restore = nullptr;
+    MBFI = &getAnalysis<MachineBlockFrequencyInfo>();
+    MLI = &getAnalysis<MachineLoopInfo>();
+    EntryFreq = MBFI->getEntryFreq();
+    const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
+    FrameSetupOpcode = TII.getCallFrameSetupOpcode();
+    FrameDestroyOpcode = TII.getCallFrameDestroyOpcode();
+    Entry = &MF.front();
+
+    ++NumFunc;
+  }
+
+  /// Check whether or not Save and Restore points are still interesting for
+  /// shrink-wrapping.
+  bool ArePointsInteresting() const { return Save != Entry && Save && Restore; }
+
+public:
+  static char ID;
+
+  ShrinkWrap() : MachineFunctionPass(ID) {
+    initializeShrinkWrapPass(*PassRegistry::getPassRegistry());
+  }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesAll();
+    AU.addRequired<MachineBlockFrequencyInfo>();
+    AU.addRequired<MachineDominatorTree>();
+    AU.addRequired<MachinePostDominatorTree>();
+    AU.addRequired<MachineLoopInfo>();
+    MachineFunctionPass::getAnalysisUsage(AU);
+  }
+
+  const char *getPassName() const override {
+    return "Shrink Wrapping analysis";
+  }
+
+  /// \brief Perform the shrink-wrapping analysis and update
+  /// the MachineFrameInfo attached to \p MF with the results.
+  bool runOnMachineFunction(MachineFunction &MF) override;
+};
+} // End anonymous namespace.
+
+char ShrinkWrap::ID = 0;
+char &llvm::ShrinkWrapID = ShrinkWrap::ID;
+
+INITIALIZE_PASS_BEGIN(ShrinkWrap, "shrink-wrap", "Shrink Wrap Pass", false,
+                      false)
+INITIALIZE_PASS_DEPENDENCY(MachineBlockFrequencyInfo)
+INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree)
+INITIALIZE_PASS_DEPENDENCY(MachinePostDominatorTree)
+INITIALIZE_PASS_DEPENDENCY(MachineLoopInfo)
+INITIALIZE_PASS_END(ShrinkWrap, "shrink-wrap", "Shrink Wrap Pass", false, false)
+
+bool ShrinkWrap::useOrDefCSROrFI(const MachineInstr &MI) const {
+  if (MI.getOpcode() == FrameSetupOpcode ||
+      MI.getOpcode() == FrameDestroyOpcode) {
+    DEBUG(dbgs() << "Frame instruction: " << MI << '\n');
+    return true;
+  }
+  for (const MachineOperand &MO : MI.operands()) {
+    bool UseCSR = false;
+    if (MO.isReg()) {
+      unsigned PhysReg = MO.getReg();
+      if (!PhysReg)
+        continue;
+      assert(TargetRegisterInfo::isPhysicalRegister(PhysReg) &&
+             "Unallocated register?!");
+      UseCSR = RCI.getLastCalleeSavedAlias(PhysReg);
+    }
+    // TODO: Handle regmask more accurately.
+    // For now, be conservative about them.
+    if (UseCSR || MO.isFI() || MO.isRegMask()) {
+      DEBUG(dbgs() << "Use or define CSR(" << UseCSR << ") or FI(" << MO.isFI()
+                   << "): " << MI << '\n');
+      return true;
+    }
+  }
+  return false;
+}
+
+/// \brief Helper function to find the immediate (post) dominator.
+template <typename ListOfBBs, typename DominanceAnalysis>
+MachineBasicBlock *FindIDom(MachineBasicBlock &Block, ListOfBBs BBs,
+                            DominanceAnalysis &Dom) {
+  MachineBasicBlock *IDom = &Block;
+  for (MachineBasicBlock *BB : BBs) {
+    IDom = Dom.findNearestCommonDominator(IDom, BB);
+    if (!IDom)
+      break;
+  }
+  return IDom;
+}
+
+void ShrinkWrap::updateSaveRestorePoints(MachineBasicBlock &MBB) {
+  // Get rid of the easy cases first.
+  if (!Save)
+    Save = &MBB;
+  else
+    Save = MDT->findNearestCommonDominator(Save, &MBB);
+
+  if (!Save) {
+    DEBUG(dbgs() << "Found a block that is not reachable from Entry\n");
+    return;
+  }
+
+  if (!Restore)
+    Restore = &MBB;
+  else
+    Restore = MPDT->findNearestCommonDominator(Restore, &MBB);
+
+  // Make sure we would be able to insert the restore code before the
+  // terminator.
+  if (Restore == &MBB) {
+    for (const MachineInstr &Terminator : MBB.terminators()) {
+      if (!useOrDefCSROrFI(Terminator))
+        continue;
+      // One of the terminator needs to happen before the restore point.
+      if (MBB.succ_empty()) {
+        Restore = nullptr;
+        break;
+      }
+      // Look for a restore point that post-dominates all the successors.
+      // The immediate post-dominator is what we are looking for.
+      Restore = FindIDom<>(*Restore, Restore->successors(), *MPDT);
+      break;
+    }
+  }
+
+  if (!Restore) {
+    DEBUG(dbgs() << "Restore point needs to be spanned on several blocks\n");
+    return;
+  }
+
+  // Make sure Save and Restore are suitable for shrink-wrapping:
+  // 1. all path from Save needs to lead to Restore before exiting.
+  // 2. all path to Restore needs to go through Save from Entry.
+  // We achieve that by making sure that:
+  // A. Save dominates Restore.
+  // B. Restore post-dominates Save.
+  // C. Save and Restore are in the same loop.
+  bool SaveDominatesRestore = false;
+  bool RestorePostDominatesSave = false;
+  while (Save && Restore &&
+         (!(SaveDominatesRestore = MDT->dominates(Save, Restore)) ||
+          !(RestorePostDominatesSave = MPDT->dominates(Restore, Save)) ||
+          MLI->getLoopFor(Save) != MLI->getLoopFor(Restore))) {
+    // Fix (A).
+    if (!SaveDominatesRestore) {
+      Save = MDT->findNearestCommonDominator(Save, Restore);
+      continue;
+    }
+    // Fix (B).
+    if (!RestorePostDominatesSave)
+      Restore = MPDT->findNearestCommonDominator(Restore, Save);
+
+    // Fix (C).
+    if (Save && Restore && Save != Restore &&
+        MLI->getLoopFor(Save) != MLI->getLoopFor(Restore)) {
+      if (MLI->getLoopDepth(Save) > MLI->getLoopDepth(Restore))
+        // Push Save outside of this loop.
+        Save = FindIDom<>(*Save, Save->predecessors(), *MDT);
+      else
+        // Push Restore outside of this loop.
+        Restore = FindIDom<>(*Restore, Restore->successors(), *MPDT);
+    }
+  }
+}
+
+bool ShrinkWrap::runOnMachineFunction(MachineFunction &MF) {
+  if (MF.empty())
+    return false;
+  DEBUG(dbgs() << "**** Analysing " << MF.getName() << '\n');
+
+  init(MF);
+
+  for (MachineBasicBlock &MBB : MF) {
+    DEBUG(dbgs() << "Look into: " << MBB.getNumber() << ' ' << MBB.getName()
+                 << '\n');
+
+    for (const MachineInstr &MI : MBB) {
+      if (!useOrDefCSROrFI(MI))
+        continue;
+      // Save (resp. restore) point must dominate (resp. post dominate)
+      // MI. Look for the proper basic block for those.
+      updateSaveRestorePoints(MBB);
+      // If we are at a point where we cannot improve the placement of
+      // save/restore instructions, just give up.
+      if (!ArePointsInteresting()) {
+        DEBUG(dbgs() << "No Shrink wrap candidate found\n");
+        return false;
+      }
+      // No need to look for other instructions, this basic block
+      // will already be part of the handled region.
+      break;
+    }
+  }
+  if (!ArePointsInteresting()) {
+    // If the points are not interesting at this point, then they must be null
+    // because it means we did not encounter any frame/CSR related code.
+    // Otherwise, we would have returned from the previous loop.
+    assert(!Save && !Restore && "We miss a shrink-wrap opportunity?!");
+    DEBUG(dbgs() << "Nothing to shrink-wrap\n");
+    return false;
+  }
+
+  DEBUG(dbgs() << "\n ** Results **\nFrequency of the Entry: " << EntryFreq
+               << '\n');
+
+  do {
+    DEBUG(dbgs() << "Shrink wrap candidates (#, Name, Freq):\nSave: "
+                 << Save->getNumber() << ' ' << Save->getName() << ' '
+                 << MBFI->getBlockFreq(Save).getFrequency() << "\nRestore: "
+                 << Restore->getNumber() << ' ' << Restore->getName() << ' '
+                 << MBFI->getBlockFreq(Restore).getFrequency() << '\n');
+
+    bool IsSaveCheap;
+    if ((IsSaveCheap = EntryFreq >= MBFI->getBlockFreq(Save).getFrequency()) &&
+        EntryFreq >= MBFI->getBlockFreq(Restore).getFrequency())
+      break;
+    DEBUG(dbgs() << "New points are too expensive\n");
+    MachineBasicBlock *NewBB;
+    if (!IsSaveCheap) {
+      Save = FindIDom<>(*Save, Save->predecessors(), *MDT);
+      if (!Save)
+        break;
+      NewBB = Save;
+    } else {
+      // Restore is expensive.
+      Restore = FindIDom<>(*Restore, Restore->successors(), *MPDT);
+      if (!Restore)
+        break;
+      NewBB = Restore;
+    }
+    updateSaveRestorePoints(*NewBB);
+  } while (Save && Restore);
+
+  if (!ArePointsInteresting()) {
+    ++NumCandidatesDropped;
+    return false;
+  }
+
+  DEBUG(dbgs() << "Final shrink wrap candidates:\nSave: " << Save->getNumber()
+               << ' ' << Save->getName() << "\nRestore: "
+               << Restore->getNumber() << ' ' << Restore->getName() << '\n');
+
+  MachineFrameInfo *MFI = MF.getFrameInfo();
+  MFI->setSavePoint(Save);
+  MFI->setRestorePoint(Restore);
+  ++NumCandidates;
+  return false;
+}
diff --git a/lib/Target/AArch64/AArch64FrameLowering.cpp b/lib/Target/AArch64/AArch64FrameLowering.cpp

index 6f133a35dce3f0c32dc7adc622cd0a5b5bb2f030..7146f592a96ac08cf4fb66bdeff4dd79e31b6058 100644 (file)
--- a/lib/Target/AArch64/AArch64FrameLowering.cpp
+++ b/lib/Target/AArch64/AArch64FrameLowering.cpp
@@ -275,8 +275,8 @@ static bool isCSSave(MachineInstr *MBBI) {
           MBBI->getOpcode() == AArch64::STPDpre;
  }
  
           MBBI->getOpcode() == AArch64::STPDpre;
  }
  
-void AArch64FrameLowering::emitPrologue(MachineFunction &MF) const {
-  MachineBasicBlock &MBB = MF.front(); // Prologue goes in entry BB.
+void AArch64FrameLowering::emitPrologue(MachineFunction &MF,
+                                        MachineBasicBlock &MBB) const {
    MachineBasicBlock::iterator MBBI = MBB.begin();
    const MachineFrameInfo *MFI = MF.getFrameInfo();
    const Function *Fn = MF.getFunction();
    MachineBasicBlock::iterator MBBI = MBB.begin();
    const MachineFrameInfo *MFI = MF.getFrameInfo();
    const Function *Fn = MF.getFunction();
@@ -539,15 +539,19 @@ static bool isCSRestore(MachineInstr *MI, const MCPhysReg *CSRegs) {
  void AArch64FrameLowering::emitEpilogue(MachineFunction &MF,
                                          MachineBasicBlock &MBB) const {
    MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
  void AArch64FrameLowering::emitEpilogue(MachineFunction &MF,
                                          MachineBasicBlock &MBB) const {
    MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
-  assert(MBBI->isReturn() && "Can only insert epilog into returning blocks");
    MachineFrameInfo *MFI = MF.getFrameInfo();
    const AArch64InstrInfo *TII =
        static_cast<const AArch64InstrInfo *>(MF.getSubtarget().getInstrInfo());
    const AArch64RegisterInfo *RegInfo = static_cast<const AArch64RegisterInfo *>(
        MF.getSubtarget().getRegisterInfo());
    MachineFrameInfo *MFI = MF.getFrameInfo();
    const AArch64InstrInfo *TII =
        static_cast<const AArch64InstrInfo *>(MF.getSubtarget().getInstrInfo());
    const AArch64RegisterInfo *RegInfo = static_cast<const AArch64RegisterInfo *>(
        MF.getSubtarget().getRegisterInfo());
-  DebugLoc DL = MBBI->getDebugLoc();
-  unsigned RetOpcode = MBBI->getOpcode();
-
+  DebugLoc DL;
+  bool IsTailCallReturn = false;
+  if (MBB.end() != MBBI) {
+    DL = MBBI->getDebugLoc();
+    unsigned RetOpcode = MBBI->getOpcode();
+    IsTailCallReturn = RetOpcode == AArch64::TCRETURNdi ||
+      RetOpcode == AArch64::TCRETURNri;
+  }
    int NumBytes = MFI->getStackSize();
    const AArch64FunctionInfo *AFI = MF.getInfo<AArch64FunctionInfo>();
  
    int NumBytes = MFI->getStackSize();
    const AArch64FunctionInfo *AFI = MF.getInfo<AArch64FunctionInfo>();
  
@@ -559,7 +563,7 @@ void AArch64FrameLowering::emitEpilogue(MachineFunction &MF,
    // Initial and residual are named for consistency with the prologue. Note that
    // in the epilogue, the residual adjustment is executed first.
    uint64_t ArgumentPopSize = 0;
    // Initial and residual are named for consistency with the prologue. Note that
    // in the epilogue, the residual adjustment is executed first.
    uint64_t ArgumentPopSize = 0;
-  if (RetOpcode == AArch64::TCRETURNdi || RetOpcode == AArch64::TCRETURNri) {
+  if (IsTailCallReturn) {
      MachineOperand &StackAdjust = MBBI->getOperand(1);
  
      // For a tail-call in a callee-pops-arguments environment, some or all of
      MachineOperand &StackAdjust = MBBI->getOperand(1);
  
      // For a tail-call in a callee-pops-arguments environment, some or all of
@@ -604,7 +608,7 @@ void AArch64FrameLowering::emitEpilogue(MachineFunction &MF,
  
    unsigned NumRestores = 0;
    // Move past the restores of the callee-saved registers.
  
    unsigned NumRestores = 0;
    // Move past the restores of the callee-saved registers.
-  MachineBasicBlock::iterator LastPopI = MBBI;
+  MachineBasicBlock::iterator LastPopI = MBB.getFirstTerminator();
    const MCPhysReg *CSRegs = RegInfo->getCalleeSavedRegs(&MF);
    if (LastPopI != MBB.begin()) {
      do {
    const MCPhysReg *CSRegs = RegInfo->getCalleeSavedRegs(&MF);
    if (LastPopI != MBB.begin()) {
      do {
diff --git a/lib/Target/AArch64/AArch64FrameLowering.h b/lib/Target/AArch64/AArch64FrameLowering.h

index 1439bf320859c16471f901d14258f54c4f35a43a..b496fccba349fba39d0fc1b5d9fd01bb6afb51b5 100644 (file)
--- a/lib/Target/AArch64/AArch64FrameLowering.h
+++ b/lib/Target/AArch64/AArch64FrameLowering.h
@@ -34,7 +34,7 @@ public:
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
-  void emitPrologue(MachineFunction &MF) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    int getFrameIndexOffset(const MachineFunction &MF, int FI) const override;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    int getFrameIndexOffset(const MachineFunction &MF, int FI) const override;
diff --git a/lib/Target/ARM/ARMFrameLowering.cpp b/lib/Target/ARM/ARMFrameLowering.cpp

index 92fe8fe5fbcedafba84a51212f268f8425c473b5..4eafd82af4c95ecc873742516bc9d91f6aeb0165 100644 (file)
--- a/lib/Target/ARM/ARMFrameLowering.cpp
+++ b/lib/Target/ARM/ARMFrameLowering.cpp
@@ -278,8 +278,9 @@ static void emitAligningInstructions(MachineFunction &MF, ARMFunctionInfo *AFI,
    }
  }
  
    }
  }
  
-void ARMFrameLowering::emitPrologue(MachineFunction &MF) const {
-  MachineBasicBlock &MBB = MF.front();
+void ARMFrameLowering::emitPrologue(MachineFunction &MF,
+                                    MachineBasicBlock &MBB) const {
+  assert(&MBB == &MF.front() && "Shrink-wrapping not yet implemented");
    MachineBasicBlock::iterator MBBI = MBB.begin();
    MachineFrameInfo  *MFI = MF.getFrameInfo();
    ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
    MachineBasicBlock::iterator MBBI = MBB.begin();
    MachineFrameInfo  *MFI = MF.getFrameInfo();
    ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
@@ -1861,7 +1862,8 @@ static const uint64_t kSplitStackAvailable = 256;
  // ARM can be found at [1].
  //
  // [1] - https://github.com/mozilla/rust/blob/86efd9/src/rt/arch/arm/morestack.S
  // ARM can be found at [1].
  //
  // [1] - https://github.com/mozilla/rust/blob/86efd9/src/rt/arch/arm/morestack.S
-void ARMFrameLowering::adjustForSegmentedStacks(MachineFunction &MF) const {
+void ARMFrameLowering::adjustForSegmentedStacks(
+    MachineFunction &MF, MachineBasicBlock &PrologueMBB) const {
    unsigned Opcode;
    unsigned CFIIndex;
    const ARMSubtarget *ST = &MF.getSubtarget<ARMSubtarget>();
    unsigned Opcode;
    unsigned CFIIndex;
    const ARMSubtarget *ST = &MF.getSubtarget<ARMSubtarget>();
@@ -1874,7 +1876,7 @@ void ARMFrameLowering::adjustForSegmentedStacks(MachineFunction &MF) const {
    if (!ST->isTargetAndroid() && !ST->isTargetLinux())
      report_fatal_error("Segmented stacks not supported on this platform.");
  
    if (!ST->isTargetAndroid() && !ST->isTargetLinux())
      report_fatal_error("Segmented stacks not supported on this platform.");
  
-  MachineBasicBlock &prologueMBB = MF.front();
+  assert(&PrologueMBB == &MF.front() && "Shrink-wrapping not yet implemented");
    MachineFrameInfo *MFI = MF.getFrameInfo();
    MachineModuleInfo &MMI = MF.getMMI();
    MCContext &Context = MMI.getContext();
    MachineFrameInfo *MFI = MF.getFrameInfo();
    MachineModuleInfo &MMI = MF.getMMI();
    MCContext &Context = MMI.getContext();
@@ -1902,8 +1904,8 @@ void ARMFrameLowering::adjustForSegmentedStacks(MachineFunction &MF) const {
    MachineBasicBlock *GetMBB = MF.CreateMachineBasicBlock();
    MachineBasicBlock *McrMBB = MF.CreateMachineBasicBlock();
  
    MachineBasicBlock *GetMBB = MF.CreateMachineBasicBlock();
    MachineBasicBlock *McrMBB = MF.CreateMachineBasicBlock();
  
-  for (MachineBasicBlock::livein_iterator i = prologueMBB.livein_begin(),
-                                          e = prologueMBB.livein_end();
+  for (MachineBasicBlock::livein_iterator i = PrologueMBB.livein_begin(),
+                                          e = PrologueMBB.livein_end();
         i != e; ++i) {
      AllocMBB->addLiveIn(*i);
      GetMBB->addLiveIn(*i);
         i != e; ++i) {
      AllocMBB->addLiveIn(*i);
      GetMBB->addLiveIn(*i);
@@ -2156,7 +2158,7 @@ void ARMFrameLowering::adjustForSegmentedStacks(MachineFunction &MF) const {
        .addCFIIndex(CFIIndex);
  
    // Organizing MBB lists
        .addCFIIndex(CFIIndex);
  
    // Organizing MBB lists
-  PostStackMBB->addSuccessor(&prologueMBB);
+  PostStackMBB->addSuccessor(&PrologueMBB);
  
    AllocMBB->addSuccessor(PostStackMBB);
  
  
    AllocMBB->addSuccessor(PostStackMBB);
  
diff --git a/lib/Target/ARM/ARMFrameLowering.h b/lib/Target/ARM/ARMFrameLowering.h

index b7be43642ad058d61d9663a20732f0b83a2eb242..ff3425795ae5d9abe4972145ac8e4679ce31bdd2 100644 (file)
--- a/lib/Target/ARM/ARMFrameLowering.h
+++ b/lib/Target/ARM/ARMFrameLowering.h
@@ -28,7 +28,7 @@ public:
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
-  void emitPrologue(MachineFunction &MF) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    void fixTCReturn(MachineFunction &MF, MachineBasicBlock &MBB) const;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    void fixTCReturn(MachineFunction &MF, MachineBasicBlock &MBB) const;
@@ -55,7 +55,8 @@ public:
    void processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
                                              RegScavenger *RS) const override;
  
    void processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
                                              RegScavenger *RS) const override;
  
-  void adjustForSegmentedStacks(MachineFunction &MF) const override;
+  void adjustForSegmentedStacks(MachineFunction &MF,
+                                MachineBasicBlock &MBB) const override;
  
   private:
    void emitPushInst(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
  
   private:
    void emitPushInst(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
diff --git a/lib/Target/ARM/Thumb1FrameLowering.cpp b/lib/Target/ARM/Thumb1FrameLowering.cpp

index c496cd7c7593b5f6a95f7d4c7a8ff097fa1b101f..77cd890e4cad32558b166e78bd602038227b0f75 100644 (file)
--- a/lib/Target/ARM/Thumb1FrameLowering.cpp
+++ b/lib/Target/ARM/Thumb1FrameLowering.cpp
@@ -82,8 +82,9 @@ eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
    MBB.erase(I);
  }
  
    MBB.erase(I);
  }
  
-void Thumb1FrameLowering::emitPrologue(MachineFunction &MF) const {
-  MachineBasicBlock &MBB = MF.front();
+void Thumb1FrameLowering::emitPrologue(MachineFunction &MF,
+                                       MachineBasicBlock &MBB) const {
+  assert(&MBB == &MF.front() && "Shrink-wrapping not yet implemented");
    MachineBasicBlock::iterator MBBI = MBB.begin();
    MachineFrameInfo  *MFI = MF.getFrameInfo();
    ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
    MachineBasicBlock::iterator MBBI = MBB.begin();
    MachineFrameInfo  *MFI = MF.getFrameInfo();
    ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
diff --git a/lib/Target/ARM/Thumb1FrameLowering.h b/lib/Target/ARM/Thumb1FrameLowering.h

index cf932035b8d2f4641fa59f85d003026feb11e277..31d57325ebd6f6b6ff7d163328aa344d4ffa5ed7 100644 (file)
--- a/lib/Target/ARM/Thumb1FrameLowering.h
+++ b/lib/Target/ARM/Thumb1FrameLowering.h
@@ -27,7 +27,7 @@ public:
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
-  void emitPrologue(MachineFunction &MF) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
diff --git a/lib/Target/BPF/BPFFrameLowering.cpp b/lib/Target/BPF/BPFFrameLowering.cpp

index ae9f35520de99f7fc1e12a288438d06619cd1d81..54c5ececc7de960d1810de3603f6df108f4b4a71 100644 (file)
--- a/lib/Target/BPF/BPFFrameLowering.cpp
+++ b/lib/Target/BPF/BPFFrameLowering.cpp
@@ -23,7 +23,8 @@ using namespace llvm;
  
  bool BPFFrameLowering::hasFP(const MachineFunction &MF) const { return true; }
  
  
  bool BPFFrameLowering::hasFP(const MachineFunction &MF) const { return true; }
  
-void BPFFrameLowering::emitPrologue(MachineFunction &MF) const {}
+void BPFFrameLowering::emitPrologue(MachineFunction &MF,
+                                    MachineBasicBlock &MBB) const {}
  
  void BPFFrameLowering::emitEpilogue(MachineFunction &MF,
                                      MachineBasicBlock &MBB) const {}
  
  void BPFFrameLowering::emitEpilogue(MachineFunction &MF,
                                      MachineBasicBlock &MBB) const {}
diff --git a/lib/Target/BPF/BPFFrameLowering.h b/lib/Target/BPF/BPFFrameLowering.h

index 833046ddab67dbc7c93052fcb27af37c5c0f0573..3b9fc443e053984888339b28a36fdfc0c77b13b7 100644 (file)
--- a/lib/Target/BPF/BPFFrameLowering.h
+++ b/lib/Target/BPF/BPFFrameLowering.h
@@ -24,7 +24,7 @@ public:
    explicit BPFFrameLowering(const BPFSubtarget &sti)
        : TargetFrameLowering(TargetFrameLowering::StackGrowsDown, 8, 0) {}
  
    explicit BPFFrameLowering(const BPFSubtarget &sti)
        : TargetFrameLowering(TargetFrameLowering::StackGrowsDown, 8, 0) {}
  
-  void emitPrologue(MachineFunction &MF) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    bool hasFP(const MachineFunction &MF) const override;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    bool hasFP(const MachineFunction &MF) const override;
diff --git a/lib/Target/Hexagon/HexagonFrameLowering.cpp b/lib/Target/Hexagon/HexagonFrameLowering.cpp

index ee025137dc0d2abfb239f61491cdea5c2b2261d5..3071b779413319c866b0ee1d96f4e71569e70854 100644 (file)
--- a/lib/Target/Hexagon/HexagonFrameLowering.cpp
+++ b/lib/Target/Hexagon/HexagonFrameLowering.cpp
@@ -344,16 +344,17 @@ void HexagonFrameLowering::findShrunkPrologEpilog(MachineFunction &MF,
    EpilogB = PDomB;
  }
  
    EpilogB = PDomB;
  }
  
-
  /// Perform most of the PEI work here:
  /// - saving/restoring of the callee-saved registers,
  /// - stack frame creation and destruction.
  /// Normally, this work is distributed among various functions, but doing it
  /// in one place allows shrink-wrapping of the stack frame.
  /// Perform most of the PEI work here:
  /// - saving/restoring of the callee-saved registers,
  /// - stack frame creation and destruction.
  /// Normally, this work is distributed among various functions, but doing it
  /// in one place allows shrink-wrapping of the stack frame.
-void HexagonFrameLowering::emitPrologue(MachineFunction &MF) const {
+void HexagonFrameLowering::emitPrologue(MachineFunction &MF,
+                                        MachineBasicBlock &MBB) const {
    auto &HST = static_cast<const HexagonSubtarget&>(MF.getSubtarget());
    auto &HRI = *HST.getRegisterInfo();
  
    auto &HST = static_cast<const HexagonSubtarget&>(MF.getSubtarget());
    auto &HRI = *HST.getRegisterInfo();
  
+  assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
    MachineFrameInfo *MFI = MF.getFrameInfo();
    const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo();
  
    MachineFrameInfo *MFI = MF.getFrameInfo();
    const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo();
  
diff --git a/lib/Target/Hexagon/HexagonFrameLowering.h b/lib/Target/Hexagon/HexagonFrameLowering.h

index 228a0442b474f284e8905d7143d683a2b066fb8f..89500cb85724176af98adb4b85898c6f9e5aca56 100644 (file)
--- a/lib/Target/Hexagon/HexagonFrameLowering.h
+++ b/lib/Target/Hexagon/HexagonFrameLowering.h
@@ -26,7 +26,8 @@ public:
    // All of the prolog/epilog functionality, including saving and restoring
    // callee-saved registers is handled in emitPrologue. This is to have the
    // logic for shrink-wrapping in one place.
    // All of the prolog/epilog functionality, including saving and restoring
    // callee-saved registers is handled in emitPrologue. This is to have the
    // logic for shrink-wrapping in one place.
-  void emitPrologue(MachineFunction &MF) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const
+      override;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const
        override {}
    bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const
        override {}
    bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
diff --git a/lib/Target/MSP430/MSP430FrameLowering.cpp b/lib/Target/MSP430/MSP430FrameLowering.cpp

index d6cb9f6459a6df481af357663f4f87133a58ead0..eb720809e47cca6910468081b330a0b04c070259 100644 (file)
--- a/lib/Target/MSP430/MSP430FrameLowering.cpp
+++ b/lib/Target/MSP430/MSP430FrameLowering.cpp
@@ -39,8 +39,9 @@ bool MSP430FrameLowering::hasReservedCallFrame(const MachineFunction &MF) const
    return !MF.getFrameInfo()->hasVarSizedObjects();
  }
  
    return !MF.getFrameInfo()->hasVarSizedObjects();
  }
  
-void MSP430FrameLowering::emitPrologue(MachineFunction &MF) const {
-  MachineBasicBlock &MBB = MF.front();   // Prolog goes in entry BB
+void MSP430FrameLowering::emitPrologue(MachineFunction &MF,
+                                       MachineBasicBlock &MBB) const {
+  assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
    MachineFrameInfo *MFI = MF.getFrameInfo();
    MSP430MachineFunctionInfo *MSP430FI = MF.getInfo<MSP430MachineFunctionInfo>();
    const MSP430InstrInfo &TII =
    MachineFrameInfo *MFI = MF.getFrameInfo();
    MSP430MachineFunctionInfo *MSP430FI = MF.getInfo<MSP430MachineFunctionInfo>();
    const MSP430InstrInfo &TII =
diff --git a/lib/Target/MSP430/MSP430FrameLowering.h b/lib/Target/MSP430/MSP430FrameLowering.h

index 1941af26e853906a65686875f62a27930ea5126c..48c4dc866a63de1b9da0967149abd75e13273eab 100644 (file)
--- a/lib/Target/MSP430/MSP430FrameLowering.h
+++ b/lib/Target/MSP430/MSP430FrameLowering.h
@@ -27,7 +27,7 @@ public:
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
-  void emitPrologue(MachineFunction &MF) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    void eliminateCallFramePseudoInstr(MachineFunction &MF,
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    void eliminateCallFramePseudoInstr(MachineFunction &MF,
diff --git a/lib/Target/Mips/Mips16FrameLowering.cpp b/lib/Target/Mips/Mips16FrameLowering.cpp

index 5828fbdee40d98023f3923873a94aac95018a83b..db2a924a99f9b54b348d20c386aa658d7691ff32 100644 (file)
--- a/lib/Target/Mips/Mips16FrameLowering.cpp
+++ b/lib/Target/Mips/Mips16FrameLowering.cpp
@@ -32,8 +32,9 @@ using namespace llvm;
  Mips16FrameLowering::Mips16FrameLowering(const MipsSubtarget &STI)
      : MipsFrameLowering(STI, STI.stackAlignment()) {}
  
  Mips16FrameLowering::Mips16FrameLowering(const MipsSubtarget &STI)
      : MipsFrameLowering(STI, STI.stackAlignment()) {}
  
-void Mips16FrameLowering::emitPrologue(MachineFunction &MF) const {
-  MachineBasicBlock &MBB = MF.front();
+void Mips16FrameLowering::emitPrologue(MachineFunction &MF,
+                                       MachineBasicBlock &MBB) const {
+  assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
    MachineFrameInfo *MFI = MF.getFrameInfo();
    const Mips16InstrInfo &TII =
        *static_cast<const Mips16InstrInfo *>(STI.getInstrInfo());
    MachineFrameInfo *MFI = MF.getFrameInfo();
    const Mips16InstrInfo &TII =
        *static_cast<const Mips16InstrInfo *>(STI.getInstrInfo());
diff --git a/lib/Target/Mips/Mips16FrameLowering.h b/lib/Target/Mips/Mips16FrameLowering.h

index 0287e59243a24c88c1fc65c669dba33277830f62..f281c927c1c4a6332410eced34436f533af44fa8 100644 (file)
--- a/lib/Target/Mips/Mips16FrameLowering.h
+++ b/lib/Target/Mips/Mips16FrameLowering.h
@@ -23,7 +23,7 @@ public:
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
-  void emitPrologue(MachineFunction &MF) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
diff --git a/lib/Target/Mips/MipsSEFrameLowering.cpp b/lib/Target/Mips/MipsSEFrameLowering.cpp

index e9a206170a6f8097b7ad88e3b802cc43f8ca2aae..19efa59e1fdfb2d7be27ba04f1243a54bf13d12d 100644 (file)
--- a/lib/Target/Mips/MipsSEFrameLowering.cpp
+++ b/lib/Target/Mips/MipsSEFrameLowering.cpp
@@ -364,8 +364,9 @@ bool ExpandPseudo::expandExtractElementF64(MachineBasicBlock &MBB,
  MipsSEFrameLowering::MipsSEFrameLowering(const MipsSubtarget &STI)
      : MipsFrameLowering(STI, STI.stackAlignment()) {}
  
  MipsSEFrameLowering::MipsSEFrameLowering(const MipsSubtarget &STI)
      : MipsFrameLowering(STI, STI.stackAlignment()) {}
  
-void MipsSEFrameLowering::emitPrologue(MachineFunction &MF) const {
-  MachineBasicBlock &MBB   = MF.front();
+void MipsSEFrameLowering::emitPrologue(MachineFunction &MF,
+                                       MachineBasicBlock &MBB) const {
+  assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
    MachineFrameInfo *MFI    = MF.getFrameInfo();
    MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
  
    MachineFrameInfo *MFI    = MF.getFrameInfo();
    MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
  
diff --git a/lib/Target/Mips/MipsSEFrameLowering.h b/lib/Target/Mips/MipsSEFrameLowering.h

index 22448a433b77f79d834dc2ce74d556bfcb8e13e2..2fcd6bbb9a151ed806926993a1ba5fcbd79de74c 100644 (file)
--- a/lib/Target/Mips/MipsSEFrameLowering.h
+++ b/lib/Target/Mips/MipsSEFrameLowering.h
@@ -24,7 +24,7 @@ public:
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
-  void emitPrologue(MachineFunction &MF) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
diff --git a/lib/Target/NVPTX/NVPTXFrameLowering.cpp b/lib/Target/NVPTX/NVPTXFrameLowering.cpp

index 34d3a66adce4e717804707c01c0b21035adff87f..5503494fc3c89ceeb7e40a4144ea4401568926e0 100644 (file)
--- a/lib/Target/NVPTX/NVPTXFrameLowering.cpp
+++ b/lib/Target/NVPTX/NVPTXFrameLowering.cpp
@@ -31,9 +31,10 @@ NVPTXFrameLowering::NVPTXFrameLowering()
  
  bool NVPTXFrameLowering::hasFP(const MachineFunction &MF) const { return true; }
  
  
  bool NVPTXFrameLowering::hasFP(const MachineFunction &MF) const { return true; }
  
-void NVPTXFrameLowering::emitPrologue(MachineFunction &MF) const {
+void NVPTXFrameLowering::emitPrologue(MachineFunction &MF,
+                                      MachineBasicBlock &MBB) const {
    if (MF.getFrameInfo()->hasStackObjects()) {
    if (MF.getFrameInfo()->hasStackObjects()) {
-    MachineBasicBlock &MBB = MF.front();
+    assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
      // Insert "mov.u32 %SP, %Depot"
      MachineBasicBlock::iterator MBBI = MBB.begin();
      // This instruction really occurs before first instruction
      // Insert "mov.u32 %SP, %Depot"
      MachineBasicBlock::iterator MBBI = MBB.begin();
      // This instruction really occurs before first instruction
diff --git a/lib/Target/NVPTX/NVPTXFrameLowering.h b/lib/Target/NVPTX/NVPTXFrameLowering.h

index d1e0a5ceb30f2196e491d9454dbccabb2e87439b..14f8bb7b98fec58afd747171ef970b68933aff69 100644 (file)
--- a/lib/Target/NVPTX/NVPTXFrameLowering.h
+++ b/lib/Target/NVPTX/NVPTXFrameLowering.h
@@ -23,7 +23,7 @@ public:
    explicit NVPTXFrameLowering();
  
    bool hasFP(const MachineFunction &MF) const override;
    explicit NVPTXFrameLowering();
  
    bool hasFP(const MachineFunction &MF) const override;
-  void emitPrologue(MachineFunction &MF) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    void
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    void
diff --git a/lib/Target/NVPTX/NVPTXPrologEpilogPass.cpp b/lib/Target/NVPTX/NVPTXPrologEpilogPass.cpp

index c1c67e3872e80c45cb38ee007eb89f257f3a0fce..5fd69a6815a8feaaf3b26bcd43f1ac228a2b0706 100644 (file)
--- a/lib/Target/NVPTX/NVPTXPrologEpilogPass.cpp
+++ b/lib/Target/NVPTX/NVPTXPrologEpilogPass.cpp
@@ -68,7 +68,7 @@ bool NVPTXPrologEpilogPass::runOnMachineFunction(MachineFunction &MF) {
    }
  
    // Add function prolog/epilog
    }
  
    // Add function prolog/epilog
-  TFI.emitPrologue(MF);
+  TFI.emitPrologue(MF, MF.front());
  
    for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) {
      // If last instruction is a return instruction, add an epilogue
  
    for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) {
      // If last instruction is a return instruction, add an epilogue
diff --git a/lib/Target/PowerPC/PPCFrameLowering.cpp b/lib/Target/PowerPC/PPCFrameLowering.cpp

index f997fea4d93e6f76f2a005726fc07d588c858cfe..b4008e4a886afb32d57f0ed53fd92d8c49ce0322 100644 (file)
--- a/lib/Target/PowerPC/PPCFrameLowering.cpp
+++ b/lib/Target/PowerPC/PPCFrameLowering.cpp
@@ -555,8 +555,9 @@ void PPCFrameLowering::replaceFPWithRealFP(MachineFunction &MF) const {
      }
  }
  
      }
  }
  
-void PPCFrameLowering::emitPrologue(MachineFunction &MF) const {
-  MachineBasicBlock &MBB = MF.front();   // Prolog goes in entry BB
+void PPCFrameLowering::emitPrologue(MachineFunction &MF,
+                                    MachineBasicBlock &MBB) const {
+  assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
    MachineBasicBlock::iterator MBBI = MBB.begin();
    MachineFrameInfo *MFI = MF.getFrameInfo();
    const PPCInstrInfo &TII =
    MachineBasicBlock::iterator MBBI = MBB.begin();
    MachineFrameInfo *MFI = MF.getFrameInfo();
    const PPCInstrInfo &TII =
diff --git a/lib/Target/PowerPC/PPCFrameLowering.h b/lib/Target/PowerPC/PPCFrameLowering.h

index dddabb808929e206c165bfdbdfbfcb8968acbbd5..28d074ecd79d8347482f0568ab5bc42447b72efe 100644 (file)
--- a/lib/Target/PowerPC/PPCFrameLowering.h
+++ b/lib/Target/PowerPC/PPCFrameLowering.h
@@ -38,7 +38,7 @@ public:
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
-  void emitPrologue(MachineFunction &MF) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    bool hasFP(const MachineFunction &MF) const override;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    bool hasFP(const MachineFunction &MF) const override;
diff --git a/lib/Target/R600/AMDGPUFrameLowering.cpp b/lib/Target/R600/AMDGPUFrameLowering.cpp

index 9e8302ec0a1b1db1e3358b9f369b5d78a4d37b6f..8175786fb9b13b10b2119a3722f69e88d0aa038b 100644 (file)
--- a/lib/Target/R600/AMDGPUFrameLowering.cpp
+++ b/lib/Target/R600/AMDGPUFrameLowering.cpp
@@ -99,9 +99,8 @@ AMDGPUFrameLowering::getCalleeSavedSpillSlots(unsigned &NumEntries) const {
    NumEntries = 0;
    return nullptr;
  }
    NumEntries = 0;
    return nullptr;
  }
-void
-AMDGPUFrameLowering::emitPrologue(MachineFunction &MF) const {
-}
+void AMDGPUFrameLowering::emitPrologue(MachineFunction &MF,
+                                       MachineBasicBlock &MBB) const {}
  void
  AMDGPUFrameLowering::emitEpilogue(MachineFunction &MF,
                                    MachineBasicBlock &MBB) const {
  void
  AMDGPUFrameLowering::emitEpilogue(MachineFunction &MF,
                                    MachineBasicBlock &MBB) const {
diff --git a/lib/Target/R600/AMDGPUFrameLowering.h b/lib/Target/R600/AMDGPUFrameLowering.h

index 15a6636a1aeaac533628ccb7d0e49daecd117db2..9f31be1af7941b6b9c9cc0c1c45839050362b059 100644 (file)
--- a/lib/Target/R600/AMDGPUFrameLowering.h
+++ b/lib/Target/R600/AMDGPUFrameLowering.h
@@ -37,7 +37,7 @@ public:
    int getFrameIndexOffset(const MachineFunction &MF, int FI) const override;
    const SpillSlot *
      getCalleeSavedSpillSlots(unsigned &NumEntries) const override;
    int getFrameIndexOffset(const MachineFunction &MF, int FI) const override;
    const SpillSlot *
      getCalleeSavedSpillSlots(unsigned &NumEntries) const override;
-  void emitPrologue(MachineFunction &MF) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
    bool hasFP(const MachineFunction &MF) const override;
  };
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
    bool hasFP(const MachineFunction &MF) const override;
  };
diff --git a/lib/Target/Sparc/SparcFrameLowering.cpp b/lib/Target/Sparc/SparcFrameLowering.cpp

index a065d3a0803a42aa2179ab78da0bf2572825df18..bccc6bdd53eb126f70e821cdecbde5a353cf301e 100644 (file)
--- a/lib/Target/Sparc/SparcFrameLowering.cpp
+++ b/lib/Target/Sparc/SparcFrameLowering.cpp
@@ -82,10 +82,11 @@ void SparcFrameLowering::emitSPAdjustment(MachineFunction &MF,
      .addReg(SP::O6).addReg(SP::G1);
  }
  
      .addReg(SP::O6).addReg(SP::G1);
  }
  
-void SparcFrameLowering::emitPrologue(MachineFunction &MF) const {
+void SparcFrameLowering::emitPrologue(MachineFunction &MF,
+                                      MachineBasicBlock &MBB) const {
    SparcMachineFunctionInfo *FuncInfo = MF.getInfo<SparcMachineFunctionInfo>();
  
    SparcMachineFunctionInfo *FuncInfo = MF.getInfo<SparcMachineFunctionInfo>();
  
-  MachineBasicBlock &MBB = MF.front();
+  assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
    MachineFrameInfo *MFI = MF.getFrameInfo();
    const SparcInstrInfo &TII =
        *static_cast<const SparcInstrInfo *>(MF.getSubtarget().getInstrInfo());
    MachineFrameInfo *MFI = MF.getFrameInfo();
    const SparcInstrInfo &TII =
        *static_cast<const SparcInstrInfo *>(MF.getSubtarget().getInstrInfo());
diff --git a/lib/Target/Sparc/SparcFrameLowering.h b/lib/Target/Sparc/SparcFrameLowering.h

index 9e53994e3c35b631ff7b40664bd8ea56d77dd415..bb3b78861cbd6db8e4c49f2075928ef9624db951 100644 (file)
--- a/lib/Target/Sparc/SparcFrameLowering.h
+++ b/lib/Target/Sparc/SparcFrameLowering.h
@@ -26,7 +26,7 @@ public:
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
-  void emitPrologue(MachineFunction &MF) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    void
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    void
diff --git a/lib/Target/SystemZ/SystemZFrameLowering.cpp b/lib/Target/SystemZ/SystemZFrameLowering.cpp

index eff4ae3baf3f506682f68d49941ac39682e5a8e3..a636b35635ce3041b5e0c5e6e024a9f8d2567176 100644 (file)
--- a/lib/Target/SystemZ/SystemZFrameLowering.cpp
+++ b/lib/Target/SystemZ/SystemZFrameLowering.cpp
@@ -309,8 +309,9 @@ static void emitIncrement(MachineBasicBlock &MBB,
    }
  }
  
    }
  }
  
-void SystemZFrameLowering::emitPrologue(MachineFunction &MF) const {
-  MachineBasicBlock &MBB = MF.front();
+void SystemZFrameLowering::emitPrologue(MachineFunction &MF,
+                                        MachineBasicBlock &MBB) const {
+  assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
    MachineFrameInfo *MFFrame = MF.getFrameInfo();
    auto *ZII =
        static_cast<const SystemZInstrInfo *>(MF.getSubtarget().getInstrInfo());
    MachineFrameInfo *MFFrame = MF.getFrameInfo();
    auto *ZII =
        static_cast<const SystemZInstrInfo *>(MF.getSubtarget().getInstrInfo());
diff --git a/lib/Target/SystemZ/SystemZFrameLowering.h b/lib/Target/SystemZ/SystemZFrameLowering.h

index cefa56fd74e5b79964bcc739c273da6ea73d4c7f..60bad894ee44d646e6d660e7f61dfcff72d87bed 100644 (file)
--- a/lib/Target/SystemZ/SystemZFrameLowering.h
+++ b/lib/Target/SystemZ/SystemZFrameLowering.h
@@ -40,7 +40,7 @@ public:
      override;
    void processFunctionBeforeFrameFinalized(MachineFunction &MF,
                                             RegScavenger *RS) const override;
      override;
    void processFunctionBeforeFrameFinalized(MachineFunction &MF,
                                             RegScavenger *RS) const override;
-  void emitPrologue(MachineFunction &MF) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
    bool hasFP(const MachineFunction &MF) const override;
    int getFrameIndexOffset(const MachineFunction &MF, int FI) const override;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
    bool hasFP(const MachineFunction &MF) const override;
    int getFrameIndexOffset(const MachineFunction &MF, int FI) const override;
diff --git a/lib/Target/X86/X86FrameLowering.cpp b/lib/Target/X86/X86FrameLowering.cpp

index 1d2c73c4308c72b7cde10aa9ef09178dcac1105c..a25643b2e2ebe74b2f337d1f32587508e4c3b606 100644 (file)
--- a/lib/Target/X86/X86FrameLowering.cpp
+++ b/lib/Target/X86/X86FrameLowering.cpp
@@ -565,8 +565,9 @@ static uint64_t calculateMaxStackAlign(const MachineFunction &MF) {
    - for 32-bit code, substitute %e?? registers for %r??
  */
  
    - for 32-bit code, substitute %e?? registers for %r??
  */
  
-void X86FrameLowering::emitPrologue(MachineFunction &MF) const {
-  MachineBasicBlock &MBB = MF.front(); // Prologue goes in entry BB.
+void X86FrameLowering::emitPrologue(MachineFunction &MF,
+                                    MachineBasicBlock &MBB) const {
+  assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
    MachineBasicBlock::iterator MBBI = MBB.begin();
    MachineFrameInfo *MFI = MF.getFrameInfo();
    const Function *Fn = MF.getFunction();
    MachineBasicBlock::iterator MBBI = MBB.begin();
    MachineFrameInfo *MFI = MF.getFrameInfo();
    const Function *Fn = MF.getFunction();
@@ -1590,9 +1591,10 @@ GetScratchRegister(bool Is64Bit, bool IsLP64, const MachineFunction &MF, bool Pr
  // limit.
  static const uint64_t kSplitStackAvailable = 256;
  
  // limit.
  static const uint64_t kSplitStackAvailable = 256;
  
-void
-X86FrameLowering::adjustForSegmentedStacks(MachineFunction &MF) const {
-  MachineBasicBlock &prologueMBB = MF.front();
+void X86FrameLowering::adjustForSegmentedStacks(
+    MachineFunction &MF, MachineBasicBlock &PrologueMBB) const {
+  assert(&PrologueMBB == &MF.front() &&
+         "Shrink-wrapping is not implemented yet");
    MachineFrameInfo *MFI = MF.getFrameInfo();
    const X86Subtarget &STI = MF.getSubtarget<X86Subtarget>();
    const TargetInstrInfo &TII = *STI.getInstrInfo();
    MachineFrameInfo *MFI = MF.getFrameInfo();
    const X86Subtarget &STI = MF.getSubtarget<X86Subtarget>();
    const TargetInstrInfo &TII = *STI.getInstrInfo();
@@ -1634,8 +1636,9 @@ X86FrameLowering::adjustForSegmentedStacks(MachineFunction &MF) const {
    // The MOV R10, RAX needs to be in a different block, since the RET we emit in
    // allocMBB needs to be last (terminating) instruction.
  
    // The MOV R10, RAX needs to be in a different block, since the RET we emit in
    // allocMBB needs to be last (terminating) instruction.
  
-  for (MachineBasicBlock::livein_iterator i = prologueMBB.livein_begin(),
-         e = prologueMBB.livein_end(); i != e; i++) {
+  for (MachineBasicBlock::livein_iterator i = PrologueMBB.livein_begin(),
+                                          e = PrologueMBB.livein_end();
+       i != e; i++) {
      allocMBB->addLiveIn(*i);
      checkMBB->addLiveIn(*i);
    }
      allocMBB->addLiveIn(*i);
      checkMBB->addLiveIn(*i);
    }
@@ -1749,7 +1752,7 @@ X86FrameLowering::adjustForSegmentedStacks(MachineFunction &MF) const {
  
    // This jump is taken if SP >= (Stacklet Limit + Stack Space required).
    // It jumps to normal execution of the function body.
  
    // This jump is taken if SP >= (Stacklet Limit + Stack Space required).
    // It jumps to normal execution of the function body.
-  BuildMI(checkMBB, DL, TII.get(X86::JA_1)).addMBB(&prologueMBB);
+  BuildMI(checkMBB, DL, TII.get(X86::JA_1)).addMBB(&PrologueMBB);
  
    // On 32 bit we first push the arguments size and then the frame size. On 64
    // bit, we pass the stack frame size in r10 and the argument size in r11.
  
    // On 32 bit we first push the arguments size and then the frame size. On 64
    // bit, we pass the stack frame size in r10 and the argument size in r11.
@@ -1816,10 +1819,10 @@ X86FrameLowering::adjustForSegmentedStacks(MachineFunction &MF) const {
    else
      BuildMI(allocMBB, DL, TII.get(X86::MORESTACK_RET));
  
    else
      BuildMI(allocMBB, DL, TII.get(X86::MORESTACK_RET));
  
-  allocMBB->addSuccessor(&prologueMBB);
+  allocMBB->addSuccessor(&PrologueMBB);
  
    checkMBB->addSuccessor(allocMBB);
  
    checkMBB->addSuccessor(allocMBB);
-  checkMBB->addSuccessor(&prologueMBB);
+  checkMBB->addSuccessor(&PrologueMBB);
  
  #ifdef XDEBUG
    MF.verify();
  
  #ifdef XDEBUG
    MF.verify();
@@ -1841,7 +1844,8 @@ X86FrameLowering::adjustForSegmentedStacks(MachineFunction &MF) const {
  ///       call inc_stack   # doubles the stack space
  ///       temp0 = sp - MaxStack
  ///       if( temp0 < SP_LIMIT(P) ) goto IncStack else goto OldStart
  ///       call inc_stack   # doubles the stack space
  ///       temp0 = sp - MaxStack
  ///       if( temp0 < SP_LIMIT(P) ) goto IncStack else goto OldStart
-void X86FrameLowering::adjustForHiPEPrologue(MachineFunction &MF) const {
+void X86FrameLowering::adjustForHiPEPrologue(
+    MachineFunction &MF, MachineBasicBlock &PrologueMBB) const {
    const X86Subtarget &STI = MF.getSubtarget<X86Subtarget>();
    const TargetInstrInfo &TII = *STI.getInstrInfo();
    MachineFrameInfo *MFI = MF.getFrameInfo();
    const X86Subtarget &STI = MF.getSubtarget<X86Subtarget>();
    const TargetInstrInfo &TII = *STI.getInstrInfo();
    MachineFrameInfo *MFI = MF.getFrameInfo();
@@ -1910,12 +1914,14 @@ void X86FrameLowering::adjustForHiPEPrologue(MachineFunction &MF) const {
    // If the stack frame needed is larger than the guaranteed then runtime checks
    // and calls to "inc_stack_0" BIF should be inserted in the assembly prologue.
    if (MaxStack > Guaranteed) {
    // If the stack frame needed is larger than the guaranteed then runtime checks
    // and calls to "inc_stack_0" BIF should be inserted in the assembly prologue.
    if (MaxStack > Guaranteed) {
-    MachineBasicBlock &prologueMBB = MF.front();
+    assert(&PrologueMBB == &MF.front() &&
+           "Shrink-wrapping is not implemented yet");
      MachineBasicBlock *stackCheckMBB = MF.CreateMachineBasicBlock();
      MachineBasicBlock *incStackMBB = MF.CreateMachineBasicBlock();
  
      MachineBasicBlock *stackCheckMBB = MF.CreateMachineBasicBlock();
      MachineBasicBlock *incStackMBB = MF.CreateMachineBasicBlock();
  
-    for (MachineBasicBlock::livein_iterator I = prologueMBB.livein_begin(),
-           E = prologueMBB.livein_end(); I != E; I++) {
+    for (MachineBasicBlock::livein_iterator I = PrologueMBB.livein_begin(),
+                                            E = PrologueMBB.livein_end();
+         I != E; I++) {
        stackCheckMBB->addLiveIn(*I);
        incStackMBB->addLiveIn(*I);
      }
        stackCheckMBB->addLiveIn(*I);
        incStackMBB->addLiveIn(*I);
      }
@@ -1951,7 +1957,7 @@ void X86FrameLowering::adjustForHiPEPrologue(MachineFunction &MF) const {
      // SPLimitOffset is in a fixed heap location (pointed by BP).
      addRegOffset(BuildMI(stackCheckMBB, DL, TII.get(CMPop))
                   .addReg(ScratchReg), PReg, false, SPLimitOffset);
      // SPLimitOffset is in a fixed heap location (pointed by BP).
      addRegOffset(BuildMI(stackCheckMBB, DL, TII.get(CMPop))
                   .addReg(ScratchReg), PReg, false, SPLimitOffset);
-    BuildMI(stackCheckMBB, DL, TII.get(X86::JAE_1)).addMBB(&prologueMBB);
+    BuildMI(stackCheckMBB, DL, TII.get(X86::JAE_1)).addMBB(&PrologueMBB);
  
      // Create new MBB for IncStack:
      BuildMI(incStackMBB, DL, TII.get(CALLop)).
  
      // Create new MBB for IncStack:
      BuildMI(incStackMBB, DL, TII.get(CALLop)).
@@ -1962,9 +1968,9 @@ void X86FrameLowering::adjustForHiPEPrologue(MachineFunction &MF) const {
                   .addReg(ScratchReg), PReg, false, SPLimitOffset);
      BuildMI(incStackMBB, DL, TII.get(X86::JLE_1)).addMBB(incStackMBB);
  
                   .addReg(ScratchReg), PReg, false, SPLimitOffset);
      BuildMI(incStackMBB, DL, TII.get(X86::JLE_1)).addMBB(incStackMBB);
  
-    stackCheckMBB->addSuccessor(&prologueMBB, 99);
+    stackCheckMBB->addSuccessor(&PrologueMBB, 99);
      stackCheckMBB->addSuccessor(incStackMBB, 1);
      stackCheckMBB->addSuccessor(incStackMBB, 1);
-    incStackMBB->addSuccessor(&prologueMBB, 99);
+    incStackMBB->addSuccessor(&PrologueMBB, 99);
      incStackMBB->addSuccessor(incStackMBB, 1);
    }
  #ifdef XDEBUG
      incStackMBB->addSuccessor(incStackMBB, 1);
    }
  #ifdef XDEBUG
diff --git a/lib/Target/X86/X86FrameLowering.h b/lib/Target/X86/X86FrameLowering.h

index 542bbbc79ae404ae70a97cd550a0a3a5df270ba3..a23bce9745e2707d31d69a5c4740128221372985 100644 (file)
--- a/lib/Target/X86/X86FrameLowering.h
+++ b/lib/Target/X86/X86FrameLowering.h
@@ -35,12 +35,14 @@ public:
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
  
    /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
    /// the function.
-  void emitPrologue(MachineFunction &MF) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
    void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  
-  void adjustForSegmentedStacks(MachineFunction &MF) const override;
+  void adjustForSegmentedStacks(MachineFunction &MF,
+                                MachineBasicBlock &PrologueMBB) const override;
  
  
-  void adjustForHiPEPrologue(MachineFunction &MF) const override;
+  void adjustForHiPEPrologue(MachineFunction &MF,
+                             MachineBasicBlock &PrologueMBB) const override;
  
    void processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
                                       RegScavenger *RS = nullptr) const override;
  
    void processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
                                       RegScavenger *RS = nullptr) const override;
diff --git a/lib/Target/XCore/XCoreFrameLowering.cpp b/lib/Target/XCore/XCoreFrameLowering.cpp

index e0ac0e56781c4afffaedea5335f6fe67fc1973cc..bd834cc5be4b69d074fe251e1b44f4496d5e1fd3 100644 (file)
--- a/lib/Target/XCore/XCoreFrameLowering.cpp
+++ b/lib/Target/XCore/XCoreFrameLowering.cpp
@@ -220,8 +220,9 @@ bool XCoreFrameLowering::hasFP(const MachineFunction &MF) const {
           MF.getFrameInfo()->hasVarSizedObjects();
  }
  
           MF.getFrameInfo()->hasVarSizedObjects();
  }
  
-void XCoreFrameLowering::emitPrologue(MachineFunction &MF) const {
-  MachineBasicBlock &MBB = MF.front();   // Prolog goes in entry BB
+void XCoreFrameLowering::emitPrologue(MachineFunction &MF,
+                                      MachineBasicBlock &MBB) const {
+  assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
    MachineBasicBlock::iterator MBBI = MBB.begin();
    MachineFrameInfo *MFI = MF.getFrameInfo();
    MachineModuleInfo *MMI = &MF.getMMI();
    MachineBasicBlock::iterator MBBI = MBB.begin();
    MachineFrameInfo *MFI = MF.getFrameInfo();
    MachineModuleInfo *MMI = &MF.getMMI();
diff --git a/lib/Target/XCore/XCoreFrameLowering.h b/lib/Target/XCore/XCoreFrameLowering.h

index 7b169c2b8cdda85255f4b45a0903936cfe8b91fc..607c7724895269cd59677ba80f5c7c2e53dee28f 100644 (file)
--- a/lib/Target/XCore/XCoreFrameLowering.h
+++ b/lib/Target/XCore/XCoreFrameLowering.h
@@ -27,7 +27,8 @@ namespace llvm {
  
      /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
      /// the function.
  
      /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
      /// the function.
-    void emitPrologue(MachineFunction &MF) const override;
+    void emitPrologue(MachineFunction &MF,
+                      MachineBasicBlock &MBB) const override;
      void emitEpilogue(MachineFunction &MF,
                        MachineBasicBlock &MBB) const override;
  
      void emitEpilogue(MachineFunction &MF,
                        MachineBasicBlock &MBB) const override;
  
diff --git a/test/CodeGen/AArch64/arm64-shrink-wrapping.ll b/test/CodeGen/AArch64/arm64-shrink-wrapping.ll

new file mode 100644 (file)

index 0000000..c177751
--- /dev/null
+++ b/test/CodeGen/AArch64/arm64-shrink-wrapping.ll
@@ -0,0 +1,502 @@
+; RUN: llc %s -o - -enable-shrink-wrap=true | FileCheck %s --check-prefix=CHECK --check-prefix=ENABLE
+; RUN: llc %s -o - -enable-shrink-wrap=false | FileCheck %s --check-prefix=CHECK --check-prefix=DISABLE
+target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
+target triple = "arm64-apple-ios"
+
+
+; Initial motivating example: Simple diamond with a call just on one side.
+; CHECK-LABEL: foo:
+;
+; Compare the arguments and jump to exit.
+; No prologue needed.
+; ENABLE: cmp w0, w1
+; ENABLE-NEXT: b.ge [[EXIT_LABEL:LBB[0-9_]+]]
+;
+; Prologue code.
+; CHECK: stp [[SAVE_SP:x[0-9]+]], [[CSR:x[0-9]+]], [sp, #-16]!
+; CHECK-NEXT: mov [[SAVE_SP]], sp
+; CHECK-NEXT: sub sp, sp, #16
+;
+; Compare the arguments and jump to exit.
+; After the prologue is set.
+; DISABLE: cmp w0, w1
+; DISABLE-NEXT: b.ge [[EXIT_LABEL:LBB[0-9_]+]]
+;
+; Store %a in the alloca.
+; CHECK: stur w0, {{\[}}[[SAVE_SP]], #-4]
+; Set the alloca address in the second argument.
+; CHECK-NEXT: sub x1, [[SAVE_SP]], #4
+; Set the first argument to zero.
+; CHECK-NEXT: mov w0, wzr
+; CHECK-NEXT: bl _doSomething
+; 
+; Without shrink-wrapping, epilogue is in the exit block.
+; DISABLE: [[EXIT_LABEL]]:
+; Epilogue code.
+; CHECK-NEXT: mov sp, [[SAVE_SP]]
+; CHECK-NEXT: ldp [[SAVE_SP]], [[CSR]], [sp], #16
+;
+; With shrink-wrapping, exit block is a simple return.
+; ENABLE: [[EXIT_LABEL]]:
+; CHECK-NEXT: ret
+define i32 @foo(i32 %a, i32 %b) {
+  %tmp = alloca i32, align 4
+  %tmp2 = icmp slt i32 %a, %b
+  br i1 %tmp2, label %true, label %false
+
+true:
+  store i32 %a, i32* %tmp, align 4
+  %tmp4 = call i32 @doSomething(i32 0, i32* %tmp)
+  br label %false
+
+false:
+  %tmp.0 = phi i32 [ %tmp4, %true ], [ %a, %0 ]
+  ret i32 %tmp.0
+}
+
+; Function Attrs: optsize
+declare i32 @doSomething(i32, i32*)
+
+
+; Check that we do not perform the restore inside the loop whereas the save
+; is outside.
+; CHECK-LABEL: freqSaveAndRestoreOutsideLoop:
+;
+; Shrink-wrapping allows to skip the prologue in the else case.
+; ENABLE: cbz w0, [[ELSE_LABEL:LBB[0-9_]+]]
+;
+; Prologue code.
+; CHECK: stp [[CSR1:x[0-9]+]], [[CSR2:x[0-9]+]], [sp, #-32]!
+; CHECK-NEXT: stp [[CSR3:x[0-9]+]], [[CSR4:x[0-9]+]], [sp, #16]
+; CHECK-NEXT: add [[NEW_SP:x[0-9]+]], sp, #16
+;
+; DISABLE: cbz w0, [[ELSE_LABEL:LBB[0-9_]+]]
+;
+; CHECK: mov [[SUM:w[0-9]+]], wzr
+; CHECK-NEXT: movz [[IV:w[0-9]+]], #0xa
+;
+; Next BB.
+; CHECK: [[LOOP:LBB[0-9_]+]]: ; %for.body
+; CHECK: bl _something
+; CHECK-NEXT: add [[SUM]], w0, [[SUM]]
+; CHECK-NEXT: sub [[IV]], [[IV]], #1
+; CHECK-NEXT: cbnz [[IV]], [[LOOP]]
+;
+; Next BB.
+; Copy SUM into the returned register + << 3.
+; CHECK: lsl w0, [[SUM]], #3
+;
+; Jump to epilogue.
+; DISABLE: b [[EPILOG_BB:LBB[0-9_]+]]
+;
+; DISABLE: [[ELSE_LABEL]]: ; %if.else
+; Shift second argument by one and store into returned register.
+; DISABLE: lsl w0, w1, #1
+; DISABLE: [[EPILOG_BB]]: ; %if.end
+;
+; Epilogue code.
+; CHECK: ldp [[CSR3]], [[CSR4]], [sp, #16]
+; CHECK-NEXT: ldp [[CSR1]], [[CSR2]], [sp], #32
+; CHECK-NEXT: ret
+;
+; ENABLE: [[ELSE_LABEL]]: ; %if.else
+; Shift second argument by one and store into returned register.
+; ENABLE: lsl w0, w1, #1
+; ENABLE: ret
+define i32 @freqSaveAndRestoreOutsideLoop(i32 %cond, i32 %N) {
+entry:
+  %tobool = icmp eq i32 %cond, 0
+  br i1 %tobool, label %if.else, label %for.body
+
+for.body:                                         ; preds = %entry, %for.body
+  %i.05 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
+  %sum.04 = phi i32 [ %add, %for.body ], [ 0, %entry ]
+  %call = tail call i32 bitcast (i32 (...)* @something to i32 ()*)()
+  %add = add nsw i32 %call, %sum.04
+  %inc = add nuw nsw i32 %i.05, 1
+  %exitcond = icmp eq i32 %inc, 10
+  br i1 %exitcond, label %for.end, label %for.body
+
+for.end:                                          ; preds = %for.body
+  %shl = shl i32 %add, 3
+  br label %if.end
+
+if.else:                                          ; preds = %entry
+  %mul = shl nsw i32 %N, 1
+  br label %if.end
+
+if.end:                                           ; preds = %if.else, %for.end
+  %sum.1 = phi i32 [ %shl, %for.end ], [ %mul, %if.else ]
+  ret i32 %sum.1
+}
+
+declare i32 @something(...)
+
+; Check that we do not perform the shrink-wrapping inside the loop even
+; though that would be legal. The cost model must prevent that.
+; CHECK-LABEL: freqSaveAndRestoreOutsideLoop2:
+; Prologue code.
+; CHECK: stp [[CSR1:x[0-9]+]], [[CSR2:x[0-9]+]], [sp, #-32]!
+; CHECK-NEXT: stp [[CSR3:x[0-9]+]], [[CSR4:x[0-9]+]], [sp, #16]
+; CHECK-NEXT: add [[NEW_SP:x[0-9]+]], sp, #16
+; CHECK: mov [[SUM:w[0-9]+]], wzr
+; CHECK-NEXT: movz [[IV:w[0-9]+]], #0xa
+; Next BB.
+; CHECK: [[LOOP_LABEL:LBB[0-9_]+]]: ; %for.body
+; CHECK: bl _something
+; CHECK-NEXT: add [[SUM]], w0, [[SUM]]
+; CHECK-NEXT: sub [[IV]], [[IV]], #1
+; CHECK-NEXT: cbnz [[IV]], [[LOOP_LABEL]]
+; Next BB.
+; CHECK: ; %for.end
+; CHECK: mov w0, [[SUM]]
+; CHECK-NEXT: ldp [[CSR3]], [[CSR4]], [sp, #16]
+; CHECK-NEXT: ldp [[CSR1]], [[CSR2]], [sp], #32
+; CHECK-NEXT: ret
+define i32 @freqSaveAndRestoreOutsideLoop2(i32 %cond) {
+entry:
+  br label %for.body
+
+for.body:                                         ; preds = %for.body, %entry
+  %i.04 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
+  %sum.03 = phi i32 [ 0, %entry ], [ %add, %for.body ]
+  %call = tail call i32 bitcast (i32 (...)* @something to i32 ()*)()
+  %add = add nsw i32 %call, %sum.03
+  %inc = add nuw nsw i32 %i.04, 1
+  %exitcond = icmp eq i32 %inc, 10
+  br i1 %exitcond, label %for.end, label %for.body
+
+for.end:                                          ; preds = %for.body
+  ret i32 %add
+}
+
+; Check with a more complex case that we do not have save within the loop and
+; restore outside.
+; CHECK-LABEL: loopInfoSaveOutsideLoop:
+;
+; ENABLE: cbz w0, [[ELSE_LABEL:LBB[0-9_]+]]
+;
+; Prologue code.
+; CHECK: stp [[CSR1:x[0-9]+]], [[CSR2:x[0-9]+]], [sp, #-32]!
+; CHECK-NEXT: stp [[CSR3:x[0-9]+]], [[CSR4:x[0-9]+]], [sp, #16]
+; CHECK-NEXT: add [[NEW_SP:x[0-9]+]], sp, #16
+;
+; DISABLE: cbz w0, [[ELSE_LABEL:LBB[0-9_]+]]
+;
+; CHECK: mov [[SUM:w[0-9]+]], wzr
+; CHECK-NEXT: movz [[IV:w[0-9]+]], #0xa
+;
+; CHECK: [[LOOP_LABEL:LBB[0-9_]+]]: ; %for.body
+; CHECK: bl _something
+; CHECK-NEXT: add [[SUM]], w0, [[SUM]]
+; CHECK-NEXT: sub [[IV]], [[IV]], #1
+; CHECK-NEXT: cbnz [[IV]], [[LOOP_LABEL]]
+; Next BB.
+; CHECK: bl _somethingElse
+; CHECK-NEXT: lsl w0, [[SUM]], #3
+;
+; Jump to epilogue.
+; DISABLE: b [[EPILOG_BB:LBB[0-9_]+]]
+;
+; DISABLE: [[ELSE_LABEL]]: ; %if.else
+; Shift second argument by one and store into returned register.
+; DISABLE: lsl w0, w1, #1
+; DISABLE: [[EPILOG_BB]]: ; %if.end
+; Epilogue code.
+; CHECK-NEXT: ldp [[CSR3]], [[CSR4]], [sp, #16]
+; CHECK-NEXT: ldp [[CSR1]], [[CSR2]], [sp], #32
+; CHECK-NEXT: ret
+;
+; ENABLE: [[ELSE_LABEL]]: ; %if.else
+; Shift second argument by one and store into returned register.
+; ENABLE: lsl w0, w1, #1
+; ENABLE: ret
+define i32 @loopInfoSaveOutsideLoop(i32 %cond, i32 %N) {
+entry:
+  %tobool = icmp eq i32 %cond, 0
+  br i1 %tobool, label %if.else, label %for.body
+
+for.body:                                         ; preds = %entry, %for.body
+  %i.05 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
+  %sum.04 = phi i32 [ %add, %for.body ], [ 0, %entry ]
+  %call = tail call i32 bitcast (i32 (...)* @something to i32 ()*)()
+  %add = add nsw i32 %call, %sum.04
+  %inc = add nuw nsw i32 %i.05, 1
+  %exitcond = icmp eq i32 %inc, 10
+  br i1 %exitcond, label %for.end, label %for.body
+
+for.end:                                          ; preds = %for.body
+  tail call void bitcast (void (...)* @somethingElse to void ()*)()
+  %shl = shl i32 %add, 3
+  br label %if.end
+
+if.else:                                          ; preds = %entry
+  %mul = shl nsw i32 %N, 1
+  br label %if.end
+
+if.end:                                           ; preds = %if.else, %for.end
+  %sum.1 = phi i32 [ %shl, %for.end ], [ %mul, %if.else ]
+  ret i32 %sum.1
+}
+
+declare void @somethingElse(...)
+
+; Check with a more complex case that we do not have restore within the loop and
+; save outside.
+; CHECK-LABEL: loopInfoRestoreOutsideLoop:
+;
+; ENABLE: cbz w0, [[ELSE_LABEL:LBB[0-9_]+]]
+;
+; CHECK: stp [[CSR1:x[0-9]+]], [[CSR2:x[0-9]+]], [sp, #-32]!
+; CHECK-NEXT: stp [[CSR3:x[0-9]+]], [[CSR4:x[0-9]+]], [sp, #16]
+; CHECK-NEXT: add [[NEW_SP:x[0-9]+]], sp, #16
+;
+; DISABLE: cbz w0, [[ELSE_LABEL:LBB[0-9_]+]]
+;
+; CHECK: bl _somethingElse
+; CHECK-NEXT: mov [[SUM:w[0-9]+]], wzr
+; CHECK-NEXT: movz [[IV:w[0-9]+]], #0xa
+;
+; CHECK: [[LOOP_LABEL:LBB[0-9_]+]]: ; %for.body
+; CHECK: bl _something
+; CHECK-NEXT: add [[SUM]], w0, [[SUM]]
+; CHECK-NEXT: sub [[IV]], [[IV]], #1
+; CHECK-NEXT: cbnz [[IV]], [[LOOP_LABEL]]
+; Next BB.
+; CHECK: lsl w0, [[SUM]], #3
+;
+; Jump to epilogue.
+; DISABLE: b [[EPILOG_BB:LBB[0-9_]+]]
+;
+; DISABLE: [[ELSE_LABEL]]: ; %if.else
+; Shift second argument by one and store into returned register.
+; DISABLE: lsl w0, w1, #1
+; DISABLE: [[EPILOG_BB]]: ; %if.end
+; Epilogue code.
+; CHECK: ldp [[CSR3]], [[CSR4]], [sp, #16]
+; CHECK-NEXT: ldp [[CSR1]], [[CSR2]], [sp], #32
+; CHECK-NEXT: ret
+;
+; ENABLE: [[ELSE_LABEL]]: ; %if.else
+; Shift second argument by one and store into returned register.
+; ENABLE: lsl w0, w1, #1
+; ENABLE: ret
+define i32 @loopInfoRestoreOutsideLoop(i32 %cond, i32 %N) #0 {
+entry:
+  %tobool = icmp eq i32 %cond, 0
+  br i1 %tobool, label %if.else, label %if.then
+
+if.then:                                          ; preds = %entry
+  tail call void bitcast (void (...)* @somethingElse to void ()*)()
+  br label %for.body
+
+for.body:                                         ; preds = %for.body, %if.then
+  %i.05 = phi i32 [ 0, %if.then ], [ %inc, %for.body ]
+  %sum.04 = phi i32 [ 0, %if.then ], [ %add, %for.body ]
+  %call = tail call i32 bitcast (i32 (...)* @something to i32 ()*)()
+  %add = add nsw i32 %call, %sum.04
+  %inc = add nuw nsw i32 %i.05, 1
+  %exitcond = icmp eq i32 %inc, 10
+  br i1 %exitcond, label %for.end, label %for.body
+
+for.end:                                          ; preds = %for.body
+  %shl = shl i32 %add, 3
+  br label %if.end
+
+if.else:                                          ; preds = %entry
+  %mul = shl nsw i32 %N, 1
+  br label %if.end
+
+if.end:                                           ; preds = %if.else, %for.end
+  %sum.1 = phi i32 [ %shl, %for.end ], [ %mul, %if.else ]
+  ret i32 %sum.1
+}
+
+; Check that we handle function with no frame information correctly.
+; CHECK-LABEL: emptyFrame:
+; CHECK: ; %entry
+; CHECK-NEXT: mov w0, wzr
+; CHECK-NEXT: ret
+define i32 @emptyFrame() {
+entry:
+  ret i32 0
+}
+
+; Check that we handle variadic function correctly.
+; CHECK-LABEL: variadicFunc:
+;
+; ENABLE: cbz w0, [[ELSE_LABEL:LBB[0-9_]+]]
+;
+; Prologue code.
+; CHECK: sub sp, sp, #16
+; DISABLE: cbz w0, [[ELSE_LABEL:LBB[0-9_]+]]
+;
+; Sum is merged with the returned register.
+; CHECK: mov [[SUM:w0]], wzr
+; CHECK-NEXT: add [[VA_BASE:x[0-9]+]], sp, #16
+; CHECK-NEXT: str [[VA_BASE]], [sp, #8]
+; CHECK-NEXT: cmp w1, #1
+; CHECK-NEXT: b.lt [[IFEND_LABEL:LBB[0-9_]+]]
+;
+; CHECK: [[LOOP_LABEL:LBB[0-9_]+]]: ; %for.body
+; CHECK: ldr [[VA_ADDR:x[0-9]+]], [sp, #8]
+; CHECK-NEXT: add [[NEXT_VA_ADDR:x[0-9]+]], [[VA_ADDR]], #8
+; CHECK-NEXT: str [[NEXT_VA_ADDR]], [sp, #8]
+; CHECK-NEXT: ldr [[VA_VAL:w[0-9]+]], {{\[}}[[VA_ADDR]]]
+; CHECK-NEXT: add [[SUM]], [[SUM]], [[VA_VAL]]
+; CHECK-NEXT: sub w1, w1, #1
+; CHECK-NEXT: cbnz w1, [[LOOP_LABEL]]
+;
+; DISABLE-NEXT: b [[IFEND_LABEL]]
+; DISABLE: [[ELSE_LABEL]]: ; %if.else
+; DISABLE: lsl w0, w1, #1
+;
+; CHECK: [[IFEND_LABEL]]:
+; Epilogue code.
+; CHECK: add sp, sp, #16
+; CHECK-NEXT: ret
+;
+; ENABLE: [[ELSE_LABEL]]: ; %if.else
+; ENABLE: lsl w0, w1, #1
+; ENABLE-NEXT: ret
+define i32 @variadicFunc(i32 %cond, i32 %count, ...) #0 {
+entry:
+  %ap = alloca i8*, align 8
+  %tobool = icmp eq i32 %cond, 0
+  br i1 %tobool, label %if.else, label %if.then
+
+if.then:                                          ; preds = %entry
+  %ap1 = bitcast i8** %ap to i8*
+  call void @llvm.va_start(i8* %ap1)
+  %cmp6 = icmp sgt i32 %count, 0
+  br i1 %cmp6, label %for.body, label %for.end
+
+for.body:                                         ; preds = %if.then, %for.body
+  %i.08 = phi i32 [ %inc, %for.body ], [ 0, %if.then ]
+  %sum.07 = phi i32 [ %add, %for.body ], [ 0, %if.then ]
+  %0 = va_arg i8** %ap, i32
+  %add = add nsw i32 %sum.07, %0
+  %inc = add nuw nsw i32 %i.08, 1
+  %exitcond = icmp eq i32 %inc, %count
+  br i1 %exitcond, label %for.end, label %for.body
+
+for.end:                                          ; preds = %for.body, %if.then
+  %sum.0.lcssa = phi i32 [ 0, %if.then ], [ %add, %for.body ]
+  call void @llvm.va_end(i8* %ap1)
+  br label %if.end
+
+if.else:                                          ; preds = %entry
+  %mul = shl nsw i32 %count, 1
+  br label %if.end
+
+if.end:                                           ; preds = %if.else, %for.end
+  %sum.1 = phi i32 [ %sum.0.lcssa, %for.end ], [ %mul, %if.else ]
+  ret i32 %sum.1
+}
+
+declare void @llvm.va_start(i8*)
+
+declare void @llvm.va_end(i8*)
+
+; Check that we handle inline asm correctly.
+; CHECK-LABEL: inlineAsm:
+;
+; ENABLE: cbz w0, [[ELSE_LABEL:LBB[0-9_]+]]
+;
+; Prologue code.
+; Make sure we save the CSR used in the inline asm: x19.
+; CHECK: stp [[CSR1:x[0-9]+]], [[CSR2:x19]], [sp, #-16]!
+;
+; DISABLE: cbz w0, [[ELSE_LABEL:LBB[0-9_]+]]
+;
+; CHECK: movz [[IV:w[0-9]+]], #0xa
+;
+; CHECK: [[LOOP_LABEL:LBB[0-9_]+]]: ; %for.body
+; Inline asm statement.
+; CHECK: add x19, x19, #1
+; CHECK: sub [[IV]], [[IV]], #1
+; CHECK-NEXT: cbnz [[IV]], [[LOOP_LABEL]]
+; Next BB.
+; CHECK: mov w0, wzr
+; Epilogue code.
+; CHECK-NEXT: ldp [[CSR1]], [[CSR2]], [sp], #16
+; CHECK-NEXT: ret
+; Next BB.
+; CHECK: [[ELSE_LABEL]]: ; %if.else
+; CHECK-NEXT: lsl w0, w1, #1
+; Epilogue code.
+; DISABLE-NEXT: ldp [[CSR1]], [[CSR2]], [sp], #16
+; CHECK-NEXT: ret
+define i32 @inlineAsm(i32 %cond, i32 %N) {
+entry:
+  %tobool = icmp eq i32 %cond, 0
+  br i1 %tobool, label %if.else, label %for.body
+
+for.body:                                         ; preds = %entry, %for.body
+  %i.03 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
+  tail call void asm sideeffect "add x19, x19, #1", "~{x19}"()
+  %inc = add nuw nsw i32 %i.03, 1
+  %exitcond = icmp eq i32 %inc, 10
+  br i1 %exitcond, label %if.end, label %for.body
+
+if.else:                                          ; preds = %entry
+  %mul = shl nsw i32 %N, 1
+  br label %if.end
+
+if.end:                                           ; preds = %for.body, %if.else
+  %sum.0 = phi i32 [ %mul, %if.else ], [ 0, %for.body ]
+  ret i32 %sum.0
+}
+
+; Check that we handle calls to variadic functions correctly.
+; CHECK-LABEL: callVariadicFunc:
+;
+; ENABLE: cbz w0, [[ELSE_LABEL:LBB[0-9_]+]]
+;
+; Prologue code.
+; CHECK: stp [[CSR1:x[0-9]+]], [[CSR2:x[0-9]+]], [sp, #-16]!
+; CHECK-NEXT: mov [[NEW_SP:x[0-9]+]], sp
+; CHECK-NEXT: sub sp, sp, #48
+;
+; DISABLE: cbz w0, [[ELSE_LABEL:LBB[0-9_]+]]
+; Setup of the varags.
+; CHECK: stp x1, x1, [sp, #32]
+; CHECK-NEXT: stp x1, x1, [sp, #16]
+; CHECK-NEXT: stp x1, x1, [sp]
+; CHECK-NEXT: mov w0, w1
+; CHECK-NEXT: bl _someVariadicFunc
+; CHECK-NEXT: lsl w0, w0, #3
+;
+; DISABLE: b [[IFEND_LABEL:LBB[0-9_]+]]
+; DISABLE: [[ELSE_LABEL]]: ; %if.else
+; DISABLE-NEXT: lsl w0, w1, #1
+; DISABLE: [[IFEND_LABEL]]: ; %if.end
+;
+; Epilogue code.
+; CHECK: mov sp, [[NEW_SP]]
+; CHECK-NEXT: ldp [[CSR1]], [[CSR2]], [sp], #16
+; CHECK-NEXT: ret
+;
+; ENABLE: [[ELSE_LABEL]]: ; %if.else
+; ENABLE-NEXT: lsl w0, w1, #1
+; ENABLE-NEXT: ret
+define i32 @callVariadicFunc(i32 %cond, i32 %N) {
+entry:
+  %tobool = icmp eq i32 %cond, 0
+  br i1 %tobool, label %if.else, label %if.then
+
+if.then:                                          ; preds = %entry
+  %call = tail call i32 (i32, ...) @someVariadicFunc(i32 %N, i32 %N, i32 %N, i32 %N, i32 %N, i32 %N, i32 %N)
+  %shl = shl i32 %call, 3
+  br label %if.end
+
+if.else:                                          ; preds = %entry
+  %mul = shl nsw i32 %N, 1
+  br label %if.end
+
+if.end:                                           ; preds = %if.else, %if.then
+  %sum.0 = phi i32 [ %shl, %if.then ], [ %mul, %if.else ]
+  ret i32 %sum.0
+}
+
+declare i32 @someVariadicFunc(i32, ...)
author	Quentin Colombet <qcolombet@apple.com>
	Tue, 5 May 2015 17:38:16 +0000 (17:38 +0000)
committer	Quentin Colombet <qcolombet@apple.com>
	Tue, 5 May 2015 17:38:16 +0000 (17:38 +0000)
include/llvm/CodeGen/MachineFrameInfo.h		patch \| blob \| history
include/llvm/CodeGen/Passes.h		patch \| blob \| history
include/llvm/InitializePasses.h		patch \| blob \| history
include/llvm/Target/TargetFrameLowering.h		patch \| blob \| history
lib/CodeGen/CMakeLists.txt		patch \| blob \| history
lib/CodeGen/CodeGen.cpp		patch \| blob \| history
lib/CodeGen/MachineFunction.cpp		patch \| blob \| history
lib/CodeGen/Passes.cpp		patch \| blob \| history
lib/CodeGen/PrologEpilogInserter.cpp		patch \| blob \| history
lib/CodeGen/ShrinkWrap.cpp	[new file with mode: 0644]	patch \| blob
lib/Target/AArch64/AArch64FrameLowering.cpp		patch \| blob \| history
lib/Target/AArch64/AArch64FrameLowering.h		patch \| blob \| history
lib/Target/ARM/ARMFrameLowering.cpp		patch \| blob \| history
lib/Target/ARM/ARMFrameLowering.h		patch \| blob \| history
lib/Target/ARM/Thumb1FrameLowering.cpp		patch \| blob \| history
lib/Target/ARM/Thumb1FrameLowering.h		patch \| blob \| history
lib/Target/BPF/BPFFrameLowering.cpp		patch \| blob \| history
lib/Target/BPF/BPFFrameLowering.h		patch \| blob \| history
lib/Target/Hexagon/HexagonFrameLowering.cpp		patch \| blob \| history
lib/Target/Hexagon/HexagonFrameLowering.h		patch \| blob \| history
lib/Target/MSP430/MSP430FrameLowering.cpp		patch \| blob \| history
lib/Target/MSP430/MSP430FrameLowering.h		patch \| blob \| history
lib/Target/Mips/Mips16FrameLowering.cpp		patch \| blob \| history
lib/Target/Mips/Mips16FrameLowering.h		patch \| blob \| history
lib/Target/Mips/MipsSEFrameLowering.cpp		patch \| blob \| history
lib/Target/Mips/MipsSEFrameLowering.h		patch \| blob \| history
lib/Target/NVPTX/NVPTXFrameLowering.cpp		patch \| blob \| history
lib/Target/NVPTX/NVPTXFrameLowering.h		patch \| blob \| history
lib/Target/NVPTX/NVPTXPrologEpilogPass.cpp		patch \| blob \| history
lib/Target/PowerPC/PPCFrameLowering.cpp		patch \| blob \| history
lib/Target/PowerPC/PPCFrameLowering.h		patch \| blob \| history
lib/Target/R600/AMDGPUFrameLowering.cpp		patch \| blob \| history
lib/Target/R600/AMDGPUFrameLowering.h		patch \| blob \| history
lib/Target/Sparc/SparcFrameLowering.cpp		patch \| blob \| history
lib/Target/Sparc/SparcFrameLowering.h		patch \| blob \| history
lib/Target/SystemZ/SystemZFrameLowering.cpp		patch \| blob \| history
lib/Target/SystemZ/SystemZFrameLowering.h		patch \| blob \| history
lib/Target/X86/X86FrameLowering.cpp		patch \| blob \| history
lib/Target/X86/X86FrameLowering.h		patch \| blob \| history
lib/Target/XCore/XCoreFrameLowering.cpp		patch \| blob \| history
lib/Target/XCore/XCoreFrameLowering.h		patch \| blob \| history
test/CodeGen/AArch64/arm64-shrink-wrapping.ll	[new file with mode: 0644]	patch \| blob