1 //==-LTOInternalize.cpp - LLVM Link Time Optimizer Internalization Utility -==//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines a helper to run the internalization part of LTO.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "llvm/LTO/legacy/UpdateCompilerUsed.h"
15 #include "llvm/Analysis/TargetLibraryInfo.h"
16 #include "llvm/IR/LegacyPassManager.h"
17 #include "llvm/IR/Mangler.h"
18 #include "llvm/Target/TargetLowering.h"
19 #include "llvm/Target/TargetSubtargetInfo.h"
20 #include "llvm/Transforms/IPO/Internalize.h"
21
22 using namespace llvm;
23
24 namespace {
25
26 // Helper class that collects AsmUsed and user supplied libcalls.
27 class PreserveLibCallsAndAsmUsed {
28 public:
PreserveLibCallsAndAsmUsed(const StringSet<> & AsmUndefinedRefs,const TargetMachine & TM,SmallPtrSetImpl<const GlobalValue * > & LLVMUsed)29 PreserveLibCallsAndAsmUsed(const StringSet<> &AsmUndefinedRefs,
30 const TargetMachine &TM,
31 SmallPtrSetImpl<const GlobalValue *> &LLVMUsed)
32 : AsmUndefinedRefs(AsmUndefinedRefs), TM(TM), LLVMUsed(LLVMUsed) {}
33
findInModule(const Module & TheModule)34 void findInModule(const Module &TheModule) {
35 initializeLibCalls(TheModule);
36 for (const Function &F : TheModule)
37 findLibCallsAndAsm(F);
38 for (const GlobalVariable &GV : TheModule.globals())
39 findLibCallsAndAsm(GV);
40 for (const GlobalAlias &GA : TheModule.aliases())
41 findLibCallsAndAsm(GA);
42 }
43
44 private:
45 // Inputs
46 const StringSet<> &AsmUndefinedRefs;
47 const TargetMachine &TM;
48
49 // Temps
50 llvm::Mangler Mangler;
51 StringSet<> Libcalls;
52
53 // Output
54 SmallPtrSetImpl<const GlobalValue *> &LLVMUsed;
55
56 // Collect names of runtime library functions. User-defined functions with the
57 // same names are added to llvm.compiler.used to prevent them from being
58 // deleted by optimizations.
initializeLibCalls(const Module & TheModule)59 void initializeLibCalls(const Module &TheModule) {
60 TargetLibraryInfoImpl TLII(Triple(TM.getTargetTriple()));
61 TargetLibraryInfo TLI(TLII);
62
63 // TargetLibraryInfo has info on C runtime library calls on the current
64 // target.
65 for (unsigned I = 0, E = static_cast<unsigned>(LibFunc::NumLibFuncs);
66 I != E; ++I) {
67 LibFunc::Func F = static_cast<LibFunc::Func>(I);
68 if (TLI.has(F))
69 Libcalls.insert(TLI.getName(F));
70 }
71
72 SmallPtrSet<const TargetLowering *, 1> TLSet;
73
74 for (const Function &F : TheModule) {
75 const TargetLowering *Lowering =
76 TM.getSubtargetImpl(F)->getTargetLowering();
77
78 if (Lowering && TLSet.insert(Lowering).second)
79 // TargetLowering has info on library calls that CodeGen expects to be
80 // available, both from the C runtime and compiler-rt.
81 for (unsigned I = 0, E = static_cast<unsigned>(RTLIB::UNKNOWN_LIBCALL);
82 I != E; ++I)
83 if (const char *Name =
84 Lowering->getLibcallName(static_cast<RTLIB::Libcall>(I)))
85 Libcalls.insert(Name);
86 }
87 }
88
findLibCallsAndAsm(const GlobalValue & GV)89 void findLibCallsAndAsm(const GlobalValue &GV) {
90 // There are no restrictions to apply to declarations.
91 if (GV.isDeclaration())
92 return;
93
94 // There is nothing more restrictive than private linkage.
95 if (GV.hasPrivateLinkage())
96 return;
97
98 // Conservatively append user-supplied runtime library functions to
99 // llvm.compiler.used. These could be internalized and deleted by
100 // optimizations like -globalopt, causing problems when later optimizations
101 // add new library calls (e.g., llvm.memset => memset and printf => puts).
102 // Leave it to the linker to remove any dead code (e.g. with -dead_strip).
103 if (isa<Function>(GV) && Libcalls.count(GV.getName()))
104 LLVMUsed.insert(&GV);
105
106 SmallString<64> Buffer;
107 TM.getNameWithPrefix(Buffer, &GV, Mangler);
108 if (AsmUndefinedRefs.count(Buffer))
109 LLVMUsed.insert(&GV);
110 }
111 };
112
113 } // namespace anonymous
114
updateCompilerUsed(Module & TheModule,const TargetMachine & TM,const StringSet<> & AsmUndefinedRefs)115 void llvm::updateCompilerUsed(Module &TheModule, const TargetMachine &TM,
116 const StringSet<> &AsmUndefinedRefs) {
117 SmallPtrSet<const GlobalValue *, 8> UsedValues;
118 PreserveLibCallsAndAsmUsed(AsmUndefinedRefs, TM, UsedValues)
119 .findInModule(TheModule);
120
121 if (UsedValues.empty())
122 return;
123
124 llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(TheModule.getContext());
125 std::vector<Constant *> UsedValuesList;
126 for (const auto *GV : UsedValues) {
127 Constant *c =
128 ConstantExpr::getBitCast(const_cast<GlobalValue *>(GV), i8PTy);
129 UsedValuesList.push_back(c);
130 }
131
132 GlobalVariable *LLVMUsed = TheModule.getGlobalVariable("llvm.compiler.used");
133 if (LLVMUsed) {
134 ConstantArray *Inits = cast<ConstantArray>(LLVMUsed->getInitializer());
135 for (auto &V : Inits->operands())
136 UsedValuesList.push_back(cast<Constant>(&V));
137 LLVMUsed->eraseFromParent();
138 }
139
140 llvm::ArrayType *ATy = llvm::ArrayType::get(i8PTy, UsedValuesList.size());
141 LLVMUsed = new llvm::GlobalVariable(
142 TheModule, ATy, false, llvm::GlobalValue::AppendingLinkage,
143 llvm::ConstantArray::get(ATy, UsedValuesList), "llvm.compiler.used");
144
145 LLVMUsed->setSection("llvm.metadata");
146 }
147