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/SmallVector.h"
17 #include "llvm/ADT/StringRef.h"
18 #include "llvm/Support/MemoryBuffer.h"
19 #include <utility> // for std::pair
20 
21 namespace llvm {
22 
23 template <typename T> class ArrayRef;
24 class Module;
25 class Function;
26 class FunctionCallee;
27 class GlobalValue;
28 class Constant;
29 class Value;
30 class Type;
31 
32 /// Append F to the list of global ctors of module M with the given Priority.
33 /// This wraps the function in the appropriate structure and stores it along
34 /// side other global constructors. For details see
35 /// http://llvm.org/docs/LangRef.html#intg_global_ctors
36 void appendToGlobalCtors(Module &M, Function *F, int Priority,
37                          Constant *Data = nullptr);
38 
39 /// Same as appendToGlobalCtors(), but for global dtors.
40 void appendToGlobalDtors(Module &M, Function *F, int Priority,
41                          Constant *Data = nullptr);
42 
43 FunctionCallee declareSanitizerInitFunction(Module &M, StringRef InitName,
44                                             ArrayRef<Type *> InitArgTypes);
45 
46 /// Creates sanitizer constructor function.
47 /// \return Returns pointer to constructor.
48 Function *createSanitizerCtor(Module &M, StringRef CtorName);
49 
50 /// Creates sanitizer constructor function, and calls sanitizer's init
51 /// function from it.
52 /// \return Returns pair of pointers to constructor, and init functions
53 /// respectively.
54 std::pair<Function *, FunctionCallee> createSanitizerCtorAndInitFunctions(
55     Module &M, StringRef CtorName, StringRef InitName,
56     ArrayRef<Type *> InitArgTypes, ArrayRef<Value *> InitArgs,
57     StringRef VersionCheckName = StringRef());
58 
59 /// Creates sanitizer constructor function lazily. If a constructor and init
60 /// function already exist, this function returns it. Otherwise it calls \c
61 /// createSanitizerCtorAndInitFunctions. The FunctionsCreatedCallback is invoked
62 /// in that case, passing the new Ctor and Init function.
63 ///
64 /// \return Returns pair of pointers to constructor, and init functions
65 /// respectively.
66 std::pair<Function *, FunctionCallee> getOrCreateSanitizerCtorAndInitFunctions(
67     Module &M, StringRef CtorName, StringRef InitName,
68     ArrayRef<Type *> InitArgTypes, ArrayRef<Value *> InitArgs,
69     function_ref<void(Function *, FunctionCallee)> FunctionsCreatedCallback,
70     StringRef VersionCheckName = StringRef());
71 
72 /// Rename all the anon globals in the module using a hash computed from
73 /// the list of public globals in the module.
74 bool nameUnamedGlobals(Module &M);
75 
76 /// Adds global values to the llvm.used list.
77 void appendToUsed(Module &M, ArrayRef<GlobalValue *> Values);
78 
79 /// Adds global values to the llvm.compiler.used list.
80 void appendToCompilerUsed(Module &M, ArrayRef<GlobalValue *> Values);
81 
82 /// Filter out potentially dead comdat functions where other entries keep the
83 /// entire comdat group alive.
84 ///
85 /// This is designed for cases where functions appear to become dead but remain
86 /// alive due to other live entries in their comdat group.
87 ///
88 /// The \p DeadComdatFunctions container should only have pointers to
89 /// `Function`s which are members of a comdat group and are believed to be
90 /// dead.
91 ///
92 /// After this routine finishes, the only remaining `Function`s in \p
93 /// DeadComdatFunctions are those where every member of the comdat is listed
94 /// and thus removing them is safe (provided *all* are removed).
95 void filterDeadComdatFunctions(
96     SmallVectorImpl<Function *> &DeadComdatFunctions);
97 
98 /// Produce a unique identifier for this module by taking the MD5 sum of
99 /// the names of the module's strong external symbols that are not comdat
100 /// members.
101 ///
102 /// This identifier is normally guaranteed to be unique, or the program would
103 /// fail to link due to multiply defined symbols.
104 ///
105 /// If the module has no strong external symbols (such a module may still have a
106 /// semantic effect if it performs global initialization), we cannot produce a
107 /// unique identifier for this module, so we return the empty string.
108 std::string getUniqueModuleId(Module *M);
109 
110 /// Embed the memory buffer \p Buf into the module \p M as a global using the
111 /// specified section name.
112 void embedBufferInModule(Module &M, MemoryBufferRef Buf, StringRef SectionName);
113 
114 class CallInst;
115 namespace VFABI {
116 /// Overwrite the Vector Function ABI variants attribute with the names provide
117 /// in \p VariantMappings.
118 void setVectorVariantNames(CallInst *CI,
119                            const SmallVector<std::string, 8> &VariantMappings);
120 } // End VFABI namespace
121 } // End llvm namespace
122 
123 #endif // LLVM_TRANSFORMS_UTILS_MODULEUTILS_H
124