TargetPassConfig.cpp File Reference (original) (raw)

Go to the source code of this file.

Namespaces
namespace	INITIALIZE_PASS
	TargetPassConfig.

namespace	llvm
	This is an optimization pass for GlobalISel generic memory operations.

Macros
#define	SET_OPTION(Option)

#define	SET_BOOLEAN_OPTION(Option) Opt.Option = Option;

#define	DISABLE_PASS(Option, Name)

Functions
static IdentifyingPassPtr	applyDisable (IdentifyingPassPtr PassID, bool Override)
	Allow standard passes to be disabled by command line options.

static IdentifyingPassPtr	overridePass (AnalysisID StandardID, IdentifyingPassPtr TargetID)
	Allow standard passes to be disabled by the command line, regardless of who is adding the pass.

static std::string	getFSProfileFile (const TargetMachine *TM)

static std::string	getFSRemappingFile (const TargetMachine *TM)

static const PassInfo *	getPassInfo (StringRef PassName)

static AnalysisID	getPassIDFromName (StringRef PassName)

static std::pair< StringRef, unsigned >	getPassNameAndInstanceNum (StringRef PassName)

static FunctionPass *	useDefaultRegisterAllocator ()
	-regalloc=... command line option.

static void	initializeDefaultRegisterAllocatorOnce ()

Variables
static cl::opt< bool >	EnableIPRA ("enable-ipra", cl::init(false), cl::Hidden, cl::desc("Enable interprocedural register allocation " "to reduce load/store at procedure calls."))

static cl::opt< bool >	DisablePostRASched ("disable-post-ra", cl::Hidden, cl::desc("Disable Post Regalloc Scheduler"))

static cl::opt< bool >	DisableBranchFold ("disable-branch-fold", cl::Hidden, cl::desc("Disable branch folding"))

static cl::opt< bool >	DisableTailDuplicate ("disable-tail-duplicate", cl::Hidden, cl::desc("Disable tail duplication"))

static cl::opt< bool >	DisableEarlyTailDup ("disable-early-taildup", cl::Hidden, cl::desc("Disable pre-register allocation tail duplication"))

static cl::opt< bool >	DisableBlockPlacement ("disable-block-placement", cl::Hidden, cl::desc("Disable probability-driven block placement"))

static cl::opt< bool >	EnableBlockPlacementStats ("enable-block-placement-stats", cl::Hidden, cl::desc("Collect probability-driven block placement stats"))

static cl::opt< bool >	DisableSSC ("disable-ssc", cl::Hidden, cl::desc("Disable Stack Slot Coloring"))

static cl::opt< bool >	DisableMachineDCE ("disable-machine-dce", cl::Hidden, cl::desc("Disable Machine Dead Code Elimination"))

static cl::opt< bool >	DisableEarlyIfConversion ("disable-early-ifcvt", cl::Hidden, cl::desc("Disable Early If-conversion"))

static cl::opt< bool >	DisableMachineLICM ("disable-machine-licm", cl::Hidden, cl::desc("Disable Machine LICM"))

static cl::opt< bool >	DisableMachineCSE ("disable-machine-cse", cl::Hidden, cl::desc("Disable Machine Common Subexpression Elimination"))

static cl::opt< cl::boolOrDefault >	OptimizeRegAlloc ("optimize-regalloc", cl::Hidden, cl::desc("Enable optimized register allocation compilation path."))

static cl::opt< bool >	DisablePostRAMachineLICM ("disable-postra-machine-licm", cl::Hidden, cl::desc("Disable Machine LICM"))

static cl::opt< bool >	DisableMachineSink ("disable-machine-sink", cl::Hidden, cl::desc("Disable Machine Sinking"))

static cl::opt< bool >	DisablePostRAMachineSink ("disable-postra-machine-sink", cl::Hidden, cl::desc("Disable PostRA Machine Sinking"))

static cl::opt< bool >	DisableLSR ("disable-lsr", cl::Hidden, cl::desc("Disable Loop Strength Reduction Pass"))

