[EVM] Add support for calculating module size

Signed-off-by: Vladimir Radosavljevic <[email protected]>

Author: vladimirradosavljevic

llvm/lib/Target/EVM/CMakeLists.txt

@@ -23,6 +23,7 @@ add_llvm_target(EVMCodeGen
   EVMArgumentMove.cpp
   EVMAsmPrinter.cpp
   EVMBackwardPropagationStackification.cpp
+  EVMCalculateModuleSize.cpp
   EVMConstantUnfolding.cpp
   EVMCodegenPrepare.cpp
   EVMFinalizeStackFrames.cpp

llvm/lib/Target/EVM/EVMCalculateModuleSize.cpp

@@ -0,0 +1,139 @@
+//===----- EVMCalculateModuleSize.cpp - Calculate module size --*- C++ -*--===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// A utility set for determining the overall size of a module.
+//
+//===----------------------------------------------------------------------===//
+
+#include "EVMCalculateModuleSize.h"
+#include "EVMMachineFunctionInfo.h"
+#include "EVMSubtarget.h"
+#include "MCTargetDesc/EVMMCTargetDesc.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/CodeGen/TargetInstrInfo.h"
+#include "llvm/CodeGen/TargetSubtargetInfo.h"
+#include "llvm/IR/Module.h"
+
+using namespace llvm;
+
+// This is the copied from AsmPrinter::isBlockOnlyReachableByFallthrough.
+static bool isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) {
+  // If this is a landing pad, it isn't a fall through.  If it has no preds,
+  // then nothing falls through to it.
+  if (MBB->isEHPad() || MBB->pred_empty())
+    return false;
+
+  // If there isn't exactly one predecessor, it can't be a fall through.
+  if (MBB->pred_size() > 1)
+    return false;
+
+  // The predecessor has to be immediately before this block.
+  MachineBasicBlock *Pred = *MBB->pred_begin();
+  if (!Pred->isLayoutSuccessor(MBB))
+    return false;
+
+  // If the block is completely empty, then it definitely does fall through.
+  if (Pred->empty())
+    return true;
+
+  // Check the terminators in the previous blocks
+  for (const auto &MI : Pred->terminators()) {
+    // If it is not a simple branch, we are in a table somewhere.
+    if (!MI.isBranch() || MI.isIndirectBranch())
+      return false;
+
+    // If we are the operands of one of the branches, this is not a fall
+    // through. Note that targets with delay slots will usually bundle
+    // terminators with the delay slot instruction.
+    for (ConstMIBundleOperands OP(MI); OP.isValid(); ++OP) {
+      if (OP->isJTI())
+        return false;
+      if (OP->isMBB() && OP->getMBB() == MBB)
+        return false;
+    }
+  }
+
+  return true;
+}
+
+// Return the size of an instruction in bytes. For some pseudo instructions,
+// don't use the size from the instruction description, since during code
+// generation, some instructions will be relaxed to smaller instructions.
+static unsigned getInstSize(const MachineInstr &MI,
+                            const TargetInstrInfo *TII) {
+  // Skip debug instructions.
+  if (MI.isDebugInstr())
+    return 0;
+
+  unsigned Size = 0;
+  switch (MI.getOpcode()) {
+  default:
+    Size = MI.getDesc().getSize();
+    break;
+  case EVM::PseudoCALL:
+    // In case that function call has a return label, we will emit JUMPDEST,
+    // so take it into account.
+    if (MI.getNumExplicitOperands() > 1)
+      Size = TII->get(EVM::JUMPDEST_S).getSize();
+    LLVM_FALLTHROUGH;
+  case EVM::PseudoJUMPI:
+  case EVM::PseudoJUMP:
+    // We emit PUSH4_S here. The linker usually relaxes it to PUSH2_S,
+    // since a 16-bit immediate covers the 24,576-byte EVM runtime code cap
+    // (EIP-170). If a wider immediate were ever required, the contract
+    // already exceeds the cap, so the push width is moot.
+    Size += TII->get(EVM::PUSH2_S).getSize() + TII->get(EVM::JUMP_S).getSize();
+    break;
+  case EVM::PUSH_LABEL:
+    // We emit PUSH4_S here. The linker usually relaxes it to PUSH2_S,
+    // since a 16-bit immediate covers the 24,576-byte EVM runtime code cap
+    // (EIP-170). If a wider immediate were ever required, the contract
+    // already exceeds the cap, so the push width is moot.
+    Size = TII->get(EVM::PUSH2_S).getSize();
+    break;
+  }
+  return Size;
+}
+
+uint64_t llvm::EVM::calculateFunctionCodeSize(const MachineFunction &MF) {
+  uint64_t Size = 0;
+  const auto *TII = MF.getSubtarget<EVMSubtarget>().getInstrInfo();
+
+  // If the function has a PUSHDEPLOYADDRESS, it starts with a PUSH20.
+  if (const auto *MFI = MF.getInfo<EVMMachineFunctionInfo>();
+      MFI->getHasPushDeployAddress())
+    Size += TII->get(EVM::PUSH20).getSize();
+
+  for (const MachineBasicBlock &MBB : MF) {
+    // If the block is not only reachable by fallthrough, it starts with
+    // a JUMPDEST instruction.
+    if (!isBlockOnlyReachableByFallthrough(&MBB))
+      Size += TII->get(EVM::JUMPDEST_S).getSize();
+
+    Size += std::accumulate(MBB.begin(), MBB.end(), 0,
+                            [&TII](unsigned Sum, const MachineInstr &MI) {
+                              return Sum + getInstSize(MI, TII);
+                            });
+  }
+  return Size;
+}
+
+uint64_t llvm::EVM::calculateModuleCodeSize(Module &M,
+                                            const MachineModuleInfo &MMI) {
+  uint64_t TotalSize = 0;
+  for (Function &F : M) {
+    MachineFunction *MF = MMI.getMachineFunction(F);
+    if (!MF)
+      continue;
+    TotalSize += llvm::EVM::calculateFunctionCodeSize(*MF);
+  }
+
+  // Take into account INVALID instruction at the end of the .text section.
+  TotalSize++;
+  return TotalSize;
+}

