An attempt at fixing lifetime extended temporaries in the CFG.

[klimek]

Summary

Fix handling of lifetime extended temporaries by using the
MaterializeTemporaryExpr as indication of whether a temporary was actually
extended. As lifetime extended temporaries do not necessarily have VarDecls,
changes the type of the destructors for those to reuse CFGTemopraryDtor.

Open problems:

• temporary dtors are not yet inlined, but some tests rely on dtor inlining for lifetime extended temporaries
• there are still missing cases for when we do not want to continue digging through the AST for the CXXBindTemporaryExpr after hitting a MaterializeTemporaryExpr; we now have 3 different places in the code that encodes this information; some refactoring is needed to clean that up
• more tests needed

This is still rough, but I wanted to get early feedback about the direction this
is taking.

[alexmc]

Thanks again for smashing on this, Manuel. This rabbit hole just keeps on getting deeper.

I'm in my usual position about not knowing enough about clang to know whether this makes sense at a high-level. Consequently, the following comments might not make sense or might miss problems with the overall approach, so please take them with a grain of salt.

lib/Analysis/CFG.cpp

439

This signature's a bit weird to me: this method is called for lifetime extended temporaries, but LifetimeExtended can be false: what does that mean?

Does this method or its arguments need to be renamed?

1052

Rather than const cast here, should we add or remove const from some other signature so this isn't needed?

1069–1070

Maybe add a comment explaining that we don't need to anything for a bind statement for a lifetime extended temporary because there's no object creation going on?

1119

if (noReturn) { createNoReturnBlock(); } else { autoCreateBlock(); }
This seems to be a common pattern. Maybe worth adding a helper to make this code easier to read?

1262

Maybe add a helper here for calls like this that don't care about CommaLHSs or Adjustments to make this easier to read

[klimek]

Add comment.

lib/Analysis/CFG.cpp

439

Yes, as I wrote, this is still pretty rough - I expect some major refactoring to happen before it lands.

1052

Unfortunately the sinks are non-const, which basically kills us.

1069–1070

Added a comment (object creation is going on, but we handle the descturctor elsewhere).

1119

I actually think this is probably not quite right here yet (I have failing tests with noreturn dtor cases), so I'll do that once all that has settled down :)

1262

I'd actually like to not need to visit this 3 times. Alas, I'm not sure it's possible. You're right, if it's not possible, we should pull something out...

[jordan_rose]

This mostly seems reasonable to me, except I wonder if we'll want to encode the path to the temporaries by something other than the expression where they were created. I can't remember when they're proper regions and when they're just values (LazyCompoundVals) in the analyzer, but we should be careful to be consistent about the region in which the constructor is run and the region in which the destructor is run.

[klimek]

Adapt now working cfg tests.
Handle more cases for lifetime extension.
Fix bug in materialize-temporary handling.

lib/Analysis/CFG.cpp

private:
   void autoCreateBlock() { if (!Block) Block = createBlock(); }
   CFGBlock *createBlock(bool add_successor = true);
   CFGBlock *createNoReturnBlock();
 
   CFGBlock *addStmt(Stmt *S) {
     return Visit(S, AddStmtChoice::AlwaysAdd);
   }
   CFGBlock *addInitializer(CXXCtorInitializer *I);
+  void addAutomaticObjDtorsForLifetimeExtendedTemporaries(
+      Stmt *E, bool LifetimeExtended = false);
+  void addAutomaticObjDtorsForVarDecl(VarDecl *VD, Stmt* S);
   void addAutomaticObjDtors(LocalScope::const_iterator B,
                             LocalScope::const_iterator E, Stmt *S);
   void addImplicitDtorsForDestructor(const CXXDestructorDecl *DD);
 
   // Local scopes creation.
   LocalScope* createOrReuseLocalScope(LocalScope* Scope);
 
   void addLocalScopeForStmt(Stmt *S);
   LocalScope* addLocalScopeForDeclStmt(DeclStmt *DS,
                                        LocalScope* Scope = nullptr);
+  bool needsLocalScopeForLifetimeExtendedTemporary(const Stmt* E);
+  bool needsLocalScopeForVarDecl(const VarDecl* VD);
+  bool needsLocalScopeForType(QualType QT);
   LocalScope* addLocalScopeForVarDecl(VarDecl *VD, LocalScope* Scope = nullptr);
 
   void addLocalScopeAndDtors(Stmt *S);
 
   // Interface to CFGBlock - adding CFGElements.
   void appendStmt(CFGBlock *B, const Stmt *S) {
     if (alwaysAdd(S) && cachedEntry)
       cachedEntry->second = B;
if (HasTemporaries) {
       return Visit(cast<ExprWithCleanups>(Init)->getSubExpr());
     }
     return Visit(Init);
   }
 
   return Block;
 }
 
