[CFG] Adding new CFGStmt LoopEntrance for the StaticAnalyzer

[szepet]

Summary

Adding LoopEntrance as a new CFGElement to the CFG.
This element is added as the last element of the CFGBlock just before the loop condition block.
This can help the Static Analyzer to have a more precise loop modeling.

[dkrupp]

include/clang/Analysis/CFG.h

214

This comment refers to the CFGLoopExit class. Please add a separate explaining comment to the CFGLoopEntrance.

[szepet]

Comment added to LoopEntrance CFGElement.

[NoQ]

Because it wasn't immediately obvious to me how to apply both this patch and D39398 (there are a couple of minor conflicts between them), i wanted to post a few pictures for the reference, because debug.ViewCFG graphs are much easier to comprehend than text dumps.

For example, here's the new CFG for check_return() in loopexit-cfg-output.cpp:

833 int check_return() {
834   for (int i = 0; i < 10; i++) {
835     int j = 1;
836     while (j < 12) {
837       if (j % 2)
838         return 0;
839     }
840   }
841   return 1;
842 }

---

I essentially have one question at a glance - for loop counter variables, don't we want LoopEntrance be before the initialization? I.e. on this picture wouldn't it be better to have

[B10]
1: ForStmt (LoopEntrance)
2: 0
3: int i = 0;

?

Because otherwise our future LoopContext wouldn't correspond to any variable's lifetime scope, so it'd be kind of useless as a ScopeContext. Because, as far as i understand, there are two scopes in every loop:

1. The scope of the whole loop which includes the counter,
2. The scope of every iteration, which goes out of scope after the iteration ends.

And currently LoopContext is none of these. Would loop unrolling still work in a sensible manner if we move LoopEntrance to the beginning of the block?

[NoQ]

(edited my comment: fixed the suggested change to mention the right block)

[szepet]

I essentially have one question at a glance - for loop counter variables, don't we want LoopEntrance be before the initialization?

I guess this would just make too much sense. Done that.

Additionally, handle the cases when we just hop to the body of the loop via goto stmt.
Now the patches can be applied without any conflict (added the loopexit patch as a dependency).

[szepet]

ping

[george.karpenkov]

I would prefer a more detailed CFG element with more meta-information about nested loop, but this is a good starting point.

[george.karpenkov]

Also loops created with gotos should also be supported (e.g. by finding backedges), but that could be done in a different patch.