llvm/lib/Target/EVM/EVMCalculateModuleSize.h

@@ -0,0 +1,29 @@
+//===----- EVMCalculateModuleSize.h - Calculate module size ----*- C++ -*--===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// A utility set for determining the overall size of a module.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_EVM_EVMCALCULATEMODULESIZE_H
+#define LLVM_LIB_TARGET_EVM_EVMCALCULATEMODULESIZE_H
+
+#include <cstdint>
+
+namespace llvm {
+class MachineFunction;
+class MachineModuleInfo;
+class Module;
+
+namespace EVM {
+uint64_t calculateFunctionCodeSize(const MachineFunction &MF);
+uint64_t calculateModuleCodeSize(Module &M, const MachineModuleInfo &MMI);
+} // namespace EVM
+} // namespace llvm
+
+#endif // LLVM_LIB_TARGET_EVM_EVMCALCULATEMODULESIZE_H

llvm/lib/Target/EVM/EVMInstrInfo.td

@@ -244,7 +244,10 @@ def FCALL
 } // Uses = [SP], isCall = 1
 
 let isCall = 1 in def PseudoCALL
-    : EVMPseudo<(outs), (ins jmptarget:$callee, variable_ops), [], true>;
+    : EVMPseudo<(outs), (ins jmptarget:$callee, variable_ops), [], true> {
+  // PUSH4_S + JUMP_S.
+  let Size = 6;
+}
 
 //===----------------------------------------------------------------------===//
 // EVM arithmetic instructions.
@@ -411,13 +414,19 @@ defm JUMPI
   : I<(outs), (ins jmptarget:$dst, GPR:$cond), [(brcond GPR:$cond, bb:$dst)],
       "JUMPI", "$dst, $cond", 0x57, 10>;
 def JUMP_UNLESS : EVMPseudo<(outs), (ins jmptarget:$dst, GPR:$cond), []>;
