[Clang] `nothrow`-implying attributes should actually manifest `nothrow` attribute (PR58798)

[lebedev.ri]

Summary

This is part of https://reviews.llvm.org/D137381,
i've stumbled into this in https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=52989&q=label%3AProj-librawspeed

Look at the callee_with_clang_attr().
pure attribute implies nounwind, and we successfully manifest that at IRgen,
and calls from nounwind functions treat it as non-unwinding,
except that when generating function definition,
we'd suddenly forget that it is nounwind...

Here, everything that could go wrong, goes wrong.

CodeGenFunction::EmitStartEHSpec() looks at the AST function exception specification,
and not IR attributes, so

You'd think we can inferr the attribute in AST after the fact,
in Sema::ActOnFunctionDeclarator(), and while that is sufficient to get the diagnostics,
the function exception specification has already been computed from parsed attributes.

So we also need to adjust handleFunctionTypeAttr() (called by processTypeAttrs())
so it considers just-parsed pure as if it's nothrow...

It would somewhat less ugly if we could just infer nothrow attribute
during *attribute parsing* from pure/etc. Is that possible?

Also, OpenMP declare variant tests are showing an unexpected error,
looks like i'm missing some attribute propagation?

[MaskRay]

This comment has been deleted.

[erichkeane]

clang/lib/Sema/SemaDeclAttr.cpp

8794

First, I'm not a fan of doing this in this list ast all, we shouldn't really have logic here, this is mostly just a jump table.

Second, I guess I'm not getting why IRGen cannot figure out from the AST that Pure/Const/NoAlias all imply nothrow?

[lebedev.ri]

Actually, apparently those attributes really do introduce UB, so it is correct that they do not cause program termination.
https://reviews.llvm.org/D137381#3927923

clang/lib/CodeGen/CGCall.cpp

if (const FunctionDecl *Fn = dyn_cast<FunctionDecl>(TargetDecl)) {
         NBA = Fn->getAttr<NoBuiltinAttr>();
       }
       // Only place nomerge attribute on call sites, never functions. This
       // allows it to work on indirect virtual function calls.
       if (AttrOnCallSite && TargetDecl->hasAttr<NoMergeAttr>())
         FuncAttrs.addAttribute(llvm::Attribute::NoMerge);
     }
 
-    // 'const', 'pure' and 'noalias' attributed functions are also nounwind.
+    // 'const', 'pure' and 'noalias' attributed functions are also nounwind,
+    // but that is manifested in AST, so we don't need to deal with that here.
     if (TargetDecl->hasAttr<ConstAttr>()) {
       FuncAttrs.addMemoryAttr(llvm::MemoryEffects::none());
-      FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
       // gcc specifies that 'const' functions have greater restrictions than
       // 'pure' functions, so they also cannot have infinite loops.
       FuncAttrs.addAttribute(llvm::Attribute::WillReturn);
     } else if (TargetDecl->hasAttr<PureAttr>()) {
       FuncAttrs.addMemoryAttr(llvm::MemoryEffects::readOnly());
-      FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
       // gcc specifies that 'pure' functions cannot have infinite loops.
       FuncAttrs.addAttribute(llvm::Attribute::WillReturn);
     } else if (TargetDecl->hasAttr<NoAliasAttr>()) {
       FuncAttrs.addMemoryAttr(llvm::MemoryEffects::argMemOnly());
-      FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
     }
     if (TargetDecl->hasAttr<RestrictAttr>())
       RetAttrs.addAttribute(llvm::Attribute::NoAlias);
     if (TargetDecl->hasAttr<ReturnsNonNullAttr>() &&
         !CodeGenOpts.NullPointerIsValid)
       RetAttrs.addAttribute(llvm::Attribute::NonNull);
     if (TargetDecl->hasAttr<AnyX86NoCallerSavedRegistersAttr>())
       FuncAttrs.addAttribute("no_caller_saved_registers");