static cl::opt< bool >	DisableConstantHoisting ("disable-constant-hoisting", cl::Hidden, cl::desc("Disable ConstantHoisting"))

static cl::opt< bool >	DisableCGP ("disable-cgp", cl::Hidden, cl::desc("Disable Codegen Prepare"))

static cl::opt< bool >	DisableCopyProp ("disable-copyprop", cl::Hidden, cl::desc("Disable Copy Propagation pass"))

static cl::opt< bool >	DisablePartialLibcallInlining ("disable-partial-libcall-inlining", cl::Hidden, cl::desc("Disable Partial Libcall Inlining"))

static cl::opt< bool >	DisableAtExitBasedGlobalDtorLowering ("disable-atexit-based-global-dtor-lowering", cl::Hidden, cl::desc("For MachO, disable atexit()-based global destructor lowering"))

static cl::opt< bool >	EnableImplicitNullChecks ("enable-implicit-null-checks", cl::desc("Fold null checks into faulting memory operations"), cl::init(false), cl::Hidden)

static cl::opt< bool >	DisableMergeICmps ("disable-mergeicmps", cl::desc("Disable MergeICmps Pass"), cl::init(false), cl::Hidden)

static cl::opt< bool >	PrintISelInput ("print-isel-input", cl::Hidden, cl::desc("Print LLVM IR input to isel pass"))

static cl::opt< cl::boolOrDefault >	VerifyMachineCode ("verify-machineinstrs", cl::Hidden, cl::desc("Verify generated machine code"))

static cl::opt< cl::boolOrDefault >	DebugifyAndStripAll ("debugify-and-strip-all-safe", cl::Hidden, cl::desc("Debugify MIR before and Strip debug after " "each pass except those known to be unsafe " "when debug info is present"))

static cl::opt< cl::boolOrDefault >	DebugifyCheckAndStripAll ("debugify-check-and-strip-all-safe", cl::Hidden, cl::desc("Debugify MIR before, by checking and stripping the debug info after, " "each pass except those known to be unsafe when debug info is " "present"))

static cl::opt< RunOutliner >	EnableMachineOutliner ("enable-machine-outliner", cl::desc("Enable the machine outliner"), cl::Hidden, cl::ValueOptional, cl::init(RunOutliner::TargetDefault), cl::values(clEnumValN(RunOutliner::AlwaysOutline, "always", "Run on all functions guaranteed to be beneficial"), clEnumValN(RunOutliner::NeverOutline, "never", "Disable all outlining"), clEnumValN(RunOutliner::AlwaysOutline, "", "")))

static cl::opt< bool >	EnableGlobalMergeFunc ("enable-global-merge-func", cl::Hidden, cl::desc("Enable global merge functions that are based on hash function"))

static cl::opt< bool >	DisableCFIFixup ("disable-cfi-fixup", cl::Hidden, cl::desc("Disable the CFI fixup pass"))

static cl::opt< cl::boolOrDefault >	EnableFastISelOption ("fast-isel", cl::Hidden, cl::desc("Enable the \"fast\" instruction selector"))

static cl::opt< cl::boolOrDefault >	EnableGlobalISelOption ("global-isel", cl::Hidden, cl::desc("Enable the \"global\" instruction selector"))

static cl::opt< bool >	PrintAfterISel ("print-after-isel", cl::init(false), cl::Hidden, cl::desc("Print machine instrs after ISel"))

static cl::opt< GlobalISelAbortMode >	EnableGlobalISelAbort ("global-isel-abort", cl::Hidden, cl::desc("Enable abort calls when \"global\" instruction selection " "fails to lower/select an instruction"), cl::values(clEnumValN(GlobalISelAbortMode::Disable, "0", "Disable the abort"), clEnumValN(GlobalISelAbortMode::Enable, "1", "Enable the abort"), clEnumValN(GlobalISelAbortMode::DisableWithDiag, "2", "Disable the abort but emit a diagnostic on failure")))

