| //===- subzero/src/IceClFlags.def - Cl Flags for translation ----*- C++ -*-===// |
| // |
| // The Subzero Code Generator |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| /// |
| /// \file |
| /// \brief Declares the command line flags used by Subzero. |
| /// |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef SUBZERO_SRC_ICECLFLAGS_DEF |
| #define SUBZERO_SRC_ICECLFLAGS_DEF |
| |
| namespace Ice { |
| // cl_detail defines tags (i.e., structs) for specifying the type of a flag |
| // (either single-, or multi-value), and whether or not the flag is available in |
| // non-LLVM_CL build. |
| namespace cl_detail { |
| |
| // Single-value flag, available in a non-LLVM_CL build. |
| struct release_opt_flag {}; |
| // Single-value flag, not available in a non-LLVM_CL build. |
| struct dev_opt_flag {}; |
| // Multi-value flag, not available in a non-LLVM_CL build. |
| struct dev_list_flag {}; |
| |
| } // end of namespace detail |
| |
| #define COMMAND_LINE_FLAGS \ |
| /* Name, Type, ClType, <<flag declaration ctor arguments>> */ \ |
| X(IRFilename, std::string, release_opt_flag, cl::Positional, \ |
| cl::desc("IR File"), cl::init("-")) \ |
| \ |
| X(NumTranslationThreads, uint32_t, release_opt_flag, "threads", \ |
| cl::desc("Number of translation threads (0 for purely sequential)"), \ |
| cl::init(2)) \ |
| \ |
| X(OptLevel, Ice::OptLevel, release_opt_flag, cl::desc("Optimization level"), \ |
| cl::init(Ice::Opt_m1), cl::value_desc("level"), \ |
| cl::values(clEnumValN(Ice::Opt_m1, "Om1", "-1"), \ |
| clEnumValN(Ice::Opt_m1, "O-1", "-1"), \ |
| clEnumValN(Ice::Opt_0, "O0", "0"), \ |
| clEnumValN(Ice::Opt_1, "O1", "1"), \ |
| clEnumValN(Ice::Opt_2, "O2", "2") CLENUMVALEND)) \ |
| \ |
| X(OutputFilename, std::string, release_opt_flag, "o", \ |
| cl::desc("Override output filename"), cl::init("-"), \ |
| cl::value_desc("filename")) \ |
| \ |
| X(TargetArch, Ice::TargetArch, release_opt_flag, "target", \ |
| cl::desc("Target architecture:"), cl::init(Ice::Target_X8632), \ |
| cl::values( \ |
| clEnumValN(Ice::Target_X8632, "x8632", "x86-32"), \ |
| clEnumValN(Ice::Target_X8632, "x86-32", "x86-32 (same as x8632)"), \ |
| clEnumValN(Ice::Target_X8632, "x86_32", "x86-32 (same as x8632)"), \ |
| clEnumValN(Ice::Target_X8664, "x8664", "x86-64"), \ |
| clEnumValN(Ice::Target_X8664, "x86-64", "x86-64 (same as x8664)"), \ |
| clEnumValN(Ice::Target_X8664, "x86_64", "x86-64 (same as x8664)"), \ |
| clEnumValN(Ice::Target_ARM32, "arm", "arm32"), \ |
| clEnumValN(Ice::Target_ARM32, "arm32", "arm32 (same as arm)"), \ |
| clEnumValN(Ice::Target_ARM64, "arm64", "arm64"), \ |
| clEnumValN(Ice::Target_MIPS32, "mips", "mips32"), \ |
| clEnumValN(Ice::Target_MIPS32, "mips32", "mips32 (same as mips)") \ |
| CLENUMVALEND)) \ |
| \ |
| /* The following are development flags, and ideally should not appear in a \ |
| * release build. */ \ |
| \ |
| X(AllowErrorRecovery, bool, dev_opt_flag, \ |
| "allow-pnacl-reader-error-recovery", \ |
| cl::desc("Allow error recovery when reading PNaCl bitcode."), \ |
| cl::init(false)) \ |
| \ |
| X(AllowExternDefinedSymbols, bool, dev_opt_flag, \ |
| "allow-externally-defined-symbols", \ |
| cl::desc( \ |
| "Allow global symbols to be externally defined (other than _start " \ |
| "and __pnacl_pso_root)."), \ |
| cl::init(false)) \ |
| \ |
| X(AllowIacaMarks, bool, dev_opt_flag, "allow-iaca-marks", \ |
| cl::desc("Allow IACA (Intel Architecture Code Analyzer) marks to be " \ |
| "inserted. These binaries are not executable."), \ |
| cl::init(false)) \ |
| \ |
| X(AllowUninitializedGlobals, bool, dev_opt_flag, \ |
| "allow-uninitialized-globals", \ |
| cl::desc("Allow global variables to be uninitialized")) \ |
| \ |
| X(AlwaysExitSuccess, bool, dev_opt_flag, "exit-success", \ |
| cl::desc("Exit with success status, even if errors found"), \ |
| cl::init(false)) \ |
| \ |
| X(AggressiveLea, bool, dev_opt_flag, "aggressive-lea", \ |
| cl::desc("Convert additions to lea when it reduces code size"), \ |
| cl::init(false)) \ |
| \ |
| X(BitcodeAsText, bool, dev_opt_flag, "bitcode-as-text", \ |
| cl::desc("Accept textual form of PNaCl bitcode " \ |
| "records (i.e. not .ll assembly)"), \ |
| cl::init(false)) \ |
| \ |
| X(BuildOnRead, bool, dev_opt_flag, "build-on-read", \ |
| cl::desc("Build ICE instructions when reading bitcode"), cl::init(true)) \ |
| \ |
| X(DataSections, bool, dev_opt_flag, "fdata-sections", \ |
| cl::desc("Emit (global) data into separate sections")) \ |
| \ |
| X(DecorateAsm, bool, dev_opt_flag, "asm-verbose", \ |
| cl::desc("Decorate textual asm output with register liveness info")) \ |
| \ |
| X(DefaultFunctionPrefix, std::string, dev_opt_flag, \ |
| "default-function-prefix", \ |
| cl::desc("Define default function prefix for naming unnamed functions"), \ |
| cl::init("Function")) \ |
| \ |
| X(DefaultGlobalPrefix, std::string, dev_opt_flag, "default-global-prefix", \ |
| cl::desc("Define default global prefix for naming unnamed globals"), \ |
| cl::init("Global")) \ |
| \ |
| X(DisableHybridAssembly, bool, dev_opt_flag, "no-hybrid-asm", \ |
| cl::desc("Disable hybrid assembly when -filetype=iasm"), cl::init(false)) \ |
| \ |
| X(DisableInternal, bool, dev_opt_flag, "externalize", \ |
| cl::desc("Externalize all symbols")) \ |
| \ |
| X(DisableTranslation, bool, dev_opt_flag, "notranslate", \ |
| cl::desc("Disable Subzero translation")) \ |
| \ |
| X(DumpStats, bool, dev_opt_flag, "szstats", \ |
| cl::desc("Print statistics after translating each function")) \ |
| \ |
| X(DumpStrings, bool, dev_opt_flag, \ |
| "dump-strings", \ |
| cl::desc("Dump string pools during compilation"), \ |
| cl::init(false)) \ |
| \ |
| X(EnableBlockProfile, bool, dev_opt_flag, "enable-block-profile", \ |
| cl::desc("Instrument basic blocks, and output profiling " \ |
| "information to stdout at the end of program execution."), \ |
| cl::init(false)) \ |
| \ |
| X(LocalCSE, Ice::LCSEOptions, dev_opt_flag, "lcse", \ |
| cl::desc("Local common subexpression elimination"), \ |
| cl::init(Ice::LCSE_EnabledSSA), \ |
| cl::values( \ |
| clEnumValN(Ice::LCSE_Disabled, "0", "disabled"), \ |
| clEnumValN(Ice::LCSE_EnabledSSA, "enabled", "assume-ssa"), \ |
| clEnumValN(Ice::LCSE_EnabledNoSSA, "no-ssa", "no-assume-ssa") \ |
| CLENUMVALEND)) \ |
| \ |
| X(EmitRevision, bool, dev_opt_flag, "emit-revision", \ |
| cl::desc("Emit Subzero revision string into the output"), cl::init(true)) \ |
| \ |
| X(EnablePhiEdgeSplit, bool, dev_opt_flag, "phi-edge-split", \ |
| cl::desc("Enable edge splitting for Phi lowering"), cl::init(true)) \ |
| \ |
| X(EnableShortCircuit, bool, dev_opt_flag, "enable-sc", \ |
| cl::desc("Split Nodes for short circuit evaluation"), cl::init(false)) \ |
| \ |
| X(ExcludedRegisters, std::string, dev_list_flag, "reg-exclude", \ |
| cl::CommaSeparated, cl::desc("Don't use specified registers")) \ |
| \ |
| X(ForceMemIntrinOpt, bool, dev_opt_flag, "fmem-intrin-opt", \ |
| cl::desc("Force optimization of memory intrinsics.")) \ |
| \ |
| X(ForceO2String, std::string, dev_opt_flag, "force-O2", \ |
| cl::desc("Force -O2 for certain functions (assumes -Om1)"), cl::init("")) \ |
| \ |
| X(SplitInstString, std::string, dev_opt_flag, "split-inst", \ |
| cl::desc("Restrict local var splitting to specific insts"), cl::init(":")) \ |
| \ |
| X(FunctionSections, bool, dev_opt_flag, "ffunction-sections", \ |
| cl::desc("Emit functions into separate sections")) \ |
| \ |
| X(GenerateBuildAtts, bool, release_opt_flag, "build-atts", \ |
| cl::desc("Generate list of build attributes associated with " \ |
| "this executable."), \ |
| cl::init(false)) \ |
| \ |
| X(SplitGlobalVars, bool, dev_opt_flag, "split-global-vars", \ |
| cl::desc("Global live range splitting"), \ |
| cl::init(false)) \ |
| \ |
| X(InputFileFormat, llvm::NaClFileFormat, dev_opt_flag, "bitcode-format", \ |
| cl::desc("Define format of input file:"), \ |
| cl::values(clEnumValN(llvm::LLVMFormat, "llvm", "LLVM file (default)"), \ |
| clEnumValN(llvm::PNaClFormat, "pnacl", "PNaCl bitcode file") \ |
| CLENUMVALEND), \ |
| cl::init(llvm::LLVMFormat)) \ |
| \ |
| X(KeepDeletedInsts, bool, dev_opt_flag, "keep-deleted-insts", \ |
| cl::desc("Retain deleted instructions in the Cfg"), \ |
| cl::init(Ice::BuildDefs::dump())) \ |
| \ |
| X(LLVMVerboseErrors, bool, dev_opt_flag, "verbose-llvm-parse-errors", \ |
| cl::desc("Print out more descriptive PNaCl bitcode parse errors when " \ |
| "building LLVM IR first"), \ |
| cl::init(false)) \ |
| \ |
| X(LocalCseMaxIterations, uint32_t, dev_opt_flag, "lcse-max-iters", \ |
| cl::desc("Number of times local-cse is run on a block"), cl::init(1)) \ |
| \ |
| X(LoopInvariantCodeMotion, bool, dev_opt_flag, "licm", \ |
| cl::desc("Hoist loop invariant arithmetic operations"), cl::init(false)) \ |
| \ |
| X(LogFilename, std::string, dev_opt_flag, "log", \ |
| cl::desc("Set log filename"), cl::init("-"), cl::value_desc("filename")) \ |
| \ |
| X(MaxNopsPerInstruction, int, dev_opt_flag, "max-nops-per-instruction", \ |
| cl::desc("Max number of nops to insert per instruction"), cl::init(1)) \ |
| \ |
| X(MockBoundsCheck, bool, dev_opt_flag, "mock-bounds-check", \ |
| cl::desc("Mock bounds checking on loads/stores")) \ |
| \ |
| X(NopProbabilityAsPercentage, int, dev_opt_flag, "nop-insertion-percentage", \ |
| cl::desc("Nop insertion probability as percentage"), cl::init(10)) \ |
| \ |
| X(OutFileType, Ice::FileType, dev_opt_flag, "filetype", \ |
| cl::desc("Output file type"), cl::init(Ice::FT_Iasm), \ |
| cl::values( \ |
| clEnumValN(Ice::FT_Elf, "obj", "Native ELF object ('.o') file"), \ |
| clEnumValN(Ice::FT_Asm, "asm", "Assembly ('.s') file"), \ |
| clEnumValN(Ice::FT_Iasm, "iasm", \ |
| "Low-level integrated assembly ('.s') file") \ |
| CLENUMVALEND)) \ |
| \ |
| X(ApplicationBinaryInterface, Ice::ABI, dev_opt_flag, "abi", \ |
| cl::desc("ABI type"), cl::init(Ice::ABI_PNaCl), \ |
| cl::values( \ |
| clEnumValN(Ice::ABI_PNaCl, "pnacl", "x32 for unsandboxed 64-bit x86"), \ |
| clEnumValN(Ice::ABI_Platform, "platform", "Native executable ABI") \ |
| CLENUMVALEND)) \ |
| \ |
| X(ParseParallel, bool, dev_opt_flag, "parse-parallel", \ |
| cl::desc("Parse function blocks in parallel"), cl::init(true)) \ |
| \ |
| X(RandomizeAndPoolImmediatesOption, Ice::RandomizeAndPoolImmediatesEnum, \ |
| dev_opt_flag, "randomize-pool-immediates", \ |
| cl::desc("Randomize or pooling the representation of immediates"), \ |
| cl::init(Ice::RPI_None), \ |
| cl::values(clEnumValN(Ice::RPI_None, "none", \ |
| "Do not randomize or pooling immediates (default)"), \ |
| clEnumValN(Ice::RPI_Randomize, "randomize", \ |
| "Turn on immediate constants blinding"), \ |
| clEnumValN(Ice::RPI_Pool, "pool", \ |
| "Turn on immediate constants pooling") \ |
| CLENUMVALEND)) \ |
| \ |
| X(RandomizeAndPoolImmediatesThreshold, uint32_t, dev_opt_flag, \ |
| "randomize-pool-threshold", \ |
| cl::desc("The threshold for immediates randomization and pooling"), \ |
| cl::init(0xffff)) \ |
| \ |
| X(RandomizeRegisterAllocation, bool, dev_opt_flag, "randomize-regalloc", \ |
| cl::desc("Randomize register allocation"), cl::init(false)) \ |
| \ |
| X(SplitLocalVars, bool, dev_opt_flag, "split-local-vars", cl::init(true), \ |
| cl::desc("Block-local variable splitting (O2 only)")) \ |
| \ |
| X(RandomSeed, unsigned long long, dev_opt_flag, "sz-seed", \ |
| cl::desc("Seed the random number generator"), cl::init(1)) \ |
| \ |
| X(RegAllocReserve, bool, dev_opt_flag, "reg-reserve", \ |
| cl::desc("Let register allocation use reserve registers"), \ |
| cl::init(false)) \ |
| \ |
| X(ReorderBasicBlocks, bool, dev_opt_flag, "reorder-basic-blocks", \ |
| cl::desc("Shuffle the layout of basic blocks in each function"), \ |
| cl::init(false)) \ |
| \ |
| X(ReorderFunctions, bool, dev_opt_flag, "reorder-functions", \ |
| cl::desc("Randomize function ordering"), cl::init(false)) \ |
| \ |
| X(ReorderFunctionsWindowSize, uint32_t, dev_opt_flag, \ |
| "reorder-functions-window-size", \ |
| cl::desc( \ |
| "The shuffling window size for function reordering. 1 or 0 means " \ |
| "no effective shuffling."), \ |
| cl::init(8)) \ |
| \ |
| X(ReorderGlobalVariables, bool, dev_opt_flag, "reorder-global-variables", \ |
| cl::desc("Randomize global data ordering"), cl::init(false)) \ |
| \ |
| X(ReorderPooledConstants, bool, dev_opt_flag, "reorder-pooled-constants", \ |
| cl::desc("Randomize constant pool entry ordering"), cl::init(false)) \ |
| \ |
| X(RepeatRegAlloc, bool, dev_opt_flag, "regalloc-repeat", \ |
| cl::desc("Repeat register allocation until convergence"), cl::init(true)) \ |
| \ |
| /* TODO(tlively): Generalize this to handle more sanitizers */ \ |
| X(SanitizeAddresses, bool, dev_opt_flag, "fsanitize-address", \ |
| cl::desc("Instrument compiled code with Address Sanitizer"), \ |
| cl::init(false)) \ |
| \ |
| X(ShouldDoNopInsertion, bool, dev_opt_flag, "nop-insertion", \ |
| cl::desc("Randomly insert NOPs"), cl::init(false)) \ |
| \ |
| X(SkipUnimplemented, bool, dev_opt_flag, "skip-unimplemented", \ |
| cl::desc("Skip through unimplemented lowering code instead of aborting."), \ |
| cl::init(false)) \ |
| \ |
| X(SubzeroTimingEnabled, bool, dev_opt_flag, "timing", \ |
| cl::desc("Enable breakdown timing of Subzero translation")) \ |
| \ |
| X(TargetInstructionSet, Ice::TargetInstructionSet, dev_opt_flag, "mattr", \ |
| cl::desc("Target architecture attributes"), \ |
| cl::init(Ice::BaseInstructionSet), \ |
| cl::values( \ |
| clEnumValN(Ice::BaseInstructionSet, "base", \ |
| "Target chooses baseline instruction set (default)"), \ |
| clEnumValN(Ice::X86InstructionSet_SSE2, "sse2", \ |
| "Enable X86 SSE2 instructions"), \ |
| clEnumValN(Ice::X86InstructionSet_SSE4_1, "sse4.1", \ |
| "Enable X86 SSE 4.1 instructions"), \ |
| clEnumValN(Ice::ARM32InstructionSet_Neon, "neon", \ |
| "Enable ARM Neon instructions"), \ |
| clEnumValN(Ice::ARM32InstructionSet_HWDivArm, "hwdiv-arm", \ |
| "Enable ARM integer divide instructions in ARM mode") \ |
| CLENUMVALEND)) \ |
| \ |
| X(TestPrefix, std::string, dev_opt_flag, "prefix", \ |
| cl::desc("Prepend a prefix to symbol names for testing"), cl::init(""), \ |
| cl::value_desc("prefix")) \ |
| \ |
| X(TestStackExtra, uint32_t, dev_opt_flag, "test-stack-extra", \ |
| cl::desc("Extra amount of stack to add to the " \ |
| "frame in bytes (for testing)."), \ |
| cl::init(0)) \ |
| \ |
| X(TestStatusString, std::string, dev_opt_flag, "test-status", \ |
| cl::desc("Testing flag for -verbose=status"), cl::init(":")) \ |
| \ |
| X(TimeEachFunction, bool, dev_opt_flag, "timing-funcs", \ |
| cl::desc("Print total translation time for each function")) \ |
| \ |
| X(TimingFocusOnString, std::string, dev_opt_flag, "timing-focus", \ |
| cl::desc("Break down timing for specific functions (use ':' for all)"), \ |
| cl::init("")) \ |
| \ |
| X(TranslateOnlyString, std::string, dev_opt_flag, "translate-only", \ |
| cl::desc("Translate only the given functions"), cl::init(":")) \ |
| \ |
| X(UseNonsfi, bool, dev_opt_flag, "nonsfi", cl::desc("Enable Non-SFI mode")) \ |
| \ |
| X(UseRestrictedRegisters, std::string, dev_list_flag, "reg-use", \ |
| cl::CommaSeparated, \ |
| cl::desc("Only use specified registers for corresponding register " \ |
| "classes")) \ |
| \ |
| X(UseSandboxing, bool, dev_opt_flag, "sandbox", cl::desc("Use sandboxing")) \ |
| \ |
| X(Verbose, Ice::VerboseItem, dev_list_flag, "verbose", cl::CommaSeparated, \ |
| cl::desc("Verbose options (can be comma-separated):"), \ |
| cl::values( \ |
| clEnumValN(Ice::IceV_Instructions, "inst", \ |
| "Print basic instructions"), \ |
| clEnumValN(Ice::IceV_Deleted, "del", "Include deleted instructions"), \ |
| clEnumValN(Ice::IceV_InstNumbers, "instnum", \ |
| "Print instruction numbers"), \ |
| clEnumValN(Ice::IceV_Preds, "pred", "Show predecessors"), \ |
| clEnumValN(Ice::IceV_Succs, "succ", "Show successors"), \ |
| clEnumValN(Ice::IceV_Liveness, "live", "Liveness information"), \ |
| clEnumValN(Ice::IceV_RegOrigins, "orig", "Physical register origins"), \ |
| clEnumValN(Ice::IceV_LinearScan, "regalloc", "Linear scan details"), \ |
| clEnumValN(Ice::IceV_Frame, "frame", "Stack frame layout details"), \ |
| clEnumValN(Ice::IceV_AddrOpt, "addropt", "Address mode optimization"), \ |
| clEnumValN(Ice::IceV_Random, "random", "Randomization details"), \ |
| clEnumValN(Ice::IceV_Folding, "fold", "Instruction folding details"), \ |
| clEnumValN(Ice::IceV_RMW, "rmw", "ReadModifyWrite optimization"), \ |
| clEnumValN(Ice::IceV_Loop, "loop", "Loop nest depth analysis"), \ |
| clEnumValN(Ice::IceV_Mem, "mem", "Memory usage details"), \ |
| clEnumValN(Ice::IceV_ShufMat, "shufvec", \ |
| "Shufflevector rematerialization"), \ |
| clEnumValN(Ice::IceV_Status, "status", \ |
| "Print the name of the function being translated"), \ |
| clEnumValN(Ice::IceV_AvailableRegs, "registers", \ |
| "Show available registers for register allocation"), \ |
| clEnumValN(Ice::IceV_GlobalInit, "global_init", \ |
| "Global initializers"), \ |
| clEnumValN(Ice::IceV_ConstPoolStats, "cpool", \ |
| "Constant pool counters"), \ |
| clEnumValN(Ice::IceV_Wasm, "wasm", "WebAssembly builder"), \ |
| clEnumValN(Ice::IceV_All, "all", "Use all verbose options"), \ |
| clEnumValN(Ice::IceV_Most, "most", \ |
| "Use all verbose options except 'regalloc,global_init'"), \ |
| clEnumValN(Ice::IceV_None, "none", "No verbosity") CLENUMVALEND)) \ |
| \ |
| X(VerboseFocusOnString, std::string, dev_opt_flag, "verbose-focus", \ |
| cl::desc("Override with -verbose=none except for specified functions"), \ |
| cl::init(":")) \ |
| \ |
| X(WasmBoundsCheck, bool, dev_opt_flag, "wasm-bounds-check", \ |
| cl::desc("Add bounds checking code in WASM frontend"), \ |
| cl::init(true)) |
| |
| //#define X(Name, Type, ClType, ...) |
| |
| } // end of namespace Ice |
| |
| #endif // SUBZERO_SRC_ICECLFLAGS_DEF |
