From c7fe26d6e428aa1e6518a95a26305acf1d3f869d Mon Sep 17 00:00:00 2001 From: Rafael Espindola Date: Mon, 30 Sep 2013 16:39:19 +0000 Subject: [PATCH] Move command line options to the users of libLTO. Fixes --enable-shared build. Patch by Richard Sandiford. llvm-svn: 191680 --- include/llvm/LTO/LTOCodeGenerator.h | 21 +++- include/llvm/LTO/LTOModule.h | 12 +-- lib/LTO/LTOCodeGenerator.cpp | 58 +++++++---- lib/LTO/LTOModule.cpp | 146 +++------------------------- tools/llvm-lto/llvm-lto.cpp | 57 +++++++++-- tools/lto/lto.cpp | 67 +++++++++++-- 6 files changed, 185 insertions(+), 176 deletions(-) diff --git a/include/llvm/LTO/LTOCodeGenerator.h b/include/llvm/LTO/LTOCodeGenerator.h index 3d151b93afc..08e63748242 100644 --- a/include/llvm/LTO/LTOCodeGenerator.h +++ b/include/llvm/LTO/LTOCodeGenerator.h @@ -39,6 +39,7 @@ #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/StringMap.h" #include "llvm/Linker.h" +#include "llvm/Target/TargetOptions.h" #include #include @@ -64,6 +65,7 @@ struct LTOCodeGenerator { // Merge given module, return true on success. bool addModule(struct LTOModule*, std::string &errMsg); + void setTargetOptions(llvm::TargetOptions options); void setDebugInfo(lto_debug_model); void setCodePICModel(lto_codegen_model); @@ -90,7 +92,11 @@ struct LTOCodeGenerator { // Do not try to remove the object file in LTOCodeGenerator's destructor // as we don't who (LTOCodeGenerator or the obj file) will last longer. // - bool compile_to_file(const char **name, std::string &errMsg); + bool compile_to_file(const char **name, + bool disableOpt, + bool disableInline, + bool disableGVNLoadPRE, + std::string &errMsg); // As with compile_to_file(), this function compiles the merged module into // single object file. Instead of returning the object-file-path to the caller @@ -98,12 +104,20 @@ struct LTOCodeGenerator { // caller. This function should delete intermediate object file once its content // is brought to memory. Return NULL if the compilation was not successful. // - const void *compile(size_t *length, std::string &errMsg); + const void *compile(size_t *length, + bool disableOpt, + bool disableInline, + bool disableGVNLoadPRE, + std::string &errMsg); private: void initializeLTOPasses(); - bool generateObjectFile(llvm::raw_ostream &out, std::string &errMsg); + bool generateObjectFile(llvm::raw_ostream &out, + bool disableOpt, + bool disableInline, + bool disableGVNLoadPRE, + std::string &errMsg); void applyScopeRestrictions(); void applyRestriction(llvm::GlobalValue &GV, std::vector &MustPreserveList, @@ -125,6 +139,7 @@ private: std::vector CodegenOptions; std::string MCpu; std::string NativeObjectPath; + llvm::TargetOptions Options; }; #endif // LTO_CODE_GENERATOR_H diff --git a/include/llvm/LTO/LTOModule.h b/include/llvm/LTO/LTOModule.h index 973466cc0ea..f4693c8d226 100644 --- a/include/llvm/LTO/LTOModule.h +++ b/include/llvm/LTO/LTOModule.h @@ -84,14 +84,17 @@ public: /// InitializeAllAsmPrinters(); /// InitializeAllAsmParsers(); static LTOModule *makeLTOModule(const char* path, + llvm::TargetOptions options, std::string &errMsg); static LTOModule *makeLTOModule(int fd, const char *path, - size_t size, std::string &errMsg); + size_t size, llvm::TargetOptions options, + std::string &errMsg); static LTOModule *makeLTOModule(int fd, const char *path, size_t map_size, - off_t offset, + off_t offset, llvm::TargetOptions options, std::string& errMsg); static LTOModule *makeLTOModule(const void *mem, size_t length, + llvm::TargetOptions options, std::string &errMsg); /// getTargetTriple - Return the Module's target triple. @@ -132,10 +135,6 @@ public: return _asm_undefines; } - /// getTargetOptions - Fill the TargetOptions object with the options - /// specified on the command line. - static void getTargetOptions(llvm::TargetOptions &Options); - private: /// parseSymbols - Parse the symbols from the module and model-level ASM and /// add them to either the defined or undefined lists. @@ -187,6 +186,7 @@ private: /// makeLTOModule - Create an LTOModule (private version). N.B. This /// method takes ownership of the buffer. static LTOModule *makeLTOModule(llvm::MemoryBuffer *buffer, + llvm::TargetOptions options, std::string &errMsg); /// makeBuffer - Create a MemoryBuffer from a memory range. diff --git a/lib/LTO/LTOCodeGenerator.cpp b/lib/LTO/LTOCodeGenerator.cpp index 22e9754bcfa..faa55bbf2ba 100644 --- a/lib/LTO/LTOCodeGenerator.cpp +++ b/lib/LTO/LTOCodeGenerator.cpp @@ -40,6 +40,7 @@ #include "llvm/Support/TargetSelect.h" #include "llvm/Support/ToolOutputFile.h" #include "llvm/Support/system_error.h" +#include "llvm/Target/TargetOptions.h" #include "llvm/Target/TargetRegisterInfo.h" #include "llvm/Target/Mangler.h" #include "llvm/Transforms/IPO.h" @@ -47,18 +48,6 @@ #include "llvm/Transforms/ObjCARC.h" using namespace llvm; -static cl::opt -DisableOpt("disable-opt", cl::init(false), - cl::desc("Do not run any optimization passes")); - -static cl::opt -DisableInline("disable-inlining", cl::init(false), - cl::desc("Do not run the inliner pass")); - -static cl::opt -DisableGVNLoadPRE("disable-gvn-loadpre", cl::init(false), - cl::desc("Do not run the GVN load PRE pass")); - const char* LTOCodeGenerator::getVersionString() { #ifdef LLVM_VERSION_INFO return PACKAGE_NAME " version " PACKAGE_VERSION ", " LLVM_VERSION_INFO; @@ -125,6 +114,27 @@ bool LTOCodeGenerator::addModule(LTOModule* mod, std::string& errMsg) { return !ret; } +void LTOCodeGenerator::setTargetOptions(TargetOptions options) { + Options.LessPreciseFPMADOption = options.LessPreciseFPMADOption; + Options.NoFramePointerElim = options.NoFramePointerElim; + Options.AllowFPOpFusion = options.AllowFPOpFusion; + Options.UnsafeFPMath = options.UnsafeFPMath; + Options.NoInfsFPMath = options.NoInfsFPMath; + Options.NoNaNsFPMath = options.NoNaNsFPMath; + Options.HonorSignDependentRoundingFPMathOption = + options.HonorSignDependentRoundingFPMathOption; + Options.UseSoftFloat = options.UseSoftFloat; + Options.FloatABIType = options.FloatABIType; + Options.NoZerosInBSS = options.NoZerosInBSS; + Options.GuaranteedTailCallOpt = options.GuaranteedTailCallOpt; + Options.DisableTailCalls = options.DisableTailCalls; + Options.StackAlignmentOverride = options.StackAlignmentOverride; + Options.TrapFuncName = options.TrapFuncName; + Options.PositionIndependentExecutable = options.PositionIndependentExecutable; + Options.EnableSegmentedStacks = options.EnableSegmentedStacks; + Options.UseInitArray = options.UseInitArray; +} + void LTOCodeGenerator::setDebugInfo(lto_debug_model debug) { switch (debug) { case LTO_DEBUG_MODEL_NONE: @@ -181,7 +191,11 @@ bool LTOCodeGenerator::writeMergedModules(const char *path, return true; } -bool LTOCodeGenerator::compile_to_file(const char** name, std::string& errMsg) { +bool LTOCodeGenerator::compile_to_file(const char** name, + bool disableOpt, + bool disableInline, + bool disableGVNLoadPRE, + std::string& errMsg) { // make unique temp .o file to put generated object file SmallString<128> Filename; int FD; @@ -194,7 +208,8 @@ bool LTOCodeGenerator::compile_to_file(const char** name, std::string& errMsg) { // generate object file tool_output_file objFile(Filename.c_str(), FD); - bool genResult = generateObjectFile(objFile.os(), errMsg); + bool genResult = generateObjectFile(objFile.os(), disableOpt, disableInline, + disableGVNLoadPRE, errMsg); objFile.os().close(); if (objFile.os().has_error()) { objFile.os().clear_error(); @@ -213,9 +228,14 @@ bool LTOCodeGenerator::compile_to_file(const char** name, std::string& errMsg) { return true; } -const void* LTOCodeGenerator::compile(size_t* length, std::string& errMsg) { +const void* LTOCodeGenerator::compile(size_t* length, + bool disableOpt, + bool disableInline, + bool disableGVNLoadPRE, + std::string& errMsg) { const char *name; - if (!compile_to_file(&name, errMsg)) + if (!compile_to_file(&name, disableOpt, disableInline, disableGVNLoadPRE, + errMsg)) return NULL; // remove old buffer if compile() called twice @@ -285,8 +305,7 @@ bool LTOCodeGenerator::determineTarget(std::string &errMsg) { else if (Triple.getArch() == llvm::Triple::x86) MCpu = "yonah"; } - TargetOptions Options; - LTOModule::getTargetOptions(Options); + TargetMach = march->createTargetMachine(TripleStr, MCpu, FeatureStr, Options, RelocModel, CodeModel::Default, CodeGenOpt::Aggressive); @@ -382,6 +401,9 @@ void LTOCodeGenerator::applyScopeRestrictions() { /// Optimize merged modules using various IPO passes bool LTOCodeGenerator::generateObjectFile(raw_ostream &out, + bool DisableOpt, + bool DisableInline, + bool DisableGVNLoadPRE, std::string &errMsg) { if (!this->determineTarget(errMsg)) return false; diff --git a/lib/LTO/LTOModule.cpp b/lib/LTO/LTOModule.cpp index 1457f2f5a21..fc8bf0c5809 100644 --- a/lib/LTO/LTOModule.cpp +++ b/lib/LTO/LTOModule.cpp @@ -40,108 +40,6 @@ #include "llvm/Target/TargetRegisterInfo.h" using namespace llvm; -static cl::opt -EnableFPMAD("enable-fp-mad", - cl::desc("Enable less precise MAD instructions to be generated"), - cl::init(false)); - -static cl::opt -DisableFPElim("disable-fp-elim", - cl::desc("Disable frame pointer elimination optimization"), - cl::init(false)); - -static cl::opt -EnableUnsafeFPMath("enable-unsafe-fp-math", - cl::desc("Enable optimizations that may decrease FP precision"), - cl::init(false)); - -static cl::opt -EnableNoInfsFPMath("enable-no-infs-fp-math", - cl::desc("Enable FP math optimizations that assume no +-Infs"), - cl::init(false)); - -static cl::opt -EnableNoNaNsFPMath("enable-no-nans-fp-math", - cl::desc("Enable FP math optimizations that assume no NaNs"), - cl::init(false)); - -static cl::opt -EnableHonorSignDependentRoundingFPMath("enable-sign-dependent-rounding-fp-math", - cl::Hidden, - cl::desc("Force codegen to assume rounding mode can change dynamically"), - cl::init(false)); - -static cl::opt -GenerateSoftFloatCalls("soft-float", - cl::desc("Generate software floating point library calls"), - cl::init(false)); - -static cl::opt -FloatABIForCalls("float-abi", - cl::desc("Choose float ABI type"), - cl::init(FloatABI::Default), - cl::values( - clEnumValN(FloatABI::Default, "default", - "Target default float ABI type"), - clEnumValN(FloatABI::Soft, "soft", - "Soft float ABI (implied by -soft-float)"), - clEnumValN(FloatABI::Hard, "hard", - "Hard float ABI (uses FP registers)"), - clEnumValEnd)); - -static cl::opt -FuseFPOps("fp-contract", - cl::desc("Enable aggresive formation of fused FP ops"), - cl::init(FPOpFusion::Standard), - cl::values( - clEnumValN(FPOpFusion::Fast, "fast", - "Fuse FP ops whenever profitable"), - clEnumValN(FPOpFusion::Standard, "on", - "Only fuse 'blessed' FP ops."), - clEnumValN(FPOpFusion::Strict, "off", - "Only fuse FP ops when the result won't be effected."), - clEnumValEnd)); - -static cl::opt -DontPlaceZerosInBSS("nozero-initialized-in-bss", - cl::desc("Don't place zero-initialized symbols into bss section"), - cl::init(false)); - -static cl::opt -EnableGuaranteedTailCallOpt("tailcallopt", - cl::desc("Turn fastcc calls into tail calls by (potentially) changing ABI."), - cl::init(false)); - -static cl::opt -DisableTailCalls("disable-tail-calls", - cl::desc("Never emit tail calls"), - cl::init(false)); - -static cl::opt -OverrideStackAlignment("stack-alignment", - cl::desc("Override default stack alignment"), - cl::init(0)); - -static cl::opt -TrapFuncName("trap-func", cl::Hidden, - cl::desc("Emit a call to trap function rather than a trap instruction"), - cl::init("")); - -static cl::opt -EnablePIE("enable-pie", - cl::desc("Assume the creation of a position independent executable."), - cl::init(false)); - -static cl::opt -SegmentedStacks("segmented-stacks", - cl::desc("Use segmented stacks if possible."), - cl::init(false)); - -static cl::opt -UseInitArray("use-init-array", - cl::desc("Use .init_array instead of .ctors."), - cl::init(false)); - LTOModule::LTOModule(llvm::Module *m, llvm::TargetMachine *t) : _module(m), _target(t), _context(_target->getMCAsmInfo(), _target->getRegisterInfo(), NULL), @@ -189,23 +87,26 @@ bool LTOModule::isTargetMatch(MemoryBuffer *buffer, const char *triplePrefix) { /// makeLTOModule - Create an LTOModule. N.B. These methods take ownership of /// the buffer. -LTOModule *LTOModule::makeLTOModule(const char *path, std::string &errMsg) { +LTOModule *LTOModule::makeLTOModule(const char *path, TargetOptions options, + std::string &errMsg) { OwningPtr buffer; if (error_code ec = MemoryBuffer::getFile(path, buffer)) { errMsg = ec.message(); return NULL; } - return makeLTOModule(buffer.take(), errMsg); + return makeLTOModule(buffer.take(), options, errMsg); } LTOModule *LTOModule::makeLTOModule(int fd, const char *path, - size_t size, std::string &errMsg) { - return makeLTOModule(fd, path, size, 0, errMsg); + size_t size, TargetOptions options, + std::string &errMsg) { + return makeLTOModule(fd, path, size, 0, options, errMsg); } LTOModule *LTOModule::makeLTOModule(int fd, const char *path, size_t map_size, off_t offset, + TargetOptions options, std::string &errMsg) { OwningPtr buffer; if (error_code ec = @@ -213,40 +114,20 @@ LTOModule *LTOModule::makeLTOModule(int fd, const char *path, errMsg = ec.message(); return NULL; } - return makeLTOModule(buffer.take(), errMsg); + return makeLTOModule(buffer.take(), options, errMsg); } LTOModule *LTOModule::makeLTOModule(const void *mem, size_t length, + TargetOptions options, std::string &errMsg) { OwningPtr buffer(makeBuffer(mem, length)); if (!buffer) return NULL; - return makeLTOModule(buffer.take(), errMsg); -} - -void LTOModule::getTargetOptions(TargetOptions &Options) { - Options.LessPreciseFPMADOption = EnableFPMAD; - Options.NoFramePointerElim = DisableFPElim; - Options.AllowFPOpFusion = FuseFPOps; - Options.UnsafeFPMath = EnableUnsafeFPMath; - Options.NoInfsFPMath = EnableNoInfsFPMath; - Options.NoNaNsFPMath = EnableNoNaNsFPMath; - Options.HonorSignDependentRoundingFPMathOption = - EnableHonorSignDependentRoundingFPMath; - Options.UseSoftFloat = GenerateSoftFloatCalls; - if (FloatABIForCalls != FloatABI::Default) - Options.FloatABIType = FloatABIForCalls; - Options.NoZerosInBSS = DontPlaceZerosInBSS; - Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt; - Options.DisableTailCalls = DisableTailCalls; - Options.StackAlignmentOverride = OverrideStackAlignment; - Options.TrapFuncName = TrapFuncName; - Options.PositionIndependentExecutable = EnablePIE; - Options.EnableSegmentedStacks = SegmentedStacks; - Options.UseInitArray = UseInitArray; + return makeLTOModule(buffer.take(), options, errMsg); } LTOModule *LTOModule::makeLTOModule(MemoryBuffer *buffer, + TargetOptions options, std::string &errMsg) { // parse bitcode buffer OwningPtr m(getLazyBitcodeModule(buffer, getGlobalContext(), @@ -278,10 +159,9 @@ LTOModule *LTOModule::makeLTOModule(MemoryBuffer *buffer, else if (Triple.getArch() == llvm::Triple::x86) CPU = "yonah"; } - TargetOptions Options; - getTargetOptions(Options); + TargetMachine *target = march->createTargetMachine(TripleStr, CPU, FeatureStr, - Options); + options); LTOModule *Ret = new LTOModule(m.take(), target); if (Ret->parseSymbols(errMsg)) { delete Ret; diff --git a/tools/llvm-lto/llvm-lto.cpp b/tools/llvm-lto/llvm-lto.cpp index 82a2c8288f1..2f51c0c3d05 100644 --- a/tools/llvm-lto/llvm-lto.cpp +++ b/tools/llvm-lto/llvm-lto.cpp @@ -12,6 +12,7 @@ // //===----------------------------------------------------------------------===// +#include "llvm/CodeGen/CommandFlags.h" #include "llvm/LTO/LTOCodeGenerator.h" #include "llvm/LTO/LTOModule.h" #include "llvm/Support/CommandLine.h" @@ -23,13 +24,26 @@ using namespace llvm; -static cl::list InputFilenames(cl::Positional, cl::OneOrMore, - cl::desc("")); +static cl::opt +DisableOpt("disable-opt", cl::init(false), + cl::desc("Do not run any optimization passes")); -static cl::opt OutputFilename("o", - cl::desc("Override output filename"), - cl::init(""), - cl::value_desc("filename")); +static cl::opt +DisableInline("disable-inlining", cl::init(false), + cl::desc("Do not run the inliner pass")); + +static cl::opt +DisableGVNLoadPRE("disable-gvn-loadpre", cl::init(false), + cl::desc("Do not run the GVN load PRE pass")); + +static cl::list +InputFilenames(cl::Positional, cl::OneOrMore, + cl::desc("")); + +static cl::opt +OutputFilename("o", cl::init(""), + cl::desc("Override output filename"), + cl::value_desc("filename")); int main(int argc, char **argv) { // Print a stack trace if we signal out. @@ -45,6 +59,28 @@ int main(int argc, char **argv) { InitializeAllAsmPrinters(); InitializeAllAsmParsers(); + // set up the TargetOptions for the machine + TargetOptions Options; + Options.LessPreciseFPMADOption = EnableFPMAD; + Options.NoFramePointerElim = DisableFPElim; + Options.AllowFPOpFusion = FuseFPOps; + Options.UnsafeFPMath = EnableUnsafeFPMath; + Options.NoInfsFPMath = EnableNoInfsFPMath; + Options.NoNaNsFPMath = EnableNoNaNsFPMath; + Options.HonorSignDependentRoundingFPMathOption = + EnableHonorSignDependentRoundingFPMath; + Options.UseSoftFloat = GenerateSoftFloatCalls; + if (FloatABIForCalls != FloatABI::Default) + Options.FloatABIType = FloatABIForCalls; + Options.NoZerosInBSS = DontPlaceZerosInBSS; + Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt; + Options.DisableTailCalls = DisableTailCalls; + Options.StackAlignmentOverride = OverrideStackAlignment; + Options.TrapFuncName = TrapFuncName; + Options.PositionIndependentExecutable = EnablePIE; + Options.EnableSegmentedStacks = SegmentedStacks; + Options.UseInitArray = UseInitArray; + unsigned BaseArg = 0; std::string ErrorMessage; @@ -52,11 +88,12 @@ int main(int argc, char **argv) { CodeGen.setCodePICModel(LTO_CODEGEN_PIC_MODEL_DYNAMIC); CodeGen.setDebugInfo(LTO_DEBUG_MODEL_DWARF); + CodeGen.setTargetOptions(Options); for (unsigned i = BaseArg; i < InputFilenames.size(); ++i) { std::string error; OwningPtr Module(LTOModule::makeLTOModule(InputFilenames[i].c_str(), - error)); + Options, error)); if (!error.empty()) { errs() << argv[0] << ": error loading file '" << InputFilenames[i] << "': " << error << "\n"; @@ -74,7 +111,8 @@ int main(int argc, char **argv) { if (!OutputFilename.empty()) { size_t len = 0; std::string ErrorInfo; - const void *Code = CodeGen.compile(&len, ErrorInfo); + const void *Code = CodeGen.compile(&len, DisableOpt, DisableInline, + DisableGVNLoadPRE, ErrorInfo); if (Code == NULL) { errs() << argv[0] << ": error compiling the code: " << ErrorInfo << "\n"; @@ -92,7 +130,8 @@ int main(int argc, char **argv) { } else { std::string ErrorInfo; const char *OutputName = NULL; - if (!CodeGen.compile_to_file(&OutputName, ErrorInfo)) { + if (!CodeGen.compile_to_file(&OutputName, DisableOpt, DisableInline, + DisableGVNLoadPRE, ErrorInfo)) { errs() << argv[0] << ": error compiling the code: " << ErrorInfo << "\n"; diff --git a/tools/lto/lto.cpp b/tools/lto/lto.cpp index 441bc77352c..79967207f55 100644 --- a/tools/lto/lto.cpp +++ b/tools/lto/lto.cpp @@ -13,11 +13,24 @@ //===----------------------------------------------------------------------===// #include "llvm-c/lto.h" +#include "llvm/CodeGen/CommandFlags.h" #include "llvm/LTO/LTOCodeGenerator.h" #include "llvm/LTO/LTOModule.h" #include "llvm-c/Core.h" #include "llvm-c/Target.h" +// extra command-line flags needed for LTOCodeGenerator +static cl::opt +DisableOpt("disable-opt", cl::init(false), + cl::desc("Do not run any optimization passes")); + +static cl::opt +DisableInline("disable-inlining", cl::init(false), + cl::desc("Do not run the inliner pass")); + +static cl::opt +DisableGVNLoadPRE("disable-gvn-loadpre", cl::init(false), + cl::desc("Do not run the GVN load PRE pass")); // Holds most recent error string. // *** Not thread safe *** @@ -40,6 +53,28 @@ static void lto_initialize() { } } +static void lto_set_target_options(llvm::TargetOptions &Options) { + Options.LessPreciseFPMADOption = EnableFPMAD; + Options.NoFramePointerElim = DisableFPElim; + Options.AllowFPOpFusion = FuseFPOps; + Options.UnsafeFPMath = EnableUnsafeFPMath; + Options.NoInfsFPMath = EnableNoInfsFPMath; + Options.NoNaNsFPMath = EnableNoNaNsFPMath; + Options.HonorSignDependentRoundingFPMathOption = + EnableHonorSignDependentRoundingFPMath; + Options.UseSoftFloat = GenerateSoftFloatCalls; + if (FloatABIForCalls != llvm::FloatABI::Default) + Options.FloatABIType = FloatABIForCalls; + Options.NoZerosInBSS = DontPlaceZerosInBSS; + Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt; + Options.DisableTailCalls = DisableTailCalls; + Options.StackAlignmentOverride = OverrideStackAlignment; + Options.TrapFuncName = TrapFuncName; + Options.PositionIndependentExecutable = EnablePIE; + Options.EnableSegmentedStacks = SegmentedStacks; + Options.UseInitArray = UseInitArray; +} + /// lto_get_version - Returns a printable string. extern const char* lto_get_version() { return LTOCodeGenerator::getVersionString(); @@ -82,14 +117,18 @@ lto_module_is_object_file_in_memory_for_target(const void* mem, /// (check lto_get_error_message() for details). lto_module_t lto_module_create(const char* path) { lto_initialize(); - return LTOModule::makeLTOModule(path, sLastErrorString); + llvm::TargetOptions Options; + lto_set_target_options(Options); + return LTOModule::makeLTOModule(path, Options, sLastErrorString); } /// lto_module_create_from_fd - Loads an object file from disk. Returns NULL on /// error (check lto_get_error_message() for details). lto_module_t lto_module_create_from_fd(int fd, const char *path, size_t size) { lto_initialize(); - return LTOModule::makeLTOModule(fd, path, size, sLastErrorString); + llvm::TargetOptions Options; + lto_set_target_options(Options); + return LTOModule::makeLTOModule(fd, path, size, Options, sLastErrorString); } /// lto_module_create_from_fd_at_offset - Loads an object file from disk. @@ -99,14 +138,19 @@ lto_module_t lto_module_create_from_fd_at_offset(int fd, const char *path, size_t map_size, off_t offset) { lto_initialize(); - return LTOModule::makeLTOModule(fd, path, map_size, offset, sLastErrorString); + llvm::TargetOptions Options; + lto_set_target_options(Options); + return LTOModule::makeLTOModule(fd, path, map_size, offset, Options, + sLastErrorString); } /// lto_module_create_from_memory - Loads an object file from memory. Returns /// NULL on error (check lto_get_error_message() for details). lto_module_t lto_module_create_from_memory(const void* mem, size_t length) { lto_initialize(); - return LTOModule::makeLTOModule(mem, length, sLastErrorString); + llvm::TargetOptions Options; + lto_set_target_options(Options); + return LTOModule::makeLTOModule(mem, length, Options, sLastErrorString); } /// lto_module_dispose - Frees all memory for a module. Upon return the @@ -150,7 +194,14 @@ lto_symbol_attributes lto_module_get_symbol_attribute(lto_module_t mod, /// is an error. lto_code_gen_t lto_codegen_create(void) { lto_initialize(); - return new LTOCodeGenerator(); + + TargetOptions Options; + lto_set_target_options(Options); + + LTOCodeGenerator *CodeGen = new LTOCodeGenerator(); + if (CodeGen) + CodeGen->setTargetOptions(Options); + return CodeGen; } /// lto_codegen_dispose - Frees all memory for a code generator. Upon return the @@ -220,14 +271,16 @@ bool lto_codegen_write_merged_modules(lto_code_gen_t cg, const char *path) { /// lto_codegen_compile() is called again. On failure, returns NULL (check /// lto_get_error_message() for details). const void *lto_codegen_compile(lto_code_gen_t cg, size_t *length) { - return cg->compile(length, sLastErrorString); + return cg->compile(length, DisableOpt, DisableInline, DisableGVNLoadPRE, + sLastErrorString); } /// lto_codegen_compile_to_file - Generates code for all added modules into one /// native object file. The name of the file is written to name. Returns true on /// error. bool lto_codegen_compile_to_file(lto_code_gen_t cg, const char **name) { - return !cg->compile_to_file(name, sLastErrorString); + return !cg->compile_to_file(name, DisableOpt, DisableInline, DisableGVNLoadPRE, + sLastErrorString); } /// lto_codegen_debug_options - Used to pass extra options to the code