[EVM] Support data sections in the code

This is achieved by emitting global variables with constant
initializers into the code section. Removed unused patters from TableGen.

Author: PavelKopyl

llvm/lib/Target/EVM/EVMAsmPrinter.cpp

@@ -11,6 +11,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "EVM.h"
 #include "EVMMCInstLower.h"
 #include "EVMMachineFunctionInfo.h"
 #include "EVMTargetMachine.h"
@@ -22,6 +23,8 @@
 #include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/CodeGen/AsmPrinter.h"
+#include "llvm/IR/GlobalVariable.h"
+#include "llvm/IR/Module.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInst.h"
@@ -49,6 +52,16 @@ class EVMAsmPrinter : public AsmPrinter {
   StringSet<> WideRelocSymbolsSet;
   StringMap<unsigned> ImmutablesMap;
 
+  // Contains constant global variable initializers in address space AS_CODE,
+  // which are concatenated into a single block. Duplicate initializers and
+  // those that are substrings of others are removed. This "data section"
+  // is emitted at the end of the .text section.
+  std::string DataSectionBuffer;
+  MCSymbol *DataSectionSymbol = nullptr;
+  // Maps each global variable symbol to the offset within the data section
+  // where its corresponding initializer is located.
+  DenseMap<const MCSymbol *, uint64_t> GlobSymbolToOffsetMap;
+
   // True if there is a function that pushes deploy address.
   bool ModuleHasPushDeployAddress = false;
 
@@ -68,14 +81,20 @@ class EVMAsmPrinter : public AsmPrinter {
 
   void emitEndOfAsmFile(Module &) override;
 
+  void emitStartOfAsmFile(Module &) override;
+
   void emitFunctionBodyStart() override;
+
   void emitFunctionBodyEnd() override;
 
+  void emitGlobalVariable(const GlobalVariable *GV) override;
+
 private:
   void emitAssemblySymbol(const MachineInstr *MI);
   void emitWideRelocatableSymbol(const MachineInstr *MI);
   void emitLoadImmutableLabel(const MachineInstr *MI);
   void emitJumpDest();
+  void createDataSectionBuffer(const Module &M);
 };
 } // end of anonymous namespace
 
@@ -221,7 +240,7 @@ void EVMAsmPrinter::emitInstruction(const MachineInstr *MI) {
   }
 
   MCInst TmpInst;
-  MCInstLowering.Lower(MI, TmpInst);
+  MCInstLowering.Lower(MI, TmpInst, GlobSymbolToOffsetMap, DataSectionSymbol);
   EmitToStreamer(*OutStreamer, TmpInst);
 }
 
@@ -328,8 +347,49 @@ void EVMAsmPrinter::emitWideRelocatableSymbol(const MachineInstr *MI) {
   OutStreamer->switchSection(CurrentSection);
 }
 
