1 | //===-LTOCodeGenerator.h - LLVM Link Time Optimizer -----------------------===// |
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 file declares the LTOCodeGenerator class. |
10 | // |
11 | // LTO compilation consists of three phases: Pre-IPO, IPO and Post-IPO. |
12 | // |
13 | // The Pre-IPO phase compiles source code into bitcode file. The resulting |
14 | // bitcode files, along with object files and libraries, will be fed to the |
15 | // linker to through the IPO and Post-IPO phases. By using obj-file extension, |
16 | // the resulting bitcode file disguises itself as an object file, and therefore |
17 | // obviates the need of writing a special set of the make-rules only for LTO |
18 | // compilation. |
19 | // |
20 | // The IPO phase perform inter-procedural analyses and optimizations, and |
21 | // the Post-IPO consists two sub-phases: intra-procedural scalar optimizations |
22 | // (SOPT), and intra-procedural target-dependent code generator (CG). |
23 | // |
24 | // As of this writing, we don't separate IPO and the Post-IPO SOPT. They |
25 | // are intermingled together, and are driven by a single pass manager (see |
26 | // PassManagerBuilder::populateLTOPassManager()). |
27 | // FIXME: populateLTOPassManager no longer exists. |
28 | // |
29 | // The "LTOCodeGenerator" is the driver for the IPO and Post-IPO stages. |
30 | // The "CodeGenerator" here is bit confusing. Don't confuse the "CodeGenerator" |
31 | // with the machine specific code generator. |
32 | // |
33 | //===----------------------------------------------------------------------===// |
34 | |
35 | #ifndef LLVM_LTO_LEGACY_LTOCODEGENERATOR_H |
36 | #define LLVM_LTO_LEGACY_LTOCODEGENERATOR_H |
37 | |
38 | #include "llvm-c/lto.h" |
39 | #include "llvm/ADT/ArrayRef.h" |
40 | #include "llvm/ADT/StringMap.h" |
41 | #include "llvm/ADT/StringSet.h" |
42 | #include "llvm/IR/GlobalValue.h" |
43 | #include "llvm/IR/Module.h" |
44 | #include "llvm/LTO/Config.h" |
45 | #include "llvm/LTO/LTO.h" |
46 | #include "llvm/Support/CommandLine.h" |
47 | #include "llvm/Support/Error.h" |
48 | #include "llvm/Support/ToolOutputFile.h" |
49 | #include "llvm/Target/TargetMachine.h" |
50 | #include "llvm/Target/TargetOptions.h" |
51 | #include <string> |
52 | #include <vector> |
53 | |
54 | namespace llvm { |
55 | template <typename T> class ArrayRef; |
56 | class LLVMContext; |
57 | class DiagnosticInfo; |
58 | class Linker; |
59 | class Mangler; |
60 | class MemoryBuffer; |
61 | class TargetLibraryInfo; |
62 | class TargetMachine; |
63 | class raw_ostream; |
64 | class raw_pwrite_stream; |
65 | |
66 | /// Enable global value internalization in LTO. |
67 | extern cl::opt<bool> EnableLTOInternalization; |
68 | |
69 | //===----------------------------------------------------------------------===// |
70 | /// C++ class which implements the opaque lto_code_gen_t type. |
71 | /// |
72 | struct LTOCodeGenerator { |
73 | static const char *getVersionString(); |
74 | |
75 | LTOCodeGenerator(LLVMContext &Context); |
76 | ~LTOCodeGenerator(); |
77 | |
78 | /// Merge given module. Return true on success. |
79 | /// |
80 | /// Resets \a HasVerifiedInput. |
81 | bool addModule(struct LTOModule *); |
82 | |
83 | /// Set the destination module. |
84 | /// |
85 | /// Resets \a HasVerifiedInput. |
86 | void setModule(std::unique_ptr<LTOModule> M); |
87 | |
88 | void setAsmUndefinedRefs(struct LTOModule *); |
89 | void setTargetOptions(const TargetOptions &Options); |
90 | void setDebugInfo(lto_debug_model); |
91 | void setCodePICModel(std::optional<Reloc::Model> Model) { |
92 | Config.RelocModel = Model; |
93 | } |
94 | |
95 | /// Set the file type to be emitted (assembly or object code). |
96 | /// The default is CodeGenFileType::ObjectFile. |
97 | void setFileType(CodeGenFileType FT) { Config.CGFileType = FT; } |
98 | |
99 | void setCpu(StringRef MCpu) { Config.CPU = std::string(MCpu); } |
100 | void setAttrs(std::vector<std::string> MAttrs) { Config.MAttrs = MAttrs; } |
101 | void setOptLevel(unsigned OptLevel); |
102 | |
103 | void setShouldInternalize(bool Value) { ShouldInternalize = Value; } |
104 | void setShouldEmbedUselists(bool Value) { ShouldEmbedUselists = Value; } |
105 | void setSaveIRBeforeOptPath(std::string Value) { |
106 | SaveIRBeforeOptPath = Value; |
107 | } |
108 | |
109 | /// Restore linkage of globals |
110 | /// |
111 | /// When set, the linkage of globals will be restored prior to code |
112 | /// generation. That is, a global symbol that had external linkage prior to |
113 | /// LTO will be emitted with external linkage again; and a local will remain |
114 | /// local. Note that this option only affects the end result - globals may |
115 | /// still be internalized in the process of LTO and may be modified and/or |
116 | /// deleted where legal. |
117 | /// |
118 | /// The default behavior will internalize globals (unless on the preserve |
119 | /// list) and, if parallel code generation is enabled, will externalize |
120 | /// all locals. |
121 | void setShouldRestoreGlobalsLinkage(bool Value) { |
122 | ShouldRestoreGlobalsLinkage = Value; |
123 | } |
124 | |
125 | void addMustPreserveSymbol(StringRef Sym) { MustPreserveSymbols.insert(key: Sym); } |
126 | |
127 | /// Pass options to the driver and optimization passes. |
128 | /// |
129 | /// These options are not necessarily for debugging purpose (the function |
130 | /// name is misleading). This function should be called before |
131 | /// LTOCodeGenerator::compilexxx(), and |
132 | /// LTOCodeGenerator::writeMergedModules(). |
133 | void setCodeGenDebugOptions(ArrayRef<StringRef> Opts); |
134 | |
135 | /// Parse the options set in setCodeGenDebugOptions. |
136 | /// |
137 | /// Like \a setCodeGenDebugOptions(), this must be called before |
138 | /// LTOCodeGenerator::compilexxx() and |
139 | /// LTOCodeGenerator::writeMergedModules(). |
140 | void parseCodeGenDebugOptions(); |
141 | |
142 | /// Write the merged module to the file specified by the given path. Return |
143 | /// true on success. |
144 | /// |
145 | /// Calls \a verifyMergedModuleOnce(). |
146 | bool writeMergedModules(StringRef Path); |
147 | |
148 | /// Compile the merged module into a *single* output file; the path to output |
149 | /// file is returned to the caller via argument "name". Return true on |
150 | /// success. |
151 | /// |
152 | /// \note It is up to the linker to remove the intermediate output file. Do |
153 | /// not try to remove the object file in LTOCodeGenerator's destructor as we |
154 | /// don't who (LTOCodeGenerator or the output file) will last longer. |
155 | bool compile_to_file(const char **Name); |
156 | |
157 | /// As with compile_to_file(), this function compiles the merged module into |
158 | /// single output file. Instead of returning the output file path to the |
159 | /// caller (linker), it brings the output to a buffer, and returns the buffer |
160 | /// to the caller. This function should delete the intermediate file once |
161 | /// its content is brought to memory. Return NULL if the compilation was not |
162 | /// successful. |
163 | std::unique_ptr<MemoryBuffer> compile(); |
164 | |
165 | /// Optimizes the merged module. Returns true on success. |
166 | /// |
167 | /// Calls \a verifyMergedModuleOnce(). |
168 | bool optimize(); |
169 | |
170 | /// Compiles the merged optimized module into a single output file. It brings |
171 | /// the output to a buffer, and returns the buffer to the caller. Return NULL |
172 | /// if the compilation was not successful. |
173 | std::unique_ptr<MemoryBuffer> compileOptimized(); |
174 | |
175 | /// Compile the merged optimized module \p ParallelismLevel output files each |
176 | /// representing a linkable partition of the module. If out contains more |
177 | /// than one element, code generation is done in parallel with \p |
178 | /// ParallelismLevel threads. Output files will be written to the streams |
179 | /// created using the \p AddStream callback. Returns true on success. |
180 | /// |
181 | /// Calls \a verifyMergedModuleOnce(). |
182 | bool compileOptimized(AddStreamFn AddStream, unsigned ParallelismLevel); |
183 | |
184 | /// Enable the Freestanding mode: indicate that the optimizer should not |
185 | /// assume builtins are present on the target. |
186 | void setFreestanding(bool Enabled) { Config.Freestanding = Enabled; } |
187 | |
188 | void setDisableVerify(bool Value) { Config.DisableVerify = Value; } |
189 | |
190 | void setDebugPassManager(bool Enabled) { Config.DebugPassManager = Enabled; } |
191 | |
192 | void setDiagnosticHandler(lto_diagnostic_handler_t, void *); |
193 | |
194 | LLVMContext &getContext() { return Context; } |
195 | |
196 | void resetMergedModule() { MergedModule.reset(); } |
197 | void DiagnosticHandler(const DiagnosticInfo &DI); |
198 | |
199 | private: |
200 | /// Verify the merged module on first call. |
201 | /// |
202 | /// Sets \a HasVerifiedInput on first call and doesn't run again on the same |
203 | /// input. |
204 | void verifyMergedModuleOnce(); |
205 | |
206 | bool compileOptimizedToFile(const char **Name); |
207 | void restoreLinkageForExternals(); |
208 | void applyScopeRestrictions(); |
209 | void preserveDiscardableGVs( |
210 | Module &TheModule, |
211 | llvm::function_ref<bool(const GlobalValue &)> mustPreserveGV); |
212 | |
213 | bool determineTarget(); |
214 | std::unique_ptr<TargetMachine> createTargetMachine(); |
215 | |
216 | bool useAIXSystemAssembler(); |
217 | bool runAIXSystemAssembler(SmallString<128> &AssemblyFile); |
218 | |
219 | void emitError(const std::string &ErrMsg); |
220 | void emitWarning(const std::string &ErrMsg); |
221 | |
222 | void (); |
223 | |
224 | LLVMContext &Context; |
225 | std::unique_ptr<Module> MergedModule; |
226 | std::unique_ptr<Linker> TheLinker; |
227 | std::unique_ptr<TargetMachine> TargetMach; |
228 | bool EmitDwarfDebugInfo = false; |
229 | bool ScopeRestrictionsDone = false; |
230 | bool HasVerifiedInput = false; |
231 | StringSet<> MustPreserveSymbols; |
232 | StringSet<> AsmUndefinedRefs; |
233 | StringMap<GlobalValue::LinkageTypes> ExternalSymbols; |
234 | std::vector<std::string> CodegenOptions; |
235 | std::string FeatureStr; |
236 | std::string NativeObjectPath; |
237 | const Target *MArch = nullptr; |
238 | std::string TripleStr; |
239 | lto_diagnostic_handler_t DiagHandler = nullptr; |
240 | void *DiagContext = nullptr; |
241 | bool ShouldInternalize = EnableLTOInternalization; |
242 | bool ShouldEmbedUselists = false; |
243 | bool ShouldRestoreGlobalsLinkage = false; |
244 | std::unique_ptr<ToolOutputFile> DiagnosticOutputFile; |
245 | std::unique_ptr<ToolOutputFile> StatsFile = nullptr; |
246 | std::string SaveIRBeforeOptPath; |
247 | |
248 | lto::Config Config; |
249 | }; |
250 | |
251 | /// A convenience function that calls cl::ParseCommandLineOptions on the given |
252 | /// set of options. |
253 | void parseCommandLineOptions(std::vector<std::string> &Options); |
254 | } |
255 | #endif |
256 | |