Fix warnings about variables that are set but only used in debug mode

[mstorsjo]

Summary

Add void casts to mark the variables used, next to the places where
they are used in assert or LLVM_DEBUG() expressions.

lld/wasm/InputFiles.cpp

void ArchiveFile::parse() {
 
   // Read the symbol table to construct Lazy symbols.
   int count = 0;
   for (const Archive::Symbol &sym : file->symbols()) {
     symtab->addLazy(this, &sym);
     ++count;
   }
   LLVM_DEBUG(dbgs() << "Read " << count << " symbols\n");
+  (void) count;
 }
 
 void ArchiveFile::addMember(const Archive::Symbol *sym) {
   const Archive::Child &c =
       CHECK(sym->getMember(),
             "could not get the member for symbol " + sym->getName());
 
   // Don't try to load the same member twice (this can happen when members

lld/wasm/SyntheticSections.cpp

if (flags & WASM_ELEM_SEGMENT_MASK_HAS_ELEM_KIND) {
     const uint8_t elemKind = 0;
     writeU8(os, elemKind, "elem kind");
   }
 
   writeUleb128(os, indirectFunctions.size(), "elem count");
   uint32_t tableIndex = config->tableBase;
   for (const FunctionSymbol *sym : indirectFunctions) {
     assert(sym->getTableIndex() == tableIndex);
+    (void) tableIndex;
     writeUleb128(os, sym->getFunctionIndex(), "function index");
     ++tableIndex;
   }
 }
 
 DataCountSection::DataCountSection(ArrayRef<OutputSegment *> segments)
     : SyntheticSection(llvm::wasm::WASM_SEC_DATACOUNT),
       numSegments(std::count_if(segments.begin(), segments.end(),

llvm/lib/Analysis/LoopInfo.cpp

for (BasicBlock *POI : Traversal) {
       }
     }
   }
   // Each irreducible loop within the unloop induces a round of iteration using
   // the DFS result cached by Traversal.
   bool Changed = FoundIB;
   for (unsigned NIters = 0; Changed; ++NIters) {
     assert(NIters < Unloop.getNumBlocks() && "runaway iterative algorithm");
+    (void) NIters;
 
     // Iterate over the postorder list of blocks, propagating the nearest loop
     // from successors to predecessors as before.
     Changed = false;
     for (LoopBlocksDFS::POIterator POI = DFS.beginPostorder(),
                                    POE = DFS.endPostorder();
          POI != POE; ++POI) {
 

llvm/lib/CodeGen/MIRFSDiscriminator.cpp

for (MachineInstr &I : BB) {
                         << Discriminator << " -> " << NewD << "\n");
       Changed = true;
     }
   }
 
   if (Changed) {
     createFSDiscriminatorVariable(MF.getFunction().getParent());
     LLVM_DEBUG(dbgs() << "Num of FS Discriminators: " << NumNewD << "\n");
+    (void) NumNewD;
   }
 
   return Changed;
 }

llvm/lib/CodeGen/RegAllocPBQP.cpp

