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