88c1452e5aa90d5814068e8910894196d6e486bd
[lldb.git] / llvm / include / llvm / LTO / Config.h
1 //===-Config.h - LLVM Link Time Optimizer Configuration ---------*- C++ -*-===//
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 defines the lto::Config data structure, which allows clients to
10 // configure LTO.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #ifndef LLVM_LTO_CONFIG_H
15 #define LLVM_LTO_CONFIG_H
16
17 #include "llvm/ADT/DenseSet.h"
18 #include "llvm/Config/llvm-config.h"
19 #include "llvm/IR/DiagnosticInfo.h"
20 #include "llvm/IR/GlobalValue.h"
21 #include "llvm/IR/LLVMContext.h"
22 #include "llvm/IR/LegacyPassManager.h"
23 #include "llvm/Passes/PassBuilder.h"
24 #include "llvm/Support/CodeGen.h"
25 #include "llvm/Target/TargetOptions.h"
26
27 #include <functional>
28
29 namespace llvm {
30
31 class Error;
32 class Module;
33 class ModuleSummaryIndex;
34 class raw_pwrite_stream;
35
36 namespace lto {
37
38 /// LTO configuration. A linker can configure LTO by setting fields in this data
39 /// structure and passing it to the lto::LTO constructor.
40 struct Config {
41   // Note: when adding fields here, consider whether they need to be added to
42   // computeCacheKey in LTO.cpp.
43   std::string CPU;
44   TargetOptions Options;
45   std::vector<std::string> MAttrs;
46   std::vector<std::string> PassPlugins;
47   /// For adding passes that run right before codegen.
48   std::function<void(legacy::PassManager &)> PreCodeGenPassesHook;
49   Optional<Reloc::Model> RelocModel = Reloc::PIC_;
50   Optional<CodeModel::Model> CodeModel = None;
51   CodeGenOpt::Level CGOptLevel = CodeGenOpt::Default;
52   CodeGenFileType CGFileType = CGFT_ObjectFile;
53   unsigned OptLevel = 2;
54   bool DisableVerify = false;
55
56   /// Use the new pass manager
57   bool UseNewPM = LLVM_ENABLE_NEW_PASS_MANAGER;
58
59   /// Flag to indicate that the optimizer should not assume builtins are present
60   /// on the target.
61   bool Freestanding = false;
62
63   /// Disable entirely the optimizer, including importing for ThinLTO
64   bool CodeGenOnly = false;
65
66   /// Run PGO context sensitive IR instrumentation.
67   bool RunCSIRInstr = false;
68
69   /// Asserts whether we can assume whole program visibility during the LTO
70   /// link.
71   bool HasWholeProgramVisibility = false;
72
73   /// Always emit a Regular LTO object even when it is empty because no Regular
74   /// LTO modules were linked. This option is useful for some build system which
75   /// want to know a priori all possible output files.
76   bool AlwaysEmitRegularLTOObj = false;
77
78   /// If this field is set, the set of passes run in the middle-end optimizer
79   /// will be the one specified by the string. Only works with the new pass
80   /// manager as the old one doesn't have this ability.
81   std::string OptPipeline;
82
83   // If this field is set, it has the same effect of specifying an AA pipeline
84   // identified by the string. Only works with the new pass manager, in
85   // conjunction OptPipeline.
86   std::string AAPipeline;
87
88   /// Setting this field will replace target triples in input files with this
89   /// triple.
90   std::string OverrideTriple;
91
92   /// Setting this field will replace unspecified target triples in input files
93   /// with this triple.
94   std::string DefaultTriple;
95
96   /// Context Sensitive PGO profile path.
97   std::string CSIRProfile;
98
99   /// Sample PGO profile path.
100   std::string SampleProfile;
101
102   /// Name remapping file for profile data.
103   std::string ProfileRemapping;
104
105   /// The directory to store .dwo files.
106   std::string DwoDir;
107
108   /// The name for the split debug info file used for the DW_AT_[GNU_]dwo_name
109   /// attribute in the skeleton CU. This should generally only be used when
110   /// running an individual backend directly via thinBackend(), as otherwise
111   /// all objects would use the same .dwo file. Not used as output path.
112   std::string SplitDwarfFile;
113
114   /// The path to write a .dwo file to. This should generally only be used when
115   /// running an individual backend directly via thinBackend(), as otherwise
116   /// all .dwo files will be written to the same path. Not used in skeleton CU.
117   std::string SplitDwarfOutput;
118
119   /// Optimization remarks file path.
120   std::string RemarksFilename;
121
122   /// Optimization remarks pass filter.
123   std::string RemarksPasses;
124
125   /// Whether to emit optimization remarks with hotness informations.
126   bool RemarksWithHotness = false;
127
128   /// The minimum hotness value a diagnostic needs in order to be included in
129   /// optimization diagnostics.
130   ///
131   /// The threshold is an Optional value, which maps to one of the 3 states:
132   /// 1. 0            => threshold disabled. All emarks will be printed.
133   /// 2. positive int => manual threshold by user. Remarks with hotness exceed
134   ///                    threshold will be printed.
135   /// 3. None         => 'auto' threshold by user. The actual value is not
136   ///                    available at command line, but will be synced with
137   ///                    hotness threhold from profile summary during
138   ///                    compilation.
139   ///
140   /// If threshold option is not specified, it is disabled by default.
141   llvm::Optional<uint64_t> RemarksHotnessThreshold = 0;
142
143   /// The format used for serializing remarks (default: YAML).
144   std::string RemarksFormat;
145
146   /// Whether to emit the pass manager debuggging informations.
147   bool DebugPassManager = false;
148
149   /// Statistics output file path.
150   std::string StatsFile;
151
152   /// Specific thinLTO modules to compile.
153   std::vector<std::string> ThinLTOModulesToCompile;
154
155   /// Time trace enabled.
156   bool TimeTraceEnabled = false;
157
158   /// Time trace granularity.
159   unsigned TimeTraceGranularity = 500;
160
161   bool ShouldDiscardValueNames = true;
162   DiagnosticHandlerFunction DiagHandler;
163
164   /// If this field is set, LTO will write input file paths and symbol
165   /// resolutions here in llvm-lto2 command line flag format. This can be
166   /// used for testing and for running the LTO pipeline outside of the linker
167   /// with llvm-lto2.
168   std::unique_ptr<raw_ostream> ResolutionFile;
169
170   /// Tunable parameters for passes in the default pipelines.
171   PipelineTuningOptions PTO;
172
173   /// The following callbacks deal with tasks, which normally represent the
174   /// entire optimization and code generation pipeline for what will become a
175   /// single native object file. Each task has a unique identifier between 0 and
176   /// getMaxTasks()-1, which is supplied to the callback via the Task parameter.
177   /// A task represents the entire pipeline for ThinLTO and regular
178   /// (non-parallel) LTO, but a parallel code generation task will be split into
179   /// N tasks before code generation, where N is the parallelism level.
180   ///
181   /// LTO may decide to stop processing a task at any time, for example if the
182   /// module is empty or if a module hook (see below) returns false. For this
183   /// reason, the client should not expect to receive exactly getMaxTasks()
184   /// native object files.
185
186   /// A module hook may be used by a linker to perform actions during the LTO
187   /// pipeline. For example, a linker may use this function to implement
188   /// -save-temps. If this function returns false, any further processing for
189   /// that task is aborted.
190   ///
191   /// Module hooks must be thread safe with respect to the linker's internal
192   /// data structures. A module hook will never be called concurrently from
193   /// multiple threads with the same task ID, or the same module.
194   ///
195   /// Note that in out-of-process backend scenarios, none of the hooks will be
196   /// called for ThinLTO tasks.
197   using ModuleHookFn = std::function<bool(unsigned Task, const Module &)>;
198
199   /// This module hook is called after linking (regular LTO) or loading
200   /// (ThinLTO) the module, before modifying it.
201   ModuleHookFn PreOptModuleHook;
202
203   /// This hook is called after promoting any internal functions
204   /// (ThinLTO-specific).
205   ModuleHookFn PostPromoteModuleHook;
206
207   /// This hook is called after internalizing the module.
208   ModuleHookFn PostInternalizeModuleHook;
209
210   /// This hook is called after importing from other modules (ThinLTO-specific).
211   ModuleHookFn PostImportModuleHook;
212
213   /// This module hook is called after optimization is complete.
214   ModuleHookFn PostOptModuleHook;
215
216   /// This module hook is called before code generation. It is similar to the
217   /// PostOptModuleHook, but for parallel code generation it is called after
218   /// splitting the module.
219   ModuleHookFn PreCodeGenModuleHook;
220
221   /// A combined index hook is called after all per-module indexes have been
222   /// combined (ThinLTO-specific). It can be used to implement -save-temps for
223   /// the combined index.
224   ///
225   /// If this function returns false, any further processing for ThinLTO tasks
226   /// is aborted.
227   ///
228   /// It is called regardless of whether the backend is in-process, although it
229   /// is not called from individual backend processes.
230   using CombinedIndexHookFn = std::function<bool(
231       const ModuleSummaryIndex &Index,
232       const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols)>;
233   CombinedIndexHookFn CombinedIndexHook;
234
235   /// This is a convenience function that configures this Config object to write
236   /// temporary files named after the given OutputFileName for each of the LTO
237   /// phases to disk. A client can use this function to implement -save-temps.
238   ///
239   /// FIXME: Temporary files derived from ThinLTO backends are currently named
240   /// after the input file name, rather than the output file name, when
241   /// UseInputModulePath is set to true.
242   ///
243   /// Specifically, it (1) sets each of the above module hooks and the combined
244   /// index hook to a function that calls the hook function (if any) that was
245   /// present in the appropriate field when the addSaveTemps function was
246   /// called, and writes the module to a bitcode file with a name prefixed by
247   /// the given output file name, and (2) creates a resolution file whose name
248   /// is prefixed by the given output file name and sets ResolutionFile to its
249   /// file handle.
250   Error addSaveTemps(std::string OutputFileName,
251                      bool UseInputModulePath = false);
252 };
253
254 struct LTOLLVMDiagnosticHandler : public DiagnosticHandler {
255   DiagnosticHandlerFunction *Fn;
256   LTOLLVMDiagnosticHandler(DiagnosticHandlerFunction *DiagHandlerFn)
257       : Fn(DiagHandlerFn) {}
258   bool handleDiagnostics(const DiagnosticInfo &DI) override {
259     (*Fn)(DI);
260     return true;
261   }
262 };
263 /// A derived class of LLVMContext that initializes itself according to a given
264 /// Config object. The purpose of this class is to tie ownership of the
265 /// diagnostic handler to the context, as opposed to the Config object (which
266 /// may be ephemeral).
267 // FIXME: This should not be required as diagnostic handler is not callback.
268 struct LTOLLVMContext : LLVMContext {
269
270   LTOLLVMContext(const Config &C) : DiagHandler(C.DiagHandler) {
271     setDiscardValueNames(C.ShouldDiscardValueNames);
272     enableDebugTypeODRUniquing();
273     setDiagnosticHandler(
274         std::make_unique<LTOLLVMDiagnosticHandler>(&DiagHandler), true);
275   }
276   DiagnosticHandlerFunction DiagHandler;
277 };
278
279 }
280 }
281
282 #endif