if (PBQPCoalescing)
       ConstraintsRoot->addConstraint(std::make_unique<Coalescing>());
     ConstraintsRoot->addConstraint(Subtarget.getCustomPBQPConstraints());
 
     bool PBQPAllocComplete = false;
     unsigned Round = 0;
 
     while (!PBQPAllocComplete) {
       LLVM_DEBUG(dbgs() << "  PBQP Regalloc round " << Round << ":\n");
+      (void) Round;
 
       PBQPRAGraph G(PBQPRAGraph::GraphMetadata(MF, LIS, MBFI));
       initializeGraph(G, VRM, *VRegSpiller);
       ConstraintsRoot->apply(G);
 
 #ifndef NDEBUG
       if (PBQPDumpGraphs) {
         std::ostringstream RS;

llvm/lib/CodeGen/StackColoring.cpp

for (WinEHTryBlockMapEntry &TBME : EHInfo->TryBlockMap)
       for (WinEHHandlerType &H : TBME.HandlerArray)
         if (H.CatchObj.FrameIndex != std::numeric_limits<int>::max() &&
             SlotRemap.count(H.CatchObj.FrameIndex))
           H.CatchObj.FrameIndex = SlotRemap[H.CatchObj.FrameIndex];
 
   LLVM_DEBUG(dbgs() << "Fixed " << FixedMemOp << " machine memory operands.\n");
   LLVM_DEBUG(dbgs() << "Fixed " << FixedDbg << " debug locations.\n");
   LLVM_DEBUG(dbgs() << "Fixed " << FixedInstr << " machine instructions.\n");
+  (void) FixedMemOp;
+  (void) FixedDbg;
+  (void) FixedInstr;
 }
 
 void StackColoring::removeInvalidSlotRanges() {
   for (MachineBasicBlock &BB : *MF)
     for (MachineInstr &I : BB) {
       if (I.getOpcode() == TargetOpcode::LIFETIME_START ||
           I.getOpcode() == TargetOpcode::LIFETIME_END || I.isDebugInstr())
         continue;

llvm/lib/Target/AArch64/AArch64A53Fix835769.cpp

if (PrevInstr) {
                         << "    CurrInstr: " << *CurrInstr
                         << "    isFirstInstructionInSequence(PrevInstr): "
                         << isFirstInstructionInSequence(PrevInstr) << "\n"
                         << "    isSecondInstructionInSequence(CurrInstr): "
                         << isSecondInstructionInSequence(CurrInstr) << "\n");
       if (isFirstInstructionInSequence(PrevInstr) &&
           isSecondInstructionInSequence(CurrInstr)) {
         LLVM_DEBUG(dbgs() << "   ** pattern found at Idx " << Idx << "!\n");
+        (void) Idx;
         Sequences.push_back(CurrInstr);
       }
     }
     if (!CurrInstr->isPseudo())
       PrevInstr = CurrInstr;
     ++Idx;
   }
 

llvm/lib/Target/X86/X86FastTileConfig.cpp

for (auto II = Cfg; II != MBB->end(); II++) {
 
     if (isTileStore(*II)) {
       assert(KeyMI && "Key AMX Should be found before!");
       break;
     }
 
     if (isAMXInstr(*II)) {
       assert((KeyAMXNum == 0) && "Too many Key AMX instruction!");
+      (void) KeyAMXNum;
       KeyAMXNum++;
       KeyMI = &*II;
     }
   }
   assert(KeyMI && "There must be an AMX instruction.");
   return KeyMI;
 }
 

llvm/lib/Transforms/Instrumentation/PGOInstrumentation.cpp

for (auto &BB : reverse(F)) {
           setEdgeCount(Count->InEdges, Total);
           Changes = true;
         }
       }
     }
   }
 
   LLVM_DEBUG(dbgs() << "Populate counts in " << NumPasses << " passes.\n");
+  (void) NumPasses;
 #ifndef NDEBUG
   // Assert every BB has a valid counter.
   for (auto &BB : F) {
     auto BI = findBBInfo(&BB);
     if (BI == nullptr)
       continue;
     assert(BI->CountValid && "BB count is not valid");
   }

llvm/lib/Transforms/Scalar/GVN.cpp

if (removedBlock)
       ++NumGVNBlocks;
 
     Changed |= removedBlock;
   }
 
   unsigned Iteration = 0;
   while (ShouldContinue) {
     LLVM_DEBUG(dbgs() << "GVN iteration: " << Iteration << "\n");
+    (void) Iteration;
     ShouldContinue = iterateOnFunction(F);
     Changed |= ShouldContinue;
     ++Iteration;
   }
 
   if (isPREEnabled()) {
     // Fabricate val-num for dead-code in order to suppress assertion in
     // performPRE().

llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

for (auto Pair : AllocaMap) {
     } else {
       assert(isa<Argument>(Def));
       Store->insertAfter(cast<Instruction>(Alloca));
     }
   }
 
   assert(PromotableAllocas.size() == Live.size() + NumRematerializedValues &&
          "we must have the same allocas with lives");
+  (void) NumRematerializedValues;
   if (!PromotableAllocas.empty()) {
     // Apply mem2reg to promote alloca to SSA
     PromoteMemToReg(PromotableAllocas, DT);
   }
 
 #ifndef NDEBUG
   for (auto &I : F.getEntryBlock())
     if (isa<AllocaInst>(I))

llvm/lib/Transforms/Utils/SimplifyIndVar.cpp