clang/lib/Sema/SemaDeclAttr.cpp

case ParsedAttr::AT_CXX11NoReturn:
     break;
   case ParsedAttr::AT_AnyX86NoCfCheck:
     handleNoCfCheckAttr(S, D, AL);
     break;
   case ParsedAttr::AT_NoThrow:
     if (!AL.isUsedAsTypeAttr())
       handleSimpleAttribute<NoThrowAttr>(S, D, AL);
     break;
+  case ParsedAttr::AT_Pure:
+    handleSimpleAttribute<PureAttr>(S, D, AL);
+    if (!D->hasAttr<NoThrowAttr>()) {
+      handleSimpleAttribute<NoThrowAttr>(S, D, AL);
+      D->getAttr<NoThrowAttr>()->setImplicit(true);
+    }
+    break;
+  case ParsedAttr::AT_Const:
+    handleSimpleAttribute<ConstAttr>(S, D, AL);
+    if (!D->hasAttr<NoThrowAttr>()) {
+      handleSimpleAttribute<NoThrowAttr>(S, D, AL);
+      D->getAttr<NoThrowAttr>()->setImplicit(true);
+    }
+    break;
+  case ParsedAttr::AT_NoAlias:
+    handleSimpleAttribute<NoAliasAttr>(S, D, AL);
+    if (!D->hasAttr<NoThrowAttr>()) {
+      handleSimpleAttribute<NoThrowAttr>(S, D, AL);
+      D->getAttr<NoThrowAttr>()->setImplicit(true);
+    }
+    break;
   case ParsedAttr::AT_CUDAShared:
     handleSharedAttr(S, D, AL);
     break;
   case ParsedAttr::AT_VecReturn:
     handleVecReturnAttr(S, D, AL);
     break;
   case ParsedAttr::AT_ObjCOwnership:
     handleObjCOwnershipAttr(S, D, AL);

clang/lib/Sema/SemaType.cpp

if (attr.getKind() == ParsedAttr::AT_Regparm) {
     }
 
     FunctionType::ExtInfo EI =
       unwrapped.get()->getExtInfo().withRegParm(value);
     type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
     return true;
   }
 
-  if (attr.getKind() == ParsedAttr::AT_NoThrow) {
+  if (attr.getKind() == ParsedAttr::AT_NoThrow ||
+      attr.getKind() == ParsedAttr::AT_Pure ||
+      attr.getKind() == ParsedAttr::AT_Const ||
+      attr.getKind() == ParsedAttr::AT_NoAlias) {
     // Delay if this is not a function type.
     if (!unwrapped.isFunctionType())
       return false;
 
     if (S.CheckAttrNoArgs(attr)) {
       attr.setInvalid();
       return true;
     }
case ParsedAttr::AT_ObjCKindOf:
       }
 
       // Apply it regardless.
       if (checkObjCKindOfType(state, type, attr))
         attr.setInvalid();
       break;
 
     case ParsedAttr::AT_NoThrow:
-    // Exception Specifications aren't generally supported in C mode throughout
-    // clang, so revert to attribute-based handling for C.
+    case ParsedAttr::AT_Pure:    // (implies nothrow attr)
+    case ParsedAttr::AT_Const:   // (implies nothrow attr)
+    case ParsedAttr::AT_NoAlias: // (implies nothrow attr)
+      // Exception Specifications aren't generally supported in C mode
+      // throughout clang, so revert to attribute-based handling for C.
       if (!state.getSema().getLangOpts().CPlusPlus)
         break;
       [[fallthrough]];
     FUNCTION_TYPE_ATTRS_CASELIST:
       attr.setUsedAsTypeAttr();
 
       // Attributes with standard syntax have strict rules for what they
       // appertain to and hence should not use the "distribution" logic below.

clang/test/CodeGenCXX/pr58798.cpp

 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --check-attributes
 // RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu -fexceptions -fcxx-exceptions | FileCheck %s
 
 // CHECK: Function Attrs: mustprogress noinline nounwind optnone willreturn memory(read)
 // CHECK-LABEL: define {{[^@]+}}@_Z54early_caller_of_callee_with_clang_attr_with_clang_attri
 // CHECK-SAME: (i32 noundef [[A:%.*]]) #[[ATTR0:[0-9]+]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i32, align 4
 // CHECK-NEXT:    store i32 [[A]], ptr [[A_ADDR]], align 4
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[A_ADDR]], align 4
 // CHECK-NEXT:    [[CALL:%.*]] = call noundef i32 @_Z22callee_with_clang_attri(i32 noundef [[TMP0]]) #[[ATTR3:[0-9]+]]
 // CHECK-NEXT:    ret i32 [[CALL]]
 //
 
 // CHECK: Function Attrs: mustprogress noinline nounwind optnone willreturn memory(read)
 // CHECK-LABEL: define {{[^@]+}}@_Z22callee_with_clang_attri
