[EVM] Support for spilling constants to memory

llvm/lib/Target/EVM/CMakeLists.txt

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

llvm/lib/Target/EVM/EVMCalculateModuleSize.cpp

@@ -89,6 +89,10 @@ static unsigned getInstSize(const MachineInstr &MI,
     // 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_FRAME:
+    // Typical frame index offsets can be encoded in a single byte, but to
+    // be conservative, let’s assume 2 bytes per offset.
+    LLVM_FALLTHROUGH;
   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

llvm/lib/Target/EVM/EVMConstantSpiller.cpp

@@ -0,0 +1,100 @@
+//===----- EVMConstantSpiller.cpp - Spill constants to memory --*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file identifies IMM_RELOAD instructions representing spilled constants
+// throughout the module. It spills constants at the start of the entry function
+// and replaces IMM_RELOAD with the corresponding reload instructions.
+//
+//===----------------------------------------------------------------------===//
+
+#include "EVMConstantSpiller.h"
+#include "EVMInstrInfo.h"
+#include "EVMSubtarget.h"
+#include "MCTargetDesc/EVMMCTargetDesc.h"
+#include "TargetInfo/EVMTargetInfo.h"
+#include "llvm/CodeGen/MachineFrameInfo.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/CodeGen/Passes.h"
+#include "llvm/CodeGen/TargetSubtargetInfo.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/Debug.h"
+
+using namespace llvm;
+
+#define DEBUG_TYPE "evm-spill-constants"
+
+constexpr uint64_t SpillSlotSize = 32;
+
+static MachineInstr *emitPush(MachineBasicBlock &MBB,
+                              MachineBasicBlock::iterator InsertBefore,
+                              const EVMInstrInfo *TII, const APInt &Imm,
+                              LLVMContext &Ctx, const DebugLoc &DL) {
+  unsigned Opc = EVM::getPUSHOpcode(Imm);
+  auto MI = BuildMI(MBB, InsertBefore, DL, TII->get(EVM::getStackOpcode(Opc)));
+  if (Opc != EVM::PUSH0)
+    MI.addCImm(ConstantInt::get(Ctx, Imm));
+  return MI;
+}
+
+uint64_t EVMConstantSpiller::getSpillSize() const {
+  return ConstantToUseCount.size() * SpillSlotSize;
+}
+
+void EVMConstantSpiller::emitSpills(uint64_t SpillOffset,
+                                    MachineFunction &EntryMF) {
+  LLVMContext &Ctx = EntryMF.getFunction().getContext();
+  const EVMInstrInfo *TII = EntryMF.getSubtarget<EVMSubtarget>().getInstrInfo();
+
+  DenseMap<APInt, uint64_t> ConstantToSpillOffset;
+  for (const auto &KV : ConstantToUseCount) {
+    ConstantToSpillOffset[KV.first] = SpillOffset;
+    SpillOffset += SpillSlotSize;
+  }
+
+  // Emit constant stores in prologue of the entry function.
+  MachineBasicBlock &SpillMBB = EntryMF.front();
+  for (const auto &[Imm, Offset] : ConstantToSpillOffset) {
+    LLVM_DEBUG({
+      dbgs() << "Spilling constant: " << Imm
+             << ", number of uses: " << ConstantToUseCount.at(Imm)
+             << ", at offset: " << Offset << '\n';
+    });
+
+    BuildMI(SpillMBB, SpillMBB.begin(), DebugLoc(), TII->get(EVM::MSTORE_S));
+    emitPush(SpillMBB, SpillMBB.begin(), TII, APInt(256, Offset), Ctx,
+             DebugLoc());
+    emitPush(SpillMBB, SpillMBB.begin(), TII, Imm, Ctx, DebugLoc());
+  }
+
+  // Reload spilled constants.
+  for (MachineInstr *MI : Reloads) {
+    const APInt Imm = MI->getOperand(0).getCImm()->getValue().zext(256);
+    uint64_t Offset = ConstantToSpillOffset.at(Imm);
+
+    MachineBasicBlock *MBB = MI->getParent();
+    emitPush(*MBB, MI, TII, APInt(256, Offset), Ctx, MI->getDebugLoc());
+    auto Load = BuildMI(*MBB, MI, MI->getDebugLoc(), TII->get(EVM::MLOAD_S));
+    Load->setAsmPrinterFlag(MachineInstr::ReloadReuse);
+    MI->eraseFromParent();
+  }
+}
+
+EVMConstantSpiller::EVMConstantSpiller(SmallVector<MachineFunction *> &MFs) {
+  for (MachineFunction *MF : MFs) {
+    for (MachineBasicBlock &MBB : *MF) {
+      for (MachineInstr &MI : MBB) {
+        if (MI.getOpcode() != EVM::IMM_RELOAD)
+          continue;
+
+        const APInt Imm = MI.getOperand(0).getCImm()->getValue().zext(256);
+        ConstantToUseCount[Imm]++;
+        Reloads.push_back(&MI);
+      }
+    }
+  }
+}

llvm/lib/Target/EVM/EVMConstantSpiller.h

@@ -0,0 +1,50 @@
+//===----- EVMConstantSpiller.h - Spill constants to memory ----*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file identifies IMM_RELOAD instructions representing spilled constants
+// throughout the module. It spills constants at the start of the entry function
+// and replaces IMM_RELOAD with the corresponding reload instructions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_EVM_EVMCONSTANTSPILLER_H
+#define LLVM_LIB_TARGET_EVM_EVMCONSTANTSPILLER_H
+
+// #include "llvm/IR/Module.h"
+#include "llvm/ADT/APInt.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace llvm {
+
+class MachineInstr;
+class MachineFunction;
+
+class EVMConstantSpiller {
+public:
+  explicit EVMConstantSpiller(SmallVector<MachineFunction *> &MFs);
+
+  /// Inserts constant spills into the first basic block of the entry
+  /// function and replaces IMM_RELOAD with the corresponding reload
+  /// instructions at their use sites.
+  void emitSpills(uint64_t SpillOffset, MachineFunction &EntryMF);
+
+  /// Return the total size needed for the spill area.
+  uint64_t getSpillSize() const;
+
+private:
+  /// Maps each APInt constant to the number of times it appears across all
+  /// functions in the module
+  SmallDenseMap<APInt, unsigned> ConstantToUseCount;
+
+  /// IMM_RELOAD instructions that need to be converted into actuall reloads.
+  SmallVector<MachineInstr *> Reloads;
+};
+} // namespace llvm
+
+#endif // LLVM_LIB_TARGET_EVM_EVMCONSTANTSPILLER_H