include/clang/Analysis/CFG.h

 class CFGElement {
 public:
   enum Kind {
     // main kind
     Statement,
     Initializer,
     NewAllocator,
     LifetimeEnds,
+    LoopEntrance,
     LoopExit,
     // dtor kind
     AutomaticObjectDtor,
     DeleteDtor,
     BaseDtor,
     MemberDtor,
     TemporaryDtor,
     DTOR_BEGIN = AutomaticObjectDtor,
private:
 
   CFGNewAllocator() = default;
 
   static bool isKind(const CFGElement &elem) {
     return elem.getKind() == NewAllocator;
   }
 };
 
+/// Represents the point where a loop begins. This element is encountered right
+/// before the first loop element.  This element is is only produced when
+/// building the CFG for the static analyzer and hidden behind the
+/// 'cfg-loopexit' analyzer config flag.
+/// In case of a ForStmt which contains an InitStmt it is placed directly before
+/// the CFGStmts of the initialization (in the same block). In case of a
+/// WhileStmt/DoStmt/ForStmt without InitStmt it appears at the end of the
+/// previous block (before the loop). However, if we step in to the loop via a
+/// gotoStmt then the CFGLoopEntrance is the last element of the goto terminated
+/// block.
+class CFGLoopEntrance : public CFGElement {
+public:
+  explicit CFGLoopEntrance(const Stmt *stmt) : CFGElement(LoopEntrance, stmt) {}
+
+  const Stmt *getLoopStmt() const {
+    return static_cast<Stmt *>(Data1.getPointer());
+  }
+
+private:
+  friend class CFGElement;
+  CFGLoopEntrance() {}
+  static bool isKind(const CFGElement &elem) {
+    return elem.getKind() == LoopEntrance;
+  }
+};
+
 /// Represents the point where a loop ends.
 /// This element is is only produced when building the CFG for the static
 /// analyzer and hidden behind the 'cfg-loopexit' analyzer config flag. It is
 /// placed at the beginning of the block after the loop, however, in special
 /// cases it can appear different positions:
 /// - Right before a ReturnStmt inside the loop
 /// - In the end of a goto terminated block (inside the loop as well)
 ///
 /// Note: whenever a loop is entered a loop exit element will be encountered
 /// after leaving it. However, a loop exit element can be reached even when the
 /// loop body was never entered.
 class CFGLoopExit : public CFGElement {
 public:
   explicit CFGLoopExit(const Stmt *stmt) : CFGElement(LoopExit, stmt) {}
 
   const Stmt *getLoopStmt() const {
     return static_cast<Stmt *>(Data1.getPointer());
   }
public:
   void appendLifetimeEnds(VarDecl *VD, Stmt *S, BumpVectorContext &C) {
     Elements.push_back(CFGLifetimeEnds(VD, S), C);
   }
 
   void appendLoopExit(const Stmt *LoopStmt, BumpVectorContext &C) {
     Elements.push_back(CFGLoopExit(LoopStmt), C);
   }
 
+  void appendLoopEntrance(const Stmt *LoopStmt, BumpVectorContext &C) {
+    Elements.push_back(CFGLoopEntrance(LoopStmt), C);
+  }
+
   void appendDeleteDtor(CXXRecordDecl *RD, CXXDeleteExpr *DE, BumpVectorContext &C) {
     Elements.push_back(CFGDeleteDtor(RD, DE), C);
   }
 
   // Destructors must be inserted in reversed order. So insertion is in two
   // steps. First we prepare space for some number of elements, then we insert
   // the elements beginning at the last position in prepared space.
   iterator beginAutomaticObjDtorsInsert(iterator I, size_t Cnt,

lib/Analysis/CFG.cpp

private:
 
   CFGBlock *addStmt(Stmt *S) {
     return Visit(S, AddStmtChoice::AlwaysAdd);
   }
 
   CFGBlock *addInitializer(CXXCtorInitializer *I);
   void addLoopExit(const Stmt *LoopStmt);
   void addLoopExit(const Stmt *FromStmt, const Stmt *ToStmt);
+  void addLoopEntrance(const Stmt *LoopStmt);
+  void addLoopEntrance(const Stmt *FromStmt, const Stmt *ToStmt);
 
   void addAutomaticObjDtors(LocalScope::const_iterator B,
                             LocalScope::const_iterator E, Stmt *S);
   void addLifetimeEnds(LocalScope::const_iterator B,
                        LocalScope::const_iterator E, Stmt *S);
   void addAutomaticObjHandling(LocalScope::const_iterator B,
                                LocalScope::const_iterator E, Stmt *S);
   void addImplicitDtorsForDestructor(const CXXDestructorDecl *DD);
private:
   void appendLifetimeEnds(CFGBlock *B, VarDecl *VD, Stmt *S) {
     B->appendLifetimeEnds(VD, S, cfg->getBumpVectorContext());
   }
 
   void appendLoopExit(CFGBlock *B, const Stmt *LoopStmt) {
     B->appendLoopExit(LoopStmt, cfg->getBumpVectorContext());
   }
 
+  void appendLoopEntrance(CFGBlock *B, const Stmt *LoopStmt) {
+    B->appendLoopEntrance(LoopStmt, cfg->getBumpVectorContext());
+  }
+
   void appendDeleteDtor(CFGBlock *B, CXXRecordDecl *RD, CXXDeleteExpr *DE) {
     B->appendDeleteDtor(RD, DE, cfg->getBumpVectorContext());
   }
 
   void prependAutomaticObjDtorsWithTerminator(CFGBlock *Blk,
       LocalScope::const_iterator B, LocalScope::const_iterator E);
 
   void prependAutomaticObjLifetimeWithTerminator(CFGBlock *Blk,
while (!NodesToVisit.empty()) {
     const Stmt *LoopStmt = Node.get<Stmt>();
     if (LoopStmt && (isa<ForStmt>(LoopStmt) || isa<WhileStmt>(LoopStmt) ||
                      isa<DoStmt>(LoopStmt)))
       LoopStmts.insert(LoopStmt);
   }
   return LoopStmts;
 }
 
+void CFGBuilder::addLoopEntrance(const Stmt *FromStmt, const Stmt *ToStmt) {
+  if (!BuildOpts.AddLoopExit)
+    return;
+
+  llvm::SmallSetVector<const Stmt *, 4> FromLoopStmts =
+      collectContainingLoops(FromStmt, *Context);
+
+  llvm::SmallSetVector<const Stmt *, 4> ToLoopStmts =
+      collectContainingLoops(ToStmt, *Context);
+
+  ToLoopStmts.set_subtract(FromLoopStmts);
+  for (llvm::SmallSetVector<const Stmt *, 4>::reverse_iterator
+           I = ToLoopStmts.rbegin(),
+           E = ToLoopStmts.rend();
+       I != E; ++I)
+    appendLoopEntrance(Block, *I);
+}
+
 void CFGBuilder::addLoopExit(const Stmt *FromStmt, const Stmt *ToStmt) {
   if (!BuildOpts.AddLoopExit)
     return;
 
   llvm::SmallSetVector<const Stmt *, 4> FromLoopStmts =
       collectContainingLoops(FromStmt, *Context);
 
   llvm::SmallSetVector<const Stmt *, 4> ToLoopStmts =
       collectContainingLoops(ToStmt, *Context);
 
   FromLoopStmts.set_subtract(ToLoopStmts);
   for (llvm::SmallSetVector<const Stmt *, 4>::reverse_iterator
            I = FromLoopStmts.rbegin(),
            E = FromLoopStmts.rend();
        I != E; ++I)
     appendLoopExit(Block, *I);
 }
 
+void CFGBuilder::addLoopEntrance(const Stmt *LoopStmt) {
+  if (!BuildOpts.AddLoopExit)
+    return;
+  autoCreateBlock();
+  appendLoopEntrance(Block, LoopStmt);
+}
+
 void CFGBuilder::addAutomaticObjHandling(LocalScope::const_iterator B,
                                          LocalScope::const_iterator E,
                                          Stmt *S) {
   if (BuildOpts.AddImplicitDtors)
     addAutomaticObjDtors(B, E, S);
   if (BuildOpts.AddLifetime)
     addLifetimeEnds(B, E, S);
 }
if (I == LabelMap.end())
     // We will need to backpatch this block later.
     BackpatchBlocks.push_back(JumpSource(Block, ScopePos));
   else {
     JumpTarget JT = I->second;
     addAutomaticObjHandling(ScopePos, JT.scopePosition, G);
     addSuccessor(Block, JT.block);
   }
   addLoopExit(G, G->getLabel()->getStmt());
+  addLoopEntrance(G, G->getLabel()->getStmt());
 
   return Block;
 }
 
 CFGBlock *CFGBuilder::VisitForStmt(ForStmt *F) {
   CFGBlock *LoopSuccessor = nullptr;
 
   // Save local scope position because in case of condition variable ScopePos
do {
     // Link up the condition block with the code that follows the loop.  (the
     // false branch).
     addSuccessor(ExitConditionBlock,
                  KnownVal.isTrue() ? nullptr : LoopSuccessor);
   } while (false);
 
   // Link up the loop-back block to the entry condition block.
   addSuccessor(TransitionBlock, EntryConditionBlock);
-  
   // The condition block is the implicit successor for any code above the loop.
   Succ = EntryConditionBlock;
 
   // If the loop contains initialization, create a new block for those
   // statements.  This block can also contain statements that precede the loop.
   if (Stmt *I = F->getInit()) {
     Block = createBlock();
-    return addStmt(I);
+    CFGBlock *InitBlock = addStmt(I);
+    addLoopEntrance(F);
+    return InitBlock;
   }
 
   // There is no loop initialization.  We are thus basically a while loop.
   // NULL out Block to force lazy block construction.
   Block = nullptr;
   Succ = EntryConditionBlock;
-  return EntryConditionBlock;
+  addLoopEntrance(F);
+  return (Block ? Block : Succ);
 }
 
 CFGBlock *CFGBuilder::VisitMemberExpr(MemberExpr *M, AddStmtChoice asc) {
   if (asc.alwaysAdd(*this, M)) {
     autoCreateBlock();
     appendStmt(Block, M);
   }
   return Visit(M->getBase());
CFGBlock *CFGBuilder::VisitWhileStmt(WhileStmt *W) {
   addSuccessor(TransitionBlock, EntryConditionBlock);
 
   // There can be no more statements in the condition block since we loop back
   // to this block.  NULL out Block to force lazy creation of another block.
   Block = nullptr;
 
   // Return the condition block, which is the dominating block for the loop.
   Succ = EntryConditionBlock;
-  return EntryConditionBlock;
+  addLoopEntrance(W);
+  return (Block ? Block : Succ);
 }
 
 CFGBlock *CFGBuilder::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
   // FIXME: For now we pretend that @catch and the code it contains does not
   //  exit.
   return Block;
 }
 
CFGBlock *CFGBuilder::VisitDoStmt(DoStmt *D) {
   addSuccessor(ExitConditionBlock, KnownVal.isTrue() ? nullptr : LoopSuccessor);
 
   // There can be no more statements in the body block(s) since we loop back to
   // the body.  NULL out Block to force lazy creation of another block.
   Block = nullptr;
 
   // Return the loop body, which is the dominating block for the loop.
   Succ = BodyBlock;
-  return BodyBlock;
+  addLoopEntrance(D);
+  return (Block ? Block : Succ);
 }
 
 CFGBlock *CFGBuilder::VisitContinueStmt(ContinueStmt *C) {
   // "continue" is a control-flow statement.  Thus we stop processing the
   // current block.
   if (badCFG)
     return nullptr;
 

 
 const CXXDestructorDecl *
 CFGImplicitDtor::getDestructorDecl(ASTContext &astContext) const {
   switch (getKind()) {
     case CFGElement::Statement:
     case CFGElement::Initializer:
     case CFGElement::NewAllocator:
     case CFGElement::LoopExit:
+    case CFGElement::LoopEntrance:
     case CFGElement::LifetimeEnds:
       llvm_unreachable("getDestructorDecl should only be used with "
                        "ImplicitDtors");
     case CFGElement::AutomaticObjectDtor: {
       const VarDecl *var = castAs<CFGAutomaticObjDtor>().getVarDecl();
       QualType ty = var->getType();
 
       // FIXME: See CFGBuilder::addLocalScopeForVarDecl.
if (Optional<CFGStmt> CS = E.getAs<CFGStmt>()) {
 
     OS << ".~" << T->getAsCXXRecordDecl()->getName().str() << "()";
     OS << " (Implicit destructor)\n";
   } else if (Optional<CFGLifetimeEnds> DE = E.getAs<CFGLifetimeEnds>()) {
     const VarDecl *VD = DE->getVarDecl();
     Helper.handleDecl(VD, OS);
 
     OS << " (Lifetime ends)\n";
+  } else if (Optional<CFGLoopEntrance> LE = E.getAs<CFGLoopEntrance>()) {
+    const Stmt *LoopStmt = LE->getLoopStmt();
+    OS << LoopStmt->getStmtClassName() << " (LoopEntrance)\n";
   } else if (Optional<CFGLoopExit> LE = E.getAs<CFGLoopExit>()) {
     const Stmt *LoopStmt = LE->getLoopStmt();
     OS << LoopStmt->getStmtClassName() << " (LoopExit)\n";
   } else if (Optional<CFGNewAllocator> NE = E.getAs<CFGNewAllocator>()) {
     OS << "CFGNewAllocator(";
     if (const CXXNewExpr *AllocExpr = NE->getAllocatorExpr())
       AllocExpr->getType().print(OS, PrintingPolicy(Helper.getLangOpts()));
     OS << ")\n";

lib/StaticAnalyzer/Core/PathDiagnostic.cpp

if (const Stmt *CallerBody = CallerInfo->getBody())
       return PathDiagnosticLocation::createEnd(CallerBody, SM, CallerCtx);
     return PathDiagnosticLocation::create(CallerInfo->getDecl(), SM);
   }
   case CFGElement::TemporaryDtor:
   case CFGElement::NewAllocator:
     llvm_unreachable("not yet implemented!");
   case CFGElement::LifetimeEnds:
   case CFGElement::LoopExit:
+  case CFGElement::LoopEntrance:
     llvm_unreachable("CFGElement kind should not be on callsite!");
   }
 
   llvm_unreachable("Unknown CFGElement kind");
 }
 
 PathDiagnosticLocation
 PathDiagnosticLocation::createBegin(const Decl *D,

test/Analysis/loopexit-cfg-output.cpp

 // CHECK-NEXT:   2: [B4.1] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:   3: 12
 // CHECK-NEXT:   4: [B4.2] < [B4.3]
 // CHECK-NEXT:   T: for (...; [B4.4]; ...)
 // CHECK-NEXT:   Preds (2): B2 B5
 // CHECK-NEXT:   Succs (2): B3 B1
 
 // CHECK:       [B5]
-// CHECK-NEXT:   1: 0
-// CHECK-NEXT:   2: int i = 0;
+// CHECK-NEXT:   1: ForStmt (LoopEntrance)
+// CHECK-NEXT:   2: 0
+// CHECK-NEXT:   3: int i = 0;
 // CHECK-NEXT:   Preds (1): B6
 // CHECK-NEXT:   Succs (1): B4
 
 // CHECK:       [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void check_forloop1() {
   for (int i = 0; i < 12; i++) {
     i++;
   }
   return;
 }
 
-// CHECK:       [B4 (ENTRY)]
-// CHECK-NEXT:   Succs (1): B3
+// CHECK:       [B5 (ENTRY)]
+// CHECK-NEXT:   Succs (1): B4
 
 // CHECK:       [B1]
 // CHECK-NEXT:   1: ForStmt (LoopExit)
 // CHECK-NEXT:   Succs (1): B0
 
 // CHECK:       [B2]
 // CHECK-NEXT:   Preds (1): B3
 // CHECK-NEXT:   Succs (1): B3
 
 // CHECK:       [B3]
 // CHECK-NEXT:   T: for (; ; )
 // CHECK-NEXT:   Preds (2): B2 B4
 // CHECK-NEXT:   Succs (2): B2 NULL
 
+// CHECK:       [B4]
+// CHECK-NEXT:   1: ForStmt (LoopEntrance)
+// CHECK-NEXT:   Preds (1): B5
+// CHECK-NEXT:   Succs (1): B3
+
 // CHECK:       [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void check_forloop2() {
   for (;;)
     ;
 }
 
-// CHECK:       [B5 (ENTRY)]
-// CHECK-NEXT:   Succs (1): B4
+// CHECK:       [B6 (ENTRY)]
+// CHECK-NEXT:   Succs (1): B5
 
 // CHECK:       [B1]
 // CHECK-NEXT:   1: WhileStmt (LoopExit)
 // CHECK-NEXT:   Succs (1): B0
 
 // CHECK:       [B2]
 // CHECK-NEXT:   Preds (1): B3
 // CHECK-NEXT:   Succs (1): B4
 
 // CHECK:       [B3]
 // CHECK-NEXT:   1: int i;
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B2
 
 // CHECK:       [B4]
 // CHECK-NEXT:   1: true
 // CHECK-NEXT:   T: while [B4.1]
 // CHECK-NEXT:   Preds (2): B2 B5
 // CHECK-NEXT:   Succs (2): B3 NULL
 
+// CHECK:       [B5]
+// CHECK-NEXT:   1: WhileStmt (LoopEntrance)
+// CHECK-NEXT:   Preds (1): B6
+// CHECK-NEXT:   Succs (1): B4
+
 // CHECK:       [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void check_while1() {
   while (true) {
     int i;
   }
 }
 

 // CHECK-NEXT:   3: 42
 // CHECK-NEXT:   4: [B3.2] < [B3.3]
 // CHECK-NEXT:   T: while [B3.4]
 // CHECK-NEXT:   Preds (2): B2 B4
 // CHECK-NEXT:   Succs (2): B2 B1
 
 // CHECK:       [B4]
 // CHECK-NEXT:   1: int l;
+// CHECK-NEXT:   2: WhileStmt (LoopEntrance)
 // CHECK-NEXT:   Preds (1): B5
 // CHECK-NEXT:   Succs (1): B3
 
 // CHECK:       [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void check_while2() {
   int l;
   while (l < 42)
     ;
   int k = 2;
   return;
 }
 
-// CHECK:       [B4 (ENTRY)]
-// CHECK-NEXT:   Succs (1): B3
+// CHECK:       [B5 (ENTRY)]
+// CHECK-NEXT:   Succs (1): B4
 
 // CHECK:       [B1]
 // CHECK-NEXT:   1: WhileStmt (LoopExit)
 // CHECK-NEXT:   Preds (1): B3
 // CHECK-NEXT:   Succs (1): B0
 
 // CHECK:       [B2]
 // CHECK-NEXT:   Succs (1): B3
 
 // CHECK:       [B3]
 // CHECK-NEXT:   1: false
 // CHECK-NEXT:   T: while [B3.1]
 // CHECK-NEXT:   Preds (2): B2 B4
 // CHECK-NEXT:   Succs (2): NULL B1
 
+// CHECK:       [B4]
+// CHECK-NEXT:   1: WhileStmt (LoopEntrance)
+// CHECK-NEXT:   Preds (1): B5
+// CHECK-NEXT:   Succs (1): B3
+
 // CHECK:       [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void check_while3() {
   while (false) {
     ;
   }
 }
 
