LLVM 19.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"
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"
47#include "llvm/Support/Error.h"
51#include <string>
52#include <vector>
54namespace llvm {
55template <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;
66/// Enable global value internalization in LTO.
67extern cl::opt<bool> EnableLTOInternalization;
70/// C++ class which implements the opaque lto_code_gen_t type.
73 static const char *getVersionString();
78 /// Merge given module. Return true on success.
79 ///
80 /// Resets \a HasVerifiedInput.
81 bool addModule(struct LTOModule *);
83 /// Set the destination module.
84 ///
85 /// Resets \a HasVerifiedInput.
86 void setModule(std::unique_ptr<LTOModule> M);
88 void setAsmUndefinedRefs(struct LTOModule *);
91 void setCodePICModel(std::optional<Reloc::Model> Model) {
92 Config.RelocModel = Model;
93 }
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; }
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);
103 void setShouldInternalize(bool Value) { ShouldInternalize = Value; }
104 void setShouldEmbedUselists(bool Value) { ShouldEmbedUselists = Value; }
105 void setSaveIRBeforeOptPath(std::string Value) {
106 SaveIRBeforeOptPath = Value;
107 }
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.
122 ShouldRestoreGlobalsLinkage = Value;
123 }
125 void addMustPreserveSymbol(StringRef Sym) { MustPreserveSymbols.insert(Sym); }
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().
135 /// Parse the options set in setCodeGenDebugOptions.
136 ///
137 /// Like \a setCodeGenDebugOptions(), this must be called before
138 /// LTOCodeGenerator::compilexxx() and
139 /// LTOCodeGenerator::writeMergedModules().
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);
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);
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();
165 /// Optimizes the merged module. Returns true on success.
166 ///
167 /// Calls \a verifyMergedModuleOnce().
168 bool optimize();
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();
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);
184 /// Enable the Freestanding mode: indicate that the optimizer should not
185 /// assume builtins are present on the target.
188 void setDisableVerify(bool Value) { Config.DisableVerify = Value; }
196 void resetMergedModule() { MergedModule.reset(); }
197 void DiagnosticHandler(const DiagnosticInfo &DI);
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();
206 bool compileOptimizedToFile(const char **Name);
207 void restoreLinkageForExternals();
208 void applyScopeRestrictions();
209 void preserveDiscardableGVs(
210 Module &TheModule,
213 bool determineTarget();
214 std::unique_ptr<TargetMachine> createTargetMachine();
216 bool useAIXSystemAssembler();
217 bool runAIXSystemAssembler(SmallString<128> &AssemblyFile);
219 void emitError(const std::string &ErrMsg);
220 void emitWarning(const std::string &ErrMsg);
222 void finishOptimizationRemarks();
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;
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;
248 lto::Config Config;
251/// A convenience function that calls cl::ParseCommandLineOptions on the given
252/// set of options.
253void 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:479
static LVOptions Options
Definition: LVOptions.cpp:25
Module.h This file contains the declarations for the Module class.
LLVMContext & Context
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:128
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:38
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:83
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:166
bool DisableVerify
Definition: Config.h:61
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:65