1 //===-- ModuleUtils.cpp - Functions to manipulate Modules -----------------===// 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 // 9 // This family of functions perform manipulations on Modules. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/Transforms/Utils/ModuleUtils.h" 14 #include "llvm/Analysis/TargetLibraryInfo.h" 15 #include "llvm/Analysis/VectorUtils.h" 16 #include "llvm/IR/DerivedTypes.h" 17 #include "llvm/IR/Function.h" 18 #include "llvm/IR/IRBuilder.h" 19 #include "llvm/IR/Module.h" 20 #include "llvm/Support/raw_ostream.h" 21 using namespace llvm; 22 23 #define DEBUG_TYPE "moduleutils" 24 25 static void appendToGlobalArray(const char *Array, Module &M, Function *F, 26 int Priority, Constant *Data) { 27 IRBuilder<> IRB(M.getContext()); 28 FunctionType *FnTy = FunctionType::get(IRB.getVoidTy(), false); 29 30 // Get the current set of static global constructors and add the new ctor 31 // to the list. 32 SmallVector<Constant *, 16> CurrentCtors; 33 StructType *EltTy = StructType::get( 34 IRB.getInt32Ty(), PointerType::getUnqual(FnTy), IRB.getInt8PtrTy()); 35 if (GlobalVariable *GVCtor = M.getNamedGlobal(Array)) { 36 if (Constant *Init = GVCtor->getInitializer()) { 37 unsigned n = Init->getNumOperands(); 38 CurrentCtors.reserve(n + 1); 39 for (unsigned i = 0; i != n; ++i) 40 CurrentCtors.push_back(cast<Constant>(Init->getOperand(i))); 41 } 42 GVCtor->eraseFromParent(); 43 } 44 45 // Build a 3 field global_ctor entry. We don't take a comdat key. 46 Constant *CSVals[3]; 47 CSVals[0] = IRB.getInt32(Priority); 48 CSVals[1] = F; 49 CSVals[2] = Data ? ConstantExpr::getPointerCast(Data, IRB.getInt8PtrTy()) 50 : Constant::getNullValue(IRB.getInt8PtrTy()); 51 Constant *RuntimeCtorInit = 52 ConstantStruct::get(EltTy, makeArrayRef(CSVals, EltTy->getNumElements())); 53 54 CurrentCtors.push_back(RuntimeCtorInit); 55 56 // Create a new initializer. 57 ArrayType *AT = ArrayType::get(EltTy, CurrentCtors.size()); 58 Constant *NewInit = ConstantArray::get(AT, CurrentCtors); 59 60 // Create the new global variable and replace all uses of 61 // the old global variable with the new one. 62 (void)new GlobalVariable(M, NewInit->getType(), false, 63 GlobalValue::AppendingLinkage, NewInit, Array); 64 } 65 66 void llvm::appendToGlobalCtors(Module &M, Function *F, int Priority, Constant *Data) { 67 appendToGlobalArray("llvm.global_ctors", M, F, Priority, Data); 68 } 69 70 void llvm::appendToGlobalDtors(Module &M, Function *F, int Priority, Constant *Data) { 71 appendToGlobalArray("llvm.global_dtors", M, F, Priority, Data); 72 } 73 74 static void appendToUsedList(Module &M, StringRef Name, ArrayRef<GlobalValue *> Values) { 75 GlobalVariable *GV = M.getGlobalVariable(Name); 76 SmallPtrSet<Constant *, 16> InitAsSet; 77 SmallVector<Constant *, 16> Init; 78 if (GV) { 79 if (GV->hasInitializer()) { 80 auto *CA = cast<ConstantArray>(GV->getInitializer()); 81 for (auto &Op : CA->operands()) { 82 Constant *C = cast_or_null<Constant>(Op); 83 if (InitAsSet.insert(C).second) 84 Init.push_back(C); 85 } 86 } 87 GV->eraseFromParent(); 88 } 89 90 Type *Int8PtrTy = llvm::Type::getInt8PtrTy(M.getContext()); 91 for (auto *V : Values) { 92 Constant *C = ConstantExpr::getPointerBitCastOrAddrSpaceCast(V, Int8PtrTy); 93 if (InitAsSet.insert(C).second) 94 Init.push_back(C); 95 } 96 97 if (Init.empty()) 98 return; 99 100 ArrayType *ATy = ArrayType::get(Int8PtrTy, Init.size()); 101 GV = new llvm::GlobalVariable(M, ATy, false, GlobalValue::AppendingLinkage, 102 ConstantArray::get(ATy, Init), Name); 103 GV->setSection("llvm.metadata"); 104 } 105 106 void llvm::appendToUsed(Module &M, ArrayRef<GlobalValue *> Values) { 107 appendToUsedList(M, "llvm.used", Values); 108 } 109 110 void llvm::appendToCompilerUsed(Module &M, ArrayRef<GlobalValue *> Values) { 111 appendToUsedList(M, "llvm.compiler.used", Values); 112 } 113 114 FunctionCallee 115 llvm::declareSanitizerInitFunction(Module &M, StringRef InitName, 116 ArrayRef<Type *> InitArgTypes) { 117 assert(!InitName.empty() && "Expected init function name"); 118 return M.getOrInsertFunction( 119 InitName, 120 FunctionType::get(Type::getVoidTy(M.getContext()), InitArgTypes, false), 121 AttributeList()); 122 } 123 124 Function *llvm::createSanitizerCtor(Module &M, StringRef CtorName) { 125 Function *Ctor = Function::createWithDefaultAttr( 126 FunctionType::get(Type::getVoidTy(M.getContext()), false), 127 GlobalValue::InternalLinkage, 0, CtorName, &M); 128 Ctor->addAttribute(AttributeList::FunctionIndex, Attribute::NoUnwind); 129 BasicBlock *CtorBB = BasicBlock::Create(M.getContext(), "", Ctor); 130 ReturnInst::Create(M.getContext(), CtorBB); 131 // Ensure Ctor cannot be discarded, even if in a comdat. 132 appendToUsed(M, {Ctor}); 133 return Ctor; 134 } 135 136 std::pair<Function *, FunctionCallee> llvm::createSanitizerCtorAndInitFunctions( 137 Module &M, StringRef CtorName, StringRef InitName, 138 ArrayRef<Type *> InitArgTypes, ArrayRef<Value *> InitArgs, 139 StringRef VersionCheckName) { 140 assert(!InitName.empty() && "Expected init function name"); 141 assert(InitArgs.size() == InitArgTypes.size() && 142 "Sanitizer's init function expects different number of arguments"); 143 FunctionCallee InitFunction = 144 declareSanitizerInitFunction(M, InitName, InitArgTypes); 145 Function *Ctor = createSanitizerCtor(M, CtorName); 146 IRBuilder<> IRB(Ctor->getEntryBlock().getTerminator()); 147 IRB.CreateCall(InitFunction, InitArgs); 148 if (!VersionCheckName.empty()) { 149 FunctionCallee VersionCheckFunction = M.getOrInsertFunction( 150 VersionCheckName, FunctionType::get(IRB.getVoidTy(), {}, false), 151 AttributeList()); 152 IRB.CreateCall(VersionCheckFunction, {}); 153 } 154 return std::make_pair(Ctor, InitFunction); 155 } 156 157 std::pair<Function *, FunctionCallee> 158 llvm::getOrCreateSanitizerCtorAndInitFunctions( 159 Module &M, StringRef CtorName, StringRef InitName, 160 ArrayRef<Type *> InitArgTypes, ArrayRef<Value *> InitArgs, 161 function_ref<void(Function *, FunctionCallee)> FunctionsCreatedCallback, 162 StringRef VersionCheckName) { 163 assert(!CtorName.empty() && "Expected ctor function name"); 164 165 if (Function *Ctor = M.getFunction(CtorName)) 166 // FIXME: Sink this logic into the module, similar to the handling of 167 // globals. This will make moving to a concurrent model much easier. 168 if (Ctor->arg_size() == 0 || 169 Ctor->getReturnType() == Type::getVoidTy(M.getContext())) 170 return {Ctor, declareSanitizerInitFunction(M, InitName, InitArgTypes)}; 171 172 Function *Ctor; 173 FunctionCallee InitFunction; 174 std::tie(Ctor, InitFunction) = llvm::createSanitizerCtorAndInitFunctions( 175 M, CtorName, InitName, InitArgTypes, InitArgs, VersionCheckName); 176 FunctionsCreatedCallback(Ctor, InitFunction); 177 return std::make_pair(Ctor, InitFunction); 178 } 179 180 void llvm::filterDeadComdatFunctions( 181 Module &M, SmallVectorImpl<Function *> &DeadComdatFunctions) { 182 // Build a map from the comdat to the number of entries in that comdat we 183 // think are dead. If this fully covers the comdat group, then the entire 184 // group is dead. If we find another entry in the comdat group though, we'll 185 // have to preserve the whole group. 186 SmallDenseMap<Comdat *, int, 16> ComdatEntriesCovered; 187 for (Function *F : DeadComdatFunctions) { 188 Comdat *C = F->getComdat(); 189 assert(C && "Expected all input GVs to be in a comdat!"); 190 ComdatEntriesCovered[C] += 1; 191 } 192 193 auto CheckComdat = [&](Comdat &C) { 194 auto CI = ComdatEntriesCovered.find(&C); 195 if (CI == ComdatEntriesCovered.end()) 196 return; 197 198 // If this could have been covered by a dead entry, just subtract one to 199 // account for it. 200 if (CI->second > 0) { 201 CI->second -= 1; 202 return; 203 } 204 205 // If we've already accounted for all the entries that were dead, the 206 // entire comdat is alive so remove it from the map. 207 ComdatEntriesCovered.erase(CI); 208 }; 209 210 auto CheckAllComdats = [&] { 211 for (Function &F : M.functions()) 212 if (Comdat *C = F.getComdat()) { 213 CheckComdat(*C); 214 if (ComdatEntriesCovered.empty()) 215 return; 216 } 217 for (GlobalVariable &GV : M.globals()) 218 if (Comdat *C = GV.getComdat()) { 219 CheckComdat(*C); 220 if (ComdatEntriesCovered.empty()) 221 return; 222 } 223 for (GlobalAlias &GA : M.aliases()) 224 if (Comdat *C = GA.getComdat()) { 225 CheckComdat(*C); 226 if (ComdatEntriesCovered.empty()) 227 return; 228 } 229 }; 230 CheckAllComdats(); 231 232 if (ComdatEntriesCovered.empty()) { 233 DeadComdatFunctions.clear(); 234 return; 235 } 236 237 // Remove the entries that were not covering. 238 erase_if(DeadComdatFunctions, [&](GlobalValue *GV) { 239 return ComdatEntriesCovered.find(GV->getComdat()) == 240 ComdatEntriesCovered.end(); 241 }); 242 } 243 244 std::string llvm::getUniqueModuleId(Module *M) { 245 MD5 Md5; 246 bool ExportsSymbols = false; 247 auto AddGlobal = [&](GlobalValue &GV) { 248 if (GV.isDeclaration() || GV.getName().startswith("llvm.") || 249 !GV.hasExternalLinkage() || GV.hasComdat()) 250 return; 251 ExportsSymbols = true; 252 Md5.update(GV.getName()); 253 Md5.update(ArrayRef<uint8_t>{0}); 254 }; 255 256 for (auto &F : *M) 257 AddGlobal(F); 258 for (auto &GV : M->globals()) 259 AddGlobal(GV); 260 for (auto &GA : M->aliases()) 261 AddGlobal(GA); 262 for (auto &IF : M->ifuncs()) 263 AddGlobal(IF); 264 265 if (!ExportsSymbols) 266 return ""; 267 268 MD5::MD5Result R; 269 Md5.final(R); 270 271 SmallString<32> Str; 272 MD5::stringifyResult(R, Str); 273 return ("." + Str).str(); 274 } 275 276 void VFABI::setVectorVariantNames( 277 CallInst *CI, const SmallVector<std::string, 8> &VariantMappings) { 278 if (VariantMappings.empty()) 279 return; 280 281 SmallString<256> Buffer; 282 llvm::raw_svector_ostream Out(Buffer); 283 for (const std::string &VariantMapping : VariantMappings) 284 Out << VariantMapping << ","; 285 // Get rid of the trailing ','. 286 assert(!Buffer.str().empty() && "Must have at least one char."); 287 Buffer.pop_back(); 288 289 Module *M = CI->getModule(); 290 #ifndef NDEBUG 291 for (const std::string &VariantMapping : VariantMappings) { 292 LLVM_DEBUG(dbgs() << "VFABI: adding mapping '" << VariantMapping << "'\n"); 293 Optional<VFInfo> VI = VFABI::tryDemangleForVFABI(VariantMapping, *M); 294 assert(VI.hasValue() && "Cannot add an invalid VFABI name."); 295 assert(M->getNamedValue(VI.getValue().VectorName) && 296 "Cannot add variant to attribute: " 297 "vector function declaration is missing."); 298 } 299 #endif 300 CI->addAttribute( 301 AttributeList::FunctionIndex, 302 Attribute::get(M->getContext(), MappingsAttrName, Buffer.str())); 303 } 304