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
51namespace llvm {
52template <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///
66struct 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  void setFileType(TargetMachine::CodeGenFileType FT) { FileType = FT; }
90
91  void setCpu(StringRef MCpu) { this->MCpu = MCpu; }
92  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    ShouldRestoreGlobalsLinkage = Value;
112  }
113
114  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  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
189private:
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
245