while (!SimpleIVUsers.empty()) {
     // Try to replace UseInst with a loop invariant before any other
     // simplifications.
     if (replaceIVUserWithLoopInvariant(UseInst))
       continue;
 
     Instruction *IVOperand = UseOper.second;
     for (unsigned N = 0; IVOperand; ++N) {
       assert(N <= Simplified.size() && "runaway iteration");
+      (void) N;
 
       Value *NewOper = foldIVUser(UseInst, IVOperand);
       if (!NewOper)
         break; // done folding
       IVOperand = dyn_cast<Instruction>(NewOper);
     }
     if (!IVOperand)
       continue;

llvm/tools/llvm-tli-checker/llvm-tli-checker.cpp

for (auto &TLIName : TLINames) {
                << YesNo[SDKHas] << ": " << getPrintableName(TLIName.first)
                << '\n';
       }
     }
 
     assert(TLIandSDKboth + TLIandSDKneither + TLIdoesSDKdoesnt +
                TLIdoesntSDKdoes ==
            LibFunc::NumLibFuncs);
+    (void) TLIandSDKneither;
     outs() << "<< Total TLI yes SDK no:  " << TLIdoesSDKdoesnt
            << "\n>> Total TLI no  SDK yes: " << TLIdoesntSDKdoes
            << "\n== Total TLI yes SDK yes: " << TLIandSDKboth;
     if (TLIandSDKboth == 0) {
       outs() << " *** NO TLI SYMBOLS FOUND";
       if (SeparateMode)
         outs() << " in '" << LibList[I] << "'";
     }

llvm/utils/TableGen/CodeGenRegisters.cpp

void CodeGenRegBank::computeRegUnitWeights() {
 
   computeUberWeights(UberSets, *this);
 
   // Iterate over each Register, normalizing the unit weights until reaching
   // a fix point.
   unsigned NumIters = 0;
   for (bool Changed = true; Changed; ++NumIters) {
     assert(NumIters <= NumNativeRegUnits && "Runaway register unit weights");
+    (void) NumIters;
     Changed = false;
     for (auto &Reg : Registers) {
       CodeGenRegister::RegUnitList NormalUnits;
       BitVector NormalRegs;
       Changed |= normalizeWeight(&Reg, UberSets, RegSets, NormalRegs,
                                  NormalUnits, *this);
     }
   }

llvm/utils/TableGen/DFAEmitter.cpp

for (Transition &T : Transitions) {
       if (SeenStates.emplace(NewState).second)
         Worklist.emplace_back(NewState);
       ++NumTransitions;
       Emitter.addTransition(State, NewState, Actions.idFor(T.getActions()));
     }
   }
   LLVM_DEBUG(dbgs() << "  NFA automaton has " << SeenStates.size()
                     << " states with " << NumTransitions << " transitions.\n");
+  (void) NumTransitions;
 
   const auto &ActionTypes = Transitions.back().getTypes();
   OS << "// The type of an action in the " << Name << " automaton.\n";
   if (ActionTypes.size() == 1) {
     OS << "using " << Name << "Action = " << ActionTypes[0] << ";\n";
   } else {
     OS << "using " << Name << "Action = std::tuple<" << join(ActionTypes, ", ")
        << ">;\n";

llvm/utils/TableGen/GlobalISelEmitter.cpp

for (Matcher *Rule : Rules) {
     if (!CurrentGroup->addMatcher(*Rule))
       // If we couldn't add the matcher to an empty group, that group type
       // doesn't support that kind of matchers at all, so just skip it:
       OptRules.push_back(Rule);
   }
   ProcessCurrentGroup();
 
   LLVM_DEBUG(dbgs() << "NumGroups: " << NumGroups << "\n");
+  (void) NumGroups;
   assert(CurrentGroup->empty() && "The last group wasn't properly processed");
   return OptRules;
 }
 
 MatchTable
 GlobalISelEmitter::buildMatchTable(MutableArrayRef<RuleMatcher> Rules,
                                    bool Optimize, bool WithCoverage) {
   std::vector<Matcher *> InputRules;

llvm/utils/TableGen/RegisterInfoEmitter.cpp

for (unsigned i = 0, e = SubRegIndicesSize; i != e; ++i)
       if (Rows[r][i])
         OS << Rows[r][i]->getQualifiedName() << ", ";
       else
         OS << "0, ";
     OS << "},\n";
   }
   OS << "  };\n\n";
 
-  OS << "  --IdxA; assert(IdxA < " << SubRegIndicesSize << ");\n"
+  OS << "  --IdxA; assert(IdxA < " << SubRegIndicesSize << "); (void) IdxA;\n"
      << "  --IdxB; assert(IdxB < " << SubRegIndicesSize << ");\n";
   if (Rows.size() > 1)
     OS << "  return Rows[RowMap[IdxA]][IdxB];\n";
   else
     OS << "  return Rows[0][IdxB];\n";
   OS << "}\n\n";
 }