-// CHECK:       [B4 (ENTRY)]
-// CHECK-NEXT:   Succs (1): B2
+// CHECK:       [B5 (ENTRY)]
+// CHECK-NEXT:   Succs (1): B4
 
 // CHECK:       [B1]
 // CHECK-NEXT:   1: DoStmt (LoopExit)
 // CHECK-NEXT:   Preds (1): B2
 // CHECK-NEXT:   Succs (1): B0
 
 // CHECK:       [B2]
 // CHECK-NEXT:   1: false
 // CHECK-NEXT:   T: do ... while [B2.1]
 // CHECK-NEXT:   Preds (2): B3 B4
 // CHECK-NEXT:   Succs (2): NULL B1
 
 // CHECK:       [B3]
 // CHECK-NEXT:   Succs (1): B2
 
+// CHECK:       [B4]
+// CHECK-NEXT:   1: DoStmt (LoopEntrance)
+// CHECK-NEXT:   Preds (1): B5
+// CHECK-NEXT:   Succs (1): B2
+
 // CHECK:       [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void check_dowhile1() {
   do {
   } while (false);
 }
 
 // CHECK:       [B6 (ENTRY)]

 
 // CHECK:       [B4]
 // CHECK-NEXT:   Preds (1): B2
 // CHECK-NEXT:   Succs (1): B3
 
 // CHECK:       [B5]
 // CHECK-NEXT:   1: 2
 // CHECK-NEXT:   2: int j = 2;
