[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

179

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,

 };
 
 /// 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.
 ///
 /// Note: a loop exit element can be reached even when the loop body was never
 /// entered.
+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;
+  }
+};
+
 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 *createBlock(bool add_successor = true);
   CFGBlock *createNoReturnBlock();
 
   CFGBlock *addStmt(Stmt *S) {
     return Visit(S, AddStmtChoice::AlwaysAdd);
   }
   CFGBlock *addInitializer(CXXCtorInitializer *I);
   void addLoopExit(const Stmt *LoopStmt);
+  void addLoopEntrance(const Stmt *LoopStmt);
   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,

 // ended by ReturnStmt, GotoStmt or ThrowExpr.
 void CFGBuilder::addLoopExit(const Stmt *LoopStmt){
   if(!BuildOpts.AddLoopExit)
     return;
   autoCreateBlock();
   appendLoopExit(Block, LoopStmt);
 }
 
+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);
 }
do {
     // 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.
+  // The condition block is the implicit sucacessor 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();
+    addLoopEntrance(F);
     return addStmt(I);
   }
 
   // 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 << " (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";

test/Analysis/loopexit-cfg-output.cpp

 // 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:   3: ForStmt (LoopEntrance)
 // 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:   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:   3: ForStmt (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: 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:   6: ForStmt (LoopEntrance)
+// 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:   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:   3: ForStmt (LoopEntrance)
 // 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)
+void check_break() {
+  for (int i = 2; i < 6; i++) {
+    if (i == 4)
       break;
   }
 
   int i = 1;
-  while(i<5){
+  while (i < 5) {
     i++;
-    if(i%2)
+    if (i % 2)
       break;
   }
-  
   return;
 }