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