-void EVMAsmPrinter::emitEndOfAsmFile(Module &) {
+void EVMAsmPrinter::createDataSectionBuffer(const Module &M) {
+  SmallVector<std::pair<const GlobalVariable *, StringRef>, 16> Globals;
+  for (const GlobalVariable &GV : M.globals()) {
+    if (GV.getAddressSpace() != EVMAS::AS_CODE || !GV.hasInitializer())
+      continue;
+
+    const auto *CV = dyn_cast<ConstantDataSequential>(GV.getInitializer());
+    if (!CV)
+      continue;
+
+    Globals.emplace_back(&GV, CV->getRawDataValues());
+  }
+  // Sort global variables in descending order based on the size of their
+  // initializers.
+  stable_sort(Globals, [](const auto &A, const auto &B) {
+    return A.second.size() > B.second.size();
+  });
+
+  // Construct the data section by concatenating unique initializers,
+  // eliminating duplicates, and excluding any initializer that is a
+  // substring of another.
+  // NOTE: Rather than simply concatenating unique strings, we could attempt
+  // to compute the Shortest Common Superstring by allowing partial overlaps
+  // between strings. Although this is an NP-hard problem, we could explore
+  // an approximate greedy solution. Consider this approach if there are
+  // real programs that could benefit from the optimization.
+  DataSectionBuffer.clear();
+  raw_string_ostream Stream(DataSectionBuffer);
+  for (const auto &[_, Init] : Globals)
+    if (!StringRef(DataSectionBuffer).contains(Init))
+      Stream << Init;
+
+  // Compute offsets of each global initializer in the data section.
+  StringRef DataView(DataSectionBuffer);
+  for (const auto &[GV, Init] : Globals) {
+    size_t Offset = DataView.find(Init);
+    assert(Offset != StringRef::npos &&
+           "Initializer not found in data section");
+    GlobSymbolToOffsetMap[getSymbol(GV)] = Offset;
+  }
+}
 
+void EVMAsmPrinter::emitEndOfAsmFile(Module &) {
   // The deploy and runtime code must end with INVALID instruction to
   // comply with 'solc'. To ensure this, we append an INVALID
   // instruction at the end of the .text section.
@@ -346,8 +406,14 @@ void EVMAsmPrinter::emitEndOfAsmFile(Module &) {
       TM.getTargetFeatureString()));
 
   OutStreamer->emitInstruction(MCI, *STI);
+
+  // Emit constants to the code.
+  OutStreamer->emitLabel(DataSectionSymbol);
+  OutStreamer->emitBinaryData(DataSectionBuffer);
+
   OutStreamer->popSection();
 
+  GlobSymbolToOffsetMap.clear();
   WideRelocSymbolsSet.clear();
   ImmutablesMap.clear();
   ModuleHasPushDeployAddress = false;
@@ -360,6 +426,20 @@ void EVMAsmPrinter::emitJumpDest() {
   EmitToStreamer(*OutStreamer, JumpDest);
 }
 
+void EVMAsmPrinter::emitStartOfAsmFile(Module &M) {
+  createDataSectionBuffer(M);
+  DataSectionSymbol = OutContext.getOrCreateSymbol("code_data_section");
+}
+
+void EVMAsmPrinter::emitGlobalVariable(const GlobalVariable *GV) {
+  // Constant arrays are handled above.
+  if (GV->getAddressSpace() == EVMAS::AS_CODE && GV->hasInitializer())
+    if (isa<ConstantDataSequential>(GV->getInitializer()))
+      return;
+
+  AsmPrinter::emitGlobalVariable(GV);
+}
+
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeEVMAsmPrinter() {
   const RegisterAsmPrinter<EVMAsmPrinter> X(getTheEVMTarget());
 }

llvm/lib/Target/EVM/EVMISelLowering.cpp

@@ -473,8 +473,16 @@ SDValue EVMTargetLowering::LowerINTRINSIC_VOID(SDValue Op,
     MemOpISD = EVMISD::MEMCPY_CODE;
     break;
   }
+
+  SDValue SrcOp = Op.getOperand(3);
+  // Support for copying bytes from a data section residing in code memory.
+  if (MemOpISD == EVMISD::MEMCPY_CODE)
+    if (const auto *GA = dyn_cast<GlobalAddressSDNode>(SrcOp))
+      SrcOp = DAG.getMCSymbol(DAG.getTarget().getSymbol(GA->getGlobal()),
+                              MVT::i256);
+
   return DAG.getNode(MemOpISD, DL, MVT::Other, Op.getOperand(0),
-                     Op.getOperand(2), Op.getOperand(3), Op.getOperand(4));
+                     Op.getOperand(2), SrcOp, Op.getOperand(4));
 }
 
 //===----------------------------------------------------------------------===//

llvm/lib/Target/EVM/EVMInstrInfo.td

@@ -29,9 +29,6 @@ def SDT_EVMRet
 def SDT_EVMSignextend
   : SDTypeProfile<1, 2, [SDTCisSameAs<0, 1>, SDTCisVT<1, i256>]>;
 
-def SDT_EVMTargetAddrWrapper
-  : SDTypeProfile<1, 1, [SDTCisPtrTy<0>]>;
-
 def SDT_EVMMemcpy
   : SDTypeProfile<0, 3, [SDTCisPtrTy<0>, SDTCisPtrTy<1>, SDTCisInt<2>]>;
 
@@ -57,9 +54,6 @@ def EVMret
 def EVMSignextend
   : SDNode<"EVMISD::SIGNEXTEND", SDT_EVMSignextend>;
 
-def EVMTargetAddrWrapper
-  : SDNode<"EVMISD::TARGET_ADDR_WRAPPER", SDT_EVMTargetAddrWrapper>;
-
 def EVMMemcpy_call_data
   : SDNode<"EVMISD::MEMCPY_CALL_DATA", SDT_EVMMemcpy,
             [SDNPHasChain, SDNPMayLoad, SDNPMayStore]>;
@@ -211,11 +205,6 @@ def CONST_I256
 let isAsCheapAsAMove = 1 in def COPY_I256
     : NRI<(outs GPR:$res), (ins GPR:$src), [], "COPY_I256 $res, $src">;
 
