[clang] Better UX for Clang’s unwind-affecting attributes

[lebedev.ri]

Summary

This is an implementation of the following RFC:
https://discourse.llvm.org/t/rfc-better-ux-for-clangs-unwind-affecting-attributes/66890

In C++, there are 3 possible behaviors when the
exception escapes out an function that can not unwind:

1. exception propagates into function's caller
2. defined behavior of immediate program termination
3. the wild UB case, behavior is undefined.

Let's look at obvious examples:

1. exception propagates into caller, is caught there, and all is good: https://godbolt.org/z/MbTW9rofn
2. exception can not exit noexcept function, program is terminated: https://godbolt.org/z/ffeaPz1dK

Now, the third case, the wild UB case, is the most interesting one.
There are 3 clang/gcc attributes that are relevant here, let's look at them:

1. __attribute__((pure)): https://godbolt.org/z/PY3KrETb7, there the fun begins. In clang, we get UB, in gcc we get "exception propagates into function's caller"
2. __attribute__((const)): https://godbolt.org/z/ozxoW16e9, same as __attribute__((pure))
3. __attribute__((nothrow)): https://godbolt.org/z/YMf4sTcfa, the behavior is consistently defined as immediate program termination. I do not understand why it was defined as such, in the sense of how is that different from plain noexcept, but at least we are consistent.

Now, there are 3 problems:

1. Our modelling of __attribute__((const))/__attribute__((pure)) differs from that of GCC, we add UB.
2. We can not ask for __attribute__((const))/__attribute__((pure)) behavior, without it acting as exception barrier.
3. We can not separately ask for the exception propagation to be UB. This would be a handy optimization tool, especially given how brittle our IRGen for the case 2. (program termination) is.

Therefore, this patch does two things:

1. Match GCC's implementation-defined behavior on __attribute__((pure))/__attribute__((const))
   • they should not cause UB on exception escape, nor should they cause immediate program termination, exceptions should be free to escape into their caller.
2. Introduce __attribute__((nounwind)), which would be lowered into LLVM IR's nounwind attribute, and if an exception escapes out of an function marked with such an attribute, wild UB happens.

Please note, while currently such an UB is indeed not sanitized,
i have a patch in progress to handle it:
https://reviews.llvm.org/D137381,
so we would not be introducing something that is impossible to deal with.

[erichkeane]

clang/docs/ReleaseNotes.rst

955–956

unrelated changes here?

clang/include/clang/Basic/AttrDocs.td

541

544

560

Similar changes to above. This attribute is more of an 'assertion' by the developer that they promise they don't do these things (and we will UB otherwise), so I think they need to be written from that perspective.

I might suggest making an attempt to reword these docs.

ALSO, since these attributes can be spelled clang::pure and clang::const (IIRC?), I'd suggest we make the documents spelling-agnostic other than in direct code examples.

clang/lib/Analysis/CFG.cpp

2725 ↗

(On Diff #478746)

I find myself thinking we should probably have a function in FunctionDecl that tests for the various states of the function, rather than keep checking the attribute's presence.

[lebedev.ri]

@erichkeane thank you for taking a look!

clang/docs/ReleaseNotes.rst

955–956

Having whitespaces before newline is bad :/
This is editor doing so on file save,
and my git complains otherwise.

clang/include/clang/Basic/AttrDocs.td

560

I might suggest making an attempt to reword these docs.

This is my best attempt :)
If you can propose a better wording,
please feel free to do so.

clang/lib/Analysis/CFG.cpp

2725 ↗

