631aed0758f58cec594181f221f9acff306af78a
[lldb.git] / llvm / tools / llvm-exegesis / lib / Assembler.cpp
1 //===-- Assembler.cpp -------------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "Assembler.h"
10
11 #include "SnippetRepetitor.h"
12 #include "Target.h"
13 #include "llvm/Analysis/TargetLibraryInfo.h"
14 #include "llvm/CodeGen/GlobalISel/CallLowering.h"
15 #include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
16 #include "llvm/CodeGen/MachineInstrBuilder.h"
17 #include "llvm/CodeGen/MachineModuleInfo.h"
18 #include "llvm/CodeGen/MachineRegisterInfo.h"
19 #include "llvm/CodeGen/TargetInstrInfo.h"
20 #include "llvm/CodeGen/TargetPassConfig.h"
21 #include "llvm/CodeGen/TargetSubtargetInfo.h"
22 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
23 #include "llvm/IR/LegacyPassManager.h"
24 #include "llvm/MC/MCInstrInfo.h"
25 #include "llvm/Support/Alignment.h"
26 #include "llvm/Support/MemoryBuffer.h"
27
28 namespace llvm {
29 namespace exegesis {
30
31 static constexpr const char ModuleID[] = "ExegesisInfoTest";
32 static constexpr const char FunctionID[] = "foo";
33 static const Align kFunctionAlignment(4096);
34
35 // Fills the given basic block with register setup code, and returns true if
36 // all registers could be setup correctly.
37 static bool generateSnippetSetupCode(
38     const ExegesisTarget &ET, const MCSubtargetInfo *const MSI,
39     ArrayRef<RegisterValue> RegisterInitialValues, BasicBlockFiller &BBF) {
40   bool IsSnippetSetupComplete = true;
41   for (const RegisterValue &RV : RegisterInitialValues) {
42     // Load a constant in the register.
43     const auto SetRegisterCode = ET.setRegTo(*MSI, RV.Register, RV.Value);
44     if (SetRegisterCode.empty())
45       IsSnippetSetupComplete = false;
46     BBF.addInstructions(SetRegisterCode);
47   }
48   return IsSnippetSetupComplete;
49 }
50
51 // Small utility function to add named passes.
52 static bool addPass(PassManagerBase &PM, StringRef PassName,
53                     TargetPassConfig &TPC) {
54   const PassRegistry *PR = PassRegistry::getPassRegistry();
55   const PassInfo *PI = PR->getPassInfo(PassName);
56   if (!PI) {
57     errs() << " run-pass " << PassName << " is not registered.\n";
58     return true;
59   }
60
61   if (!PI->getNormalCtor()) {
62     errs() << " cannot create pass: " << PI->getPassName() << "\n";
63     return true;
64   }
65   Pass *P = PI->getNormalCtor()();
66   std::string Banner = std::string("After ") + std::string(P->getPassName());
67   PM.add(P);
68   TPC.printAndVerify(Banner);
69
70   return false;
71 }
72
73 MachineFunction &createVoidVoidPtrMachineFunction(StringRef FunctionName,
74                                                   Module *Module,
75                                                   MachineModuleInfo *MMI) {
76   Type *const ReturnType = Type::getInt32Ty(Module->getContext());
77   Type *const MemParamType = PointerType::get(
78       Type::getInt8Ty(Module->getContext()), 0 /*default address space*/);
79   FunctionType *FunctionType =
80       FunctionType::get(ReturnType, {MemParamType}, false);
81   Function *const F = Function::Create(
82       FunctionType, GlobalValue::InternalLinkage, FunctionName, Module);
83   // Making sure we can create a MachineFunction out of this Function even if it
84   // contains no IR.
85   F->setIsMaterializable(true);
86   return MMI->getOrCreateMachineFunction(*F);
87 }
88
89 BasicBlockFiller::BasicBlockFiller(MachineFunction &MF, MachineBasicBlock *MBB,
90                                    const MCInstrInfo *MCII)
91     : MF(MF), MBB(MBB), MCII(MCII) {}
92
93 void BasicBlockFiller::addInstruction(const MCInst &Inst, const DebugLoc &DL) {
94   const unsigned Opcode = Inst.getOpcode();
95   const MCInstrDesc &MCID = MCII->get(Opcode);
96   MachineInstrBuilder Builder = BuildMI(MBB, DL, MCID);
97   for (unsigned OpIndex = 0, E = Inst.getNumOperands(); OpIndex < E;
98        ++OpIndex) {
99     const MCOperand &Op = Inst.getOperand(OpIndex);
100     if (Op.isReg()) {
101       const bool IsDef = OpIndex < MCID.getNumDefs();
102       unsigned Flags = 0;
103       const MCOperandInfo &OpInfo = MCID.operands().begin()[OpIndex];
104       if (IsDef && !OpInfo.isOptionalDef())
105         Flags |= RegState::Define;
106       Builder.addReg(Op.getReg(), Flags);
107     } else if (Op.isImm()) {
108       Builder.addImm(Op.getImm());
109     } else if (!Op.isValid()) {
110       llvm_unreachable("Operand is not set");
111     } else {
112       llvm_unreachable("Not yet implemented");
113     }
114   }
115 }
116
117 void BasicBlockFiller::addInstructions(ArrayRef<MCInst> Insts,
118                                        const DebugLoc &DL) {
119   for (const MCInst &Inst : Insts)
120     addInstruction(Inst, DL);
121 }
122
123 void BasicBlockFiller::addReturn(const DebugLoc &DL) {
124   // Insert the return code.
125   const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
126   if (TII->getReturnOpcode() < TII->getNumOpcodes()) {
127     BuildMI(MBB, DL, TII->get(TII->getReturnOpcode()));
128   } else {
129     MachineIRBuilder MIB(MF);
130     MIB.setMBB(*MBB);
131     MF.getSubtarget().getCallLowering()->lowerReturn(MIB, nullptr, {});
132   }
133 }
134
135 FunctionFiller::FunctionFiller(MachineFunction &MF,
136                                std::vector<unsigned> RegistersSetUp)
137     : MF(MF), MCII(MF.getTarget().getMCInstrInfo()), Entry(addBasicBlock()),
138       RegistersSetUp(std::move(RegistersSetUp)) {}
139
140 BasicBlockFiller FunctionFiller::addBasicBlock() {
141   MachineBasicBlock *MBB = MF.CreateMachineBasicBlock();
142   MF.push_back(MBB);
143   return BasicBlockFiller(MF, MBB, MCII);
144 }
145
146 ArrayRef<unsigned> FunctionFiller::getRegistersSetUp() const {
147   return RegistersSetUp;
148 }
149
150 static std::unique_ptr<Module>
151 createModule(const std::unique_ptr<LLVMContext> &Context, const DataLayout DL) {
152   auto Mod = std::make_unique<Module>(ModuleID, *Context);
153   Mod->setDataLayout(DL);
154   return Mod;
155 }
156
157 BitVector getFunctionReservedRegs(const TargetMachine &TM) {
158   std::unique_ptr<LLVMContext> Context = std::make_unique<LLVMContext>();
159   std::unique_ptr<Module> Module = createModule(Context, TM.createDataLayout());
160   // TODO: This only works for targets implementing LLVMTargetMachine.
161   const LLVMTargetMachine &LLVMTM = static_cast<const LLVMTargetMachine &>(TM);
162   std::unique_ptr<MachineModuleInfoWrapperPass> MMIWP =
163       std::make_unique<MachineModuleInfoWrapperPass>(&LLVMTM);
164   MachineFunction &MF = createVoidVoidPtrMachineFunction(
165       FunctionID, Module.get(), &MMIWP.get()->getMMI());
166   // Saving reserved registers for client.
167   return MF.getSubtarget().getRegisterInfo()->getReservedRegs(MF);
168 }
169
170 void assembleToStream(const ExegesisTarget &ET,
171                       std::unique_ptr<LLVMTargetMachine> TM,
172                       ArrayRef<unsigned> LiveIns,
173                       ArrayRef<RegisterValue> RegisterInitialValues,
174                       const FillFunction &Fill, raw_pwrite_stream &AsmStream) {
175   auto Context = std::make_unique<LLVMContext>();
176   std::unique_ptr<Module> Module =
177       createModule(Context, TM->createDataLayout());
178   auto MMIWP = std::make_unique<MachineModuleInfoWrapperPass>(TM.get());
179   MachineFunction &MF = createVoidVoidPtrMachineFunction(
180       FunctionID, Module.get(), &MMIWP.get()->getMMI());
181   MF.ensureAlignment(kFunctionAlignment);
182
183   // We need to instruct the passes that we're done with SSA and virtual
184   // registers.
185   auto &Properties = MF.getProperties();
186   Properties.set(MachineFunctionProperties::Property::NoVRegs);
187   Properties.reset(MachineFunctionProperties::Property::IsSSA);
188   Properties.set(MachineFunctionProperties::Property::NoPHIs);
189
190   for (const unsigned Reg : LiveIns)
191     MF.getRegInfo().addLiveIn(Reg);
192
193   std::vector<unsigned> RegistersSetUp;
194   for (const auto &InitValue : RegisterInitialValues) {
195     RegistersSetUp.push_back(InitValue.Register);
196   }
197   FunctionFiller Sink(MF, std::move(RegistersSetUp));
198   auto Entry = Sink.getEntry();
199   for (const unsigned Reg : LiveIns)
200     Entry.MBB->addLiveIn(Reg);
201
202   const bool IsSnippetSetupComplete = generateSnippetSetupCode(
203       ET, TM->getMCSubtargetInfo(), RegisterInitialValues, Entry);
204
205   // If the snippet setup is not complete, we disable liveliness tracking. This
206   // means that we won't know what values are in the registers.
207   if (!IsSnippetSetupComplete)
208     Properties.reset(MachineFunctionProperties::Property::TracksLiveness);
209
210   Fill(Sink);
211
212   // prologue/epilogue pass needs the reserved registers to be frozen, this
213   // is usually done by the SelectionDAGISel pass.
214   MF.getRegInfo().freezeReservedRegs(MF);
215
216   // We create the pass manager, run the passes to populate AsmBuffer.
217   MCContext &MCContext = MMIWP->getMMI().getContext();
218   legacy::PassManager PM;
219
220   TargetLibraryInfoImpl TLII(Triple(Module->getTargetTriple()));
221   PM.add(new TargetLibraryInfoWrapperPass(TLII));
222
223   TargetPassConfig *TPC = TM->createPassConfig(PM);
224   PM.add(TPC);
225   PM.add(MMIWP.release());
226   TPC->printAndVerify("MachineFunctionGenerator::assemble");
227   // Add target-specific passes.
228   ET.addTargetSpecificPasses(PM);
229   TPC->printAndVerify("After ExegesisTarget::addTargetSpecificPasses");
230   // Adding the following passes:
231   // - postrapseudos: expands pseudo return instructions used on some targets.
232   // - machineverifier: checks that the MachineFunction is well formed.
233   // - prologepilog: saves and restore callee saved registers.
234   for (const char *PassName :
235        {"postrapseudos", "machineverifier", "prologepilog"})
236     if (addPass(PM, PassName, *TPC))
237       report_fatal_error("Unable to add a mandatory pass");
238   TPC->setInitialized();
239
240   // AsmPrinter is responsible for generating the assembly into AsmBuffer.
241   if (TM->addAsmPrinter(PM, AsmStream, nullptr, TargetMachine::CGFT_ObjectFile,
242                         MCContext))
243     report_fatal_error("Cannot add AsmPrinter passes");
244
245   PM.run(*Module); // Run all the passes
246 }
247
248 object::OwningBinary<object::ObjectFile>
249 getObjectFromBuffer(StringRef InputData) {
250   // Storing the generated assembly into a MemoryBuffer that owns the memory.
251   std::unique_ptr<MemoryBuffer> Buffer =
252       MemoryBuffer::getMemBufferCopy(InputData);
253   // Create the ObjectFile from the MemoryBuffer.
254   std::unique_ptr<object::ObjectFile> Obj =
255       cantFail(object::ObjectFile::createObjectFile(Buffer->getMemBufferRef()));
256   // Returning both the MemoryBuffer and the ObjectFile.
257   return object::OwningBinary<object::ObjectFile>(std::move(Obj),
258                                                   std::move(Buffer));
259 }
260
261 object::OwningBinary<object::ObjectFile> getObjectFromFile(StringRef Filename) {
262   return cantFail(object::ObjectFile::createObjectFile(Filename));
263 }
264
265 namespace {
266
267 // Implementation of this class relies on the fact that a single object with a
268 // single function will be loaded into memory.
269 class TrackingSectionMemoryManager : public SectionMemoryManager {
270 public:
271   explicit TrackingSectionMemoryManager(uintptr_t *CodeSize)
272       : CodeSize(CodeSize) {}
273
274   uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
275                                unsigned SectionID,
276                                StringRef SectionName) override {
277     *CodeSize = Size;
278     return SectionMemoryManager::allocateCodeSection(Size, Alignment, SectionID,
279                                                      SectionName);
280   }
281
282 private:
283   uintptr_t *const CodeSize = nullptr;
284 };
285
286 } // namespace
287
288 ExecutableFunction::ExecutableFunction(
289     std::unique_ptr<LLVMTargetMachine> TM,
290     object::OwningBinary<object::ObjectFile> &&ObjectFileHolder)
291     : Context(std::make_unique<LLVMContext>()) {
292   assert(ObjectFileHolder.getBinary() && "cannot create object file");
293   // Initializing the execution engine.
294   // We need to use the JIT EngineKind to be able to add an object file.
295   LLVMLinkInMCJIT();
296   uintptr_t CodeSize = 0;
297   std::string Error;
298   ExecEngine.reset(
299       EngineBuilder(createModule(Context, TM->createDataLayout()))
300           .setErrorStr(&Error)
301           .setMCPU(TM->getTargetCPU())
302           .setEngineKind(EngineKind::JIT)
303           .setMCJITMemoryManager(
304               std::make_unique<TrackingSectionMemoryManager>(&CodeSize))
305           .create(TM.release()));
306   if (!ExecEngine)
307     report_fatal_error(Error);
308   // Adding the generated object file containing the assembled function.
309   // The ExecutionEngine makes sure the object file is copied into an
310   // executable page.
311   ExecEngine->addObjectFile(std::move(ObjectFileHolder));
312   // Fetching function bytes.
313   const uint64_t FunctionAddress = ExecEngine->getFunctionAddress(FunctionID);
314   assert(isAligned(kFunctionAlignment, FunctionAddress) &&
315          "function is not properly aligned");
316   FunctionBytes =
317       StringRef(reinterpret_cast<const char *>(FunctionAddress), CodeSize);
318 }
319
320 } // namespace exegesis
321 } // namespace llvm