[CodeGen] Store call frame size in MachineBasicBlock

[foad]

Summary

Record the call frame size on entry to each basic block. This is usually
zero except when a basic block has been split in the middle of a call
sequence.

This simplifies PEI::replaceFrameIndices which previously had to visit
basic blocks in a specific order and had special handling for
unreachable blocks. More importantly it paves the way for an equally
simple implementation of a backwards version of replaceFrameIndices,
which is required to fully convert PrologEpilogInserter to backwards
register scavenging, which is preferred because it does not rely on
accurate kill flags.

[foad]

This is a rework of D154281:

• Fixes the ARM bug reported by @olista01. ARM frame index elimination was relying on SPAdj being passed in as 0 if call frame pseudos were eliminated early (the canSimplifyCallFramePseudos case).
• Stores "call frame size" instead of "SP adjustment". This feels a bit more canonical and maps directly to the call frame size stored in call frame setup/destroy pseudos.
• Adds machine verification and a bunch of fixes that that required.

[arsenm]

llvm/lib/CodeGen/MachineVerifier.cpp

3405

Separate err from the report seems weird but it seems that's what all this code is already doing

3407

single quotes

llvm/lib/CodeGen/PrologEpilogInserter.cpp

391–394

Should the pseudo elimination itself take care of this?

llvm/lib/CodeGen/TargetInstrInfo.cpp

1466

I'd assume this would be a compute this to set this situation, not a try to compute and fallback to precomputed?

[foad]

llvm/lib/CodeGen/PrologEpilogInserter.cpp

391–394

I don't see how that would work. You could (at least in theory) have block with a non-0 call frame size on entry, that doesn't contain any call frame pseudos. In any case it seems a bit weird for the per-instruction call eliminateCallFramePseudoInstr to change per-block state.

llvm/lib/CodeGen/TargetInstrInfo.cpp

1466

It's not really a matter of computing vs using a precomputed value.

To find the call frame size at an arbitrary point, conceptually you should start with the stored value at the start of the BB and then walk forwards updating it on every call frame pseudo. But because call frame pseudos are not allowed to be nested it is quicker to walk backwards and stop at the first pseudo you hit.

[foad]

Single quotes.

[phosek]

The new test is failing on Windows, would it be possible to take a look and revert if needed?

Script:
--
: 'RUN: at line 2';   c:\b\s\w\ir\x\w\llvm_build\bin\llc.exe -march=arm -run-pass none -o - C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\CodeGen\MIR\ARM\call-frame-size.mir | c:\b\s\w\ir\x\w\llvm_build\bin\filecheck.exe C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\CodeGen\MIR\ARM\call-frame-size.mir
--
Exit Code: 1

Command Output (stdout):
--
$ ":" "RUN: at line 2"
$ "c:\b\s\w\ir\x\w\llvm_build\bin\llc.exe" "-march=arm" "-run-pass" "none" "-o" "-" "C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\CodeGen\MIR\ARM\call-frame-size.mir"
# command stderr:
error: Function 'callframesize' uses ARM instructions, but the target does not support ARM mode execution.

error: command failed with exit status: 1
$ "c:\b\s\w\ir\x\w\llvm_build\bin\filecheck.exe" "C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\CodeGen\MIR\ARM\call-frame-size.mir"

--

[arsenm]

In D156113#4539462, @phosek wrote:

The new test is failing on Windows, would it be possible to take a look and revert if needed?

Script:
--
: 'RUN: at line 2';   c:\b\s\w\ir\x\w\llvm_build\bin\llc.exe -march=arm -run-pass none -o - C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\CodeGen\MIR\ARM\call-frame-size.mir | c:\b\s\w\ir\x\w\llvm_build\bin\filecheck.exe C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\CodeGen\MIR\ARM\call-frame-size.mir
--
Exit Code: 1

Command Output (stdout):
--
$ ":" "RUN: at line 2"
$ "c:\b\s\w\ir\x\w\llvm_build\bin\llc.exe" "-march=arm" "-run-pass" "none" "-o" "-" "C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\CodeGen\MIR\ARM\call-frame-size.mir"
# command stderr:
error: Function 'callframesize' uses ARM instructions, but the target does not support ARM mode execution.

error: command failed with exit status: 1
$ "c:\b\s\w\ir\x\w\llvm_build\bin\filecheck.exe" "C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\CodeGen\MIR\ARM\call-frame-size.mir"

