[BOLT][NFC] Rename icf-dfs option variable to ICFUseDFS

[Amir]

Summary

Rename to avoid collision with profile-use-dfs.

bolt/lib/Passes/IdenticalCodeFolding.cpp

 
 using namespace llvm;
 using namespace bolt;
 
 namespace opts {
 
 extern cl::OptionCategory BoltOptCategory;
 
-static cl::opt<bool> UseDFS("icf-dfs",
-                            cl::desc("use DFS ordering when using -icf option"),
-                            cl::ReallyHidden, cl::cat(BoltOptCategory));
+static cl::opt<bool>
+    ICFUseDFS("icf-dfs", cl::desc("use DFS ordering when using -icf option"),
 
 static cl::opt<bool>
 TimeICF("time-icf",
   cl::desc("time icf steps"),
   cl::ReallyHidden,
   cl::ZeroOrMore,
   cl::cat(BoltOptCategory));
 } // namespace opts
if (A.isMultiEntry() || B.isMultiEntry())
     return false;
 
   if (A.hasIslandsInfo() || B.hasIslandsInfo())
     return false;
 
   // Process both functions in either DFS or existing order.
   SmallVector<const BinaryBasicBlock *, 0> OrderA;
   SmallVector<const BinaryBasicBlock *, 0> OrderB;
-  if (opts::UseDFS) {
+  if (opts::ICFUseDFS) {
     copy(A.dfs(), std::back_inserter(OrderA));
     copy(B.dfs(), std::back_inserter(OrderB));
   } else {
     copy(A.getLayout().blocks(), std::back_inserter(OrderA));
     copy(B.getLayout().blocks(), std::back_inserter(OrderB));
   }
 
   const BinaryContext &BC = A.getBinaryContext();
auto hashFunctions = [&]() {
     NamedRegionTimer HashFunctionsTimer("hashing", "hashing", "ICF breakdown",
                                         "ICF breakdown", opts::TimeICF);
     ParallelUtilities::WorkFuncTy WorkFun = [&](BinaryFunction &BF) {
       // Make sure indices are in-order.
       BF.getLayout().updateLayoutIndices();
 
       // Pre-compute hash before pushing into hashtable.
       // Hash instruction operands to minimize hash collisions.
-      BF.computeHash(opts::UseDFS, [&BC](const MCOperand &Op) {
+      BF.computeHash(opts::ICFUseDFS, [&BC](const MCOperand &Op) {
         return hashInstOperand(BC, Op);
       });
     };
 
     ParallelUtilities::PredicateTy SkipFunc = [&](const BinaryFunction &BF) {
       return !shouldOptimize(BF);
     };