"icp-calls-remaining-percent-threshold",
cl::desc("The percentage threshold against remaining unpromoted indirect "
"call count for the promotion for calls"),
- cl::init(50), cl::ZeroOrMore, cl::Hidden, cl::cat(BoltOptCategory));
+ cl::init(50), cl::Hidden, cl::cat(BoltOptCategory));
static cl::opt<unsigned> ICPCallsTotalPercentThreshold(
"icp-calls-total-percent-threshold",
"indirect-call-promotion-mispredict-threshold",
cl::desc("misprediction threshold for skipping ICP on an "
"indirect call"),
- cl::init(0), cl::ZeroOrMore, cl::cat(BoltOptCategory));
+ cl::init(0), cl::cat(BoltOptCategory));
static cl::opt<bool> ICPUseMispredicts(
"indirect-call-promotion-use-mispredicts",
ICPTopN("indirect-call-promotion-topn",
cl::desc("limit number of targets to consider when doing indirect "
"call promotion. 0 = no limit"),
- cl::init(3), cl::ZeroOrMore, cl::cat(BoltOptCategory));
+ cl::init(3), cl::cat(BoltOptCategory));
static cl::opt<unsigned> ICPCallsTopN(
"indirect-call-promotion-calls-topn",
cl::desc("limit number of targets to consider when doing indirect "
"call promotion on calls. 0 = no limit"),
- cl::init(0), cl::ZeroOrMore, cl::cat(BoltOptCategory));
+ cl::init(0), cl::cat(BoltOptCategory));
static cl::opt<unsigned> ICPJumpTablesTopN(
"indirect-call-promotion-jump-tables-topn",
cl::desc("limit number of targets to consider when doing indirect "
"call promotion on jump tables. 0 = no limit"),
- cl::init(0), cl::ZeroOrMore, cl::cat(BoltOptCategory));
+ cl::init(0), cl::cat(BoltOptCategory));
static cl::opt<bool> EliminateLoads(
"icp-eliminate-loads",
cl::desc("enable load elimination using memory profiling data when "
"performing ICP"),
- cl::init(true), cl::ZeroOrMore, cl::cat(BoltOptCategory));
+ cl::init(true), cl::cat(BoltOptCategory));
static cl::opt<unsigned> ICPTopCallsites(
"icp-top-callsites",
cl::desc("optimize hottest calls until at least this percentage of all "
"indirect calls frequency is covered. 0 = all callsites"),
- cl::init(99), cl::Hidden, cl::ZeroOrMore, cl::cat(BoltOptCategory));
+ cl::init(99), cl::Hidden, cl::cat(BoltOptCategory));
static cl::list<std::string>
ICPFuncsList("icp-funcs", cl::CommaSeparated,
static cl::opt<bool>
ICPOldCodeSequence("icp-old-code-sequence",
cl::desc("use old code sequence for promoted calls"),
- cl::init(false), cl::ZeroOrMore, cl::Hidden,
- cl::cat(BoltOptCategory));
+ cl::Hidden, cl::cat(BoltOptCategory));
static cl::opt<bool> ICPJumpTablesByTarget(
"icp-jump-tables-targets",
cl::desc(
"for jump tables, optimize indirect jmp targets instead of indices"),
- cl::init(false), cl::ZeroOrMore, cl::Hidden, cl::cat(BoltOptCategory));
+ cl::Hidden, cl::cat(BoltOptCategory));
static cl::opt<bool> ICPPeelForInline(
"icp-inline", cl::desc("only promote call targets eligible for inlining"),
- cl::init(false), cl::ZeroOrMore, cl::Hidden, cl::cat(BoltOptCategory));
+ cl::Hidden, cl::cat(BoltOptCategory));
} // namespace opts
static cl::opt<unsigned> TailDuplicationMaxCacheDistance(
"tail-duplication-max-cache-distance",
cl::desc("The weight of backward jumps for ExtTSP value"), cl::init(256),
- cl::ReallyHidden, cl::ZeroOrMore, cl::cat(BoltOptCategory));
+ cl::ReallyHidden, cl::cat(BoltOptCategory));
static cl::opt<double> TailDuplicationCacheBackwardWeight(
"tail-duplication-cache-backward-weight",
cl::desc(
"The maximum distance (in bytes) of backward jumps for ExtTSP value"),
- cl::init(0.5), cl::ReallyHidden, cl::ZeroOrMore, cl::cat(BoltOptCategory));
+ cl::init(0.5), cl::ReallyHidden, cl::cat(BoltOptCategory));
} // namespace opts
cl::ZeroOrMore, cl::Hidden, cl::cat(BoltCategory));
static cl::opt<bool>
-EliminateUnreachable("eliminate-unreachable",
- cl::desc("eliminate unreachable code"),
- cl::init(true), cl::ZeroOrMore, cl::cat(BoltOptCategory));
+ EliminateUnreachable("eliminate-unreachable",
+ cl::desc("eliminate unreachable code"), cl::init(true),
+ cl::cat(BoltOptCategory));
cl::opt<bool>
ICF("icf",
"instructions at jump sites"),
cl::ZeroOrMore, cl::cat(BoltOptCategory));
-cl::opt<bool>
-NeverPrint("never-print",
- cl::desc("never print"),
- cl::init(false), cl::ZeroOrMore, cl::ReallyHidden, cl::cat(BoltOptCategory));
+cl::opt<bool> NeverPrint("never-print", cl::desc("never print"),
+ cl::ReallyHidden, cl::cat(BoltOptCategory));
cl::opt<bool>
PrintAfterBranchFixup("print-after-branch-fixup",
cl::desc("print functions after clustering"),
cl::ZeroOrMore, cl::Hidden, cl::cat(BoltOptCategory));
-static cl::opt<bool>
-PrintRetpolineInsertion("print-retpoline-insertion",
- cl::desc("print functions after retpoline insertion pass"),
- cl::init(false), cl::ZeroOrMore, cl::cat(BoltCategory));
+static cl::opt<bool> PrintRetpolineInsertion(
+ "print-retpoline-insertion",
+ cl::desc("print functions after retpoline insertion pass"),
+ cl::cat(BoltCategory));
static cl::opt<bool>
PrintSCTC("print-sctc",
cl::ZeroOrMore, cl::Hidden, cl::cat(BoltOptCategory));
static cl::opt<bool>
-PrintStoke("print-stoke",
- cl::desc("print functions after stoke analysis"),
- cl::init(false), cl::ZeroOrMore, cl::cat(BoltOptCategory));
+ PrintStoke("print-stoke", cl::desc("print functions after stoke analysis"),
+ cl::cat(BoltOptCategory));
-static cl::opt<bool>
-PrintVeneerElimination("print-veneer-elimination",
- cl::desc("print functions after veneer elimination pass"),
- cl::init(false), cl::ZeroOrMore, cl::cat(BoltOptCategory));
+static cl::opt<bool> PrintVeneerElimination(
+ "print-veneer-elimination",
+ cl::desc("print functions after veneer elimination pass"),
+ cl::cat(BoltOptCategory));
static cl::opt<bool>
PrintUCE("print-uce",
cl::desc("print functions after unreachable code elimination"),
cl::ZeroOrMore, cl::Hidden, cl::cat(BoltOptCategory));
-static cl::opt<bool>
-RegReAssign("reg-reassign",
- cl::desc("reassign registers so as to avoid using REX prefixes in hot code"),
- cl::init(false), cl::ZeroOrMore, cl::cat(BoltOptCategory));
+static cl::opt<bool> RegReAssign(
+ "reg-reassign",
+ cl::desc(
+ "reassign registers so as to avoid using REX prefixes in hot code"),
+ cl::cat(BoltOptCategory));
-static cl::opt<bool>
-SimplifyConditionalTailCalls("simplify-conditional-tail-calls",
- cl::desc("simplify conditional tail calls by removing unnecessary jumps"),
- cl::init(true), cl::ZeroOrMore, cl::cat(BoltOptCategory));
+static cl::opt<bool> SimplifyConditionalTailCalls(
+ "simplify-conditional-tail-calls",
+ cl::desc("simplify conditional tail calls by removing unnecessary jumps"),
+ cl::init(true), cl::cat(BoltOptCategory));
static cl::opt<bool>
SimplifyRODataLoads("simplify-rodata-loads",
cl::value_desc("func1,func2:cs1:cs2,func3:cs1,..."),
cl::ZeroOrMore, cl::cat(BoltOptCategory));
-static cl::opt<bool>
-Stoke("stoke",
- cl::desc("turn on the stoke analysis"),
- cl::init(false), cl::ZeroOrMore, cl::cat(BoltOptCategory));
+static cl::opt<bool> Stoke("stoke", cl::desc("turn on the stoke analysis"),
+ cl::cat(BoltOptCategory));
-static cl::opt<bool>
-StringOps("inline-memcpy",
- cl::desc("inline memcpy using 'rep movsb' instruction (X86-only)"),
- cl::init(false), cl::ZeroOrMore, cl::cat(BoltOptCategory));
+static cl::opt<bool> StringOps(
+ "inline-memcpy",
+ cl::desc("inline memcpy using 'rep movsb' instruction (X86-only)"),
+ cl::cat(BoltOptCategory));
-static cl::opt<bool>
-StripRepRet("strip-rep-ret",
- cl::desc("strip 'repz' prefix from 'repz retq' sequence (on by default)"),
- cl::init(true), cl::ZeroOrMore, cl::cat(BoltOptCategory));
+static cl::opt<bool> StripRepRet(
+ "strip-rep-ret",
+ cl::desc("strip 'repz' prefix from 'repz retq' sequence (on by default)"),
+ cl::init(true), cl::cat(BoltOptCategory));
-static cl::opt<bool>
-VerifyCFG("verify-cfg",
- cl::desc("verify the CFG after every pass"),
- cl::init(false), cl::Hidden, cl::ZeroOrMore, cl::cat(BoltOptCategory));
+static cl::opt<bool> VerifyCFG("verify-cfg",
+ cl::desc("verify the CFG after every pass"),
+ cl::Hidden, cl::cat(BoltOptCategory));
static cl::opt<bool>
ThreeWayBranchFlag("three-way-branch",
static cl::opt<std::string> DWPPathName("dwp",
cl::desc("Path and name to DWP file."),
- cl::Hidden, cl::ZeroOrMore,
- cl::init(""), cl::cat(BoltCategory));
+ cl::Hidden, cl::init(""),
+ cl::cat(BoltCategory));
static cl::opt<bool>
UseGnuStack("use-gnu-stack",
static cl::opt<std::string> RuntimeHugifyLib(
"runtime-hugify-lib",
- cl::desc("specify file name of the runtime hugify library"), cl::ZeroOrMore,
+ cl::desc("specify file name of the runtime hugify library"),
cl::init("libbolt_rt_hugify.a"), cl::cat(BoltOptCategory));
} // namespace opts
cl::opt<unsigned> AlignFunctions(
"align-functions",
cl::desc("align functions at a given value (relocation mode)"),
- cl::init(64), cl::ZeroOrMore, cl::cat(BoltOptCategory));
+ cl::init(64), cl::cat(BoltOptCategory));
cl::opt<bool>
AggregateOnly("aggregate-only",
EntryPointName("entry", cl::desc("Symbol to call as main entry point"),
cl::init("entry"));
-static cl::list<std::string> InputObjects(cl::Positional, cl::ZeroOrMore,
+static cl::list<std::string> InputObjects(cl::Positional,
cl::desc("input objects"));
int main(int argc, char *argv[]) {
// total call count) for it to be considered as the promotion target.
static cl::opt<unsigned>
ICPTotalPercentThreshold("icp-total-percent-threshold", cl::init(5),
- cl::Hidden, cl::ZeroOrMore,
+ cl::Hidden,
cl::desc("The percentage threshold against total "
"count for the promotion"));
static cl::opt<int>
ColdCallSiteThreshold("inline-cold-callsite-threshold", cl::Hidden,
- cl::init(45), cl::ZeroOrMore,
+ cl::init(45),
cl::desc("Threshold for inlining cold callsites"));
static cl::opt<bool> InlineEnableCostBenefitAnalysis(
namespace llvm {
// A command line option to enable the CopyToPhi DAG mutation.
-cl::opt<bool>
- SwpEnableCopyToPhi("pipeliner-enable-copytophi", cl::ReallyHidden,
- cl::init(true), cl::ZeroOrMore,
- cl::desc("Enable CopyToPhi DAG Mutation"));
+cl::opt<bool> SwpEnableCopyToPhi("pipeliner-enable-copytophi", cl::ReallyHidden,
+ cl::init(true),
+ cl::desc("Enable CopyToPhi DAG Mutation"));
} // end namespace llvm
cl::opt<unsigned> ProfileSummaryHugeWorkingSetSizeThreshold(
"profile-summary-huge-working-set-size-threshold", cl::Hidden,
- cl::init(15000), cl::ZeroOrMore,
+ cl::init(15000),
cl::desc("The code working set size is considered huge if the number of"
" blocks required to reach the -profile-summary-cutoff-hot"
" percentile exceeds this count."));
cl::opt<unsigned> ProfileSummaryLargeWorkingSetSizeThreshold(
"profile-summary-large-working-set-size-threshold", cl::Hidden,
- cl::init(12500), cl::ZeroOrMore,
+ cl::init(12500),
cl::desc("The code working set size is considered large if the number of"
" blocks required to reach the -profile-summary-cutoff-hot"
" percentile exceeds this count."));
"debug-only",
cl::desc("Enable a specific type of debug output (comma separated list "
"of types)"),
- cl::Hidden, cl::ZeroOrMore, cl::value_desc("debug string"),
+ cl::Hidden, cl::value_desc("debug string"),
cl::location(DebugOnlyOptLoc), cl::ValueRequired);
}
};
static cl::opt<bool>
ClUseStackSafety("stack-tagging-use-stack-safety", cl::Hidden,
- cl::init(true), cl::ZeroOrMore,
+ cl::init(true),
cl::desc("Use Stack Safety analysis results"));
static cl::opt<unsigned> ClScanLimit("stack-tagging-merge-init-scan-limit",
cl::Hidden, cl::desc("Set the number of scavenger slots"), cl::init(2),
cl::ZeroOrMore);
-static cl::opt<int> SpillFuncThreshold("spill-func-threshold",
- cl::Hidden, cl::desc("Specify O2(not Os) spill func threshold"),
- cl::init(6), cl::ZeroOrMore);
+static cl::opt<int>
+ SpillFuncThreshold("spill-func-threshold", cl::Hidden,
+ cl::desc("Specify O2(not Os) spill func threshold"),
+ cl::init(6));
-static cl::opt<int> SpillFuncThresholdOs("spill-func-threshold-Os",
- cl::Hidden, cl::desc("Specify Os spill func threshold"),
- cl::init(1), cl::ZeroOrMore);
+static cl::opt<int>
+ SpillFuncThresholdOs("spill-func-threshold-Os", cl::Hidden,
+ cl::desc("Specify Os spill func threshold"),
+ cl::init(1));
-static cl::opt<bool> EnableStackOVFSanitizer("enable-stackovf-sanitizer",
- cl::Hidden, cl::desc("Enable runtime checks for stack overflow."),
- cl::init(false), cl::ZeroOrMore);
+static cl::opt<bool> EnableStackOVFSanitizer(
+ "enable-stackovf-sanitizer", cl::Hidden,
+ cl::desc("Enable runtime checks for stack overflow."), cl::init(false));
static cl::opt<bool>
EnableShrinkWrapping("hexagon-shrink-frame", cl::init(true), cl::Hidden,
cl::init(std::numeric_limits<unsigned>::max()), cl::Hidden,
cl::desc("Max count of stack frame shrink-wraps"));
-static cl::opt<bool> EnableSaveRestoreLong("enable-save-restore-long",
- cl::Hidden, cl::desc("Enable long calls for save-restore stubs."),
- cl::init(false), cl::ZeroOrMore);
+static cl::opt<bool>
+ EnableSaveRestoreLong("enable-save-restore-long", cl::Hidden,
+ cl::desc("Enable long calls for save-restore stubs."),
+ cl::init(false));
static cl::opt<bool> EliminateFramePointer("hexagon-fp-elim", cl::init(true),
cl::Hidden, cl::desc("Refrain from using FP whenever possible"));
cl::Hidden,
cl::desc("Maximum size of IFMap"));
-static cl::opt<bool> OptTiming("insert-timing", cl::Hidden, cl::ZeroOrMore,
+static cl::opt<bool> OptTiming("insert-timing", cl::Hidden,
cl::desc("Enable timing of insert generation"));
static cl::opt<bool>
OptTimingDetail("insert-timing-detail", cl::Hidden,
STATISTIC(HexagonNumVectorLoopCarriedReuse,
"Number of values that were reused from a previous iteration.");
-static cl::opt<int> HexagonVLCRIterationLim("hexagon-vlcr-iteration-lim",
- cl::Hidden,
+static cl::opt<int> HexagonVLCRIterationLim(
+ "hexagon-vlcr-iteration-lim", cl::Hidden,
cl::desc("Maximum distance of loop carried dependences that are handled"),
- cl::init(2), cl::ZeroOrMore);
+ cl::init(2));
namespace llvm {
// produces larger value, the BFI value will be used.
static cl::opt<int>
OutlineRegionFreqPercent("outline-region-freq-percent", cl::init(75),
- cl::Hidden, cl::ZeroOrMore,
+ cl::Hidden,
cl::desc("Relative frequency of outline region to "
"the entry block"));
static cl::opt<unsigned>
ClThreshold("wholeprogramdevirt-branch-funnel-threshold", cl::Hidden,
- cl::init(10), cl::ZeroOrMore,
+ cl::init(10),
cl::desc("Maximum number of call targets per "
"call site to enable branch funnels"));
static cl::opt<bool>
PrintSummaryDevirt("wholeprogramdevirt-print-index-based", cl::Hidden,
- cl::init(false), cl::ZeroOrMore,
cl::desc("Print index-based devirtualization messages"));
/// Provide a way to force enable whole program visibility in tests.
/// !vcall_visibility metadata (the mere presense of type tests
/// previously implied hidden visibility).
static cl::opt<bool>
- WholeProgramVisibility("whole-program-visibility", cl::init(false),
- cl::Hidden, cl::ZeroOrMore,
+ WholeProgramVisibility("whole-program-visibility", cl::Hidden,
cl::desc("Enable whole program visibility"));
/// Provide a way to force disable whole program for debugging or workarounds,
static cl::opt<bool>
ClInstrumentLandingPads("hwasan-instrument-landing-pads",
cl::desc("instrument landing pads"), cl::Hidden,
- cl::init(false), cl::ZeroOrMore);
+ cl::init(false));
static cl::opt<bool> ClUseShortGranules(
"hwasan-use-short-granules",
cl::desc("use short granules in allocas and outlined checks"), cl::Hidden,
- cl::init(false), cl::ZeroOrMore);
+ cl::init(false));
static cl::opt<bool> ClInstrumentPersonalityFunctions(
"hwasan-instrument-personality-functions",
// The percent threshold to optimize memory intrinsic calls.
static cl::opt<unsigned>
MemOPPercentThreshold("pgo-memop-percent-threshold", cl::init(40),
- cl::Hidden, cl::ZeroOrMore,
+ cl::Hidden,
cl::desc("The percentage threshold for the "
"memory intrinsic calls optimization"));
static cl::opt<bool>
VerboseFusionDebugging("loop-fusion-verbose-debug",
cl::desc("Enable verbose debugging for Loop Fusion"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore);
+ cl::Hidden, cl::init(false));
#endif
namespace {
cl::opt<bool> ApplyExtTspWithoutProfile(
"ext-tsp-apply-without-profile",
cl::desc("Whether to apply ext-tsp placement for instances w/o profile"),
- cl::init(true), cl::Hidden, cl::ZeroOrMore);
+ cl::init(true), cl::Hidden);
// Algorithm-specific constants. The values are tuned for the best performance
// of large-scale front-end bound binaries.
static cl::opt<RunPassOption, true, cl::parser<std::string>> RunPass(
"run-pass",
cl::desc("Run compiler only for specified passes (comma separated list)"),
- cl::value_desc("pass-name"), cl::ZeroOrMore, cl::location(RunPassOpt));
+ cl::value_desc("pass-name"), cl::location(RunPassOpt));
static int compileModule(char **, LLVMContext &);
cl::Positional, cl::desc("Covered executable or object file."));
cl::list<std::string> CovFilenames(
- "object", cl::desc("Coverage executable or object file"), cl::ZeroOrMore);
+ "object", cl::desc("Coverage executable or object file"));
cl::opt<bool> DebugDumpCollectedObjects(
"dump-collected-objects", cl::Optional, cl::Hidden,
cl::ZeroOrMore,
cl::cat(LibtoolCategory));
-static cl::opt<std::string> ArchType(
- "arch_only", cl::desc("Specify architecture type for output library"),
- cl::value_desc("arch_type"), cl::ZeroOrMore, cl::cat(LibtoolCategory));
+static cl::opt<std::string>
+ ArchType("arch_only",
+ cl::desc("Specify architecture type for output library"),
+ cl::value_desc("arch_type"), cl::cat(LibtoolCategory));
enum class Operation { None, Static };
OptLevel("O",
cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
"(default = '-O2')"),
- cl::Prefix, cl::ZeroOrMore, cl::init('2'), cl::cat(LTOCategory));
+ cl::Prefix, cl::init('2'), cl::cat(LTOCategory));
static cl::opt<bool>
IndexStats("thinlto-index-stats",
static codegen::RegisterCodeGenFlags CGF;
static cl::opt<char>
- OptLevel("O", cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
- "(default = '-O2')"),
- cl::Prefix, cl::ZeroOrMore, cl::init('2'));
+ OptLevel("O",
+ cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
+ "(default = '-O2')"),
+ cl::Prefix, cl::init('2'));
static cl::opt<char> CGOptLevel(
"cg-opt-level",
cl::desc("dump id hashes and index offsets"),
cl::cat(TypeOptions), cl::sub(DumpSubcommand));
cl::list<uint32_t> DumpIdIndex(
- "id-index", cl::ZeroOrMore, cl::CommaSeparated,
+ "id-index", cl::CommaSeparated,
cl::desc("only dump ids with the specified hexadecimal type index"),
cl::cat(TypeOptions), cl::sub(DumpSubcommand));
static cl::alias UPA("up", cl::desc("Alias for --unsymbolized-profile"),
cl::aliasopt(UnsymbolizedProfFilename));
-static cl::opt<std::string>
- SampleProfFilename("llvm-sample-profile",
- cl::value_desc("llvm sample profile"), cl::ZeroOrMore,
- cl::desc("Path of the LLVM sample profile"),
- cl::cat(ProfGenCategory));
+static cl::opt<std::string> SampleProfFilename(
+ "llvm-sample-profile", cl::value_desc("llvm sample profile"),
+ cl::desc("Path of the LLVM sample profile"), cl::cat(ProfGenCategory));
static cl::opt<std::string>
BinaryPath("binary", cl::value_desc("binary"), cl::Required,
"polly-dependences-computeout",
cl::desc("Bound the dependence analysis by a maximal amount of "
"computational steps (0 means no bound)"),
- cl::Hidden, cl::init(500000), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::init(500000), cl::cat(PollyCategory));
-static cl::opt<bool> LegalityCheckDisabled(
- "disable-polly-legality", cl::desc("Disable polly legality check"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+static cl::opt<bool>
+ LegalityCheckDisabled("disable-polly-legality",
+ cl::desc("Disable polly legality check"), cl::Hidden,
+ cl::cat(PollyCategory));
static cl::opt<bool>
UseReductions("polly-dependences-use-reductions",
cl::desc("Exploit reductions in dependence analysis"),
- cl::Hidden, cl::init(true), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::Hidden, cl::init(true), cl::cat(PollyCategory));
enum AnalysisType { VALUE_BASED_ANALYSIS, MEMORY_BASED_ANALYSIS };
static cl::opt<bool> CheckParallel("polly-check-parallel",
cl::desc("Check for parallel loops"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
static cl::opt<bool> CheckVectorizable("polly-check-vectorizable",
cl::desc("Check for vectorizable loops"),
static cl::opt<bool, true> XModelReadOnlyScalars(
"polly-analyze-read-only-scalars",
cl::desc("Model read-only scalar values in the scop description"),
- cl::location(ModelReadOnlyScalars), cl::Hidden, cl::ZeroOrMore,
- cl::init(true), cl::cat(PollyCategory));
+ cl::location(ModelReadOnlyScalars), cl::Hidden, cl::init(true),
+ cl::cat(PollyCategory));
static cl::opt<int>
OptComputeOut("polly-analysis-computeout",
cl::desc("Bound the scop analysis by a maximal amount of "
"computational steps (0 means no bound)"),
- cl::Hidden, cl::init(800000), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::Hidden, cl::init(800000), cl::cat(PollyCategory));
static cl::opt<bool> PollyAllowDereferenceOfAllFunctionParams(
"polly-allow-dereference-of-all-function-parameters",
static cl::opt<unsigned> RunTimeChecksMaxArraysPerGroup(
"polly-rtc-max-arrays-per-group",
cl::desc("The maximal number of arrays to compare in each alias group."),
- cl::Hidden, cl::ZeroOrMore, cl::init(20), cl::cat(PollyCategory));
+ cl::Hidden, cl::init(20), cl::cat(PollyCategory));
static cl::opt<unsigned> RunTimeChecksMaxAccessDisjuncts(
"polly-rtc-max-array-disjuncts",
cl::desc("The maximal number of disjunts allowed in memory accesses to "
"to build RTCs."),
- cl::Hidden, cl::ZeroOrMore, cl::init(8), cl::cat(PollyCategory));
+ cl::Hidden, cl::init(8), cl::cat(PollyCategory));
static cl::opt<unsigned> RunTimeChecksMaxParameters(
"polly-rtc-max-parameters",
static cl::opt<bool> DetectReductions("polly-detect-reductions",
cl::desc("Detect and exploit reductions"),
- cl::Hidden, cl::ZeroOrMore,
- cl::init(true), cl::cat(PollyCategory));
+ cl::Hidden, cl::init(true),
+ cl::cat(PollyCategory));
// Multiplicative reductions can be disabled separately as these kind of
// operations can overflow easily. Additive reductions and bit operations
// are in contrast pretty stable.
static cl::opt<bool> DisableMultiplicativeReductions(
"polly-disable-multiplicative-reductions",
- cl::desc("Disable multiplicative reductions"), cl::Hidden, cl::ZeroOrMore,
- cl::init(false), cl::cat(PollyCategory));
+ cl::desc("Disable multiplicative reductions"), cl::Hidden,
+ cl::cat(PollyCategory));
enum class GranularityChoice { BasicBlocks, ScalarIndependence, Stores };
"polly-process-unprofitable",
cl::desc(
"Process scops that are unlikely to benefit from Polly optimizations."),
- cl::location(PollyProcessUnprofitable), cl::init(false), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::location(PollyProcessUnprofitable), cl::cat(PollyCategory));
static cl::list<std::string> OnlyFunctions(
"polly-only-func",
static cl::opt<bool>
IgnoreAliasing("polly-ignore-aliasing",
cl::desc("Ignore possible aliasing of the array bases"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
bool polly::PollyAllowUnsignedOperations;
static cl::opt<bool, true> XPollyAllowUnsignedOperations(
"polly-allow-unsigned-operations",
cl::desc("Allow unsigned operations such as comparisons or zero-extends."),
- cl::location(PollyAllowUnsignedOperations), cl::Hidden, cl::ZeroOrMore,
- cl::init(true), cl::cat(PollyCategory));
+ cl::location(PollyAllowUnsignedOperations), cl::Hidden, cl::init(true),
+ cl::cat(PollyCategory));
bool polly::PollyUseRuntimeAliasChecks;
static cl::opt<bool, true> XPollyUseRuntimeAliasChecks(
"polly-use-runtime-alias-checks",
cl::desc("Use runtime alias checks to resolve possible aliasing."),
- cl::location(PollyUseRuntimeAliasChecks), cl::Hidden, cl::ZeroOrMore,
- cl::init(true), cl::cat(PollyCategory));
+ cl::location(PollyUseRuntimeAliasChecks), cl::Hidden, cl::init(true),
+ cl::cat(PollyCategory));
static cl::opt<bool>
ReportLevel("polly-report",
cl::desc("Print information about the activities of Polly"),
- cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::cat(PollyCategory));
static cl::opt<bool> AllowDifferentTypes(
"polly-allow-differing-element-types",
cl::desc("Allow different element types for array accesses"), cl::Hidden,
- cl::init(true), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::init(true), cl::cat(PollyCategory));
static cl::opt<bool>
AllowNonAffine("polly-allow-nonaffine",
cl::desc("Allow non affine access functions in arrays"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
static cl::opt<bool>
AllowModrefCall("polly-allow-modref-calls",
cl::desc("Allow functions with known modref behavior"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
static cl::opt<bool> AllowNonAffineSubRegions(
"polly-allow-nonaffine-branches",
cl::desc("Allow non affine conditions for branches"), cl::Hidden,
- cl::init(true), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::init(true), cl::cat(PollyCategory));
static cl::opt<bool>
AllowNonAffineSubLoops("polly-allow-nonaffine-loops",
cl::desc("Allow non affine conditions for loops"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
static cl::opt<bool, true>
TrackFailures("polly-detect-track-failures",
cl::desc("Track failure strings in detecting scop regions"),
- cl::location(PollyTrackFailures), cl::Hidden, cl::ZeroOrMore,
- cl::init(true), cl::cat(PollyCategory));
+ cl::location(PollyTrackFailures), cl::Hidden, cl::init(true),
+ cl::cat(PollyCategory));
static cl::opt<bool> KeepGoing("polly-detect-keep-going",
cl::desc("Do not fail on the first error."),
- cl::Hidden, cl::ZeroOrMore, cl::init(false),
- cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
static cl::opt<bool, true>
PollyDelinearizeX("polly-delinearize",
static cl::opt<bool>
VerifyScops("polly-detect-verify",
cl::desc("Verify the detected SCoPs after each transformation"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
bool polly::PollyInvariantLoadHoisting;
-static cl::opt<bool, true> XPollyInvariantLoadHoisting(
- "polly-invariant-load-hoisting", cl::desc("Hoist invariant loads."),
- cl::location(PollyInvariantLoadHoisting), cl::Hidden, cl::ZeroOrMore,
- cl::init(false), cl::cat(PollyCategory));
+static cl::opt<bool, true>
+ XPollyInvariantLoadHoisting("polly-invariant-load-hoisting",
+ cl::desc("Hoist invariant loads."),
+ cl::location(PollyInvariantLoadHoisting),
+ cl::Hidden, cl::cat(PollyCategory));
static cl::opt<bool> PollyAllowErrorBlocks(
"polly-allow-error-blocks",
cl::desc("Allow to speculate on the execution of 'error blocks'."),
- cl::Hidden, cl::init(true), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::init(true), cl::cat(PollyCategory));
/// The minimal trip count under which loops are considered unprofitable.
static const unsigned MIN_LOOP_TRIP_COUNT = 8;
static cl::opt<std::string>
ViewFilter("polly-view-only",
cl::desc("Only view functions that match this pattern"),
- cl::Hidden, cl::init(""), cl::ZeroOrMore);
+ cl::Hidden, cl::init(""));
static cl::opt<bool> ViewAll("polly-view-all",
cl::desc("Also show functions without any scops"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore);
+ cl::Hidden, cl::init(false));
namespace llvm {
static cl::opt<bool> PollyRemarksMinimal(
"polly-remarks-minimal",
cl::desc("Do not emit remarks about assumptions that are known"),
- cl::Hidden, cl::ZeroOrMore, cl::init(false), cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
static cl::opt<bool>
IslOnErrorAbort("polly-on-isl-error-abort",
static cl::opt<bool> Aligned("enable-polly-aligned",
cl::desc("Assumed aligned memory accesses."),
- cl::Hidden, cl::init(false), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
bool PollyDebugPrinting;
static cl::opt<bool, true> DebugPrintingX(
static cl::opt<bool> TraceStmts(
"polly-codegen-trace-stmts",
cl::desc("Add printf calls that print the statement being executed"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
static cl::opt<bool> TraceScalars(
"polly-codegen-trace-scalars",
cl::desc("Add printf calls that print the values of all scalar values "
"used in a statement. Requires -polly-codegen-trace-stmts."),
- cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
BlockGenerator::BlockGenerator(
PollyIRBuilder &B, LoopInfo &LI, ScalarEvolution &SE, DominatorTree &DT,
static cl::opt<bool> Verify("polly-codegen-verify",
cl::desc("Verify the function generated by Polly"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
bool polly::PerfMonitoring;
static cl::opt<bool>
PollyParallel("polly-parallel",
cl::desc("Generate thread parallel code (isl codegen only)"),
- cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::cat(PollyCategory));
static cl::opt<bool> PrintAccesses("polly-ast-print-accesses",
cl::desc("Print memory access functions"),
- cl::init(false), cl::ZeroOrMore,
cl::cat(PollyCategory));
static cl::opt<bool> PollyParallelForce(
static cl::opt<bool> UseContext("polly-ast-use-context",
cl::desc("Use context"), cl::Hidden,
- cl::init(true), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::init(true), cl::cat(PollyCategory));
static cl::opt<bool> DetectParallel("polly-ast-detect-parallel",
cl::desc("Detect parallelism"), cl::Hidden,
- cl::init(false), cl::ZeroOrMore,
cl::cat(PollyCategory));
STATISTIC(ScopsProcessed, "Number of SCoPs processed");
static cl::opt<bool> PollyGenerateRTCPrint(
"polly-codegen-emit-rtc-print",
cl::desc("Emit code that prints the runtime check result dynamically."),
- cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
// If this option is set we always use the isl AST generator to regenerate
// memory accesses. Without this option set we regenerate expressions using the
static cl::opt<bool> PollyGenerateExpressions(
"polly-codegen-generate-expressions",
cl::desc("Generate AST expressions for unmodified and modified accesses"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
static cl::opt<int> PollyTargetFirstLevelCacheLineSize(
"polly-target-first-level-cache-line-size",
cl::desc("The size of the first level cache line size specified in bytes."),
- cl::Hidden, cl::init(64), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::init(64), cl::cat(PollyCategory));
static cl::opt<OpenMPBackend> PollyOmpBackend(
"polly-omp-backend", cl::desc("Choose the OpenMP library to use:"),
"polly-acc-rewrite-allocas",
cl::desc(
"Ask the managed memory rewriter to also rewrite alloca instructions"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
static cl::opt<bool> IgnoreLinkageForGlobals(
"polly-acc-rewrite-ignore-linkage-for-globals",
static cl::opt<bool> DumpSchedule("polly-acc-dump-schedule",
cl::desc("Dump the computed GPU Schedule"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
static cl::opt<bool>
DumpCode("polly-acc-dump-code",
cl::desc("Dump C code describing the GPU mapping"), cl::Hidden,
- cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::cat(PollyCategory));
static cl::opt<bool> DumpKernelIR("polly-acc-dump-kernel-ir",
cl::desc("Dump the kernel LLVM-IR"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
static cl::opt<bool> DumpKernelASM("polly-acc-dump-kernel-asm",
cl::desc("Dump the kernel assembly code"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
static cl::opt<bool> FastMath("polly-acc-fastmath",
cl::desc("Allow unsafe math optimizations"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
static cl::opt<bool> SharedMemory("polly-acc-use-shared",
cl::desc("Use shared memory"), cl::Hidden,
- cl::init(false), cl::ZeroOrMore,
cl::cat(PollyCategory));
static cl::opt<bool> PrivateMemory("polly-acc-use-private",
cl::desc("Use private memory"), cl::Hidden,
- cl::init(false), cl::ZeroOrMore,
cl::cat(PollyCategory));
bool polly::PollyManagedMemory;
static cl::opt<std::string>
CudaVersion("polly-acc-cuda-version",
cl::desc("The CUDA version to compile for"), cl::Hidden,
- cl::init("sm_30"), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::init("sm_30"), cl::cat(PollyCategory));
static cl::opt<int>
MinCompute("polly-acc-mincompute",
static cl::opt<bool>
PollyEnabled("polly",
cl::desc("Enable the polly optimizer (with -O1, -O2 or -O3)"),
- cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::cat(PollyCategory));
static cl::opt<bool> PollyDetectOnly(
"polly-only-scop-detection",
cl::desc("Only run scop detection, but no other optimizations"),
- cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::cat(PollyCategory));
enum PassPositionChoice {
POSITION_EARLY,
static cl::opt<bool> ImportJScop(
"polly-import",
cl::desc("Import the polyhedral description of the detected Scops"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
static cl::opt<bool> FullyIndexedStaticExpansion(
"polly-enable-mse",
cl::desc("Fully expand the memory accesses of the detected Scops"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
static cl::opt<bool> ExportJScop(
"polly-export",
cl::desc("Export the polyhedral description of the detected Scops"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
static cl::opt<bool> DeadCodeElim("polly-run-dce",
cl::desc("Run the dead code elimination"),
- cl::Hidden, cl::init(false), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
static cl::opt<bool> PollyViewer(
"polly-show",
"polly-ignore-integer-wrapping",
cl::desc("Do not build run-time checks to proof absence of integer "
"wrapping"),
- cl::Hidden, cl::ZeroOrMore, cl::init(false), cl::cat(PollyCategory));
+ cl::Hidden, cl::cat(PollyCategory));
// The maximal number of basic sets we allow during the construction of a
// piecewise affine function. More complex ones will result in very high
static cl::opt<bool>
PollyInliner("polly-run-inliner",
cl::desc("Run an early inliner pass before Polly"), cl::Hidden,
- cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::cat(PollyCategory));
void polly::registerCanonicalicationPasses(llvm::legacy::PassManagerBase &PM) {
bool UseMemSSA = true;
static cl::opt<bool> IgnoreDepcheck(
"polly-pragma-ignore-depcheck",
cl::desc("Skip the dependency check for pragma-based transformations"),
- cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::cat(PollyCategory));
/// Same as llvm::hasUnrollTransformation(), but takes a LoopID as argument
/// instead of a Loop.
static cl::opt<int> FirstCacheLevelSize(
"polly-target-1st-cache-level-size",
cl::desc("The size of the first cache level specified in bytes."),
- cl::Hidden, cl::init(-1), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::init(-1), cl::cat(PollyCategory));
static cl::opt<int> FirstCacheLevelDefaultSize(
"polly-target-1st-cache-level-default-size",
cl::desc("The default size of the first cache level specified in bytes"
" (if not enough were provided by the TargetTransformInfo)."),
- cl::Hidden, cl::init(32768), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::init(32768), cl::cat(PollyCategory));
static cl::opt<int> SecondCacheLevelSize(
"polly-target-2nd-cache-level-size",
cl::desc("The size of the second level specified in bytes."), cl::Hidden,
- cl::init(-1), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::init(-1), cl::cat(PollyCategory));
static cl::opt<int> SecondCacheLevelDefaultSize(
"polly-target-2nd-cache-level-default-size",
cl::desc("The default size of the second cache level specified in bytes"
" (if not enough were provided by the TargetTransformInfo)."),
- cl::Hidden, cl::init(262144), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::init(262144), cl::cat(PollyCategory));
// This option, along with --polly-target-2nd-cache-level-associativity,
// --polly-target-1st-cache-level-size, and --polly-target-2st-cache-level-size
static cl::opt<int> FirstCacheLevelAssociativity(
"polly-target-1st-cache-level-associativity",
cl::desc("The associativity of the first cache level."), cl::Hidden,
- cl::init(-1), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::init(-1), cl::cat(PollyCategory));
static cl::opt<int> FirstCacheLevelDefaultAssociativity(
"polly-target-1st-cache-level-default-associativity",
cl::desc("The default associativity of the first cache level"
" (if not enough were provided by the TargetTransformInfo)."),
- cl::Hidden, cl::init(8), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::init(8), cl::cat(PollyCategory));
static cl::opt<int> SecondCacheLevelAssociativity(
"polly-target-2nd-cache-level-associativity",
cl::desc("The associativity of the second cache level."), cl::Hidden,
- cl::init(-1), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::init(-1), cl::cat(PollyCategory));
static cl::opt<int> SecondCacheLevelDefaultAssociativity(
"polly-target-2nd-cache-level-default-associativity",
cl::desc("The default associativity of the second cache level"
" (if not enough were provided by the TargetTransformInfo)."),
- cl::Hidden, cl::init(8), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::init(8), cl::cat(PollyCategory));
static cl::opt<int> VectorRegisterBitwidth(
"polly-target-vector-register-bitwidth",
cl::desc("The size in bits of a vector register (if not set, this "
"information is taken from LLVM's target information."),
- cl::Hidden, cl::init(-1), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::init(-1), cl::cat(PollyCategory));
static cl::opt<int> PollyPatternMatchingNcQuotient(
"polly-pattern-matching-nc-quotient",
cl::desc("Quotient that is obtained by dividing Nc, the parameter of the"
"macro-kernel, by Nr, the parameter of the micro-kernel"),
- cl::Hidden, cl::init(256), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::init(256), cl::cat(PollyCategory));
namespace {
/// Parameters of the micro kernel.
static cl::opt<std::string>
OptimizeDeps("polly-opt-optimize-only",
cl::desc("Only a certain kind of dependences (all/raw)"),
- cl::Hidden, cl::init("all"), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::Hidden, cl::init("all"), cl::cat(PollyCategory));
static cl::opt<std::string>
SimplifyDeps("polly-opt-simplify-deps",
cl::desc("Dependences should be simplified (yes/no)"),
- cl::Hidden, cl::init("yes"), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::Hidden, cl::init("yes"), cl::cat(PollyCategory));
static cl::opt<int> MaxConstantTerm(
"polly-opt-max-constant-term",
cl::desc("The maximal constant term allowed (-1 is unlimited)"), cl::Hidden,
- cl::init(20), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::init(20), cl::cat(PollyCategory));
static cl::opt<int> MaxCoefficient(
"polly-opt-max-coefficient",
cl::desc("The maximal coefficient allowed (-1 is unlimited)"), cl::Hidden,
- cl::init(20), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::init(20), cl::cat(PollyCategory));
static cl::opt<std::string>
MaximizeBandDepth("polly-opt-maximize-bands",
cl::desc("Maximize the band depth (yes/no)"), cl::Hidden,
- cl::init("yes"), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::init("yes"), cl::cat(PollyCategory));
static cl::opt<bool>
GreedyFusion("polly-loopfusion-greedy",
"polly-opt-outer-coincidence",
cl::desc("Try to construct schedules where the outer member of each band "
"satisfies the coincidence constraints (yes/no)"),
- cl::Hidden, cl::init("no"), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::init("no"), cl::cat(PollyCategory));
static cl::opt<int> PrevectorWidth(
"polly-prevect-width",
cl::desc(
"The number of loop iterations to strip-mine for pre-vectorization"),
- cl::Hidden, cl::init(4), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::init(4), cl::cat(PollyCategory));
static cl::opt<bool> FirstLevelTiling("polly-tiling",
cl::desc("Enable loop tiling"),
- cl::init(true), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::init(true), cl::cat(PollyCategory));
static cl::opt<int> FirstLevelDefaultTileSize(
"polly-default-tile-size",
static cl::opt<bool>
SecondLevelTiling("polly-2nd-level-tiling",
cl::desc("Enable a 2nd level loop of loop tiling"),
- cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::cat(PollyCategory));
static cl::opt<int> SecondLevelDefaultTileSize(
"polly-2nd-level-default-tile-size",
cl::desc("The default 2nd-level tile size (if not enough were provided by"
" --polly-2nd-level-tile-sizes)"),
- cl::Hidden, cl::init(16), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::Hidden, cl::init(16), cl::cat(PollyCategory));
static cl::list<int>
SecondLevelTileSizes("polly-2nd-level-tile-sizes",
static cl::opt<bool> RegisterTiling("polly-register-tiling",
cl::desc("Enable register tiling"),
- cl::init(false), cl::ZeroOrMore,
cl::cat(PollyCategory));
static cl::opt<int> RegisterDefaultTileSize(
static cl::opt<bool> PragmaBasedOpts(
"polly-pragma-based-opts",
cl::desc("Apply user-directed transformation from metadata"),
- cl::init(true), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::init(true), cl::cat(PollyCategory));
static cl::opt<bool> EnableReschedule("polly-reschedule",
cl::desc("Optimize SCoPs using ISL"),
- cl::init(true), cl::ZeroOrMore,
- cl::cat(PollyCategory));
+ cl::init(true), cl::cat(PollyCategory));
static cl::opt<bool>
PMBasedOpts("polly-pattern-matching-based-opts",
cl::desc("Perform optimizations based on pattern matching"),
- cl::init(true), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::init(true), cl::cat(PollyCategory));
static cl::opt<bool>
EnablePostopts("polly-postopts",
cl::desc("Apply post-rescheduling optimizations such as "
"tiling (requires -polly-reschedule)"),
- cl::init(true), cl::ZeroOrMore, cl::cat(PollyCategory));
+ cl::init(true), cl::cat(PollyCategory));
static cl::opt<bool> OptimizedScops(
"polly-optimized-scops",