1 //===-- ModuleUtils.h - Functions to manipulate Modules ---------*- C++ -*-===// 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 #ifndef LLVM_TRANSFORMS_UTILS_MODULEUTILS_H 14 #define LLVM_TRANSFORMS_UTILS_MODULEUTILS_H 15 16 #include "llvm/ADT/STLFunctionalExtras.h" 17 #include "llvm/ADT/StringRef.h" 18 #include "llvm/IR/GlobalIFunc.h" 19 #include "llvm/Support/Alignment.h" 20 #include "llvm/Support/MemoryBufferRef.h" 21 #include <utility> // for std::pair 22 23 namespace llvm { 24 template <typename T> class SmallVectorImpl; 25 26 template <typename T> class ArrayRef; 27 class Module; 28 class Function; 29 class FunctionCallee; 30 class GlobalIFunc; 31 class GlobalValue; 32 class Constant; 33 class Value; 34 class Type; 35 36 /// Append F to the list of global ctors of module M with the given Priority. 37 /// This wraps the function in the appropriate structure and stores it along 38 /// side other global constructors. For details see 39 /// https://llvm.org/docs/LangRef.html#the-llvm-global-ctors-global-variable 40 void appendToGlobalCtors(Module &M, Function *F, int Priority, 41 Constant *Data = nullptr); 42 43 /// Same as appendToGlobalCtors(), but for global dtors. 44 void appendToGlobalDtors(Module &M, Function *F, int Priority, 45 Constant *Data = nullptr); 46 47 /// Sets the KCFI type for the function. Used for compiler-generated functions 48 /// that are indirectly called in instrumented code. 49 void setKCFIType(Module &M, Function &F, StringRef MangledType); 50 51 FunctionCallee declareSanitizerInitFunction(Module &M, StringRef InitName, 52 ArrayRef<Type *> InitArgTypes, 53 bool Weak = false); 54 55 /// Creates sanitizer constructor function. 56 /// \return Returns pointer to constructor. 57 Function *createSanitizerCtor(Module &M, StringRef CtorName); 58 59 /// Creates sanitizer constructor function, and calls sanitizer's init 60 /// function from it. 61 /// \return Returns pair of pointers to constructor, and init functions 62 /// respectively. 63 std::pair<Function *, FunctionCallee> createSanitizerCtorAndInitFunctions( 64 Module &M, StringRef CtorName, StringRef InitName, 65 ArrayRef<Type *> InitArgTypes, ArrayRef<Value *> InitArgs, 66 StringRef VersionCheckName = StringRef(), bool Weak = false); 67 68 /// Creates sanitizer constructor function lazily. If a constructor and init 69 /// function already exist, this function returns it. Otherwise it calls \c 70 /// createSanitizerCtorAndInitFunctions. The FunctionsCreatedCallback is invoked 71 /// in that case, passing the new Ctor and Init function. 72 /// 73 /// \return Returns pair of pointers to constructor, and init functions 74 /// respectively. 75 std::pair<Function *, FunctionCallee> getOrCreateSanitizerCtorAndInitFunctions( 76 Module &M, StringRef CtorName, StringRef InitName, 77 ArrayRef<Type *> InitArgTypes, ArrayRef<Value *> InitArgs, 78 function_ref<void(Function *, FunctionCallee)> FunctionsCreatedCallback, 79 StringRef VersionCheckName = StringRef(), bool Weak = false); 80 81 /// Rename all the anon globals in the module using a hash computed from 82 /// the list of public globals in the module. 83 bool nameUnamedGlobals(Module &M); 84 85 /// Adds global values to the llvm.used list. 86 void appendToUsed(Module &M, ArrayRef<GlobalValue *> Values); 87 88 /// Adds global values to the llvm.compiler.used list. 89 void appendToCompilerUsed(Module &M, ArrayRef<GlobalValue *> Values); 90 91 /// Removes global values from the llvm.used and llvm.compiler.used arrays. \p 92 /// ShouldRemove should return true for any initializer field that should not be 93 /// included in the replacement global. 94 void removeFromUsedLists(Module &M, 95 function_ref<bool(Constant *)> ShouldRemove); 96 97 /// Filter out potentially dead comdat functions where other entries keep the 98 /// entire comdat group alive. 99 /// 100 /// This is designed for cases where functions appear to become dead but remain 101 /// alive due to other live entries in their comdat group. 102 /// 103 /// The \p DeadComdatFunctions container should only have pointers to 104 /// `Function`s which are members of a comdat group and are believed to be 105 /// dead. 106 /// 107 /// After this routine finishes, the only remaining `Function`s in \p 108 /// DeadComdatFunctions are those where every member of the comdat is listed 109 /// and thus removing them is safe (provided *all* are removed). 110 void filterDeadComdatFunctions( 111 SmallVectorImpl<Function *> &DeadComdatFunctions); 112 113 /// Produce a unique identifier for this module by taking the MD5 sum of 114 /// the names of the module's strong external symbols that are not comdat 115 /// members. 116 /// 117 /// This identifier is normally guaranteed to be unique, or the program would 118 /// fail to link due to multiply defined symbols. 119 /// 120 /// If the module has no strong external symbols (such a module may still have a 121 /// semantic effect if it performs global initialization), we cannot produce a 122 /// unique identifier for this module, so we return the empty string. 123 std::string getUniqueModuleId(Module *M); 124 125 /// Embed the memory buffer \p Buf into the module \p M as a global using the 126 /// specified section name. Also provide a metadata entry to identify it in the 127 /// module using the same section name. 128 void embedBufferInModule(Module &M, MemoryBufferRef Buf, StringRef SectionName, 129 Align Alignment = Align(1)); 130 131 /// Lower all calls to ifuncs by replacing uses with indirect calls loaded out 132 /// of a global table initialized in a global constructor. This will introduce 133 /// one constructor function and adds it to llvm.global_ctors. The constructor 134 /// will call the resolver function once for each ifunc. 135 /// 136 /// Leaves any unhandled constant initializer uses as-is. 137 /// 138 /// If \p IFuncsToLower is empty, all ifuncs in the module will be lowered. 139 /// If \p IFuncsToLower is non-empty, only the selected ifuncs will be lowered. 140 /// 141 /// The processed ifuncs without remaining users will be removed from the 142 /// module. 143 bool lowerGlobalIFuncUsersAsGlobalCtor( 144 Module &M, ArrayRef<GlobalIFunc *> IFuncsToLower = {}); 145 146 } // End llvm namespace 147 148 #endif // LLVM_TRANSFORMS_UTILS_MODULEUTILS_H 149