tools/lto/lto.cpp

   1 //===-lto.cpp - 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 implements the Link Time Optimization library. This library is
  11 // intended to be used by linker to optimize code at link time.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm-c/lto.h"
  16 #include "llvm/ADT/STLExtras.h"
  17 #include "llvm/CodeGen/CommandFlags.h"
  18 #include "llvm/IR/LLVMContext.h"
  19 #include "llvm/LTO/LTOCodeGenerator.h"
  20 #include "llvm/LTO/LTOModule.h"
  21 #include "llvm/Support/MemoryBuffer.h"
  22 #include "llvm/Support/Signals.h"
  23 #include "llvm/Support/TargetSelect.h"
  24
  25 // extra command-line flags needed for LTOCodeGenerator
  26 static cl::opt<char>
  27 OptLevel("O",
  28          cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
  29                   "(default = '-O2')"),
  30          cl::Prefix,
  31          cl::ZeroOrMore,
  32          cl::init('2'));
  33
  34 static cl::opt<bool>
  35 DisableInline("disable-inlining", cl::init(false),
  36   cl::desc("Do not run the inliner pass"));
  37
  38 static cl::opt<bool>
  39 DisableGVNLoadPRE("disable-gvn-loadpre", cl::init(false),
  40   cl::desc("Do not run the GVN load PRE pass"));
  41
  42 static cl::opt<bool>
  43 DisableLTOVectorization("disable-lto-vectorization", cl::init(false),
  44   cl::desc("Do not run loop or slp vectorization during LTO"));
  45
  46 #ifdef NDEBUG
  47 static bool VerifyByDefault = false;
  48 #else
  49 static bool VerifyByDefault = true;
  50 #endif
  51
  52 static cl::opt<bool> DisableVerify(
  53     "disable-llvm-verifier", cl::init(!VerifyByDefault),
  54     cl::desc("Don't run the LLVM verifier during the optimization pipeline"));
  55
  56 // Holds most recent error string.
  57 // *** Not thread safe ***
  58 static std::string sLastErrorString;
  59
  60 // Holds the initialization state of the LTO module.
  61 // *** Not thread safe ***
  62 static bool initialized = false;
  63
  64 // Holds the command-line option parsing state of the LTO module.
  65 static bool parsedOptions = false;
  66
  67 // Initialize the configured targets if they have not been initialized.
  68 static void lto_initialize() {
  69   if (!initialized) {
  70 #ifdef LLVM_ON_WIN32
  71     // Dialog box on crash disabling doesn't work across DLL boundaries, so do
  72     // it here.
  73     llvm::sys::DisableSystemDialogsOnCrash();
  74 #endif
  75
  76     InitializeAllTargetInfos();
  77     InitializeAllTargets();
  78     InitializeAllTargetMCs();
  79     InitializeAllAsmParsers();
  80     InitializeAllAsmPrinters();
  81     InitializeAllDisassemblers();
  82     initialized = true;
  83   }
  84 }
  85
  86 namespace {
  87
  88 static void handleLibLTODiagnostic(lto_codegen_diagnostic_severity_t Severity,
  89                                    const char *Msg, void *) {
  90   sLastErrorString = Msg;
  91   sLastErrorString += "\n";
  92 }
  93
  94 // This derived class owns the native object file. This helps implement the
  95 // libLTO API semantics, which require that the code generator owns the object
  96 // file.
  97 struct LibLTOCodeGenerator : LTOCodeGenerator {
  98   LibLTOCodeGenerator() : LTOCodeGenerator(getGlobalContext()) {
  99     setDiagnosticHandler(handleLibLTODiagnostic, nullptr); }
 100   LibLTOCodeGenerator(std::unique_ptr<LLVMContext> Context)
 101       : LTOCodeGenerator(*Context), OwnedContext(std::move(Context)) {
 102     setDiagnosticHandler(handleLibLTODiagnostic, nullptr); }
 103
 104   std::unique_ptr<MemoryBuffer> NativeObjectFile;
 105   std::unique_ptr<LLVMContext> OwnedContext;
 106 };
 107
 108 }
 109
 110 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LibLTOCodeGenerator, lto_code_gen_t)
 111 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LTOModule, lto_module_t)
 112
 113 // Convert the subtarget features into a string to pass to LTOCodeGenerator.
 114 static void lto_add_attrs(lto_code_gen_t cg) {
 115   LTOCodeGenerator *CG = unwrap(cg);
 116   if (MAttrs.size()) {
 117     std::string attrs;
 118     for (unsigned i = 0; i < MAttrs.size(); ++i) {
 119       if (i > 0)
 120         attrs.append(",");
 121       attrs.append(MAttrs[i]);
 122     }
 123
 124     CG->setAttr(attrs.c_str());
 125   }
 126
 127   if (OptLevel < '0' || OptLevel > '3')
 128     report_fatal_error("Optimization level must be between 0 and 3");
 129   CG->setOptLevel(OptLevel - '0');
 130 }
 131
 132 extern const char* lto_get_version() {
 133   return LTOCodeGenerator::getVersionString();
 134 }
 135
 136 const char* lto_get_error_message() {
 137   return sLastErrorString.c_str();
 138 }
 139
 140 bool lto_module_is_object_file(const char* path) {
 141   return LTOModule::isBitcodeFile(path);
 142 }
 143
 144 bool lto_module_is_object_file_for_target(const char* path,
 145                                           const char* target_triplet_prefix) {
 146   ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer = MemoryBuffer::getFile(path);
 147   if (!Buffer)
 148     return false;
 149   return LTOModule::isBitcodeForTarget(Buffer->get(), target_triplet_prefix);
 150 }
 151
 152 bool lto_module_is_object_file_in_memory(const void* mem, size_t length) {
 153   return LTOModule::isBitcodeFile(mem, length);
 154 }
 155
 156 bool
 157 lto_module_is_object_file_in_memory_for_target(const void* mem,
 158                                             size_t length,
 159                                             const char* target_triplet_prefix) {
 160   std::unique_ptr<MemoryBuffer> buffer(LTOModule::makeBuffer(mem, length));
 161   if (!buffer)
 162     return false;
 163   return LTOModule::isBitcodeForTarget(buffer.get(), target_triplet_prefix);
 164 }
 165
 166 lto_module_t lto_module_create(const char* path) {
 167   lto_initialize();
 168   llvm::TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
 169   return wrap(LTOModule::createFromFile(path, Options, sLastErrorString));
 170 }
 171
 172 lto_module_t lto_module_create_from_fd(int fd, const char *path, size_t size) {
 173   lto_initialize();
 174   llvm::TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
 175   return wrap(
 176       LTOModule::createFromOpenFile(fd, path, size, Options, sLastErrorString));
 177 }
 178
 179 lto_module_t lto_module_create_from_fd_at_offset(int fd, const char *path,
 180                                                  size_t file_size,
 181                                                  size_t map_size,
 182                                                  off_t offset) {
 183   lto_initialize();
 184   llvm::TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
 185   return wrap(LTOModule::createFromOpenFileSlice(fd, path, map_size, offset,
 186                                                  Options, sLastErrorString));
 187 }
 188
 189 lto_module_t lto_module_create_from_memory(const void* mem, size_t length) {
 190   lto_initialize();
 191   llvm::TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
 192   return wrap(LTOModule::createFromBuffer(mem, length, Options, sLastErrorString));
 193 }
 194
 195 lto_module_t lto_module_create_from_memory_with_path(const void* mem,
 196                                                      size_t length,
 197                                                      const char *path) {
 198   lto_initialize();
 199   llvm::TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
 200   return wrap(
 201       LTOModule::createFromBuffer(mem, length, Options, sLastErrorString, path));
 202 }
 203
 204 lto_module_t lto_module_create_in_local_context(const void *mem, size_t length,
 205                                                 const char *path) {
 206   lto_initialize();
 207   llvm::TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
 208   return wrap(LTOModule::createInLocalContext(mem, length, Options,
 209                                               sLastErrorString, path));
 210 }
 211
 212 lto_module_t lto_module_create_in_codegen_context(const void *mem,
 213                                                   size_t length,
 214                                                   const char *path,
 215                                                   lto_code_gen_t cg) {
 216   lto_initialize();
 217   llvm::TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
 218   return wrap(LTOModule::createInContext(mem, length, Options, sLastErrorString,
 219                                          path, &unwrap(cg)->getContext()));
 220 }
 221
 222 void lto_module_dispose(lto_module_t mod) { delete unwrap(mod); }
 223
 224 const char* lto_module_get_target_triple(lto_module_t mod) {
 225   return unwrap(mod)->getTargetTriple().c_str();
 226 }
 227
 228 void lto_module_set_target_triple(lto_module_t mod, const char *triple) {
 229   return unwrap(mod)->setTargetTriple(triple);
 230 }
 231
 232 unsigned int lto_module_get_num_symbols(lto_module_t mod) {
 233   return unwrap(mod)->getSymbolCount();
 234 }
 235
 236 const char* lto_module_get_symbol_name(lto_module_t mod, unsigned int index) {
 237   return unwrap(mod)->getSymbolName(index);
 238 }
 239
 240 lto_symbol_attributes lto_module_get_symbol_attribute(lto_module_t mod,
 241                                                       unsigned int index) {
 242   return unwrap(mod)->getSymbolAttributes(index);
 243 }
 244
 245 const char* lto_module_get_linkeropts(lto_module_t mod) {
 246   return unwrap(mod)->getLinkerOpts();
 247 }
 248
 249 void lto_codegen_set_diagnostic_handler(lto_code_gen_t cg,
 250                                         lto_diagnostic_handler_t diag_handler,
 251                                         void *ctxt) {
 252   unwrap(cg)->setDiagnosticHandler(diag_handler, ctxt);
 253 }
 254
 255 static lto_code_gen_t createCodeGen(bool InLocalContext) {
 256   lto_initialize();
 257
 258   TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
 259
 260   LibLTOCodeGenerator *CodeGen =
 261       InLocalContext ? new LibLTOCodeGenerator(make_unique<LLVMContext>())
 262                      : new LibLTOCodeGenerator();
 263   CodeGen->setTargetOptions(Options);
 264   return wrap(CodeGen);
 265 }
 266
 267 lto_code_gen_t lto_codegen_create(void) {
 268   return createCodeGen(/* InLocalContext */ false);
 269 }
 270
 271 lto_code_gen_t lto_codegen_create_in_local_context(void) {
 272   return createCodeGen(/* InLocalContext */ true);
 273 }
 274
 275 void lto_codegen_dispose(lto_code_gen_t cg) { delete unwrap(cg); }
 276
 277 bool lto_codegen_add_module(lto_code_gen_t cg, lto_module_t mod) {
 278   return !unwrap(cg)->addModule(unwrap(mod));
 279 }
 280
 281 void lto_codegen_set_module(lto_code_gen_t cg, lto_module_t mod) {
 282   unwrap(cg)->setModule(std::unique_ptr<LTOModule>(unwrap(mod)));
 283 }
 284
 285 bool lto_codegen_set_debug_model(lto_code_gen_t cg, lto_debug_model debug) {
 286   unwrap(cg)->setDebugInfo(debug);
 287   return false;
 288 }
 289
 290 bool lto_codegen_set_pic_model(lto_code_gen_t cg, lto_codegen_model model) {
 291   switch (model) {
 292   case LTO_CODEGEN_PIC_MODEL_STATIC:
 293     unwrap(cg)->setCodePICModel(Reloc::Static);
 294     return false;
 295   case LTO_CODEGEN_PIC_MODEL_DYNAMIC:
 296     unwrap(cg)->setCodePICModel(Reloc::PIC_);
 297     return false;
 298   case LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC:
 299     unwrap(cg)->setCodePICModel(Reloc::DynamicNoPIC);
 300     return false;
 301   case LTO_CODEGEN_PIC_MODEL_DEFAULT:
 302     unwrap(cg)->setCodePICModel(Reloc::Default);
 303     return false;
 304   }
 305   sLastErrorString = "Unknown PIC model";
 306   return true;
 307 }
 308
 309 void lto_codegen_set_cpu(lto_code_gen_t cg, const char *cpu) {
 310   return unwrap(cg)->setCpu(cpu);
 311 }
 312
 313 void lto_codegen_set_assembler_path(lto_code_gen_t cg, const char *path) {
 314   // In here only for backwards compatibility. We use MC now.
 315 }
 316
 317 void lto_codegen_set_assembler_args(lto_code_gen_t cg, const char **args,
 318                                     int nargs) {
 319   // In here only for backwards compatibility. We use MC now.
 320 }
 321
 322 void lto_codegen_add_must_preserve_symbol(lto_code_gen_t cg,
 323                                           const char *symbol) {
 324   unwrap(cg)->addMustPreserveSymbol(symbol);
 325 }
 326
 327 static void maybeParseOptions(lto_code_gen_t cg) {
 328   if (!parsedOptions) {
 329     unwrap(cg)->parseCodeGenDebugOptions();
 330     lto_add_attrs(cg);
 331     parsedOptions = true;
 332   }
 333 }
 334
 335 bool lto_codegen_write_merged_modules(lto_code_gen_t cg, const char *path) {
 336   maybeParseOptions(cg);
 337   return !unwrap(cg)->writeMergedModules(path);
 338 }
 339
 340 const void *lto_codegen_compile(lto_code_gen_t cg, size_t *length) {
 341   maybeParseOptions(cg);
 342   LibLTOCodeGenerator *CG = unwrap(cg);
 343   CG->NativeObjectFile =
 344       CG->compile(DisableVerify, DisableInline, DisableGVNLoadPRE,
 345                   DisableLTOVectorization);
 346   if (!CG->NativeObjectFile)
 347     return nullptr;
 348   *length = CG->NativeObjectFile->getBufferSize();
 349   return CG->NativeObjectFile->getBufferStart();
 350 }
 351
 352 bool lto_codegen_optimize(lto_code_gen_t cg) {
 353   maybeParseOptions(cg);
 354   return !unwrap(cg)->optimize(DisableVerify, DisableInline, DisableGVNLoadPRE,
 355                                DisableLTOVectorization);
 356 }
 357
 358 const void *lto_codegen_compile_optimized(lto_code_gen_t cg, size_t *length) {
 359   maybeParseOptions(cg);
 360   LibLTOCodeGenerator *CG = unwrap(cg);
 361   CG->NativeObjectFile = CG->compileOptimized();
 362   if (!CG->NativeObjectFile)
 363     return nullptr;
 364   *length = CG->NativeObjectFile->getBufferSize();
 365   return CG->NativeObjectFile->getBufferStart();
 366 }
 367
 368 bool lto_codegen_compile_to_file(lto_code_gen_t cg, const char **name) {
 369   maybeParseOptions(cg);
 370   return !unwrap(cg)->compile_to_file(
 371       name, DisableVerify, DisableInline, DisableGVNLoadPRE,
 372       DisableLTOVectorization);
 373 }
 374
 375 void lto_codegen_debug_options(lto_code_gen_t cg, const char *opt) {
 376   unwrap(cg)->setCodeGenDebugOptions(opt);
 377 }
 378
 379 unsigned int lto_api_version() { return LTO_API_VERSION; }
 380
 381 void lto_codegen_set_should_internalize(lto_code_gen_t cg,
 382                                         bool ShouldInternalize) {
 383   unwrap(cg)->setShouldInternalize(ShouldInternalize);
 384 }
 385
 386 void lto_codegen_set_should_embed_uselists(lto_code_gen_t cg,
 387                                            lto_bool_t ShouldEmbedUselists) {
 388   unwrap(cg)->setShouldEmbedUselists(ShouldEmbedUselists);
 389 }