-// CHECK-SAME: (i32 noundef [[A:%.*]]) #[[ATTR0]] {
+// CHECK-SAME: (i32 noundef [[A:%.*]]) #[[ATTR0]] personality ptr @__gxx_personality_v0 {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i32, align 4
 // CHECK-NEXT:    store i32 [[A]], ptr [[A_ADDR]], align 4
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[A_ADDR]], align 4
 // CHECK-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[TMP0]], 0
 // CHECK-NEXT:    br i1 [[TOBOOL]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 // CHECK:       if.then:
 // CHECK-NEXT:    [[EXCEPTION:%.*]] = call ptr @__cxa_allocate_exception(i64 4) #[[ATTR4:[0-9]+]]
 // CHECK-NEXT:    store i32 42, ptr [[EXCEPTION]], align 16
-// CHECK-NEXT:    call void @__cxa_throw(ptr [[EXCEPTION]], ptr @_ZTIi, ptr null) #[[ATTR5:[0-9]+]]
-// CHECK-NEXT:    unreachable
+// CHECK-NEXT:    invoke void @__cxa_throw(ptr [[EXCEPTION]], ptr @_ZTIi, ptr null) #[[ATTR5:[0-9]+]]
+// CHECK-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[TERMINATE_LPAD:%.*]]
 // CHECK:       if.end:
 // CHECK-NEXT:    ret i32 24
+// CHECK:       terminate.lpad:
+// CHECK-NEXT:    [[TMP1:%.*]] = landingpad { ptr, i32 }
+// CHECK-NEXT:    catch ptr null
+// CHECK-NEXT:    [[TMP2:%.*]] = extractvalue { ptr, i32 } [[TMP1]], 0
+// CHECK-NEXT:    call void @__clang_call_terminate(ptr [[TMP2]]) #[[ATTR6:[0-9]+]]
+// CHECK-NEXT:    unreachable
+// CHECK:       unreachable:
+// CHECK-NEXT:    unreachable
 //
 
 // CHECK: Function Attrs: mustprogress noinline nounwind optnone
 // CHECK-LABEL: define {{[^@]+}}@_Z52early_caller_of_callee_with_clang_attr_with_cxx_attri
 // CHECK-SAME: (i32 noundef [[A:%.*]]) #[[ATTR1:[0-9]+]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i32, align 4
 // CHECK-NEXT:    store i32 [[A]], ptr [[A_ADDR]], align 4

 // CHECK-NEXT:    invoke void @__cxa_throw(ptr [[EXCEPTION]], ptr @_ZTIi, ptr null) #[[ATTR5]]
 // CHECK-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[TERMINATE_LPAD:%.*]]
 // CHECK:       if.end:
 // CHECK-NEXT:    ret i32 24
 // CHECK:       terminate.lpad:
 // CHECK-NEXT:    [[TMP1:%.*]] = landingpad { ptr, i32 }
 // CHECK-NEXT:    catch ptr null
 // CHECK-NEXT:    [[TMP2:%.*]] = extractvalue { ptr, i32 } [[TMP1]], 0
