[CodeGen] Add MachineFunction::estimateSizeInBytes()

[piggynl]

Summary

This will avoid duplicating EstimateFunctionSizeInBytes for architectures.

[piggynl]

Fix compile error.

[lattner]

Looks fine to me, but I'm not active in this part of the codebase, it would be better for others to review it.

[piggynl]

ARM hard-coded EK_Inline as jump table encoding in rG8d3ba7349c2137f1a7f68c0ce5c1345496fc0b63. As a result, std::max(JTI->getEntrySize(DL), JTI->getEntryAlignment(DL)) always returns 1, which causes test/CodeGen/Thumb/large-fn-switch.ll to fail.

[zixuan-wu]

llvm/lib/Target/CSKY/CSKYFrameLowering.cpp

274

CSKY function does not contain jumptable now if there is any jumpable.

[efriedma]

The ARM version EstimateFunctionSizeInBytes in the context of frame lowering needs to ensure that it interacts correctly with later passes that might cause the function to grow, in particular ARMConstantIslandPass. The inclusion of constant pools and jump tables is intended to account for that. On targets which don't have an equivalent pass, you probably don't want to measure them. I guess CSKY in particular does embed constant pools... but it doesn't look like it embeds jump tables?

Anyway, it isn't obvious to me that you can actually come up with an estimate that actually makes sense in a target-independent context, so I'm not sure this is worth doing.

llvm/include/llvm/CodeGen/MachineFunction.h

public:
   bool hasWinCFI() const {
     return HasWinCFI;
   }
   void setHasWinCFI(bool v) { HasWinCFI = v; }
 
   /// True if this function needs frame moves for debug or exceptions.
   bool needsFrameMoves() const;
 
+  /// Estimate the total size of instructions, constants and jump table entries
+  /// in bytes. This may overestimate the function size.
+  unsigned estimateSizeInBytes() const;
+
   /// Get the function properties
   const MachineFunctionProperties &getProperties() const { return Properties; }
   MachineFunctionProperties &getProperties() { return Properties; }
 
   /// getInfo - Keep track of various per-function pieces of information for
   /// backends that would like to do so.
   ///
   template<typename Ty>

llvm/lib/CodeGen/MachineFunction.cpp

 
 /// True if this function needs frame moves for debug or exceptions.
 bool MachineFunction::needsFrameMoves() const {
   return getMMI().hasDebugInfo() ||
          getTarget().Options.ForceDwarfFrameSection ||
          F.needsUnwindTableEntry();
 }
 
