LLVM 17.0.0git
Go to the documentation of this file.
1//===-LTOCodeGenerator.h - LLVM Link Time Optimizer -----------------------===//
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
9// This file declares the LTOCodeGenerator class.
11// LTO compilation consists of three phases: Pre-IPO, IPO and Post-IPO.
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.
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).
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.
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.
38#include "llvm-c/lto.h"
39#include "llvm/ADT/ArrayRef.h"
41#include "llvm/ADT/StringMap.h"
42#include "llvm/ADT/StringSet.h"
43#include "llvm/IR/GlobalValue.h"
44#include "llvm/IR/Module.h"
45#include "llvm/LTO/Config.h"
46#include "llvm/LTO/LTO.h"
48#include "llvm/Support/Error.h"
52#include <string>
53#include <vector>
55namespace llvm {
56template <typename T> class ArrayRef;
57 class LLVMContext;
58 class DiagnosticInfo;
59 class Linker;
60 class Mangler;
61 class MemoryBuffer;
62 class TargetLibraryInfo;
63 class TargetMachine;
64 class raw_ostream;
65 class raw_pwrite_stream;
67/// Enable global value internalization in LTO.
68extern cl::opt<bool> EnableLTOInternalization;
71/// C++ class which implements the opaque lto_code_gen_t type.
74 static const char *getVersionString();
79 /// Merge given module. Return true on success.
80 ///
81 /// Resets \a HasVerifiedInput.
82 bool addModule(struct LTOModule *);
84 /// Set the destination module.
85 ///
86 /// Resets \a HasVerifiedInput.
87 void setModule(std::unique_ptr<LTOModule> M);
89 void setAsmUndefinedRefs(struct LTOModule *);
92 void setCodePICModel(std::optional<Reloc::Model> Model) {
93 Config.RelocModel = Model;
94 }
96 /// Set the file type to be emitted (assembly or object code).
97 /// The default is CGFT_ObjectFile.
98 void setFileType(CodeGenFileType FT) { Config.CGFileType = FT; }
100 void setCpu(StringRef MCpu) { Config.CPU = std::string(MCpu); }
101 void setAttrs(std::vector<std::string> MAttrs) { Config.MAttrs = MAttrs; }
102 void setOptLevel(unsigned OptLevel);
104 void setShouldInternalize(bool Value) { ShouldInternalize = Value; }
105 void setShouldEmbedUselists(bool Value) { ShouldEmbedUselists = Value; }
106 void setSaveIRBeforeOptPath(std::string Value) {
107 SaveIRBeforeOptPath = Value;
108 }
110 /// Restore linkage of globals
111 ///
112 /// When set, the linkage of globals will be restored prior to code
113 /// generation. That is, a global symbol that had external linkage prior to
114 /// LTO will be emitted with external linkage again; and a local will remain
115 /// local. Note that this option only affects the end result - globals may
116 /// still be internalized in the process of LTO and may be modified and/or
117 /// deleted where legal.
118 ///
119 /// The default behavior will internalize globals (unless on the preserve
120 /// list) and, if parallel code generation is enabled, will externalize
121 /// all locals.
123 ShouldRestoreGlobalsLinkage = Value;
124 }
126 void addMustPreserveSymbol(StringRef Sym) { MustPreserveSymbols.insert(Sym); }
128 /// Pass options to the driver and optimization passes.
129 ///
130 /// These options are not necessarily for debugging purpose (the function
131 /// name is misleading). This function should be called before
132 /// LTOCodeGenerator::compilexxx(), and
133 /// LTOCodeGenerator::writeMergedModules().
136 /// Parse the options set in setCodeGenDebugOptions.
137 ///
138 /// Like \a setCodeGenDebugOptions(), this must be called before
139 /// LTOCodeGenerator::compilexxx() and
140 /// LTOCodeGenerator::writeMergedModules().
143 /// Write the merged module to the file specified by the given path. Return
144 /// true on success.
145 ///
146 /// Calls \a verifyMergedModuleOnce().
147 bool writeMergedModules(StringRef Path);
149 /// Compile the merged module into a *single* output file; the path to output
150 /// file is returned to the caller via argument "name". Return true on
151 /// success.
152 ///
153 /// \note It is up to the linker to remove the intermediate output file. Do
154 /// not try to remove the object file in LTOCodeGenerator's destructor as we
155 /// don't who (LTOCodeGenerator or the output file) will last longer.
156 bool compile_to_file(const char **Name);
158 /// As with compile_to_file(), this function compiles the merged module into
159 /// single output file. Instead of returning the output file path to the
160 /// caller (linker), it brings the output to a buffer, and returns the buffer
161 /// to the caller. This function should delete the intermediate file once
162 /// its content is brought to memory. Return NULL if the compilation was not
163 /// successful.
164 std::unique_ptr<MemoryBuffer> compile();
166 /// Optimizes the merged module. Returns true on success.
167 ///
168 /// Calls \a verifyMergedModuleOnce().
169 bool optimize();
171 /// Compiles the merged optimized module into a single output file. It brings
172 /// the output to a buffer, and returns the buffer to the caller. Return NULL
173 /// if the compilation was not successful.
174 std::unique_ptr<MemoryBuffer> compileOptimized();
176 /// Compile the merged optimized module \p ParallelismLevel output files each
177 /// representing a linkable partition of the module. If out contains more
178 /// than one element, code generation is done in parallel with \p
179 /// ParallelismLevel threads. Output files will be written to the streams
180 /// created using the \p AddStream callback. Returns true on success.
181 ///
182 /// Calls \a verifyMergedModuleOnce().
183 bool compileOptimized(AddStreamFn AddStream, unsigned ParallelismLevel);
185 /// Enable the Freestanding mode: indicate that the optimizer should not
186 /// assume builtins are present on the target.
189 void setDisableVerify(bool Value) { Config.DisableVerify = Value; }
197 void resetMergedModule() { MergedModule.reset(); }
198 void DiagnosticHandler(const DiagnosticInfo &DI);
201 /// Verify the merged module on first call.
202 ///
203 /// Sets \a HasVerifiedInput on first call and doesn't run again on the same
204 /// input.
205 void verifyMergedModuleOnce();
207 bool compileOptimizedToFile(const char **Name);
208 void restoreLinkageForExternals();
209 void applyScopeRestrictions();
210 void preserveDiscardableGVs(
211 Module &TheModule,
214 bool determineTarget();
215 std::unique_ptr<TargetMachine> createTargetMachine();
217 bool useAIXSystemAssembler();
218 bool runAIXSystemAssembler(SmallString<128> &AssemblyFile);
220 void emitError(const std::string &ErrMsg);
221 void emitWarning(const std::string &ErrMsg);
223 void finishOptimizationRemarks();
226 std::unique_ptr<Module> MergedModule;
227 std::unique_ptr<Linker> TheLinker;
228 std::unique_ptr<TargetMachine> TargetMach;
229 bool EmitDwarfDebugInfo = false;
230 bool ScopeRestrictionsDone = false;
231 bool HasVerifiedInput = false;
232 StringSet<> MustPreserveSymbols;
233 StringSet<> AsmUndefinedRefs;
235 std::vector<std::string> CodegenOptions;
236 std::string FeatureStr;
237 std::string NativeObjectPath;
238 const Target *MArch = nullptr;
239 std::string TripleStr;
240 lto_diagnostic_handler_t DiagHandler = nullptr;
241 void *DiagContext = nullptr;
242 bool ShouldInternalize = EnableLTOInternalization;
243 bool ShouldEmbedUselists = false;
244 bool ShouldRestoreGlobalsLinkage = false;
245 std::unique_ptr<ToolOutputFile> DiagnosticOutputFile;
246 std::unique_ptr<ToolOutputFile> StatsFile = nullptr;
247 std::string SaveIRBeforeOptPath;
249 lto::Config Config;
252/// A convenience function that calls cl::ParseCommandLineOptions on the given
253/// set of options.
254void parseCommandLineOptions(std::vector<std::string> &Options);
This file defines the StringMap class.
static bool mustPreserveGV(const GlobalValue &GV)
Predicate for Internalize pass.
std::string Name
Symbol * Sym
Definition: ELF_riscv.cpp:463
static LVOptions Options
Definition: LVOptions.cpp:25
Module.h This file contains the declarations for the Module class.
LLVMContext & Context
This file defines the SmallPtrSet class.
static bool Enabled
Definition: Statistic.cpp:46
StringSet - A set-like wrapper for the StringMap.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
This is the base abstract class for diagnostic reporting in the backend.
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:111
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
StringSet - A wrapper for StringMap that provides set-like functionality.
Definition: StringSet.h:23
std::pair< typename Base::iterator, bool > insert(StringRef key)
Definition: StringSet.h:34
Target - Wrapper for Target specific information.
LLVM Value Representation.
Definition: Value.h:74
An efficient, type-erasing, non-owning reference to a callable.
Definition: lto.h:79
void(* lto_diagnostic_handler_t)(lto_codegen_diagnostic_severity_t severity, const char *diag, void *ctxt)
Diagnostic handler type.
Definition: lto.h:346
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
std::function< Expected< std::unique_ptr< CachedFileStream > >(unsigned Task, const Twine &ModuleName)> AddStreamFn
This type defines the callback to add a file that is generated on the fly.
Definition: Caching.h:42
These enums are meant to be passed into addPassesToEmitFile to indicate what type of file to emit,...
Definition: CodeGen.h:84
cl::opt< bool > EnableLTOInternalization
Enable global value internalization in LTO.
void parseCommandLineOptions(std::vector< std::string > &Options)
A convenience function that calls cl::ParseCommandLineOptions on the given set of options.
ArrayRef(const T &OneElt) -> ArrayRef< T >
This is the base class for diagnostic handling in LLVM.
C++ class which implements the opaque lto_code_gen_t type.
bool optimize()
Optimizes the merged module.
std::unique_ptr< MemoryBuffer > compile()
As with compile_to_file(), this function compiles the merged module into single output file.
void setModule(std::unique_ptr< LTOModule > M)
Set the destination module.
bool compile_to_file(const char **Name)
Compile the merged module into a single output file; the path to output file is returned to the calle...
void setCpu(StringRef MCpu)
void addMustPreserveSymbol(StringRef Sym)
void setShouldInternalize(bool Value)
void setAttrs(std::vector< std::string > MAttrs)
void parseCodeGenDebugOptions()
Parse the options set in setCodeGenDebugOptions.
void setOptLevel(unsigned OptLevel)
LLVMContext & getContext()
void setAsmUndefinedRefs(struct LTOModule *)
void setDiagnosticHandler(lto_diagnostic_handler_t, void *)
void setFileType(CodeGenFileType FT)
Set the file type to be emitted (assembly or object code).
void setTargetOptions(const TargetOptions &Options)
void setCodeGenDebugOptions(ArrayRef< StringRef > Opts)
Pass options to the driver and optimization passes.
void setCodePICModel(std::optional< Reloc::Model > Model)
std::unique_ptr< MemoryBuffer > compileOptimized()
Compiles the merged optimized module into a single output file.
void setDebugPassManager(bool Enabled)
bool addModule(struct LTOModule *)
Merge given module.
void setDebugInfo(lto_debug_model)
void setSaveIRBeforeOptPath(std::string Value)
void setDisableVerify(bool Value)
void setShouldEmbedUselists(bool Value)
bool writeMergedModules(StringRef Path)
Write the merged module to the file specified by the given path.
static const char * getVersionString()
void setShouldRestoreGlobalsLinkage(bool Value)
Restore linkage of globals.
void setFreestanding(bool Enabled)
Enable the Freestanding mode: indicate that the optimizer should not assume builtins are present on t...
C++ class which implements the opaque lto_module_t type.
Definition: LTOModule.h:38
LTO configuration.
Definition: Config.h:41
bool DebugPassManager
Whether to emit the pass manager debuggging informations.
Definition: Config.h:162
bool DisableVerify
Definition: Config.h:60
std::vector< std::string > MAttrs
Definition: Config.h:50
std::string CPU
Definition: Config.h:48
std::optional< Reloc::Model > RelocModel
Definition: Config.h:55
CodeGenFileType CGFileType
Definition: Config.h:58
bool Freestanding
Flag to indicate that the optimizer should not assume builtins are present on the target.
Definition: Config.h:67