-def PseudoJUMPI : EVMPseudo<(outs), (ins jmptarget:$dst), [], true>;
+def PseudoJUMPI : EVMPseudo<(outs), (ins jmptarget:$dst), [], true> {
+  // PUSH4_S + JUMPI_S.
+  let Size = 6;
+}
 def PseudoJUMP_UNLESS : EVMPseudo<(outs), (ins jmptarget:$dst), [], true>;
 
 let isBarrier = 1 in {
   defm JUMP : I<(outs), (ins jmptarget:$dst), [(br bb:$dst)], "JUMP", "$dst",
                 0x56, 8>;
-  def PseudoJUMP : EVMPseudo<(outs), (ins jmptarget:$dst), [], true>;
+  def PseudoJUMP : EVMPseudo<(outs), (ins jmptarget:$dst), [], true> {
+    // PUSH4_S + JUMP_S.
+    let Size = 6;
+  }
 } // isBarrier = 1
 } // isBranch = 1, isTerminator = 1
 
@@ -829,6 +838,8 @@ defm PUSH0 : I<(outs), (ins), [], "PUSH0", "", 0x5F, 2>;
 
 def PUSH_LABEL : NI<(outs), (ins jmptarget:$dst), [], true, "", 0, 0> {
   let isCodeGenOnly = 1;
+  // PUSH4_S.
+  let Size = 5;
 }
 
 def PUSH_FRAME : NI<(outs), (ins i256imm:$imm), [], true, "", 0, 0> {
@@ -1162,22 +1173,34 @@ def PUSH32_S : PushBase<(outs), (ins i256imm:$imm), [], true, "PUSH32$imm",
 let isAsCheapAsAMove = 1, isReMaterializable = 1, isCodeGenOnly = 1, hasSideEffects = 0 in {
   let  BaseName = "DATASIZE" in {
     def DATASIZE : NI<(outs GPR:$dst), (ins jmptarget:$reloc), [], false, "", 0, 0>;
-    def DATASIZE_S : NI<(outs), (ins jmptarget:$reloc), [], true, "", 0, 0>;
+    def DATASIZE_S : NI<(outs), (ins jmptarget:$reloc), [], true, "", 0, 0> {
+      // PUSH4_S
+      let Size = 5;
+    }
   }
 
   let BaseName = "DATAOFFSET" in {
     def DATAOFFSET : NI<(outs GPR:$dst), (ins jmptarget:$reloc), [], false, "", 0, 0>;
-    def DATAOFFSET_S : NI<(outs), (ins jmptarget:$reloc), [], true, "", 0, 0>;
+    def DATAOFFSET_S : NI<(outs), (ins jmptarget:$reloc), [], true, "", 0, 0> {
+      // PUSH4_S
+      let Size = 5;
+    }
   }
 
   let BaseName = "LINKERSYMBOL" in {
     def LINKERSYMBOL : NI<(outs GPR:$dst), (ins jmptarget:$sym), [], false, "", 0, 0>;
-    def LINKERSYMBOL_S : NI<(outs), (ins jmptarget:$sym), [], true, "", 0, 0>;
+    def LINKERSYMBOL_S : NI<(outs), (ins jmptarget:$sym), [], true, "", 0, 0> {
+      // PUSH20_S
+      let Size = 21;
+    }
   }
 
   let BaseName = "LOADIMMUTABLE" in {
     def LOADIMMUTABLE : NI<(outs GPR:$dst), (ins jmptarget:$sym), [], false, "", 0, 0>;
-    def LOADIMMUTABLE_S : NI<(outs), (ins jmptarget:$sym), [], true, "", 0, 0>;
+    def LOADIMMUTABLE_S : NI<(outs), (ins jmptarget:$sym), [], true, "", 0, 0> {
+      // PUSH32_S
+      let Size = 33;
+    }
   }
 }