nonblocking/nonallocating attributes: 2nd pass caller/callee analysis

clang/lib/Sema/SemaFunctionEffects.cpp

@@ -158,6 +158,8 @@ static FunctionEffectKindSet getBuiltinFunctionEffects(unsigned BuiltinID) {
     break;
 
   // These block in some other way than allocating memory.
+  // longjmp() and friends are presumed unsafe because they are the moral
+  // equivalent of throwing a C++ exception, which is unsafe.
   case Builtin::ID::BIlongjmp:
   case Builtin::ID::BI_longjmp:
   case Builtin::ID::BIsiglongjmp:
@@ -1016,17 +1018,22 @@ class Analyzer {
       // Check for a call to a builtin function, whose effects are
       // handled specially.
       if (const auto *FD = dyn_cast<FunctionDecl>(CI.CDecl)) {
+        bool IgnoreIfNoexceptNoreturn = true;
         if (unsigned BuiltinID = FD->getBuiltinID()) {
           CI.Effects = getBuiltinFunctionEffects(BuiltinID);
           if (CI.Effects.empty()) {
             // A builtin with no known effects is assumed safe.
             return;
           }
+          // A builtin WITH effects doesn't get any special treatment for
+          // being noreturn/noexcept, e.g. longjmp().
+          IgnoreIfNoexceptNoreturn = false;
         }
+
         // If the callee is both `noreturn` and `noexcept`, it presumably
         // terminates. Ignore it for the purposes of effect analysis.
         // If not C++, `noreturn` alone is sufficient.
-        if (FD->isNoReturn() &&
+        if (IgnoreIfNoexceptNoreturn && FD->isNoReturn() &&
             (!Outer.S.getLangOpts().CPlusPlus || isNoexcept(FD)))
           return;
       }

clang/test/Headers/Inputs/include/setjmp.h

@@ -5,4 +5,7 @@ typedef struct {
   int x[42];
 } jmp_buf;
 
+ __attribute__((noreturn))
+void longjmp(jmp_buf, int);
+
 #endif

clang/test/Sema/attr-nonblocking-constraints.c

@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c89 -Wfunction-effects %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c89 -Wfunction-effects -internal-isystem %S/../Headers/Inputs/include %s
 
 // Tests for a few cases involving C functions without prototypes.
 
@@ -16,3 +16,12 @@ void nb2(void) __attribute__((nonblocking)) {
   nb1();
   aborts(); // no diagnostic because it's noreturn.
 }
+
+#include <setjmp.h>
+
+void nb3(int x, int y) __attribute__((nonblocking)) {
+  if (x != y) {
+    jmp_buf jb;
+    longjmp(jb, 0); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' function 'longjmp'}}
+  }
+}