1//===-- ModuleUtils.cpp - Functions to manipulate Modules -----------------===// 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 7//===----------------------------------------------------------------------===// 9// This family of functions perform manipulations on Modules. 11//===----------------------------------------------------------------------===// 27#define DEBUG_TYPE "moduleutils" 33// Get the current set of static global constructors and add the new ctor 38 EltTy = cast<StructType>(GVCtor->getValueType()->getArrayElementType());
40unsigned n =
Init->getNumOperands();
42for (
unsigned i = 0; i != n; ++i)
45 GVCtor->eraseFromParent();
49 PointerType::get(M.getContext(),
F->getAddressSpace()), IRB.
getPtrTy());
52// Build a 3 field global_ctor entry. We don't take a comdat key. 63// Create a new initializer. 67// Create the new global variable and replace all uses of 68// the old global variable with the new one. 97 Changed |= (!NewC || NewC !=
C);
107// Create a new initializer. 111// Create the new global variable and replace all uses of 112// the old global variable with the new one. 131for (
Use &
Op : CA->operands())
132Init.insert(cast<Constant>(
Op));
144for (
auto *V : Values)
178if (!ShouldRemove(MaybeRemoved->stripPointerCasts()))
182if (!NewInit.
empty()) {
202if (!M.getModuleFlag(
"kcfi"))
204// Matches CodeGenModule::CreateKCFITypeId in Clang. 207 std::string
Type = MangledType.
str();
208if (M.getModuleFlag(
"cfi-normalize-integers"))
210F.setMetadata(LLVMContext::MD_kcfi_type,
214// If the module was compiled with -fpatchable-function-entry, ensure 215// we use the same patchable-function-prefix. 216if (
auto *MD = mdconst::extract_or_null<ConstantInt>(
217 M.getModuleFlag(
"kcfi-offset"))) {
218if (
unsignedOffset = MD->getZExtValue())
219F.addFnAttr(
"patchable-function-prefix", std::to_string(
Offset));
226assert(!InitName.
empty() &&
"Expected init function name");
228auto *FnTy = FunctionType::get(VoidTy, InitArgTypes,
false);
229auto FnCallee = M.getOrInsertFunction(InitName, FnTy);
230auto *Fn = cast<Function>(FnCallee.getCallee());
231if (Weak && Fn->isDeclaration())
232 Fn->setLinkage(Function::ExternalWeakLinkage);
245// Ensure Ctor cannot be discarded, even if in a comdat. 254assert(!InitName.
empty() &&
"Expected init function name");
256"Sanitizer's init function expects different number of arguments");
268auto *InitFn = cast<Function>(InitFunction.
getCallee());
270 PointerType::get(M.getContext(), InitFn->getAddressSpace());
281if (!VersionCheckName.
empty()) {
283 VersionCheckName, FunctionType::get(IRB.
getVoidTy(), {},
false),
291return std::make_pair(Ctor, InitFunction);
294std::pair<Function *, FunctionCallee>
300assert(!CtorName.
empty() &&
"Expected ctor function name");
302if (
Function *Ctor = M.getFunction(CtorName))
303// FIXME: Sink this logic into the module, similar to the handling of 304// globals. This will make moving to a concurrent model much easier. 305if (Ctor->arg_empty() ||
313 M, CtorName, InitName, InitArgTypes, InitArgs, VersionCheckName, Weak);
314 FunctionsCreatedCallback(Ctor, InitFunction);
315return std::make_pair(Ctor, InitFunction);
328// Find comdats for which all users are dead now. 330for (
Comdat *
C : MaybeDeadComdats) {
332auto *
F = dyn_cast<Function>(GO);
335if (
all_of(
C->getUsers(), IsUserDead))
339// Only keep functions which have no comdat or a dead comdat. 348bool ExportsSymbols =
false;
350if (GV.isDeclaration() || GV.getName().starts_with(
"llvm.") ||
351 !GV.hasExternalLinkage() || GV.hasComdat())
353 ExportsSymbols =
true;
360for (
auto &GV : M->globals())
362for (
auto &GA : M->aliases())
364for (
auto &IF : M->ifuncs())
375return (
"." + Str).str();
380// Embed the memory buffer into the module. 385 ModuleConstant,
"llvm.embedded.object");
390NamedMDNode *MD = M.getOrInsertNamedMetadata(
"llvm.embedded.objects");
404if (FilteredIFuncsToLower.
empty()) {
// Default to lowering all ifuncs 407 IFuncsToLower = AllIFuncs;
410bool UnhandledUsers =
false;
415 PointerType::get(Ctx,
DL.getProgramAddressSpace());
418 ArrayType::get(TableEntryTy, IFuncsToLower.
size());
420Align PtrAlign =
DL.getABITypeAlign(TableEntryTy);
422// Create a global table of function pointers we'll initialize in a global 427 GlobalVariable::NotThreadLocal,
DL.getDefaultGlobalsAddressSpace());
428 FuncPtrTable->setAlignment(PtrAlign);
430// Create a function to initialize the function pointer table. 432 FunctionType::get(
Type::getVoidTy(Ctx),
false), Function::InternalLinkage,
433DL.getProgramAddressSpace(),
"", &M);
438size_t TableIndex = 0;
440Function *ResolvedFunction = GI->getResolverFunction();
442// We don't know what to pass to a resolver function taking arguments 444// FIXME: Is this even valid? clang and gcc don't complain but this 445// probably should be invalid IR. We could just pass through undef. 448 << ResolvedFunction->
getName() <<
" with parameters\n");
449 UnhandledUsers =
true;
453// Initialize the function pointer table. 457 FuncPtrTableTy, FuncPtrTable, 0, TableIndex++));
460// Update all users to load a pointer from the global table. 464// TODO: Should handle constantexpr casts in user instructions. Probably 465// can't do much about constant initializers. 466 UnhandledUsers =
true;
478// If we handled all users, erase the ifunc. 480 GI->eraseFromParent();
485PointerType *ConstantDataTy = PointerType::get(Ctx, 0);
487// TODO: Is this the right priority? Probably should be before any other 489constint Priority = 10;
492return UnhandledUsers;
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Module.h This file contains the declarations for the Module class.
static void appendToUsedList(Module &M, StringRef Name, ArrayRef< GlobalValue * > Values)
static void collectUsedGlobals(GlobalVariable *GV, SmallSetVector< Constant *, 16 > &Init)
static void transformGlobalArray(StringRef ArrayName, Module &M, const GlobalCtorTransformFn &Fn)
static void removeFromUsedList(Module &M, StringRef Name, function_ref< bool(Constant *)> ShouldRemove)
static void appendToGlobalArray(StringRef ArrayName, Module &M, Function *F, int Priority, Constant *Data)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallString class.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
size - Get the array size.
bool empty() const
empty - Check if the array is empty.
Class to represent array types.
LLVM Basic Block Representation.
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
This class represents a function call, abstracting a target machine's calling convention.
static Constant * get(ArrayType *T, ArrayRef< Constant * > V)
static ConstantAsMetadata * get(Constant *C)
static Constant * get(LLVMContext &Context, ArrayRef< ElementTy > Elts)
get() constructor - Return a constant with array type with an element count and element type matching...
static Constant * getPointerCast(Constant *C, Type *Ty)
Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant expression.
static Constant * getPointerBitCastOrAddrSpaceCast(Constant *C, Type *Ty)
Create a BitCast or AddrSpaceCast for a pointer type depending on the address space.
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
static Constant * get(StructType *T, ArrayRef< Constant * > V)
This is an important base class in LLVM.
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
ArrayRef< Type * > params() const
void addFnAttr(Attribute::AttrKind Kind)
Add function attributes to this function.
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
const BasicBlock & getEntryBlock() const
FunctionType * getFunctionType() const
Returns the FunctionType for me.
static Function * createWithDefaultAttr(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Creates a function with some attributes recorded in llvm.module.flags and the LLVMContext applied.
StringRef getSection() const
Get the custom section of this global if it has one.
void setMetadata(unsigned KindID, MDNode *Node)
Set a particular kind of metadata attachment.
void setAlignment(Align Align)
Sets the alignment attribute of the GlobalObject.
void setSection(StringRef S)
Change the section for this global.
ThreadLocalMode getThreadLocalMode() const
unsigned getAddressSpace() const
@ PrivateLinkage
Like Internal, but omit from symbol table.
@ InternalLinkage
Rename collisions when linking (static functions).
@ AppendingLinkage
Special purpose, only applies to global arrays.
Type * getValueType() const
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool hasInitializer() const
Definitions have initializers, declarations don't.
void eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing module and deletes it.
LoadInst * CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align, const char *Name)
Value * CreatePointerCast(Value *V, Type *DestTy, const Twine &Name="")
IntegerType * getInt32Ty()
Fetch the type representing a 32-bit integer.
Value * CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name="")
ConstantInt * getInt32(uint32_t C)
Get a constant 32-bit value.
BranchInst * CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False, MDNode *BranchWeights=nullptr, MDNode *Unpredictable=nullptr)
Create a conditional 'br Cond, TrueDest, FalseDest' instruction.
ReturnInst * CreateRetVoid()
Create a 'ret void' instruction.
Value * CreateConstInBoundsGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1, const Twine &Name="")
CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value * > Args={}, const Twine &Name="", MDNode *FPMathTag=nullptr)
PointerType * getPtrTy(unsigned AddrSpace=0)
Fetch the type representing a pointer.
BranchInst * CreateBr(BasicBlock *Dest)
Create an unconditional 'br label X' instruction.
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block.
Type * getVoidTy()
Fetch the type representing void.
StoreInst * CreateAlignedStore(Value *Val, Value *Ptr, MaybeAlign Align, bool isVolatile=false)
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
This is an important class for using LLVM in a threaded context.
An instruction for reading from memory.
void update(ArrayRef< uint8_t > Data)
Updates the hash for the byte stream provided.
static void stringifyResult(MD5Result &Result, SmallVectorImpl< char > &Str)
Translates the bytes in Res to a hex string that is deposited into Str.
void final(MD5Result &Result)
Finishes off the hash and puts the result in result.
ConstantAsMetadata * createConstant(Constant *C)
Return the given constant as metadata.
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
static MDString * get(LLVMContext &Context, StringRef Str)
size_t getBufferSize() const
const char * getBufferStart() const
Root of the metadata hierarchy.
A Module instance is used to store all the information related to an LLVM module.
void addOperand(MDNode *M)
Class to represent pointers.
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the default address space (address sp...
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
static ReturnInst * Create(LLVMContext &C, Value *retVal=nullptr, InsertPosition InsertBefore=nullptr)
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
bool contains(ConstPtrType Ptr) const
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
A SetVector that performs no allocations if smaller than a certain size.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void reserve(size_type N)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
std::string str() const
str - Get the contents as an std::string.
constexpr bool empty() const
empty - Check if the string is empty.
Class to represent struct types.
static StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
unsigned getNumElements() const
Random access to the elements.
The instances of the Type class are immutable: once they are created, they are never changed.
Type * getArrayElementType() const
static Type * getVoidTy(LLVMContext &C)
static IntegerType * getInt32Ty(LLVMContext &C)
A Use represents the edge between a Value definition and its users.
bool replaceUsesOfWith(Value *From, Value *To)
Replace uses of one Value with another.
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
void setName(const Twine &Name)
Change the name of the value.
StringRef getName() const
Return a constant reference to the value's name.
void takeName(Value *V)
Transfer the name from V to this value.
An efficient, type-erasing, non-owning reference to a callable.
@ C
The default llvm calling convention, compatible with C.
This is an optimization pass for GlobalISel generic memory operations.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Function * createSanitizerCtor(Module &M, StringRef CtorName)
Creates sanitizer constructor function.
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
FunctionCallee declareSanitizerInitFunction(Module &M, StringRef InitName, ArrayRef< Type * > InitArgTypes, bool Weak=false)
void transformGlobalDtors(Module &M, const GlobalCtorTransformFn &Fn)
std::string getUniqueModuleId(Module *M)
Produce a unique identifier for this module by taking the MD5 sum of the names of the module's strong...
std::pair< Function *, FunctionCallee > getOrCreateSanitizerCtorAndInitFunctions(Module &M, StringRef CtorName, StringRef InitName, ArrayRef< Type * > InitArgTypes, ArrayRef< Value * > InitArgs, function_ref< void(Function *, FunctionCallee)> FunctionsCreatedCallback, StringRef VersionCheckName=StringRef(), bool Weak=false)
Creates sanitizer constructor function lazily.
std::pair< Function *, FunctionCallee > createSanitizerCtorAndInitFunctions(Module &M, StringRef CtorName, StringRef InitName, ArrayRef< Type * > InitArgTypes, ArrayRef< Value * > InitArgs, StringRef VersionCheckName=StringRef(), bool Weak=false)
Creates sanitizer constructor function, and calls sanitizer's init function from it.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
void removeFromUsedLists(Module &M, function_ref< bool(Constant *)> ShouldRemove)
Removes global values from the llvm.used and llvm.compiler.used arrays.
void appendToCompilerUsed(Module &M, ArrayRef< GlobalValue * > Values)
Adds global values to the llvm.compiler.used list.
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.
void setKCFIType(Module &M, Function &F, StringRef MangledType)
Sets the KCFI type for the function.
void transformGlobalCtors(Module &M, const GlobalCtorTransformFn &Fn)
void erase_if(Container &C, UnaryPredicate P)
Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...
void filterDeadComdatFunctions(SmallVectorImpl< Function * > &DeadComdatFunctions)
Filter out potentially dead comdat functions where other entries keep the entire comdat group alive.
void embedBufferInModule(Module &M, MemoryBufferRef Buf, StringRef SectionName, Align Alignment=Align(1))
Embed the memory buffer Buf into the module M as a global using the specified section name.
bool lowerGlobalIFuncUsersAsGlobalCtor(Module &M, ArrayRef< GlobalIFunc * > IFuncsToLower={})
Lower all calls to ifuncs by replacing uses with indirect calls loaded out of a global table initiali...
void appendToUsed(Module &M, ArrayRef< GlobalValue * > Values)
Adds global values to the llvm.used list.
void appendToGlobalDtors(Module &M, Function *F, int Priority, Constant *Data=nullptr)
Same as appendToGlobalCtors(), but for global dtors.
uint64_t xxHash64(llvm::StringRef Data)
This struct is a compact representation of a valid (non-zero power of two) alignment.