--

I assume this just needs s/march/mtriple

[foad]

In D156113#4539464, @arsenm wrote:

In D156113#4539462, @phosek wrote:

The new test is failing on Windows, would it be possible to take a look and revert if needed?

Script:
--
: 'RUN: at line 2';   c:\b\s\w\ir\x\w\llvm_build\bin\llc.exe -march=arm -run-pass none -o - C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\CodeGen\MIR\ARM\call-frame-size.mir | c:\b\s\w\ir\x\w\llvm_build\bin\filecheck.exe C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\CodeGen\MIR\ARM\call-frame-size.mir
--
Exit Code: 1

Command Output (stdout):
--
$ ":" "RUN: at line 2"
$ "c:\b\s\w\ir\x\w\llvm_build\bin\llc.exe" "-march=arm" "-run-pass" "none" "-o" "-" "C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\CodeGen\MIR\ARM\call-frame-size.mir"
# command stderr:
error: Function 'callframesize' uses ARM instructions, but the target does not support ARM mode execution.

error: command failed with exit status: 1
$ "c:\b\s\w\ir\x\w\llvm_build\bin\filecheck.exe" "C:\b\s\w\ir\x\w\llvm-llvm-project\llvm\test\CodeGen\MIR\ARM\call-frame-size.mir"

--

I assume this just needs s/march/mtriple

@phosek does that fix it for you?

[thakis]

Also failing on http://45.33.8.238/win/81600/step_11.txt

If you think that helps, can you commit that? I think we're all just looking at bots and can't easily if a fix helps.

[foad]

If you think that helps, can you commit that? I think we're all just looking at bots and can't easily if a fix helps.

e5f04830c59fba05e39b7ca2c958c76876e7cd91, thanks @arsenm

llvm/include/llvm/CodeGen/MachineBasicBlock.h

RegisterMaskPair(MCPhysReg PhysReg, LaneBitmask LaneMask)
         : PhysReg(PhysReg), LaneMask(LaneMask) {}
   };
 
 private:
   using Instructions = ilist<MachineInstr, ilist_sentinel_tracking<true>>;
 
   const BasicBlock *BB;
   int Number;
+
+  /// The call frame size on entry to this basic block due to call frame setup
+  /// instructions in a predecessor. This is usually zero, unless basic blocks
+  /// are split in the middle of a call sequence.
+  ///
+  /// This information is only maintained until PrologEpilogInserter eliminates
+  /// call frame pseudos.
+  unsigned CallFrameSize = 0;
+
   MachineFunction *xParent;
   Instructions Insts;
 
   /// Keep track of the predecessor / successor basic blocks.
   std::vector<MachineBasicBlock *> Predecessors;
   std::vector<MachineBasicBlock *> Successors;
 
   /// Keep track of the probabilities to the successors. This vector has the
public:
   // Printing method used by LoopInfo.
   void printAsOperand(raw_ostream &OS, bool PrintType = true) const;
 
   /// MachineBasicBlocks are uniquely numbered at the function level, unless
   /// they're not in a MachineFunction yet, in which case this will return -1.
   int getNumber() const { return Number; }
   void setNumber(int N) { Number = N; }
 
+  /// Return the call frame size on entry to this basic block.
+  unsigned getCallFrameSize() const { return CallFrameSize; }
+  /// Set the call frame size on entry to this basic block.
+  void setCallFrameSize(unsigned N) { CallFrameSize = N; }
+
   /// Return the MCSymbol for this basic block.
   MCSymbol *getSymbol() const;
 
   /// Return the EHCatchret Symbol for this basic block.
   MCSymbol *getEHCatchretSymbol() const;
 
   std::optional<uint64_t> getIrrLoopHeaderWeight() const {
     return IrrLoopHeaderWeight;

llvm/include/llvm/CodeGen/TargetInstrInfo.h

public:
   /// tracked by their offset, can have values, and can have debug info
   /// associated with it. If so, sets \p Index and \p Offset of the target index
   /// operand.
   virtual bool isExplicitTargetIndexDef(const MachineInstr &MI, int &Index,
                                         int64_t &Offset) const {
     return false;
   }
 
+  // Get the call frame size just before MI.
+  unsigned getCallFrameSizeAt(MachineInstr &MI) const;
+
 private:
   mutable std::unique_ptr<MIRFormatter> Formatter;
   unsigned CallFrameSetupOpcode, CallFrameDestroyOpcode;
   unsigned CatchRetOpcode;
   unsigned ReturnOpcode;
 };
 
 /// Provide DenseMapInfo for TargetInstrInfo::RegSubRegPair.