+/// Estimate the total size of instructions, constants and jump table entries
+/// in bytes. This may overestimate the function size.
+unsigned MachineFunction::estimateSizeInBytes() const {
+  unsigned FnSize = 0;
+  const TargetInstrInfo *TII = getSubtarget().getInstrInfo();
+  const DataLayout &DL = getDataLayout();
+  for (auto &MBB : *this)
+    for (auto &MI : MBB)
+      FnSize += TII.getInstSizeInBytes(MI);
+  for (auto &C : getConstantPool()->getConstants())
+    FnSize += std::max(C.getSizeInBytes(DL), (unsigned)C.getAlign().value());
+  const MachineJumpTableInfo *JTI = getJumpTableInfo();
+  if (JTI)
+    for (auto &Table : JTI->getJumpTables())
+      FnSize += Table.MBBs.size() *
+                std::max(JTI->getEntrySize(DL), JTI->getEntryAlignment(DL));
+  return FnSize;
+}
+
 namespace llvm {
 
   template<>
   struct DOTGraphTraits<const MachineFunction*> : public DefaultDOTGraphTraits {
     DOTGraphTraits(bool isSimple = false) : DefaultDOTGraphTraits(isSimple) {}
 
     static std::string getGraphName(const MachineFunction *F) {
       return ("CFG for '" + F->getName() + "' function").str();

llvm/lib/Target/ARM/ARMFrameLowering.cpp

emitPopInst(MBB, MI, CSI, PopOpc, LdrOpc, isVarArg, false,
                 &isARMArea2Register, 0);
     emitPopInst(MBB, MI, CSI, PopOpc, LdrOpc, isVarArg, false,
                 &isARMArea1Register, 0);
   }
 
   return true;
 }
 
-// FIXME: Make generic?
-static unsigned EstimateFunctionSizeInBytes(const MachineFunction &MF,
-                                            const ARMBaseInstrInfo &TII) {
-  unsigned FnSize = 0;
-  for (auto &MBB : MF) {
-    for (auto &MI : MBB)
-      FnSize += TII.getInstSizeInBytes(MI);
-  }
-  if (MF.getJumpTableInfo())
-    for (auto &Table: MF.getJumpTableInfo()->getJumpTables())
-      FnSize += Table.MBBs.size() * 4;
-  FnSize += MF.getConstantPool()->getConstants().size() * 4;
-  return FnSize;
-}
-
 /// estimateRSStackSizeLimit - Look at each instruction that references stack
 /// frames and return the stack size limit beyond which some of these
 /// instructions will require a scratch register during their expansion later.
 // FIXME: Move to TII?
 static unsigned estimateRSStackSizeLimit(MachineFunction &MF,
                                          const TargetFrameLowering *TFI,
                                          bool &HasNonSPFrameIndex) {
   const ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
void ARMFrameLowering::determineCalleeSaves(MachineFunction &MF,
   bool CS1Spilled = false;
   bool LRSpilled = false;
   unsigned NumGPRSpills = 0;
   unsigned NumFPRSpills = 0;
   SmallVector<unsigned, 4> UnspilledCS1GPRs;
   SmallVector<unsigned, 4> UnspilledCS2GPRs;
   const ARMBaseRegisterInfo *RegInfo = static_cast<const ARMBaseRegisterInfo *>(
       MF.getSubtarget().getRegisterInfo());
-  const ARMBaseInstrInfo &TII =
-      *static_cast<const ARMBaseInstrInfo *>(MF.getSubtarget().getInstrInfo());
   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
   MachineFrameInfo &MFI = MF.getFrameInfo();
   MachineRegisterInfo &MRI = MF.getRegInfo();
   const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
   (void)TRI;  // Silence unused warning in non-assert builds.
   Register FramePtr = RegInfo->getFrameRegister(MF);
 
   // Spill R4 if Thumb2 function requires stack realignment - it will be used as
if (Spilled) {
         UnspilledCS2GPRs.push_back(Reg);
         break;
       }
     }
   }
 
   bool ForceLRSpill = false;
   if (!LRSpilled && AFI->isThumb1OnlyFunction()) {
-    unsigned FnSize = EstimateFunctionSizeInBytes(MF, TII);
+    unsigned FnSize = MF.estimateSizeInBytes();
     // Force LR to be spilled if the Thumb function size is > 2048. This enables
     // use of BL to implement far jump.
     if (FnSize >= (1 << 11)) {
       CanEliminateFrame = false;
       ForceLRSpill = true;
     }
   }
 

llvm/lib/Target/CSKY/CSKYFrameLowering.cpp

if (hasFP(MF)) {
     adjustReg(MBB, LastFrameDestroy, DL, SPReg, SPReg, (StackSize - ActualSize),
               MachineInstr::FrameDestroy);
   }
 
   adjustReg(MBB, MBBI, DL, SPReg, SPReg, ActualSize,
             MachineInstr::FrameDestroy);
 }
 
-static unsigned EstimateFunctionSizeInBytes(const MachineFunction &MF,
-                                            const CSKYInstrInfo &TII) {
-  unsigned FnSize = 0;
-  for (auto &MBB : MF) {
-    for (auto &MI : MBB)
-      FnSize += TII.getInstSizeInBytes(MI);
-  }
-  FnSize += MF.getConstantPool()->getConstants().size() * 4;
-  return FnSize;
-}
-
 static unsigned estimateRSStackSizeLimit(MachineFunction &MF,
                                          const CSKYSubtarget &STI) {
   unsigned Limit = (1 << 12) - 1;
 
   for (auto &MBB : MF) {
     for (auto &MI : MBB) {
       if (MI.isDebugInstr())
         continue;

 
 void CSKYFrameLowering::determineCalleeSaves(MachineFunction &MF,
                                              BitVector &SavedRegs,
                                              RegScavenger *RS) const {
   TargetFrameLowering::determineCalleeSaves(MF, SavedRegs, RS);
 
   CSKYMachineFunctionInfo *CFI = MF.getInfo<CSKYMachineFunctionInfo>();
   const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
-  const CSKYInstrInfo *TII = STI.getInstrInfo();
   const MachineRegisterInfo &MRI = MF.getRegInfo();
   MachineFrameInfo &MFI = MF.getFrameInfo();
 
   if (hasFP(MF))
     SavedRegs.set(CSKY::R8);
 
   // Mark BP as used if function has dedicated base pointer.
   if (hasBP(MF))
void CSKYFrameLowering::determineCalleeSaves(MachineFunction &MF,
   if (BigFrame || CFI->isCRSpilled() || !STI.hasE2()) {
     const TargetRegisterClass *RC = &CSKY::GPRRegClass;
     unsigned size = TRI->getSpillSize(*RC);
     Align align = TRI->getSpillAlign(*RC);
 
     RS->addScavengingFrameIndex(MFI.CreateStackObject(size, align, false));
   }
 
-  unsigned FnSize = EstimateFunctionSizeInBytes(MF, *TII);
+  unsigned FnSize = MF.estimateSizeInBytes();
   // Force R15 to be spilled if the function size is > 65534. This enables
   // use of BSR to implement far jump.
   if (FnSize >= ((1 << (16 - 1)) * 2))
     SavedRegs.set(CSKY::R15);
 
   CFI->setLRIsSpilled(SavedRegs.test(CSKY::R15));
 }