+// CHECK-NEXT:   3: DoStmt (LoopEntrance)
 // CHECK-NEXT:   Preds (1): B6
 // CHECK-NEXT:   Succs (1): B3
 
 // CHECK:       [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void check_dowhile2() {
   int j = 2;
   do {

 // CHECK-NEXT:   2: [B6.1] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:   3: 6
 // CHECK-NEXT:   4: [B6.2] < [B6.3]
 // CHECK-NEXT:   T: for (...; [B6.4]; ...)
 // CHECK-NEXT:   Preds (2): B4 B7
 // CHECK-NEXT:   Succs (2): B5 B3
 
 // CHECK:       [B7]
-// CHECK-NEXT:   1: 1
-// CHECK-NEXT:   2: int j = 1;
+// CHECK-NEXT:   1: ForStmt (LoopEntrance)
+// CHECK-NEXT:   2: 1
+// CHECK-NEXT:   3: int j = 1;
 // CHECK-NEXT:   Preds (1): B8
 // CHECK-NEXT:   Succs (1): B6
 
 // CHECK:       [B8]
 // CHECK-NEXT:   1: i
 // CHECK-NEXT:   2: [B8.1] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:   3: 2
 // CHECK-NEXT:   4: [B8.2] < [B8.3]
 // CHECK-NEXT:   T: while [B8.4]
 // CHECK-NEXT:   Preds (2): B2 B9
 // CHECK-NEXT:   Succs (2): B7 B1
 
 // CHECK:       [B9]
 // CHECK-NEXT:   1: 40
 // CHECK-NEXT:   2: -[B9.1]
 // CHECK-NEXT:   3: int i = -40;
+// CHECK-NEXT:   4: WhileStmt (LoopEntrance)
 // CHECK-NEXT:   Preds (1): B10
 // CHECK-NEXT:   Succs (1): B8
 
 // CHECK:       [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void nested_loops1() {
   int i = -40;
   while (i < 2) {
     for (int j = 1; j < 6; j++)
       i++;
   }
 }
 
