ModuleUtils.cpp Source File (original) (raw)

25using namespace llvm;

27#define DEBUG_TYPE "moduleutils"

30 int Priority, Constant *Data) {

37 if (GlobalVariable *GVCtor = M.getNamedGlobal(ArrayName)) {

38 EltTy = cast(GVCtor->getValueType()->getArrayElementType());

39 if (Constant *Init = GVCtor->getInitializer()) {

40 unsigned n = Init->getNumOperands();

41 CurrentCtors.reserve(n + 1);

42 for (unsigned i = 0; i != n; ++i)

43 CurrentCtors.push_back(cast(Init->getOperand(i)));

44 }

45 GVCtor->eraseFromParent();

46 } else {

49 PointerType::get(M.getContext(), F->getAddressSpace()), IRB.getPtrTy());

50 }

54 CSVals[0] = IRB.getInt32(Priority);

55 CSVals[1] = F;

61 CurrentCtors.push_back(RuntimeCtorInit);

64 ArrayType *AT = ArrayType::get(EltTy, CurrentCtors.size());

71}

75}

79}

84 if (!GVCtor)

85 return;

89 bool Changed = false;

93 CurrentCtors.reserve(Init->getNumOperands());

97 Changed |= (!NewC || NewC != C);

98 if (NewC)

100 }

101 }

102 if (!Changed)

103 return;

104

106

107

108 ArrayType *AT = ArrayType::get(EltTy, CurrentCtors.size());

110

111

112

115}

116

119}

120

123}

124

128 return;

129

130 auto *CA = cast(GV->getInitializer());

131 for (Use &Op : CA->operands())

132 Init.insert(cast(Op));

133}

134

137

140 if (GV)

142

144 for (auto *V : Values)

146

147 if (Init.empty())

148 return;

149

150 ArrayType *ATy = ArrayType::get(ArrayEltTy, Init.size());

155}

156

159}

160

163}

164

168 if (!GV)

169 return;

170

173

174 Type *ArrayEltTy = cast(GV->getValueType())->getElementType();

175

178 if (!ShouldRemove(MaybeRemoved->stripPointerCasts()))

180 }

181

182 if (!NewInit.empty()) {

183 ArrayType *ATy = ArrayType::get(ArrayEltTy, NewInit.size());

190 }

191

193}

194

199}

200

202 if (!M.getModuleFlag("kcfi"))

203 return;

204

207 std::string Type = MangledType.str();

208 if (M.getModuleFlag("cfi-normalize-integers"))

209 Type += ".normalized";

210 F.setMetadata(LLVMContext::MD_kcfi_type,

214

215

216 if (auto *MD = mdconst::extract_or_null(

217 M.getModuleFlag("kcfi-offset"))) {

218 if (unsigned Offset = MD->getZExtValue())

219 F.addFnAttr("patchable-function-prefix", std::to_string(Offset));

220 }

221}

222

225 bool Weak) {

226 assert(!InitName.empty() && "Expected init function name");

228 auto *FnTy = FunctionType::get(VoidTy, InitArgTypes, false);

229 auto FnCallee = M.getOrInsertFunction(InitName, FnTy);

230 auto *Fn = cast(FnCallee.getCallee());

231 if (Weak && Fn->isDeclaration())

232 Fn->setLinkage(Function::ExternalWeakLinkage);

233 return FnCallee;

234}

235

238 FunctionType::get(Type::getVoidTy(M.getContext()), false),

240 CtorName, &M);

241 Ctor->addFnAttr(Attribute::NoUnwind);

242 setKCFIType(M, *Ctor, "_ZTSFvvE");

245

247 return Ctor;

248}

249

253 StringRef VersionCheckName, bool Weak) {

254 assert(!InitName.empty() && "Expected init function name");

256 "Sanitizer's init function expects different number of arguments");

261

263 if (Weak) {

265 auto *EntryBB = BasicBlock::Create(M.getContext(), "entry", Ctor, RetBB);

266 auto *CallInitBB =

268 auto *InitFn = cast(InitFunction.getCallee());

269 auto *InitFnPtr =

270 PointerType::get(M.getContext(), InitFn->getAddressSpace());

272 Value *InitNotNull =

274 IRB.CreateCondBr(InitNotNull, CallInitBB, RetBB);

276 } else {

278 }

