LLVM  10.0.0svn
CompileUtils.cpp
Go to the documentation of this file.
1 //===------ CompileUtils.cpp - Utilities for compiling IR in the JIT ------===//
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 
10 
11 #include "llvm/ADT/SmallVector.h"
14 #include "llvm/IR/Module.h"
15 #include "llvm/Object/ObjectFile.h"
16 #include "llvm/Support/Error.h"
21 
22 #include <algorithm>
23 
24 namespace llvm {
25 namespace orc {
26 
27 /// Compile a Module to an ObjectFile.
29  CompileResult CachedObject = tryToLoadFromObjectCache(M);
30  if (CachedObject)
31  return CachedObject;
32 
33  SmallVector<char, 0> ObjBufferSV;
34 
35  {
36  raw_svector_ostream ObjStream(ObjBufferSV);
37 
39  MCContext *Ctx;
40  if (TM.addPassesToEmitMC(PM, Ctx, ObjStream))
41  llvm_unreachable("Target does not support MC emission.");
42  PM.run(M);
43  }
44 
45  auto ObjBuffer = std::make_unique<SmallVectorMemoryBuffer>(
46  std::move(ObjBufferSV),
47  "<in memory object compiled from " + M.getModuleIdentifier() + ">");
48 
49  auto Obj = object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef());
50 
51  if (Obj) {
52  notifyObjectCompiled(M, *ObjBuffer);
53  return std::move(ObjBuffer);
54  }
55 
56  // TODO: Actually report errors helpfully.
57  consumeError(Obj.takeError());
58  return nullptr;
59 }
60 
62 SimpleCompiler::tryToLoadFromObjectCache(const Module &M) {
63  if (!ObjCache)
64  return CompileResult();
65 
66  return ObjCache->getObject(&M);
67 }
68 
69 void SimpleCompiler::notifyObjectCompiled(const Module &M,
70  const MemoryBuffer &ObjBuffer) {
71  if (ObjCache)
72  ObjCache->notifyObjectCompiled(&M, ObjBuffer.getMemBufferRef());
73 }
74 
76  ObjectCache *ObjCache)
77  : JTMB(std::move(JTMB)), ObjCache(ObjCache) {}
78 
79 std::unique_ptr<MemoryBuffer> ConcurrentIRCompiler::operator()(Module &M) {
80  auto TM = cantFail(JTMB.createTargetMachine());
81  SimpleCompiler C(*TM, ObjCache);
82  return C(M);
83 }
84 
85 } // end namespace orc
86 } // end namespace llvm
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
Definition: Error.h:703
uint64_t CallInst * C
static Expected< OwningBinary< ObjectFile > > createObjectFile(StringRef ObjectPath)
Definition: ObjectFile.cpp:168
This class represents lattice values for constants.
Definition: AllocatorList.h:23
virtual bool addPassesToEmitMC(PassManagerBase &, MCContext *&, raw_pwrite_stream &, bool=true)
Add passes to the specified pass manager to get machine code emitted with the MCJIT.
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:66
virtual std::unique_ptr< MemoryBuffer > getObject(const Module *M)=0
Returns a pointer to a newly allocated MemoryBuffer that contains the object which corresponds with M...
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:530
Definition: BitVector.h:937
Simple compile functor: Takes a single IR module and returns an ObjectFile.
Definition: CompileUtils.h:34
Context object for machine code objects.
Definition: MCContext.h:65
PassManager manages ModulePassManagers.
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1001
bool run(Module &M)
run - Execute all of the passes scheduled for execution.
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
Definition: Module.h:211
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
virtual void notifyObjectCompiled(const Module *M, MemoryBufferRef Obj)=0
notifyObjectCompiled - Provides a pointer to compiled code for Module M.
ConcurrentIRCompiler(JITTargetMachineBuilder JTMB, ObjectCache *ObjCache=nullptr)
Module.h This file contains the declarations for the Module class.
MemoryBufferRef getMemBufferRef() const
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:41
std::unique_ptr< MemoryBuffer > operator()(Module &M)
Expected< std::unique_ptr< TargetMachine > > createTargetMachine()
Create a TargetMachine.
This is the base ObjectCache type which can be provided to an ExecutionEngine for the purpose of avoi...
Definition: ObjectCache.h:22
std::unique_ptr< MemoryBuffer > CompileResult
Definition: CompileUtils.h:36
CompileResult operator()(Module &M)
Compile a Module to an ObjectFile.
A utility class for building TargetMachines for JITs.