Go to the documentation of this file.
50 #define DEBUG_TYPE "lto-backend"
63 "Embed after all optimization passes"),
66 "Embed post merge, but before optimizations")),
67 cl::desc(
"Embed LLVM bitcode in object files produced by LTO"));
70 "thinlto-assume-merged",
cl::init(
false),
71 cl::desc(
"Assume the input has already undergone ThinLTO function "
72 "importing and the other pre-optimization pipeline changes."));
79 errs() <<
"failed to open " << Path <<
": " <<
Msg <<
'\n';
85 bool UseInputModulePath) {
90 std::make_unique<raw_fd_ostream>(OutputFileName +
"resolution.txt", EC,
97 auto setHook = [&](std::string PathSuffix,
ModuleHookFn &Hook) {
100 Hook = [=](
unsigned Task,
const Module &
M) {
103 if (LinkerHook && !LinkerHook(Task,
M))
106 std::string PathPrefix;
110 if (
M.getModuleIdentifier() ==
"ld-temp.o" || !UseInputModulePath) {
111 PathPrefix = OutputFileName;
112 if (Task != (
unsigned)-1)
113 PathPrefix += utostr(Task) +
".";
115 PathPrefix =
M.getModuleIdentifier() +
".";
116 std::string Path = PathPrefix + PathSuffix +
".bc";
138 std::string Path = OutputFileName +
"index.bc";
147 Path = OutputFileName +
"index.dot";
151 Index.exportToDot(OSDot, GUIDPreservedSymbols);
158 #define HANDLE_EXTENSION(Ext) \
159 llvm::PassPluginLibraryInfo get##Ext##PluginInfo();
160 #include "llvm/Support/Extension.def"
164 #define HANDLE_EXTENSION(Ext) \
165 get##Ext##PluginInfo().RegisterPassBuilderCallbacks(PB);
166 #include "llvm/Support/Extension.def"
169 for (
auto &PluginFN : PassPlugins) {
172 errs() <<
"Failed to load passes from '" << PluginFN
173 <<
"'. Request ignored.\n";
181 static std::unique_ptr<TargetMachine>
186 for (
const std::string &A : Conf.
MAttrs)
192 else if (
M.getModuleFlag(
"PIC Level"))
205 assert(
TM &&
"Failed to create target machine");
210 unsigned OptLevel,
bool IsThinLTO,
230 TM->setPGOOption(PGOOpt);
244 std::unique_ptr<TargetLibraryInfoImpl> TLII(
247 TLII->disableAllFunctions();
300 }
else if (IsThinLTO) {
315 const std::vector<uint8_t> &CmdArgs) {
327 dbgs() <<
"Post-(Thin)LTO merge bitcode embedding was requested, but "
328 "command line arguments are not available");
349 std::vector<uint8_t>());
351 std::unique_ptr<ToolOutputFile> DwoOut;
353 if (!Conf.
DwoDir.empty()) {
357 ": " + EC.message());
361 TM->Options.MCOptions.SplitDwarfFile = std::string(DwoFile);
365 if (!DwoFile.empty()) {
376 std::unique_ptr<CachedFileStream> &Stream = *StreamOrErr;
377 TM->Options.ObjectFilenameForDebug = Stream->ObjectPathName;
386 if (
TM->addPassesToEmitFile(CodeGenPasses, *Stream->OS,
387 DwoOut ? &DwoOut->os() :
nullptr,
398 unsigned ParallelCodeGenParallelismLevel,
Module &Mod,
402 unsigned ThreadCount = 0;
406 Mod, ParallelCodeGenParallelismLevel,
407 [&](std::unique_ptr<Module> MPart) {
419 CodegenThreadPool.
async(
427 std::unique_ptr<Module> MPartInCtx =
std::move(MOrErr.
get());
429 std::unique_ptr<TargetMachine>
TM =
432 codegen(
C,
TM.get(), AddStream, ThreadId, *MPartInCtx,
444 CodegenThreadPool.
wait();
449 if (!
C.OverrideTriple.empty())
462 std::unique_ptr<ToolOutputFile> DiagOutputFile) {
467 DiagOutputFile->keep();
468 DiagOutputFile->os().flush();
473 unsigned ParallelCodeGenParallelismLevel,
Module &Mod,
481 if (!
C.CodeGenOnly) {
483 &CombinedIndex,
nullptr,
484 std::vector<uint8_t>()))
488 if (ParallelCodeGenParallelismLevel == 1) {
499 std::vector<GlobalValue*> DeadGVs;
502 if (!
Index.isGlobalValueLive(GVS)) {
503 DeadGVs.push_back(&GV);
510 GV->removeDeadConstantUsers();
514 GV->eraseFromParent();
523 const std::vector<uint8_t> &CmdArgs) {
536 return DiagFileOrErr.takeError();
537 auto DiagnosticOutputFile =
std::move(*DiagFileOrErr);
544 codegen(Conf,
TM.get(), AddStream, Task,
Mod, CombinedIndex);
551 auto OptimizeAndCodegen =
553 std::unique_ptr<ToolOutputFile> DiagnosticOutputFile) {
555 nullptr, &CombinedIndex,
564 return OptimizeAndCodegen(
Mod,
TM.get(),
std::move(DiagnosticOutputFile));
568 bool ClearDSOLocalOnDeclarations =
569 TM->getTargetTriple().isOSBinFormatELF() &&
581 if (!DefinedGlobals.
empty())
588 auto ModuleLoader = [&](
StringRef Identifier) {
590 "ODR Type uniquing should be enabled on the context");
592 auto I = ModuleMap->
find(Identifier);
603 Twine(
"Error loading imported file ") + Identifier +
" : ",
609 Twine(
"Error loading imported file ") + Identifier +
" : " +
618 (*MOrErr)->setOwnedMemoryBuffer(
std::move(*MBOrErr));
623 ClearDSOLocalOnDeclarations);
630 return OptimizeAndCodegen(
Mod,
TM.get(),
std::move(DiagnosticOutputFile));
639 if (LTOInfo && LTOInfo->IsThinLTO)
655 return make_error<StringError>(
"Could not find module summary",
667 for (
const auto &GlobalList : CombinedIndex) {
669 if (GlobalList.second.SummaryList.empty())
672 auto GUID = GlobalList.first;
673 for (
const auto &Summary : GlobalList.second.SummaryList) {
676 if (Summary->modulePath() ==
M.getModuleIdentifier())
679 ImportList[Summary->modulePath()].
insert(GUID);
iterator_range< global_value_iterator > global_values()
A manager for alias analyses.
This is an optimization pass for GlobalISel generic memory operations.
bool UseDefaultPipeline
Use the standard optimization pipeline.
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
bool initImportList(const Module &M, const ModuleSummaryIndex &CombinedIndex, FunctionImporter::ImportMapTy &ImportList)
Distributed ThinLTO: collect the referenced modules based on module summary and initialize ImportList...
static const OptimizationLevel O1
Optimize quickly without destroying debuggability.
void thinLTOInternalizeModule(Module &TheModule, const GVSummaryMapTy &DefinedGlobals)
Internalize TheModule based on the information recorded in the summaries during global summary-based ...
Error finalizeOptimizationRemarks(std::unique_ptr< ToolOutputFile > DiagOutputFile)
A ThreadPool for asynchronous parallel execution on a defined number of threads.
CodeGenOpt::Level CGOptLevel
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same< PassT, PassManager >::value > addPass(PassT &&Pass)
bool renameModuleForThinLTO(Module &M, const ModuleSummaryIndex &Index, bool ClearDSOLocalOnDeclarations, SetVector< GlobalValue * > *GlobalsToImport=nullptr)
Perform in-place global value handling on the given Module for exported local functions renamed and p...
static const OptimizationLevel O2
Optimize for fast execution as much as possible without triggering significant incremental compile ti...
std::string RemarksFormat
The format used for serializing remarks (default: YAML).
Optional< CodeModel::Model > CodeModel
Target - Wrapper for Target specific information.
static void RegisterPassPlugins(ArrayRef< std::string > PassPlugins, PassBuilder &PB)
void AddFeature(StringRef String, bool Enable=true)
Adds Features.
bool RemarksWithHotness
Whether to emit optimization remarks with hotness informations.
std::function< Expected< std::unique_ptr< CachedFileStream > >(unsigned Task)> AddStreamFn
This type defines the callback to add a file that is generated on the fly.
void registerCallbacks(PassInstrumentationCallbacks &PIC, FunctionAnalysisManager *FAM=nullptr)
static ErrorSuccess success()
Create a success value.
Triple - Helper class for working with autoconf configuration names.
FunctionAnalysisManager FAM
ThreadPoolStrategy heavyweight_hardware_concurrency(unsigned ThreadCount=0)
Returns a thread strategy for tasks requiring significant memory or other resources.
PassInstrumentationCallbacks PIC
ImmutablePass * createImmutableModuleSummaryIndexWrapperPass(const ModuleSummaryIndex *Index)
bool Freestanding
Flag to indicate that the optimizer should not assume builtins are present on the target.
Implementation of the target library information.
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
The function importer is automatically importing function from other modules based on the provided su...
Expected< std::unique_ptr< ToolOutputFile > > setupLLVMOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename, StringRef RemarksPasses, StringRef RemarksFormat, bool RemarksWithHotness, Optional< uint64_t > RemarksHotnessThreshold=0, int Count=-1)
Setup optimization remarks.
Tagged union holding either a T or a Error.
bool ShouldDiscardValueNames
ModuleHookFn PostImportModuleHook
This hook is called after importing from other modules (ThinLTO-specific).
bool CodeGenOnly
Disable entirely the optimizer, including importing for ThinLTO.
static const OptimizationLevel O0
Disable as many optimizations as possible.
static const Target * lookupTarget(const std::string &Triple, std::string &Error)
lookupTarget - Lookup a target based on a target triple.
static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM, unsigned OptLevel, bool IsThinLTO, ModuleSummaryIndex *ExportSummary, const ModuleSummaryIndex *ImportSummary)
BitcodeModule * findThinLTOModule(MutableArrayRef< BitcodeModule > BMs)
Returns the BitcodeModule that is ThinLTO.
CombinedIndexHookFn CombinedIndexHook
static Expected< const Target * > initAndLookupTarget(const Config &C, Module &Mod)
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText)
Parse a textual pass pipeline description into a ModulePassManager.
std::string SplitDwarfFile
The name for the split debug info file used for the DW_AT_[GNU_]dwo_name attribute in the skeleton CU...
Expected< bool > importFunctions(Module &M, const ImportMapTy &ImportList)
Import functions in Module M based on the supplied import list.
static Expected< PassPlugin > Load(const std::string &Filename)
Attempts to load a pass plugin from a given file.
bool RunCSIRInstr
Run PGO context sensitive IR instrumentation.
Function and variable summary information to aid decisions and implementation of importing.
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, bool IsVolatile=false)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
ModuleHookFn PostPromoteModuleHook
This hook is called after promoting any internal functions (ThinLTO-specific).
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
bool opt(const Config &Conf, TargetMachine *TM, unsigned Task, Module &Mod, bool IsThinLTO, ModuleSummaryIndex *ExportSummary, const ModuleSummaryIndex *ImportSummary, const std::vector< uint8_t > &CmdArgs)
Runs middle-end LTO optimizations on Mod.
std::string SampleProfile
Sample PGO profile path.
(vector float) vec_cmpeq(*A, *B) C
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
ModuleAnalysisManager MAM
This class provides access to building LLVM's passes.
std::function< void(legacy::PassManager &)> PreCodeGenPassesHook
For adding passes that run right before codegen.
Manages the enabling and disabling of subtarget specific features.
std::error_code getError() const
bool isODRUniquingDebugTypes() const
Whether there is a string map for uniquing debug info identifiers across the context.
std::error_code create_directories(const Twine &path, bool IgnoreExisting=true, perms Perms=owner_all|group_all)
Create all the non-existent directories in path.
std::unique_ptr< raw_ostream > ResolutionFile
If this field is set, LTO will write input file paths and symbol resolutions here in llvm-lto2 comman...
void thinLTOFinalizeInModule(Module &TheModule, const GVSummaryMapTy &DefinedGlobals, bool PropagateAttrs)
Based on the information recorded in the summaries during global summary-based analysis:
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
std::function< bool(unsigned Task, const Module &)> ModuleHookFn
The following callbacks deal with tasks, which normally represent the entire optimization and code ge...
bool DebugPassManager
Whether to emit the pass manager debuggging informations.
void getDefaultSubtargetFeatures(const Triple &Triple)
Adds the default features for the specified target triple.
void setTargetTriple(StringRef T)
Set the target triple.
ModuleHookFn PostInternalizeModuleHook
This hook is called after internalizing the module.
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
@ OF_TextWithCRLF
The file should be opened in text mode and use a carriage linefeed '\r '.
ModuleHookFn PreCodeGenModuleHook
This module hook is called before code generation.
bool convertToDeclaration(GlobalValue &GV)
Converts value GV to declaration, or replaces with a declaration if it is an alias.
PassBuilder PB(Machine, PassOpts->PTO, None, &PIC)
void registerPassBuilderCallbacks(PassBuilder &PB) const
Invoke the PassBuilder callback registration.
std::string getString() const
Returns features as a string.
Implements a dense probed hash-table based set.
std::string RemarksFilename
Optimization remarks file path.
Error backend(const Config &C, AddStreamFn AddStream, unsigned ParallelCodeGenParallelismLevel, Module &M, ModuleSummaryIndex &CombinedIndex)
Runs a regular LTO backend.
void registerFunctionAnalyses(FunctionAnalysisManager &FAM)
Registers all available function analysis passes.
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
This class provides an interface to register all the standard pass instrumentations and manages their...
iterator find(const KeyT &Key)
Expected< std::unique_ptr< Module > > parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context, DataLayoutCallbackTy DataLayoutCallback=[](StringRef) { return None;})
Read the specified bitcode file, returning the module.
std::string DwoDir
The directory to store .dwo files.
bool AddFSDiscriminator
Add FSAFDO discriminators.
void registerModuleAnalyses(ModuleAnalysisManager &MAM)
Registers all available module analysis passes.
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
ModulePassManager buildLTODefaultPipeline(OptimizationLevel Level, ModuleSummaryIndex *ExportSummary)
Build an LTO default optimization pipeline to a pass manager.
A derived class of LLVMContext that initializes itself according to a given Config object.
ModulePassManager buildThinLTODefaultPipeline(OptimizationLevel Level, const ModuleSummaryIndex *ImportSummary)
Build an ThinLTO default optimization pipeline to a pass manager.
static std::unique_ptr< TargetMachine > createTargetMachine(const Config &Conf, const Target *TheTarget, Module &M)
initializer< Ty > init(const Ty &Val)
Error addSaveTemps(std::string OutputFileName, bool UseInputModulePath=false)
This is a convenience function that configures this Config object to write temporary files named afte...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Primary interface to the complete machine description for the target machine.
std::string SplitDwarfOutput
The path to write a .dwo file to.
StandardInstrumentations SI(Debug, VerifyEach)
std::vector< std::string > MAttrs
A Module instance is used to store all the information related to an LLVM module.
std::string ProfileRemapping
Name remapping file for profile data.
void WriteBitcodeToFile(const Module &M, raw_ostream &Out, bool ShouldPreserveUseListOrder=false, const ModuleSummaryIndex *Index=nullptr, bool GenerateHash=false, ModuleHash *ModHash=nullptr)
Write the specified module to the specified raw output stream.
Optional< Reloc::Model > RelocModel
ModuleHookFn PostOptModuleHook
This module hook is called after optimization is complete.
llvm::Optional< uint64_t > RemarksHotnessThreshold
The minimum hotness value a diagnostic needs in order to be included in optimization diagnostics.
Error thinBackend(const Config &C, unsigned Task, AddStreamFn AddStream, Module &M, const ModuleSummaryIndex &CombinedIndex, const FunctionImporter::ImportMapTy &ImportList, const GVSummaryMapTy &DefinedGlobals, MapVector< StringRef, BitcodeModule > *ModuleMap, const std::vector< uint8_t > &CmdArgs=std::vector< uint8_t >())
Runs a ThinLTO backend.
StringRef - Represent a constant reference to a string, i.e.
@ EmbedPostMergePreOptimized
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
auto async(Function &&F, Args &&...ArgList)
Asynchronous submission of a task to the pool.
reference get()
Returns a reference to the stored T value.
A struct capturing PGO tunables.
static const OptimizationLevel O3
Optimize for fast execution as much as possible.
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
std::string OptPipeline
If this field is set, the set of passes run in the middle-end optimizer will be the one specified by ...
static cl::opt< bool > ThinLTOAssumeMerged("thinlto-assume-merged", cl::init(false), cl::desc("Assume the input has already undergone ThinLTO function " "importing and the other pre-optimization pipeline changes."))
cl::opt< bool > NoPGOWarnMismatch
A raw_ostream that writes to a file descriptor.
Error parseAAPipeline(AAManager &AA, StringRef PipelineText)
Parse a textual alias analysis pipeline into the provided AA manager.
const CustomOperand< const MCSubtargetInfo & > Msg[]
LLVM_NODISCARD bool empty() const
static cl::opt< LTOBitcodeEmbedding > EmbedBitcode("lto-embed-bitcode", cl::init(LTOBitcodeEmbedding::DoNotEmbed), cl::values(clEnumValN(LTOBitcodeEmbedding::DoNotEmbed, "none", "Do not embed"), clEnumValN(LTOBitcodeEmbedding::EmbedOptimized, "optimized", "Embed after all optimization passes"), clEnumValN(LTOBitcodeEmbedding::EmbedPostMergePreOptimized, "post-merge-pre-opt", "Embed post merge, but before optimizations")), cl::desc("Embed LLVM bitcode in object files produced by LTO"))
void registerLoopAnalyses(LoopAnalysisManager &LAM)
Registers all available loop analysis passes.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
void writeIndexToFile(const ModuleSummaryIndex &Index, raw_ostream &Out, const std::map< std::string, GVSummaryMapTy > *ModuleToSummariesForIndex=nullptr)
Write the specified module summary index to the given raw output stream, where it will be written in ...
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
const char * toString(DWARFSectionKind Kind)
ModulePassManager buildPerModuleDefaultPipeline(OptimizationLevel Level, bool LTOPreLink=false)
Build a per-module default optimization pipeline.
Lightweight error class with error context and mandatory checking.
PassManager manages ModulePassManagers.
LLVMContext & getContext() const
Get the global data context.
static void dropDeadSymbols(Module &Mod, const GVSummaryMapTy &DefinedGlobals, const ModuleSummaryIndex &Index)
void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM)
Registers all available CGSCC analysis passes.
ModuleHookFn PreOptModuleHook
This module hook is called after linking (regular LTO) or loading (ThinLTO) the module,...
PipelineTuningOptions PTO
Tunable parameters for passes in the default pipelines.
void add(Pass *P) override
Add a pass to the queue of passes to run.
std::string CSIRProfile
Context Sensitive PGO profile path.
static void reportOpenError(StringRef Path, Twine Msg)
void embedBitcodeInModule(Module &M, MemoryBufferRef Buf, bool EmbedBitcode, bool EmbedCmdline, const std::vector< uint8_t > &CmdArgs)
If EmbedBitcode is set, save a copy of the llvm IR as data in the __LLVM,__bitcode section (....
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
PIELevel::Level getPIELevel() const
Returns the PIE level (small or large model)
PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs)
Run all of the passes in this manager over the given unit of IR.
void setPartialSampleProfileRatio(const ModuleSummaryIndex &Index)
Set the partial sample profile ratio in the profile summary module flag, if applicable.
Error takeError()
Take ownership of the stored error.
void wait()
Blocking wait for all the threads to complete and the queue to be empty.
static void codegen(const Config &Conf, TargetMachine *TM, AddStreamFn AddStream, unsigned Task, Module &Mod, const ModuleSummaryIndex &CombinedIndex)
CodeGenFileType CGFileType
Class to hold module path string table and global value map, and encapsulate methods for operating on...
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
declare void exit(i32) noreturn nounwind This compiles into
const std::string & getTargetTriple() const
Get the target triple which is a string describing the target host.
void crossRegisterProxies(LoopAnalysisManager &LAM, FunctionAnalysisManager &FAM, CGSCCAnalysisManager &CGAM, ModuleAnalysisManager &MAM)
Cross register the analysis managers through their proxies.
Represents either an error or a value T.
std::string to_string(const T &Value)
size_t size() const
size - Get the array size.
A raw_ostream that writes to an SmallVector or SmallString.
bool run(Module &M)
run - Execute all of the passes scheduled for execution.
A container for analyses that lazily runs them and caches their results.
const char LLVMTargetMachineRef TM
std::vector< std::string > PassPlugins
Expected< std::vector< BitcodeModule > > getBitcodeModuleList(MemoryBufferRef Buffer)
Returns a list of modules in the specified bitcode buffer.
Represents a module in a bitcode file.
void SplitModule(Module &M, unsigned N, function_ref< void(std::unique_ptr< Module > MPart)> ModuleCallback, bool PreserveLocals=false)
Splits the module M into N linkable partitions.
CGSCCAnalysisManager CGAM
Analysis pass providing the TargetLibraryInfo.
void splitCodeGen(Module &M, ArrayRef< raw_pwrite_stream * > OSs, ArrayRef< llvm::raw_pwrite_stream * > BCOSs, const std::function< std::unique_ptr< TargetMachine >()> &TMFactory, CodeGenFileType FileType=CGFT_ObjectFile, bool PreserveLocals=false)
Split M into OSs.size() partitions, and generate code for each.
std::string RemarksPasses
Optimization remarks pass filter.
bool PGOWarnMismatch
Turn on/off the warning about a hash mismatch in the PGO profile data.
TargetMachine * createTargetMachine(StringRef TT, StringRef CPU, StringRef Features, const TargetOptions &Options, Optional< Reloc::Model > RM, Optional< CodeModel::Model > CM=None, CodeGenOpt::Level OL=CodeGenOpt::Default, bool JIT=false) const
createTargetMachine - Create a target specific machine implementation for the specified Triple.