(On Diff #478746)

Yes, we have a huge spaghetti code spread through clang
that tries to answer the same two question:

1. i'm a caller, if i call this function, might it throw?
2. i'm a callee, what should i do with exceptions that try to unwind out of me?

I don't know how to improve that, and i don't think just moving this into FunctionDecl would help.

[erichkeane]

I'll take a look at rewording the docs if no one else does. I should hopefully have time next week, the rest of the patch is perhaps more important at the moment.

clang/docs/ReleaseNotes.rst

955–956

Yep, i had to turn that off in my editor at one point because I did this! I just pushed d5fc931ba to remove that WS, so this will disappear in your next rebase.

clang/lib/Analysis/CFG.cpp

2725 ↗

(On Diff #478746)

FunctionDecl::WontThrow and FunctionDecl::ShouldUnwind ?

[lebedev.ri]

clang/lib/Analysis/CFG.cpp

2725 ↗

(On Diff #478746)

As noted in the RFC, there are 3 possible behaviors on unwind.
If we want to improve interface, we should account for all of them.

[lebedev.ri]

I've been thinking, and it seems to me that explicitly opting into
__attribute__((nounwind))-provided semantics should override
the __attribute__((nothrow))/noexcept semantics.
So looks like i should look into exception specification handling.

[lebedev.ri]

(ping, maybe)

In D138958#3968118, @lebedev.ri wrote:

I've been thinking, and it seems to me that explicitly opting into
__attribute__((nounwind))-provided semantics should override
the __attribute__((nothrow))/noexcept semantics.
So looks like i should look into exception specification handling.

I've looked, and unless told otherwise, it seems like we
shouldn't add new exception specification for this attribute,
but special-case the attribute where it matters,
but i may be wrong.

[lebedev.ri]

Last(?) ping of the year?

[lebedev.ri]

ping

[erichkeane]

2 quick nits, otherwise LFTM.

clang/include/clang/Basic/AttrDocs.td

558

565

A quick sentence somewhere saying HOW this is a 'stronger' version of pure would be a good addition here.

[lebedev.ri]

In D138958#4037526, @erichkeane wrote:

2 quick nits, otherwise LFTM.

@erichkeane thank you for the review!
@aaron.ballman would you like to stamp this too?

[lebedev.ri]

clang/include/clang/Basic/AttrDocs.td

565

Hopefully this is sufficient?

[erichkeane]

clang/include/clang/Basic/AttrDocs.td

565

I think that clarifies it for me.

[aaron.ballman]

Precommit CI seems to have found relevant issues that need to be addressed.

clang/include/clang/Basic/Attr.td

4133

Should this be allowed in C (where structured exception handling is still a thing)?

4138

I would have guessed we'd want to help the user out in a case like: [[clang::nounwind]] void func() noexcept(false);, given that this stuff can creep in via macros?

clang/include/clang/Basic/AttrDocs.td

549

564

569

579

Looks like a whole pile of unrelated whitespace-only changes crept in; those can be backed out.

582

Presumably?

clang/lib/CodeGen/CGCall.cpp

2208–2209

clang/lib/Sema/SemaStmtAttr.cpp

246–248 ↗

(On Diff #487548)

Test coverage?

252–257 ↗

(On Diff #487548)

Oh great! But you're missing test coverage for this.

[lebedev.ri]

@aaron.ballman thank you for taking a look!
Addressed all review notes other than the SEH question and the simplehandler one.
(i'll deal with whitespace changes when committing, they should just be fixed upstream)

clang/include/clang/Basic/Attr.td

4133

The only two thing about structured exceptions i know
is that it's abbreviation and that it's a MSVC thing.
I don't know anything about how "exceptions" work there,
and therefore i do not want to touch it.

https://llvm.org/docs/LangRef.html notes:

nounwind
This function attribute indicates that the function never raises an exception. <...>.
However, functions marked nounwind may still trap or generate asynchronous exceptions.
Exception handling schemes that are recognized by LLVM to handle asynchronous exceptions,
such as SEH, will still provide their implementation defined semantics.

4138

Could you please clarify, what do you mean by "help the user" in this case?
Given

[[clang::nounwind]] void func() noexcept(false);

void qqq();

void foo() {
  try {
    func();
  } catch (...) {
    qqq();
  }
}

we already end up with

; Function Attrs: mustprogress noinline nounwind optnone uwtable
define dso_local void @_Z3foov() #0 {
entry:
  call void @_Z4funcv() #2
  ret void
}

; Function Attrs: nounwind
declare void @_Z4funcv() #1

attributes #0 = { mustprogress noinline nounwind optnone uwtable "frame-pointer"="all" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nounwind "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { nounwind }

and if i drop [[clang::nounwind]], landingpad is back.

[aaron.ballman]

clang/include/clang/Basic/Attr.td

4133

Okay, let's leave it as-is for now and we can relax the restriction later if we find a need.

4138

Could you please clarify, what do you mean by "help the user" in this case?

The user has said "this function throws exceptions" (noexcept(false)) and it's also said "this function never unwinds to its caller" (the attribute) and these statements are in conflict with one another and likely signify user confusion. I would have expected a warning diagnostic here.

[lebedev.ri]

clang/include/clang/Basic/Attr.td

4138

Ah. This is effectively intentional. This attribute, effectively,
specifies the behavior in case the exception does get thrown, as being UB.
If we diagnose that case, should we also disallow the stmt case?

void i_will_throw() noexcept(false);

void foo() {
  [[clang::nounwind]] i_will_throw(); // Should this be diagnosed?
}

Presumably not, because that immediately limits usefulness of the attribute.

What we *DO* want, is diagnostics (and more importantly, a sanitizer!)
in the case the exception *does* reach this UB boundary.

[aaron.ballman]

clang/include/clang/Basic/Attr.td

4138

Sorry if this is a dumb question, but is the goal of this attribute basically to insert UB where there is well-defined behavior per spec? Throwing an exception that escapes from a function marked noexcept(false) is guaranteed to call std::terminate(): http://eel.is/c++draft/except#spec-5

[lebedev.ri]

clang/include/clang/Basic/Attr.td

4138

Sorry if this is a dumb question, but is the goal of this attribute basically to insert UB where there is well-defined behavior per spec?

Precisely! I was under impression i did call that out in the RFC/description, but guess not explicitly enough?
This is consistent with the existing (accidental) behavior of const/pure attirbutes.

[aaron.ballman]

clang/include/clang/Basic/Attr.td

4138

@lebedev.ri and I (and a few others) discussed this attribute on IRC and we're thinking of trying a different approach. Instead of exposing this attribute (which is pretty expert-only and seems likely to cause unintentional UB as a result), it might be worth exploring adding a -f flag to treat non-throwing exception specifications as implying nounwind. This is a language dialect and we usually avoid those, but we already have a significantly greater dialect in this same space with the -fno-exceptions functionality. We think the perf gains for the flag are likely to be worth supporting the dialect.

Next steps here are to rip out the nounwind attribute bits so we can move on the const and pure changes, and to start an RFC about the potential new flag.

[efriedma]

From an IR semantics standpoint, I'm not sure the memory(none) marking is right if the function throws an exception. LangRef doesn't explicitly exclude the possibility, but take the following:

void f() { throw 1; }

It gets lowered to:

define dso_local void @_Z1fv() local_unnamed_addr #0 {
entry:
  %exception = tail call ptr @__cxa_allocate_exception(i64 4) #1
  store i32 1, ptr %exception, align 16, !tbaa !5
  tail call void @__cxa_throw(ptr nonnull %exception, ptr nonnull @_ZTIi, ptr null) #2
  unreachable
}

So we have a function that essentially makes a heap allocation, store a value to it, then throws it. And throwing the exception then makes other changes to the exception handling state which are visible to the caller. Given these details are exposed in LLVM IR, saying that this is memory(none) seems a bit dubious. (I don't have a testcase that breaks off the top of my head, but I suspect it's possible to write such a testcase.) Given that, if you're going to drop the nounwind attribute, I suspect it also makes sense to also drop the memory(none) attribute.

The AddPotentialArgAccess() helper exists to handle a similar sort of situation: a function is marked pure in C, but the return value is returned indirectly, so it's not actually pure from the perspective of LLVM IR. To fix that, we adjust the IR attributes to something more appropriate.

(Adding @nikic and @jdoerfert for additional perspective on the IR attributes.)

---

See also https://github.com/llvm/llvm-project/issues/36098 , which is also about a mismatch between the meaning of the C pure attribute and the LLVM IR memory(none).

[lebedev.ri]

In D138958#4045567, @efriedma wrote:

From an IR semantics standpoint, I'm not sure the memory(none) marking is right if the function throws an exception.

Then memory(read) would be wrong, either.
A bit of a hot take: it's a Schrodinger's exception in quantum state.
What i mean by that, is that e.g. pure attribute is documented as

and will not cause any observable side-effects other than
returning a value. They may read memory, but can not modify memory in a way
that would either affect observable state or their outcome on subsequent runs.

So if it does unwind, that's fine, but if you *observed* that (not by catching an exception),
then you're in UB lands, because *you*, not the function, violated it's contract.

That might be too hot of a take, but it does seem like the EH internal details aren't really *that* observable...

[efriedma]

I'm not trying to argue what the pure/const attribute in C/C++ is supposed to mean. I agree with your interpretation of the gcc documentation/implementation. I'm saying that there's a mismatch between the gcc pure/const and the LLVM IR memory(read)/memory(none), and therefore you can't unconditionally lower const to memory(none).

[jdoerfert]

In D138958#4045567, @efriedma wrote:

From an IR semantics standpoint, I'm not sure the memory(none) marking is right if the function throws an exception. LangRef doesn't explicitly exclude the possibility, but take the following:

void f() { throw 1; }

It gets lowered to:

define dso_local void @_Z1fv() local_unnamed_addr #0 {
entry:
  %exception = tail call ptr @__cxa_allocate_exception(i64 4) #1
  store i32 1, ptr %exception, align 16, !tbaa !5
  tail call void @__cxa_throw(ptr nonnull %exception, ptr nonnull @_ZTIi, ptr null) #2
  unreachable
}

If you mark this one as readonly/none we might, at some point, see the mismatch in the body and declare it UB.
From the outside, it should almost be fine since it's not-nounwind and the memory that is accessed is freshly allocated.
However, it still would be a problem waiting to happen to have escaping memory being written in a readonly/none function.

That said, I think we anyway want a memory category to express all accesses are to freshly allocated memory that may escape the function. This is a common pattern.
So memory(allocated, inaccessiblemem) would express that the allocation does access some inaccesible memory and the function will also access the newly allocated memory.
Its arguably not as good as readnone but I'm not sure how to get there.
The best idea I have off the top of my head is a dedicated exception category for memory such that it won't interfere with anything but other exceptions, which it already does due to unwind.
Thus, pure/const -> `memory(exception).

[lebedev.ri]

In D138958#4054903, @jdoerfert wrote:

In D138958#4045567, @efriedma wrote:

From an IR semantics standpoint, I'm not sure the memory(none) marking is right if the function throws an exception. LangRef doesn't explicitly exclude the possibility, but take the following:

void f() { throw 1; }

It gets lowered to:

define dso_local void @_Z1fv() local_unnamed_addr #0 {
entry:
  %exception = tail call ptr @__cxa_allocate_exception(i64 4) #1
  store i32 1, ptr %exception, align 16, !tbaa !5
  tail call void @__cxa_throw(ptr nonnull %exception, ptr nonnull @_ZTIi, ptr null) #2
  unreachable
}

If you mark this one as readonly/none we might, at some point, see the mismatch in the body and declare it UB.
From the outside, it should almost be fine since it's not-nounwind and the memory that is accessed is freshly allocated.
However, it still would be a problem waiting to happen to have escaping memory being written in a readonly/none function.

That said, I think we anyway want a memory category to express all accesses are to freshly allocated memory that may escape the function. This is a common pattern.
So memory(allocated, inaccessiblemem) would express that the allocation does access some inaccesible memory and the function will also access the newly allocated memory.
Its arguably not as good as readnone but I'm not sure how to get there.
The best idea I have off the top of my head is a dedicated exception category for memory such that it won't interfere with anything but other exceptions, which it already does due to unwind.
Thus, pure/const -> `memory(exception).

Thank you for commenting! Is there a feeling that just dropping the attributes,
until they can be reasonably represented, hinders optimizations too much,
and we must retain the ongoing miscompile?

[nlopes]

The issue is the function call, not the stores.
Stores are valid as long as they are to local memory (stack or allocated by the function).

Because of the call, you can't tag it as memory(none). But you may be able to tag it with inaccessiblemem if the call is also marked as such. Otherwise, no.

Performance wise it shouldn't matter much. How many functions are tagged with pure/const in source code? So here I would lean towards correctness.

[lebedev.ri]

@jdoerfert can you please clarify, do you believe we are fine as-is, or need to change attributes we emit?

[lebedev.ri]

Ok, if we must not unconditionally emit the memory attributes, then let's not.
Please stamp? :)

@Anastasia @svenvh @arsenm This breaks opencl headers in a way i do not understand how to undo.

[aaron.ballman]

In D138958#4060633, @lebedev.ri wrote:

Ok, if we must not unconditionally emit the memory attributes, then let's not.
Please stamp? :)

FWIW, I don't think we should land any of this until after the Clang 16 branch has happened; I think we need more time for this to bake before we release it to the wild.

[lebedev.ri]

Ok, so. I looked really hard, and essentially i'm not sure we can just change those attributes from implying readonly/readnone.
Things kinda just fall apart

clang/test/CodeGenOpenCL/fdeclare-opencl-builtins.cl

20

I've looked, and i really don't understand how D64319 works.
It seems like the AST is then serialized into a header?
Because just adding a new attribute without spelling does not solve the issue.

[svenvh]

clang/test/CodeGenOpenCL/fdeclare-opencl-builtins.cl

20

We're not setting the NoUnwind attribute for OpenCL (yet). The following quick-and-dirty patch appears to fix this test for your patch (but will cause other tests to fail). If you think it's time to add NoUnwind now, I can try putting up a review for that.

diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp
index 276d91fa2758..1ea3c11fbe03 100644
--- a/clang/lib/CodeGen/CGCall.cpp
+++ b/clang/lib/CodeGen/CGCall.cpp
@@ -1972,7 +1972,7 @@ void CodeGenModule::getDefaultFunctionAttributes(StringRef Name,
   // TODO: NoUnwind attribute should be added for other GPU modes OpenCL, HIP,
   // SYCL, OpenMP offload. AFAIK, none of them support exceptions in device
   // code.
-  if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice) {
+  if ((getLangOpts().CUDA && getLangOpts().CUDAIsDevice) || getLangOpts().OpenCL) {
     // Exceptions aren't supported in CUDA device code.
     FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
   }

[lebedev.ri]

clang/test/CodeGenOpenCL/fdeclare-opencl-builtins.cl

20

Yeah, that would be my guess as to how you'd fix this it, yes.
I'd suggest posting such a patch.

clang-tools-extra/clang-tidy/bugprone/ExceptionEscapeCheck.cpp

 
 void ExceptionEscapeCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "FunctionsThatShouldNotThrow",
                 RawFunctionsThatShouldNotThrow);
   Options.store(Opts, "IgnoredExceptions", RawIgnoredExceptions);
 }
 
 void ExceptionEscapeCheck::registerMatchers(MatchFinder *Finder) {
+  // FIXME: this does not consider NoThrowAttr.
   Finder->addMatcher(
       functionDecl(anyOf(isNoThrow(), cxxDestructorDecl(),
                          cxxConstructorDecl(isMoveConstructor()),
                          cxxMethodDecl(isMoveAssignmentOperator()),
                          hasName("main"), hasName("swap"),
                          isEnabled(FunctionsThatShouldNotThrow)))
           .bind("thrower"),
       this);

clang-tools-extra/clang-tidy/utils/ExceptionAnalyzer.cpp

 }
 
 ExceptionAnalyzer::ExceptionInfo ExceptionAnalyzer::throwsException(
     const FunctionDecl *Func,
     llvm::SmallSet<const FunctionDecl *, 32> &CallStack) {
   if (CallStack.count(Func))
     return ExceptionInfo::createNonThrowing();
 
+  // FIXME: this does not deal with NoThrow attribute.
+
   if (const Stmt *Body = Func->getBody()) {
     CallStack.insert(Func);
     ExceptionInfo Result =
         throwsException(Body, ExceptionInfo::Throwables(), CallStack);
 
     // For a constructor, we also have to check the initializers.
     if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(Func)) {
       for (const CXXCtorInitializer *Init : Ctor->inits()) {

clang-tools-extra/test/clang-tidy/checkers/bugprone/exception-escape.cpp

 
 struct throwing_move_assignment {
   throwing_move_assignment& operator=(throwing_move_assignment&&) {
     // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: an exception may be thrown in function 'operator=' which should not throw exceptions
     throw 1;
   }
 };
 
+void thrower(int n) {
+  throw n;
+}
+
 void throwing_noexcept() noexcept {
     // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throwing_noexcept' which should not throw exceptions
   throw 1;
 }
 
+void __attribute__((nothrow)) throwing_attribute_nothrow() {
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: an exception may be thrown in function 'throwing_attribute_nothrow' which should not throw exceptions
+  throw 1;
+}
+
+// FIXME: false-positives.
+void non_throwing_call_of_noexcept() noexcept {
+  // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'non_throwing_call_of_noexcept' which should not throw exceptions
+  throwing_noexcept();
+}
+void non_throwing_call_of_attribute_nothrow() noexcept {
+  // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'non_throwing_call_of_attribute_nothrow' which should not throw exceptions
+  throwing_attribute_nothrow();
+}
+
 void throwing_throw_nothing() throw() {
     // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throwing_throw_nothing' which should not throw exceptions
   throw 1;
 }
 
 void throw_and_catch() noexcept {
   // CHECK-MESSAGES-NOT: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'throw_and_catch' which should not throw exceptions
   try {

 }
 
 void this_counts(int n) noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: an exception may be thrown in function 'this_counts' which should not throw exceptions
   if (n) throw 1;
   throw ignored1();
 }
 
-void thrower(int n) {
-  throw n;
-}
-
 int directly_recursive(int n) noexcept {
   // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: an exception may be thrown in function 'directly_recursive' which should not throw exceptions
   if (n == 0)
     thrower(n);
   return directly_recursive(n);
 }
 
 int indirectly_recursive(int n) noexcept;

clang/docs/ReleaseNotes.rst

 - In C mode, when ``e1`` has ``__attribute__((noreturn))`` but ``e2`` doesn't,
   ``(c ? e1 : e2)`` is no longer considered noreturn.
   `Issue 59792 <https://github.com/llvm/llvm-project/issues/59792>`_
 - Fix an issue that makes Clang crash on lambda template parameters. This fixes
   `Issue 57960 <https://github.com/llvm/llvm-project/issues/57960>`_
 - Fix issue that the standard C++ modules importer will call global
   constructor/destructor for the global varaibles in the importing modules.
   This fixes `Issue 59765 <https://github.com/llvm/llvm-project/issues/59765>`_
+- ``__attribute__((const))``/``__attribute__((pure))`` are no longer defined as
+  exhibiting UB if an exception unwinds out a function marked with such
+  an attribute. This matches GCC behavior.
 
 Improvements to Clang's diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - Clang will now check compile-time determinable string literals as format strings.
   Fixes `Issue 55805: <https://github.com/llvm/llvm-project/issues/55805>`_.
 - ``-Wformat`` now recognizes ``%b`` for the ``printf``/``scanf`` family of
   functions and ``%B`` for the ``printf`` family of functions. Fixes
   `Issue 56885: <https://github.com/llvm/llvm-project/issues/56885>`_.
- Updated the value returned by ``__has_c_attribute(fallthrough)`` to ``201910L``
   used ``201904L`` (the date the proposal was seen by the committee) by mistake.
   There were no other changes to the attribute behavior.
 
 - Introduced a new record declaration attribute ``__attribute__((enforce_read_only_placement))``
   to support analysis of instances of a given type focused on read-only program
   memory placement. It emits a warning if something in the code provably prevents
   an instance from a read-only memory placement.
 
+- ``__attribute__((const))``/``__attribute__((pure))`` are no longer defined as
+  exhibiting UB if an exception unwinds out a function marked with such
+  an attribute. This matches GCC behavior.
+
 Windows Support
 ---------------
 - For the MinGW driver, added the options ``-mguard=none``, ``-mguard=cf`` and
   ``-mguard=cf-nochecks`` (equivalent to ``/guard:cf-``, ``/guard:cf`` and
   ``/guard:cf,nochecks`` in clang-cl) for enabling Control Flow Guard checks
   and generation of address-taken function table.
 
 - Switched from SHA1 to BLAKE3 for PDB type hashing / ``-gcodeview-ghash``

 - Introduced the new function ``clang_CXXMethod_isDeleted``, which queries
   whether the method is declared ``= delete``.
 - Introduced the new function ``clang_CXXMethod_isCopyAssignmentOperator``,
   which identifies whether a method cursor is a copy-assignment
   operator.
 - Introduced the new function ``clang_CXXMethod_isMoveAssignmentOperator``,
   which identifies whether a method cursor is a move-assignment
   operator.
 - ``clang_Cursor_getNumTemplateArguments``, ``clang_Cursor_getTemplateArgumentKind``,
   ``clang_Cursor_getTemplateArgumentType``, ``clang_Cursor_getTemplateArgumentValue`` and
   ``clang_Cursor_getTemplateArgumentUnsignedValue`` now work on struct, class,
   and partial template specialization cursors in addition to function cursors.
 
 Static Analyzer
 ---------------
 - Removed the deprecated ``-analyzer-store`` and
   ``-analyzer-opt-analyze-nested-blocks`` analyzer flags.
   ``scanbuild`` was also updated accordingly.

clang/include/clang/Basic/Attr.td

 def Common : InheritableAttr {
   let Spellings = [GCC<"common">];
   let Subjects = SubjectList<[Var]>;
   let Documentation = [Undocumented];
 }
 
 def Const : InheritableAttr {
   let Spellings = [GCC<"const">, GCC<"__const">];
-  let Documentation = [Undocumented];
+  let Documentation = [ConstDocs];
   let SimpleHandler = 1;
 }
 
 def ConstInit : InheritableAttr {
   // This attribute does not have a C [[]] spelling because it requires the
   // CPlusPlus language option.
   let Spellings = [Keyword<"constinit">,
                    Clang<"require_constant_initialization", 0>];

 
 def AArch64SVEPcs: DeclOrTypeAttr {
   let Spellings = [Clang<"aarch64_sve_pcs">];
   let Documentation = [AArch64SVEPcsDocs];
 }
 
 def Pure : InheritableAttr {
   let Spellings = [GCC<"pure">];
-  let Documentation = [Undocumented];
+  let Documentation = [PureDocs];
   let SimpleHandler = 1;
 }
 
 def Regparm : TypeAttr {
   let Spellings = [GCC<"regparm">];
   let Args = [UnsignedArgument<"NumParams">];
   let Documentation = [RegparmDocs];
   // Represented as part of the enclosing function type.
def FunctionReturnThunks : InheritableAttr,
   let Spellings = [GCC<"function_return">];
   let Args = [EnumArgument<"ThunkType", "Kind",
     ["keep", "thunk-extern"],
     ["Keep", "Extern"]
   >];
   let Subjects = SubjectList<[Function]>;
   let Documentation = [FunctionReturnThunksDocs];
 }
+
 def ReadOnlyPlacement : InheritableAttr {
   let Spellings = [Clang<"enforce_read_only_placement">];
   let Subjects = SubjectList<[Record]>;
   let Documentation = [ReadOnlyPlacementDocs];
 }

clang/include/clang/Basic/AttrDocs.td

 compiler will generate a diagnostic for a function declared as ``[[noreturn]]``
 that appears to be capable of returning to its caller.
 
 The ``[[_Noreturn]]`` spelling is deprecated and only exists to ease code
 migration for code using ``[[noreturn]]`` after including ``<stdnoreturn.h>``.
   }];
 }
 
+def PureDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+A function declared with the ``pure`` attribute guarantees it does not have
+infinite loops (i.e. they must either terminate or return to the caller,
+be it either via a normal return, or by throwing an exception and unwinding
+or exibiting UB), and will not cause any observable side-effects other than
+returning a value. They may read memory, but can not modify memory in a way
+that would either affect observable state or their outcome on subsequent runs.
+
+Note: this attribute does not define any behaviour regarding exceptions,
+so functions annotated with this attribute are allowed to throw exceptions,
+and doing so is neither UB nor will cause immediate program termination,
+but rather the exception will successfully unwind into function's caller.
+  }];
+}
+
+def ConstDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+A stronger version of ``pure`` attribute.
+
+A function declared with ``const`` attribute guarantees  it does not not have
+infinite loops (i.e. they must either terminate or return to the caller,
+be it either via a normal return, or by throwing an exception and unwinding
+or exibiting UB), and will not cause any observable side-effects other than
+returning a value. They cannot write to memory, unlike functions declared
+with ``pure`` attribute, but may still read memory that is immutable between
+invocations of the function.
+
+Note: this attribute does not define any behaviour regarding exceptions,
+so functions annotated with this attribute are allowed to throw exceptions,
+and doing so is neither UB nor will cause immediate program termination,
+but rather the exception will successfully unwind into function's caller.
+  }];
+}
+
 def NoMergeDocs : Documentation {
   let Category = DocCatStmt;
   let Content = [{
 If a statement is marked ``nomerge`` and contains call expressions, those call
-expressions inside the statement will not be merged during optimization. This 
+expressions inside the statement will not be merged during optimization. This
 attribute can be used to prevent the optimizer from obscuring the source
 location of certain calls. For example, it will prevent tail merging otherwise
 identical code sequences that raise an exception or terminate the program. Tail
 merging normally reduces the precision of source location information, making
 stack traces less useful for debugging. This attribute gives the user control
-over the tradeoff between code size and debug information precision. 
+over the tradeoff between code size and debug information precision.
 
-``nomerge`` attribute can also be used as function attribute to prevent all 
-calls to the specified function from merging. It has no effect on indirect 
+``nomerge`` attribute can also be used as function attribute to prevent all
+calls to the specified function from merging. It has no effect on indirect
 calls.
   }];
 }
 
 def NoInlineDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 This function attribute suppresses the inlining of a function at the call sites

 
 ``tvos``
   Apple's tvOS operating system. The minimum deployment target is specified by
   the ``-mtvos-version-min=*version*`` command-line argument.
 
 ``watchos``
   Apple's watchOS operating system. The minimum deployment target is specified by
   the ``-mwatchos-version-min=*version*`` command-line argument.