-// CHECK-NEXT:    call void @__clang_call_terminate(ptr [[TMP2]]) #[[ATTR6:[0-9]+]]
+// CHECK-NEXT:    call void @__clang_call_terminate(ptr [[TMP2]]) #[[ATTR6]]
 // CHECK-NEXT:    unreachable
 // CHECK:       unreachable:
 // CHECK-NEXT:    unreachable
 //
 
 // CHECK: Function Attrs: mustprogress noinline nounwind optnone
 // CHECK-LABEL: define {{[^@]+}}@_Z50early_caller_of_callee_with_cxx_attr_with_cxx_attri
 // CHECK-SAME: (i32 noundef [[A:%.*]]) #[[ATTR1]] {
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i32, align 4
 // CHECK-NEXT:    store i32 [[A]], ptr [[A_ADDR]], align 4
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[A_ADDR]], align 4
 // CHECK-NEXT:    [[CALL:%.*]] = call noundef i32 @_Z20callee_with_cxx_attri(i32 noundef [[TMP0]]) #[[ATTR4]]
 // CHECK-NEXT:    ret i32 [[CALL]]
 //
 
-
 // Forward declarations:
 
 __attribute__((pure)) int callee_with_clang_attr(int a);
 int callee_with_cxx_attr(int a) noexcept;
 
 // Calls to forward declarations:
 
 __attribute__((pure)) int early_caller_of_callee_with_clang_attr_with_clang_attr(int a) {

clang/test/OpenMP/declare_variant_messages.cpp

 
 #pragma omp declare variant(foo) match(implementation = {vendor(score(constexpr_fn(3)) : llvm)})
 #pragma omp declare variant(foo) match(implementation = {vendor(score(constexpr_fn(C)) : llvm)})
 #pragma omp declare variant(foo) match(user = {condition(constexpr_fn(1))})
 #pragma omp declare variant(foo) match(user = {condition(constexpr_fn(C))})
 template <int C>
 int score_and_cond_const_inst();
 
+// FIXME: why does this produce: error: exception specification in declaration does not match previous declaration
 __attribute__((pure)) int pure() { return 0; }
 
 #pragma omp declare variant(pure) match(user = {condition(1)}) // expected-warning {{ignoring return value of function declared with pure attribute}}
 int unused_warning_after_specialization() { return foo(); }
 
 void score_and_cond_inst() {
   score_and_cond_non_const();
   score_and_cond_non_const_inst<8>(); // expected-note {{in instantiation of function template specialization 'score_and_cond_non_const_inst<8>' requested here}}

clang/test/SemaCXX/attr-print.cpp

 // RUN: %clang_cc1 %s -ast-print -fms-extensions | FileCheck %s
 
 // CHECK: int x __attribute__((aligned(4)));
 int x __attribute__((aligned(4)));
 
 // FIXME: Print this at a valid location for a __declspec attr.
 // CHECK: int y __declspec(align(4));
 __declspec(align(4)) int y;
 
-// CHECK: void foo() __attribute__((const));
+// CHECK: void foo() noexcept __attribute__((const));
 void foo() __attribute__((const));
 
-// CHECK: void bar() __attribute__((__const));
+// CHECK: void bar() noexcept __attribute__((__const));
 void bar() __attribute__((__const));
 
 // FIXME: Print this with correct format.
-// CHECK: void foo1() __attribute__((noinline)) __attribute__((pure));
+// CHECK: void foo1() noexcept __attribute__((noinline)) __attribute__((pure));
 void foo1() __attribute__((noinline, pure));
 
 // CHECK: typedef int Small1 __attribute__((mode(byte)));
 typedef int Small1 __attribute__((mode(byte)));
 
 // CHECK: int small __attribute__((mode(byte)));
 int small __attribute__((mode(byte)));
 

clang/test/SemaCXX/cxx11-attr-print.cpp

 int e __attribute__((deprecated("warning", "fixit")));
 
 // CHECK: int cxx11_alignas alignas(4);
 alignas(4) int cxx11_alignas;
 
 // CHECK: int c11_alignas _Alignas(alignof(int));
 _Alignas(int) int c11_alignas;
 
-// CHECK: void foo() __attribute__((const));
+// CHECK: void foo() noexcept __attribute__((const));
 void foo() __attribute__((const));
 
-// CHECK: void bar() __attribute__((__const));
+// CHECK: void bar() noexcept __attribute__((__const));
 void bar() __attribute__((__const));
 
 // FIXME: It's unfortunate that the string literal prints with the below three
 // cases given that the string is only exposed via the [[nodiscard]] spelling.
 // CHECK: int f1() __attribute__((warn_unused_result("")));
 int f1() __attribute__((warn_unused_result));
 
 // CHECK: {{\[}}[clang::warn_unused_result("")]];

 inline void f7 [[gnu::gnu_inline]] ();
 
 // arguments printing
 // CHECK: __attribute__((format(printf, 2, 3)));
 void f8 (void *, const char *, ...) __attribute__ ((format (printf, 2, 3)));
 
 // CHECK: int m __attribute__((aligned(4
 // CHECK: int n alignas(4
-// CHECK: static int f() __attribute__((pure))
-// CHECK: static int g() {{\[}}[gnu::pure]]
+// CHECK: static int f() noexcept __attribute__((pure))
+// CHECK: static int g() noexcept {{\[}}[gnu::pure]]
 template <typename T> struct S {
   __attribute__((aligned(4))) int m;
   alignas(4) int n;
   __attribute__((pure)) static int f() {
     return 0;
   }
   [[gnu::pure]] static int g() {
     return 1;
   }
 };
 
 // CHECK: int m __attribute__((aligned(4
 // CHECK: int n alignas(4
-// CHECK: static int f() __attribute__((pure))
-// CHECK: static int g() {{\[}}[gnu::pure]]
+// CHECK: static int f() noexcept __attribute__((pure))
+// CHECK: static int g() noexcept {{\[}}[gnu::pure]]
 template struct S<int>;
 
 // CHECK: using Small2 {{\[}}[gnu::mode(byte)]] = int;
 using Small2 [[gnu::mode(byte)]] = int;

clang/test/SemaCXX/warn-throw-out-noexcept-func.cpp

__attribute__((nothrow)) R_ShouldDiag() {// expected-note {{function declared non-throwing here}}
     throw 1;// expected-warning {{has a non-throwing exception specification but}}
   }
   void __attribute__((nothrow)) SomeThrow() {// expected-note {{function declared non-throwing here}}
    throw 1; // expected-warning {{has a non-throwing exception specification but}}
   }
   void __declspec(nothrow) SomeDeclspecThrow() {// expected-note {{function declared non-throwing here}}
    throw 1; // expected-warning {{has a non-throwing exception specification but}}
   }
+  void __attribute__((pure)) SomeAnotherThrow() {// expected-note {{function declared non-throwing here}}
+   throw 1; // expected-warning {{has a non-throwing exception specification but}}
+  }
 };
 
 struct M_ShouldNotDiag {
   B_ShouldDiag b;
   ~M_ShouldNotDiag() noexcept(false);
 };
 
 M_ShouldNotDiag::~M_ShouldNotDiag() noexcept(false) {

 void n_ShouldNotDiag() noexcept {
   try {
     S s = S{};
     throw s;
   } catch (const S &s) {
   }
 }
 // As seen in p34973, this should not throw the warning.  If there is an active
-// exception, catch(...) catches everything. 
+// exception, catch(...) catches everything.
 void o_ShouldNotDiag() noexcept {
   try {
     throw;
   } catch (...) {
   }
 }
 
 void p_ShouldNotDiag() noexcept {