[NFC][BOLT] Make file-local cl::opt global variables static

Author: chrisPyr

bolt/lib/Core/BinaryContext.cpp

@@ -46,9 +46,10 @@ using namespace llvm;
 
 namespace opts {
 
-cl::opt<bool> NoHugePages("no-huge-pages",
-                          cl::desc("use regular size pages for code alignment"),
-                          cl::Hidden, cl::cat(BoltCategory));
+static cl::opt<bool>
+    NoHugePages("no-huge-pages",
+                cl::desc("use regular size pages for code alignment"),
+                cl::Hidden, cl::cat(BoltCategory));
 
 static cl::opt<bool>
 PrintDebugInfo("print-debug-info",

bolt/lib/Core/BinaryData.cpp

@@ -24,7 +24,7 @@ namespace opts {
 extern cl::OptionCategory BoltCategory;
 extern cl::opt<unsigned> Verbosity;
 
-cl::opt<bool>
+static cl::opt<bool>
     PrintSymbolAliases("print-aliases",
                        cl::desc("print aliases when printing objects"),
                        cl::Hidden, cl::cat(BoltCategory));

bolt/lib/Core/BinaryFunction.cpp

@@ -67,7 +67,7 @@ extern cl::opt<unsigned> Verbosity;
 
 extern bool processAllFunctions();
 
-cl::opt<bool> CheckEncoding(
+static cl::opt<bool> CheckEncoding(
     "check-encoding",
     cl::desc("perform verification of LLVM instruction encoding/decoding. "
              "Every instruction in the input is decoded and re-encoded. "
@@ -144,14 +144,11 @@ cl::opt<bool>
               cl::desc("print time spent constructing binary functions"),
               cl::Hidden, cl::cat(BoltCategory));
 
-cl::opt<bool>
-TrapOnAVX512("trap-avx512",
-  cl::desc("in relocation mode trap upon entry to any function that uses "
-            "AVX-512 instructions"),
-  cl::init(false),
-  cl::ZeroOrMore,
-  cl::Hidden,
-  cl::cat(BoltCategory));
+static cl::opt<bool> TrapOnAVX512(
+    "trap-avx512",
+    cl::desc("in relocation mode trap upon entry to any function that uses "
+             "AVX-512 instructions"),
+    cl::init(false), cl::ZeroOrMore, cl::Hidden, cl::cat(BoltCategory));
 
 bool shouldPrint(const BinaryFunction &Function) {
   if (Function.isIgnored())

bolt/lib/Passes/Aligner.cpp

@@ -25,15 +25,12 @@ extern cl::opt<bool> AlignBlocks;
 extern cl::opt<bool> PreserveBlocksAlignment;
 extern cl::opt<unsigned> AlignFunctions;
 
-cl::opt<unsigned>
-AlignBlocksMinSize("align-blocks-min-size",
-  cl::desc("minimal size of the basic block that should be aligned"),
-  cl::init(0),
-  cl::ZeroOrMore,
-  cl::Hidden,
-  cl::cat(BoltOptCategory));
-
-cl::opt<unsigned> AlignBlocksThreshold(
+static cl::opt<unsigned> AlignBlocksMinSize(
+    "align-blocks-min-size",
+    cl::desc("minimal size of the basic block that should be aligned"),
+    cl::init(0), cl::ZeroOrMore, cl::Hidden, cl::cat(BoltOptCategory));
+
+static cl::opt<unsigned> AlignBlocksThreshold(
     "align-blocks-threshold",
     cl::desc(
         "align only blocks with frequency larger than containing function "
@@ -42,19 +39,17 @@ cl::opt<unsigned> AlignBlocksThreshold(
         "containing function."),
     cl::init(800), cl::Hidden, cl::cat(BoltOptCategory));
 
-cl::opt<unsigned> AlignFunctionsMaxBytes(
+static cl::opt<unsigned> AlignFunctionsMaxBytes(
     "align-functions-max-bytes",
     cl::desc("maximum number of bytes to use to align functions"), cl::init(32),
     cl::cat(BoltOptCategory));
 
-cl::opt<unsigned>
-BlockAlignment("block-alignment",
-  cl::desc("boundary to use for alignment of basic blocks"),
-  cl::init(16),
-  cl::ZeroOrMore,
-  cl::cat(BoltOptCategory));
+static cl::opt<unsigned>
+    BlockAlignment("block-alignment",
+                   cl::desc("boundary to use for alignment of basic blocks"),
+                   cl::init(16), cl::ZeroOrMore, cl::cat(BoltOptCategory));
 
-cl::opt<bool>
+static cl::opt<bool>
     UseCompactAligner("use-compact-aligner",
                       cl::desc("Use compact approach for aligning functions"),
                       cl::init(true), cl::cat(BoltOptCategory));

bolt/lib/Passes/FrameOptimizer.cpp

@@ -43,7 +43,7 @@ FrameOptimization("frame-opt",
   cl::ZeroOrMore,
   cl::cat(BoltOptCategory));
 
-cl::opt<bool> RemoveStores(
+static cl::opt<bool> RemoveStores(
     "frame-opt-rm-stores", cl::init(FOP_NONE),
     cl::desc("apply additional analysis to remove stores (experimental)"),
     cl::cat(BoltOptCategory));

bolt/lib/Passes/PLTCall.cpp

@@ -22,22 +22,16 @@ namespace opts {
 
 extern cl::OptionCategory BoltOptCategory;
 
-cl::opt<bolt::PLTCall::OptType>
-PLT("plt",
-  cl::desc("optimize PLT calls (requires linking with -znow)"),
-  cl::init(bolt::PLTCall::OT_NONE),
-  cl::values(clEnumValN(bolt::PLTCall::OT_NONE,
-      "none",
-      "do not optimize PLT calls"),
-    clEnumValN(bolt::PLTCall::OT_HOT,
-      "hot",
-      "optimize executed (hot) PLT calls"),
-    clEnumValN(bolt::PLTCall::OT_ALL,
-      "all",
-      "optimize all PLT calls")),
-  cl::ZeroOrMore,
-  cl::cat(BoltOptCategory));
-
+static cl::opt<bolt::PLTCall::OptType>
+    PLT("plt", cl::desc("optimize PLT calls (requires linking with -znow)"),
+        cl::init(bolt::PLTCall::OT_NONE),
+        cl::values(clEnumValN(bolt::PLTCall::OT_NONE, "none",
+                              "do not optimize PLT calls"),
+                   clEnumValN(bolt::PLTCall::OT_HOT, "hot",
+                              "optimize executed (hot) PLT calls"),
+                   clEnumValN(bolt::PLTCall::OT_ALL, "all",
+                              "optimize all PLT calls")),
+        cl::ZeroOrMore, cl::cat(BoltOptCategory));
 }
 
 namespace llvm {

bolt/lib/Passes/RetpolineInsertion.cpp

@@ -33,19 +33,17 @@ namespace opts {
 
 extern cl::OptionCategory BoltCategory;
 
-llvm::cl::opt<bool> InsertRetpolines("insert-retpolines",
-                                     cl::desc("run retpoline insertion pass"),
-                                     cl::cat(BoltCategory));
-
-llvm::cl::opt<bool>
-RetpolineLfence("retpoline-lfence",
-  cl::desc("determine if lfence instruction should exist in the retpoline"),
-  cl::init(true),
-  cl::ZeroOrMore,
-  cl::Hidden,
-  cl::cat(BoltCategory));
-
-cl::opt<RetpolineInsertion::AvailabilityOptions> R11Availability(
+static llvm::cl::opt<bool>
+    InsertRetpolines("insert-retpolines",
+                     cl::desc("run retpoline insertion pass"),
+                     cl::cat(BoltCategory));
+
+static llvm::cl::opt<bool> RetpolineLfence(
+    "retpoline-lfence",
+    cl::desc("determine if lfence instruction should exist in the retpoline"),
+    cl::init(true), cl::ZeroOrMore, cl::Hidden, cl::cat(BoltCategory));
+
+static cl::opt<RetpolineInsertion::AvailabilityOptions> R11Availability(
     "r11-availability",
     cl::desc("determine the availability of r11 before indirect branches"),
     cl::init(RetpolineInsertion::AvailabilityOptions::NEVER),

bolt/lib/Passes/StokeInfo.cpp

@@ -21,7 +21,7 @@ using namespace llvm;
 using namespace bolt;
 
 namespace opts {
-cl::OptionCategory StokeOptCategory("STOKE pass options");
+static cl::OptionCategory StokeOptCategory("STOKE pass options");
 
 static cl::opt<std::string>
 StokeOutputDataFilename("stoke-out",

bolt/lib/Passes/TailDuplication.cpp

@@ -26,7 +26,7 @@ namespace opts {
 extern cl::OptionCategory BoltOptCategory;
 extern cl::opt<bool> NoThreads;
 
-cl::opt<bolt::TailDuplication::DuplicationMode> TailDuplicationMode(
+static cl::opt<bolt::TailDuplication::DuplicationMode> TailDuplicationMode(
     "tail-duplication",
     cl::desc("duplicate unconditional branches that cross a cache line"),
     cl::init(bolt::TailDuplication::TD_NONE),

bolt/lib/Profile/StaleProfileMatching.cpp

@@ -52,66 +52,66 @@ cl::opt<bool>
                       cl::desc("Infer counts from stale profile data."),
                       cl::init(false), cl::Hidden, cl::cat(BoltOptCategory));
 
-cl::opt<unsigned> StaleMatchingMinMatchedBlock(
+static cl::opt<unsigned> StaleMatchingMinMatchedBlock(
     "stale-matching-min-matched-block",
     cl::desc("Percentage threshold of matched basic blocks at which stale "
              "profile inference is executed."),
     cl::init(0), cl::Hidden, cl::cat(BoltOptCategory));
 
-cl::opt<unsigned> StaleMatchingMaxFuncSize(
+static cl::opt<unsigned> StaleMatchingMaxFuncSize(
     "stale-matching-max-func-size",
     cl::desc("The maximum size of a function to consider for inference."),
     cl::init(10000), cl::Hidden, cl::cat(BoltOptCategory));
 
 // Parameters of the profile inference algorithm. The default values are tuned
 // on several benchmarks.
-cl::opt<bool> StaleMatchingEvenFlowDistribution(
+static cl::opt<bool> StaleMatchingEvenFlowDistribution(
     "stale-matching-even-flow-distribution",
     cl::desc("Try to evenly distribute flow when there are multiple equally "
              "likely options."),
     cl::init(true), cl::ReallyHidden, cl::cat(BoltOptCategory));
 
-cl::opt<bool> StaleMatchingRebalanceUnknown(
+static cl::opt<bool> StaleMatchingRebalanceUnknown(
     "stale-matching-rebalance-unknown",
     cl::desc("Evenly re-distribute flow among unknown subgraphs."),
     cl::init(false), cl::ReallyHidden, cl::cat(BoltOptCategory));
 
-cl::opt<bool> StaleMatchingJoinIslands(
+static cl::opt<bool> StaleMatchingJoinIslands(
     "stale-matching-join-islands",
     cl::desc("Join isolated components having positive flow."), cl::init(true),
     cl::ReallyHidden, cl::cat(BoltOptCategory));
 
-cl::opt<unsigned> StaleMatchingCostBlockInc(
+static cl::opt<unsigned> StaleMatchingCostBlockInc(
     "stale-matching-cost-block-inc",
     cl::desc("The cost of increasing a block count by one."), cl::init(150),
     cl::ReallyHidden, cl::cat(BoltOptCategory));
 
-cl::opt<unsigned> StaleMatchingCostBlockDec(
+static cl::opt<unsigned> StaleMatchingCostBlockDec(
     "stale-matching-cost-block-dec",
     cl::desc("The cost of decreasing a block count by one."), cl::init(150),
     cl::ReallyHidden, cl::cat(BoltOptCategory));
 
-cl::opt<unsigned> StaleMatchingCostJumpInc(
+static cl::opt<unsigned> StaleMatchingCostJumpInc(
     "stale-matching-cost-jump-inc",
     cl::desc("The cost of increasing a jump count by one."), cl::init(150),
     cl::ReallyHidden, cl::cat(BoltOptCategory));
 
-cl::opt<unsigned> StaleMatchingCostJumpDec(
+static cl::opt<unsigned> StaleMatchingCostJumpDec(
     "stale-matching-cost-jump-dec",
     cl::desc("The cost of decreasing a jump count by one."), cl::init(150),
     cl::ReallyHidden, cl::cat(BoltOptCategory));
 
-cl::opt<unsigned> StaleMatchingCostBlockUnknownInc(
+static cl::opt<unsigned> StaleMatchingCostBlockUnknownInc(
     "stale-matching-cost-block-unknown-inc",
     cl::desc("The cost of increasing an unknown block count by one."),
     cl::init(1), cl::ReallyHidden, cl::cat(BoltOptCategory));
 
-cl::opt<unsigned> StaleMatchingCostJumpUnknownInc(
+static cl::opt<unsigned> StaleMatchingCostJumpUnknownInc(
     "stale-matching-cost-jump-unknown-inc",
     cl::desc("The cost of increasing an unknown jump count by one."),
     cl::init(140), cl::ReallyHidden, cl::cat(BoltOptCategory));
 
-cl::opt<unsigned> StaleMatchingCostJumpUnknownFTInc(
+static cl::opt<unsigned> StaleMatchingCostJumpUnknownFTInc(
     "stale-matching-cost-jump-unknown-ft-inc",
     cl::desc(
         "The cost of increasing an unknown fall-through jump count by one."),