279

280 IRB.CreateCall(InitFunction, InitArgs);

281 if (!VersionCheckName.empty()) {

282 FunctionCallee VersionCheckFunction = M.getOrInsertFunction(

283 VersionCheckName, FunctionType::get(IRB.getVoidTy(), {}, false),

285 IRB.CreateCall(VersionCheckFunction, {});

286 }

287

288 if (Weak)

290

291 return std::make_pair(Ctor, InitFunction);

292}

293

294std::pair<Function *, FunctionCallee>

299 StringRef VersionCheckName, bool Weak) {

300 assert(!CtorName.empty() && "Expected ctor function name");

301

302 if (Function *Ctor = M.getFunction(CtorName))

303

304

305 if (Ctor->arg_empty() ||

306 Ctor->getReturnType() == Type::getVoidTy(M.getContext()))

307 return {Ctor,

309

313 M, CtorName, InitName, InitArgTypes, InitArgs, VersionCheckName, Weak);

314 FunctionsCreatedCallback(Ctor, InitFunction);

315 return std::make_pair(Ctor, InitFunction);

316}

317

322 for (Function *F : DeadComdatFunctions) {

323 MaybeDeadFunctions.insert(F);

324 if (Comdat *C = F->getComdat())

325 MaybeDeadComdats.insert(C);

326 }

327

328

330 for (Comdat *C : MaybeDeadComdats) {

332 auto *F = dyn_cast(GO);

333 return F && MaybeDeadFunctions.contains(F);

334 };

335 if (all_of(C->getUsers(), IsUserDead))

337 }

338

339

342 return C && !DeadComdats.contains(C);

343 });

344}

345

348 bool ExportsSymbols = false;

350 if (GV.isDeclaration() || GV.getName().starts_with("llvm.") ||

351 !GV.hasExternalLinkage() || GV.hasComdat())

352 return;

353 ExportsSymbols = true;

354 Md5.update(GV.getName());

356 };

357

358 for (auto &F : *M)

359 AddGlobal(F);

360 for (auto &GV : M->globals())

361 AddGlobal(GV);

362 for (auto &GA : M->aliases())

363 AddGlobal(GA);

364 for (auto &IF : M->ifuncs())

365 AddGlobal(IF);

366

367 if (!ExportsSymbols)

368 return "";

369

372

375 return ("." + Str).str();

376}

377

380

385 ModuleConstant, "llvm.embedded.object");

388

390 NamedMDNode *MD = M.getOrInsertNamedMetadata("llvm.embedded.objects");

393

396

398}

399

404 if (FilteredIFuncsToLower.empty()) {

407 IFuncsToLower = AllIFuncs;

408 }

409

410 bool UnhandledUsers = false;

413

415 PointerType::get(Ctx, DL.getProgramAddressSpace());

416

418 ArrayType::get(TableEntryTy, IFuncsToLower.size());

419

420 Align PtrAlign = DL.getABITypeAlign(TableEntryTy);

421

422

423

427 GlobalVariable::NotThreadLocal, DL.getDefaultGlobalsAddressSpace());

428 FuncPtrTable->setAlignment(PtrAlign);

429

430

432 FunctionType::get(Type::getVoidTy(Ctx), false), Function::InternalLinkage,

433 DL.getProgramAddressSpace(), "", &M);

434

437

438 size_t TableIndex = 0;

440 Function *ResolvedFunction = GI->getResolverFunction();

441

442

443

444

445

447 LLVM_DEBUG(dbgs() << "Not lowering ifunc resolver function "

448 << ResolvedFunction->getName() << " with parameters\n");

449 UnhandledUsers = true;

450 continue;

451 }

452

453

457 FuncPtrTableTy, FuncPtrTable, 0, TableIndex++));

459

460

463 if (!UserInst) {

464

465

466 UnhandledUsers = true;

467 continue;

468 }

469

473 Value *ResolvedCast =

476 }

477

478

479 if (GI->use_empty())

480 GI->eraseFromParent();

481 }

482

484

485 PointerType *ConstantDataTy = PointerType::get(Ctx, 0);

486

487

488

489 const int Priority = 10;

492 return UnhandledUsers;

493}

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 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

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.