LLVM  4.0.0
IndirectionUtils.cpp
Go to the documentation of this file.
1 //===---- IndirectionUtils.cpp - Utilities for call indirection in Orc ----===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "llvm/ADT/STLExtras.h"
11 #include "llvm/ADT/Triple.h"
14 #include "llvm/IR/CallSite.h"
15 #include "llvm/IR/IRBuilder.h"
17 #include <sstream>
18 
19 namespace llvm {
20 namespace orc {
21 
22 void JITCompileCallbackManager::anchor() {}
23 void IndirectStubsManager::anchor() {}
24 
25 std::unique_ptr<JITCompileCallbackManager>
27  JITTargetAddress ErrorHandlerAddress) {
28  switch (T.getArch()) {
29  default: return nullptr;
30 
31  case Triple::x86: {
33  return llvm::make_unique<CCMgrT>(ErrorHandlerAddress);
34  }
35 
36  case Triple::x86_64: {
37  if ( T.getOS() == Triple::OSType::Win32 ) {
39  return llvm::make_unique<CCMgrT>(ErrorHandlerAddress);
40  } else {
42  return llvm::make_unique<CCMgrT>(ErrorHandlerAddress);
43  }
44  }
45  }
46 }
47 
48 std::function<std::unique_ptr<IndirectStubsManager>()>
50  switch (T.getArch()) {
51  default: return nullptr;
52 
53  case Triple::x86:
54  return [](){
55  return llvm::make_unique<
57  };
58 
59  case Triple::x86_64:
60  if (T.getOS() == Triple::OSType::Win32) {
61  return [](){
62  return llvm::make_unique<
64  };
65  } else {
66  return [](){
67  return llvm::make_unique<
69  };
70  }
71  }
72 }
73 
75  Constant *AddrIntVal =
77  Constant *AddrPtrVal =
78  ConstantExpr::getCast(Instruction::IntToPtr, AddrIntVal,
79  PointerType::get(&FT, 0));
80  return AddrPtrVal;
81 }
82 
84  const Twine &Name, Constant *Initializer) {
85  auto IP = new GlobalVariable(M, &PT, false, GlobalValue::ExternalLinkage,
86  Initializer, Name, nullptr,
88  IP->setVisibility(GlobalValue::HiddenVisibility);
89  return IP;
90 }
91 
92 void makeStub(Function &F, Value &ImplPointer) {
93  assert(F.isDeclaration() && "Can't turn a definition into a stub.");
94  assert(F.getParent() && "Function isn't in a module.");
95  Module &M = *F.getParent();
96  BasicBlock *EntryBlock = BasicBlock::Create(M.getContext(), "entry", &F);
97  IRBuilder<> Builder(EntryBlock);
98  LoadInst *ImplAddr = Builder.CreateLoad(&ImplPointer);
99  std::vector<Value*> CallArgs;
100  for (auto &A : F.args())
101  CallArgs.push_back(&A);
102  CallInst *Call = Builder.CreateCall(ImplAddr, CallArgs);
103  Call->setTailCall();
104  Call->setAttributes(F.getAttributes());
105  if (F.getReturnType()->isVoidTy())
106  Builder.CreateRetVoid();
107  else
108  Builder.CreateRet(Call);
109 }
110 
111 // Utility class for renaming global values and functions during partitioning.
113 public:
114 
115  static bool needsRenaming(const Value &New) {
116  return !New.hasName() || New.getName().startswith("\01L");
117  }
118 
119  const std::string& getRename(const Value &Orig) {
120  // See if we have a name for this global.
121  {
122  auto I = Names.find(&Orig);
123  if (I != Names.end())
124  return I->second;
125  }
126 
127  // Nope. Create a new one.
128  // FIXME: Use a more robust uniquing scheme. (This may blow up if the user
129  // writes a "__orc_anon[[:digit:]]* method).
130  unsigned ID = Names.size();
131  std::ostringstream NameStream;
132  NameStream << "__orc_anon" << ID++;
133  auto I = Names.insert(std::make_pair(&Orig, NameStream.str()));
134  return I.first->second;
135  }
136 private:
138 };
139 
141  if (V.hasLocalLinkage()) {
142  if (R.needsRenaming(V))
143  V.setName(R.getRename(V));
146  }
148  assert(!R.needsRenaming(V) && "Invalid global name.");
149 }
150 
152  GlobalRenamer Renamer;
153 
154  for (auto &F : M)
155  raiseVisibilityOnValue(F, Renamer);
156 
157  for (auto &GV : M.globals())
158  raiseVisibilityOnValue(GV, Renamer);
159 
160  for (auto &A : M.aliases())
161  raiseVisibilityOnValue(A, Renamer);
162 }
163 
165  ValueToValueMapTy *VMap) {
166  assert(F.getParent() != &Dst && "Can't copy decl over existing function.");
167  Function *NewF =
168  Function::Create(cast<FunctionType>(F.getValueType()),
169  F.getLinkage(), F.getName(), &Dst);
170  NewF->copyAttributesFrom(&F);
171 
172  if (VMap) {
173  (*VMap)[&F] = NewF;
174  auto NewArgI = NewF->arg_begin();
175  for (auto ArgI = F.arg_begin(), ArgE = F.arg_end(); ArgI != ArgE;
176  ++ArgI, ++NewArgI)
177  (*VMap)[&*ArgI] = &*NewArgI;
178  }
179 
180  return NewF;
181 }
182 
184  ValueMaterializer *Materializer,
185  Function *NewF) {
186  assert(!OrigF.isDeclaration() && "Nothing to move");
187  if (!NewF)
188  NewF = cast<Function>(VMap[&OrigF]);
189  else
190  assert(VMap[&OrigF] == NewF && "Incorrect function mapping in VMap.");
191  assert(NewF && "Function mapping missing from VMap.");
192  assert(NewF->getParent() != OrigF.getParent() &&
193  "moveFunctionBody should only be used to move bodies between "
194  "modules.");
195 
196  SmallVector<ReturnInst *, 8> Returns; // Ignore returns cloned.
197  CloneFunctionInto(NewF, &OrigF, VMap, /*ModuleLevelChanges=*/true, Returns,
198  "", nullptr, nullptr, Materializer);
199  OrigF.deleteBody();
200 }
201 
203  ValueToValueMapTy *VMap) {
204  assert(GV.getParent() != &Dst && "Can't copy decl over existing global var.");
205  GlobalVariable *NewGV = new GlobalVariable(
206  Dst, GV.getValueType(), GV.isConstant(),
207  GV.getLinkage(), nullptr, GV.getName(), nullptr,
209  NewGV->copyAttributesFrom(&GV);
210  if (VMap)
211  (*VMap)[&GV] = NewGV;
212  return NewGV;
213 }
214 
216  ValueToValueMapTy &VMap,
217  ValueMaterializer *Materializer,
218  GlobalVariable *NewGV) {
219  assert(OrigGV.hasInitializer() && "Nothing to move");
220  if (!NewGV)
221  NewGV = cast<GlobalVariable>(VMap[&OrigGV]);
222  else
223  assert(VMap[&OrigGV] == NewGV &&
224  "Incorrect global variable mapping in VMap.");
225  assert(NewGV->getParent() != OrigGV.getParent() &&
226  "moveGlobalVariable should only be used to move initializers between "
227  "modules");
228 
229  NewGV->setInitializer(MapValue(OrigGV.getInitializer(), VMap, RF_None,
230  nullptr, Materializer));
231 }
232 
234  ValueToValueMapTy &VMap) {
235  assert(OrigA.getAliasee() && "Original alias doesn't have an aliasee?");
236  auto *NewA = GlobalAlias::create(OrigA.getValueType(),
237  OrigA.getType()->getPointerAddressSpace(),
238  OrigA.getLinkage(), OrigA.getName(), &Dst);
239  NewA->copyAttributesFrom(&OrigA);
240  VMap[&OrigA] = NewA;
241  return NewA;
242 }
243 
244 void cloneModuleFlagsMetadata(Module &Dst, const Module &Src,
245  ValueToValueMapTy &VMap) {
246  auto *MFs = Src.getModuleFlagsMetadata();
247  if (!MFs)
248  return;
249  for (auto *MF : MFs->operands())
250  Dst.addModuleFlag(MapMetadata(MF, VMap));
251 }
252 
253 } // End namespace orc.
254 } // End namespace llvm.
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:225
OSType getOS() const
getOS - Get the parsed operating system type of this triple.
Definition: Triple.h:279
LinkageTypes getLinkage() const
Definition: GlobalValue.h:429
IndirectStubsManager implementation for the host architecture, e.g.
virtual void copyAttributesFrom(const GlobalValue *Src)
Copy all additional attributes (those not needed to create a GlobalValue) from the GlobalValue Src to...
Definition: Globals.cpp:66
bool hasName() const
Definition: Value.h:236
std::function< std::unique_ptr< IndirectStubsManager >)> createLocalIndirectStubsManagerBuilder(const Triple &T)
Create a local indriect stubs manager builder.
GlobalAlias * cloneGlobalAliasDecl(Module &Dst, const GlobalAlias &OrigA, ValueToValueMapTy &VMap)
Clone a global alias declaration into a new module.
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
void cloneModuleFlagsMetadata(Module &Dst, const Module &Src, ValueToValueMapTy &VMap)
Clone module flags metadata into the destination module.
Type * getValueType() const
Definition: GlobalValue.h:261
This class represents a function call, abstracting a target machine's calling convention.
static PointerType * get(Type *ElementType, unsigned AddressSpace)
This constructs a pointer to an object of the specified type in a numbered address space...
Definition: Type.cpp:655
static bool needsRenaming(const Value &New)
Externally visible function.
Definition: GlobalValue.h:49
Type * getReturnType() const
Returns the type of the ret val.
Definition: Function.cpp:238
arg_iterator arg_end()
Definition: Function.h:559
unsigned getAddressSpace() const
Return the address space of the Pointer type.
Definition: DerivedTypes.h:471
An instruction for reading from memory.
Definition: Instructions.h:164
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:170
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
const Constant * getAliasee() const
Definition: GlobalAlias.h:74
Manage compile callbacks for in-process JITs.
Metadata * MapMetadata(const Metadata *MD, ValueToValueMapTy &VM, RemapFlags Flags=RF_None, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr)
Lookup or compute a mapping for a piece of metadata.
Definition: ValueMapper.h:220
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:191
const std::string & getRename(const Value &Orig)
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
void setInitializer(Constant *InitVal)
setInitializer - Sets the initializer for this global variable, removing any existing initializer if ...
Definition: Globals.cpp:323
GlobalVariable * createImplPointer(PointerType &PT, Module &M, const Twine &Name, Constant *Initializer)
Create a function pointer with the given type, name, and initializer in the given Module...
void CloneFunctionInto(Function *NewFunc, const Function *OldFunc, ValueToValueMapTy &VMap, bool ModuleLevelChanges, SmallVectorImpl< ReturnInst * > &Returns, const char *NameSuffix="", ClonedCodeInfo *CodeInfo=nullptr, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr)
Clone OldFunc into NewFunc, transforming the old arguments into references to VMap values...
std::unique_ptr< JITCompileCallbackManager > createLocalCompileCallbackManager(const Triple &T, JITTargetAddress ErrorHandlerAddress)
Create a local compile callback manager.
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:588
static void raiseVisibilityOnValue(GlobalValue &V, GlobalRenamer &R)
void moveGlobalVariableInitializer(GlobalVariable &OrigGV, ValueToValueMapTy &VMap, ValueMaterializer *Materializer=nullptr, GlobalVariable *NewGV=nullptr)
Move global variable GV from its parent module to cloned global declaration in a different module...
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:257
void makeStub(Function &F, Value &ImplPointer)
Turn a function declaration into a stub function that makes an indirect call using the given function...
Class to represent function types.
Definition: DerivedTypes.h:102
#define F(x, y, z)
Definition: MD5.cpp:51
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:264
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:128
ArchType getArch() const
getArch - Get the parsed architecture type of this triple.
Definition: Triple.h:270
GlobalVariable * cloneGlobalVariableDecl(Module &Dst, const GlobalVariable &GV, ValueToValueMapTy *VMap=nullptr)
Clone a global variable declaration into a new module.
Class to represent pointers.
Definition: DerivedTypes.h:443
void setAttributes(AttributeSet Attrs)
Set the parameter attributes for this call.
This is a class that can be implemented by clients to materialize Values on demand.
Definition: ValueMapper.h:40
std::enable_if<!std::is_array< T >::value, std::unique_ptr< T > >::type make_unique(Args &&...args)
Constructs a new T() with the given args and returns a unique_ptr<T> which owns the object...
Definition: STLExtras.h:845
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
void deleteBody()
deleteBody - This method deletes the body of the function, and converts the linkage to external...
Definition: Function.h:475
This is an important base class in LLVM.
Definition: Constant.h:42
void getModuleFlagsMetadata(SmallVectorImpl< ModuleFlagEntry > &Flags) const
Returns the module flags in the provided vector.
Definition: Module.cpp:305
void addModuleFlag(ModFlagBehavior Behavior, StringRef Key, Metadata *Val)
Add a module-level flag to the module-level flags metadata.
Definition: Module.cpp:352
void copyAttributesFrom(const GlobalValue *Src) override
copyAttributesFrom - copy all additional attributes (those not needed to create a Function) from the ...
Definition: Function.cpp:431
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:93
uint64_t JITTargetAddress
Represents an address in the target process's address space.
Definition: JITSymbol.h:33
arg_iterator arg_begin()
Definition: Function.h:550
void setTailCall(bool isTC=true)
Value * MapValue(const Value *V, ValueToValueMapTy &VM, RemapFlags Flags=RF_None, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr)
Look up or compute a value in the value map.
Definition: ValueMapper.h:198
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
Constant * createIRTypedAddress(FunctionType &FT, JITTargetAddress Addr)
Build a function pointer of FunctionType with the given constant address.
Function * cloneFunctionDecl(Module &Dst, const Function &F, ValueToValueMapTy *VMap=nullptr)
Clone a function declaration into a new module.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:558
void setLinkage(LinkageTypes LT)
Definition: GlobalValue.h:424
AttributeSet getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:176
bool hasInitializer() const
Definitions have initializers, declarations don't.
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
static Constant * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)
Convenience function for getting a Cast operation.
Definition: Constants.cpp:1452
void makeAllSymbolsExternallyAccessible(Module &M)
Raise linkage types and rename as necessary to ensure that all symbols are accessible for other modul...
ThreadLocalMode getThreadLocalMode() const
Definition: GlobalValue.h:240
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:259
void setUnnamedAddr(UnnamedAddr Val)
Definition: GlobalValue.h:203
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:188
#define I(x, y, z)
Definition: MD5.cpp:54
bool hasLocalLinkage() const
Definition: GlobalValue.h:415
void copyAttributesFrom(const GlobalValue *Src) override
copyAttributesFrom - copy all additional attributes (those not needed to create a GlobalVariable) fro...
Definition: Globals.cpp:346
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:537
LLVM Value Representation.
Definition: Value.h:71
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, const Twine &N="", Module *M=nullptr)
Definition: Function.h:117
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: DerivedTypes.h:479
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
void moveFunctionBody(Function &OrigF, ValueToValueMapTy &VMap, ValueMaterializer *Materializer=nullptr, Function *NewF=nullptr)
Move the body of function 'F' to a cloned function declaration in a different module (See related clo...
static GlobalAlias * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Aliasee, Module *Parent)
If a parent module is specified, the alias is automatically inserted into the end of the specified mo...
Definition: Globals.cpp:384
iterator_range< arg_iterator > args()
Definition: Function.h:568
bool isVoidTy() const
Return true if this is 'void'.
Definition: Type.h:139