-/// \brief Retrieve the type of the temporary object whose lifetime was 
-/// extended by a local reference with the given initializer.
-static QualType getReferenceInitTemporaryType(ASTContext &Context,
-                                              const Expr *Init) {
-  while (true) {
-    // Skip parentheses.
-    Init = Init->IgnoreParens();
-    
-    // Skip through cleanups.
-    if (const ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(Init)) {
-      Init = EWC->getSubExpr();
-      continue;
+void CFGBuilder::addAutomaticObjDtorsForLifetimeExtendedTemporaries(
+    Stmt *E, bool LifetimeExtended) {
+  switch (E->getStmtClass()) {
+    // FIXME: What do we want to do for conditional operators and binary
+    // conditional operators?
+  case Stmt::MaterializeTemporaryExprClass: {
+    const MaterializeTemporaryExpr * MTE = cast<MaterializeTemporaryExpr>(E);
+    if (MTE->getStorageDuration() != SD_FullExpression) {
+      SmallVector<const Expr *, 2> CommaLHSs;
+      SmallVector<SubobjectAdjustment, 2> Adjustments;
+      assert(MTE->GetTemporaryExpr());
+      const Expr *ExtendedE =
+          MTE->GetTemporaryExpr()->skipRValueSubobjectAdjustments(CommaLHSs,
+                                                                  Adjustments);
+      addAutomaticObjDtorsForLifetimeExtendedTemporaries(
+          const_cast<Expr*>(ExtendedE), /*LifetimeExtended=*/true);
     }
-    
-    // Skip through the temporary-materialization expression.
-    if (const MaterializeTemporaryExpr *MTE
-          = dyn_cast<MaterializeTemporaryExpr>(Init)) {
-      Init = MTE->GetTemporaryExpr();
-      continue;
+  } break;
+  case Stmt::CXXBindTemporaryExprClass:
+    // If the temporary is not lifetime extended, we'll handle it in
+    // VisitForTemporaryDtors instead.
+    if (LifetimeExtended) {
+      const CXXDestructorDecl *Dtor =
+          cast<CXXBindTemporaryExpr>(E)->getTemporary()->getDestructor();
+      if (Dtor->isNoReturn()) {
+        Block = createNoReturnBlock();
+      } else {
+        autoCreateBlock();
       }
-    
-    // Skip derived-to-base and no-op casts.
-    if (const CastExpr *CE = dyn_cast<CastExpr>(Init)) {
-      if ((CE->getCastKind() == CK_DerivedToBase ||
-           CE->getCastKind() == CK_UncheckedDerivedToBase ||
-           CE->getCastKind() == CK_NoOp) &&
-          Init->getType()->isRecordType()) {
-        Init = CE->getSubExpr();
-        continue;
-      }
+      appendTemporaryDtor(Block, cast<CXXBindTemporaryExpr>(E));
+    break;
+  case Stmt::ConditionalOperatorClass:
+  case Stmt::BinaryConditionalOperatorClass:
+    // FIXME: Implement. If both the true and false branch yield lifetime
+    // extended temporaries, we need to add a branch that triggers on which
+    // temporary constructor was executed.
+    break;
+  default:
+    LifetimeExtended = false;
+    // Fallthrough.
+  case Stmt::ParenExprClass:
+  case Stmt::CXXFunctionalCastExprClass:
+  case Stmt::ImplicitCastExprClass:
+  case Stmt::ExprWithCleanupsClass:
+  case Stmt::CXXDefaultArgExprClass:
+  case Stmt::CXXDefaultInitExprClass:
+    for (Stmt *Child : E->children()) {
+      if (Child)
+        addAutomaticObjDtorsForLifetimeExtendedTemporaries(Child,
+                                                           LifetimeExtended);
     }
-    
-    // Skip member accesses into rvalues.
-    if (const MemberExpr *ME = dyn_cast<MemberExpr>(Init)) {
-      if (!ME->isArrow() && ME->getBase()->isRValue()) {
-        Init = ME->getBase();
-        continue;
-      }
-    }
-    
-    break;
-  }
+    break;
+  case Stmt::BlockExprClass:
+  case Stmt::LambdaExprClass:
+    break;
+void CFGBuilder::addAutomaticObjDtorsForVarDecl(VarDecl *VD,
+                                                Stmt *S) {
+  if (!VD->getType()->isReferenceType() &&
+      needsLocalScopeForType(VD->getType())) {
+    QualType QT = VD->getType();
+    QT = Context->getBaseElementType(QT);
+
+    const CXXDestructorDecl *Dtor = QT->getAsCXXRecordDecl()->getDestructor();
+    if (Dtor->isNoReturn())
+      Block = createNoReturnBlock();
+    else
+      autoCreateBlock();
 
-  return Init->getType();
+    appendAutomaticObjDtor(Block, VD, S);
+  }
+  if (const Expr *Init = VD->getInit()) {
+    addAutomaticObjDtorsForLifetimeExtendedTemporaries(
+        const_cast<Expr *>(Init));
+  }
 }
-  
 /// addAutomaticObjDtors - Add to current block automatic objects destructors
 /// for objects in range of local scope positions. Use S as trigger statement
 /// for destructors.
 void CFGBuilder::addAutomaticObjDtors(LocalScope::const_iterator B,
                                       LocalScope::const_iterator E, Stmt *S) {
   if (!BuildOpts.AddImplicitDtors)
     return;
 
   if (B == E)
     return;
 
   // We need to append the destructors in reverse order, but any one of them
   // may be a no-return destructor which changes the CFG. As a result, buffer
   // this sequence up and replay them in reverse order when appending onto the
   // CFGBlock(s).
   SmallVector<VarDecl*, 10> Decls;
   Decls.reserve(B.distance(E));
   for (LocalScope::const_iterator I = B; I != E; ++I)
     Decls.push_back(*I);
 
   for (SmallVectorImpl<VarDecl*>::reverse_iterator I = Decls.rbegin(),
                                                    E = Decls.rend();
        I != E; ++I) {
-    // If this destructor is marked as a no-return destructor, we need to
-    // create a new block for the destructor which does not have as a successor
-    // anything built thus far: control won't flow out of this block.
-    QualType Ty = (*I)->getType();
-    if (Ty->isReferenceType()) {
-      Ty = getReferenceInitTemporaryType(*Context, (*I)->getInit());
-    }
-    Ty = Context->getBaseElementType(Ty);
-
-    const CXXDestructorDecl *Dtor = Ty->getAsCXXRecordDecl()->getDestructor();
-    if (Dtor->isNoReturn())
-      Block = createNoReturnBlock();
-    else
-      autoCreateBlock();
-
-    appendAutomaticObjDtor(Block, *I, S);
+    addAutomaticObjDtorsForVarDecl(*I, S);
   }
 }
 
 /// addImplicitDtorsForDestructor - Add implicit destructors generated for
 /// base and member objects in destructor.
 void CFGBuilder::addImplicitDtorsForDestructor(const CXXDestructorDecl *DD) {
   assert (BuildOpts.AddImplicitDtors
       && "Can be called only when dtors should be added");
if (!BuildOpts.AddImplicitDtors)
     return Scope;
 
   for (auto *DI : DS->decls())
     if (VarDecl *VD = dyn_cast<VarDecl>(DI))
       Scope = addLocalScopeForVarDecl(VD, Scope);
   return Scope;
 }
 
+bool CFGBuilder::needsLocalScopeForType(QualType QT) {
+  // Check for constant size array. Set type to array element type.
+  while (const ConstantArrayType *AT = Context->getAsConstantArrayType(QT)) {
+    if (AT->getSize() == 0)
+      return false;
+    QT = AT->getElementType();
+  }
+
+  // Check if type is a C++ class with non-trivial destructor.
+  if (const CXXRecordDecl *CD = QT->getAsCXXRecordDecl())
+    return !CD->hasTrivialDestructor();
+  return false;
+}
+
+bool CFGBuilder::needsLocalScopeForLifetimeExtendedTemporary(const Stmt* E) {
+  // FIXME: Handle cases where the scope would be introduced by a nested
+  // lambda or block.
+  switch (E->getStmtClass()) {
+  case Stmt::MaterializeTemporaryExprClass: {
+    const MaterializeTemporaryExpr * MTE = cast<MaterializeTemporaryExpr>(E);
+    if (MTE->getStorageDuration() != SD_FullExpression) {
+      SmallVector<const Expr *, 2> CommaLHSs;
+      SmallVector<SubobjectAdjustment, 2> Adjustments;
+      assert(MTE->GetTemporaryExpr());
+      const Expr *ExtendedE =
+          MTE->GetTemporaryExpr()->skipRValueSubobjectAdjustments(CommaLHSs,
+                                                                  Adjustments);
+      return needsLocalScopeForType(ExtendedE->getType()) ||
+             needsLocalScopeForLifetimeExtendedTemporary(ExtendedE);
+    }
+  } break;
+  default:
+    for (const Stmt *Child : E->children()) {
+      if (Child && needsLocalScopeForLifetimeExtendedTemporary(Child))
+        return true;
+    }
+    break;
+  }
+  return false;
+}
+
+bool CFGBuilder::needsLocalScopeForVarDecl(const VarDecl* VD) {
+  if (!VD->getType()->isReferenceType() &&
+      needsLocalScopeForType(VD->getType())) {
+    return true;
+  }
+  if (const Expr *Init = VD->getInit()) {
+    return needsLocalScopeForLifetimeExtendedTemporary(Init);
+  }
+  return false;
+}
+
 /// addLocalScopeForVarDecl - Add LocalScope for variable declaration. It will
 /// create add scope for automatic objects and temporary objects bound to
 /// const reference. Will reuse Scope if not NULL.
 LocalScope* CFGBuilder::addLocalScopeForVarDecl(VarDecl *VD,
                                                 LocalScope* Scope) {
   if (!BuildOpts.AddImplicitDtors)
     return Scope;
 
   // Check if variable is local.
   switch (VD->getStorageClass()) {
   case SC_None:
   case SC_Auto:
   case SC_Register:
     break;
   default: return Scope;
   }
 
-  // Check for const references bound to temporary. Set type to pointee.
-  QualType QT = VD->getType();
-  if (QT.getTypePtr()->isReferenceType()) {
-    // Attempt to determine whether this declaration lifetime-extends a
-    // temporary.
-    //
-    // FIXME: This is incorrect. Non-reference declarations can lifetime-extend
-    // temporaries, and a single declaration can extend multiple temporaries.
-    // We should look at the storage duration on each nested
-    // MaterializeTemporaryExpr instead.
-    const Expr *Init = VD->getInit();
-    if (!Init)
-      return Scope;
-    if (const ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(Init))
-      Init = EWC->getSubExpr();
-    if (!isa<MaterializeTemporaryExpr>(Init))
-      return Scope;
-
-    // Lifetime-extending a temporary.
-    QT = getReferenceInitTemporaryType(*Context, Init);
-  }
-
-  // Check for constant size array. Set type to array element type.
-  while (const ConstantArrayType *AT = Context->getAsConstantArrayType(QT)) {
-    if (AT->getSize() == 0)
-      return Scope;
-    QT = AT->getElementType();
-  }
-
-  // Check if type is a C++ class with non-trivial destructor.
-  if (const CXXRecordDecl *CD = QT->getAsCXXRecordDecl())
-    if (!CD->hasTrivialDestructor()) {
-      // Add the variable to scope
-      Scope = createOrReuseLocalScope(Scope);
-      Scope->addVar(VD);
-      ScopePos = Scope->begin();
-    }
+  if (!needsLocalScopeForVarDecl(VD))
   return Scope;
 }
 
 /// addLocalScopeAndDtors - For given statement add local scope for it and
 /// add destructors that will cleanup the scope. Will reuse Scope if not NULL.
 void CFGBuilder::addLocalScopeAndDtors(Stmt *S) {
   if (!BuildOpts.AddImplicitDtors)
     return;

test/Analysis/auto-obj-dtors-cfg-output.cpp

 // CHECK-NEXT:   3: a
 // CHECK-NEXT:   4: [B1.3] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   5: const A &b = a;
 // CHECK-NEXT:   6: A() (CXXConstructExpr, class A)
 // CHECK-NEXT:   7: [B1.6] (BindTemporary)
 // CHECK-NEXT:   8: [B1.7] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   9: [B1.8]
 // CHECK:       10: const A &c = A();
-// CHECK:       11: [B1.10].~A() (Implicit destructor)
+// CHECK:       11: ~A()
 // CHECK:       12: [B1.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B2
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void test_const_ref() {
   A a;
   const A& b = a;

test/Analysis/cfg.cpp

 // RUN: %clang_cc1 -analyze -analyzer-checker=debug.DumpCFG -triple x86_64-apple-darwin12 -analyzer-config cfg-temporary-dtors=true -std=c++11 %s > %t 2>&1
 // RUN: FileCheck --input-file=%t %s
 
+#include "Inputs/system-header-simulator-cxx.h"
+
 // CHECK-LABEL: void checkWrap(int i)
 // CHECK: ENTRY
 // CHECK-NEXT: Succs (1): B1
 // CHECK: [B1]
 // CHECK: Succs (21): B2 B3 B4 B5 B6 B7 B8 B9
 // CHECK: B10 B11 B12 B13 B14 B15 B16 B17 B18 B19
 // CHECK: B20 B21 B0
 // CHECK: [B0 (EXIT)]

 // CHECK: [B0 (EXIT)]
 // CHECK-NEXT:  Preds (1): B1
 
 void test_placement_new_array() {
   int buffer[16];
   MyClass* obj = new (buffer) MyClass[5];
 }
 
-
 // CHECK-LABEL: void test_lifetime_extended_temporaries()
 // CHECK: [B1]
-struct LifetimeExtend { LifetimeExtend(int); ~LifetimeExtend(); };
+struct LifetimeExtend { LifetimeExtend(int); ~LifetimeExtend(); int i; };
 struct Aggregate { const LifetimeExtend a; const LifetimeExtend b; };
 struct AggregateRef { const LifetimeExtend &a; const LifetimeExtend &b; };
 void test_lifetime_extended_temporaries() {
   // CHECK: LifetimeExtend(1);
   // CHECK-NEXT: : 1
   // CHECK-NEXT: ~LifetimeExtend()
   // CHECK-NOT: ~LifetimeExtend()
   {
void test_lifetime_extended_temporaries() {
   // CHECK-NEXT: : 4
   // CHECK-NOT: ~LifetimeExtend()
   {
     Aggregate a{LifetimeExtend(4), LifetimeExtend(4)};
     4;
   }
   // CHECK: LifetimeExtend(5)
   // CHECK-NEXT: : 5
-  // FIXME: We want to emit the destructors of the lifetime
-  // extended variables here.
+  // CHECK-NEXT: ~LifetimeExtend()
+  // CHECK-NEXT: ~LifetimeExtend()
   // CHECK-NOT: ~LifetimeExtend()
   {
     AggregateRef a{LifetimeExtend(5), LifetimeExtend(5)};
     5;
   }
-  // FIXME: Add tests for lifetime extension via subobject
-  // references (LifetimeExtend().some_member).
+  // CHECK: LifetimeExtend(6)
+  // CHECK-NEXT: : 6
+  // CHECK-NEXT: ~LifetimeExtend()
+  // CHECK-NOT: ~LifetimeExtend()
+  {
+    const int &i = LifetimeExtend(6).i;
+    6;
+  }
+}
+
+
+// CHECK-LABEL: void test_lifetime_extended_temporaries_for_range()
+void test_lifetime_extended_temporaries_for_range() {
+  // CHECK: [B1]
+  // CHECK-NEXT: ~const LifetimeExtend [1]()
+  // CHECK-NEXT: Preds (1): B2
+  // CHECK: auto &&__range = { LifetimeExtend(7) };
+  // CHECK-NEXT: ~LifetimeExtend() (Temporary object destructor)
+  {
+    for (LifetimeExtend e : {LifetimeExtend(7)}) {
+      1;
+    }
+  }
 }
 
 
 // CHECK-LABEL: int *PR18472()
 // CHECK: [B2 (ENTRY)]
 // CHECK-NEXT:   Succs (1): B1
 // CHECK: [B1]
 // CHECK-NEXT:   1: 0

test/Analysis/temp-obj-dtors-cfg-output.cpp

 // CHECK:     Succs (2): B2 B1
 // CHECK:   [B0 (EXIT)]
 // CHECK:     Preds (2): B1 B2
 // CHECK:   [B14 (ENTRY)]
 // CHECK:     Succs (1): B13
 // CHECK:   [B1]
 // CHECK:     1: ~B() (Temporary object destructor)
 // CHECK:     2: int b;
-// CHECK:     3: [B10.4].~A() (Implicit destructor)
 // CHECK:     Preds (2): B2 B3
 // CHECK:     Succs (1): B0
 // CHECK:   [B2]
 // CHECK:     1: ~A() (Temporary object destructor)
 // CHECK:     2: ~A() (Temporary object destructor)
 // CHECK:     Preds (1): B4
 // CHECK:     Succs (1): B1
 // CHECK:   [B3]

 // CHECK:     Succs (2): B5 B6
 // CHECK:   [B0 (EXIT)]
 // CHECK:     Preds (1): B1
 // CHECK:   [B13 (ENTRY)]
 // CHECK:     Succs (1): B12
 // CHECK:   [B1]
 // CHECK:     1: ~A() (Temporary object destructor)
 // CHECK:     2: int b;
-// CHECK:     3: [B9.4].~A() (Implicit destructor)
 // CHECK:     Preds (2): B2 B3
 // CHECK:     Succs (1): B0
 // CHECK:   [B2]
 // CHECK:     1: ~A() (Temporary object destructor)
 // CHECK:     Preds (1): B4
 // CHECK:     Succs (1): B1
 // CHECK:   [B3]
 // CHECK:     1: ~A() (Temporary object destructor)

 // CHECK:     7: [B1.6] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class A &))
 // CHECK:     8: A() (CXXConstructExpr, class A)
 // CHECK:     9: [B1.8] (BindTemporary)
 // CHECK:    10: [B1.9] (ImplicitCastExpr, NoOp, const class A)
 // CHECK:    11: [B1.10]
 // CHECK:    12: [B1.7]([B1.11])
 // CHECK:    13: ~A() (Temporary object destructor)
 // CHECK:    14: int b;
-// CHECK:    15: [B1.5].~A() (Implicit destructor)
+// CHECK:    15: ~A() (Temporary object destructor)
 // CHECK:     Preds (1): B2
 // CHECK:     Succs (1): B0
 // CHECK:   [B0 (EXIT)]
 // CHECK:     Preds (1): B1
 // CHECK:   [B2 (ENTRY)]
 // CHECK:     Succs (1): B1
 // CHECK:   [B1]
 // CHECK:     1: A::make

 // CHECK:    11: [B1.10] (ImplicitCastExpr, FunctionToPointerDecay, class A (*)(void))
 // CHECK:    12: [B1.11]()
 // CHECK:    13: [B1.12] (BindTemporary)
 // CHECK:    14: [B1.13] (ImplicitCastExpr, NoOp, const class A)
 // CHECK:    15: [B1.14]
 // CHECK:    16: [B1.9]([B1.15])
 // CHECK:    17: ~A() (Temporary object destructor)
 // CHECK:    18: int b;
-// CHECK:    19: [B1.7].~A() (Implicit destructor)
+// CHECK:    19: ~A() (Temporary object destructor)
 // CHECK:     Preds (1): B2
 // CHECK:     Succs (1): B0
 // CHECK:   [B0 (EXIT)]
 // CHECK:     Preds (1): B1
 // CHECK:   [B2 (ENTRY)]
 // CHECK:     Succs (1): B1
 // CHECK:   [B1]
 // CHECK:     1: int a;

 // CHECK:     Preds (1): B2
 // CHECK:     Succs (1): B0
 // CHECK:   [B0 (EXIT)]
 // CHECK:     Preds (1): B1
 // CHECK:   [B3 (ENTRY)]
 // CHECK:     Succs (1): B2
 // CHECK:   [B1]
 // CHECK:     1: int b;
+// CHECK:     Preds (1): B2(Unreachable)
 // CHECK:     Succs (1): B0
 // CHECK:   [B2 (NORETURN)]
 // CHECK:     1: int a;
 // CHECK:     2: NoReturn() (CXXConstructExpr, class NoReturn)
 // CHECK:     3: [B2.2] (BindTemporary)
 // CHECK:     4: [B2.3].f
 // CHECK:     5: [B2.4]()
 // CHECK:     6: ~NoReturn() (Temporary object destructor)
 // CHECK:     Preds (1): B3
 // CHECK:     Succs (1): B0
 // CHECK:   [B0 (EXIT)]
 // CHECK:     Preds (2): B1 B2
 // CHECK:   [B3 (ENTRY)]
 // CHECK:     Succs (1): B2
 // CHECK:   [B1]
 // CHECK:     1: int b;
+// CHECK:     Preds (1): B2(Unreachable)
 // CHECK:     Succs (1): B0
 // CHECK:   [B2 (NORETURN)]
 // CHECK:     1: int a;
 // CHECK:     2: NoReturn() (CXXConstructExpr, class NoReturn)
 // CHECK:     3: [B2.2] (BindTemporary)
 // CHECK:     4: 47
 // CHECK:     5: ... , [B2.4]
 // CHECK:     6: ~NoReturn() (Temporary object destructor)