LLVM  4.0.0
ModuleUtils.cpp
Go to the documentation of this file.
1 //===-- ModuleUtils.cpp - Functions to manipulate Modules -----------------===//
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 // This family of functions perform manipulations on Modules.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "llvm/IR/DerivedTypes.h"
16 #include "llvm/IR/Function.h"
17 #include "llvm/IR/IRBuilder.h"
18 #include "llvm/IR/Module.h"
20 
21 using namespace llvm;
22 
23 static void appendToGlobalArray(const char *Array, Module &M, Function *F,
24  int Priority, Constant *Data) {
25  IRBuilder<> IRB(M.getContext());
26  FunctionType *FnTy = FunctionType::get(IRB.getVoidTy(), false);
27 
28  // Get the current set of static global constructors and add the new ctor
29  // to the list.
30  SmallVector<Constant *, 16> CurrentCtors;
31  StructType *EltTy;
32  if (GlobalVariable *GVCtor = M.getNamedGlobal(Array)) {
33  ArrayType *ATy = cast<ArrayType>(GVCtor->getValueType());
34  StructType *OldEltTy = cast<StructType>(ATy->getElementType());
35  // Upgrade a 2-field global array type to the new 3-field format if needed.
36  if (Data && OldEltTy->getNumElements() < 3)
37  EltTy = StructType::get(IRB.getInt32Ty(), PointerType::getUnqual(FnTy),
38  IRB.getInt8PtrTy(), nullptr);
39  else
40  EltTy = OldEltTy;
41  if (Constant *Init = GVCtor->getInitializer()) {
42  unsigned n = Init->getNumOperands();
43  CurrentCtors.reserve(n + 1);
44  for (unsigned i = 0; i != n; ++i) {
45  auto Ctor = cast<Constant>(Init->getOperand(i));
46  if (EltTy != OldEltTy)
47  Ctor = ConstantStruct::get(
48  EltTy, Ctor->getAggregateElement((unsigned)0),
49  Ctor->getAggregateElement(1),
50  Constant::getNullValue(IRB.getInt8PtrTy()), nullptr);
51  CurrentCtors.push_back(Ctor);
52  }
53  }
54  GVCtor->eraseFromParent();
55  } else {
56  // Use the new three-field struct if there isn't one already.
57  EltTy = StructType::get(IRB.getInt32Ty(), PointerType::getUnqual(FnTy),
58  IRB.getInt8PtrTy(), nullptr);
59  }
60 
61  // Build a 2 or 3 field global_ctor entry. We don't take a comdat key.
62  Constant *CSVals[3];
63  CSVals[0] = IRB.getInt32(Priority);
64  CSVals[1] = F;
65  // FIXME: Drop support for the two element form in LLVM 4.0.
66  if (EltTy->getNumElements() >= 3)
67  CSVals[2] = Data ? ConstantExpr::getPointerCast(Data, IRB.getInt8PtrTy())
68  : Constant::getNullValue(IRB.getInt8PtrTy());
69  Constant *RuntimeCtorInit =
70  ConstantStruct::get(EltTy, makeArrayRef(CSVals, EltTy->getNumElements()));
71 
72  CurrentCtors.push_back(RuntimeCtorInit);
73 
74  // Create a new initializer.
75  ArrayType *AT = ArrayType::get(EltTy, CurrentCtors.size());
76  Constant *NewInit = ConstantArray::get(AT, CurrentCtors);
77 
78  // Create the new global variable and replace all uses of
79  // the old global variable with the new one.
80  (void)new GlobalVariable(M, NewInit->getType(), false,
81  GlobalValue::AppendingLinkage, NewInit, Array);
82 }
83 
84 void llvm::appendToGlobalCtors(Module &M, Function *F, int Priority, Constant *Data) {
85  appendToGlobalArray("llvm.global_ctors", M, F, Priority, Data);
86 }
87 
88 void llvm::appendToGlobalDtors(Module &M, Function *F, int Priority, Constant *Data) {
89  appendToGlobalArray("llvm.global_dtors", M, F, Priority, Data);
90 }
91 
93  GlobalVariable *GV = M.getGlobalVariable(Name);
96  if (GV) {
98  for (auto &Op : CA->operands()) {
99  Constant *C = cast_or_null<Constant>(Op);
100  if (InitAsSet.insert(C).second)
101  Init.push_back(C);
102  }
103  GV->eraseFromParent();
104  }
105 
106  Type *Int8PtrTy = llvm::Type::getInt8PtrTy(M.getContext());
107  for (auto *V : Values) {
108  Constant *C = ConstantExpr::getBitCast(V, Int8PtrTy);
109  if (InitAsSet.insert(C).second)
110  Init.push_back(C);
111  }
112 
113  if (Init.empty())
114  return;
115 
116  ArrayType *ATy = ArrayType::get(Int8PtrTy, Init.size());
117  GV = new llvm::GlobalVariable(M, ATy, false, GlobalValue::AppendingLinkage,
118  ConstantArray::get(ATy, Init), Name);
119  GV->setSection("llvm.metadata");
120 }
121 
123  appendToUsedList(M, "llvm.used", Values);
124 }
125 
127  appendToUsedList(M, "llvm.compiler.used", Values);
128 }
129 
131  if (isa<Function>(FuncOrBitcast))
132  return cast<Function>(FuncOrBitcast);
133  FuncOrBitcast->dump();
134  std::string Err;
135  raw_string_ostream Stream(Err);
136  Stream << "Sanitizer interface function redefined: " << *FuncOrBitcast;
137  report_fatal_error(Err);
138 }
139 
140 std::pair<Function *, Function *> llvm::createSanitizerCtorAndInitFunctions(
141  Module &M, StringRef CtorName, StringRef InitName,
142  ArrayRef<Type *> InitArgTypes, ArrayRef<Value *> InitArgs,
143  StringRef VersionCheckName) {
144  assert(!InitName.empty() && "Expected init function name");
145  assert(InitArgs.size() == InitArgTypes.size() &&
146  "Sanitizer's init function expects different number of arguments");
147  Function *Ctor = Function::Create(
149  GlobalValue::InternalLinkage, CtorName, &M);
150  BasicBlock *CtorBB = BasicBlock::Create(M.getContext(), "", Ctor);
151  IRBuilder<> IRB(ReturnInst::Create(M.getContext(), CtorBB));
152  Function *InitFunction =
154  InitName, FunctionType::get(IRB.getVoidTy(), InitArgTypes, false),
155  AttributeSet()));
156  InitFunction->setLinkage(Function::ExternalLinkage);
157  IRB.CreateCall(InitFunction, InitArgs);
158  if (!VersionCheckName.empty()) {
159  Function *VersionCheckFunction =
161  VersionCheckName, FunctionType::get(IRB.getVoidTy(), {}, false),
162  AttributeSet()));
163  IRB.CreateCall(VersionCheckFunction, {});
164  }
165  return std::make_pair(Ctor, InitFunction);
166 }
167 
169  Module &M, SmallVectorImpl<Function *> &DeadComdatFunctions) {
170  // Build a map from the comdat to the number of entries in that comdat we
171  // think are dead. If this fully covers the comdat group, then the entire
172  // group is dead. If we find another entry in the comdat group though, we'll
173  // have to preserve the whole group.
174  SmallDenseMap<Comdat *, int, 16> ComdatEntriesCovered;
175  for (Function *F : DeadComdatFunctions) {
176  Comdat *C = F->getComdat();
177  assert(C && "Expected all input GVs to be in a comdat!");
178  ComdatEntriesCovered[C] += 1;
179  }
180 
181  auto CheckComdat = [&](Comdat &C) {
182  auto CI = ComdatEntriesCovered.find(&C);
183  if (CI == ComdatEntriesCovered.end())
184  return;
185 
186  // If this could have been covered by a dead entry, just subtract one to
187  // account for it.
188  if (CI->second > 0) {
189  CI->second -= 1;
190  return;
191  }
192 
193  // If we've already accounted for all the entries that were dead, the
194  // entire comdat is alive so remove it from the map.
195  ComdatEntriesCovered.erase(CI);
196  };
197 
198  auto CheckAllComdats = [&] {
199  for (Function &F : M.functions())
200  if (Comdat *C = F.getComdat()) {
201  CheckComdat(*C);
202  if (ComdatEntriesCovered.empty())
203  return;
204  }
205  for (GlobalVariable &GV : M.globals())
206  if (Comdat *C = GV.getComdat()) {
207  CheckComdat(*C);
208  if (ComdatEntriesCovered.empty())
209  return;
210  }
211  for (GlobalAlias &GA : M.aliases())
212  if (Comdat *C = GA.getComdat()) {
213  CheckComdat(*C);
214  if (ComdatEntriesCovered.empty())
215  return;
216  }
217  };
218  CheckAllComdats();
219 
220  if (ComdatEntriesCovered.empty()) {
221  DeadComdatFunctions.clear();
222  return;
223  }
224 
225  // Remove the entries that were not covering.
226  erase_if(DeadComdatFunctions, [&](GlobalValue *GV) {
227  return ComdatEntriesCovered.find(GV->getComdat()) ==
228  ComdatEntriesCovered.end();
229  });
230 }
void appendToGlobalDtors(Module &M, Function *F, int Priority, Constant *Data=nullptr)
Same as appendToGlobalCtors(), but for global dtors.
Definition: ModuleUtils.cpp:88
Special purpose, only applies to global arrays.
Definition: GlobalValue.h:55
Function * checkSanitizerInterfaceFunction(Constant *FuncOrBitcast)
void appendToCompilerUsed(Module &M, ArrayRef< GlobalValue * > Values)
Adds global values to the llvm.compiler.used list.
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
size_t i
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
Externally visible function.
Definition: GlobalValue.h:49
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Definition: Constants.cpp:195
static ReturnInst * Create(LLVMContext &C, Value *retVal=nullptr, Instruction *InsertBefore=nullptr)
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:440
Class to represent struct types.
Definition: DerivedTypes.h:199
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:32
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:588
void filterDeadComdatFunctions(Module &M, SmallVectorImpl< Function * > &DeadComdatFunctions)
Filter out potentially dead comdat functions where other entries keep the entire comdat group alive...
void eraseFromParent() override
eraseFromParent - This method unlinks 'this' from the containing module and deletes it...
Definition: Globals.cpp:319
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:60
Class to represent function types.
Definition: DerivedTypes.h:102
#define F(x, y, z)
Definition: MD5.cpp:51
Class to represent array types.
Definition: DerivedTypes.h:345
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:291
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
Type * getElementType() const
Definition: DerivedTypes.h:336
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:141
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1695
iterator_range< iterator > functions()
Definition: Module.h:546
Constant * getOrInsertFunction(StringRef Name, FunctionType *T, AttributeSet AttributeList)
Look up the specified function in the module symbol table.
Definition: Module.cpp:123
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important base class in LLVM.
Definition: Constant.h:42
static void appendToGlobalArray(const char *Array, Module &M, Function *F, int Priority, Constant *Data)
Definition: ModuleUtils.cpp:23
static Constant * get(ArrayType *T, ArrayRef< Constant * > V)
Definition: Constants.cpp:888
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:368
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:154
op_range operands()
Definition: User.h:213
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:93
static Constant * get(StructType *T, ArrayRef< Constant * > V)
Definition: Constants.cpp:949
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:213
void dump() const
Support for debugging, callable in GDB: V->dump()
Definition: AsmWriter.cpp:3540
static Constant * getPointerCast(Constant *C, Type *Ty)
Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant expression.
Definition: Constants.cpp:1509
std::pair< Function *, Function * > createSanitizerCtorAndInitFunctions(Module &M, StringRef CtorName, StringRef InitName, ArrayRef< Type * > InitArgTypes, ArrayRef< Value * > InitArgs, StringRef VersionCheckName=StringRef())
Creates sanitizer constructor function, and calls sanitizer's init function from it.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:425
Comdat * getComdat()
Definition: Globals.cpp:155
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the generic address space (address sp...
Definition: DerivedTypes.h:458
static StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
Definition: Type.cpp:330
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
Module.h This file contains the declarations for the Module class.
GlobalVariable * getNamedGlobal(StringRef Name)
Return the global variable in the module with the specified name, of arbitrary type.
Definition: Module.h:357
void appendToGlobalCtors(Module &M, Function *F, int Priority, Constant *Data=nullptr)
Append F to the list of global ctors of module M with the given Priority.
Definition: ModuleUtils.cpp:84
void setLinkage(LinkageTypes LT)
Definition: GlobalValue.h:424
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
void erase_if(Container &C, UnaryPredicate P)
Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...
Definition: STLExtras.h:826
ConstantArray - Constant Array Declarations.
Definition: Constants.h:411
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:130
static void appendToUsedList(Module &M, StringRef Name, ArrayRef< GlobalValue * > Values)
Definition: ModuleUtils.cpp:92
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:135
static ArrayType * get(Type *ElementType, uint64_t NumElements)
This static method is the primary way to construct an ArrayType.
Definition: Type.cpp:606
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:287
Rename collisions when linking (static functions).
Definition: GlobalValue.h:56
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:463
void appendToUsed(Module &M, ArrayRef< GlobalValue * > Values)
Adds global values to the llvm.used list.
iterator_range< global_iterator > globals()
Definition: Module.h:524
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, const Twine &N="", Module *M=nullptr)
Definition: Function.h:117
unsigned getNumElements() const
Random access to the elements.
Definition: DerivedTypes.h:289
GlobalVariable * getGlobalVariable(StringRef Name) const
Look up the specified global variable in the module symbol table.
Definition: Module.h:344
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:222
iterator_range< alias_iterator > aliases()
Definition: Module.h:564