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

References

include/llvm/ADT/ilist.h

  250     pointer Node = &*IT++;

include/llvm/ADT/simple_ilist.h

  198     remove(*I++);
  278       iterator RunStart = RI++;

include/llvm/CodeGen/MachineBasicBlock.h

  949     It++;

include/llvm/IR/InstVisitor.h

   91       static_cast<SubClass*>(this)->visit(*Start++);

lib/Analysis/AliasSetTracker.cpp

  311     iterator Cur = I++;
  338     iterator Cur = I++;
  613   for (iterator I = begin(), E = end(); I != E; I++)

lib/Analysis/Loads.cpp

  400     ScanFrom++;

lib/Analysis/MemorySSAUpdater.cpp

 1384     removeMemoryAccess(&*(BBI++));

lib/AsmParser/LLParser.cpp

  236     UpgradeCallsToIntrinsic(&*FI++); // must be post-increment, as we remove
  242     Function *F = &*FI++;

lib/CodeGen/BranchFolding.cpp

 1281     MachineBasicBlock *MBB = &*I++;
 1834     MachineBasicBlock *MBB = &*I++;

lib/CodeGen/CodeGenPrepare.cpp

  476       BasicBlock *BB = &*I++;
 1579       TruncInsertPt++;
 7093     MadeChange |= optimizeInst(&*CurInstIterator++, ModifiedDT);
 7121       Instruction *Insn = &*BI++;

lib/CodeGen/GCRootLowering.cpp

  198       IntrinsicInst *CI = dyn_cast<IntrinsicInst>(II++);

lib/CodeGen/IfConversion.cpp

 1446     PI = I++;

lib/CodeGen/MachineBlockPlacement.cpp

 2917           PrevUnplacedBlockIt++;

lib/CodeGen/ModuloSchedule.cpp

  755         MI++->eraseFromParent();
 1658       MachineInstr *MI = &*I++;

lib/CodeGen/ScalarizeMaskedMemIntrin.cpp

  818       BasicBlock *BB = &*I++;
  838     if (CallInst *CI = dyn_cast<CallInst>(&*CurInstIterator++))

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

 8536     SDNode *N = &*I++;

lib/CodeGen/ShadowStackGCLowering.cpp

  238       if (IntrinsicInst *CI = dyn_cast<IntrinsicInst>(II++))

lib/CodeGen/StackProtector.cpp

  412     BasicBlock *BB = &*I++;

lib/CodeGen/TailDuplicator.cpp

  269     MachineBasicBlock *MBB = &*I++;

lib/CodeGen/WinEHPrepare.cpp

  694     BasicBlock *BB = &*FI++;
  701       Instruction *I = &*BI++;
 1009     BasicBlock *BB = &*FI++;

lib/ExecutionEngine/Interpreter/Execution.cpp

 2164     Instruction &I = *SF.CurInst++;         // Increment before execute

lib/IR/DebugInfo.cpp

  323       Instruction &I = *II++; // We may delete the instruction, increment now.

lib/Linker/LinkModules.cpp

  487     GlobalAlias &GV = *I++;
  492     GlobalVariable &GV = *I++;
  497     Function &GV = *I++;

lib/Target/AMDGPU/AMDGPUISelDAGToDAG.cpp

 2716       SDNode *Node = &*Position++;

lib/Target/AMDGPU/AMDGPUMachineCFGStructurizer.cpp

 2489   AfterExitIter++;

lib/Target/AMDGPU/GCNILPSched.cpp

  259     auto &C = *I++;

lib/Target/AMDGPU/GCNMinRegStrategy.cpp

  129       auto &Cand = *I++;

lib/Target/AMDGPU/R600Packetizer.cpp

   76       BI++;