-def : Pat<(i256 (EVMTargetAddrWrapper tglobaladdr:$addr)),
-          (CONST_I256 tglobaladdr:$addr)>;
-def : Pat<(i256 (EVMTargetAddrWrapper texternalsym:$addr)),
-          (CONST_I256 texternalsym:$addr)>;
-
 let Uses = [SP], isCall = 1 in {
 
 // CALL should take both variadic arguments and produce variadic results, but

llvm/lib/Target/EVM/EVMMCInstLower.cpp

@@ -87,7 +87,10 @@ MCOperand EVMMCInstLower::LowerSymbolOperand(const MachineOperand &MO,
   return MCOperand::createExpr(Expr);
 }
 
-void EVMMCInstLower::Lower(const MachineInstr *MI, MCInst &OutMI) {
+void EVMMCInstLower::Lower(
+    const MachineInstr *MI, MCInst &OutMI,
+    const DenseMap<const MCSymbol *, uint64_t> &GlobSymbolToOffsetMap,
+    const MCSymbol *DataSectionSymbol) {
   OutMI.setOpcode(MI->getOpcode());
   const MCInstrDesc &Desc = MI->getDesc();
   for (unsigned I = 0, E = MI->getNumOperands(); I != E; ++I) {
@@ -125,16 +128,25 @@ void EVMMCInstLower::Lower(const MachineInstr *MI, MCInst &OutMI) {
       }
     } break;
     case MachineOperand::MO_MCSymbol: {
-      MCSymbolRefExpr::VariantKind Kind = MCSymbolRefExpr::VariantKind::VK_None;
 #ifndef NDEBUG
       unsigned Opc = MI->getOpcode();
       // We handle the linkage-related instructions in the EVMAsmPrinter.
       assert(Opc != EVM::DATASIZE_S && Opc != EVM::DATAOFFSET_S &&
              Opc != EVM::LINKERSYMBOL_S && Opc != EVM::LOADIMMUTABLE_S);
 #endif // NDEBUG
 
-      MCOp = MCOperand::createExpr(
-          MCSymbolRefExpr::create(MO.getMCSymbol(), Kind, Ctx));
+      if (auto It = GlobSymbolToOffsetMap.find(MO.getMCSymbol());
+          It != GlobSymbolToOffsetMap.end()) {
+        const MCExpr *Expr = MCSymbolRefExpr::create(DataSectionSymbol, Ctx);
+        if (It->second)
+          Expr = MCBinaryExpr::createAdd(
+              Expr, MCConstantExpr::create(It->second, Ctx), Ctx);
+
+        MCOp = MCOperand::createExpr(Expr);
+        break;
+      }
+      MCOp =
+          MCOperand::createExpr(MCSymbolRefExpr::create(MO.getMCSymbol(), Ctx));
     } break;
     case MachineOperand::MO_MachineBasicBlock:
       MCOp = MCOperand::createExpr(

llvm/lib/Target/EVM/EVMMCInstLower.h

@@ -13,6 +13,7 @@
 
 namespace llvm {
 class AsmPrinter;
+class GlobalValue;
 class MCContext;
 class MCInst;
 class MCOperand;
@@ -40,7 +41,9 @@ class LLVM_LIBRARY_VISIBILITY EVMMCInstLower {
                  const VRegRCMap &VRegMapping, const MachineRegisterInfo &MRI)
       : Ctx(Ctx), Printer(Printer), VRegMapping(VRegMapping), MRI(MRI) {}
 
-  void Lower(const MachineInstr *MI, MCInst &OutMI);
+  void Lower(const MachineInstr *MI, MCInst &OutMI,
+             const DenseMap<const MCSymbol *, uint64_t> &GlobSymbolToOffsetMap,
+             const MCSymbol *DataSectionSymbol);
 
 private:
   // Encodes the register class in the upper 4 bits along with the register

llvm/lib/Target/EVM/EVMStackModel.cpp

@@ -87,16 +87,10 @@ StackSlot *EVMStackModel::getStackSlot(const MachineOperand &MO) const {
 Stack EVMStackModel::getSlotsForInstructionUses(const MachineInstr &MI) const {
   Stack In;
   for (const auto &MO : reverse(MI.explicit_uses())) {
-    // All the non-register operands are handled in instruction specific
-    // handlers.
-    if (!MO.isReg())
-      continue;
-
-    // SP is not used anyhow.
-    if (MO.getReg() == EVM::SP)
-      continue;
-
-    In.push_back(getStackSlot(MO));
+    if (MO.isReg() && MO.getReg() != EVM::SP)
+      In.push_back(getStackSlot(MO));
+    else if (MO.isMCSymbol())
+      In.push_back(getSymbolSlot(MO.getMCSymbol(), &MI));
   }
   return In;
 }

llvm/lib/Target/EVM/EVMStackifyCodeEmitter.cpp

@@ -117,11 +117,13 @@ void EVMStackifyCodeEmitter::CodeEmitter::emitConstant(uint64_t Val) {
 
 void EVMStackifyCodeEmitter::CodeEmitter::emitSymbol(const MachineInstr *MI,
                                                      MCSymbol *Symbol) {
-  assert(isLinkerPseudoMI(*MI) && "Unexpected symbol instruction");
+  assert((isLinkerPseudoMI(*MI) || MI->getOpcode() == EVM::CODECOPY) &&
+         "Unexpected symbol instruction");
+
   StackHeight += 1;
-  // This is codegen-only instruction, that will be converted into PUSH4.
-  auto NewMI = BuildMI(*CurMBB, CurMBB->end(), MI->getDebugLoc(),
-                       TII->get(EVM::getStackOpcode(MI->getOpcode())))
+  unsigned Opc = isLinkerPseudoMI(*MI) ? EVM::getStackOpcode(MI->getOpcode())
+                                       : EVM::PUSH_LABEL;
+  auto NewMI = BuildMI(*CurMBB, CurMBB->end(), MI->getDebugLoc(), TII->get(Opc))
                    .addSym(Symbol);
   verify(NewMI);
 }

llvm/lib/Target/EVM/MCTargetDesc/EVMMCCodeEmitter.cpp

@@ -102,24 +102,39 @@ unsigned EVMMCCodeEmitter::getMachineOpValue(const MCInst &MI,
                                              const MCSubtargetInfo &STI) const {
   if (MO.isImm()) {
     Op = MO.getImm();
-  } else if (MO.isExpr()) {
-    auto Kind = MO.getExpr()->getKind();
-    if (Kind == MCExpr::ExprKind::Target) {
-      const auto *CImmExp = cast<EVMCImmMCExpr>(MO.getExpr());
-      Op = APInt(Op.getBitWidth(), CImmExp->getString(), /*radix=*/16);
-    } else if (Kind == MCExpr::ExprKind::SymbolRef) {
-      const auto *RefExpr = cast<MCSymbolRefExpr>(MO.getExpr());
-      MCSymbolRefExpr::VariantKind Kind = RefExpr->getKind();
-      EVM::Fixups Fixup = getFixupForOpc(MI.getOpcode(), Kind);
-      // The byte index of start of the relocation is always 1, as
-      // we need to skip the instruction opcode which is always one byte.
-      Fixups.push_back(
-          MCFixup::create(1, MO.getExpr(), MCFixupKind(Fixup), MI.getLoc()));
-    }
-  } else {
-    llvm_unreachable("Unexpected MC operand type");
+    return 0;
   }
 
+  if (!MO.isExpr())
+    llvm_unreachable("Unable to encode MCOperand");
+
+  MCExpr::ExprKind Kind = MO.getExpr()->getKind();
+  if (Kind == MCExpr::ExprKind::Target) {
+    const auto *CImmExp = cast<EVMCImmMCExpr>(MO.getExpr());
+    Op = APInt(Op.getBitWidth(), CImmExp->getString(), /*radix=*/16);
+    return 0;
+  }
+
+  // We expect the relocatable immediate operand to be in the
+  // form: @symbol + imm.
+  const MCSymbolRefExpr *RefExpr = nullptr;
+  if (Kind == MCExpr::ExprKind::Binary) {
+    const auto *BE = cast<MCBinaryExpr>(MO.getExpr());
+    RefExpr = dyn_cast<MCSymbolRefExpr>(
+        isa<MCSymbolRefExpr>(BE->getLHS()) ? BE->getLHS() : BE->getRHS());
+  } else if (Kind == MCExpr::ExprKind::SymbolRef) {
+    RefExpr = cast<MCSymbolRefExpr>(MO.getExpr());
+  }
+
+  if (!RefExpr)
+    llvm_unreachable("Unexpected MCOperand type");
+
+  EVM::Fixups Fixup = getFixupForOpc(MI.getOpcode(), RefExpr->getKind());
+  // The byte index of start of the relocation is always 1, as
+  // we need to skip the instruction opcode which is always one byte.
+  Fixups.push_back(
+      MCFixup::create(1, MO.getExpr(), MCFixupKind(Fixup), MI.getLoc()));
+
   return 0;
 }