1 //===-Config.h - LLVM Link Time Optimizer Configuration -------------------===//
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 defines the lto::Config data structure, which allows clients to
11 // configure LTO.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_LTO_CONFIG_H
16 #define LLVM_LTO_CONFIG_H
17 
18 #include "llvm/IR/DiagnosticInfo.h"
19 #include "llvm/Support/CodeGen.h"
20 #include "llvm/Target/TargetMachine.h"
21 #include "llvm/Target/TargetOptions.h"
22 
23 #include <functional>
24 
25 namespace llvm {
26 
27 class Error;
28 class Module;
29 class ModuleSummaryIndex;
30 class raw_pwrite_stream;
31 
32 namespace lto {
33 
34 /// LTO configuration. A linker can configure LTO by setting fields in this data
35 /// structure and passing it to the lto::LTO constructor.
36 struct Config {
37   // Note: when adding fields here, consider whether they need to be added to
38   // computeCacheKey in LTO.cpp.
39   std::string CPU;
40   TargetOptions Options;
41   std::vector<std::string> MAttrs;
42   Optional<Reloc::Model> RelocModel = Reloc::PIC_;
43   Optional<CodeModel::Model> CodeModel = None;
44   CodeGenOpt::Level CGOptLevel = CodeGenOpt::Default;
45   TargetMachine::CodeGenFileType CGFileType = TargetMachine::CGFT_ObjectFile;
46   unsigned OptLevel = 2;
47   bool DisableVerify = false;
48 
49   /// Use the new pass manager
50   bool UseNewPM = false;
51 
52   /// Flag to indicate that the optimizer should not assume builtins are present
53   /// on the target.
54   bool Freestanding = false;
55 
56   /// Disable entirely the optimizer, including importing for ThinLTO
57   bool CodeGenOnly = false;
58 
59   /// If this field is set, the set of passes run in the middle-end optimizer
60   /// will be the one specified by the string. Only works with the new pass
61   /// manager as the old one doesn't have this ability.
62   std::string OptPipeline;
63 
64   // If this field is set, it has the same effect of specifying an AA pipeline
65   // identified by the string. Only works with the new pass manager, in
66   // conjunction OptPipeline.
67   std::string AAPipeline;
68 
69   /// Setting this field will replace target triples in input files with this
70   /// triple.
71   std::string OverrideTriple;
72 
73   /// Setting this field will replace unspecified target triples in input files
74   /// with this triple.
75   std::string DefaultTriple;
76 
77   /// Sample PGO profile path.
78   std::string SampleProfile;
79 
80   /// Name remapping file for profile data.
81   std::string ProfileRemapping;
82 
83   /// The directory to store .dwo files.
84   std::string DwoDir;
85 
86   /// The path to write a .dwo file to. This should generally only be used when
87   /// running an individual backend directly via thinBackend(), as otherwise
88   /// all .dwo files will be written to the same path.
89   std::string DwoPath;
90 
91   /// Optimization remarks file path.
92   std::string RemarksFilename = "";
93 
94   /// Whether to emit optimization remarks with hotness informations.
95   bool RemarksWithHotness = false;
96 
97   /// Whether to emit the pass manager debuggging informations.
98   bool DebugPassManager = false;
99 
100   /// Statistics output file path.
101   std::string StatsFile;
102 
103   bool ShouldDiscardValueNames = true;
104   DiagnosticHandlerFunction DiagHandler;
105 
106   /// If this field is set, LTO will write input file paths and symbol
107   /// resolutions here in llvm-lto2 command line flag format. This can be
108   /// used for testing and for running the LTO pipeline outside of the linker
109   /// with llvm-lto2.
110   std::unique_ptr<raw_ostream> ResolutionFile;
111 
112   /// The following callbacks deal with tasks, which normally represent the
113   /// entire optimization and code generation pipeline for what will become a
114   /// single native object file. Each task has a unique identifier between 0 and
115   /// getMaxTasks()-1, which is supplied to the callback via the Task parameter.
116   /// A task represents the entire pipeline for ThinLTO and regular
117   /// (non-parallel) LTO, but a parallel code generation task will be split into
118   /// N tasks before code generation, where N is the parallelism level.
119   ///
120   /// LTO may decide to stop processing a task at any time, for example if the
121   /// module is empty or if a module hook (see below) returns false. For this
122   /// reason, the client should not expect to receive exactly getMaxTasks()
123   /// native object files.
124 
125   /// A module hook may be used by a linker to perform actions during the LTO
126   /// pipeline. For example, a linker may use this function to implement
127   /// -save-temps. If this function returns false, any further processing for
128   /// that task is aborted.
129   ///
130   /// Module hooks must be thread safe with respect to the linker's internal
131   /// data structures. A module hook will never be called concurrently from
132   /// multiple threads with the same task ID, or the same module.
133   ///
134   /// Note that in out-of-process backend scenarios, none of the hooks will be
135   /// called for ThinLTO tasks.
136   typedef std::function<bool(unsigned Task, const Module &)> ModuleHookFn;
137 
138   /// This module hook is called after linking (regular LTO) or loading
139   /// (ThinLTO) the module, before modifying it.
140   ModuleHookFn PreOptModuleHook;
141 
142   /// This hook is called after promoting any internal functions
143   /// (ThinLTO-specific).
144   ModuleHookFn PostPromoteModuleHook;
145 
146   /// This hook is called after internalizing the module.
147   ModuleHookFn PostInternalizeModuleHook;
148 
149   /// This hook is called after importing from other modules (ThinLTO-specific).
150   ModuleHookFn PostImportModuleHook;
151 
152   /// This module hook is called after optimization is complete.
153   ModuleHookFn PostOptModuleHook;
154 
155   /// This module hook is called before code generation. It is similar to the
156   /// PostOptModuleHook, but for parallel code generation it is called after
157   /// splitting the module.
158   ModuleHookFn PreCodeGenModuleHook;
159 
160   /// A combined index hook is called after all per-module indexes have been
161   /// combined (ThinLTO-specific). It can be used to implement -save-temps for
162   /// the combined index.
163   ///
164   /// If this function returns false, any further processing for ThinLTO tasks
165   /// is aborted.
166   ///
167   /// It is called regardless of whether the backend is in-process, although it
168   /// is not called from individual backend processes.
169   typedef std::function<bool(const ModuleSummaryIndex &Index)>
170       CombinedIndexHookFn;
171   CombinedIndexHookFn CombinedIndexHook;
172 
173   /// This is a convenience function that configures this Config object to write
174   /// temporary files named after the given OutputFileName for each of the LTO
175   /// phases to disk. A client can use this function to implement -save-temps.
176   ///
177   /// FIXME: Temporary files derived from ThinLTO backends are currently named
178   /// after the input file name, rather than the output file name, when
179   /// UseInputModulePath is set to true.
180   ///
181   /// Specifically, it (1) sets each of the above module hooks and the combined
182   /// index hook to a function that calls the hook function (if any) that was
183   /// present in the appropriate field when the addSaveTemps function was
184   /// called, and writes the module to a bitcode file with a name prefixed by
185   /// the given output file name, and (2) creates a resolution file whose name
186   /// is prefixed by the given output file name and sets ResolutionFile to its
187   /// file handle.
188   Error addSaveTemps(std::string OutputFileName,
189                      bool UseInputModulePath = false);
190 };
191 
192 struct LTOLLVMDiagnosticHandler : public DiagnosticHandler {
193   DiagnosticHandlerFunction *Fn;
LTOLLVMDiagnosticHandlerLTOLLVMDiagnosticHandler194   LTOLLVMDiagnosticHandler(DiagnosticHandlerFunction *DiagHandlerFn)
195       : Fn(DiagHandlerFn) {}
handleDiagnosticsLTOLLVMDiagnosticHandler196   bool handleDiagnostics(const DiagnosticInfo &DI) override {
197     (*Fn)(DI);
198     return true;
199   }
200 };
201 /// A derived class of LLVMContext that initializes itself according to a given
202 /// Config object. The purpose of this class is to tie ownership of the
203 /// diagnostic handler to the context, as opposed to the Config object (which
204 /// may be ephemeral).
205 // FIXME: This should not be required as diagnostic handler is not callback.
206 struct LTOLLVMContext : LLVMContext {
207 
LTOLLVMContextLTOLLVMContext208   LTOLLVMContext(const Config &C) : DiagHandler(C.DiagHandler) {
209     setDiscardValueNames(C.ShouldDiscardValueNames);
210     enableDebugTypeODRUniquing();
211     setDiagnosticHandler(
212         llvm::make_unique<LTOLLVMDiagnosticHandler>(&DiagHandler), true);
213   }
214   DiagnosticHandlerFunction DiagHandler;
215 };
216 
217 }
218 }
219 
220 #endif
221