llvm/lib/CodeGen/MIRParser/MILexer.h

enum TokenKind {
     kw_pcsections,
     kw_cfi_type,
     kw_bbsections,
     kw_bb_id,
     kw_unknown_size,
     kw_unknown_address,
     kw_ir_block_address_taken,
     kw_machine_block_address_taken,
+    kw_call_frame_size,
 
     // Metadata types.
     kw_distinct,
 
     // Named metadata keywords
     md_tbaa,
     md_alias_scope,
     md_noalias,

llvm/lib/CodeGen/MIRParser/MILexer.cpp

return StringSwitch<MIToken::TokenKind>(Identifier)
       .Case("bbsections", MIToken::kw_bbsections)
       .Case("bb_id", MIToken::kw_bb_id)
       .Case("unknown-size", MIToken::kw_unknown_size)
       .Case("unknown-address", MIToken::kw_unknown_address)
       .Case("distinct", MIToken::kw_distinct)
       .Case("ir-block-address-taken", MIToken::kw_ir_block_address_taken)
       .Case("machine-block-address-taken",
             MIToken::kw_machine_block_address_taken)
+      .Case("call-frame-size", MIToken::kw_call_frame_size)
       .Default(MIToken::Identifier);
 }
 
 static Cursor maybeLexIdentifier(Cursor C, MIToken &Token) {
   if (!isalpha(C.peek()) && C.peek() != '_')
     return std::nullopt;
   auto Range = C;
   while (isIdentifierChar(C.peek()))

llvm/lib/CodeGen/MIRParser/MIParser.cpp

bool parseMachineOperandAndTargetFlags(const unsigned OpCode,
                                          MachineOperand &Dest,
                                          std::optional<unsigned> &TiedDefIdx);
   bool parseOffset(int64_t &Offset);
   bool parseIRBlockAddressTaken(BasicBlock *&BB);
   bool parseAlignment(uint64_t &Alignment);
   bool parseAddrspace(unsigned &Addrspace);
   bool parseSectionID(std::optional<MBBSectionID> &SID);
   bool parseBBID(std::optional<unsigned> &BBID);
+  bool parseCallFrameSize(unsigned &CallFrameSize);
   bool parseOperandsOffset(MachineOperand &Op);
   bool parseIRValue(const Value *&V);
   bool parseMemoryOperandFlag(MachineMemOperand::Flags &Flags);
   bool parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV);
   bool parseMachinePointerInfo(MachinePointerInfo &Dest);
   bool parseOptionalScope(LLVMContext &Context, SyncScope::ID &SSID);
   bool parseOptionalAtomicOrdering(AtomicOrdering &Order);
   bool parseMachineMemoryOperand(MachineMemOperand *&Dest);
bool MIParser::parseBBID(std::optional<unsigned> &BBID) {
   unsigned Value = 0;
   if (getUnsigned(Value))
     return error("Unknown BB ID");
   BBID = Value;
   lex();
   return false;
 }
 