static cl::opt< bool >	DisableRAFSProfileLoader ("disable-ra-fsprofile-loader", cl::init(false), cl::Hidden, cl::desc("Disable MIRProfileLoader before RegAlloc"))

static cl::opt< bool >	DisableLayoutFSProfileLoader ("disable-layout-fsprofile-loader", cl::init(false), cl::Hidden, cl::desc("Disable MIRProfileLoader before BlockPlacement"))

static cl::opt< std::string >	FSProfileFile ("fs-profile-file", cl::init(""), cl::value_desc("filename"), cl::desc("Flow Sensitive profile file name."), cl::Hidden)

static cl::opt< std::string >	FSRemappingFile ("fs-remapping-file", cl::init(""), cl::value_desc("filename"), cl::desc("Flow Sensitive profile remapping file name."), cl::Hidden)

static cl::opt< bool >	MISchedPostRA ("misched-postra", cl::Hidden, cl::desc("Run MachineScheduler post regalloc (independent of preRA sched)"))

static cl::opt< bool >	EarlyLiveIntervals ("early-live-intervals", cl::Hidden, cl::desc("Run live interval analysis earlier in the pipeline"))

static cl::opt< bool >	DisableReplaceWithVecLib ("disable-replace-with-vec-lib", cl::Hidden, cl::desc("Disable replace with vector math call pass"))

static const char	StartAfterOptName [] = "start-after"
	Option names for limiting the codegen pipeline.

static const char	StartBeforeOptName [] = "start-before"

static const char	StopAfterOptName [] = "stop-after"

static const char	StopBeforeOptName [] = "stop-before"

static cl::opt< std::string >	StartAfterOpt (StringRef(StartAfterOptName), cl::desc("Resume compilation after a specific pass"), cl::value_desc("pass-name"), cl::init(""), cl::Hidden)

static cl::opt< std::string >	StartBeforeOpt (StringRef(StartBeforeOptName), cl::desc("Resume compilation before a specific pass"), cl::value_desc("pass-name"), cl::init(""), cl::Hidden)

static cl::opt< std::string >	StopAfterOpt (StringRef(StopAfterOptName), cl::desc("Stop compilation after a specific pass"), cl::value_desc("pass-name"), cl::init(""), cl::Hidden)

static cl::opt< std::string >	StopBeforeOpt (StringRef(StopBeforeOptName), cl::desc("Stop compilation before a specific pass"), cl::value_desc("pass-name"), cl::init(""), cl::Hidden)

static cl::opt< bool >	EnableMachineFunctionSplitter ("enable-split-machine-functions", cl::Hidden, cl::desc("Split out cold blocks from machine functions based on profile " "information."))
	Enable the machine function splitter pass.

static cl::opt< bool >	DisableExpandReductions ("disable-expand-reductions", cl::init(false), cl::Hidden, cl::desc("Disable the expand reduction intrinsics pass from running"))
	Disable the expand reductions pass for testing.

static cl::opt< bool >	DisableSelectOptimize ("disable-select-optimize", cl::init(true), cl::Hidden, cl::desc("Disable the select-optimization pass from running"))
	Disable the select optimization pass.

static cl::opt< bool >	GCEmptyBlocks ("gc-empty-basic-blocks", cl::init(false), cl::Hidden, cl::desc("Enable garbage-collecting empty basic blocks"))
	Enable garbage-collecting empty basic blocks.

static cl::opt< RegisterRegAlloc::FunctionPassCtor, false, RegisterPassParser< RegisterRegAlloc > >	RegAlloc ("regalloc", cl::Hidden, cl::init(&useDefaultRegisterAllocator), cl::desc("Register allocator to use"))

static llvm::once_flag	InitializeDefaultRegisterAllocatorFlag
	A dummy default pass factory indicates whether the register allocator is overridden on the command line.

static RegisterRegAlloc	defaultRegAlloc ("default", "pick register allocator based on -O option", useDefaultRegisterAllocator)

◆ DISABLE_PASS

| #define DISABLE_PASS | ( | | Option, | | ---------------------------------------------------------------------- | - | | ------- | | | Name | | | | | ) | | | |