-  
 ``driverkit``
   Apple's DriverKit userspace kernel extensions. The minimum deployment target
   is specified as part of the triple.
 
 A declaration can typically be used even when deploying back to a platform
 version prior to when the declaration was introduced. When this happens, the
 declaration is `weakly linked
 <https://developer.apple.com/library/mac/#documentation/MacOSX/Conceptual/BPFrameworks/Concepts/WeakLinking.html>`_,

 
 
 def NullabilityDocs : DocumentationCategory<"Nullability Attributes"> {
   let Content = [{
 Whether a particular pointer may be "null" is an important concern when working
 with pointers in the C family of languages. The various nullability attributes
 indicate whether a particular pointer can be null or not, which makes APIs more
 expressive and can help static analysis tools identify bugs involving null
-pointers. Clang supports several kinds of nullability attributes: the 
+pointers. Clang supports several kinds of nullability attributes: the
 ``nonnull`` and ``returns_nonnull`` attributes indicate which function or
 method parameters and result types can never be null, while nullability type
 qualifiers indicate which pointer types can be null (``_Nullable``) or cannot
 be null (``_Nonnull``).
 
 The nullability (type) qualifiers express whether a value of a given pointer
 type can be null (the ``_Nullable`` qualifier), doesn't have a defined meaning
 for null (the ``_Nonnull`` qualifier), or for which the purpose of null is
memory is not available rather than returning a null pointer:
 
   .. code-block:: c
 
     extern void * malloc (size_t size) __attribute__((returns_nonnull));
 
 The ``returns_nonnull`` attribute implies that returning a null pointer is
 undefined behavior, which the optimizer may take advantage of. The ``_Nonnull``
 type qualifier indicates that a pointer cannot be null in a more general manner
-(because it is part of the type system) and does not imply undefined behavior, 
+(because it is part of the type system) and does not imply undefined behavior,
 making it more widely applicable
 }];
 }
 
 def NoAliasDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 The ``noalias`` attribute indicates that the only memory accesses inside
def NoThrowDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 Clang supports the GNU style ``__attribute__((nothrow))`` and Microsoft style
 ``__declspec(nothrow)`` attribute as an equivalent of ``noexcept`` on function
 declarations. This attribute informs the compiler that the annotated function
 does not throw an exception. This prevents exception-unwinding. This attribute
 is particularly useful on functions in the C Standard Library that are
 guaranteed to not throw an exception.
+
+If an exception does unwind out of a function marked with this attribute,
+the behaviour matches that of ``noexcept`` -- program is immediately terminated.
     }];
 }
 
 def NoUwtableDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 Clang supports the ``nouwtable`` attribute which skips emitting
 the unwind table entry for the specified function. This attribute is useful for

 }];
 }
 
 def CFGuardDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 Code can indicate CFG checks are not wanted with the ``__declspec(guard(nocf))``
 attribute. This directs the compiler to not insert any CFG checks for the entire
-function. This approach is typically used only sparingly in specific situations 
-where the programmer has manually inserted "CFG-equivalent" protection. The 
-programmer knows that they are calling through some read-only function table 
-whose address is obtained through read-only memory references and for which the 
-index is masked to the function table limit. This approach may also be applied 
-to small wrapper functions that are not inlined and that do nothing more than 
-make a call through a function pointer. Since incorrect usage of this directive 
-can compromise the security of CFG, the programmer must be very careful using 
-the directive. Typically, this usage is limited to very small functions that 
+function. This approach is typically used only sparingly in specific situations
+where the programmer has manually inserted "CFG-equivalent" protection. The
+programmer knows that they are calling through some read-only function table
+whose address is obtained through read-only memory references and for which the
+index is masked to the function table limit. This approach may also be applied
+to small wrapper functions that are not inlined and that do nothing more than
+make a call through a function pointer. Since incorrect usage of this directive
+can compromise the security of CFG, the programmer must be very careful using
+the directive. Typically, this usage is limited to very small functions that
 only call one function.
 
 `Control Flow Guard documentation <https://docs.microsoft.com/en-us/windows/win32/secbp/pe-metadata>`
 }];
 }
 
 def CUDADeviceBuiltinSurfaceTypeDocs : Documentation {
   let Category = DocCatType;

clang/lib/CodeGen/CGCall.cpp

if (const FunctionDecl *Fn = dyn_cast<FunctionDecl>(TargetDecl)) {
           FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
         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.
     if (TargetDecl->hasAttr<ConstAttr>()) {
-      FuncAttrs.addMemoryAttr(llvm::MemoryEffects::none());
-      FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
+      // We can not blindly state that the function does not acccess memory,
+      // since we do not know that it is `nounwind`. We do that later, though.
+      // FIXME: we may need a better way to model this kind of memory effects.
       // gcc specifies that 'const' functions have greater restrictions than
-      // 'pure' functions, so they also cannot have infinite loops.
+      // 'pure' functions, so they, either, cannot have infinite loops.
       FuncAttrs.addAttribute(llvm::Attribute::WillReturn);
     } else if (TargetDecl->hasAttr<PureAttr>()) {
-      FuncAttrs.addMemoryAttr(llvm::MemoryEffects::readOnly());
-      FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
+      // We can not blindly state that the function does not acccess memory,
+      // since we do not know that it is `nounwind`. We do that later, though.
+      // FIXME: we may need a better way to model this kind of memory effects.
       // 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);
void CodeGenModule::ConstructAttributeList(StringRef Name,
   addNoBuiltinAttributes(FuncAttrs, getLangOpts(), NBA);
 
   // Collect function IR attributes based on global settiings.
   getDefaultFunctionAttributes(Name, HasOptnone, AttrOnCallSite, FuncAttrs);
 
   // Override some default IR attributes based on declaration-specific
   // information.
   if (TargetDecl) {
+    if (FuncAttrs.contains(llvm::Attribute::NoUnwind)) {
+      if (TargetDecl->hasAttr<ConstAttr>())
+        FuncAttrs.addMemoryAttr(llvm::MemoryEffects::none());
+      else if (TargetDecl->hasAttr<PureAttr>())
+        FuncAttrs.addMemoryAttr(llvm::MemoryEffects::readOnly());
+    }
     if (TargetDecl->hasAttr<NoSpeculativeLoadHardeningAttr>())
       FuncAttrs.removeAttribute(llvm::Attribute::SpeculativeLoadHardening);
     if (TargetDecl->hasAttr<SpeculativeLoadHardeningAttr>())
       FuncAttrs.addAttribute(llvm::Attribute::SpeculativeLoadHardening);
     if (TargetDecl->hasAttr<NoSplitStackAttr>())
       FuncAttrs.removeAttribute("split-stack");
     if (TargetDecl->hasAttr<ZeroCallUsedRegsAttr>()) {
       // A function "__attribute__((...))" overrides the command-line flag.
#endif
   if (TargetDecl && TargetDecl->hasAttr<ErrorAttr>()) {
     llvm::ConstantInt *Line =
         llvm::ConstantInt::get(Int32Ty, Loc.getRawEncoding());
     llvm::ConstantAsMetadata *MD = llvm::ConstantAsMetadata::get(Line);
     llvm::MDTuple *MDT = llvm::MDNode::get(getLLVMContext(), {MD});
     CI->setMetadata("srcloc", MDT);
   }
 
+  // Late manifestation for `pure`/`const` attributes, now that we know whether
+  // or not a call to a function with these attributes is nounwind or not.
+  if (TargetDecl && CI->doesNotThrow()) {
+    if (TargetDecl->hasAttr<ConstAttr>())
+      CI->setDoesNotAccessMemory();
+    else if (TargetDecl->hasAttr<PureAttr>())
+      CI->setOnlyReadsMemory();
+  }
+
   // 4. Finish the call.
 
   // If the call doesn't return, finish the basic block and clear the
   // insertion point; this allows the rest of IRGen to discard
   // unreachable code.
   if (CI->doesNotReturn()) {
     if (UnusedReturnSizePtr)
       PopCleanupBlock();

clang/lib/Sema/SemaDecl.cpp

if ((Trip.isGNUEnvironment() || Trip.isOSMSVCRT()) &&
         !FD->hasAttr<ConstAttr>()) {
       switch (BuiltinID) {
       case Builtin::BI__builtin_fma:
       case Builtin::BI__builtin_fmaf:
       case Builtin::BI__builtin_fmal:
       case Builtin::BIfma:
       case Builtin::BIfmaf:
       case Builtin::BIfmal:
-        FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
-        break;
       default:
         break;
       }
     }
 
     if (Context.BuiltinInfo.isReturnsTwice(BuiltinID) &&
         !FD->hasAttr<ReturnsTwiceAttr>())
       FD->addAttr(ReturnsTwiceAttr::CreateImplicit(Context,

clang/test/CodeGen/function-attributes.c

 void f9(void) { f9_t(); }
 
 // CHECK: call void @f9a()
 // CHECK: [[NR]]
 // CHECK: }
 _Noreturn void f9a(void);
 void f9b(void) { f9a(); }
 
-// FIXME: We should be setting nounwind on calls.
 // CHECK: call i32 @f10_t()
-// CHECK: [[NUW_RN:#[0-9]+]]
+// CHECK: [[OS_WR2:#[0-9]+]]
 // CHECK: {
 int __attribute__((const)) f10_t(void);
 int f10(void) { return f10_t(); }
 int f11(void) {
  exit:
   return f10_t();
 }
 int f12(int arg) {
   return arg ? 0 : f10_t();
 }
 
-// CHECK: define{{.*}} void @f13() [[NUW_OS_RN:#[0-9]+]]
-void f13(void) __attribute__((pure)) __attribute__((const));
-void f13(void){}
+// CHECK: declare{{.*}} void @f13_t() [[OS_WR:#[0-9]+]]
+void f13_t(void) __attribute__((pure)) __attribute__((const));
+void f13(void) { return f13_t(); }
 
 
 // <rdar://problem/7102668> [irgen] clang isn't setting the optsize bit on functions
 // CHECK-LABEL: define{{.*}} void @f15
 // CHECK: [[NUW]]
 // CHECK: {
 void f15(void) {
 }

 // CHECK: ret void
 int _setjmp(jmp_buf);
 void f20(void) {
   _setjmp(0);
 }
 
 // CHECK: attributes [[NUW]] = { nounwind optsize{{.*}} }
 // CHECK: attributes [[AI]] = { alwaysinline nounwind optsize{{.*}} }
-// CHECK: attributes [[NUW_OS_RN]] = { nounwind optsize willreturn memory(none){{.*}} }
+// CHECK: attributes [[OS_WR]] = { optsize willreturn {{.*}} }
 // CHECK: attributes [[SR]] = { nounwind optsize{{.*}} "stackrealign"{{.*}} }
 // CHECK: attributes [[RT]] = { nounwind optsize returns_twice{{.*}} }
 // CHECK: attributes [[NR]] = { noreturn optsize }
-// CHECK: attributes [[NUW_RN]] = { nounwind optsize willreturn memory(none) }
+// CHECK: attributes [[OS_WR2]] = { optsize willreturn }
 // CHECK: attributes [[RT_CALL]] = { optsize returns_twice }

clang/test/CodeGen/pragma-weak.c

 
 void __a1(void) __attribute((noinline));
 #pragma weak a1 = __a1
 void __a1(void) {}
 // CHECK: define{{.*}} void @__a1() [[NI:#[0-9]+]]
 
 #pragma weak xxx = __xxx
 __attribute((pure,noinline,const)) void __xxx(void) { }
-// CHECK: void @__xxx() [[RN:#[0-9]+]]
+// CHECK: void @__xxx() [[WR:#[0-9]+]]
 
 ///////////// PR28611: Try multiple aliases of same undeclared symbol or alias
 #pragma weak undecfunc_alias1 = undecfunc
 #pragma weak undecfunc_alias1 = undecfunc // Try specifying same alias/target pair a second time.
 #pragma weak undecfunc_alias3 = undecfunc_alias2 // expected-warning {{alias will always resolve to undecfunc}}
 #pragma weak undecfunc_alias4 = undecfunc_alias2 // expected-warning {{alias will always resolve to undecfunc}}
 #pragma weak undecfunc_alias2 = undecfunc
 void undecfunc_alias2(void);

 void zzz(void){}
 #pragma weak yyy
 // NOTE: weak doesn't apply, not before or in same TopLevelDec(!)
 // CHECK-LABEL: define{{.*}} void @yyy()
 
 int correct_linkage;
 
 // CHECK: attributes [[NI]] = { noinline nounwind{{.*}} }
-// CHECK: attributes [[RN]] = { noinline nounwind optnone willreturn memory(none){{.*}} }
+// CHECK: attributes [[WR]] = { noinline nounwind optnone willreturn {{.*}} }

clang/test/CodeGen/struct-passing.c

 T0 __attribute__((pure)) f1(void);
 T1 __attribute__((const)) f2(void);
 T1 __attribute__((pure)) f3(void);
 void __attribute__((const)) f4(T1 a);
 void __attribute__((pure)) f5(T1 a);
 
 void *ps[] = { f0, f1, f2, f3, f4, f5 };
 
-// CHECK: declare i32 @f0() [[RN:#[0-9]+]]
-// CHECK: declare i32 @f1() [[RO:#[0-9]+]]
+// CHECK: declare i32 @f0() [[WR:#[0-9]+]]
+// CHECK: declare i32 @f1() [[WR]]
 // CHECK: declare void @f2({{.*}} sret({{.*}}) align 4)
 // CHECK: declare void @f3({{.*}} sret({{.*}}) align 4)
 // CHECK: declare void @f4({{.*}} byval({{.*}}) align 4)
 // CHECK: declare void @f5({{.*}} byval({{.*}}) align 4)
 
-// CHECK: attributes [[RN]] = { nounwind willreturn memory(none){{.*}} }
-// CHECK: attributes [[RO]] = { nounwind willreturn memory(read){{.*}} }
+// CHECK: attributes [[WR]] = { willreturn {{.*}} }

clang/test/CodeGenCXX/2009-05-04-PureConstNounwind.cpp

 // RUN: %clang_cc1 -triple i386-unknown-unknown -fexceptions -emit-llvm %s -o - | FileCheck %s
 int c(void) __attribute__((const));
 int p(void) __attribute__((pure));
+int NoT(void) __attribute__((nothrow));
 int t(void);
 
 // CHECK: define{{.*}} i32 @_Z1fv() [[TF:#[0-9]+]] {
 int f(void) {
-  // CHECK: call noundef i32 @_Z1cv() [[NUW_RN_CALL:#[0-9]+]]
-  // CHECK: call noundef i32 @_Z1pv() [[NUW_RO_CALL:#[0-9]+]]
-  return c() + p() + t();
+  // CHECK: call noundef i32 @_Z1cv() [[WR_CALL:#[0-9]+]]
+  // CHECK: call noundef i32 @_Z1pv() [[WR_CALL]]
+  // CHECK: call noundef i32 @_Z3NoTv() [[NUW_CALL:#[0-9]+]]
+  return c() + p() + NoT() +  t();
 }
 
-// CHECK: declare noundef i32 @_Z1cv() [[NUW_RN:#[0-9]+]]
-// CHECK: declare noundef i32 @_Z1pv() [[NUW_RO:#[0-9]+]]
+// CHECK: declare noundef i32 @_Z1cv() [[WR:#[0-9]+]]
+// CHECK: declare noundef i32 @_Z1pv() [[WR]]
+// CHECK: declare noundef i32 @_Z3NoTv() [[NUW:#[0-9]+]]
 // CHECK: declare noundef i32 @_Z1tv() [[TF2:#[0-9]+]]
 
 // CHECK: attributes [[TF]] = { {{.*}} }
-// CHECK: attributes [[NUW_RN]] = { nounwind willreturn memory(none){{.*}} }
-// CHECK: attributes [[NUW_RO]] = { nounwind willreturn memory(read){{.*}} }
+// CHECK: attributes [[WR]] = { willreturn {{.*}} }
+// CHECK: attributes [[NUW]] = { nounwind {{.*}} }
 // CHECK: attributes [[TF2]] = { {{.*}} }
-// CHECK: attributes [[NUW_RN_CALL]] = { nounwind willreturn memory(none) }
-// CHECK: attributes [[NUW_RO_CALL]] = { nounwind willreturn memory(read) }
+// CHECK: attributes [[WR_CALL]] = { willreturn }
+// CHECK: attributes [[NUW_CALL]] = { nounwind }

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: Function Attrs: mustprogress noinline optnone willreturn{{$}}
 // 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:    [[CALL:%.*]] = call noundef i32 @_Z22callee_with_clang_attri(i32 noundef [[TMP0]]) #[[ATTR4:[0-9]+]]
 // CHECK-NEXT:    ret i32 [[CALL]]
 //
 
-// CHECK: Function Attrs: mustprogress noinline nounwind optnone willreturn memory(read)
+// CHECK: Function Attrs: mustprogress noinline optnone willreturn{{$}}
 // CHECK-LABEL: define {{[^@]+}}@_Z22callee_with_clang_attri
 // CHECK-SAME: (i32 noundef [[A:%.*]]) #[[ATTR0]] {
 // 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:    [[EXCEPTION:%.*]] = call ptr @__cxa_allocate_exception(i64 4) #[[ATTR5:[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:    call void @__cxa_throw(ptr [[EXCEPTION]], ptr @_ZTIi, ptr null) #[[ATTR6:[0-9]+]]
 // CHECK-NEXT:    unreachable
 // CHECK:       if.end:
 // CHECK-NEXT:    ret i32 24
 //
 
 // 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-SAME: (i32 noundef [[A:%.*]]) #[[ATTR1:[0-9]+]] 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:    [[CALL:%.*]] = call noundef i32 @_Z22callee_with_clang_attri(i32 noundef [[TMP0]]) #[[ATTR3]]
+// CHECK-NEXT:    [[CALL:%.*]] = invoke noundef i32 @_Z22callee_with_clang_attri(i32 noundef [[TMP0]]) #[[ATTR4]]
+// CHECK-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[TERMINATE_LPAD:%.*]]
+// CHECK:       invoke.cont:
 // CHECK-NEXT:    ret i32 [[CALL]]
+// 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]]) #[[ATTR7:[0-9]+]]
+// CHECK-NEXT:    unreachable
 //
 
-// CHECK: Function Attrs: mustprogress noinline nounwind optnone willreturn memory(read)
+// CHECK: Function Attrs: mustprogress noinline nounwind optnone willreturn{{$}}
 // CHECK-LABEL: define {{[^@]+}}@_Z52early_caller_of_callee_with_cxx_attr_with_clang_attri
-// CHECK-SAME: (i32 noundef [[A:%.*]]) #[[ATTR0]] {
+// CHECK-SAME: (i32 noundef [[A:%.*]]) #[[ATTR3:[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 @_Z20callee_with_cxx_attri(i32 noundef [[TMP0]]) #[[ATTR4]]
+// CHECK-NEXT:    [[CALL:%.*]] = call noundef i32 @_Z20callee_with_cxx_attri(i32 noundef [[TMP0]]) #[[ATTR5]]
 // CHECK-NEXT:    ret i32 [[CALL]]
 //
 
 // CHECK: Function Attrs: mustprogress noinline nounwind optnone
 // CHECK-LABEL: define {{[^@]+}}@_Z20callee_with_cxx_attri
 // CHECK-SAME: (i32 noundef [[A:%.*]]) #[[ATTR1]] 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]]
+// CHECK-NEXT:    [[EXCEPTION:%.*]] = call ptr @__cxa_allocate_exception(i64 4) #[[ATTR5]]
 // CHECK-NEXT:    store i32 42, ptr [[EXCEPTION]], align 16
-// CHECK-NEXT:    invoke void @__cxa_throw(ptr [[EXCEPTION]], ptr @_ZTIi, ptr null) #[[ATTR5]]
+// CHECK-NEXT:    invoke void @__cxa_throw(ptr [[EXCEPTION]], ptr @_ZTIi, ptr null) #[[ATTR6]]
 // 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]]) #[[ATTR7]]
 // 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:    [[CALL:%.*]] = call noundef i32 @_Z20callee_with_cxx_attri(i32 noundef [[TMP0]]) #[[ATTR5]]
 // CHECK-NEXT:    ret i32 [[CALL]]
 //
 
 
 // Forward declarations:
 
 __attribute__((pure)) int callee_with_clang_attr(int a);
 int callee_with_cxx_attr(int a) noexcept;

 int callee_with_cxx_attr(int a) noexcept {
   if(a)
     throw int(42);
   return 24;
 }
 
 // Calls to definitions:
 
-// CHECK: Function Attrs: mustprogress noinline nounwind optnone willreturn memory(read)
+// CHECK: Function Attrs: mustprogress noinline optnone willreturn{{$}}
 // CHECK-LABEL: define {{[^@]+}}@_Z53late_caller_of_callee_with_clang_attr_with_clang_attri
 // CHECK-SAME: (i32 noundef [[A:%.*]]) #[[ATTR0]] {
 // 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]]
+// CHECK-NEXT:    [[CALL:%.*]] = call noundef i32 @_Z22callee_with_clang_attri(i32 noundef [[TMP0]]) #[[ATTR4]]
 // CHECK-NEXT:    ret i32 [[CALL]]
 //
 __attribute__((pure)) int late_caller_of_callee_with_clang_attr_with_clang_attr(int a) {
   return callee_with_clang_attr(a);
 }
 
 // CHECK: Function Attrs: mustprogress noinline nounwind optnone
 // CHECK-LABEL: define {{[^@]+}}@_Z51late_caller_of_callee_with_clang_attr_with_cxx_attri
-// CHECK-SAME: (i32 noundef [[A:%.*]]) #[[ATTR1]] {
+// CHECK-SAME: (i32 noundef [[A:%.*]]) #[[ATTR1]] 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:    [[CALL:%.*]] = call noundef i32 @_Z22callee_with_clang_attri(i32 noundef [[TMP0]]) #[[ATTR3]]
+// CHECK-NEXT:    [[CALL:%.*]] = invoke noundef i32 @_Z22callee_with_clang_attri(i32 noundef [[TMP0]]) #[[ATTR4]]
+// CHECK-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[TERMINATE_LPAD:%.*]]
+// CHECK:       invoke.cont:
 // CHECK-NEXT:    ret i32 [[CALL]]
+// 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]]) #[[ATTR7]]
+// CHECK-NEXT:    unreachable
 //
 int late_caller_of_callee_with_clang_attr_with_cxx_attr(int a) noexcept {
   return callee_with_clang_attr(a);
 }
 
-// CHECK: Function Attrs: mustprogress noinline nounwind optnone willreturn memory(read)
+// CHECK: Function Attrs: mustprogress noinline nounwind optnone willreturn{{$}}
 // CHECK-LABEL: define {{[^@]+}}@_Z51late_caller_of_callee_with_cxx_attr_with_clang_attri
-// CHECK-SAME: (i32 noundef [[A:%.*]]) #[[ATTR0]] {
+// CHECK-SAME: (i32 noundef [[A:%.*]]) #[[ATTR3]] {
 // 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:    [[CALL:%.*]] = call noundef i32 @_Z20callee_with_cxx_attri(i32 noundef [[TMP0]]) #[[ATTR5]]
 // CHECK-NEXT:    ret i32 [[CALL]]
 //
 __attribute__((pure)) int late_caller_of_callee_with_cxx_attr_with_clang_attr(int a) {
   return callee_with_cxx_attr(a);
 }
 
 // CHECK: Function Attrs: mustprogress noinline nounwind optnone
 // CHECK-LABEL: define {{[^@]+}}@_Z49late_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:    [[CALL:%.*]] = call noundef i32 @_Z20callee_with_cxx_attri(i32 noundef [[TMP0]]) #[[ATTR5]]
 // CHECK-NEXT:    ret i32 [[CALL]]
 //
 int late_caller_of_callee_with_cxx_attr_with_cxx_attr(int a) noexcept {
   return callee_with_cxx_attr(a);
 }

clang/test/CodeGenCXX/pure-const-attrs-and-ir-memory-attributes.cpp

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
+// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu                               | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-NO-EXCEPTIONS
+// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu -fcxx-exceptions              | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-NO-EXCEPTIONS
+// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu -fcxx-exceptions -fexceptions | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-EXCEPTIONS
+// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu -fcxx-exceptions -fexceptions | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-EXCEPTIONS
+
+void opaque_callee();
+
+// CHECK-NO-EXCEPTIONS: Function Attrs: mustprogress noinline nounwind optnone willreturn
+// CHECK-NO-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z13pure_functionv
+// CHECK-NO-EXCEPTIONS-SAME: () #[[ATTR0:[0-9]+]] {
+// CHECK-NO-EXCEPTIONS-NEXT:  entry:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z13opaque_calleev()
+// CHECK-NO-EXCEPTIONS-NEXT:    ret void
+//
+// CHECK-EXCEPTIONS: Function Attrs: mustprogress noinline optnone willreturn
+// CHECK-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z13pure_functionv
+// CHECK-EXCEPTIONS-SAME: () #[[ATTR0:[0-9]+]] {
+// CHECK-EXCEPTIONS-NEXT:  entry:
+// CHECK-EXCEPTIONS-NEXT:    call void @_Z13opaque_calleev()
+// CHECK-EXCEPTIONS-NEXT:    ret void
+//
+__attribute__((pure)) void pure_function() {
+  opaque_callee();
+}
+
+// CHECK-NO-EXCEPTIONS: Function Attrs: mustprogress noinline nounwind optnone willreturn
+// CHECK-NO-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z14const_functionv
+// CHECK-NO-EXCEPTIONS-SAME: () #[[ATTR0]] {
+// CHECK-NO-EXCEPTIONS-NEXT:  entry:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z13opaque_calleev()
+// CHECK-NO-EXCEPTIONS-NEXT:    ret void
+//
+// CHECK-EXCEPTIONS: Function Attrs: mustprogress noinline optnone willreturn
+// CHECK-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z14const_functionv
+// CHECK-EXCEPTIONS-SAME: () #[[ATTR0]] {
+// CHECK-EXCEPTIONS-NEXT:  entry:
+// CHECK-EXCEPTIONS-NEXT:    call void @_Z13opaque_calleev()
+// CHECK-EXCEPTIONS-NEXT:    ret void
+//
+__attribute__((const)) void const_function() {
+  opaque_callee();
+}
+
+// CHECK-NO-EXCEPTIONS: Function Attrs: mustprogress noinline nounwind optnone
+// CHECK-NO-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z30normal_caller_of_pure_functionv
+// CHECK-NO-EXCEPTIONS-SAME: () #[[ATTR2:[0-9]+]] {
+// CHECK-NO-EXCEPTIONS-NEXT:  entry:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z13pure_functionv() #[[ATTR5:[0-9]+]]
+// CHECK-NO-EXCEPTIONS-NEXT:    ret void
+//
+// CHECK-EXCEPTIONS: Function Attrs: mustprogress noinline optnone
+// CHECK-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z30normal_caller_of_pure_functionv
+// CHECK-EXCEPTIONS-SAME: () #[[ATTR2:[0-9]+]] {
+// CHECK-EXCEPTIONS-NEXT:  entry:
+// CHECK-EXCEPTIONS-NEXT:    call void @_Z13pure_functionv() #[[ATTR7:[0-9]+]]
+// CHECK-EXCEPTIONS-NEXT:    ret void
+//
+void normal_caller_of_pure_function() {
+  pure_function();
+}
+
+// CHECK-NO-EXCEPTIONS: Function Attrs: mustprogress noinline nounwind optnone
+// CHECK-NO-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z31normal_caller_of_const_functionv
+// CHECK-NO-EXCEPTIONS-SAME: () #[[ATTR2]] {
+// CHECK-NO-EXCEPTIONS-NEXT:  entry:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z14const_functionv() #[[ATTR6:[0-9]+]]
+// CHECK-NO-EXCEPTIONS-NEXT:    ret void
+//
+// CHECK-EXCEPTIONS: Function Attrs: mustprogress noinline optnone
+// CHECK-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z31normal_caller_of_const_functionv
+// CHECK-EXCEPTIONS-SAME: () #[[ATTR2]] {
+// CHECK-EXCEPTIONS-NEXT:  entry:
+// CHECK-EXCEPTIONS-NEXT:    call void @_Z14const_functionv() #[[ATTR7]]
+// CHECK-EXCEPTIONS-NEXT:    ret void
+//
+void normal_caller_of_const_function() {
+  const_function();
+}
+
+// CHECK-NO-EXCEPTIONS: Function Attrs: mustprogress noinline nounwind optnone willreturn memory(read)
+// CHECK-NO-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z22pure_noexcept_functionv
+// CHECK-NO-EXCEPTIONS-SAME: () #[[ATTR3:[0-9]+]] {
+// CHECK-NO-EXCEPTIONS-NEXT:  entry:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z13opaque_calleev()
+// CHECK-NO-EXCEPTIONS-NEXT:    ret void
+//
+// CHECK-EXCEPTIONS: Function Attrs: mustprogress noinline nounwind optnone willreturn memory(read)
+// CHECK-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z22pure_noexcept_functionv
+// CHECK-EXCEPTIONS-SAME: () #[[ATTR3:[0-9]+]] personality ptr @__gxx_personality_v0 {
+// CHECK-EXCEPTIONS-NEXT:  entry:
+// CHECK-EXCEPTIONS-NEXT:    invoke void @_Z13opaque_calleev()
+// CHECK-EXCEPTIONS-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[TERMINATE_LPAD:%.*]]
+// CHECK-EXCEPTIONS:       invoke.cont:
+// CHECK-EXCEPTIONS-NEXT:    ret void
+// CHECK-EXCEPTIONS:       terminate.lpad:
+// CHECK-EXCEPTIONS-NEXT:    [[TMP0:%.*]] = landingpad { ptr, i32 }
+// CHECK-EXCEPTIONS-NEXT:    catch ptr null
+// CHECK-EXCEPTIONS-NEXT:    [[TMP1:%.*]] = extractvalue { ptr, i32 } [[TMP0]], 0
+// CHECK-EXCEPTIONS-NEXT:    call void @__clang_call_terminate(ptr [[TMP1]]) #[[ATTR8:[0-9]+]]
+// CHECK-EXCEPTIONS-NEXT:    unreachable
+//
+__attribute__((pure)) void pure_noexcept_function() noexcept {
+  opaque_callee();
+}
+
+// CHECK-NO-EXCEPTIONS: Function Attrs: mustprogress noinline nounwind optnone willreturn memory(none)
+// CHECK-NO-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z23const_noexcept_functionv
+// CHECK-NO-EXCEPTIONS-SAME: () #[[ATTR4:[0-9]+]] {
+// CHECK-NO-EXCEPTIONS-NEXT:  entry:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z13opaque_calleev()
+// CHECK-NO-EXCEPTIONS-NEXT:    ret void
+//
+// CHECK-EXCEPTIONS: Function Attrs: mustprogress noinline nounwind optnone willreturn memory(none)
+// CHECK-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z23const_noexcept_functionv
+// CHECK-EXCEPTIONS-SAME: () #[[ATTR5:[0-9]+]] personality ptr @__gxx_personality_v0 {
+// CHECK-EXCEPTIONS-NEXT:  entry:
+// CHECK-EXCEPTIONS-NEXT:    invoke void @_Z13opaque_calleev()
+// CHECK-EXCEPTIONS-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[TERMINATE_LPAD:%.*]]
+// CHECK-EXCEPTIONS:       invoke.cont:
+// CHECK-EXCEPTIONS-NEXT:    ret void
+// CHECK-EXCEPTIONS:       terminate.lpad:
+// CHECK-EXCEPTIONS-NEXT:    [[TMP0:%.*]] = landingpad { ptr, i32 }
+// CHECK-EXCEPTIONS-NEXT:    catch ptr null
+// CHECK-EXCEPTIONS-NEXT:    [[TMP1:%.*]] = extractvalue { ptr, i32 } [[TMP0]], 0
+// CHECK-EXCEPTIONS-NEXT:    call void @__clang_call_terminate(ptr [[TMP1]]) #[[ATTR8]]
+// CHECK-EXCEPTIONS-NEXT:    unreachable
+//
+__attribute__((const)) void const_noexcept_function() noexcept {
+  opaque_callee();
+}
+
+// CHECK-NO-EXCEPTIONS: Function Attrs: mustprogress noinline nounwind optnone
+// CHECK-NO-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z39normal_caller_of_pure_noexcept_functionv
+// CHECK-NO-EXCEPTIONS-SAME: () #[[ATTR2]] {
+// CHECK-NO-EXCEPTIONS-NEXT:  entry:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z22pure_noexcept_functionv() #[[ATTR7:[0-9]+]]
+// CHECK-NO-EXCEPTIONS-NEXT:    ret void
+//
+// CHECK-EXCEPTIONS: Function Attrs: mustprogress noinline nounwind optnone
+// CHECK-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z39normal_caller_of_pure_noexcept_functionv
+// CHECK-EXCEPTIONS-SAME: () #[[ATTR6:[0-9]+]] {
+// CHECK-EXCEPTIONS-NEXT:  entry:
+// CHECK-EXCEPTIONS-NEXT:    call void @_Z22pure_noexcept_functionv() #[[ATTR10:[0-9]+]]
+// CHECK-EXCEPTIONS-NEXT:    ret void
+//
+void normal_caller_of_pure_noexcept_function() {
+  pure_noexcept_function();
+}
+
+// CHECK-NO-EXCEPTIONS: Function Attrs: mustprogress noinline nounwind optnone
+// CHECK-NO-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z40normal_caller_of_const_noexcept_functionv
+// CHECK-NO-EXCEPTIONS-SAME: () #[[ATTR2]] {
+// CHECK-NO-EXCEPTIONS-NEXT:  entry:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z23const_noexcept_functionv() #[[ATTR8:[0-9]+]]
+// CHECK-NO-EXCEPTIONS-NEXT:    ret void
+//
+// CHECK-EXCEPTIONS: Function Attrs: mustprogress noinline nounwind optnone
+// CHECK-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z40normal_caller_of_const_noexcept_functionv
+// CHECK-EXCEPTIONS-SAME: () #[[ATTR6]] {
+// CHECK-EXCEPTIONS-NEXT:  entry:
+// CHECK-EXCEPTIONS-NEXT:    call void @_Z23const_noexcept_functionv() #[[ATTR11:[0-9]+]]
+// CHECK-EXCEPTIONS-NEXT:    ret void
+//
+void normal_caller_of_const_noexcept_function() {
+  const_noexcept_function();
+}
+//.
+// CHECK-NO-EXCEPTIONS: attributes #0 = { mustprogress noinline nounwind optnone willreturn "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+// CHECK-NO-EXCEPTIONS: attributes #1 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+// CHECK-NO-EXCEPTIONS: attributes #2 = { mustprogress noinline nounwind optnone "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+// CHECK-NO-EXCEPTIONS: attributes #3 = { mustprogress noinline nounwind optnone willreturn memory(read) "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+// CHECK-NO-EXCEPTIONS: attributes #4 = { mustprogress noinline nounwind optnone willreturn memory(none) "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+// CHECK-NO-EXCEPTIONS: attributes #5 = { willreturn memory(read) }
+// CHECK-NO-EXCEPTIONS: attributes #6 = { willreturn memory(none) }
+// CHECK-NO-EXCEPTIONS: attributes #7 = { nounwind willreturn memory(read) }
+// CHECK-NO-EXCEPTIONS: attributes #8 = { nounwind willreturn memory(none) }
+//.
+// CHECK-EXCEPTIONS: attributes #0 = { mustprogress noinline optnone willreturn "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+// CHECK-EXCEPTIONS: attributes #1 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+// CHECK-EXCEPTIONS: attributes #2 = { mustprogress noinline optnone "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+// CHECK-EXCEPTIONS: attributes #3 = { mustprogress noinline nounwind optnone willreturn memory(read) "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+// CHECK-EXCEPTIONS: attributes #4 = { noinline noreturn nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+// CHECK-EXCEPTIONS: attributes #5 = { mustprogress noinline nounwind optnone willreturn memory(none) "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+// CHECK-EXCEPTIONS: attributes #6 = { mustprogress noinline nounwind optnone "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+// CHECK-EXCEPTIONS: attributes #7 = { willreturn }
+// CHECK-EXCEPTIONS: attributes #8 = { noreturn nounwind }
+// CHECK-EXCEPTIONS: attributes #9 = { nounwind }
+// CHECK-EXCEPTIONS: attributes #10 = { nounwind willreturn memory(read) }
+// CHECK-EXCEPTIONS: attributes #11 = { nounwind willreturn memory(none) }
+//.
+//// NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+// CHECK-ALL: {{.*}}

clang/test/CodeGenOpenCL/fdeclare-opencl-builtins.cl

 // CHECK-LABEL: @test_float
 // CHECK: call spir_func <4 x float> @_Z3mixDv4_fS_f
 // CHECK: ret
 void test_float(float4 x, float a) {
   float4 ret = mix(x, x, a);
 }
 
 // Test that Attr.Const from OpenCLBuiltins.td is lowered to a readnone attribute.
+// FIXME: we don't, though.
 // CHECK-LABEL: @test_const_attr
-// CHECK: call spir_func i32 @_Z3maxii({{.*}}) [[ATTR_CONST:#[0-9]]]
+// CHECK: call spir_func i32 @_Z3maxii({{.*}}) [[ATTR_CONST_OR_PURE:#[0-9]]]
 // CHECK: ret
 int test_const_attr(int a) {
   return max(a, 2);
 }
 
 // Test that Attr.Pure from OpenCLBuiltins.td is lowered to a readonly attribute.
+// FIXME: we don't, though.
 // CHECK-LABEL: @test_pure_attr
-// CHECK: call spir_func <4 x float> @_Z11read_imagef{{.*}} [[ATTR_PURE:#[0-9]]]
+// CHECK: call spir_func <4 x float> @_Z11read_imagef{{.*}} [[ATTR_CONST_OR_PURE]]
 // CHECK: ret
 kernel void test_pure_attr(read_only image1d_t img) {
   float4 resf = read_imagef(img, 42);
 }
 
 // Test that builtins with only one prototype are mangled.
 // CHECK-LABEL: @test_mangling
 // CHECK: call spir_func i32 @_Z12get_local_idj
 kernel void test_mangling() {
   size_t lid = get_local_id(0);
 }
 
 // Test that the correct builtin is called depending on the generic address
 // space feature availability.
 // CHECK-LABEL: @test_generic_optionality
 // CHECK-GAS: call spir_func float @_Z5fractfPU3AS4f
 // CHECK-NOGAS: call spir_func float @_Z5fractfPf
 void test_generic_optionality(float a, float *b) {
   float res = fract(a, b);
 }
 
-// CHECK: attributes [[ATTR_CONST]] =
-// CHECK-SAME: memory(none)
-// CHECK: attributes [[ATTR_PURE]] =
-// CHECK-SAME: memory(read)
+// CHECK: attributes [[ATTR_CONST_OR_PURE]] =
+// CHECK-NOT: memory(none)

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

 // RUN: %clang_cc1 %s  -fdelayed-template-parsing -fcxx-exceptions -fsyntax-only -Wexceptions -verify -fdeclspec -std=c++17
 struct A_ShouldDiag {
   ~A_ShouldDiag(); // implicitly noexcept(true)
 };
 A_ShouldDiag::~A_ShouldDiag() { // expected-note {{destructor has a implicit non-throwing exception specification}}
   throw 1; // expected-warning {{has a non-throwing exception specification but can still throw}}
 }
 struct B_ShouldDiag {
   int i;
   ~B_ShouldDiag() noexcept(true) {} //no disg, no throw stmt
 };
-struct R_ShouldDiag : A_ShouldDiag {
+struct R_ShouldDiag_NoThrow : A_ShouldDiag {
   B_ShouldDiag b;
-  ~R_ShouldDiag() { // expected-note  {{destructor has a implicit non-throwing exception specification}}
+  ~R_ShouldDiag_NoThrow() { // expected-note  {{destructor has a implicit non-throwing exception specification}}
     throw 1; // expected-warning {{has a non-throwing exception specification but}}
   }
-  __attribute__((nothrow)) R_ShouldDiag() {// expected-note {{function declared non-throwing here}}
+  __attribute__((nothrow)) R_ShouldDiag_NoThrow() {// 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 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 {