reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

  108     assert(EL.empty() && "Expected the list of edges to be empty.");
  112     return !EL.empty();
  217     assert(EL.empty() && "Expected the list of edges to be empty.");
  226     return !EL.empty();

  666     assert(!stack.empty());
  672     assert(!stack.empty());
  676   bool atEnd() const { return stack.empty(); }
  683     assert(!stack.empty());
  685     if (stack.empty())
  708     assert(!stack.empty());
  734     assert(!stack.empty());

  811     return !path.empty() && path.front().offset < path.front().size;

   80     return Vector.empty();

   69     return V.empty();
  151     } while (!V.empty() && V.back() == T());
  172       } while (!V.empty() && V.back() == T());

   73     return vector_.empty();

  156     return Vector.empty() && Set.empty();
  193     while (!Vector.empty()) {

  158     assert(!empty());
  162     assert(!empty());
  167     assert(!empty());
  171     assert(!empty());
  870     if (!RHS.empty())
  880     if (!RHS.empty())
  885     if (!RHS.empty())

  183   bool empty() const { return Dense.empty(); }

  168       return Vec->empty();

  585       assert(CallHandles.empty() && "Must start with a clear set of handles.");

  123     assert(!InstList.empty() && "Instruction List is empty.");

  947       assert(!PostOrderRefSCCs.empty() &&
  953       assert(!PostOrderRefSCCs.empty() &&
 1078     while (!Worklist.empty()) {

  382   bool empty() const { return Pointers.empty(); }

   60     assert(!Subscripts.empty() && "Expecting non-empty container");
   64     assert(!Subscripts.empty() && "Expecting non-empty container");

  330     while (!PreOrderWorklist.empty()) {

  319       assert(!OutsideLoopPreds.empty() && "Loop is unreachable!");
  320     } else if (!OutsideLoopPreds.empty()) {
  555     if (!Backedges.empty()) {
  593     assert(PreOrderWorklist.empty() &&
  602     } while (!PreOrderWorklist.empty());

  234     while (!Worklist.empty()) {

 1305       return !ExitNotTaken.empty() || !isa<SCEVCouldNotCompute>(getMax());

  157       assert(InsertPointGuards.empty());

  576       while (!Worklist.empty() && !Visitor.isDone()) {

  470   while (!BBWorkList.empty() || !ValueWorkList.empty()) {
  470   while (!BBWorkList.empty() || !ValueWorkList.empty()) {
  472     while (!ValueWorkList.empty()) {
  487     while (!BBWorkList.empty()) {

  500     if (BlockScope.empty()) return true;

   73   bool isCollapsed() const { return Instrs.empty(); }

   64     if (OnFailResumeAt.empty())

  433     if (!DeadInsts.empty())

  471     assert(Rules.empty() && "Aliasing will discard rules");

  300     bool hasAtLeastOneValue() const { return !valnos.empty(); }
  373     bool empty() const { return segments.empty(); }

  931     return !LPadToCallSiteMap[Sym].empty();

  187     return DbgValues.empty() && ByvalParmDbgValues.empty() && DbgLabels.empty();
  187     return DbgValues.empty() && ByvalParmDbgValues.empty() && DbgLabels.empty();
  187     return DbgValues.empty() && ByvalParmDbgValues.empty() && DbgLabels.empty();

  905     while (!Worklist.empty()) {

  525          (I == MBBIndexEnd() && !idx2MBBMap.empty())) ? std::prev(I) : I;

   57   bool empty() const { return Macros.empty(); }

  791     return !CI.ParameterEncoding.empty();
  804     assert(!CI.ParameterEncoding.empty() &&

  249     return MCDwarfFiles.empty() || (HasAllMD5 == HasAnyMD5);

   74     assert(!CurTok.empty());
   80     if (CurTok.empty()) {

  200   bool hasPendingError() { return !PendingErrors.empty(); }
  203     bool rv = !PendingErrors.empty();

  347     if (!SectionStack.empty())
  355     if (!SectionStack.empty())
  398     if (SectionStack.empty())

  207     assert(Users.empty() && "Write is in an inconsistent state.");
  384   bool isZeroLatency() const { return !MaxLatency && Resources.empty(); }

  200     if (Slabs.empty())

   98     assert(Bucket.empty() && "Non-empty ArrayRecycler deleted!");

  154     while (!WorkStack.empty()) {
  359     while (!WL.empty()) {
  589     if (Roots.empty()) {
  705     while (!WorkStack.empty()) {

  225     while (!WorkList.empty()) {
  280     assert(Stack.empty());
  299     } while (!Stack.empty());
  372     return !ChildrenGetter<false>::Get(N, BUI).empty();
  581     if (DT.Roots.empty()) return;
  836         if (UnaffectedOnCurrentLevel.empty())
 1224     assert(!BUI.Updates.empty() && "No updates to apply!");
 1241     if (FS.empty()) BUI.FutureSuccessors.erase(CurrentUpdate.getFrom());
 1247     if (FP.empty()) BUI.FuturePredecessors.erase(CurrentUpdate.getTo());
 1265     if (!DT.Parent && !DT.Roots.empty()) {
 1272       if (DT.Roots.empty()) {

  171     while (!Worklist.empty()) {

   36   bool isEmpty() const { return Worklist.empty(); }
   56     assert(Worklist.empty() && "Worklist must be empty to add initial group");

  122     assert(PreOrderLoops.empty() && "Must start with an empty preorder walk.");
  123     assert(PreOrderWorklist.empty() &&
  130     } while (!PreOrderWorklist.empty());

  127     while (!WorkList.empty()) {
  169     while (!RootList.empty()) {
  176     while (!WorkList.empty()) {
  411     while (!WorkList.empty()) {

  172   assert(AssumeHandles.empty() && "Already have assumes when scanning!");

  706   } while (!Worklist.empty() && --MaxLookup);
  709   return Worklist.empty();
 1285       !DecompObject.VarIndices.empty())
 1295   if (!DecompGEP.VarIndices.empty())
 1435   if (GEP1BaseOffset == 0 && DecompGEP1.VarIndices.empty())
 1442   if (GEP1BaseOffset != 0 && DecompGEP1.VarIndices.empty()) {
 1467   if (!DecompGEP1.VarIndices.empty()) {
 1698   if (V1Srcs.empty())
 1944   if (Src.empty())

  216   if (Weights.empty())

  227   if (UnreachableEdges.empty())
  230   if (ReachableEdges.empty()) {
  373   if (ColdEdges.empty())
  376   if (NormalEdges.empty()) {
  528   while (!WorkList.empty()) {
  616   if (BackEdges.empty() && ExitingEdges.empty() && UnlikelyEdges.empty())
  616   if (BackEdges.empty() && ExitingEdges.empty() && UnlikelyEdges.empty())
  616   if (BackEdges.empty() && ExitingEdges.empty() && UnlikelyEdges.empty())
  621   unsigned Denom = (BackEdges.empty() ? 0 : LBH_TAKEN_WEIGHT) +
  622                    (InEdges.empty() ? 0 : LBH_TAKEN_WEIGHT) +
  623                    (UnlikelyEdges.empty() ? 0 : LBH_UNLIKELY_WEIGHT) +
  624                    (ExitingEdges.empty() ? 0 : LBH_NONTAKEN_WEIGHT);

   65   } while (!VisitStack.empty());
  199   } while (!Worklist.empty());
  255     if (Worklist.empty()) {

  546   if (!NewRefSCCs.empty()) {

  249   while (!Worklist.empty()) {

  925         if (!NewIdxs.empty())

   30   assert(IList.empty() && "Expected the IList to be empty on entry.");
   37   return !IList.empty();
   81   assert(InstList.empty() && "Expected empty list.");

  135     if (SrcIList.empty())
  143       if (DstIList.empty())

  204   while (!TaintStack.empty()) {

   97   while (!Worklist.empty()) {

  678   } while (!Inputs.empty());
  801   } while (!Inputs.empty());

  169   while (!Worklist.empty()) {
  273   while (!Worklist.empty()) {
  917   assert(CastInsts.empty() && "CastInsts is expected to be empty.");
  971       if (!CastInsts.empty())

 1710     while (!NewDead.empty()) {

  234   assert(!Nodes.empty() && "Can't have an empty SCC!");
  291   } while (!Worklist.empty());
  308   assert(!SCCs.empty() && "Can't have an empty SCC!");
  388   } while (!Worklist.empty());
  618     } while (!Worklist.empty());
  763     assert(DFSStack.empty() &&
  765     assert(PendingSCCStack.empty() &&
  811             while (!DFSStack.empty())
  868     } while (!DFSStack.empty());
 1034     } while (!Worklist.empty());
 1074     if (MergedSCCs.empty())
 1195     assert(DFSStack.empty() &&
 1197     assert(PendingRefSCCStack.empty() &&
 1259         assert(!DFSStack.empty() &&
 1300     } while (!DFSStack.empty());
 1302     assert(DFSStack.empty() && "Didn't flush the entire DFS stack!");
 1303     assert(PendingRefSCCStack.empty() && "Didn't flush all pending nodes!");
 1304   } while (!Worklist.empty());
 1582     assert(DFSStack.empty() &&
 1584     assert(PendingSCCStack.empty() &&
 1657     } while (!DFSStack.empty());
 1667   assert(RC.SCCs.empty() && "Already built SCCs!");
 1701   if (EntryEdges.empty() || !PostOrderRefSCCs.empty())

  514   while (!BlockValueStack.empty()) {
  528       while (!StartingStack.empty()) {
 1556   assert(BlockValueStack.empty() && BlockValueSet.empty());

  251   assert(Checks.empty() && "Checks is not empty");
  559   bool isDependencyCheckNeeded() { return !CheckDeps.empty(); }

   56   assert(!Loops.empty() && "Expecting a non-empy loop vector");
  308   assert(Subscripts.empty() && "Subscripts should be empty");
  309   assert(Sizes.empty() && "Sizes should be empty");
  336     if (Subscripts.empty() || Sizes.empty() ||
  336     if (Subscripts.empty() || Sizes.empty() ||
  458   assert(!Loops.empty() && "Expecting a non-empty loop vector.");
  512   assert(RefGroups.empty() && "Reference groups should be empty");
  557   if (RefGroups.empty())
  606   assert(!RG.empty() && "Reference group should have at least one member.");

  966   if (!ExitBlocks.empty()) {

  389   while (!LoadOperandsQueue.empty()) {
  834   while (!DirtyBlocks.empty()) {
 1233   while (!Worklist.empty()) {
 1612     while (!ReverseDepsToAdd.empty()) {
 1643     while (!ReverseDepsToAdd.empty()) {
 1686     while (!ReversePtrDepsToAdd.empty()) {

  417   while (!Worklist.empty()) {
  626     assert(!PausedSearches.empty() && "No searches to continue?");
  630     while (!PausedSearches.empty()) {
  746     assert(!Paths.empty() && NP >= &Paths.front() && NP <= &Paths.back() &&
  766     assert(Paths.empty() && VisitedPhis.empty() &&
  783       assert(!Paths.empty() && "Need a path to move");
  853       if (NewPaused.empty()) {
  870       if (!TerminatedPaths.empty()) {
  891       if (!Clobbers.empty()) {
 1154   while (!WorkStack.empty()) {
 1338         !VersionStack.empty() &&

  260   if (!RenameUses && !InsertedPHIs.empty()) {
  416   while (!FixupList.empty()) {
  483     while (!Worklist.empty()) {
  793   if (!RevDeleteUpdates.empty()) {
 1054   if (!BlocksToProcess.empty()) {

   95   while (!Worklist.empty()) {
  587     if (!Types.empty()) {

  169   while (!WorkList.empty()) {

   99   if (!Tmp.empty()) {

   84     while (!Stack.empty() && DepthMap[Stack.back()] >= DepthNumber) {
  117     assert(Stack.empty());

 2411   assert(!Ops.empty() && "Cannot get empty add!");
 2601       if (Ops.empty())
 2707     if (!LIOps.empty()) {
 2912   assert(!Ops.empty() && "Cannot get empty mul!");
 3045     if (!LIOps.empty()) {
 3129         if (SumOps.empty())
 3551   assert(!Ops.empty() && "Cannot get empty (u|s)(min|max)!");
 3661   assert(!Ops.empty() && "Reduced smax down to nothing!");
 4136   assert(!Ops.empty() && "At least one operand must be!");
 4197   while (!Worklist.empty()) {
 4912     assert(!(Rewrite.second).empty() && "Expected to find Predicates");
 6080   while (!PoisonStack.empty() && !LatchControlDependentOnPoison) {
 6707     while (!Worklist.empty()) {
 6803   while (!LoopWorklist.empty()) {
 6829     while (!Worklist.empty()) {
 6868   while (!Worklist.empty()) {
 6896   if (!isComplete() || ExitNotTaken.empty())
11195   if (NewTerms.empty() || !findArrayDimensionsRec(*this, NewTerms, Sizes)) {
11214   if (Sizes.empty())
11324   if (Terms.empty())
11330   if (Sizes.empty())
11336   if (Subscripts.empty())
11373   while (!Worklist.empty()) {
11943   while (!LoopStack.empty()) {

  326   const SCEV *Sum = NoAddRecs.empty() ?
  367   if (!AddRecs.empty()) {
  447         if (!ScaledOps.empty()) {
  458     Value *Scaled = ScaledOps.empty() ?
  470       if (Ops.empty())

  287   while (!WorkList.empty()) {

   92   if (!Assumes.empty())

  343   if (Parameters.empty())

  475   while (!WorkSet.empty()) {
 1937       assert(WorkList.empty() && "Should be!");
 1941       while (!WorkList.empty()) {
 3802   } while (!Worklist.empty());
 3866   } while (!Working.empty());

  406   if (Worklist.empty() || (TTI && !SeenExtFromIllegalType))
  410   while (!Worklist.empty()) {

 2299       if (Indices.empty()) return TokError("expected index");
 2438     if (!ArgList.empty() &&
 2514     if (!BundleList.empty() &&
 2544   if (BundleList.empty())
 3148     if (Elts.empty())
 3177     if (Elts.empty()) {
 6151     if (!Args.empty() &&
 7231   if (!Indices.empty() && !Ty->isSized(&Visited))
 7361   assert(Indexes.empty() && "Expected empty order vector");

  127     if (Stack.empty())
  156     while (!Stack.empty()) {
  167   } while (!Stack.empty());
  216     while (!Stack.empty()) {
  226     if (Stack.empty())

 1967   if (!SSIDs.empty())
 1982       if (SSIDs.empty())
 2370       if (Record.empty())
 2385       if (!CurTy->isIntegerTy() || Record.empty())
 2390       if (!CurTy->isIntegerTy() || Record.empty())
 2400       if (Record.empty())
 2430       if (Record.empty())
 2458       if (Record.empty())
 2467       if (Record.empty())

  150   bool empty() const { return MetadataPtrs.empty(); }
 2014       if (Record.empty())

 2175       if (MDs.empty()) continue;
 2198   if (Names.empty()) return;
 2224   if (Tags.empty())
 2244   if (SSNs.empty())
 4142     if (!NameVals.empty()) {
 4156     if (!NameVals.empty()) {

  599   while (!Worklist.empty())
  622   while (!Worklist.empty()) {
  649     if (Worklist.empty() || Worklist.back().first->isDistinct()) {

   42     if (!Hints.empty()) {

  426   while (!Path.empty() && !indexReallyValid(SubTypes.back(), Path.back() + 1)) {
  432   if (Path.empty())
  478   if (Path.empty())
  499     assert(!Path.empty() && "found a leaf but didn't set the path?");
  701   while (!Worklist.empty()) {
  768   if (EHScopeBlocks.empty())

  192   assert(!DD && Handlers.empty() && "Debug/EH info didn't get finalized");
 1365     assert(!Filename->empty() && "The filename can't be empty.");
 3121   if (Sleds.empty())

 1202   return !Loc.LoadChain.empty() && Loc.LoadChain.back() == 0;
 1255       DR.InMemory = !Location->LoadChain.empty();
 1257           !Location->LoadChain.empty() ? Location->LoadChain.back() : 0;
 1266       if (Var.DefRanges.empty() ||
 1287     if (!R.empty() && R.back().second == Begin)
 1869   if (!ReturnAndArgTypeIndices.empty()) {
 1921   if (!ArgTypeIndices.empty() && ArgTypeIndices.back() == TypeIndex::Void())
 2586   while (!DeferredCompleteTypes.empty()) {
 2621   if (Var.DefRanges.empty())
 3034   if (!GlobalVariables.empty()) {

   60   if (!Entries.empty() && Entries.back().isDbgValue() &&
  121   if (VarSet.empty())

   96   while (!WorkList.empty()) {
  100     if (!Children.empty())
  214     if (Entries.empty())

  328   if (CURanges.empty() || !SameAsPrevCU ||
  735   while (!WorkList.empty()) {
  777   assert(Children.empty());
  799     *HasNonScopeChildren = !Children.empty();

  255   assert(FrameIndexExprs.empty() && "Already initialized?");
  292   assert(!FrameIndexExprs.empty() && "Expected an MMI entry");
  293   assert(!V.FrameIndexExprs.empty() && "Expected an MMI entry");
  491   if (Ranges.empty())
  631     if (ExplicitFwdRegDefs.empty() && ImplicitFwdRegDefs.empty())
  631     if (ExplicitFwdRegDefs.empty() && ImplicitFwdRegDefs.empty())
  643     if (I->getNumExplicitDefs() != 1 || ExplicitFwdRegDefs.empty())
 1099       if (getDwarfVersion() < 5 && !SkeletonHolder.getRangeLists().empty()) {
 1452     if (OpenRanges.empty())
 1521     if (HistoryMapEntries.empty())
 1941   if (getUnits().empty())
 2222   assert(!Values.empty() &&
 2668   if (Holder.getRangeLists().empty())
 2697   if (Holder.getRangeLists().empty())
 2882   if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
 2891   bool TopLevelType = TypeUnitsUnderConstruction.empty();
 2966   assert(TypeUnitsUnderConstruction.empty() || !DD->AddrPool.hasBeenUsed());

  141     assert(FrameIndexExprs.empty() && "Already initialized?");
  152     assert(FrameIndexExprs.empty() && "Already initialized?");
  181   bool hasFrameIndexExprs() const { return !FrameIndexExprs.empty(); }
  212     assert((FrameIndexExprs.empty() ||
  216     return !FrameIndexExprs.empty();

  685   if (!FuncInfo.CxxUnwindMap.empty())
  688   if (!FuncInfo.TryBlockMap.empty())
  691   if (!IPToStateTable.empty())
  782       if (!TBME.HandlerArray.empty())
 1041   assert(!FuncInfo.SEHUnwindMap.empty());
 1177     assert(HandlerStack.empty());
 1216     assert(HandlerStack.empty());

  204       MadeChange |= MBB.CorrectExtraCFGEdges(TBB, FBB, !Cond.empty());
  524     if (TBB == NextBB && !Cond.empty() && !FBB) {
 1178         if (!Cond.empty() && TBB == IBB) {
 1190         if (TBB && (Cond.empty() || FBB)) {
 1193           if (!Cond.empty())
 1452                                               !PriorCond.empty());
 1475     if (PriorCond.empty() && !PriorTBB && MBB->pred_size() == 1 &&
 1547     if (MBB->succ_empty() && !PriorCond.empty() && !PriorFBB &&
 1595       if (PredAnalyzable && !PredCond.empty() && PredTBB == MBB &&
 1626     MadeChange |= MBB->CorrectExtraCFGEdges(CurTBB, CurFBB, !CurCond.empty());
 1647     if (CurTBB && CurCond.empty() && !CurFBB &&
 1677               assert(PriorCond.empty() && !PriorFBB &&
 1970   if (TII->analyzeBranch(*MBB, TBB, FBB, Cond, true) || !TBB || Cond.empty())

  100   if (SetjmpCalls.empty())

  242   } while (!Stack.empty());

  633   while (!LoopList.empty()) {
 1916         while (!PtrOps.empty()) {
 2725   return !Actions.empty() ? Actions.back().get() : nullptr;
 2737   while (!Actions.empty() && Point != Actions.back().get()) {
 3004     while (!WorkList.empty()) {
 3111     if (AddrModes.empty()) {
 3289     while (!WorkList.empty()) {
 3383     while (!TraverseOrder.empty()) {
 3424     while (!Worklist.empty()) {
 4678   while (!worklist.empty()) {
 5723   while (!WorkList.empty()) {
 6312     if (InstsToBePromoted.empty())
 6528     if (InstsToBePromoted.empty() || !CombineInst)

  194   if (Resumes.empty())

  394     while (!Reads.empty())
  494   if (Cond.empty()) {

   26   DomainValue *dv = Avail.empty() ? new (Allocator.Allocate()) DomainValue
  116   while (!dv->Instrs.empty())
  350   while (!Regs.empty()) {

  226       (LoadSequence.empty() || LoadSequence.size() > 2)) {
  230     if (!OverlappingLoads.empty() &&
  231         (LoadSequence.empty() ||

  167                    Offsets->empty() ? Offsets : nullptr);
  190                    Offsets->empty() ? Offsets : nullptr);
  498   while (!WorkList.empty()) {
 1030     if (!Regs.empty())
 1863     if (Regs.empty()) {
 1887     if (Regs.empty()) {
 2083   if (Offsets && !Offsets->empty())
 2252   assert(PendingPHIs.empty() && "stale PHIs");

  217     assert(RetryList.empty() && "Expected no instructions in RetryList");
  248     if (!RetryList.empty()) {
  250         while (!RetryList.empty())

  183   if (Rules.empty()) {
  206   if (Rules.empty()) {
  229   if (Rules.empty()) {

  291   assert(!PossibleMappings.empty() &&
  637     if (PossibleMappings.empty())

  274   while (!SeenOpcodes.empty()) {

  687       if (TrueBBI.TrueBB && TrueBBI.BrCond.empty())
 1060   bool AlreadyPredicated = !BBI.Predicate.empty();
 1217   while (!BBStack.empty()) {
 1238       if (!BBI.IsBrAnalyzable || BBI.BrCond.empty() || BBI.IsDone) {
 1284     bool TNeedSub = !TrueBBI.Predicate.empty();
 1285     bool FNeedSub = !FalseBBI.Predicate.empty();

  307   if (!NullCheckList.empty())
  310   return !NullCheckList.empty();

  108   if (IndirectBrs.empty())
  157   if (BBs.empty()) {

  481   } while (!WorkList.empty());
  517   } while (!WorkList.empty());
  684   if (DeadDefs.empty())
  832   if (FoldOps.empty())
 1086   if (!DeadDefs.empty()) {
 1125   assert(DeadDefs.empty() && "Previous spill didn't remove dead defs");
 1131   if (!RegsToSpill.empty())
 1502     if (!SpillsToIns.empty() || !SpillsToRm.empty())

  305   if (Shuffles.empty())

  238   while (!WorkStack.empty()) {
  332   if (!Children.empty())

  765   if (Kills.empty())
  802   if (CopyValues.empty())

  121     if (segments().empty())
  137     if (segments().empty())
  523     } while (!valnos.empty() && valnos.back()->isUnused());
  560   assert(segments.empty() || segments.back().end <= S.start);
  807       segments.empty() &&
 1185     assert(Spills.empty() && "Leftover spilled segments");
 1226   if (!Spills.empty() && coalescable(Spills.back(), Seg)) {
 1286   if (Spills.empty()) {

  385   while (!WorkList.empty()) {
  760         if (!SRs.empty()) {

  134   assert(MainRange.segments.empty() && MainRange.valnos.empty() &&
  134   assert(MainRange.segments.empty() && MainRange.valnos.empty() &&

  399     while (!Dead.empty())
  434     if (!SplitLIs.empty())

  488   while (!Defs.empty()) {
  588   if (!PHIVarInfo[MBB->getNumber()].empty()) {

   41     while (!Workqueue.empty()) {

  899   if (!Operands.empty() && expectAndConsume(MIToken::equal))
  988   if (!MemOperands.empty())

  544   if (Cond.empty()) {
  863   if (Cond.empty()) return nullptr;
  994     while (!KilledRegs.empty()) {

  272     assert(!Blocks.empty() && "Can't merge into an empty chain.");
 1593   if (WorkList.empty())
 2470   assert(BlockWorkList.empty() &&
 2472   assert(EHPadWorkList.empty() &&
 2596   assert(BlockWorkList.empty() &&
 2598   assert(EHPadWorkList.empty() &&
 2721       if (TBB && !Cond.empty() && FBB &&

  688         while (!PhysDefs.empty()) {
  753   } while (!WorkList.empty());
  864   } while (!BBs.empty());

  278   assert(!InsInstrs.empty() && "Only support sequences that insert instrs.");
  475     if (InsInstrs.empty() || !TSchedModel.hasInstrSchedModelOrItineraries())

   88   if (CriticalEdgesToSplit.empty())

  746       if (LandingPads[i].BeginLabels.empty()) {

 1828   while (!DeadOps.empty()) {
 1893   while (!DeadOps.empty()) {

  341   while (!Worklist.empty()) {
  682   while (!WorkList.empty()) {
  817     if (!TII->analyzeBranch(*BB, TBB, FBB, Cond, false) && Cond.empty())
 1085   } while (!Work.empty());

  490     if (SSNs.empty())

  609   while (!Worklist.empty()) {
  671       if (Objs.empty())
  680       if (Objs.empty())
 2344   while (!Worklist.empty()) {
 2367   while (!Worklist.empty()) {

 1292     assert((!UsedOpsInCopy.empty() && !DefedRegsInCopy.empty()) &&
 1292     assert((!UsedOpsInCopy.empty() && !DefedRegsInCopy.empty()) &&

  548     } while (!WorkList.empty());
  573     } while (!WorkList.empty());
  859   while (!Stack.empty()) {
 1044   for (;!Stack.empty(); Stack.pop_back()) {
 1079         if (!Deps.empty()) {

  702       if (!Cond.empty()) {
  706     } else if (TBB && !FBB && Cond.empty()) {
  729     } else if (TBB && !FBB && !Cond.empty()) {
  788       if (Cond.empty()) {
 2107   while (!regMasks.empty()) {

  103         if (SU.Succs.empty())

 1418       Defaults.resize(Defaults.size() + StageDiff, Defaults.empty()

  554   if (ExtendLife && !ExtendedUses.empty())
  560   if (!Uses.empty()) {
  743   } while (!SrcToLook.empty());
  758   assert(!SrcRegs.empty() && "No sources to create a PHI instruction?");

  490   while (!WorkList.empty()) {
 1036   if (!ObjectsToAllocate.empty() &&

  223   assert(!Intfs.empty() && "expected interference");

 2473     if (PhysReg || !NewVRegs.empty())
 2499     if (PhysReg || !NewVRegs.empty())
 2983   } while (!RecoloringCandidates.empty());
 3048         NewVRegs.empty()) {
 3051       if (CSRReg || !NewVRegs.empty())
 3084   assert((NewVRegs.empty() || Depth) && "Cannot append to existing NewVRegs");

  735       AnotherRoundNeeded |= !NewVRegs.empty();

 1506     if (!DeadDefs.empty())
 2864     assert(!TaintExtent.empty() && "There should be at least one conflict.");
 3255   if (EndPoints.empty())
 3385   while (!ShrinkRegs.empty())
 3397   if (!EndPoints.empty()) {
 3482     if (!DeadDefs.empty())
 3637   assert(WorkList.empty() && LocalWorkList.empty() && "Old data still around.");
 3637   assert(WorkList.empty() && LocalWorkList.empty() && "Old data still around.");

  325   assert(P.LiveInRegs.empty() && "inconsistent max pressure result");
  337   assert(P.LiveOutRegs.empty() && "inconsistent max pressure result");

  288   while (!WorkList.empty()) {
  761   if (StaticAllocas.empty() && DynamicAllocas.empty() &&
  761   if (StaticAllocas.empty() && DynamicAllocas.empty() &&
  762       ByValArguments.empty() && StackRestorePoints.empty())
  762       ByValArguments.empty() && StackRestorePoints.empty())
  765   if (!StaticAllocas.empty() || !DynamicAllocas.empty() ||
  765   if (!StaticAllocas.empty() || !DynamicAllocas.empty() ||
  766       !ByValArguments.empty())
  769   if (!StackRestorePoints.empty())
  819       IRB, F, StackRestorePoints, StaticTop, !DynamicAllocas.empty());

   75     while (!WorkList.empty()) {

   57     unsigned LastRegionEnd = Regions.empty() ? 0 : Regions.back().End;
   93   unsigned LastRegionEnd = Regions.empty() ? 0 : Regions.back().End;

   71   unsigned getFrameSize() { return Regions.empty() ? 0 : Regions.back().End; }

  229   } while (!WorkList.empty());
  244   } while (!WorkList.empty());
  291   } while (!WorkList.empty());
  322   } while (!WorkList.empty());
  488       assert(SU.Succs.empty() && "SUnit should have no successors");

  200       while (!N && !Worklist.empty()) {
 1868     if (Ops.empty()) {
15437   while (!Worklist.empty()) {
16346   while (!Chains.empty()) {
20663   while (!Chains.empty()) {

  969   if (!UsedRegs.empty() || II.getImplicitDefs() || II.hasOptionalDef())

 1425   if (!Stores.empty())    // Not all undef elements?
 3711   if (Results.empty() && Node->isStrictFPOpcode()) {
 3739   if (Results.empty()) {
 4104   if (!Results.empty()) {
 4578   if (!Results.empty()) {

  214   while (!Worklist.empty()) {
  888   if (Results.empty())
  923   if (Results.empty())

   51     bool empty() const { return Queue.empty(); }
  518   return !LRegs.empty();
  533     assert(RootSU->Succs.empty() && "Graph root shouldn't have successors!");

  368   assert(Interferences.empty() && LRegsMap.empty() && "stale Interferences");
 1431   return !LRegs.empty();
 1604     assert(RootSU->Succs.empty() && "Graph root shouldn't have successors!");
 1612   while (!AvailableQueue->empty() || !Interferences.empty()) {
 1955   while (!WorkList.empty()) {

  346   while (!Worklist.empty()) {
  422   while (!CallSUnits.empty()) {
  684   while (!GluedNodes.empty()) {
  906     while (!GluedNodes.empty()) {

  175     if (SUnits[i].Preds.empty()) {

  701   while (!DeadNodes.empty()) {

  804   if (ValueVTs.empty())
  951   else if (!Regs.empty() && Register::isVirtualRegister(Regs.front())) {
 1035   if (PendingLoads.empty())
 1055   if (PendingExports.empty())
 3031   while (!UsersToVisit.empty()) {
 4081       assert(PendingLoads.empty() && "PendingLoads must be serialized first");
 8227         if (OpInfo.AssignedRegs.Regs.empty()) {
 8374       if (OpInfo.AssignedRegs.Regs.empty()) {
 8392       if (!OpInfo.AssignedRegs.Regs.empty())
 8458       if (OpInfo.AssignedRegs.Regs.empty())
 8498   if (!ResultValues.empty()) {
 8510   if (!OutChains.empty())
 8514   if (ResultValues.empty() || HasSideEffect || !OutChains.empty() || IsCallBr)
 8514   if (ResultValues.empty() || HasSideEffect || !OutChains.empty() || IsCallBr)
 8528   if (ValueVTs.empty())
 9267   assert((!CLI.IsTailCall || InVals.empty()) &&
 9348     if (ReturnValues.empty())
 9838     if (ArgValues.empty())
 9896   if (!Chains.empty()) {
 9908   if (!DbgDeclareInfo.empty() && !ArgCopyElisionFrameIndexMap.empty()) {
10566   while (!WorkList.empty()) {

  564   if (!FuncInfo->ArgDbgValues.empty())
  774   } while (!Worklist.empty());
 1066   while (!Nodes.empty()) {
 1133       while (!Nodes.empty()) {
 2289   if (!ChainNodesMatched.empty()) {
 2328   if (!NowDeadNodes.empty())
 2374   while (!Worklist.empty())
 2934       NewEntry.HasChainNodesMatched = !ChainNodesMatched.empty();
 3000       assert(!NodeStack.empty() && "Node stack imbalance!");
 3257       assert(ChainNodesMatched.empty() &&
 3293       assert(ChainNodesMatched.empty() &&
 3312       if (ChainNodesMatched.empty())
 3507       LLVM_DEBUG(if (!MatchedMemRefs.empty() && Res->memoperands_empty()) dbgs()
 3577       if (MatchScopes.empty()) {

  282     while (!GluedNodes.empty()) {
  286       if (!GluedNodes.empty())

   74   assert(PendingGCRelocateCalls.empty() &&
   88   assert(PendingGCRelocateCalls.empty() &&
  506     assert(SI.Bases.empty() && "No gc specified, so cannot relocate pointers!");
  507     assert(SI.Ptrs.empty() && "No gc specified, so cannot relocate pointers!");

  138   while (!UseWorkList.empty()) {
  291       while (!Users.empty()) {
  375   if (Invokes.empty())

   56   assert(idx2MBBMap.empty() &&
   58   assert(MBBRanges.empty() &&

  329   return !RecentPositive.empty();

   97     if (EHPadSuccessors.empty())
  166   assert(UseSlots.empty() && "Call clear first");
 1429   if (Dead.empty())
 1467   } while(!WorkList.empty());

 1035             if (Objs.empty())

  121   if (SwiftErrorVals.empty())
  153   if (SwiftErrorVals.empty())
  214         assert(!VRegs.empty() &&
  229         assert(!VRegs.empty() &&
  262   if (!TLI->supportSwiftError() || SwiftErrorVals.empty())

  185   if (!SSAUpdateVRs.empty()) {
  692     if (!PredCond.empty())
  727     if (PredCond.empty())
  782   if (!PredCond.empty())
  886       PriorCond.empty() &&

  800   if (!VirtRegPairs.empty()) {
  803     while (!VirtRegPairs.empty()) {

  575       while (!SuperKills.empty())
  578       while (!SuperDeads.empty())
  581       while (!SuperDefs.empty())

  156   while (!WL.empty()) {
  217   if (CatchPads.empty() && CleanupPads.empty())
  217   if (CatchPads.empty() && CleanupPads.empty())

  430   if (!FuncInfo.SEHUnwindMap.empty())
  526   while (!Worklist.empty()) {
  914       if (UsesToRename.empty())
  925       while (!UsesToRename.empty())
 1118   while (!Worklist.empty()) {

   27   assert(!Limits.empty() && "Not in a record!");
   61   assert(!Limits.empty() && "Not in a record!");

  405   if (Refs.empty())

  875   if (NameIndices.empty())

  875   if (!NormalUnits.empty())
  887   if (!DWOUnits.empty())
  955   if (InlinedChain.empty())

  304   if (!AugmentationData.empty()) {

  650   assert(InlinedChain.empty());

 1188       if (Result.empty() || Result[0] != Str)
 1336   if (EntryNames.empty())

  174   if (!InjectedSources.empty()) {

  477       while (!BlockSyms.empty()) {

   99   if (IBBs.empty())
  291   if (CallerBlocks.empty())

 1855     if (!PendingRelocs.empty())

   79   if (!MAttrs.empty()) {

 1711   if (Extra || SplitFlags.empty())
 1735   if (Extra || SplitFlags.empty())
 2488     if (SSNs.empty())
 4089   if (MDs.empty())
 4092   if (MDNames.empty())

 2453   if (!NewIdxs.empty()) {

  471   while (!WorkList.empty()) {

  382     assert(Storage.empty() && "Expected empty storage");
  493     assert(Storage.empty() && "Expected empty storage");

   87   if (!RetainValues.empty())
   97   if (!AllGVs.empty())
  100   if (!AllImportedModules.empty())

  573   while (!ToVisit.empty()) {

 1062   if (Ops.empty())

  339     if (!Name.empty())
  342     if (!Name.empty())
 1063   if (!ArgTys.empty() && ArgTys.back()->isVoidTy()) {

 1179   bool empty() const { return Attachments.empty(); }
 1222   bool empty() const { return Attachments.empty(); }

 1027   if (PassDebugging >= Details && !DeadPasses.empty()) {
 1117   if (!TransferLastUses.empty()) {
 1305   if (Set.empty())

  969   if (!EndPoints.empty())

  163     while (!NewDead.empty()) {
  335   while(!Worklist.empty()) {

  113   } while (!TypeWorklist.empty());

 1884   while (!Stack.empty()) {
 2232   assert(F.hasMetadata() != MDs.empty() && "Bit out-of-sync");
 2246     Assert(MDs.empty(), "unmaterialized function cannot have metadata", &F,
 2247            MDs.empty() ? nullptr : MDs.front().second);
 3770   while (!Worklist.empty()) {
 3883       while (!Worklist.empty()) {
 5085   if (DeoptimizeDeclarations.empty())

  334   if (!DwoFile.empty()) {

  354     if (EntryPath.empty())
  369     if (EntryPath.empty())

   81   assert(SpeculativeTypes.empty());
   82   assert(SpeculativeDstOpaqueTypes.empty());
 1164       if (!AllImportedModules.empty())

   27   if (Entries.empty())
   57 bool ConstantPool::empty() { return Entries.empty(); }

  366   if (CommentToEmit.empty() && CommentStream.GetNumBytesInBuffer() == 0) {

  314   if (Windows.empty())
  331   if (Window.empty())

  195   if (Files.empty())

  628   if (FileNameBuf.empty() || FileNameBuf == "-")

  436   MCOS->EmitULEB128IntValue(MCDwarfFiles.empty() ? 1 : MCDwarfFiles.size());
  570   if (MCDwarfFiles.empty()) {
  579     FileNumber = MCDwarfFiles.empty() ? 1 : MCDwarfFiles.size();
 1022   assert(MCDwarfFiles.empty() || MCDwarfFiles.size() >= 2);
 1024       MCDwarfFiles.empty()

  652     assert(!BundleGroups.empty() && "There are no bundle groups");

   46   if (PendingLabels.empty())

   59   if (Subsection == 0 && SubsectionFragmentMap.empty())

  813   if (DataSegments.empty())
  853   if (DataSegments.empty())

  490   bool UsesResources = !ID.Resources.empty();
  676   if (D.Writes.empty())

   38   assert(!Stages.empty() && "Unexpected empty pipeline found!");
   77   if (!Stages.empty()) {

  568   if (!StringTableBuf.empty())

 3055   assert(!Stack.empty() && "ExportEntry::moveNext() with empty node stack");
 3065   while (!Stack.empty()) {

 1658     if (WorkList.empty())

 1637   if (!Callbacks.empty()) {

  147   assert(ModuleDescStack.empty() && "ModuleDescStack is not empty at exit");
  161   assert(!ModuleDescStack.empty() && "empty ModuleDescStack");

  271     if (RecordIndices.empty() || RecordIndices.back() != RecordIndex)
  338   if (Readers.empty() && !ObjectFilenames.empty())
  488         startSegment(ActiveRegions.empty() ? CR.value() : *ActiveRegions.back(),
  504     if (!ActiveRegions.empty())

  414   if (!SrcEdges.empty()) {
  420   if (!DstEdges.empty()) {
  426   if (!Lines.empty()) {

  238   assert(!FilenameBuf.empty() && "The filename can't be empty.");

 3553   assert(!buffer.empty() && "no characters in buffer!");

  689       if (!Indicies.empty())

  302     return (!Sub.OptionsMap.empty() || !Sub.PositionalOpts.empty() ||
  447   assert(!Categories.empty() && "Categories cannot be empty.");
  815     if (Token.empty()) {
  852       if (!Token.empty())
  863   if (!Token.empty())
  988   if (!Token.empty())
 1313   if (!PositionalOpts.empty()) {
 1382       if (!PositionalOpts.empty()) {
 1437       if (!Handler && SinkOpts.empty())
 1443       if (SinkOpts.empty()) {
 1544     if (PositionalOpts.size() == 1 && ValNo == 0 && !PositionalVals.empty()) {
 2129     if (Sub == &*TopLevelSubCommand && !Subs.empty()) {

  144   assert(DstUTF16.empty());

  669   assert(!MatchInfo.empty() && "Didn't get any match");

   19   assert(!path.empty() && "Can't replace missing root");

  661   assert(!Stack.empty());
  679   assert(!Stack.empty());

  432         !path.empty() && is_separator(path[path.size() - 1], style);
  446         !(path.empty() || has_root_name(component, style))) {
  533   if (Path.empty())
  700       if (!components.empty() && components.back() != "..") {

   72     assert(!Stack.empty() && "Must call begin() first");
   77     assert((Entries.empty() ||
  107     assert(Stack.empty() &&

  710   if (Path.empty())
  820   if (Path.empty())
  962   if (!Path.empty())
 1386           assert(!FullPath.empty() &&
 1641   if (Path.empty())
 1928       DirStack.empty() ? Path : containedPart(DirStack.back(), Path);
 1997         while (!DirStack.empty() && !containedIn(DirStack.back(), Dir)) {
 2014     while (!DirStack.empty()) {

 1000   if (!SimpleKeys.empty() && (SimpleKeys.end() - 1)->FlowLevel == Level)
 1220   if (!SimpleKeys.empty()) {

  376     if (!StringStorage.empty()) {
  408       if (!StringStorage.empty()) {
  709   if (!StateStack.empty())
  714   unsigned Indent = StateStack.empty() ? 1 : StateStack.size();
  757   if (StateStack.empty() || (!inFlowSeqAnyElement(StateStack.back()) &&

  248   while (!Stack.empty()) {

  604   if (Result.TemplateArgs.empty()) {
  649   if (Result.TemplateArgs.empty()) {
  754   if (Ranges.empty()) return true;
  776   if (Ranges.empty()) return true;
 1837     if (Args.empty()) return nullptr;
 1886       if (Vals.empty()) return nullptr;
 1950       if (Vals.empty()) return nullptr;
 2049       if (DagArgs.empty()) return nullptr;
 2121       if (Ranges.empty()) return nullptr;
 2144       if (Ranges.empty()) return nullptr;
 2497   if (!Ranges.empty()) {
 2913   if (LetInfo.empty()) return true;

  565   if (OutArgs.empty())

  376     if (HeadCond.empty() || !parseCond(HeadCond, HeadCmp)) {
  381     if (TrueCond.empty() || !parseCond(TrueCond, TrueCmp)) {

  510   if (!TBB || HeadCond.empty()) {
  537   if (!TBB || CmpBBCond.empty()) {

 3470   if (!MemOps.empty()) {
 3618   if (isVarArg && !Outs.empty()) {
 3653   if (Outs.empty())
 3912         assert(!Ins.empty() && Ins[0].VT == MVT::i64 &&
 4009   if (!MemOpChains.empty())
 4138   if (!Ins.empty())

  347         while (!toDel.empty()) {

  570   if (Updates.empty())

  367   if (KnownRegs.empty())
  445     if (KnownRegs.empty())

  194   if (analyzeBranchCondCode.empty())

  185     if (Ranges.empty()) {
  631     if (UnrecognizedLifetimes.empty() && Info.LifetimeStart.size() == 1 &&

  202   if (ReTags.empty())

 4494   assert(!Operands.empty() && "Unexpect empty operand list!");

   66   while (!Stack.empty()) {

  115   while (!Stack.empty()) {

   95   const bool Changed = !ToReplace.empty();

 1532     if (!GEPInfo.VgprParts.empty())
 1882   if (AddrInfo.empty() || AddrInfo[0].SgprParts.size() != 1)
 1903   if (AddrInfo.empty() || AddrInfo[0].SgprParts.size() != 1)
 1928   if (AddrInfo.empty() || AddrInfo[0].SgprParts.size() != 1)

  581   if (Printfs.empty())

  249       while (!ToReplace.empty()) {

 1052   if (SrcRegs.empty()) {
 1142   if (!SrcReg.empty()) {
 1346     if (DefRegs.empty()) {
 1347       assert(Src1Regs.empty() && Src2Regs.empty());
 1347       assert(Src1Regs.empty() && Src2Regs.empty());
 1352     if (Src0Regs.empty())
 1358     if (Src1Regs.empty())
 1364     if (Src2Regs.empty())
 1394     if (DefRegs.empty()) {
 1395       assert(Src0Regs.empty() && Src1Regs.empty());
 1395       assert(Src0Regs.empty() && Src1Regs.empty());
 1401            (Src0Regs.empty() || Src0Regs.size() == 2));
 1408     if (Src0Regs.empty())
 1413     if (Src1Regs.empty())
 1656     if (DstRegs.empty()) {
 1722     if (InsRegs.empty()) {

  257   if (OutArgs.empty())
  270   if (Returns.empty())

  796     while (!Preds.empty()) {
  816     while (!Worklist.empty() && MaxChain-- > 0) {

  105   while (!Stack.empty()) {
  211   if (!UnreachableBlocks.empty()) {
  228     if (!ReturningBlocks.empty()) {
  253   if (ReturningBlocks.empty())

 1042   assert(!ExitingMBBs.empty() && "Infinite Loop not supported");

  450   while (!Uses.empty()) {
  535   Rollback |= !Uses.empty();
  546       while (!S.second.empty())

  198   while (!Worklist.empty()) {

  292     if (Intervals.empty())

  659   while (!BankStalls.empty()) {

  505   assert(!Regions.empty());
  527   if (!Regions.empty())

  169   return !Stack.empty() && Stack.back().first == BB;
  364   if (!Stack.empty()) {

  367   while (!Worklist.empty()) {

   92   while (!Worklist.empty()) {

 2236   return Chains.empty() ? Chain :
 2274   Info->setIfReturnsVoid(Outs.empty());
 2636   if (Outs.empty())
 2879   if (!MemOpChains.empty())
 2972   if (!Ins.empty())

  451     if (!ExecBranchStack.empty() && ExecBranchStack.back() == &MBB) {
  456     if (HaveKill && ExecBranchStack.empty()) {
  492         if (ExecBranchStack.empty()) {

 2006   if (TBB != MaskBrDest || Cond.empty())

  165   while (!Worklist.empty()) {

  155     assert(Stack.empty());
  193     while (!Stack.empty()) {
  380     while (!Stack.empty()) {

  237   assert(SaveBlocks.empty() && RestoreBlocks.empty());
  237   assert(SaveBlocks.empty() && RestoreBlocks.empty());

  336   if (!Spill.Lanes.empty())

  333       while (!Blocks.empty()) {

 1253       Changed = !ConvertedInstructions.empty();
 1257       while (!ConvertedInstructions.empty())

  895     if (!(GlobalFlags & StateWWM) && LowerToCopyInstrs.empty())
  896       return !LiveMaskQueries.empty();
  902     if (GlobalFlags & StateExact || !LiveMaskQueries.empty()) {

  306   if (!MemOpChains.empty())
  411   if (!MemOpChains.empty())
  556   if (!CFRegNode.empty())
  580   if (!MemOps.empty()) {
  655   if (!MemOpChains.empty())

  202       if (!Cond.empty())

  169   if (! ThumbIndirectPads.empty()) {
 1130           assert(RegList.empty() &&

  348       if (!Cond.empty())

  406   if (!T2JumpTables.empty())
 2412   if (!B && Cond.empty() && BB != &MF->front() &&

 1016     if (Regs.empty())
 1112     if (Regs.empty())
 2006       for (; RegDeficit > 0 && !AvailableRegs.empty(); --RegDeficit) {
 2050       if (CS1Spilled && !UnspilledCS1GPRs.empty()) {
 2068       } else if (!UnspilledCS2GPRs.empty() && !AFI->isThumb1OnlyFunction()) {
 2088       while (NumExtras && !UnspilledCS1GPRs.empty()) {
 2099         while (NumExtras && !UnspilledCS2GPRs.empty()) {
 2305   } while (!WalkList.empty());

 2066   bool isStructRet = (Outs.empty()) ? false : Outs[0].Flags.isSRet();
 2186         assert(!Ins.empty() && Ins[0].VT == MVT::i32 &&
 2253   if (!MemOpChains.empty())
 2440   if (!Ins.empty())
 2624   if (!Outs.empty()) {
 3302   while (!Worklist.empty()) {
 3925   if (!MemOps.empty())
 9820     while (!Successors.empty()) {

  407     if (Libcalls.empty()) {

  963     assert(ImpDefs.empty());

  532     if (Starts.empty() && Decs.empty() && Ends.empty())
  532     if (Starts.empty() && Decs.empty() && Ends.empty())
  532     if (Starts.empty() && Decs.empty() && Ends.empty())

  369   if (Loads.empty() || Loads.size() > NumLoadLimit)
  622   return !R.getMulPairs().empty();

  122   bool hasFnStart() const { return !FnStartLocs.empty(); }
  123   bool cantUnwind() const { return !CantUnwindLocs.empty(); }
  124   bool hasHandlerData() const { return !HandlerDataLocs.empty(); }
  127     return !(PersonalityLocs.empty() && PersonalityIndexLocs.empty());
  127     return !(PersonalityLocs.empty() && PersonalityIndexLocs.empty());

  103         return !VPTStates.empty();

  766   assert(Contents.empty() &&
 1076   if (Contents.empty())

  314   return !MaskedInsts.empty();

 1298   if (!Ins.empty()) {

  330     if (Cond.empty()) {

 1015     } while (!Lookahead.empty () && !Lexer.is(AsmToken::Colon));
 1022   while (!Lookahead.empty()) {
 1069   while (!Tokens.empty()) {
 1105       if (!Operands.empty())
 1113       if (Operands.empty()) {

 2933     if (!NewInstrs.empty()) {

  458   if (!ExtTo.empty())

  451   if (SFBlocks.empty())
 1950   if (!NewRegs.empty() || mayOverflowFrameOffset(MF)) {

 1661   if (NotAnalyzed || Cond.empty())
 1972       if (TB != Header && (Tmp2.empty() || FB != Header))

 1664     return (!HaveConst && Q.empty());
 1954   while (!Worklist.empty()) {
 2255     while (!Worklist.empty()) {

  974   return !Nodes.empty();

  327   bool IsStructRet    = Outs.empty() ? false : Outs[0].Flags.isSRet();
  445   if (!MemOpChains.empty())

 1524   if (Cond.empty())
 4141   if (Cond.empty())

  582   if (!Ms.empty())
 1824   if (!ReachedDefs.empty()) {
 1830   if (!ReachedUses.empty()) {

  289   if (RDs.empty())
  671       if (!Ds.empty()) {

  705   if (!MemOpChains.empty())

  624     if (Condition.empty()) {

  409   if (Args.empty())
  563     if (Ins.empty())
  731   if (CallConv == CallingConv::MSP430_INTR && !Outs.empty())
  867   if (!MemOpChains.empty())

  237     if (Cond.empty()) {

   23   if (SeqLs.empty()) {

 3225   if (!MemOpChains.empty())

  206   while (!WorkList.empty()) {

  289   while (!AdjacentInstrs.empty()) {

  750   while (!WorkStack.empty()) {

  632   if (E0.empty() || E1.empty())
  632   if (E0.empty() || E1.empty())

 1511           assert(StoreOperands.empty() && "Unfinished preceding store.");
 1570       assert(StoreOperands.empty() && "Unfinished parameter store.");
 1799         assert(VecIdx == -1 && LoadVTs.empty() && "Orphaned operand list.");
 2692       assert(StoreOperands.empty() && "Orphaned operand list.");

   91   return !RemoveList.empty();

   77     while (!WorkList.empty()) {
  160     while (!ToRemove.empty()) {

  168   if (!CheckPreds && Preds.empty())
  192   } while (!Preds.empty());

  163     if (!thisBlockISELs.empty())
  329   if (BIL.empty())

  826   bool MustSaveCR = !MustSaveCRs.empty();
 1397   bool MustSaveCR = !MustSaveCRs.empty();

 1474         if (BitGroups.empty())
 1505     if (BitGroups.empty())
 2362     if (BitGroups.empty())
 5385   while (!Queue.empty()) {

 3668   if (!MemOps.empty())
 4096   if (!MemOps.empty())
 4456   if (!MemOps.empty())
 4920   if (!MemOpChains2.empty())
 5328   if (!Ins.empty())
 5613   if (!MemOpChains.empty())
 6281   if (!MemOpChains.empty())
 6675   if (!MemOpChains.empty())
 8341     if (!Stores.empty())
11885   while (!Queue.empty()) {
11916     while (!Queue.empty()) {
12120   while (!BinOps.empty()) {
12336   while (!BinOps.empty()) {

  471   if (Buckets.empty())
  601   if (!UpdateFormBuckets.empty())

  162     if (FeatureBitStack.empty())

 1526     assert(!ArgFlags.isSplit() && PendingLocs.empty() &&
 1548   if (ArgFlags.isSplit() || !PendingLocs.empty()) {
 1585   if (!PendingLocs.empty()) {
 2052   auto IsCalleeStructRet = Outs.empty() ? false : Outs[0].Flags.isSRet();
 2247   if (!MemOpChains.empty())

  680   if (!OutChains.empty())
  925   if (!MemOpChains.empty())
 1228   if (!MemOpChains.empty())

   96   if (!ArgFlags.isSplit() && PendingMembers.empty())

 1553   if (!MemOpChains.empty())
 1675   if (RetLocs.empty())
 4556   if (!ResidueOps.empty()) {
 5543   if (!Replicate || OtherUses.empty())

  415     if (Cond.empty()) {

  101       if (ControlFlowStack.empty()) {
  110       if (ControlFlowStack.empty()) {
  120       if (ControlFlowStack.empty()) {
  131       if (EHPadStack.empty()) {
  145       if (EHPadStack.empty()) {

  104     if (Grouped.empty() || Grouped.back().first != Type)

  195   int FieldCount = int(!Languages.empty()) + int(!Tools.empty());
  195   int FieldCount = int(!Languages.empty()) + int(!Tools.empty());
  204       if (Producers.second->empty())

  290       while (!Entries.empty() && Entries.back().NumBlocksLeft == 0)
  311       if (!Entries.empty() &&
  342         if (!Entries.empty() &&
  355   assert(Entries.empty() && "Active sort region list not finished");

  664     if (Analyzable && ((Cond.empty() && TBB && TBB == Cont) ||
  665                        (!Cond.empty() && FBB && FBB == Cont)))
  905   assert(EHPadStack.empty());
  937       if (EHPadStack.empty() || !WebAssembly::mayThrow(MI))
  958   assert(EHPadStack.empty());
 1342   assert(Stack.empty() && "Control flow should be balanced");

  105   while (!WL.empty()) {

  140     while (!WorkList.empty()) {
  208     while (!WorkList.empty()) {

  783     if (!Chains.empty())
  839       DAG.getNode(Ins.empty() ? WebAssemblyISD::CALL0 : WebAssemblyISD::CALL1,
  841   if (Ins.empty()) {

   66   while (!WL.empty()) {
   89   while (!WL.empty()) {
  251   bool Changed = !ToDelete.empty() || !ExtractInstrs.empty();
  251   bool Changed = !ToDelete.empty() || !ExtractInstrs.empty();
  254   if (ExtractInstrs.empty())

  368   bool HasMutableRegisters = !MutableRegisters.empty();
  664   bool done() const { return Worklist.empty(); }
  672     assert((Worklist.empty() ||
  697     if (Worklist.empty())
  931     assert(Stack.empty() &&

  522   assert(Rets.empty());
  523   assert(Params.empty());

  151       assert (!PostfixStack.empty() && "Poped an empty stack!");
  166       if (InfixOperatorStack.empty()) {
  186         if (InfixOperatorStack.empty())
  216       while (!InfixOperatorStack.empty()) {
  222       if (PostfixStack.empty())
 3144   assert(!Operands.empty() && "Unexpect empty operand list!");
 3350   assert(!Operands.empty() && "Unexpect empty operand list!");
 3436       if (Match.empty() || LastOpcode != Inst.getOpcode())
 3451   if (Match.empty()) {

 1264   if (ShuffleMask.empty())

  187     if (!CurFPOData->Instructions.empty()) {

  428   bool IsFixed = Info.OrigArgs.empty() ? true : Info.OrigArgs.back().IsFixed;
  477     if (!NewRegs.empty())

  251   if (ArgFlags.isSplit() || !PendingMembers.empty()) {
  260   if (PendingMembers.empty()) {

  295         if (Group.empty()) {
  331       if (Group.empty())
  350     if (Group.empty())
  359   return !CmovInstGroups.empty();
  561   return !CmovInstGroups.empty();
  612   assert(!Group.empty() && "No CMOV instructions to convert");

  551   while (!Worklist.empty()) {

  439   while (!MIReplacements.empty()) {

  454       } while (!Worklist.empty());
  678     } while (!Blocks.empty());

  393   assert(LiveBundles.empty() && "Stale data in LiveBundles");

 3091   if (ObjectsToAllocate.empty())

 2479   if (CallConv == CallingConv::X86_INTR && !Outs.empty())
 3438     if (!MemOps.empty())
 3721   if (!Outs.empty() && Outs.back().Flags.isInAlloca()) {
 3852   if (!MemOpChains.empty())
 3975     if (!MemOpChains2.empty())
 4356   if (isVarArg && !Outs.empty()) {
 4409   if (!Outs.empty()) {
 5571   assert(Ops.empty() && "Expected an empty ops vector");
 5959   assert(EltBits.empty() && "Expected an empty EltBits vector");
 6340   assert(Mask.empty() && "Expected an empty shuffle mask vector");
 6423   assert(Mask.empty() && "getTargetShuffleMask expects an empty Mask vector");
 6424   assert(Ops.empty() && "getTargetShuffleMask expects an empty Ops vector");
 6562     if (N0.getValueType() == VT || !Ops.empty()) {
 6695   if (Mask.empty())
 6713   if (Ops.empty()) {
32889   assert(!WideInputs.empty() && "Shuffle with no inputs detected");
33085     OpInputIdx.push_back(AddOp(OpInput, OpInputIdx.empty() ? SrcOpIndex : -1));
33178   assert(!Ops.empty() && "Shuffle with no inputs detected");
33397   while (!Chain.empty()) {
40841   unsigned NumShuffles = (LMask.empty() ? 0 : 1) + (RMask.empty() ? 0 : 1);
40841   unsigned NumShuffles = (LMask.empty() ? 0 : 1) + (RMask.empty() ? 0 : 1);
40845   if (LMask.empty()) {
40851   if (RMask.empty()) {

 1658     assert(Mask.empty() && "Expected an empty shuffle mask vector");

  109   assert(Prefetches.empty() &&
  153   return !Prefetches.empty();
  206       assert(!Prefetches.empty() &&

 2567     if (Cond.empty()) {
 3858   if (SrcOperandIds.empty())
 5505       bool isAligned = !MMOs.empty() && MMOs.front()->getAlignment() >= Alignment;
 5582     bool isAligned = !MMOs.empty() && MMOs.front()->getAlignment() >= Alignment;
 5637     if (MMOs.empty() && RC == &X86::VR128RegClass &&
 5649       bool isAligned = !MMOs.empty() && MMOs.front()->getAlignment() >= Alignment;
 5708     if (MMOs.empty() && RC == &X86::VR128RegClass &&
 5715     bool isAligned = !MMOs.empty() && MMOs.front()->getAlignment() >= Alignment;

 2150       if (!Mask.empty())
 2222       if (!Mask.empty())
 2253       if (!Mask.empty())
 2270       if (!Mask.empty())

  354       while (!DupIndices.empty()) {
  440   if (!HasVulnerableLoad && Infos.empty())
  467   if (FenceCallAndRet && Infos.empty())
  669     if (Info.CondBrs.empty()) {
 1993       (HardenOpRegs.empty() ||
 2016   if (HardenOpRegs.empty())

  309   assert(BlockStates.empty() && DirtySuccessors.empty() &&
  309   assert(BlockStates.empty() && DirtySuccessors.empty() &&
  327   while (!DirtySuccessors.empty()) {

 1096   if (!MemOpChains.empty())
 1178   if (!MemOpChains.empty())
 1381   if (!CFRegNode.empty())
 1409   if (!MemOps.empty()) {
 1492   if (!MemOpChains.empty())

  133     while (!WUsers.empty())
  165   while (!WUsers.empty())

   47       Require(!OpenRanges.empty(), "unmatched ]]");
   64   Require(OpenRanges.empty(), "unmatched [[");

   72   while (!Worklist.empty()) {
   84     if (!Stack.empty() && Stack.back() == I) {
  153   while (!Worklist.empty()) {
  169     if (!Stack.empty() && Stack.back() == I) {
  403   while (!Worklist.empty()) {

  279   if (IndirectCalls.empty()) {

   47   if (Users.empty())
  147   if (CoroAllocs.empty())
  263   if (DevirtAddr.empty())
  313     if (L->CoroIds.empty())

  765     if (!UsersToUpdate.empty()) {
 1319   if (!AllocasToPromote.empty()) {
 1370     if (Spills.empty())

  791   if (Shape.CoroSizes.empty())
  825   assert(!Args.empty());
 1028   while (!Worklist.empty()) {
 1177   assert(Clones.empty());
 1192   assert(Clones.empty());
 1265       assert(ReturnPHIs.empty());
 1362   if (Shape.CoroSuspends.empty()) {
 1550     if (Coroutines.empty() && !PrepareFn)
 1555     if (Coroutines.empty())

  172   if (CoroFrees.empty())

   83   if (!InlinedFunctions.empty()) {

  739   if (Loads.empty())
  825   while (!WorkList.empty()) {
  899   if (PointerArgs.empty())

  233   } while (!Worklist.empty());
 3642     while (!Worklist.empty()) {

  120     if (LineSplit.empty())
  127     if (BBNames.empty())

  302   if (UnusedArgs.empty())

  462   while (!Worklist.empty()) {
  724           if (Tracker.Uses.empty()) {
  785       if (Node->Uses.empty()) {
 1159     if (InferInSCC.empty())
 1180     if (InferInThisFunc.empty())
 1197       if (InferInThisFunc.empty())
 1202   if (InferInSCC.empty())

  558   while (!Worklist.empty()) {
  820   while (!Worklist.empty()) {

  171     if (GV.isDeclaration() || Types.empty())
  344   while (!NewLiveGVs.empty()) {

  151   } while (!Types.empty());
  284   while (!WorkList.empty()) {
 2513   if (SimpleCEs.empty())

  297   assert(!Region.empty());
  606   if (OutliningWorklist.empty())
  631   } while (!OutliningWorklist.empty());

  595   if (CallSites.empty())
  706         if (!InlineInfo.InlinedCalls.empty()) {
  836   if (!DeadFunctionsInComdats.empty()) {
  844   if (FunctionsToRemove.empty())
  948   if (Calls.empty())
 1096       if (!IFI.InlinedCallSites.empty()) {

 1113   if (ClonedOMRI->ORI.empty())
 1177   return !OutlinedFunctions.empty();
 1333   if (Cloner.OutlinedFunctions.empty())

  193   return GlobalExtensions.isConstructed() && !GlobalExtensions->empty();

 1322     if (!Predecessors[B1].empty())
 1332     if (!Successors[B1].empty())

  351     if (!LiveGlobalVariables.empty())

  340   if(!CfiFunctionMDs.empty()) {
  365   if (!FunctionAliases.empty()) {
  381   if (!Symvers.empty()) {

  787     if (GV.isDeclaration() || Types.empty())
 1573     if (!Assumes.empty()) {

  590   if (!SimpVect.empty())
  602   assert(!Opnds.empty() && "Expect at least one addend");

 4288   if (!ArgNos.empty()) {

 2180   while (!PhiWorklist.empty()) {

  228     if (!LaterIndices.empty())
  533   while (!WorkList.empty()) {
  536     while (!WorkList.empty()) {
 1053   while (!Worklist.empty()) {

   67   while (!ValuesToInspect.empty()) {
  817   } while (!Worklist.empty());

 1018   if (PHIUsers.empty())

 1903     if (!Indices.empty())
 2349   } while (!Worklist.empty());
 3097     if (NewClauses.empty())
 3462   } while (!Worklist.empty());

  929     if (AllocaVec.empty() && DynamicAllocaVec.empty()) return false;
  929     if (AllocaVec.empty() && DynamicAllocaVec.empty()) return false;
 1025         if (AllocaVec.empty())
 2083   if (!MetadataGlobals.empty())
 2155   if (!LivenessGlobals.empty())
 2738   if (NumInstrumented > 0 || ChangedStack || !NoReturnCalls.empty())
 2957   if (!ClInstrumentDynamicAllocas || DynamicAllocaVec.empty()) {
 2958     assert(DynamicAllocaPoisonCallVec.empty());
 2984   if (AllocaVec.empty()) {
 2985     assert(StaticAllocaPoisonCallVec.empty());
 3166   if (!StaticAllocaPoisonCallVec.empty()) {

  205   return !TrapInfo.empty();

  894   if (RI.HasBranch || !Selects.empty()) {
 1272     assert(Result.empty() &&
 1367     assert(Scope->HoistStopMap.empty() && Scope->CHRRegions.empty() &&
 2052     if (!SortedScopes.empty()) {

  321       assert(OutEdges.empty());
  424         if (Block.OutEdges.empty()) continue;
  996     uint32_t CfgChecksum = FileChecksums.empty() ? 0 : FileChecksums[i];
 1006       uint32_t FuncChecksum = Funcs.empty() ? 0 : Funcs[j]->getFuncChecksum();
 1060   if (FileInfos.empty()) {

 1150   if (!LandingPadVec.empty())
 1153   if (AllocasToInstrument.empty() && F.hasPersonalityFn() &&
 1160   if (AllocasToInstrument.empty() && ToInstrument.empty())
 1160   if (AllocasToInstrument.empty() && ToInstrument.empty())
 1169                    !AllocasToInstrument.empty());
 1172   if (!AllocasToInstrument.empty()) {

 3938     if (!VAStartInstrumentationList.empty()) {
 4091     if (!VAStartInstrumentationList.empty()) {
 4276     if (!VAStartInstrumentationList.empty()) {
 4528     if (!VAStartInstrumentationList.empty()) {

  257   } while (!Worklist.empty());

  729     while (!BitCastUsers.empty()) {

  323     bool isExit() const { return Succs.empty(); }
  697   } while (!Users.empty());
 1033     } while (!Worklist.empty());
 1497   } while (!SuccStack.empty());
 1514     while (!PredStack.empty()) {
 1715     if (NewReleases.empty()) break;
 1773     if (NewRetains.empty()) break;
 1875   while (!DeadInsts.empty())

  109   } while (!Worklist.empty());

  358     while (!Worklist.empty()) {
  374   } while (!Worklist.empty());
  558   return !Worklist.empty();

  316   while (!WorkList.empty()) {

   67   while (!WorkList.empty()) {

  485         return P.second.empty();
  499   if (PredsWithConds.empty())
  501   if (PredsWithConds.empty())

  310   assert(!ConstInfo.RebasedConstants.empty() && "Invalid constant info entry.");
  949   if (!ConstIntInfoVec.empty())
  952     if (!MapEntry.second.empty())

  177   if (!CommonValue || IncomingConstants.empty())
  595   if (ArgNos.empty())

  145   } while (!NowDeadInsts.empty());
  602   while (!WorkList.empty()) {
  667   while (!Blocks.empty()) {

  835   while (!WorkList.empty()) {

  722   } while (!BBWorklist.empty());
 1204     while (!NewInsts.empty()) {
 1214     return !CriticalEdgePred.empty();
 1221   LLVM_DEBUG(if (!NewInsts.empty()) dbgs()
 1352   if (ValuesPerBlock.empty())
 1360   if (UnavailableBlocks.empty()) {
 1785   while (!Worklist.empty()) {
 2147   assert(InstrsToErase.empty() &&
 2162     if (InstrsToErase.empty()) {
 2461   if (toSplit.empty())
 2467   } while (!toSplit.empty());
 2527   while (!NewDead.empty()) {

  143     if (Insts.empty())
  180     if (NewInsts.empty()) {
  809   if (Candidates.empty() || Candidates.front().Cost <= 0)

  346   assert(EliminatedGuardsAndBranches.empty() || Changed);
  691   while (!Checks.empty()) {

  556   while (!WorkList.empty()) {
 1791   assert(Widened.empty() && NarrowIVUsers.empty() && "expect initial state" );
 1796   while (!NarrowIVUsers.empty()) {
 1905   while (!Worklist.empty()) {
 1981   while (!LoopPhis.empty()) {
 2000     } while(!LoopPhis.empty());
 2002     for (; !WideIVs.empty(); WideIVs.pop_back()) {
 2138   while (!Worklist.empty()) {
 2677   if (ExitCounts.empty())
 2711   if (ExitingBlocks.empty())
 2901   if (ExitingBlocks.empty())
 3096   while (!DeadInsts.empty())

 1805   if (RangeChecks.empty())

  610     return !Result.empty();
  643     return !Result.empty();
  665     return !Result.empty();
  676     if (Result.empty())
  700       if (LHSVals.empty() && RHSVals.empty())
  700       if (LHSVals.empty() && RHSVals.empty())
  726       return !Result.empty();
  735       if (Result.empty())
  764     return !Result.empty();
  819       return !Result.empty();
  846         return !Result.empty();
  889             return !Result.empty();
  907       return !Result.empty();
  941       return !Result.empty();
  956   return !Result.empty();
 1412   if (AvailablePreds.empty()) return false;
 1534   assert(!PredToDestList.empty());
 1574   if (!SamePopularity.empty()) {
 1604   assert(!PredValues.empty() &&
 1650     if (PredToDestList.empty()) {
 1672   if (PredToDestList.empty())
 1733     if (PredToDestList.empty())
 1836     assert(XorOpValues.empty());
 1843   assert(!XorOpValues.empty() &&
 2071     if (UsesToRename.empty())
 2082     while (!UsesToRename.empty())
 2264   assert(!PredBBs.empty() && "Can't handle an empty set");
 2390     if (UsesToRename.empty())
 2402     while (!UsesToRename.empty())

 2043       if (LoopUses.empty()) {

  169     while (!Worklist.empty()) {
  690     if (!Dependences || Dependences->empty())
  804     if (LAI->hasConvergentOp() && !Checks.empty()) {
  809     if (!Pred.isAlwaysTrue() || !Checks.empty()) {

 1409     assert(OriginalFC0PHIs.empty() && "Expecting OriginalFC0PHIs to be empty!");

  152     if (!DeadInsts.empty()) {

  517     if (Candidates.empty())
  537     if (!Checks.empty() || !LAI.getPSE().getUnionPredicate().isAlwaysTrue()) {

  771   } while (!Worklist.empty());
 1007   if (Guards.empty() && GuardsAsWidenableBranches.empty())
 1007   if (Guards.empty() && GuardsAsWidenableBranches.empty())

  688   while (!Queue.empty()) {
  819   if (Roots.empty() || (Roots.size() == 1 && BaseUsers.empty()))
  879   if (DRS.Roots.empty())
  939     } else if (DRS.Roots.empty()) {
  968   assert(RootSets.empty() && "Unclean state!");
  982   if (RootSets.empty()) {
  987     if (V.Roots.empty() || V.Roots.size() != RootSets[0].Roots.size()) {
 1676   if (PossibleIVs.empty()) {

  349     if (DeadExitBlocks.empty())
  547     if (FoldCandidates.empty()) {
  586     if (!DeadLoopBlocks.empty()) {

  339   } while (!PreorderLoops.empty());

  447   if (!Good.empty()) {
  453   if (!Bad.empty()) {
  472   if (Scale == 1 && BaseRegs.empty())
  501   assert(!BaseRegs.empty() && "1*reg => reg, should not be needed.");
  555   return !BaseRegs.empty() ? BaseRegs.front()->getType() :
  601   if (HasBaseReg && BaseRegs.empty()) {
  604   } else if (!HasBaseReg && !BaseRegs.empty()) {
  970   while (!DeadInsts.empty()) {
 1536   if (!Formulae.empty() && RigidFormula)
 1878     assert(!Incs.empty());
 2673     } while (!Worklist.empty());
 2847   assert(!Chain.Incs.empty() && "empty IV chains are not allowed");
 3106   assert(!Chain.Incs.empty() && "empty IV chains are not allowed");
 3326     if (LU.Formulae.empty()) {
 3393   while (!Worklist.empty()) {
 4008           if (F.Scale == 1 && (F.BaseRegs.empty() ||
 4981   if (Solution.empty()) {
 5091     if (!ExitingBlocks.empty()) {
 5196       if (!Ops.empty() && LU.Kind == LSRUse::Address &&
 5213     if (!Ops.empty()) {
 5223   if (!Ops.empty()) {
 5257   const SCEV *FullS = Ops.empty() ?
 5572   if (Uses.empty())
 5593   if (Solution.empty())

  386     assert(CostWorklist.empty() && "Must start with an empty cost list");
  387     assert(PHIUsedList.empty() && "Must start with an empty phi used list");
  448       } while (!CostWorklist.empty());
  450       if (PHIUsedList.empty())
  500     while (!SimplifiedInputValues.empty())
 1393     assert(PreOrderLoops.empty() && "Must start with an empty preorder walk.");
 1394     assert(PreOrderWorklist.empty() &&
 1401     } while (!PreOrderWorklist.empty());
 1444   while (!Worklist.empty()) {

  406   if (LAI->getRuntimePointerChecking()->getChecks().empty()) {

  132   return !Worklist.empty();

   55   if (ToLower.empty())

   56   if (ToLower.empty())

   92   if (GuardIntrinsics.empty())

  163   bool empty() const { return Ranges.empty(); }
  405     if (!Range.TheStores.empty())
  821   while (!srcUseList.empty()) {

  535   while (!Candidates.empty()) {

  229       while (!Stack.empty() && Root.lookup(Stack.back()) >= OurDFS) {
 2637   while (!Worklist.empty()) {
 2939   while (!TempInst.empty()) {
 3733   bool empty() const { return DFSStack.empty(); }
 3747         !DFSStack.empty() &&

  657   assert(IFI.StaticAllocas.empty() && "can't have allocs");

  497   while (!Worklist.empty()) {
  623   if (Ops.empty()) {
  758     if (NodesToRewrite.empty()) {
 1470       if (Ops.empty())
 1646     if (Ops.empty())
 1734   } while (!Ops.empty());
 1825   if (Ops.empty())
 1839   while (!Ops.empty() && isa<Constant>(Ops.back().Op)) {
 1844   if (Ops.empty())
 2000   if (Candidates.empty())
 2341       while (!Worklist.empty() && Ops.size() <= GlobalReassociateLimit) {

  810     while (!Worklist.empty()) {
 1866   if (!PromotableAllocas.empty()) {
 2378   return !Records.empty();
 2555   if (ParsePointNeeded.empty())

 1367   while (!BBWorkList.empty() || !InstWorkList.empty() ||
 1367   while (!BBWorkList.empty() || !InstWorkList.empty() ||
 1368          !OverdefinedInstWorkList.empty()) {
 1371     while (!OverdefinedInstWorkList.empty()) {
 1387     while (!InstWorkList.empty()) {
 1404     while (!BBWorkList.empty()) {

  459     assert((P.SI != SE || !P.SplitTails.empty()) &&
  463     if (!P.SplitTails.empty()) {
  494       assert(P.SplitTails.empty() && "Failed to clear the split slices!");
  523       if (!P.SplitTails.empty() && P.SI->beginOffset() != P.EndOffset &&
  536     P.BeginOffset = P.SplitTails.empty() ? P.SI->beginOffset() : P.EndOffset;
  591     if (P.SI == RHS.P.SI && P.SplitTails.empty() == RHS.P.SplitTails.empty()) {
  591     if (P.SI == RHS.P.SI && P.SplitTails.empty() == RHS.P.SplitTails.empty()) {
  986     } while (!Uses.empty());
 1399   if (Indices.empty())
 1894       if (!CandidateTys.empty()) {
 1919   if (CandidateTys.empty())
 1935     if (CandidateTys.empty())
 3142     } while (!Uses.empty());
 3239     while (!Queue.empty()) {
 3811   if (Loads.empty() && Stores.empty())
 3811   if (Loads.empty() && Stores.empty())
 3900       if (!Stores.empty() && SplitOffsetsMap.count(SI)) {

  248   else if (CachePtr->empty())
  315   assert(Gathered.empty() && Scattered.empty());
  369   if (!SV.empty()) {
  827   if (Gathered.empty() && Scattered.empty())

 1153   while (!Candidates.empty()) {

  136   } while (!Worklist.empty());
  598   } else if (ExitCaseIndices.empty())
 1182   } while (!LoopsToClone.empty());
 1272     while (!Worklist.empty()) {
 1371   while (!UnloopedBlockSet.empty() && !OrderedClonedExitsInLoops.empty()) {
 1372     assert(Worklist.empty() && "Didn't clear worklist!");
 1406     } while (!Worklist.empty());
 1492   while (!DeathCandidates.empty()) {
 1598   while (!Worklist.empty()) {
 1760   while (!UnloopedBlocks.empty() && !ExitsInLoops.empty()) {
 1761     assert(Worklist.empty() && "Didn't clear worklist!");
 1805     } while (!Worklist.empty());
 1898   } while (!DomWorklist.empty());
 2588   if (UnswitchCandidates.empty())

  164     } while (!DFSStack.empty());
  381       } while (!DFSStack.empty());
  529         while (!SpecWorklist.empty()) {
  763   if (PNs.empty()) {
  796   if (SpecPNs.empty())
  818     if (PNs.empty())

  724   BasicBlock *Insert = Order.empty() ? ParentRegion->getExit() :
  755   if (!Order.empty() || !ExitUseAllowed)
  828     while (!Order.empty() && !Visited.count(LoopEnd) &&
  895   while (!Order.empty()) {

  121     while (!Worklist.empty()) {
  293     if (!WorklistEscaped.empty()) {
  298       while (!WorklistUnescaped.empty()) {
  710   while (!UncondBranchPreds.empty()) {

  713   if (!NewBB2Preds.empty()) {

  305         if (!LoopPreds.empty()) {
  382     if (!IBRPred || OtherPreds.empty())

  100   while (!ToVisit.empty()) {
  551     if (Bitcasts.empty())

   63   if (Calls.empty())

  859   while (!FnLBBs.empty()) {
  932   while (!BBs.empty()) {

  232   while (!Worklist.empty()) {
  453   while (!Worklist.empty()) {
  836   while (!Queue.empty()) {
  931   if (NoAliasArgs.empty())
 1027       if (PtrArgs.empty() && !IsFuncCall)
 1104       if (!NoAliases.empty())
 1130       if (!Scopes.empty())
 1891         if (!VarArgsToForward.empty() &&
 1898           if (!Attrs.isEmpty() || !VarArgsAttrs.empty()) {
 1956   if (InsertLifetime && !IFI.StaticAllocas.empty()) {
 2152         assert(!OpBundles.empty() &&
 2349   } else if (!Returns.empty()) {

   88   while (!Worklist.empty()) {
  101     if (ExitBlocks.empty())
  115     if (UsesToRewrite.empty())
  285   while (!BBWorklist.empty()) {
  332   if (ExitBlocks.empty())

  457   while (!DeadInsts.empty()) {
  497   return !DbgUsers.empty();
 1399   if (Dbgs.empty())
 1608   if (DbgUsers.empty())
 1650     if (!Ops.empty()) {
 1738   if (Users.empty())
 2171   } while (!Worklist.empty());

  413   if (!InsertedPHIs.empty())

  177   } while (!Worklist.empty());
  737   while (!Worklist.empty())

  209     while (!DeadInsts.empty())

  101   while (!Worklist.empty()) {

   86     if (!Exits.empty()) {

   60     assert(InLoopPredecessors.empty() &&
   81     assert(!InLoopPredecessors.empty() && "Must have *some* loop predecessor!");

   92   if (Init.empty())

  257   if (Stack.empty())
  285   while (!Stack.empty() && !stackIsInScope(Stack, VD))
  343   if (OperandInfo.Infos.empty())
  672       if (RenameStack.empty()) {
  694       if (RenameStack.empty())

  410   if (!Info.UsingBlocks.empty())
  481       if (StoresByIndex.empty())
  817   while (!LiveInBlockWorklist.empty()) {

  142   if (PredValues.empty())

  104   while (!LiveInBlockWorklist.empty()) {

  645     while (!DFT.empty()) {
 1010   while (!Preds.empty()) {
 4128   if (!UncondBranchPreds.empty() && DupRet) {
 4129     while (!UncondBranchPreds.empty()) {
 4150   while (!CondBranchPreds.empty()) {
 4370   assert(!CasesB.empty() && "There must be non-default cases.");
 4371   assert(!CasesA.empty() || HasDefault);
 4377   if (!CasesA.empty() && CasesAreContiguous(CasesA)) {
 4400   if (NumCases->isNullValue() && !ContiguousCases->empty())
 4489   if (HasDefault && DeadCases.empty() &&
 4496   if (DeadCases.empty())

  867   while (!SimpleIVUsers.empty()) {

 2140   if (SinCosCalls.empty() && (SinCalls.empty() || CosCalls.empty()))
 2140   if (SinCosCalls.empty() && (SinCalls.empty() || CosCalls.empty()))
 2140   if (SinCosCalls.empty() && (SinCalls.empty() || CosCalls.empty()))

   82     while (!Worklist.empty()) {

   70   return !GCRelocates.empty();

  131   bool hasWorkToDo() const { return !Worklist.empty(); }
  634   while (!Worklist.empty()) {
  737   assert(DistinctWorklist.empty() && "MDNodeMapper::map is not recursive");
  746   while (!DistinctWorklist.empty())
  815   while (!Worklist.empty()) {
  845   while (!DelayedBBs.empty()) {

  510   while (!Worklist.empty()) {

  501   if (!Casts.empty())

 1782   if (Casts.empty())
 4833   if (!PSE.getUnionPredicate().getPredicates().empty()) {
 5597   while (!Worklist.empty()) {
 6055   while (!Worklist.empty()) {
 6966   assert(VPBB->getSuccessors().empty() &&
 7853   while (!Worklist.empty()) {

  928     bool empty() const { return OpsVec.empty(); }
 1260       assert(Operands.empty() && "Already initialized?");
 1288       assert(!Operands[OpIdx].empty() && "No operand available");
 1366       if (ReuseShuffleIndices.empty())
 2125       if (!Entry->ReuseShuffleIndices.empty()) {
 2369       if (!CurrentOrder.empty()) {
 2438         if (CurrentOrder.empty()) {
 2452           if (CurrentOrder.empty()) {
 2924   bool NeedToShuffleReuses = !E->ReuseShuffleIndices.empty();
 3344   assert(VectorizableTree.empty()
 3345              ? ExternalUses.empty()
 3637         if (!E->ReuseShuffleIndices.empty()) {
 3656         if (VL.size() == E->Scalars.size() && !E->ReuseShuffleIndices.empty()) {
 3702   if (!ReuseShuffleIndicies.empty()) {
 3736   bool NeedToShuffleReuses = !E->ReuseShuffleIndices.empty();
 4552   while (!Bundle->isReady() && !ReadyInsts.empty()) {
 4725   while (!WorkList.empty()) {
 4942   while (!Worklist.empty() && !FoundUnknownInst) {
 5056   if (ExternalUses.empty())
 5179   while (!Roots.empty())
 6282     while (!Stack.empty()) {
 6374     if (ReducedVals.empty())
 6757   while (!Stack.empty()) {

   89   if (!Successors.empty() || !Parent)
   97   if (!Predecessors.empty() || !Parent)
  180       !(Replica && getPredecessors().empty())) {       /* C */

  506     assert(Successors.empty() && "Setting one successor when others exist.");
  516     assert(Successors.empty() && "Setting two successors when others exist.");
  527     assert(Predecessors.empty() && "Block predecessors already set.");
 1088     assert(Entry->getPredecessors().empty() && "Entry block has predecessors.");
 1089     assert(Exit->getSuccessors().empty() && "Exit block has successors.");
 1113     assert(EntryBlock->getPredecessors().empty() &&
 1131     assert(ExitBlock->getSuccessors().empty() &&
 1466     assert(NewBlock->getSuccessors().empty() &&
 1484     assert(IfTrue->getSuccessors().empty() &&
 1486     assert(IfFalse->getSuccessors().empty() &&

  262   if (BestCandidates.empty())

  190     if (aliases.empty())

  181         if (Nodes.empty())

   61     if (MoreLATokens.empty())

  519     if (Vec.empty())

  229     } else if (!Vec.empty() && Vec.back()->hasTagIdentifierNamespace()) {

   54       while (!Pending.empty()) {

 4462         assert(!CI->empty() && "Invalid component list!");

  639   while (!LocalQueue.empty()) {

  288     assert(!CaptureRegions.empty() &&

   59       while (!Pending.empty()) {

  123   bool empty() const { return decls().empty(); }

  455     return ContainingVBases.empty() ? nullptr : ContainingVBases.front();

 6471   while(!Stack.empty()) {

  227     if (Bindings.empty())
  245     return !Bindings.empty();

  101   bool branch_empty() const { return UninitBranches.empty(); }

  167   bool empty() const { return CalledFunctions.empty(); }

  300           if (!A.empty())

  764     if (pathStack.empty())
  778   void popActivePath() { if (!pathStack.empty()) pathStack.pop_back(); }
  780   bool isWithinCall() const { return !pathStack.empty(); }

 1710     assert(LoadedSLocEntryTable.empty() &&

   72     assert(Buffer.empty() && "didn't claim all values out of buffer");

   75     return Entries.empty();

  193   bool empty() const { return Jobs.empty(); }

  197     assert(!UDSuffixBuf.empty() && "no ud-suffix");
  264     assert(!UDSuffixBuf.empty() && "no ud-suffix");
  269     assert(!UDSuffixBuf.empty() && "no ud-suffix");

  244   bool tokens_empty() const { return ReplacementTokens.empty(); }

  467     bool hasRecordedPreamble() const { return !ConditionalStack.empty(); }

  109     if (ConditionalStack.empty())
  118     assert(!ConditionalStack.empty() && "No conditionals active!");

  325       if (!Locs.empty() && Locs.back().isActive(P)) {
  341       while (!Locs.empty() && Locs.back().isActiveOrNested(P))
  348       if (!Locs.empty() && Locs.back().isActive(P))

   62     assert(!FieldCount.empty() && "no currently-parsed class");

 2207     assert(!DeclTypeInfo.empty() && "No type chunks to drop.");

  300     return (Diagnostics.empty() && (!Parent || Parent->empty()));
  310     if (pool.Diagnostics.empty()) return;
  312     if (Diagnostics.empty()) {
  324   bool pool_empty() const { return Diagnostics.empty(); }

  190   bool empty() const { return Designators.empty(); }

 1034     bool empty() const { return Candidates.empty(); }

  902     return !TemplateParams.empty() || GLTemplateParameterList;

 1471     return FunctionScopes.empty() ? nullptr : FunctionScopes.back();
 1711     return ModuleScopes.empty() ? nullptr : ModuleScopes.back().Module;
 8075     if (!CodeSynthesisContexts.empty() &&
 8100     assert(!ExprEvalContexts.empty() &&
 8226       assert(S.VTableUses.empty() &&
11548       assert(S.DelayedOverridingExceptionSpecChecks.empty() &&
11550       assert(S.DelayedEquivalentExceptionSpecChecks.empty() &&
11552       assert(S.DelayedDllExportClasses.empty() &&

  333   bool empty() const { return Candidates.empty(); }

  203     return !CorrectionDecls.empty() && CorrectionDecls.front() == nullptr;
  213   bool isResolved() const { return !CorrectionDecls.empty(); }
  262     return (!isKeyword() && !CorrectionDecls.empty());

 1238     if (I == KeyDecls.end() || I->second.empty())
 2279     assert(!StmtStack.empty() && "Read too many sub-statements!");

  801   bool empty() const { return Record->empty(); }

   67     if (!Rep.empty() && Rep.back() == Val)
   70     assert((Rep.empty() || Rep.back().first < Val.first) &&

  223     assert((R.isValid() || Ranges.empty()) && "Invalid range can only be used "
  552     assert(!Reports.empty());

 1162     if (Cache.empty())

   46   bool isLeaf() const { return Children.empty(); }

  857   if (PotentialImplicitProtocols.empty())
  869   if (ConformingProtocols.empty())
  891   if (MinimalConformingProtocols.empty())
 1398   if (CFFunctionIBCandidates.empty())
 1436     assert(CFFunctionIBCandidates.empty() &&
 1451       if (!CFFunctionIBCandidates.empty()) {

  203       if (Scopes.empty())

  255   if (ATLs.empty())

  336     if (props.empty())
  346     assert(!props.empty());
  359     assert(!props.empty());

 1058   if (LazyInitializers.empty())
 1070   assert(LazyInitializers.empty() &&
 8426       if (!Protocols.empty())
 8477       if (!Protocols.empty())
 8776         newParamInfos.empty() ? nullptr : newParamInfos.data();
 9173   assert(NewParamInfos.empty() && "param info list not empty");
 9745   if (ArgTypes.empty() && Variadic && !getLangOpts().CPlusPlus)

 1883     if (!Bases.empty())
 2213     if (!ConflictingDecls.empty()) {
 2338     if (!ConflictingDecls.empty()) {
 2416     if (!ConflictingDecls.empty()) {
 2530     if (!ConflictingDecls.empty()) {
 2608     if (!FoundDecls.empty()) {
 2666     if (!ConflictingDecls.empty() && SearchName) {
 2837     if (!ConflictingDecls.empty()) {
 3072     if (!ConflictingDecls.empty()) {
 3730     if (!ConflictingDecls.empty()) {
 5078     if (!ConflictingDecls.empty()) {
 5363   if (!ConflictingDecls.empty()) {
 7847     if (Result.empty())
 8228   while (!NestedNames.empty()) {

  183     if (Queue.empty())
  199   bool IsFirstStep = ScratchPath.empty();
  687     while (!Stack.empty()) {

  503   while (!HTMLOpenTags.empty()) {
  549   while (!HTMLOpenTags.empty()) {

 2386     Eval->IsICE = Result && Notes.empty();
 4386   if (Decls.empty())

  817   assert(AttrBlank.empty() && "HasAttrs was wrong?");
 1301   if (Decls.empty())

  172   while (!WorkList.empty()) {
  460   if (VBases.empty()) {
  618   while (!WorkList.empty()) {
 2143   assert(PreventedBy.empty() && "PreventedBy is expected to be empty");

  463   if (ProtocolRefs.empty())
 1295     assert(!Overridden.empty() &&
 1642       if (!layout.empty()) {

  407     if (!Decls.empty() && !CurDeclType.isNull()) {
  417     if (!Decls.empty())
  489   if (!Decls.empty())

  688         if (!Buffer.empty() && Buffer.front() == '\01')

  115       if (!Adjustments.empty())
 1071       if (!EvalStatus.Diag->empty()) {
 1204                         Info.EvalStatus.Diag->empty() &&
 1212       if (Enabled && HadNoPriorDiags && !Info.EvalStatus.Diag->empty() &&
 1576       if (!Designator.Entries.empty()) {
 1667       assert(!Path.empty());
 1695       if (Path.empty())
 1703       if (Path.empty())
 2016         << IsReferenceType << !Designator.Entries.empty()
 2031         << IsReferenceType << !Designator.Entries.empty();
 2100       << !Designator.Entries.empty() << !!VD << VD;
 3758       if (LVal.Designator.Entries.empty()) {
 4137   } else if (!MemPtr.Path.empty()) {
 5388   if (UnionPathLengths.empty())
 6633       if (Diag.empty())
 6641       if (Diag.empty())
 6996     if (!CovariantAdjustmentPath.empty() &&
10312   if (!LVal.Designator.Entries.empty())
11158     while (!Queue.empty())
14313   if (!Diags.empty()) {
14389       return Diags.empty();
14418   return Diags.empty();
14447   return Diags.empty();

  505   if (Candidates.empty())

   45   if (!getEvalStatus().Diag || !getEvalStatus().Diag->empty()) {

  667   if (ReturnTypeAbiTags.empty()) {
  820     if (VariableTypeAbiTags.empty()) {
 2306     if (!ASString.empty())

  650   while (!Stack.empty()) {
  675     SaveSourceLocation(Stack.empty()? R.getEnd() : R.getBegin(),

 2830     if (FieldOffsets.empty() && Bases.empty())

  466   bool empty() const { return Offsets.empty(); }
 3251   assert(Paths.empty());
 3283       if (P->MangledPath.empty() || P->MangledPath.back() != Base)
 3298       else if (P->ContainingVBases.empty())

   72   if (Bindings.empty())
  423     return !Patterns.empty();

 5844   while (!DFSWorkList.empty()) {

   54   while (!worklist.empty()) {

  156   if (IgnoredFilesPattern.empty() || Group.empty() ||
  358     if (Group.empty())

  165     while (!WorkList.empty()) {

  327   while (!WL.empty()) {
  489   while (!WorkList.empty()) {
  530   if (!DeferredLocs.empty()) {

  144   return !(match(SubclassM, *D, D->getASTContext()).empty());

 1158     if (Info->Vect.empty())

  260   if (!worklist.empty())
  611     while (!Queue.empty()) {

 1012       if (getDiags()->PrintTemplateTree && Tree.empty()) {
 1021         if (!Tree.empty()) {

  611     if (::getDiagnosticsInGroup(Flavor, &O, Diags) || Diags.empty())

  154     if (!Current->MissingHeaders.empty()) {
  298   while (!Stack.empty()) {
  410   while (!Stack.empty()) {
  438   if (!Requirements.empty()) {
  545       OS << (UnresolvedExports[I].Id.empty() ? "*" : ".*");

  630     if (!ValidList.empty())

 1676   if (UsedArray.empty())

  450   assert(elementTypes.empty());
  664   if (layout.empty()) {

 1288   if (!RetainableOperands.empty() && getLangOpts().ObjCAutoRefCount &&

  396   if (EmittedKernels.empty() && DeviceVars.empty())
  396   if (EmittedKernels.empty() && DeviceVars.empty())
  493   if ((IsHIP || (IsCUDA && !RelocatableDeviceCode)) && EmittedKernels.empty() &&
  494       DeviceVars.empty())

  148     assert(paramInfos.empty() &&
  329   if (!paramInfos.empty()) {

  314     bool hasWritebacks() const { return !Writebacks.empty(); }

 1092         if (!AggregatedInits.empty()) {
 1231         if (!AggregatedStmts.empty()) {
 2194   } else if (!CXXInheritedCtorInitExprArgs.empty()) {

  215   if (!BranchFixups.empty()) {

  405     if (Bundles.empty()) {

 3171     if (Identifier.empty())
 4435         Expr.empty() ? nullptr : DBuilder.createExpression(Expr),

  539   if (CXXGlobalInits.empty() && PrioritizedCXXGlobalInits.empty())
  546   if (!PrioritizedCXXGlobalInits.empty()) {
  582   if (FileName.empty())

  866       llvm::ArrayType::get(!filterTypes.empty() ?
 1960   assert(!SEHCodeSlotStack.empty() && "emitting EH code outside of __except");
 1974   assert(!SEHCodeSlotStack.empty() && "emitting EH code outside of __except");

  481       assert(Adjustments.empty());

 1627   assert((cleanupDominator || cleanups.empty()) &&

 1433   assert(!PlaceholderAddresses.empty());
 1575   if (!PlaceholderAddresses.empty()) {
 1585   assert(PlaceholderAddresses.empty() && "unhandled placeholders");

 1844           if (!Args.empty()) {
 1894     if (Args.empty()) {
 3651     assert(!Checks.empty());
 4758   assert(!Checks.empty() && "Should have produced some checks.");

  568                    Active.empty() ? nullptr : Active.back().get()));
  759   assert(!Active.empty() && "No active loops to pop");

  275   bool hasInfo() const { return !Active.empty(); }

 1914     if (Protocols.empty())
 3941     assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&

 2340     bool hasBitmapData() const { return !IvarsInfo.empty(); }
 2374   if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
 2720   if (RunSkipBlockVars.empty())
 2781   while (!Layout.empty()) {
 3288   if (Properties.empty())
 4209   if (Locals.empty()) return;
 4250   if (Locals.empty()) return;
 4256   assert(!Locals.empty());
 4265   if (Locals.empty()) return;
 4770     assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
 5272   assert(!IvarsInfo.empty() && "generating bitmap for no data");
 5284   assert(buffer.empty());
 5292     if (!buffer.empty() && !(buffer.back() & ScanMask)) {
 5317     if (!buffer.empty()) {
 5380   if (buffer.empty())
 5451     } else if (!ivars.empty()) {
 5466   if (ivars.empty())
 5482    if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
 5586     if (!Asm.empty() && Asm.back() != '\n')

 4769   if ((!IsTargetTask && !Data.FirstprivateVars.empty()) ||
 4927   if (!Data.FirstprivateVars.empty()) {
 5041   if (!Privates.empty()) {
 5073   if (!Privates.empty()) {
 5136   if (!Privates.empty()) {
 5141         (!Data.LastprivateVars.empty() || checkInitIsRequired(CGF, Privates))) {
 5145           /*WithLastIter=*/!Data.LastprivateVars.empty());
 6189   if (!CGF.HaveInsertPoint() || Data.ReductionVars.empty())
 9353         if (CurBasePointers.empty())
 9364       assert(!CurBasePointers.empty() &&
10459   assert(!Sizes.empty() && "Unable to determine NDS and WDS.");

 2046     if (!LastPrivatesReductions.empty()) {
 2051   } else if (!LastPrivatesReductions.empty()) {
 5059   if (!GlobalizedRecords.empty()) {
 5070       if (Records.Records.empty())
 5168   if (!TeamsReductions.empty()) {

  570   assert(!Labels.empty());
 1148   assert(!BreakContinueStack.empty() && "break stmt not in a loop or switch!");
 1160   assert(!BreakContinueStack.empty() && "continue stmt not in a loop!");
 1672   if (!BreakContinueStack.empty())

 2805   if (!S.getSingleClause<OMPNowaitClause>() && CopyprivateVars.empty()) {
 2985     if (!Data.PrivateVars.empty() || !Data.FirstprivateVars.empty() ||
 2985     if (!Data.PrivateVars.empty() || !Data.FirstprivateVars.empty() ||
 2986         !Data.LastprivateVars.empty()) {
 3091     if (!InRedVars.empty()) {
 3224     if (!Data.FirstprivateVars.empty()) {

  901   if (LinkModules.empty())

   93   assert(LifetimeExtendedCleanupStack.empty() && "failed to emit a cleanup");
  296   assert(BreakContinueStack.empty() &&
 2150   if (ReqFeatures.empty())
 2256   if (!RO.Conditions.Features.empty()) {

  596   bool isSEHTryScope() const { return !SEHTryEpilogueStack.empty(); }
  809       if (!Labels.empty())
  814       return !Labels.empty();

  444       (Context.getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
  460   if (!ELFDependentLibraries.empty() && !Context.getLangOpts().CUDAIsDevice) {
 1912   if (UsedArray.empty())
 2030   while (!Stack.empty()) {
 5415     while (!Stack.empty()) {

  454     assert(!BreakContinueStack.empty() && "break not in a loop or switch!");
  462     assert(!BreakContinueStack.empty() && "continue stmt not in a loop!");
  610     if (!BreakContinueStack.empty())

  375     while (!DeferredRecords.empty())
  768     while (!DeferredRecords.empty())

   53   assert(Buffer.empty() && "buffer not current empty");
  170     assert(indices.empty());

  422     if (MappingRegions.empty())
  853     if (MappingRegions.empty())
  925     assert(!BreakContinueStack.empty() && "break not in a loop or switch!");
  934     assert(!BreakContinueStack.empty() && "continue stmt not in a loop!");
 1134     if (!BreakContinueStack.empty())

  296     assert(!Args.empty() && "expected the arglist to not be empty!");
 2570   if (!OrderedInits.empty()) {

 1621   if (Info.PathToIntroducingObject.empty()) {
 2635   assert(fields.empty());
 2887   assert(!fields.empty());

   90       assert(DeferredInlineMemberFuncDefs.empty() ||
  176       if (DeferredInlineMemberFuncDefs.empty())

  266   if (Entries.empty() || Entries.back().End <= begin) {
  452   if (Entries.empty()) {
  486   assert(Entries.empty());
  556   if (Entries.empty()) {
  613   if (Entries.empty()) return false;

  226   assert(!getInputs().empty() && "No dependencies for offload action??");
  270   assert(!getInputs().empty() && "No dependencies for offload action??");

  198   if (FailingCommands.empty())

  796       if (!CfgDir.empty()) {
  807       if (!CfgDir.empty()) {
  899   if (!FixedConfigFile.empty()) {
 1003     if (!CLModePassThroughArgList.empty()) {
 1231   if (!CrashFilePath.empty()) {
 1302   if (Inputs.empty()) {
 1347   if (!FailingCommands.empty()) {
 1354   if (TempFiles.empty()) {
 1371     if (ReproCrashFilename.empty()) {
 1468   if (FailingCommands.empty())
 2226   if (CCCIsCPP() && Inputs.empty()) {
 2321     bool isValid() { return !ToolChains.empty(); }
 2372         assert(!GpuArchList.empty() &&
 2450       if (CudaDeviceActions.empty())
 2546       if (GpuArchList.empty())
 2572       if (CudaDeviceActions.empty())
 2630         if (!DeviceActions.empty()) {
 2690       if (CudaDeviceActions.empty() ||
 2805       if (OpenMPDeviceActions.empty())
 2893       if (OpenMPDeviceActions.empty())
 3016     if (SpecializedBuilders.empty())
 3054     if (DDeps.getActions().empty())
 3137         HostAction->getType() != types::TY_Nothing && !OffloadAL.empty()) {
 3166     if (DeviceAL.empty())
 3197     if (DDeps.getActions().empty()) {
 3337   if (!SuppressMissingInputWarning && Inputs.empty()) {
 3396     if (PL.empty())
 3480   if (!LinkerInputs.empty()) {
 3489   if (!MergerInputs.empty())
 4195   if (!OffloadDependencesInputInfo.empty())
 4296     if (UnbundlingResults.empty())
 4308     if (UnbundlingResults.empty())
 4541     if (BasePath.empty())
 4690     if (Output.empty())

  243         if (!NewIncFlags.empty()) {

  105     assert(!Inputs.empty() && "Must have at least one input.");

  738       if (Path.empty() || llvm::sys::fs::is_directory(Path))
 2758     } else if (Path.empty()) {
 5138       if (F.empty()) {
 5235   if (!StatsFile.empty())
 6123     assert(!SourceAction->getInputs().empty() && "unexpected root action!");

   77     assert(!Inputs.empty() && "Must have at least one input.");

  472     if (Path.empty() || llvm::sys::fs::is_directory(Path))
  488   if (!StatsFile.empty())
  767   return !StaticRuntimes.empty() || !NonWholeStaticRuntimes.empty();
  767   return !StaticRuntimes.empty() || !NonWholeStaticRuntimes.empty();
 1283   if (DeviceInputs.empty())

   97     assert(!SourceAction->getInputs().empty() && "unexpected root action!");
  536   if (!StatsFile.empty()) {

  263     assert(!Inputs.empty() && "Must have at least one input.");

  110     assert(!Inputs.empty() && "Must have at least one input.");

  514     assert(!Inputs.empty() && "Must have at least one input.");

  328   if (BCLibs.empty()) {

 1253     if (!Dirs.empty())

  105     assert(!Inputs.empty() && "Must have at least one input.");

  576     if (Vals.empty()) {

  125     if (!Tok->Children.empty() && Tok->Children.front()->Affected)
  128     IncludeLeadingNewlines = Tok->Children.empty();

  836         !Current.MatchingParen->Children.empty()) {
 1411       Current.Children.empty() &&

 2032       } else if (!IncludesInBlock.empty() && !EmptyLineSkipped) {
 2044   if (!IncludesInBlock.empty()) {
 2187     } else if (Trimmed.size() > 0 && !ImportsInBlock.empty()) {
 2196   if (!ImportsInBlock.empty())
 2638           if (!UnsuitableConfigFiles.empty())
 2651   if (!UnsuitableConfigFiles.empty())

  642     if (Commas.empty())

   49   assert(Tokens.empty());

  138     if (References.empty())
  287       if (Start.isInvalid() || References.empty())

   73   assert(UnwrappedLines.rbegin()->empty());
  115   assert(!UnwrappedLines.empty());

 2640     return !Left.Children.empty(); // No spaces in "{}".
 3023         !Left.Children.empty())
 3127         (!Left.Children.empty() &&

 1067   assert(!Lines.empty());
 1140           if (!Tok->Children.empty())

  285     while (!PPLevelBranchIndex.empty() &&
  290     if (!PPLevelBranchIndex.empty()) {
  295   } while (!PPLevelBranchIndex.empty());
  320       !CommentsBeforeNextToken.empty())
  436       if (LBraceStack.empty())
  499       if (!LBraceStack.empty() && LBraceStack.back()->BlockKind == BK_Unknown)
  507   } while (Tok->Tok.isNot(tok::eof) && !LBraceStack.empty());
  552       CurrentLines->empty()
  703       (!PPStack.empty() && PPStack.back().Kind == PP_Unreachable))
  722   if (!PPStack.empty())
  744   if (!PPStack.empty())
  939       CommentsBeforeNextToken.empty()
 1366             CommentsBeforeNextToken.empty()
 1988   if (CommentsBeforeNextToken.empty() && FormatTok->Tok.is(tok::l_brace)) {
 2482   if (CurrentLines == &Lines && !PreprocessorDirectives.empty()) {
 2665   if (Comments.empty())
 2739     if (!PPStack.empty() && (PPStack.back().Kind == PP_Unreachable) &&

   89   if (Changes.empty())

 2329   if (!Buffer.empty())
 2441   if (Decls->empty() || Decls->back().first <= Offset) {
 2468   if (LocDecls.empty())

  174       assert(!SerialBufs.empty());
  208   assert(!SerialBufs.empty());

  474   if (!SpecificModuleCache.empty() && !getHeaderSearchOpts().DisableModuleHash)
 1401   assert(!TimestampFile.empty());
 1565           while (!Stack.empty()) {

 2051   if (!(P.empty() || llvm::sys::path::is_absolute(P))) {

  332   if (!Module->MissingHeaders.empty()) {

   83   if (Entries.empty())

 1603   if (Stmts.empty() || !isa<ObjCForCollectionStmt>(Stmts.back()))
 1633   if (Stmts.empty() || !isa<ObjCForCollectionStmt>(Stmts.back()))
 1680   assert(!Stmts.empty() && "ObjCForCollectionStmt - Statement stack empty");
 1683   assert(!ObjCBcLabelNo.empty() &&
 3812       if (!IVars.empty()) {
 3821   if (!IVars.empty()) {
 4323                     !Blocks.empty() &&
 4431     (!Blocks.empty()) ? getFunctionSourceLocation(*this, FD)
 5205   if (!InnerBlockDeclRefs.empty()) {
 5578     if (Stmts.empty() || !IsDeclStmtInForeachHeader(DS))
 5616     assert(!Stmts.empty() && "Statement stack is empty");
 7201     if (!DefinedNonLazyClasses.empty()) {
 7232   if (!DefinedNonLazyCategories.empty()) {

 1410   if (Stmts.empty() || !isa<ObjCForCollectionStmt>(Stmts.back()))
 1427   if (Stmts.empty() || !isa<ObjCForCollectionStmt>(Stmts.back()))
 1474   assert(!Stmts.empty() && "ObjCForCollectionStmt - Statement stack empty");
 1477   assert(!ObjCBcLabelNo.empty() &&
 3533   if (CurFunctionDeclToDeclareForBlock && !Blocks.empty())
 3536                     !Blocks.empty() &&
 4358   if (!InnerBlockDeclRefs.empty()) {
 4682     if (Stmts.empty() || !IsDeclStmtInForeachHeader(DS))
 4718     assert(!Stmts.empty() && "Statement stack is empty");

  569   while (End < Length && !PunctuationEndStack.empty()) {
 1152   if (Loc == LastLoc && Ranges.empty() && Hints.empty() &&

  915       if (!USR.empty()) {

   60     assert(!StmtStack.empty() && E == StmtStack.back());

   76   TokenKind top() const { return Tokens.empty() ? pp_none : Tokens.back().K; }
  888     if (!Out.empty() && Out.back() != '\n')
  921       if (Offsets.empty())
  930       if (Offsets.empty())
  938       } while (!Offsets.empty());

  513   if (FrameworkName.empty() || FrameworkName.back() != '/')
  685   return !FrameworkName.empty() && FoundComp >= 2;
  904     if (!MappedName.empty()) {
  913       *IsMapped |= (!MappedName.empty() || (IsInHeaderMap && File));

 2744   while (!ConditionalStack.empty()) {

 1563       if (UDSuffixBuf.empty()) {

   42   if (ReplacementTokens.empty())

  112   if (Unresolved.Id.empty()) {
  166   if (Paths.empty())
  628         if (UmbrellaModule->InferExportWildcard && Result->Exports.empty())
  644       if (UmbrellaModule->InferExportWildcard && Result->Exports.empty())
 1277   return !Mod->UnresolvedExports.empty();
 1290   return !Mod->UnresolvedDirectUses.empty();
 2085       ActiveModule->LinkLibraries.empty()) {

  113   assert(!CondDirectiveStack.empty());

 2324       if (Parameters.empty())  // #define FOO()

  314       !BuildingSubmoduleStack.empty() &&
  710   if (BuildingSubmoduleStack.empty())
  722   if (BuildingSubmoduleStack.empty() ||

  207   while (!Worklist.empty()) {
  290   while (!Worklist.empty()) {
  530       if (!DelayedMacroExpandsCallbacks.empty()) {
  636       if (Brackets.empty() || Brackets.back() == Brace)
  642       if (Brackets.empty() || Brackets.back() == Paren)
  647   return Brackets.empty();
  746   return !ParenHints.empty() && InitLists.empty();
  746   return !ParenHints.empty() && InitLists.empty();
  815           if (!ArgTokens.empty() &&
  864     if (ArgTokens.empty() && Tok.getKind() == tok::r_paren)
  919       if (!InitLists.empty()) {

  142     assert(!Tokens.empty() && "collected unexpected number of tokens");
  771     if (LexModuleNameComponent(PP, Tok, NameComponent, ModuleName.empty()))

 1127   if (ModuleImportPath.empty() && getLangOpts().CPlusPlusModules) {
 1232   if (ModuleImportPath.empty() || Result.is(tok::eof))
 1278   if (!Suffix.empty()) {
 1298   if (!BuildingSubmoduleStack.empty() && M != BuildingSubmoduleStack.back().M)

  160   if (ResultToks.empty() || !ResultToks.back().is(tok::comma))
  170   if (!ResultToks.empty()) {
  406       !ResultToks.empty() && ResultToks.back().is(tok::hashhash);

  495   assert(!LM.Toks.empty() && "Empty body!");
  590   if (!Class.LateParsedDeclarations.empty()) {

  365   if (!ArgExprs.empty() ? Tok.is(tok::comma) : Tok.isNot(tok::r_paren)) {
  367     if (!ArgExprs.empty())
 1446   if (!Class.LateParsedDeclarations.empty()) {
 2436       assert(!Exprs.empty() && Exprs.size()-1 == CommaLocs.size() &&
 6054     if (!Bindings.empty()) {
 6090     if (Bindings.empty())

  112   if (!ExtraNSs.empty() && attrLoc.isValid())
  154   if (ExtraNSs.empty()) {
 3778                                         Exceptions.empty());
 3779   return Exceptions.empty() ? EST_DynamicNone : EST_Dynamic;
 3836   if (Victim->LateParsedDeclarations.empty()) {

 1273     if (TemplateParams.empty()) {
 2971     if (PlacementArgs.empty()) {
 3323   if (!Arity && Args.empty()) {

  334     if (!ProtocolIdents.empty()) {
  344   } else if (protocols.empty() && Tok.is(tok::less) &&
 1803     if (!protocols.empty()) {
 2248   assert(LateParsedObjCMethods.empty());
 3641   assert(!LM.Toks.empty() && "ParseLexedObjCMethodDef - Empty body!");

  298   if (ReductionTypes.empty()) {
  459       assert(!Exprs.empty() && Exprs.size() - 1 == CommaLocs.size() &&
  580   if (Clauses.empty()) {
 1197   if (Decls.empty())
 2771           Vars.empty()) ||
 2772          (Kind != OMPC_depend && Kind != OMPC_map && Vars.empty()) ||

 1366     if (SubjectMatchRuleSet.empty()) {
 1982   assert(!Identifiers.empty() && "Valid '#pragma unused' must have arguments");
 3246     if (AttributeTokens.empty()) {

 2259     if (Handlers.empty())

  564   assert(!LBraceLocs.empty() && "Should have at least one location here");
  568   if (!TheTarget || AsmToks.empty()) {

  127     if (!TemplateParams.empty()) {
 1494   assert(!LPT.Toks.empty() && "Empty body!");

  432       !PP.isIncrementalProcessingEnabled() && !TemplateIds.empty()) {
  440   assert(TemplateIds.empty() && "Still alive TemplateIdAnnotations around?");
 2346   else if (!Path.empty())

  228   while (!WorkList.empty()) {
  289   while (!Stack.empty()) {
 1406   if (UsesByStmt.empty())
 1541       if (!vec->empty() && hasSelfInit && hasAlwaysUninitializedUse(vec))
 2095   if (!fscope->PossiblyUnreachableDiags.empty()) {

 1311       if (!SpecName.empty()) SpecName += " ";

  603   while (!Jumps.empty()) {
  667   if (GotoJumps.empty())
  673   if (JumpTargets.empty()) {
  856   if (!Diagnosed && !ToScopesCXX98Compat.empty()) {
  915   if (!ToScopesWarning.empty()) {
  921   if (!ToScopesError.empty()) {
  927   if (ToScopesError.empty() && !ToScopesCXX98Compat.empty()) {
  927   if (ToScopesError.empty() && !ToScopesCXX98Compat.empty()) {

   66   if (index < FreeLists.size() && !FreeLists[index].empty()) {

  112       if (!IncludeStack.empty()) {
  548     if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
  716   if (Undefined.empty()) return;
  933   assert(LateParsedInstantiations.empty() &&
  965         !ModuleScopes.empty() && ModuleScopes.back().Module->Kind ==
  991   assert(DelayedOverridingExceptionSpecChecks.empty());
  992   assert(DelayedEquivalentExceptionSpecChecks.empty());
  995   assert(DelayedDllExportClasses.empty());
  996   assert(DelayedDllExportMemberFunctions.empty());
 1043   if (!ModuleScopes.empty() &&
 1056         (ModuleScopes.empty() ||
 1072       while (!Stack.empty()) {
 1529   while (!Worklist.empty()) {
 1633   if (FunctionScopes.empty() && CachedFunctionScope) {
 1739   assert(!FunctionScopes.empty() && "mismatched push/pop!");
 1774   assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
 1786   if (!FunctionScopes.empty())
 1791   if (!FunctionScopes.empty())
 1796   if (!FunctionScopes.empty())
 1801   if (FunctionScopes.empty())
 1808     assert(!CodeSynthesisContexts.empty());
 1816   if (FunctionScopes.empty())
 1834         assert(!CodeSynthesisContexts.empty());
 1844   if (FunctionScopes.empty())
 1859     assert(!CodeSynthesisContexts.empty());
 2175   if (FunctionScopes.empty())
 2199   if (Exts.empty())

  320     if (Queue.empty()) break;
  512   if (EC.Functions.empty()) return AR_inaccessible;
  676     assert(CurPath.empty());
  791         if (S.getLangOpts().MSVCCompat && !EC.Functions.empty())

   63   if (PackIncludeStack.empty())
  241     if (PackStack.Stack.empty()) {
  328     if (PackStack.Stack.empty())
  346         (PackIncludeStack.empty() ||
  370   if (PackStack.Stack.empty())
  420   if (Action & PSK_Pop && VtorDispStack.Stack.empty())
  451     } else if (!Stack.empty()) {
  523   if (Action & PSK_Pop && Stack->Stack.empty())
  664   if (StrictSubjectMatchRuleSet.empty()) {
  756   if (PragmaAttributeStack.empty()) {
  774   if (PragmaAttributeStack.empty()) {
  808   if (PragmaAttributeStack.empty())
  844   if (PragmaAttributeStack.empty())

12461   } while (!Exprs.empty());
12986   while (!WorkList.empty()) {

  680   while (!TargetParents.empty()) {
 2211         !SemaRef.getCurFunction()->SwitchStack.empty()) {
 4963   if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
 8678     if (!NativeRelDir.empty()) {
 8704             NativeRelDir.empty() && !Filename.consume_back(".framework"))

 1190   if (!OperatorNew && !PlacementArgs.empty()) {

 8001             MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1;
 8460       assert(!HistoryStack.empty());
 8538   } while (!VisitStack.empty());
12468      if (Context.DeclMustBeEmitted(var) && !ModuleScopes.empty())
12557   if (Context.DeclMustBeEmitted(var) && !ModuleScopes.empty())
16368   if (LangOpts.ObjCRuntime.isFragile() || AllIvarDecls.empty())

  780   if (Args.empty())
 1470   if (NonNullArgs.empty() && AL.getLoc().isFileID() &&
 6112   if (Args.empty())
 8341     if (StmtStack.empty())

  754     if (!BadSpecifiers.empty()) {
  762     } else if (!CPlusPlus20Specifiers.empty()) {
 2237     if (ReturnStmts.empty()) {
 2393     if (Queue.empty())
 2804   assert(BasePathArray.empty() && "Base path array must be empty!");
 2983     if (!OverloadedMethods.empty()) {
 7102   while (!Classes.empty()) {
 8313   if (!OverloadedMethods.empty()) {
11836   if (!DelayedDllExportMemberFunctions.empty()) {
11853   if (!DelayedDllExportClasses.empty()) {
12745     while (!Worklist.empty()) {
14534   if (!CodeSynthesisContexts.empty()) {
15652   if (VTableUses.empty())
15794     if (ivars.empty())
16073         if (!Unexpanded.empty()) {

 3492   if (!Methods.empty())

 1952             !CodeSynthesisContexts.empty() &&
14203   if (!Params.empty()) {
14977   if (Folded && getLangOpts().CPlusPlus11 && Notes.empty()) {
15157   if (!Rec.Lambdas.empty()) {

 1444   if (Result || !getLangOpts().CUDA || PreventedBy.empty())
 2078     if (!AllPlaceArgs.empty())
 2626   } else if (!Matches.empty()) {
 2932   if (!Matches.empty()) {
 3132   if (!NewExprs.empty())
 3154   return NewExprs.empty();
 7930   if (E && !ExprEvalContexts.empty() && ExprEvalContexts.back().NumTypos &&

 2793       if (!Methods.empty()) {
 2853             if (!Methods.empty()) {
 2941               if (!Methods.empty()) {

 3513   return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization;
 7379       if (Path.empty()) {
 7435           if (Path.empty() ||
 7822   if (Steps.empty())
 8392       assert(!ArrayLoopCommonExprs.empty() &&

  229   if (!LSI->GLTemplateParameterList && !LSI->TemplateParams.empty()) {
  527   assert(LSI->TemplateParams.empty() &&
  724   if (CSI.Returns.empty()) {
 1065       if (!LSI->Captures.empty())
 1217     if (!LSI->Captures.empty())
 1780     if (Captures.empty() && CaptureDefault == LCD_None)

  166         if (queue.empty())
  615   if (!EquivalentNonFunctions.empty() && !Ambiguous)
 1741     if (VisibleWithinParent && SemaRef.CodeSynthesisContexts.empty() &&
 2081   while (!Queue.empty()) {
 2776   while (!Bases.empty()) {
 2963     if (Queue.empty())
 4122   bool AnyVisibleDecls = !NewDecls.empty();
 4136   if (NewDecls.empty())
 4263   if (!CList.empty() && !CList.back().isResolved())
 4280   if (CList.empty() || Correction.isResolved())
 4330     if (RI->second.empty()) {
 4537     if (NamespaceDeclChain.empty() || NamespaceDeclChain.back() != C)
 4546   if (NamespaceDeclChain.empty()) {
 4579   if (NNS && !CurNameSpecifierIdentifiers.empty()) {
 4767           !SemaRef.getCurFunction()->SwitchStack.empty()) {
 4825   if (!CodeSynthesisContexts.empty())
 5372   if (UniqueModules.empty()) {

   61   if (!ModuleScopes.empty() &&
  132   if (!ModuleScopes.empty() &&
  142   if (!ModuleScopes.empty() &&
  151         ModuleScopes.empty()
  253   switch (ModuleScopes.empty() ? Module::GlobalModuleFragment
  392   if (!ModuleScopes.empty())
  396   if (!ModuleScopes.empty() && ModuleScopes.back().ModuleInterface) {
  430     if (!ModuleScopes.empty())
  472   assert(!ModuleScopes.empty() && ModuleScopes.back().Module == Mod &&
  536   if (ModuleScopes.empty() || !ModuleScopes.back().Module->isModulePurview()) {

  856   if (Properties.empty())
  949   if (Mismatches.empty())

  183     return Stack.empty() ? const_iterator()
  187     return Stack.empty() ? const_iterator() : Stack.back().first.rend();
  191     return Stack.empty() ? iterator()
  195     return Stack.empty() ? iterator() : Stack.back().first.rend();
  201     return Stack.empty() ||
  312     if (Stack.empty() ||
  322     assert(!Stack.back().first.empty() &&
  392     if (!Stack.empty() && Stack.back().second == OldFSI) {
  393       assert(Stack.back().first.empty());
 2495   if (!Vars.empty()) {
 2654   if (Vars.empty())
 3705   if (!LCs.empty() && OC && OC->getNumForLoops()) {
 4288     if (!ImplicitFirstprivates.empty()) {
 4299     if (!ImplicitMaps.empty()) {
 4339     assert(ClausesWithImplicit.empty() &&
 4348     assert(ClausesWithImplicit.empty() &&
 4377     assert(ClausesWithImplicit.empty() &&
 4384     assert(ClausesWithImplicit.empty() &&
 4391     assert(ClausesWithImplicit.empty() &&
 4436     assert(ClausesWithImplicit.empty() &&
 4683   if (!AllowedNameModifiers.empty())
12141   if (Vars.empty())
12441   if (Vars.empty())
12601   if (Vars.empty())
12655   if (Vars.empty())
13538       if (!BasePath.empty()) {
13680   return RD.Vars.empty();
13884   if (Vars.empty())
14099   if (Vars.empty())
14193   if (Vars.empty())
14306   if (Vars.empty())
14477       Vars.empty())
15340     assert(!CurComponents.empty() &&
15599         (ParentFn != nullptr) && !ParentFn->CompoundScopes.empty();
15851         (ParentFn != nullptr) && !ParentFn->CompoundScopes.empty();
16358   if (MVLI.ProcessedVarList.empty())
16375   if (MVLI.ProcessedVarList.empty())
16461   if (MVLI.ProcessedVarList.empty())
16543   if (MVLI.ProcessedVarList.empty())
16605   if (Vars.empty())

 1553           NewParamInfos.empty() ? nullptr : NewParamInfos.data();
 5602     if (Notes.empty()) {
 6502   if (Attrs.empty())
 9648   while (!PendingBest.empty()) {
 9673   if (!EquivalentCands.empty())
11551     assert(Ret || Matches.empty());
11610     assert(Matches.empty());

  433   if (getCurFunction()->SwitchStack.empty())
  482   if (getCurFunction()->SwitchStack.empty()) {
  506   if (getCurFunction()->SwitchStack.empty()) {
  981     if (!CaseVals.empty()) {
 1227       if (TheDefaultStmt && UnhandledNames.empty() && ED->isClosedNonFlag())
 1231       if (!UnhandledNames.empty()) {
 1297           if (EnumVals.empty())
 2913   if (!S.CurrentSEHFinally.empty() &&

   38   if (FnScope->SwitchStack.empty()) {
  358   if (Attrs.empty())

 5300         if (!ArgumentPack.empty()) {
 5321       if ((*Param)->isTemplateParameterPack() && !ArgumentPack.empty())
 8933   assert(S.DelayedDllExportClasses.empty() &&
10399     if (Modules.empty())

  739     assert(!Packs.empty() && "Pack expansion without unexpanded packs?");
  844       if (!Pack.New.empty() || !DeducedArg.isNull()) {
  879       if (PackElements && Pack.New.empty()) {
  889       } else if (Pack.New.empty()) {
 1798       while (!ToVisit.empty()) {
 2562     if (PackedArgsBuilder.empty()) {
 3035   if (!Builder.empty()) {

 1652   assert(!CodeSynthesisContexts.empty() &&
 1669   assert(!CodeSynthesisContexts.empty() &&
 1699   assert(!CodeSynthesisContexts.empty() &&
 1744   assert(!CodeSynthesisContexts.empty() &&
 1922   assert(!CodeSynthesisContexts.empty() &&

  114   assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
 3817   assert(Params.empty() && "parameter vector is non-empty at start");

  316     if (LambdaParamPackReferences.empty()) {
  393   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
  407   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
  423   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
  460   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
  474   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
  487   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");

  234       trivial &= savedAttrs.empty();
 2811       if (!QualStr.empty()) QualStr += ' ';
 4344   if (S.CodeSynthesisContexts.empty()) {
 5144         if (!RemovalLocs.empty()) {
 7920       if (CodeSynthesisContexts.empty() &&
 8385   if (AsUnevaluated && CodeSynthesisContexts.empty() &&

 3520     assert(NewArgs.empty() &&
 3548       assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
 3678   while (!Qualifiers.empty()) {
 4153       assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
 5515       assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
 6517       assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
12158   assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
12338       assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
12761   if (!params.empty())

  414   if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
  426   return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
  426   return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
 3230       if (SpecialTypes.empty()) {
 3323       if (!Record.empty()) {
 3334       if (!Record.empty()) {
 3361       if (!Record.empty() && Listener)
 3418       if (!F.PreloadSLocEntries.empty()) {
 4012   while (!Stack.empty()) {
 4704       if (F->PragmaDiagMappings.empty())
 4916   if (!CUDASpecialDeclRefs.empty()) {
 6165     if (Record.empty())
 6290       if (T.empty())
 7845       if (Merged.empty())
 8073   return !Decls.empty();
 8178   if (!SelectorsLoaded.empty())
 8297   if (!FPPragmaOptions.empty()) {
 8314   if (!SemaDeclRefs.empty()) {
 8346     if (!PragmaPackStack.empty() &&
 8727   if (ReferencedSelectorsData.empty())
 8745   if (WeakUndeclaredIdentifiers.empty())
 9854   while (!PendingIdentifierInfos.empty() || !PendingFunctionTypes.empty() ||
 9855          !PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() ||
 9855          !PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() ||
 9857          !PendingUpdateRecords.empty()) {
 9943     while (!PendingUpdateRecords.empty()) {
10063   if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty() &&
10117   while (!PendingOdrMergeChecks.empty()) {
10179       if (Candidates.empty())

  266       if (IDs.empty())
 4021   assert((PendingLazySpecializationIDs.empty() || isa<ClassTemplateDecl>(D) ||

   63       if (Found.empty() && !Data.empty()) {

 2118     while (!Worklist.empty()) {
 2579     while (!Worklist.empty()) {
 2600     if (Record.empty() && !EmittedModuleMacros)
 3037     if (!Mod->Exports.empty()) {
 3078     if (!Inits.empty())
 3857   if (!InterestingIdents.empty())
 4179   if (!ConstructorDecls.empty())
 4182   if (!ConversionDecls.empty())
 4822   if (!SemaRef.VTableUses.empty()) {
 4941     if (Record.empty())
 5101   if (!DeclUpdatesOffsetsRecord.empty())
 5128   if (!EagerlyDeserializedDecls.empty())
 5131   if (!ModularCodegenDecls.empty())
 5135   if (!TentativeDefinitions.empty())
 5139   if (!UnusedFileScopedDecls.empty())
 5143   if (!WeakUndeclaredIdentifiers.empty())
 5148   if (!ExtVectorDecls.empty())
 5152   if (!VTableUses.empty())
 5156   if (!UnusedLocalTypedefNameCandidates.empty())
 5161   if (!PendingInstantiations.empty())
 5165   if (!SemaDeclRefs.empty())
 5169   if (!CUDASpecialDeclRefs.empty())
 5173   if (!DelegatingCtorDecls.empty())
 5177   if (!KnownNamespaces.empty())
 5181   if (!UndefinedButUsed.empty())
 5184   if (!DeleteExprsToAnalyze.empty())
 5205     if (!Imports.empty()) {
 5754   if (Decls.empty() || Decls.back().first <= Offset) {
 5881   while(!NestedNames.empty()) {
 5928   while(!NestedNames.empty()) {

 1756       if (LocalRedecls.empty())

  354     while (!Queue.empty()) {
  385   if (ModuleFilesHit && !ModulesInCommonWithGlobalIndex.empty()) {
  423       if (State->Stack.empty())

   89   while (!worklist.empty()) {

  183       *BT_null, buf.empty() ? BT_null->getDescription() : StringRef(buf), N);

  203       return SrcArgs.empty() && DstArgs.empty() &&
  203       return SrcArgs.empty() && DstArgs.empty() &&

 1329   if (!MatchingStatements.empty()) {
 1357   if (!MatchingStatements.empty()) {

   71   if (ReqRegions.empty())

 2664   if (!Errors.empty()) {

  273   if (PossibleMallocOverflows.empty())

  268     while (!Fields.empty()) {

 1432   if (Leaked.empty()) {

  326   if (Cb.V.empty())

  566     if (Accesses.empty())
  572     if (Guards.empty())

 1179     if (!C.CallStack.empty()) {
 2331   if (Ranges.empty() && isa_and_nonnull<Expr>(getStmt()))
 2550   if (ReportNodes.empty())
 2947     while (!WL.empty()) {
 2978       if (!WL.empty() && &WL.back() == &WI)

 2443   if (LhsString.empty() || RhsString.empty() ||
 2443   if (LhsString.empty() || RhsString.empty() ||

  731     if (TempBuf.empty())
  747     if (TempBuf.empty())

  464   while (!WL1.empty()) {
  482   if (WL2.empty())
  489   while (!WL2.empty()) {

  191     if (!Match.empty())
  208   if (Matches.empty())

  622     while (!WorkList.empty()) {