lib/Target/AMDGPU/SIInsertWaitcnts.cpp

 1108          &*II != &MI; II = NextI, NextI++) {

lib/Target/ARM/ARMISelDAGToDAG.cpp

  353     SDNode *N = &*I++; // Preincrement iterator to avoid invalidation issues.

lib/Target/BPF/BPFISelDAGToDAG.cpp

  314   I++;
  330     SDNode *Node = &*I++;
  494   I++;

lib/Target/Hexagon/HexagonISelDAGToDAG.cpp

 2234     SDNode *N = &*I++;

lib/Target/Hexagon/HexagonVectorPrint.cpp

  174         MII++;
  177       MII++;

lib/Target/NVPTX/NVPTXAllocaHoisting.cpp

   43   Instruction *firstTerminatorInst = (I++)->getTerminator();
   47       AllocaInst *allocaInst = dyn_cast<AllocaInst>(BI++);

lib/Target/NVPTX/NVPTXGenericToNVVM.cpp

   79     GlobalVariable *GV = &*I++;

lib/Target/PowerPC/PPCEarlyReturn.cpp

  185         MachineBasicBlock &B = *I++;

lib/Target/PowerPC/PPCTLSDynamicCall.cpp

  159         MachineBasicBlock &B = *I++;

lib/Target/PowerPC/PPCTOCRegDeps.cpp

  135         MachineBasicBlock &B = *I++;

lib/Target/PowerPC/PPCVSXCopy.cpp

  152         MachineBasicBlock &B = *I++;

lib/Target/PowerPC/PPCVSXFMAMutate.cpp

  364         MachineBasicBlock &B = *I++;

lib/Target/SystemZ/SystemZISelDAGToDAG.cpp

 1893     SDNode *N = &*I++;

lib/Target/X86/X86CmovConversion.cpp

  599   for (auto I = First->getIterator(), E = Last->getIterator(); I != E; I++) {

lib/Target/X86/X86FlagsCopyLowering.cpp

  540         MachineInstr &MI = *MII++;

lib/Target/X86/X86ISelDAGToDAG.cpp

  792     SDNode *N = &*I++; // Preincrement iterator to avoid invalidation issues.

lib/Target/X86/X86SpeculativeLoadHardening.cpp

  855       MachineInstr &MI = *MII++;

lib/Transforms/IPO/ConstantMerge.cpp

  157       GlobalVariable *GV = &*GVI++;
  203       GlobalVariable *GV = &*GVI++;

lib/Transforms/IPO/DeadArgumentElimination.cpp

 1094     Function &F = *I++;
 1112     Function *F = &*I++;

lib/Transforms/IPO/GlobalOpt.cpp

 2257     Function *F = &*FI++;
 2264     Function *F = &*FI++;
 2359     GlobalVariable *GV = &*GVI++;
 2762     GlobalAlias *J = &*I++;

lib/Transforms/IPO/PruneEH.cpp

  205       if (CallInst *CI = dyn_cast<CallInst>(I++))

lib/Transforms/IPO/StripDeadPrototypes.cpp

   33     Function *F = &*I++;
   45     GlobalVariable *GV = &*I++;

lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

  145     Function &F = *I++;
  166     GlobalVariable &GV = *I++;

lib/Transforms/InstCombine/InstCombinePHI.cpp

  184        II != EI; II++, NumPhis++) {
  264         InsertPos++;

lib/Transforms/InstCombine/InstructionCombining.cpp

 2501     Instruction &Instr = *It++;
 3389       Instruction *Inst = &*BBI++;

lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

 1231       Instruction *I = &*II++;

lib/Transforms/Instrumentation/InstrProfiling.cpp

  414       auto Instr = I++;
  519       for (auto I = BB.begin(), E = BB.end(); I != E; I++)

lib/Transforms/Instrumentation/PoisonChecking.cpp

  262     for (auto I = BB.begin(); isa<PHINode>(&*I); I++) {
  302     for (auto I = BB.begin(); isa<PHINode>(&*I); I++) {

lib/Transforms/ObjCARC/ObjCARCAPElim.cpp

   95     Instruction *Inst = &*I++;

lib/Transforms/Scalar/CallSiteSplitting.cpp

  396     Instruction *CurrentI = &*I++;
  514     BasicBlock &BB = *BI++;
  522       Instruction *I = &*II++;

lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

  840       Instruction *II = &*BI++;

lib/Transforms/Scalar/DCE.cpp

   55         Instruction *Inst = &*DI++;

lib/Transforms/Scalar/DeadStoreElimination.cpp

 1096     Instruction *Inst = &*BBI++;

lib/Transforms/Scalar/EarlyCSE.cpp

  900     Instruction *Inst = &*I++;

lib/Transforms/Scalar/GVN.cpp

 2103     BasicBlock *BB = &*FI++;
 2436       Instruction *CurInst = &*BI++;

lib/Transforms/Scalar/GVNSink.cpp

  615     while (PHINode *PN = dyn_cast<PHINode>(I++)) {

lib/Transforms/Scalar/IndVarSimplify.cpp

  606     while ((PN = dyn_cast<PHINode>(BBI++))) {

lib/Transforms/Scalar/LICM.cpp

  827       Instruction &I = *II++;

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

  643     Instruction *Inst = &*I++;
 1343          Iter != IterE; Iter++) {
 1468        Iter != IterE; Iter++) {

lib/Transforms/Scalar/LoopRerollPass.cpp

 1440       J++->eraseFromParent();

lib/Transforms/Scalar/LoopSink.cpp

  298     Instruction *I = &*II++;

lib/Transforms/Scalar/LoopUnswitch.cpp

 1630         while (PHINode *PN = dyn_cast<PHINode>(SuccIt++)) {

lib/Transforms/Scalar/LowerAtomic.cpp

  120     Instruction *Inst = &*DI++;

lib/Transforms/Scalar/LowerExpectIntrinsic.cpp

  338       Instruction *Inst = &*BI++;

lib/Transforms/Scalar/MemCpyOptimizer.cpp

 1349       Instruction *I = &*BI++;

lib/Transforms/Scalar/MergedLoadStoreMotion.cpp

  357     BasicBlock *BB = &*FI++;

lib/Transforms/Scalar/NewGVN.cpp

 3690     Instruction &Inst = *I++;

lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp

   95     CurrBB = BB++;

lib/Transforms/Scalar/PlaceSafepoints.cpp

  271        BBI != BBE0 && BBI != BBE1; BBI++) {
  647   After++;

lib/Transforms/Scalar/Reassociate.cpp

 2414         EraseInst(&*II++);

lib/Transforms/Scalar/SCCP.cpp

 1843       Instruction *Inst = &*BI++;
 2095         Instruction *Inst = &*BI++;
 2165         Instruction *Inst = &*BI++;

lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp

 1128       if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(I++))
 1204       Instruction *Cur = &*I++;

lib/Transforms/Scalar/SimplifyCFGPass.cpp

   79     BasicBlock &BB = *BBI++;
  163       if (simplifyCFG(&*BBIt++, TTI, Options, &LoopHeaders)) {

lib/Transforms/Scalar/TailRecursionElimination.cpp

  585         if (AllocaInst *AI = dyn_cast<AllocaInst>(OEBI++))
  782     BasicBlock *BB = &*BBI++; // foldReturnAndProcessPred may delete BB.

lib/Transforms/Utils/BasicBlockUtils.cpp

  534     PHINode *PN = cast<PHINode>(I++);

lib/Transforms/Utils/BreakCriticalEdges.cpp

  448       Direct++;
  452       Indirect++;

lib/Transforms/Utils/CloneFunction.cpp

  589       while ((PN = dyn_cast<PHINode>(I++))) {
  675       BasicBlock *DeadBB = &*I++;

lib/Transforms/Utils/EscapeEnumerator.cpp

   35     BasicBlock *CurBB = &*StateBB++;

lib/Transforms/Utils/FlattenCFG.cpp

  192         Instruction *CI = &*BI++;

lib/Transforms/Utils/InlineFunction.cpp

  527     Instruction *I = &*BBI++;
 1826       AllocaInst *AI = dyn_cast<AllocaInst>(I++);
 1884         Instruction &I = *II++;
 2057         Instruction *I = &*BBI++;

lib/Transforms/Utils/Local.cpp

 1112   for (auto I = BB->begin(); PHINode *PN = dyn_cast<PHINode>(I++);) {
 1933     BB->getInstList().erase(BBI++);

lib/Transforms/Utils/LoopRotationUtils.cpp

  325     Instruction *Inst = &*I++;

lib/Transforms/Utils/LoopSimplify.cpp

  594        (PN = dyn_cast<PHINode>(I++)); )

lib/Transforms/Utils/LoopUnroll.cpp

  221       Instruction *Inst = &*I++;

lib/Transforms/Utils/LowerSwitch.cpp

  162     BasicBlock *Cur = &*I++; // Advance over block so we don't traverse new blocks

lib/Transforms/Utils/PromoteMemoryToRegister.cpp

  757     while ((SomePHI = dyn_cast<PHINode>(BBI++)) &&
  933     Instruction *I = &*II++; // get the instruction, increment iterator

lib/Transforms/Utils/SimplifyCFG.cpp

 1250   Instruction *I1 = &*BB1_Itr++, *I2 = &*BB2_Itr++;
 1250   Instruction *I1 = &*BB1_Itr++, *I2 = &*BB2_Itr++;
 1256       I1 = &*BB1_Itr++;
 1258       I2 = &*BB2_Itr++;
 1330     I1 = &*BB1_Itr++;
 1331     I2 = &*BB2_Itr++;
 1337         I1 = &*BB1_Itr++;
 1339         I2 = &*BB2_Itr++;
 2331     PHINode *PN = cast<PHINode>(II++);
 4026       PHINode *PN = cast<PHINode>(I++);
 5780       I++;

lib/Transforms/Vectorize/LoopVectorize.cpp

 3203     Instruction *In = &*I++;

lib/Transforms/Vectorize/SLPVectorizer.cpp

 4449       Instruction *In = &*it++;

lib/Transforms/Vectorize/VPlan.h

  718     Begin = End++;
  735     End++;

lib/Transforms/Vectorize/VPlanHCFGTransforms.cpp

   47       VPRecipeBase *Ingredient = &*I++;

tools/bugpoint/CrashDebugger.cpp

  699       simplifyCFG(&*BBIt++, TTI);
  778         Instruction *Inst = &*I++;

tools/llvm-extract/llvm-extract.cpp

  174          GA != E; GA++) {
  241          F++) {

tools/polly/lib/CodeGen/BlockGenerators.cpp

  400   for (auto I = NewBB->rbegin(); I != NewBB->rend(); I++) {

unittests/ADT/IListIteratorTest.cpp

  112   L.remove(*I++);
  114   L.remove(*I++);
  127   L.remove(*RI++);
  129   L.remove(*RI++);

unittests/ADT/SimpleIListTest.cpp

  241   EXPECT_EQ(&A, &*I++);
  242   EXPECT_EQ(&B, &*I++);
  243   EXPECT_EQ(&C, &*I++);
  244   EXPECT_EQ(&D, &*I++);
  245   EXPECT_EQ(&E, &*I++);
  265   EXPECT_EQ(&A, &*I++);
  266   EXPECT_EQ(B, &*I++);
  267   EXPECT_EQ(C, &*I++);
  268   EXPECT_EQ(D, &*I++);
  269   EXPECT_EQ(&E, &*I++);
  290   EXPECT_EQ(&A, &*I++);
  291   EXPECT_EQ(&B, &*I++);
  292   EXPECT_EQ(&C, &*I++);
  293   EXPECT_EQ(&D, &*I++);
  294   EXPECT_EQ(&E, &*I++);
  354   EXPECT_EQ(&A, &*I++);
  355   EXPECT_EQ(&B, &*I++);
  356   EXPECT_EQ(&C, &*I++);
  357   EXPECT_EQ(&D, &*I++);
  377   EXPECT_EQ(&A, &*I++);
  378   EXPECT_EQ(&B, &*I++);
  379   EXPECT_EQ(&C, &*I++);
  383   EXPECT_EQ(&D, &*I++);
  384   EXPECT_EQ(&E, &*I++);
  405   EXPECT_EQ(&A, &*I++);
  406   EXPECT_EQ(&B, &*I++);
  407   EXPECT_EQ(&C, &*I++);
  408   EXPECT_EQ(&D, &*I++);
  412   EXPECT_EQ(&E, &*I++);
  413   EXPECT_EQ(&F, &*I++);
  451       EXPECT_EQ(&N, &*I++);
  487   EXPECT_EQ(&Ns[0], &*I++);
  488   EXPECT_EQ(&Ns[3], &*I++);
  489   EXPECT_EQ(&Ns[4], &*I++);
  490   EXPECT_EQ(&Ns[1], &*I++);
  491   EXPECT_EQ(&Ns[2], &*I++);
  502   EXPECT_EQ(&Ns[1], &*I++);
  503   EXPECT_EQ(&Ns[2], &*I++);
  504   EXPECT_EQ(&Ns[0], &*I++);
  505   EXPECT_EQ(&Ns[3], &*I++);
  506   EXPECT_EQ(&Ns[4], &*I++);
  535       EXPECT_EQ(&N, &*I++);
  564     EXPECT_EQ(&N, &*I++);
  591     EXPECT_EQ(&Ns[O], &*I++);
  593     EXPECT_EQ(&Ns[O], &*I++);
  640     EXPECT_EQ(&Ns[I], &*I1++);
  648     EXPECT_EQ(&Ns[I], &*I2++);

unittests/Analysis/DivergenceAnalysisTest.cpp

  318     ItBlocks++; // Skip A
  319     ItBlocks++; // Skip B
  320     auto *C = &*ItBlocks++;
  321     auto *D = &*ItBlocks++;
  340     ItBlocks++; // Skip A
  341     ItBlocks++; // Skip B
  342     ItBlocks++; // Skip C
  343     auto *D = &*ItBlocks++;
  362     ItBlocks++; // Skip A
  363     ItBlocks++; // Skip B
  364     auto *C = &*ItBlocks++;
  365     ItBlocks++; // Skip D

unittests/Analysis/DomTreeUpdaterTest.cpp

   67   BasicBlock *BB0 = &*FI++;
   68   BasicBlock *BB1 = &*FI++;
   69   BasicBlock *BB2 = &*FI++;
   70   BasicBlock *BB3 = &*FI++;
  176   BasicBlock *BB0 = &*FI++;
  177   BasicBlock *BB1 = &*FI++;
  249   BasicBlock *BB0 = &*FI++;
  250   BasicBlock *BB1 = &*FI++;
  251   BasicBlock *BB2 = &*FI++;
  252   BasicBlock *BB3 = &*FI++;
  338   BasicBlock *BB0 = &*FI++;
  339   BasicBlock *BB1 = &*FI++;
  340   BasicBlock *BB2 = &*FI++;
  341   BasicBlock *BB3 = &*FI++;
  468   BasicBlock *BB0 = &*FI++;
  469   BasicBlock *BB1 = &*FI++;
  470   BasicBlock *BB2 = &*FI++;
  471   BasicBlock *BB3 = &*FI++;
  551   BasicBlock *BB0 = &*FI++;
  552   BasicBlock *BB1 = &*FI++;
  642   BasicBlock *BB0 = &*FI++;
  643   FI++;
  644   BasicBlock *BB2 = &*FI++;
  645   BasicBlock *BB3 = &*FI++;
  722   BasicBlock *BB0 = &*FI++;
  753   BasicBlock *BB0 = &*FI++;
  754   BasicBlock *BB1 = &*FI++;
  755   BasicBlock *BB2 = &*FI++;

unittests/Analysis/LoopInfoTest.cpp

  193   Loop &L_0 = *LI.getLoopFor(&*I++);
  195   Loop &L_0_0 = *LI.getLoopFor(&*I++);
  197   Loop &L_0_1 = *LI.getLoopFor(&*I++);
  199   Loop &L_0_2 = *LI.getLoopFor(&*I++);
  201   Loop &L_1 = *LI.getLoopFor(&*I++);
  203   Loop &L_1_0 = *LI.getLoopFor(&*I++);
  205   Loop &L_1_1 = *LI.getLoopFor(&*I++);
  207   Loop &L_1_2 = *LI.getLoopFor(&*I++);

unittests/Analysis/OrderedBasicBlockTest.cpp

   41   Instruction *Add = &*I++;
   42   Instruction *Ret = &*I++;

unittests/Analysis/ScalarEvolutionTest.cpp

  377     PHINode *Phi = cast<PHINode>(&*II++);

unittests/Analysis/UnrollAnalyzerTest.cpp

   31     FI++; // First basic block is entry - skip it.
   32     BasicBlock *Header = &*FI++;
   95   Function *F = &*MI++;
   97   FI++; // First basic block is entry - skip it.
   98   BasicBlock *Header = &*FI++;
  102   Instruction *Y1 = &*BBI++;
  103   Instruction *Y2 = &*BBI++;
  157   Function *F = &*MI++;
  159   FI++;
  160   BasicBlock *Header = &*FI++;
  161   BasicBlock *InnerBody = &*FI++;
  164   BBI++;
  167   BBI++;
  203   Function *F = &*MI++;
  205   FI++; // First basic block is entry - skip it.
  206   BasicBlock *Header = &*FI++;
  209   BBI++;
  210   Instruction *Y1 = &*BBI++;
  211   Instruction *Y2 = &*BBI++;
  250   Function *F = &*MI++;
  252   FI++; // First basic block is entry - skip it.
  296   Function *F = &*MI++;
  298   FI++; // First basic block is entry - skip it.
  299   BasicBlock *Header = &*FI++;
  303   Instruction *Y1 = &*BBI++;
  304   Instruction *Y2 = &*BBI++;
  305   Instruction *Y3 = &*BBI++;

unittests/IR/DominatorTreeTest.cpp

   79         BasicBlock *BB0 = &*FI++;
   81         Instruction *Y1 = &*BBI++;
   82         Instruction *Y2 = &*BBI++;
   83         Instruction *Y3 = &*BBI++;
   85         BasicBlock *BB1 = &*FI++;
   87         Instruction *Y4 = &*BBI++;
   89         BasicBlock *BB2 = &*FI++;
   91         Instruction *Y5 = &*BBI++;
   93         BasicBlock *BB3 = &*FI++;
   95         Instruction *Y6 = &*BBI++;
   96         Instruction *Y7 = &*BBI++;
   98         BasicBlock *BB4 = &*FI++;
  100         Instruction *Y8 = &*BBI++;
  101         Instruction *Y9 = &*BBI++;
  299         BasicBlock *BB0 = &*FI++;
  300         BasicBlock *BB1 = &*FI++;
  301         BasicBlock *BB2 = &*FI++;
  383         FI++;
  384         BasicBlock *B = &*FI++;
  385         BasicBlock *C = &*FI++;
  386         BasicBlock *D = &*FI++;
  477         FI++;
  478         BasicBlock *B = &*FI++;
  479         BasicBlock *C = &*FI++;
  480         BasicBlock *D = &*FI++;
  566         FI++;
  567         BasicBlock *B = &*FI++;
  568         BasicBlock *C = &*FI++;
  569         BasicBlock *C2 = &*FI++;
  570         BasicBlock *D = &*FI++;
  640         BasicBlock *A = &*FI++;
  641         BasicBlock *B = &*FI++;
  642         BasicBlock *C = &*FI++;
  643         BasicBlock *D = &*FI++;
  644         BasicBlock *E = &*FI++;

unittests/Transforms/Scalar/LoopPassManagerTest.cpp

  886   BasicBlock &EntryBB = *BBI++;
  888   BasicBlock &Loop0BB = *BBI++;
  890   BasicBlock &Loop00PHBB = *BBI++;
  892   BasicBlock &Loop00BB = *BBI++;
  894   BasicBlock &Loop01PHBB = *BBI++;
  896   BasicBlock &Loop01BB = *BBI++;
  898   BasicBlock &Loop02PHBB = *BBI++;
  900   BasicBlock &Loop02BB = *BBI++;
  902   BasicBlock &Loop0LatchBB = *BBI++;
  904   BasicBlock &EndBB = *BBI++;
 1089   BasicBlock &EntryBB = *BBI++;
 1091   BasicBlock &Loop0BB = *BBI++;
 1093   BasicBlock &Loop00PHBB = *BBI++;
 1095   BasicBlock &Loop00BB = *BBI++;
 1097   BasicBlock &Loop02PHBB = *BBI++;
 1099   BasicBlock &Loop02BB = *BBI++;
 1101   BasicBlock &Loop0LatchBB = *BBI++;
 1103   BasicBlock &Loop2PHBB = *BBI++;
 1105   BasicBlock &Loop2BB = *BBI++;
 1107   BasicBlock &EndBB = *BBI++;
 1350   BasicBlock &EntryBB = *BBI++;
 1352   BasicBlock &Loop0BB = *BBI++;
 1354   BasicBlock &Loop00PHBB = *BBI++;
 1356   BasicBlock &Loop00BB = *BBI++;
 1358   BasicBlock &Loop01PHBB = *BBI++;
 1360   BasicBlock &Loop01BB = *BBI++;
 1362   BasicBlock &Loop02PHBB = *BBI++;
 1364   BasicBlock &Loop02BB = *BBI++;
 1366   BasicBlock &Loop020PHBB = *BBI++;
 1368   BasicBlock &Loop020BB = *BBI++;
 1370   BasicBlock &Loop02LatchBB = *BBI++;
 1372   BasicBlock &Loop0LatchBB = *BBI++;
 1374   BasicBlock &EndBB = *BBI++;

unittests/Transforms/Utils/LocalTest.cpp

  215       BasicBlock *BB = &*I++;
  439       BasicBlock *BB = &*I++;
  451       BasicBlock *BB = &*I++;

unittests/Transforms/Vectorize/VPlanHCFGTest.cpp

   55   VPInstruction *Phi = dyn_cast<VPInstruction>(&*Iter++);
   58   VPInstruction *Idx = dyn_cast<VPInstruction>(&*Iter++);
   63   VPInstruction *Load = dyn_cast<VPInstruction>(&*Iter++);
   68   VPInstruction *Add = dyn_cast<VPInstruction>(&*Iter++);
   73   VPInstruction *Store = dyn_cast<VPInstruction>(&*Iter++);
   79   VPInstruction *IndvarAdd = dyn_cast<VPInstruction>(&*Iter++);
   84   VPInstruction *ICmp = dyn_cast<VPInstruction>(&*Iter++);
  136   auto *Phi = dyn_cast<VPWidenPHIRecipe>(&*Iter++);
  139   auto *Idx = dyn_cast<VPWidenRecipe>(&*Iter++);
  142   auto *Load = dyn_cast<VPWidenMemoryInstructionRecipe>(&*Iter++);
  145   auto *Add = dyn_cast<VPWidenRecipe>(&*Iter++);
  148   auto *Store = dyn_cast<VPWidenMemoryInstructionRecipe>(&*Iter++);
  151   auto *LastWiden = dyn_cast<VPWidenRecipe>(&*Iter++);