Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2025-03-01 14:58:18 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Remove unneeded cl::ZeroOrMore for cl::opt options

Browse Source 
Similar to 557efc9a8b68628c2c944678c6471dac30ed9e8e.
This commit handles options where cl::ZeroOrMore is more than one line below
cl::opt.
This commit is contained in:
Fangrui Song 2022-06-04 00:10:42 -07:00
parent bcfc0a9051
commit 36c7d79dc4
47 changed files with 195 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
bolt/lib/Passes/IndirectCallPromotion.cpp
View File

@ -50,7 +50,7 @@ static cl::opt<unsigned> ICPCallsRemainingPercentThreshold(
"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",
@ -63,7 +63,7 @@ static cl::opt<unsigned> ICPMispredictThreshold(
"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",
@ -77,31 +77,31 @@ static cl::opt<unsigned>
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,
@ -112,18 +112,17 @@ static cl::list<std::string>
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

4
bolt/lib/Passes/TailDuplication.cpp
View File

@ -66,13 +66,13 @@ static cl::opt<bool> TailDuplicationConstCopyPropagation(
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

79
bolt/lib/Rewrite/BinaryPassManager.cpp
View File

@ -55,9 +55,9 @@ DynoStatsAll("dyno-stats-all",
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",
@ -70,10 +70,8 @@ JTFootprintReductionFlag("jt-footprint-reduction",
"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",
@ -160,10 +158,10 @@ PrintReorderedFunctions("print-reordered-functions",
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",
@ -181,29 +179,29 @@ PrintSplit("print-split",
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",
@ -218,25 +216,22 @@ SpecializeMemcpy1("memcpy1-spec",
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",

4
bolt/lib/Rewrite/RewriteInstance.cpp
View File

@ -275,8 +275,8 @@ TrapOldCode("trap-old-code",
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",

2
bolt/lib/RuntimeLibs/HugifyRuntimeLibrary.cpp
View File

@ -35,7 +35,7 @@ cl::opt<bool>
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

2
bolt/lib/Utils/CommandLineOpts.cpp
View File

@ -50,7 +50,7 @@ AlignText("align-text",
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",

2
llvm/examples/OrcV2Examples/LLJITWithObjectLinkingLayerPlugin/LLJITWithObjectLinkingLayerPlugin.cpp
View File

@ -183,7 +183,7 @@ static cl::opt<std::string>
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[]) {

2
llvm/lib/Analysis/IndirectCallPromotionAnalysis.cpp
View File

@ -34,7 +34,7 @@ static cl::opt<unsigned> ICPRemainingPercentThreshold(
// 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"));

2
llvm/lib/Analysis/InlineCost.cpp
View File

@ -78,7 +78,7 @@ static cl::opt<int> HintThreshold(
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(

7
llvm/lib/CodeGen/MachinePipeliner.cpp
View File

@ -169,10 +169,9 @@ static cl::opt<bool> ExperimentalCodeGen(
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

4
llvm/lib/ProfileData/ProfileSummaryBuilder.cpp
View File

@ -41,14 +41,14 @@ cl::opt<int> ProfileSummaryCutoffCold(
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."));

2
llvm/lib/Support/Debug.cpp
View File

@ -132,7 +132,7 @@ struct CreateDebugOnly {
"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);
}
};

2
llvm/lib/Target/AArch64/AArch64StackTagging.cpp
View File

@ -70,7 +70,7 @@ static cl::opt<bool> ClMergeInit(
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",

27
llvm/lib/Target/Hexagon/HexagonFrameLowering.cpp
View File

@ -156,17 +156,19 @@ static cl::opt<unsigned> NumberScavengerSlots("number-scavenger-slots",
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,
@ -177,9 +179,10 @@ static cl::opt<unsigned>
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"));

2
llvm/lib/Target/Hexagon/HexagonGenInsert.cpp
View File

@ -65,7 +65,7 @@ static cl::opt<unsigned> MaxIFMSize("insert-max-ifmap", cl::init(1024),
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,

6
llvm/lib/Target/Hexagon/HexagonVectorLoopCarriedReuse.cpp
View File

@ -53,10 +53,10 @@ using namespace llvm;
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 {

2
llvm/lib/Transforms/IPO/PartialInlining.cpp
View File

@ -135,7 +135,7 @@ static cl::opt<int> MaxNumPartialInlining(
// 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"));

6
llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp
View File

@ -144,13 +144,12 @@ static cl::opt<std::string> ClWriteSummary(
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.
@ -158,8 +157,7 @@ static cl::opt<bool>
/// !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,

4
llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp
View File

@ -193,12 +193,12 @@ static cl::opt<bool>
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",

2
llvm/lib/Transforms/Instrumentation/PGOMemOPSizeOpt.cpp
View File

@ -68,7 +68,7 @@ static cl::opt<bool> DisableMemOPOPT("disable-memop-opt", cl::init(false),
// 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"));

2
llvm/lib/Transforms/Scalar/LoopFuse.cpp
View File

@ -128,7 +128,7 @@ static cl::opt<unsigned> FusionPeelMaxCount(
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 {

2
llvm/lib/Transforms/Utils/CodeLayout.cpp
View File

@ -52,7 +52,7 @@ cl::opt<bool> EnableExtTspBlockPlacement(
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.

2
llvm/tools/llc/llc.cpp
View File

@ -213,7 +213,7 @@ static RunPassOption RunPassOpt;
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 &);

2
llvm/tools/llvm-cov/CodeCoverage.cpp
View File

@ -621,7 +621,7 @@ int CodeCoverageTool::run(Command Cmd, int argc, const char **argv) {
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,

7
llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp
View File

@ -46,9 +46,10 @@ static cl::list<std::string> InputFiles(cl::Positional,
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 };

2
llvm/tools/llvm-lto/llvm-lto.cpp
View File

@ -71,7 +71,7 @@ static cl::opt<char>
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",

7
llvm/tools/llvm-lto2/llvm-lto2.cpp
View File

@ -37,9 +37,10 @@ using namespace lto;
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",

2
llvm/tools/llvm-pdbutil/llvm-pdbutil.cpp
View File

@ -521,7 +521,7 @@ cl::opt<bool> DumpIdExtras("id-extras",
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));

8
llvm/tools/llvm-profgen/llvm-profgen.cpp
View File

@ -48,11 +48,9 @@ static cl::opt<std::string> UnsymbolizedProfFilename(
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,

12
polly/lib/Analysis/DependenceInfo.cpp
View File

@ -45,17 +45,17 @@ static cl::opt<int> OptComputeOut(
"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 };

3
polly/lib/Analysis/PolyhedralInfo.cpp
View File

@ -36,8 +36,7 @@ using namespace polly;
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"),

19
polly/lib/Analysis/ScopBuilder.cpp
View File

@ -78,15 +78,14 @@ static unsigned const MaxDimensionsInAccessRange = 9;
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",
@ -106,13 +105,13 @@ static cl::opt<bool>
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",
@ -131,16 +130,16 @@ static cl::opt<std::string> UserContextStr(
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 };

50
polly/lib/Analysis/ScopDetection.cpp
View File

@ -109,8 +109,7 @@ static cl::opt<bool, true> XPollyProcessUnprofitable(
"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",
@ -146,68 +145,63 @@ static cl::opt<std::string> OnlyRegion(
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",
@ -218,20 +212,20 @@ static cl::opt<bool, true>
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;

4
polly/lib/Analysis/ScopGraphPrinter.cpp
View File

@ -23,11 +23,11 @@ using namespace llvm;
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 {

2
polly/lib/Analysis/ScopInfo.cpp
View File

@ -126,7 +126,7 @@ static int const MaxDisjunktsInDefinedBehaviourContext = 8;
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",

7
polly/lib/CodeGen/BlockGenerators.cpp
View File

@ -33,8 +33,7 @@ using namespace polly;
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(
@ -46,13 +45,13 @@ 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,

3
polly/lib/CodeGen/CodeGeneration.cpp
View File

@ -51,8 +51,7 @@ using namespace polly;
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;

7
polly/lib/CodeGen/IslAst.cpp
View File

@ -62,11 +62,10 @@ using IslAstUserPayload = IslAstInfo::IslAstUserPayload;
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(
@ -77,12 +76,10 @@ 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");

6
polly/lib/CodeGen/IslNodeBuilder.cpp
View File

@ -86,7 +86,7 @@ enum class OpenMPBackend { GNU, LLVM };
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
@ -95,12 +95,12 @@ static cl::opt<bool> PollyGenerateRTCPrint(
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:"),

2
polly/lib/CodeGen/ManagedMemoryRewrite.cpp
View File

@ -33,7 +33,7 @@ static cl::opt<bool> RewriteAllocas(
"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",

18
polly/lib/CodeGen/PPCGCodeGeneration.cpp
View File

@ -55,35 +55,29 @@ using namespace llvm;
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;
@ -111,7 +105,7 @@ static cl::opt<std::string> CUDALibDevice(
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",

13
polly/lib/Support/RegisterPasses.cpp
View File

@ -65,12 +65,12 @@ namespace polly {
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,
@ -136,22 +136,21 @@ static cl::opt<VectorizerChoice, true> Vectorizer(
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",

2
polly/lib/Support/SCEVAffinator.cpp
View File

@ -27,7 +27,7 @@ static cl::opt<bool> IgnoreIntegerWrapping(
"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

2
polly/lib/Transform/Canonicalization.cpp
View File

@ -37,7 +37,7 @@ using namespace polly;
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;

2
polly/lib/Transform/ManualOptimizer.cpp
View File

@ -32,7 +32,7 @@ namespace {
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.

20
polly/lib/Transform/MatmulOptimizer.cpp
View File

@ -66,24 +66,24 @@ static cl::opt<int> ThroughputVectorFma(
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
@ -95,36 +95,36 @@ static cl::opt<int> SecondCacheLevelDefaultSize(
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.

33
polly/lib/Transform/ScheduleOptimizer.cpp
View File

@ -74,29 +74,27 @@ class Module;
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",
@ -107,18 +105,17 @@ static cl::opt<std::string> OuterCoincidence(
"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",
@ -136,13 +133,13 @@ static cl::list<int>
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",
@ -153,7 +150,6 @@ static cl::list<int>
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(
@ -172,23 +168,22 @@ static cl::list<int>
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",