+// Parse basic block call frame size.
+bool MIParser::parseCallFrameSize(unsigned &CallFrameSize) {
+  assert(Token.is(MIToken::kw_call_frame_size));
+  lex();
+  unsigned Value = 0;
+  if (getUnsigned(Value))
+    return error("Unknown call frame size");
+  CallFrameSize = Value;
+  lex();
+  return false;
+}
+
 bool MIParser::parseBasicBlockDefinition(
     DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
   assert(Token.is(MIToken::MachineBasicBlockLabel));
   unsigned ID = 0;
   if (getUnsigned(ID))
     return true;
   auto Loc = Token.location();
   auto Name = Token.stringValue();
   lex();
   bool MachineBlockAddressTaken = false;
   BasicBlock *AddressTakenIRBlock = nullptr;
   bool IsLandingPad = false;
   bool IsInlineAsmBrIndirectTarget = false;
   bool IsEHFuncletEntry = false;
   std::optional<MBBSectionID> SectionID;
   uint64_t Alignment = 0;
   std::optional<unsigned> BBID;
+  unsigned CallFrameSize = 0;
   BasicBlock *BB = nullptr;
   if (consumeIfPresent(MIToken::lparen)) {
     do {
       // TODO: Report an error when multiple same attributes are specified.
       switch (Token.kind()) {
       case MIToken::kw_machine_block_address_taken:
         MachineBlockAddressTaken = true;
         lex();
do {
       case MIToken::kw_bbsections:
         if (parseSectionID(SectionID))
           return true;
         break;
       case MIToken::kw_bb_id:
         if (parseBBID(BBID))
           return true;
         break;
+      case MIToken::kw_call_frame_size:
+        if (parseCallFrameSize(CallFrameSize))
+          return true;
+        break;
       default:
         break;
       }
     } while (consumeIfPresent(MIToken::comma));
     if (expectAndConsume(MIToken::rparen))
       return true;
   }
   if (expectAndConsume(MIToken::colon))
bool MIParser::parseBasicBlockDefinition(
   }
   if (BBID.has_value()) {
     // BBSectionsType is set to `List` if any basic blocks has `SectionID`.
     // Here, we set it to `Labels` if it hasn't been set above.
     if (!MF.hasBBSections())
       MF.setBBSectionsType(BasicBlockSection::Labels);
     MBB->setBBID(BBID.value());
   }
+  MBB->setCallFrameSize(CallFrameSize);
   return false;
 }
 
 bool MIParser::parseBasicBlockDefinitions(
     DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
   lex();
   // Skip until the first machine basic block.
   while (Token.is(MIToken::Newline))

llvm/lib/CodeGen/MachineBasicBlock.cpp

if (getSectionID() != MBBSectionID(0)) {
       }
       hasAttributes = true;
     }
     if (getBBID().has_value()) {
       os << (hasAttributes ? ", " : " (");
       os << "bb_id " << *getBBID();
       hasAttributes = true;
     }
+    if (CallFrameSize != 0) {
+      os << (hasAttributes ? ", " : " (");
+      os << "call-frame-size " << CallFrameSize;
+      hasAttributes = true;
+    }
   }
 
   if (hasAttributes)
     os << ')';
 }
 
 void MachineBasicBlock::printAsOperand(raw_ostream &OS,
                                        bool /*PrintType*/) const {
MachineBasicBlock *MachineBasicBlock::SplitCriticalEdge(
   if (!canSplitCriticalEdge(Succ))
     return nullptr;
 
   MachineFunction *MF = getParent();
   MachineBasicBlock *PrevFallthrough = getNextNode();
   DebugLoc DL;  // FIXME: this is nowhere
 
   MachineBasicBlock *NMBB = MF->CreateMachineBasicBlock();
+  NMBB->setCallFrameSize(Succ->getCallFrameSize());
 
   // Is there an indirect jump with jump table?
   bool ChangedIndirectJump = false;
   int JTI = findJumpTableIndex(*this);
   if (JTI >= 0) {
     MachineJumpTableInfo &MJTI = *MF->getJumpTableInfo();
     MJTI.ReplaceMBBInJumpTable(JTI, Succ, NMBB);
     ChangedIndirectJump = true;

llvm/lib/CodeGen/MachineVerifier.cpp

if (DFI.getPathLength() >= 2) {
       assert(Reachable.count(StackPred) &&
              "DFS stack predecessor is already visited.\n");
       BBState.EntryValue = SPState[StackPred->getNumber()].ExitValue;
       BBState.EntryIsSetup = SPState[StackPred->getNumber()].ExitIsSetup;
       BBState.ExitValue = BBState.EntryValue;
       BBState.ExitIsSetup = BBState.EntryIsSetup;
     }
 
+    if ((int)MBB->getCallFrameSize() != -BBState.EntryValue) {
+      report("Call frame size on entry does not match value computed from "
+             "predecessor",
+             MBB);
+      errs() << "Call frame size on entry " << MBB->getCallFrameSize()
+             << " does not match value computed from predecessor "
+             << -BBState.EntryValue << '\n';
+    }
+
     // Update stack state by checking contents of MBB.
     for (const auto &I : *MBB) {
       if (I.getOpcode() == FrameSetupOpcode) {
         if (BBState.ExitIsSetup)
           report("FrameSetup is after another FrameSetup", &I);
         BBState.ExitValue -= TII->getFrameTotalSize(I);
         BBState.ExitIsSetup = true;
       }

llvm/lib/CodeGen/PrologEpilogInserter.cpp

 //
 // This pass must be run after register allocation.  After this pass is
 // executed, it is illegal to construct MO_FrameIndex operands.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitVector.h"
-#include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
for (MachineBasicBlock::iterator I = BB.begin(); I != BB.end(); ++I)
       }
 
   assert(!MFI.isMaxCallFrameSizeComputed() ||
          (MFI.getMaxCallFrameSize() >= MaxCallFrameSize &&
           !(AdjustsStack && !MFI.adjustsStack())));
   MFI.setAdjustsStack(AdjustsStack);
   MFI.setMaxCallFrameSize(MaxCallFrameSize);
 
-  for (MachineBasicBlock::iterator I : FrameSDOps) {
+  if (TFI->canSimplifyCallFramePseudos(MF)) {
     // If call frames are not being included as part of the stack frame, and
     // the target doesn't indicate otherwise, remove the call frame pseudos
     // here. The sub/add sp instruction pairs are still inserted, but we don't
     // need to track the SP adjustment for frame index elimination.
-    if (TFI->canSimplifyCallFramePseudos(MF))
+    for (MachineBasicBlock::iterator I : FrameSDOps)
       TFI->eliminateCallFramePseudoInstr(MF, *I->getParent(), I);
+
+    // We can't track the call frame size after call frame pseudos have been
+    // eliminated. Set it to zero everywhere to keep MachineVerifier happy.
+    for (MachineBasicBlock &MBB : MF)
+      MBB.setCallFrameSize(0);
   }
 }
 
 /// Compute the sets of entry and return blocks for saving and restoring
 /// callee-saved registers, and placing prolog and epilog code.
 void PEI::calculateSaveRestoreBlocks(MachineFunction &MF) {
   const MachineFrameInfo &MFI = MF.getFrameInfo();
 
if (!TFI.needsFrameIndexResolution(MF))
     return;
 
   const TargetRegisterInfo *TRI = ST.getRegisterInfo();
 
   // Allow the target to determine this after knowing the frame size.
   FrameIndexEliminationScavenging = (RS && !FrameIndexVirtualScavenging) ||
     TRI->requiresFrameIndexReplacementScavenging(MF);
 
-  // Store SPAdj at exit of a basic block.
-  SmallVector<int, 8> SPState;
-  SPState.resize(MF.getNumBlockIDs());
-  df_iterator_default_set<MachineBasicBlock*> Reachable;
-
-  // Iterate over the reachable blocks in DFS order.
-  for (auto DFI = df_ext_begin(&MF, Reachable), DFE = df_ext_end(&MF, Reachable);
-       DFI != DFE; ++DFI) {
-    int SPAdj = 0;
-    // Check the exit state of the DFS stack predecessor.
-    if (DFI.getPathLength() >= 2) {
-      MachineBasicBlock *StackPred = DFI.getPath(DFI.getPathLength() - 2);
-      assert(Reachable.count(StackPred) &&
-             "DFS stack predecessor is already visited.\n");
-      SPAdj = SPState[StackPred->getNumber()];
-    }
-    MachineBasicBlock *BB = *DFI;
-    replaceFrameIndices(BB, MF, SPAdj);
-    SPState[BB->getNumber()] = SPAdj;
-  }
-
-  // Handle the unreachable blocks.
-  for (auto &BB : MF) {
-    if (Reachable.count(&BB))
-      // Already handled in DFS traversal.
-      continue;
-    int SPAdj = 0;
-    replaceFrameIndices(&BB, MF, SPAdj);
+  for (auto &MBB : MF) {
+    int SPAdj = TFI.alignSPAdjust(MBB.getCallFrameSize());
+    if (TFI.getStackGrowthDirection() == TargetFrameLowering::StackGrowsUp)
+      SPAdj = -SPAdj;
+
+    replaceFrameIndices(&MBB, MF, SPAdj);
+
+    // We can't track the call frame size after call frame pseudos have been
+    // eliminated. Set it to zero everywhere to keep MachineVerifier happy.
+    MBB.setCallFrameSize(0);
   }
 }
 
 bool PEI::replaceFrameIndexDebugInstr(MachineFunction &MF, MachineInstr &MI,
                                       unsigned OpIdx, int SPAdj) {
   const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
   const TargetRegisterInfo &TRI = *MF.getSubtarget().getRegisterInfo();
   if (MI.isDebugValue()) {

llvm/lib/CodeGen/TargetInstrInfo.cpp

if (auto DestSrc = isCopyInstr(MI)) {
     Ops.push_back(MMO->getSize());
     Expr = DIExpression::prependOpcodes(Expr, Ops);
     return ParamLoadedValue(*BaseOp, Expr);
   }
 
   return std::nullopt;
 }
 
+// Get the call frame size just before MI.
+unsigned TargetInstrInfo::getCallFrameSizeAt(MachineInstr &MI) const {
+  // Search backwards from MI for the most recent call frame instruction.
+  MachineBasicBlock *MBB = MI.getParent();
+  for (auto &AdjI : reverse(make_range(MBB->instr_begin(), MI.getIterator()))) {
+    if (AdjI.getOpcode() == getCallFrameSetupOpcode())
+      return getFrameTotalSize(AdjI);
+    if (AdjI.getOpcode() == getCallFrameDestroyOpcode())
+      return 0;
+  }
+
+  // If none was found, use the call frame size from the start of the basic
+  // block.
+  return MBB->getCallFrameSize();
+}
+
 /// Both DefMI and UseMI must be valid.  By default, call directly to the
 /// itinerary. This may be overriden by the target.
 int TargetInstrInfo::getOperandLatency(const InstrItineraryData *ItinData,
                                        const MachineInstr &DefMI,
                                        unsigned DefIdx,
                                        const MachineInstr &UseMI,
                                        unsigned UseIdx) const {
   unsigned DefClass = DefMI.getDesc().getSchedClass();

llvm/lib/Target/ARM/ARMISelLowering.cpp

ARMTargetLowering::EmitStructByval(MachineInstr &MI,
   //   epilogue to handle left-over bytes
   //   [scratch, srcOut] = LDRB_POST(srcLoop, 1)
   //   [destOut] = STRB_POST(scratch, destLoop, 1)
   MachineBasicBlock *loopMBB = MF->CreateMachineBasicBlock(LLVM_BB);
   MachineBasicBlock *exitMBB = MF->CreateMachineBasicBlock(LLVM_BB);
   MF->insert(It, loopMBB);
   MF->insert(It, exitMBB);
 
+  // Set the call frame size on entry to the new basic blocks.
+  unsigned CallFrameSize = TII->getCallFrameSizeAt(MI);
+  loopMBB->setCallFrameSize(CallFrameSize);
+  exitMBB->setCallFrameSize(CallFrameSize);
+
   // Transfer the remainder of BB and its successor edges to exitMBB.
   exitMBB->splice(exitMBB->begin(), BB,
                   std::next(MachineBasicBlock::iterator(MI)), BB->end());
   exitMBB->transferSuccessorsAndUpdatePHIs(BB);
 
   // Load an immediate to varEnd.
   Register varEnd = MRI.createVirtualRegister(TRC);
   if (Subtarget->useMovt()) {
case ARM::tMOVCCr_pseudo: {
     //   fallthrough --> copy0MBB
     MachineBasicBlock *thisMBB  = BB;
     MachineFunction *F = BB->getParent();
     MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
     MachineBasicBlock *sinkMBB  = F->CreateMachineBasicBlock(LLVM_BB);
     F->insert(It, copy0MBB);
     F->insert(It, sinkMBB);
 
+    // Set the call frame size on entry to the new basic blocks.
+    unsigned CallFrameSize = TII->getCallFrameSizeAt(MI);
+    copy0MBB->setCallFrameSize(CallFrameSize);
+    sinkMBB->setCallFrameSize(CallFrameSize);
+
     // Check whether CPSR is live past the tMOVCCr_pseudo.
     const TargetRegisterInfo *TRI = Subtarget->getRegisterInfo();
     if (!MI.killsRegister(ARM::CPSR) &&
         !checkAndUpdateCPSRKill(MI, thisMBB, TRI)) {
       copy0MBB->addLiveIn(ARM::CPSR);
       sinkMBB->addLiveIn(ARM::CPSR);
     }
 

llvm/lib/Target/AVR/AVRISelLowering.cpp

AVRTargetLowering::EmitInstrWithCustomInserter(MachineInstr &MI,
   MachineFunction::iterator I;
   for (I = MF->begin(); I != MF->end() && &(*I) != MBB; ++I)
     ;
   if (I != MF->end())
     ++I;
   MF->insert(I, trueMBB);
   MF->insert(I, falseMBB);
 
+  // Set the call frame size on entry to the new basic blocks.
+  unsigned CallFrameSize = TII.getCallFrameSizeAt(MI);
+  trueMBB->setCallFrameSize(CallFrameSize);
+  falseMBB->setCallFrameSize(CallFrameSize);
+
   // Transfer remaining instructions and all successors of the current
   // block to the block which will contain the Phi node for the
   // select.
   trueMBB->splice(trueMBB->begin(), MBB,
                   std::next(MachineBasicBlock::iterator(MI)), MBB->end());
   trueMBB->transferSuccessorsAndUpdatePHIs(MBB);
 
   AVRCC::CondCodes CC = (AVRCC::CondCodes)MI.getOperand(3).getImm();

llvm/lib/Target/M68k/M68kISelLowering.cpp

if (CascadedCMOV) {
     Jcc1MBB->addLiveIn(M68k::CCR);
   }
 
   MachineBasicBlock *Copy0MBB = F->CreateMachineBasicBlock(BB);
   MachineBasicBlock *SinkMBB = F->CreateMachineBasicBlock(BB);
   F->insert(It, Copy0MBB);
   F->insert(It, SinkMBB);
 
+  // Set the call frame size on entry to the new basic blocks.
+  unsigned CallFrameSize = TII->getCallFrameSizeAt(MI);
+  Copy0MBB->setCallFrameSize(CallFrameSize);
+  SinkMBB->setCallFrameSize(CallFrameSize);
+
   // If the CCR register isn't dead in the terminator, then claim that it's
   // live into the sink and copy blocks.
   const TargetRegisterInfo *TRI = Subtarget.getRegisterInfo();
 
   MachineInstr *LastCCRSUser = CascadedCMOV ? CascadedCMOV : LastCMOV;
   if (!LastCCRSUser->killsRegister(M68k::CCR) &&
       !checkAndUpdateCCRKill(LastCCRSUser, MBB, TRI)) {
     Copy0MBB->addLiveIn(M68k::CCR);

llvm/lib/Target/X86/X86ISelLowering.cpp

X86TargetLowering::EmitLoweredSelect(MachineInstr &MI,
   MachineFunction *F = ThisMBB->getParent();
   MachineBasicBlock *FalseMBB = F->CreateMachineBasicBlock(LLVM_BB);
   MachineBasicBlock *SinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
 
   MachineFunction::iterator It = ++ThisMBB->getIterator();
   F->insert(It, FalseMBB);
   F->insert(It, SinkMBB);
 
+  // Set the call frame size on entry to the new basic blocks.
+  unsigned CallFrameSize = TII->getCallFrameSizeAt(MI);
+  FalseMBB->setCallFrameSize(CallFrameSize);
+  SinkMBB->setCallFrameSize(CallFrameSize);
+
   // If the EFLAGS register isn't dead in the terminator, then claim that it's
   // live into the sink and copy blocks.
   const TargetRegisterInfo *TRI = Subtarget.getRegisterInfo();
   if (!LastCMOV->killsRegister(X86::EFLAGS) &&
       !checkAndUpdateEFLAGSKill(LastCMOV, ThisMBB, TRI)) {
     FalseMBB->addLiveIn(X86::EFLAGS);
     SinkMBB->addLiveIn(X86::EFLAGS);
   }

llvm/test/CodeGen/ARM/2013-06-03-ByVal-2Kbytes.ll

 ; RUN: llc < %s -mcpu=cortex-a15 | FileCheck %s
+; RUN: llc < %s -mcpu=cortex-a15 -stop-after=finalize-isel -o %t.mir
+; RUN: llc %t.mir -mcpu=cortex-a15 -start-after=finalize-isel -o - | FileCheck %s
 ; ModuleID = 'attri_16.c'
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:128-a0:0:64-n32-S64"
 target triple = "armv4t--linux-gnueabihf"
 
 %big_struct0 = type { [517 x i32] }
 %big_struct1 = type { [516 x i32] }
 
 ;CHECK-LABEL: f:

llvm/test/CodeGen/ARM/no-register-coalescing-in-returnsTwice.mir

bb.1:
     ADJCALLSTACKDOWN 72, 0, 14, $noreg, implicit-def dead $sp, implicit $sp
     %24:gpr = LDRi12 %stack.0.P0, 0, 14, $noreg
     %25:gpr = LDRi12 %stack.0.P0, 4, 14, $noreg
     %27:gpr = COPY $sp
     %29:gpr = MOVi16 72, 14, $noreg
     %61:gpr = COPY killed %29
     %62:gpr = COPY killed %4
     %63:gpr = COPY killed %27
-  bb.2:
+  bb.2 (call-frame-size 72):
     %35:gpr = COPY killed %63
     %33:gpr = COPY killed %62
     %31:gpr = COPY killed %61
     %32:gpr = COPY killed %33
     %36:dpr, %32:gpr = VLD1d32wb_fixed %32, 0, 14, $noreg
     %34:gpr = COPY killed %35
     %34:gpr = VST1d32wb_fixed %34, 0, killed %36, 14, $noreg
     %30:gpr = SUBri killed %31, 8, 14, $noreg, def $cpsr
     %61:gpr = COPY killed %30
     %62:gpr = COPY killed %32
     %63:gpr = COPY killed %34
     Bcc %bb.2, 1, killed $cpsr
-  bb.3:
+  bb.3 (call-frame-size 72):
     successors:
     %28:gpr = ADDri %stack.1.jb1, 0, 14, $noreg, $noreg
     $r0 = COPY killed %28
     $r2 = COPY killed %24
     $r3 = COPY killed %25
     BL @_Z3barPx3S37z, csr_aapcs, implicit-def dead $lr, implicit $sp, implicit killed $r0, implicit killed $r2, implicit killed $r3, implicit-def $sp
     ADJCALLSTACKUP 72, 0, 14, $noreg, implicit-def dead $sp, implicit $sp
   bb.4:

llvm/test/CodeGen/MIR/ARM/call-frame-size.mir

+# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py UTC_ARGS: --version 2
+# RUN: llc -march=arm -run-pass none -o - %s | FileCheck %s
+# This test ensures that the MIR parser parses machine functions correctly.
+
+---
+name: callframesize
+body: |
+  ; CHECK-LABEL: name: callframesize
+  ; CHECK: bb.0:
+  ; CHECK-NEXT:   successors: %bb.1(0x80000000)
+  ; CHECK-NEXT: {{  $}}
+  ; CHECK-NEXT:   ADJCALLSTACKDOWN 100, 0, 14 /* CC::al */, $noreg, implicit-def $sp, implicit $sp
+  ; CHECK-NEXT: {{  $}}
+  ; CHECK-NEXT: bb.1 (call-frame-size 100):
+  ; CHECK-NEXT:   successors: %bb.2(0x80000000)
+  ; CHECK-NEXT: {{  $}}
+  ; CHECK-NEXT:   ADJCALLSTACKUP 100, 0, 14 /* CC::al */, $noreg, implicit-def $sp, implicit $sp
+  ; CHECK-NEXT: {{  $}}
+  ; CHECK-NEXT: bb.2:
+  bb.0:
+    ADJCALLSTACKDOWN 100, 0, 14, $noreg, implicit-def $sp, implicit $sp
+  bb.1 (call-frame-size 100):
+    ADJCALLSTACKUP 100, 0, 14, $noreg, implicit-def $sp, implicit $sp
+  bb.2:
+...

llvm/tools/llvm-reduce/ReducerWorkItem.cpp

static std::unique_ptr<MachineFunction> cloneMF(MachineFunction *SrcMF,
   auto *DstMRI = &DstMF->getRegInfo();
 
   // Clone blocks.
   for (MachineBasicBlock &SrcMBB : *SrcMF) {
     MachineBasicBlock *DstMBB =
         DstMF->CreateMachineBasicBlock(SrcMBB.getBasicBlock());
     Src2DstMBB[&SrcMBB] = DstMBB;
 
+    DstMBB->setCallFrameSize(SrcMBB.getCallFrameSize());
+
     if (SrcMBB.isIRBlockAddressTaken())
       DstMBB->setAddressTakenIRBlock(SrcMBB.getAddressTakenIRBlock());
     if (SrcMBB.isMachineBlockAddressTaken())
       DstMBB->setMachineBlockAddressTaken();
 
     // FIXME: This is not serialized
     if (SrcMBB.hasLabelMustBeEmitted())
       DstMBB->setLabelMustBeEmitted();