-// CHECK:       [B9 (ENTRY)]
-// CHECK-NEXT:   Succs (1): B8
+// CHECK:       [B10 (ENTRY)]
+// CHECK-NEXT:   Succs (1): B9
 
 // CHECK:       [B1]
 // CHECK-NEXT:   1: ForStmt (LoopExit)
-// CHECK-NEXT:   Preds (1): B7
+// CHECK-NEXT:   Preds (1): B8
 // CHECK-NEXT:   Succs (1): B0
 
 // CHECK:       [B2]
 // CHECK-NEXT:   1: j
 // CHECK-NEXT:   2: [B2.1]++
 // CHECK-NEXT:   Preds (1): B3
-// CHECK-NEXT:   Succs (1): B7
+// CHECK-NEXT:   Succs (1): B8
 
 // CHECK:       [B3]
 // CHECK-NEXT:   1: DoStmt (LoopExit)
 // CHECK-NEXT:   2: i
 // CHECK-NEXT:   3: [B3.2]--
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B2
 

 // CHECK-NEXT:   Preds (2): B6 B7
 // CHECK-NEXT:   Succs (1): B4
 
 // CHECK:       [B6]
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B5
 
 // CHECK:       [B7]
+// CHECK-NEXT:   1: DoStmt (LoopEntrance)
+// CHECK-NEXT:   Preds (1): B8
+// CHECK-NEXT:   Succs (1): B5
+
+// CHECK:       [B8]
 // CHECK-NEXT:   1: j