Value:

if (Option && P.contains(#Name)) \

return false;

◆ SET_BOOLEAN_OPTION

| #define SET_BOOLEAN_OPTION | ( | | Option | ) | Opt.Option = Option; | | ---------------------------- | - | | ------ | - | -------------------- |

◆ SET_OPTION

| #define SET_OPTION | ( | | Option | ) | | ------------------- | - | | ------ | - |

Value:

if (Option.getNumOccurrences()) \

Opt.Option = Option;

◆ applyDisable()

Allow standard passes to be disabled by command line options.

This supports simple binary flags that either suppress the pass or do nothing. i.e. -disable-mypass=false has no effect. These should be converted to boolOrDefault in order to use applyOverride.

Definition at line 268 of file TargetPassConfig.cpp.

Referenced by overridePass().

◆ getFSProfileFile()

◆ getFSRemappingFile()

◆ getPassIDFromName()

◆ getPassInfo()

◆ getPassNameAndInstanceNum()

◆ initializeDefaultRegisterAllocatorOnce()

static void initializeDefaultRegisterAllocatorOnce ( )	static

◆ overridePass()

Allow standard passes to be disabled by the command line, regardless of who is adding the pass.

StandardID is the pass identified in the standard pass pipeline and provided to addPass(). It may be a target-specific ID in the case that the target directly adds its own pass, but in that case we harmlessly fall through.

TargetID is the pass that the target has configured to override StandardID.

StandardID may be a pseudo ID. In that case TargetID is the name of the real pass to run. This allows multiple options to control a single pass depending on where in the pipeline that pass is added.

Definition at line 287 of file TargetPassConfig.cpp.

References applyDisable(), llvm::BranchFolderPassID, llvm::DeadMachineInstructionElimID, DisableBlockPlacement, DisableBranchFold, DisableCopyProp, DisableEarlyIfConversion, DisableEarlyTailDup, DisableMachineCSE, DisableMachineDCE, DisableMachineLICM, DisableMachineSink, DisablePostRAMachineLICM, DisablePostRAMachineSink, DisablePostRASched, DisableSSC, DisableTailDuplicate, llvm::EarlyIfConverterLegacyID, llvm::EarlyMachineLICMID, llvm::EarlyTailDuplicateLegacyID, llvm::MachineBlockPlacementID, llvm::MachineCopyPropagationID, llvm::MachineCSELegacyID, llvm::MachineLICMID, llvm::MachineSinkingID, llvm::PostRAMachineSinkingID, llvm::PostRASchedulerID, llvm::StackSlotColoringID, and llvm::TailDuplicateLegacyID.

Referenced by llvm::TargetPassConfig::addPass(), and llvm::TargetPassConfig::isPassSubstitutedOrOverridden().

◆ useDefaultRegisterAllocator()

static FunctionPass * useDefaultRegisterAllocator ( )	static

◆ DebugifyAndStripAll

cl::opt< cl::boolOrDefault > DebugifyAndStripAll("debugify-and-strip-all-safe", cl::Hidden, cl::desc("Debugify MIR before and Strip debug after " "each pass except those known to be unsafe " "when debug info is present")) ( "debugify-and-strip-all-safe" , cl::Hidden , cl::desc("Debugify MIR before and Strip debug after " "each pass except those known to be unsafe " "when debug info is present") )	static

◆ DebugifyCheckAndStripAll

cl::opt< cl::boolOrDefault > DebugifyCheckAndStripAll("debugify-check-and-strip-all-safe", cl::Hidden, cl::desc( "Debugify MIR before, by checking and stripping the debug info after, " "each pass except those known to be unsafe when debug info is " "present")) ( "debugify-check-and-strip-all-safe" , cl::Hidden , cl::desc( "Debugify MIR before, by checking and stripping the debug info after, " "each pass except those known to be unsafe when debug info is " "present") )

static

◆ defaultRegAlloc

◆ DisableAtExitBasedGlobalDtorLowering

cl::opt< bool > DisableAtExitBasedGlobalDtorLowering("disable-atexit-based-global-dtor-lowering", cl::Hidden, cl::desc("For MachO, disable atexit()-based global destructor lowering")) ( "disable-atexit-based-global-dtor-lowering" , cl::Hidden , cl::desc("For MachO, disable atexit()-based global destructor lowering") )	static

◆ DisableBlockPlacement

cl::opt< bool > DisableBlockPlacement("disable-block-placement", cl::Hidden, cl::desc("Disable probability-driven block placement")) ( "disable-block-placement" , cl::Hidden , cl::desc("Disable probability-driven block placement") )	static

◆ DisableBranchFold

cl::opt< bool > DisableBranchFold("disable-branch-fold", cl::Hidden, cl::desc("Disable branch folding")) ( "disable-branch-fold" , cl::Hidden , cl::desc("Disable branch folding") )	static

◆ DisableCFIFixup

cl::opt< bool > DisableCFIFixup("disable-cfi-fixup", cl::Hidden, cl::desc("Disable the CFI fixup pass")) ( "disable-cfi-fixup" , cl::Hidden , cl::desc("Disable the CFI fixup pass") )	static

◆ DisableCGP

cl::opt< bool > DisableCGP("disable-cgp", cl::Hidden, cl::desc("Disable Codegen Prepare")) ( "disable-cgp" , cl::Hidden , cl::desc("Disable Codegen Prepare") )	static

◆ DisableConstantHoisting

cl::opt< bool > DisableConstantHoisting("disable-constant-hoisting", cl::Hidden, cl::desc("Disable ConstantHoisting")) ( "disable-constant-hoisting" , cl::Hidden , cl::desc("Disable ConstantHoisting") )	static

◆ DisableCopyProp

cl::opt< bool > DisableCopyProp("disable-copyprop", cl::Hidden, cl::desc("Disable Copy Propagation pass")) ( "disable-copyprop" , cl::Hidden , cl::desc("Disable Copy Propagation pass") )	static

◆ DisableEarlyIfConversion

cl::opt< bool > DisableEarlyIfConversion("disable-early-ifcvt", cl::Hidden, cl::desc("Disable Early If-conversion")) ( "disable-early-ifcvt" , cl::Hidden , cl::desc("Disable Early If-conversion") )	static

◆ DisableEarlyTailDup

cl::opt< bool > DisableEarlyTailDup("disable-early-taildup", cl::Hidden, cl::desc("Disable pre-register allocation tail duplication")) ( "disable-early-taildup" , cl::Hidden , cl::desc("Disable pre-register allocation tail duplication") )	static

◆ DisableExpandReductions

◆ DisableLayoutFSProfileLoader

◆ DisableLSR

cl::opt< bool > DisableLSR("disable-lsr", cl::Hidden, cl::desc("Disable Loop Strength Reduction Pass")) ( "disable-lsr" , cl::Hidden , cl::desc("Disable Loop Strength Reduction Pass") )	static

◆ DisableMachineCSE

cl::opt< bool > DisableMachineCSE("disable-machine-cse", cl::Hidden, cl::desc("Disable Machine Common Subexpression Elimination")) ( "disable-machine-cse" , cl::Hidden , cl::desc("Disable Machine Common Subexpression Elimination") )	static

◆ DisableMachineDCE

cl::opt< bool > DisableMachineDCE("disable-machine-dce", cl::Hidden, cl::desc("Disable Machine Dead Code Elimination")) ( "disable-machine-dce" , cl::Hidden , cl::desc("Disable Machine Dead Code Elimination") )	static

◆ DisableMachineLICM

◆ DisableMachineSink

◆ DisableMergeICmps

cl::opt< bool > DisableMergeICmps("disable-mergeicmps", cl::desc("Disable MergeICmps Pass"), cl::init(false), cl::Hidden) ( "disable-mergeicmps" , cl::desc("Disable MergeICmps Pass") , cl::init(false) , cl::Hidden )	static

◆ DisablePartialLibcallInlining

cl::opt< bool > DisablePartialLibcallInlining("disable-partial-libcall-inlining", cl::Hidden, cl::desc("Disable Partial Libcall Inlining")) ( "disable-partial-libcall-inlining" , cl::Hidden , cl::desc("Disable Partial Libcall Inlining") )	static

◆ DisablePostRAMachineLICM

cl::opt< bool > DisablePostRAMachineLICM("disable-postra-machine-licm", cl::Hidden, cl::desc("Disable Machine LICM")) ( "disable-postra-machine-licm" , cl::Hidden , cl::desc("Disable Machine LICM") )	static

◆ DisablePostRAMachineSink

cl::opt< bool > DisablePostRAMachineSink("disable-postra-machine-sink", cl::Hidden, cl::desc("Disable PostRA Machine Sinking")) ( "disable-postra-machine-sink" , cl::Hidden , cl::desc("Disable PostRA Machine Sinking") )	static

◆ DisablePostRASched

cl::opt< bool > DisablePostRASched("disable-post-ra", cl::Hidden, cl::desc("Disable Post Regalloc Scheduler")) ( "disable-post-ra" , cl::Hidden , cl::desc("Disable Post Regalloc Scheduler") )	static

◆ DisableRAFSProfileLoader

◆ DisableReplaceWithVecLib

◆ DisableSelectOptimize

◆ DisableSSC

cl::opt< bool > DisableSSC("disable-ssc", cl::Hidden, cl::desc("Disable Stack Slot Coloring")) ( "disable-ssc" , cl::Hidden , cl::desc("Disable Stack Slot Coloring") )	static

◆ DisableTailDuplicate

cl::opt< bool > DisableTailDuplicate("disable-tail-duplicate", cl::Hidden, cl::desc("Disable tail duplication")) ( "disable-tail-duplicate" , cl::Hidden , cl::desc("Disable tail duplication") )	static

◆ EarlyLiveIntervals

◆ EnableBlockPlacementStats

cl::opt< bool > EnableBlockPlacementStats("enable-block-placement-stats", cl::Hidden, cl::desc("Collect probability-driven block placement stats")) ( "enable-block-placement-stats" , cl::Hidden , cl::desc("Collect probability-driven block placement stats") )	static

◆ EnableFastISelOption

cl::opt< cl::boolOrDefault > EnableFastISelOption("fast-isel", cl::Hidden, cl::desc("Enable the \"fast\" instruction selector")) ( "fast-isel" , cl::Hidden , cl::desc("Enable the \"fast\" instruction selector") )	static

◆ EnableGlobalISelAbort

cl::opt< GlobalISelAbortMode > EnableGlobalISelAbort("global-isel-abort", cl::Hidden, cl::desc("Enable abort calls when \"global\" instruction selection " "fails to lower/select an instruction"), cl::values( clEnumValN(GlobalISelAbortMode::Disable, "0", "Disable the abort"), clEnumValN(GlobalISelAbortMode::Enable, "1", "Enable the abort"), clEnumValN(GlobalISelAbortMode::DisableWithDiag, "2", "Disable the abort but emit a diagnostic on failure"))) ( "global-isel-abort" , cl::Hidden , cl::desc("Enable abort calls when \"global\" instruction selection " "fails to lower/select an instruction") , cl::values( clEnumValN(GlobalISelAbortMode::Disable, "0", "Disable the abort"), clEnumValN(GlobalISelAbortMode::Enable, "1", "Enable the abort"), clEnumValN(GlobalISelAbortMode::DisableWithDiag, "2", "Disable the abort but emit a diagnostic on failure")) )

static

◆ EnableGlobalISelOption

cl::opt< cl::boolOrDefault > EnableGlobalISelOption("global-isel", cl::Hidden, cl::desc("Enable the \"global\" instruction selector")) ( "global-isel" , cl::Hidden , cl::desc("Enable the \"global\" instruction selector") )	static

◆ EnableGlobalMergeFunc

◆ EnableImplicitNullChecks

cl::opt< bool > EnableImplicitNullChecks("enable-implicit-null-checks", cl::desc("Fold null checks into faulting memory operations"), cl::init(false), cl::Hidden) ( "enable-implicit-null-checks" , cl::desc("Fold null checks into faulting memory operations") , cl::init(false) , cl::Hidden )	static

◆ EnableIPRA

◆ EnableMachineFunctionSplitter

cl::opt< bool > EnableMachineFunctionSplitter("enable-split-machine-functions", cl::Hidden, cl::desc("Split out cold blocks from machine functions based on profile " "information.")) ( "enable-split-machine-functions" , cl::Hidden , cl::desc("Split out cold blocks from machine functions based on profile " "information.") )	static

◆ EnableMachineOutliner

cl::opt< RunOutliner > EnableMachineOutliner("enable-machine-outliner", cl::desc("Enable the machine outliner"), cl::Hidden, cl::ValueOptional, cl::init(RunOutliner::TargetDefault), cl::values(clEnumValN(RunOutliner::AlwaysOutline, "always", "Run on all functions guaranteed to be beneficial"), clEnumValN(RunOutliner::NeverOutline, "never", "Disable all outlining"), clEnumValN(RunOutliner::AlwaysOutline, "", ""))) ( "enable-machine-outliner" , cl::desc("Enable the machine outliner") , cl::Hidden , cl::ValueOptional , cl::init(RunOutliner::TargetDefault) , cl::values(clEnumValN(RunOutliner::AlwaysOutline, "always", "Run on all functions guaranteed to be beneficial"), clEnumValN(RunOutliner::NeverOutline, "never", "Disable all outlining"), clEnumValN(RunOutliner::AlwaysOutline, "", "")) )

static

◆ FSProfileFile

◆ FSRemappingFile

cl::opt< std::string > FSRemappingFile("fs-remapping-file", cl::init(""), cl::value_desc("filename"), cl::desc("Flow Sensitive profile remapping file name."), cl::Hidden) ( "fs-remapping-file" , cl::init("") , cl::value_desc("filename") , cl::desc("Flow Sensitive profile remapping file name.") , cl::Hidden )	static

◆ GCEmptyBlocks

cl::opt< bool > GCEmptyBlocks("gc-empty-basic-blocks", cl::init(false), cl::Hidden, cl::desc("Enable garbage-collecting empty basic blocks")) ( "gc-empty-basic-blocks" , cl::init(false) , cl::Hidden , cl::desc("Enable garbage-collecting empty basic blocks") )	static

◆ InitializeDefaultRegisterAllocatorFlag

◆ MISchedPostRA

cl::opt< bool > MISchedPostRA("misched-postra", cl::Hidden, cl::desc( "Run MachineScheduler post regalloc (independent of preRA sched)")) ( "misched-postra" , cl::Hidden , cl::desc( "Run MachineScheduler post regalloc (independent of preRA sched)") )	static

◆ OptimizeRegAlloc

◆ PrintAfterISel

cl::opt< bool > PrintAfterISel("print-after-isel", cl::init(false), cl::Hidden, cl::desc("Print machine instrs after ISel")) ( "print-after-isel" , cl::init(false) , cl::Hidden , cl::desc("Print machine instrs after ISel") )	static

◆ PrintISelInput

◆ RegAlloc

◆ StartAfterOpt

◆ StartAfterOptName

const char StartAfterOptName[] = "start-after"	static

◆ StartBeforeOpt

◆ StartBeforeOptName

const char StartBeforeOptName[] = "start-before"	static

◆ StopAfterOpt

◆ StopAfterOptName

◆ StopBeforeOpt

◆ StopBeforeOptName

const char StopBeforeOptName[] = "stop-before"	static

◆ VerifyMachineCode

cl::opt< cl::boolOrDefault > VerifyMachineCode("verify-machineinstrs", cl::Hidden, cl::desc("Verify generated machine code")) ( "verify-machineinstrs" , cl::Hidden , cl::desc("Verify generated machine code") )	static