Fix PR13910: Don't warn that __builtin_unreachable() is unreachable

[arphaman]

Summary

This patch fixes the issue of clang emitting an unreachable warning when it encounters unreachable __builtin_unreachable() statements. It detects references to __builtin_unreachable and doesn't emit an unreachable warning for them.

[arphaman]

Slight update: There's no need to pass CFGBlock into isBuiltinUnreachable.

[aprantl]

lib/Analysis/ReachableCode.cpp

64

Maybe also wrap the inner dyn_cast in an if for symmetry?

static bool isBuiltinUnreachable(const Stmt *S) {
  if (const auto *DRE = dyn_cast<DeclRefExpr>(S))
    if (const auto *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl()))
      return FDecl->getIdentifier() &&
             FDecl->getBuiltinID() == Builtin::BI__builtin_unreachable;
  return false;
}

[arphaman]

The updated patch uses Adrian's suggestion.

[aprantl]

Thanks, LGTM!

lib/Analysis/ReachableCode.cpp

if (const Stmt *Term = B->getTerminator()) {
     if (const DoStmt *DS = dyn_cast<DoStmt>(Term)) {
       const Expr *Cond = DS->getCond()->IgnoreParenCasts();
       return Cond == S && isTrivialExpression(Cond);
     }
   }
   return false;
 }
 
+static bool isBuiltinUnreachable(const Stmt *S) {
+  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(S)) {
+    const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
+    return FDecl && FDecl->getIdentifier() &&
+           FDecl->getBuiltinID() == Builtin::BI__builtin_unreachable;
+  }
+  return false;
+}
+
 static bool isDeadReturn(const CFGBlock *B, const Stmt *S) {
   // Look to see if the current control flow ends with a 'return', and see if
   // 'S' is a substatement. The 'return' may not be the last element in the
   // block, or may be in a subsequent block because of destructors.
   const CFGBlock *Current = B;
   while (true) {
     for (CFGBlock::const_reverse_iterator I = Current->rbegin(),
                                           E = Current->rend();

 void DeadCodeScan::reportDeadCode(const CFGBlock *B,
                                   const Stmt *S,
                                   clang::reachable_code::Callback &CB) {
   // Classify the unreachable code found, or suppress it in some cases.
   reachable_code::UnreachableKind UK = reachable_code::UK_Other;
 
   if (isa<BreakStmt>(S)) {
     UK = reachable_code::UK_Break;
-  }
-  else if (isTrivialDoWhile(B, S)) {
+  } else if (isTrivialDoWhile(B, S) || isBuiltinUnreachable(S)) {
     return;
   }
   else if (isDeadReturn(B, S)) {
     UK = reachable_code::UK_Return;
   }
 
   SourceRange SilenceableCondVal;
 

test/Sema/warn-unreachable.c

void test_with_paren_silencing(int x) {
   else
     calledFun();
   
   if (!(1))
     calledFun(); // no-warning
   else
     calledFun();
 }
+
+int pr13910_foo(int x) {
+  if (x == 1)
+    return 0;
+  else
+    return x;
+  __builtin_unreachable(); // expected no warning
+}
+
+int pr13910_bar(int x) {
+  switch (x) {
+  default:
+    return x + 1;
+  }
+  pr13910_foo(x); // expected-warning {{code will never be executed}}
+}
+
+int pr13910_bar2(int x) {
+  if (x == 1)
+    return 0;
+  else
+    return x;
+  pr13910_foo(x);          // expected-warning {{code will never be executed}}
+  __builtin_unreachable(); // expected no warning
+  pr13910_foo(x);          // expected-warning {{code will never be executed}}
+}
+
+void pr13910_noreturn() {
+  raze();
+  __builtin_unreachable(); // expected no warning
+}
+
+void pr13910_assert() {
+  myassert(0 && "unreachable");
+  return;
+  __builtin_unreachable(); // expected no warning
+}