-// CHECK-NEXT:   2: [B7.1] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:   2: [B8.1] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:   3: 6
-// CHECK-NEXT:   4: [B7.2] < [B7.3]
-// CHECK-NEXT:   T: for (...; [B7.4]; ...)
-// CHECK-NEXT:   Preds (2): B2 B8
-// CHECK-NEXT:   Succs (2): B5 B1
+// CHECK-NEXT:   4: [B8.2] < [B8.3]
+// CHECK-NEXT:   T: for (...; [B8.4]; ...)
+// CHECK-NEXT:   Preds (2): B2 B9
+// CHECK-NEXT:   Succs (2): B7 B1
 
-// CHECK:       [B8]
+// CHECK:       [B9]
 // CHECK-NEXT:   1: 40
-// CHECK-NEXT:   2: -[B8.1]
+// CHECK-NEXT:   2: -[B9.1]
 // CHECK-NEXT:   3: int i = -40;
-// CHECK-NEXT:   4: 1
-// CHECK-NEXT:   5: int j = 1;
-// CHECK-NEXT:   Preds (1): B9
-// CHECK-NEXT:   Succs (1): B7
+// CHECK-NEXT:   4: ForStmt (LoopEntrance)
+// CHECK-NEXT:   5: 1
+// CHECK-NEXT:   6: int j = 1;
+// CHECK-NEXT:   Preds (1): B10
+// CHECK-NEXT:   Succs (1): B8
 
 // CHECK:       [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void nested_loops2() {
   int i = -40;
   for (int j = 1; j < 6; j++) {
     do {
       i++;

 // CHECK-NEXT:   T: while [B5.4]
 // CHECK-NEXT:   Preds (2): B2 B6
 // CHECK-NEXT:   Succs (2): B4 B1
 
 // CHECK:       [B6]
 // CHECK-NEXT:   1: ForStmt (LoopExit)
 // CHECK-NEXT:   2: 1
 // CHECK-NEXT:   3: int i = 1;
+// CHECK-NEXT:   4: WhileStmt (LoopEntrance)
 // CHECK-NEXT:   Preds (2): B8 B10
 // CHECK-NEXT:   Succs (1): B5
 
 // CHECK:       [B7]
 // CHECK-NEXT:   1: i
 // CHECK-NEXT:   2: [B7.1]++
 // CHECK-NEXT:   Preds (1): B9
 // CHECK-NEXT:   Succs (1): B10

 // CHECK-NEXT:   2: [B10.1] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:   3: 6
 // CHECK-NEXT:   4: [B10.2] < [B10.3]
 // CHECK-NEXT:   T: for (...; [B10.4]; ...)
 // CHECK-NEXT:   Preds (2): B7 B11
 // CHECK-NEXT:   Succs (2): B9 B6
 
 // CHECK:       [B11]
-// CHECK-NEXT:   1: 2
-// CHECK-NEXT:   2: int i = 2;
+// CHECK-NEXT:   1: ForStmt (LoopEntrance)
+// CHECK-NEXT:   2: 2
+// CHECK-NEXT:   3: int i = 2;
 // CHECK-NEXT:   Preds (1): B12
 // CHECK-NEXT:   Succs (1): B10
 
 // CHECK:       [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void check_break() {
   for (int i = 2; i < 6; i++) {
     if (i == 4)

 // CHECK-NEXT:   4: [B7.2] < [B7.3]
 // CHECK-NEXT:   T: while [B7.4]
 // CHECK-NEXT:   Preds (2): B4 B8
 // CHECK-NEXT:   Succs (2): B6 B3
 
 // CHECK:       [B8]
 // CHECK-NEXT:   1: 1
 // CHECK-NEXT:   2: int j = 1;
+// CHECK-NEXT:   3: WhileStmt (LoopEntrance)
 // CHECK-NEXT:   Preds (1): B9
 // CHECK-NEXT:   Succs (1): B7
 
 // CHECK:       [B9]
 // CHECK-NEXT:   1: i
 // CHECK-NEXT:   2: [B9.1] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:   3: 10
 // CHECK-NEXT:   4: [B9.2] < [B9.3]
 // CHECK-NEXT:   T: for (...; [B9.4]; ...)
 // CHECK-NEXT:   Preds (2): B2 B10
 // CHECK-NEXT:   Succs (2): B8 B1
 
 // CHECK:       [B10]
 // CHECK-NEXT:   lab:
-// CHECK-NEXT:   1: 0
-// CHECK-NEXT:   2: int i = 0;
+// CHECK-NEXT:   1: ForStmt (LoopEntrance)
+// CHECK-NEXT:   2: 0
+// CHECK-NEXT:   3: int i = 0;
 // CHECK-NEXT:   Preds (2): B5 B11
 // CHECK-NEXT:   Succs (1): B9
 
 // CHECK:       [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void check_goto() {
 lab:
   for (int i = 0; i < 10; i++) {

 // CHECK-NEXT:   T: while [B7.4]
 // CHECK-NEXT:   Preds (2): B4 B8
 // CHECK-NEXT:   Succs (2): B6 B3
 
 // CHECK:       [B8]
 // CHECK-NEXT:   lab:
 // CHECK-NEXT:   1: 1
 // CHECK-NEXT:   2: int j = 1;
+// CHECK-NEXT:   3: WhileStmt (LoopEntrance)
 // CHECK-NEXT:   Preds (2): B9 B5
 // CHECK-NEXT:   Succs (1): B7
 
 // CHECK:       [B9]
 // CHECK-NEXT:   1: i
 // CHECK-NEXT:   2: [B9.1] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:   3: 10
 // CHECK-NEXT:   4: [B9.2] < [B9.3]
 // CHECK-NEXT:   T: for (...; [B9.4]; ...)
 // CHECK-NEXT:   Preds (2): B2 B10
 // CHECK-NEXT:   Succs (2): B8 B1
 
 // CHECK:       [B10]
-// CHECK-NEXT:   1: 0
-// CHECK-NEXT:   2: int i = 0;
+// CHECK-NEXT:   1: ForStmt (LoopEntrance)
+// CHECK-NEXT:   2: 0
+// CHECK-NEXT:   3: int i = 0;
 // CHECK-NEXT:   Preds (1): B11
 // CHECK-NEXT:   Succs (1): B9
 
 // CHECK:       [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 
 void check_goto2() {
   for (int i = 0; i < 10; i++) {
   lab:
     int j = 1;
     while (j < 12) {
       if (j % 2)
         goto lab;
     }
   }
   return;
 }
 
-// CHECK:       [B10 (ENTRY)]
-// CHECK-NEXT:   Succs (1): B9
+// CHECK:       [B11 (ENTRY)]
+// CHECK-NEXT:   Succs (1): B10
 
 // CHECK:       [B1]
 // CHECK-NEXT:   1: ForStmt (LoopExit)
 // CHECK-NEXT:   2: return;
-// CHECK-NEXT:   Preds (1): B8
+// CHECK-NEXT:   Preds (1): B9
 // CHECK-NEXT:   Succs (1): B0
 
 // CHECK:       [B2]
 // CHECK-NEXT:   1: i
 // CHECK-NEXT:   2: [B2.1]++
 // CHECK-NEXT:   Preds (1): B3
-// CHECK-NEXT:   Succs (1): B8
+// CHECK-NEXT:   Succs (1): B9
 
 // CHECK:       [B3]
 // CHECK-NEXT:   1: WhileStmt (LoopExit)
 // CHECK-NEXT:   Preds (1): B6
 // CHECK-NEXT:   Succs (1): B2
 
 // CHECK:       [B4]
 // CHECK-NEXT:   Preds (1): B5
 // CHECK-NEXT:   Succs (1): B6
 
 // CHECK:       [B5]
 // CHECK-NEXT:   lab:
 // CHECK-NEXT:   1: 2
 // CHECK-NEXT:   2: j
 // CHECK-NEXT:   3: [B5.2] = [B5.1]
-// CHECK-NEXT:   Preds (2): B6 B7
+// CHECK-NEXT:   Preds (2): B6 B8
 // CHECK-NEXT:   Succs (1): B4
 
 // CHECK:       [B6]
 // CHECK-NEXT:   1: j
 // CHECK-NEXT:   2: [B6.1] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:   3: 12
 // CHECK-NEXT:   4: [B6.2] < [B6.3]
 // CHECK-NEXT:   T: while [B6.4]
-// CHECK-NEXT:   Preds (1): B4
+// CHECK-NEXT:   Preds (2): B4 B7
 // CHECK-NEXT:   Succs (2): B5 B3
 
 // CHECK:       [B7]
+// CHECK-NEXT:   1: WhileStmt (LoopEntrance)
+// CHECK-NEXT:   Succs (1): B6
+
+// CHECK:       [B8]
 // CHECK-NEXT:   1: 1
 // CHECK-NEXT:   2: int j = 1;
+// CHECK-NEXT:   3: WhileStmt (LoopEntrance)
 // CHECK-NEXT:   T: goto lab;
-// CHECK-NEXT:   Preds (1): B8
+// CHECK-NEXT:   Preds (1): B9
 // CHECK-NEXT:   Succs (1): B5
 
-// CHECK:       [B8]
+// CHECK:       [B9]
 // CHECK-NEXT:   1: i
-// CHECK-NEXT:   2: [B8.1] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:   2: [B9.1] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:   3: 10
-// CHECK-NEXT:   4: [B8.2] < [B8.3]
-// CHECK-NEXT:   T: for (...; [B8.4]; ...)
-// CHECK-NEXT:   Preds (2): B2 B9
-// CHECK-NEXT:   Succs (2): B7 B1
+// CHECK-NEXT:   4: [B9.2] < [B9.3]
+// CHECK-NEXT:   T: for (...; [B9.4]; ...)
+// CHECK-NEXT:   Preds (2): B2 B10
+// CHECK-NEXT:   Succs (2): B8 B1
 
-// CHECK:       [B9]
-// CHECK-NEXT:   1: 0
-// CHECK-NEXT:   2: int i = 0;
-// CHECK-NEXT:   Preds (1): B10
-// CHECK-NEXT:   Succs (1): B8
+// CHECK:       [B10]
+// CHECK-NEXT:   1: ForStmt (LoopEntrance)
+// CHECK-NEXT:   2: 0
+// CHECK-NEXT:   3: int i = 0;
+// CHECK-NEXT:   Preds (1): B11
+// CHECK-NEXT:   Succs (1): B9
 
 // CHECK:       [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void check_goto3() {
   for (int i = 0; i < 10; i++) {
     int j = 1;
     goto lab;
     while (j < 12) {

 // CHECK-NEXT:   4: [B7.2] < [B7.3]
 // CHECK-NEXT:   T: while [B7.4]
 // CHECK-NEXT:   Preds (2): B4 B8
 // CHECK-NEXT:   Succs (2): B6 B3
 
 // CHECK:       [B8]
 // CHECK-NEXT:   1: 1
 // CHECK-NEXT:   2: int j = 1;
+// CHECK-NEXT:   3: WhileStmt (LoopEntrance)
 // CHECK-NEXT:   Preds (1): B9
 // CHECK-NEXT:   Succs (1): B7
 
 // CHECK:       [B9]
 // CHECK-NEXT:   1: i
 // CHECK-NEXT:   2: [B9.1] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:   3: 10
 // CHECK-NEXT:   4: [B9.2] < [B9.3]
 // CHECK-NEXT:   T: for (...; [B9.4]; ...)
 // CHECK-NEXT:   Preds (2): B2 B10
 // CHECK-NEXT:   Succs (2): B8 B1
 
 // CHECK:       [B10]
-// CHECK-NEXT:   1: 0
-// CHECK-NEXT:   2: int i = 0;
+// CHECK-NEXT:   1: ForStmt (LoopEntrance)
+// CHECK-NEXT:   2: 0
+// CHECK-NEXT:   3: int i = 0;
 // CHECK-NEXT:   Preds (1): B11
 // CHECK-NEXT:   Succs (1): B9
 
 // CHECK:       [B0 (EXIT)]
 // CHECK-NEXT:   Preds (2): B1 B5
 int check_return() {
   for (int i = 0; i < 10; i++) {
     int j = 1;

 // CHECK-NEXT:   4: [B6.2] < [B6.3]
 // CHECK-NEXT:   T: while [B6.4]
 // CHECK-NEXT:   Preds (2): B4 B7
 // CHECK-NEXT:   Succs (2): B5 B3
 
 // CHECK:       [B7]
 // CHECK-NEXT:   1: 1
 // CHECK-NEXT:   2: int j = 1;
+// CHECK-NEXT:   3: WhileStmt (LoopEntrance)
 // CHECK-NEXT:   Preds (1): B8
 // CHECK-NEXT:   Succs (1): B6
 
 // CHECK:       [B8]
 // CHECK-NEXT:   1: i
 // CHECK-NEXT:   2: [B8.1] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:   3: 10
 // CHECK-NEXT:   4: [B8.2] < [B8.3]
 // CHECK-NEXT:   T: for (...; [B8.4]; ...)
 // CHECK-NEXT:   Preds (2): B2 B9
 // CHECK-NEXT:   Succs (2): B7 B1
 
 // CHECK:       [B9]
-// CHECK-NEXT:   1: 0
-// CHECK-NEXT:   2: int i = 0;
+// CHECK-NEXT:   1: ForStmt (LoopEntrance)
+// CHECK-NEXT:   2: 0
+// CHECK-NEXT:   3: int i = 0;
 // CHECK-NEXT:   Preds (1): B10
 // CHECK-NEXT:   Succs (1): B8
 
 // CHECK:       [B0 (EXIT)]
 // CHECK-NEXT:   Preds (2): B1 B3
 int check_return2() {
   for (int i = 0; i < 10; i++) {
     int j = 1;
     while (j < 12)
       j++;
     return 0;
   }
   return 1;
 }
 No newline at end of file