[nofree] Refine concurrency requirements

[nhaehnle]

Summary

(Triggered by discussion on https://reviews.llvm.org/D100141, this is
a counter-proposal to https://reviews.llvm.org/D100676)

Declare that a nofree function cannot arrange for memory to be freed
that was dereferenceable before the call -- whether by (transitive) call
or by communication with another thread.

This is a simplification from the perspective of using the information
provided by the function attribute when optimizing the caller, at the
cost of complicating the inference of nofree.

This change arguably increases the expressive power of the IR, since we
can now have functions that are (usefully) nofree without being nosync.
Before this change, nofree on a not-nosync function does not do
anything.

The attributor is updated so that a function containing a volatile
memory operation or a release (or stronger) atomic operations is not
nofree. The reasoning behind only checking for release ordering is
explained in a code comment.

@jdoerfert: I have zero knowledge of the attributor infrastructure, so if
this direction is taken I'd appreciate a review specifically of those parts.

[reames]

At a minimum, you need to update FunctionAttrs.cpp.

[nlopes]

LGTM for the LangRef changes.
I agree the proposed semantics is more useful this way. Plus I agree with the argument that the IR is more expressive this way, as it then supports nofree functions that do atomic stuff.

[nikic]

+1 for the semantics change from me as well.

[reames]

I am neutral on the proposed change, but I would very much like to hear from @sstefan1, the original author of the nofree attribute.

[sstefan1]

In D101701#2735040, @reames wrote:

I am neutral on the proposed change, but I would very much like to hear from @sstefan1, the original author of the nofree attribute.

I'm not actually the one who introduced it, but I think this sounds good. Attributor changes look good as well.

llvm/docs/LangRef.rst

1619–1620

If I'm not wrong, this part hasn't been implemented yet? We won't infer nofree for a function that frees memory it allocated.

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

1408

Maybe make this static, like AANoSyncImpl does?

[nhaehnle]

Address review feedback: Adding the required change to FunctionAttrs that @reames pointed out; in the new version, I also made sure to really go through all test cases.

Curiously, there is a test case in Analysis/ValueTracking/memory-dereferenceable.ll which already seemed to assume the semantics introduced with this change. At least, the comment seems to follow the logic that readonly implies nofree, which implies (*without* nosync) that dereferenceable on function arguments survives throughout the body. (Or perhaps the comment there could be interpreted as the belief that readonly should imply nosync? But that doesn't seem right to me.)

llvm/docs/LangRef.rst

1619–1620

Well, we do infer nofree for functions that contain alloca, which is implicitly freed at the end, though you're probably right about malloc and friends. In any case, that doesn't contradict what's written here.

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

1408

I'm moving this helper around in the second version, so the point hopefully becomes moot :)

[sstefan1]

llvm/docs/LangRef.rst

1619–1620

Yeah, that was just an observation. Maybe we have a TODO in AANoFree for that case?

[reames]

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

1303

This is wrong. A thread can coordinate using only acquire ordering within 'f'.

Example:
g = o; // the object being potentially freed
if (g_acquire)

return; // then *caller* does release store

use o;

The other thread does:
while (!g) {

g_acquire = true;
while (!g_release) {}
free(g);

}

Please exactly match the existing nosync logic in this file by using isOrderedAtomic helper in this file. We can be more aggressive later if desired.

[jdoerfert]

I'm late for the party, apologies.

Let me put down some thoughts:

1. What is the motivation here? I mean, which functions, except very few intrinsic, would be "strong" nofree but not nosync?
2. Doesn't this just mean we would check for nosync in order to derive nofree? What would be different?
3. Have you considered the pointer nofree and if it does not suffices for your use case:

%ptr = not_captured i8*
call @completely_unknown(i8* nofree nocapture)  ; <-- doesn't free %ptr even though it could free other stuff.

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

1452

You would ask AANoSync for the status on all those instructions, and that is the crucial point why I don't even see the benefit here. See main comment.

[nhaehnle]

In D101701#2744727, @jdoerfert wrote:

Let me put down some thoughts:

1. What is the motivation here? I mean, which functions, except very few intrinsic, would be "strong" nofree but not nosync?

My main motivation here is to make the nofree attribute less surprising and easier to consume. I find having an attribute in the IR that is called "no free" but means "can free, unless some other attribute is present" pretty surprising.

It comes down to the ability to think about callees as abstracted black boxes: I care about the side effects of calling the black box; I don't care (and don't want to have to care) about how those side effects come to be.

2. Doesn't this just mean we would check for nosync in order to derive nofree? What would be different?

That is one option, though I believe it is slightly more conservative than it needs to be. See the inline discussion with @reames. (There may still be non-correctness arguments for going down the conservative path of course.)

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

1303

This is an interesting example, but I don't think it shows what you want it to show? Without the release store in the caller, the other thread cannot proceed to free(g). In other words, the point at which g/o stops being dereferenceable is the release store in the caller, not the acquire load in the callee.

The acquire load is part of some coordination with the other thread, but it's redundant as far as the free concerned. At least it looks that way to me.

To attack this from a different angle, consider a slight variation of the example where the caller does a g_release store before calling f. In that case, putting dereferenceable on o is incorrect, because the other thread could free o before f is even entered.

From yet another different angle, which part of the reasoning in the comment in the AANoFreeImpl is wrong?

[reames]

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

1303

I'm not going to debate concurrency in this review. My (blocking, mandatory) request is that you exactly match existing behavior in this review.

If you wish to open a follow up review to refine the concurrency logic, we can do so. Warning: Concurrency is *hard* and we will need to loop in some experts who are not on this thread, and should not have to care about this review.

[jdoerfert]

In D101701#2746437, @nhaehnle wrote:

In D101701#2744727, @jdoerfert wrote:

Let me put down some thoughts:

1. What is the motivation here? I mean, which functions, except very few intrinsic, would be "strong" nofree but not nosync?

My main motivation here is to make the nofree attribute less surprising and easier to consume. I find having an attribute in the IR that is called "no free" but means "can free, unless some other attribute is present" pretty surprising.

But all our attributes work that way so changing nofree would make it an outlier.
Some examples:

willreturn + nounwind -> comes back and executes the next instruction after the call
argmemonly/inaccessiblemem_only + nosync -> there is no synchronization that revealed new values for globals

Depending on where we did fall wrt. synchronizing intrinsics you really cannot even use readnone/readonly
without nosync (maybe restricted to convergent functions).

The reason we want this is that attributes should compose. Almost always they also help on their own.
nofree without nosync can in fact be used for optimization. However, if we force it to go hand
in hand we loose that. Let me show you by example:

a = malloc
b = malloc
unknown(a);
nofree_nocapture_only(a, b);

Here, I can do heap2stack for b but not for a because nofree_nocapture_only could synchronize with someone to free a which escaped before.

It comes down to the ability to think about callees as abstracted black boxes: I care about the side effects of calling the black box; I don't care (and don't want to have to care) about how those side effects come to be.

I do not understand how this would be affected. The attributes limit the effects of the black box, regardless if there is one or two.
Could you elaborate why the black box view would be impaired if we do not apply this change?

2. Doesn't this just mean we would check for nosync in order to derive nofree? What would be different?

That is one option, though I believe it is slightly more conservative than it needs to be. See the inline discussion with @reames. (There may still be non-correctness arguments for going down the conservative path of course.)

The only more conservative part I can see is arguably out of range for the static analyses we have right now.
That is, we could add "strong nofree" if we show that all synchronizing parties do not free. Other than that
I fail to see how this is not just nofree + nosync packaged as nofree, and that does not make sense to
me at all. Composability is useful, as shown above.

[nlopes]

@jdoerfert a function that syncs with another thread may not free anything itself and the other thread may not free anything either.
If you require an optimization to have nofree + nosync in a call to preserve dereferenceability then you can't optimize this case.

That said, I had a thought last night and it isn't clear to me what to do with escaped pointers. On one hand it's nice for the optimizers if nofree implies escaped pointers aren't freed. This, however, makes inferring nofree harder. Functions that sync with other threads can't really be marked nofree without IPA. Essentially it degenerates in your concern, that nofree then implies nosync (in practice). However, it allows improved precision in theory (in case someone cares and implements an IPA).

Another possibility is to restrict nofree to unescaped pointers. But that degenerates in tagging function arguments with nofree, as unescaped can't be freed anyway.

The current proposal leaves room for improvement in the future if someone cares about multi-threaded programs and implements an IPA. Since it doesn't seem to impose any major pain in the implementation, it seems to be the best option.

[jdoerfert]

In D101701#2746841, @nlopes wrote:

@jdoerfert a function that syncs with another thread may not free anything itself and the other thread may not free anything either.
If you require an optimization to have nofree + nosync in a call to preserve dereferenceability then you can't optimize this case.

I disagree, and I think this is the conceptual differences we have here.

If one does only look at a function in isolation then I agree, nofree alone is not sufficient to make statements about all call sites and arguments.
However, if you look at a call site of a nofree function the situation is different because you have context information about the arguments.

Let's go back to my last example:

a = malloc
b = malloc
unknown(a);                  // no attributes 0-> escapes
nofree_nocapture_only(a, b); // `nofree`, `nocapture` on args

I know that at the end of this sequence b has not been freed, even though there is no nosync in sight.
I can also derive nofree for nofree_nocapture_only without worrying about atomics, for example.
(Here is the sequence in action with heap2stack kicking in for b: https://godbolt.org/z/hjYrhaEvW)

So, with nofree and nosync being completely separated, as it was in the very beginning, you can:

1. Optimize even if only one is present, given additional call site information.
2. Derive nofree even if nosync is not present.

All the "strong nofree" effectively gives us is that it combines the to attributes.
Let's introduce a helper:
bool cannotFreeAtAll(Function &F) { return F.hasAttr(NoFree) && F.hasAttr(NoSync); }
you get your guarantee that F will not, in any way` free something. That said,
I find the call site specific reasoning is the way to go anyway but if some generic
"for all call sites and arguments" handling is required we can go with the helper instead.

[nlopes]

In D101701#2746949, @jdoerfert wrote:

In D101701#2746841, @nlopes wrote:

@jdoerfert a function that syncs with another thread may not free anything itself and the other thread may not free anything either.
If you require an optimization to have nofree + nosync in a call to preserve dereferenceability then you can't optimize this case.

I disagree, and I think this is the conceptual differences we have here.

If one does only look at a function in isolation then I agree, nofree alone is not sufficient to make statements about all call sites and arguments.
However, if you look at a call site of a nofree function the situation is different because you have context information about the arguments.

Let's go back to my last example:

a = malloc
b = malloc
unknown(a);                  // no attributes 0-> escapes
nofree_nocapture_only(a, b); // `nofree`, `nocapture` on args

I know that at the end of this sequence b has not been freed, even though there is no nosync in sight.
I can also derive nofree for nofree_nocapture_only without worrying about atomics, for example.
(Here is the sequence in action with heap2stack kicking in for b: https://godbolt.org/z/hjYrhaEvW)

So, with nofree and nosync being completely separated, as it was in the very beginning, you can:

1. Optimize even if only one is present, given additional call site information.
2. Derive nofree even if nosync is not present.

Your examples are around nofree arguments, not nofree functions, which is what this patch is about.
nofree in functions is useful for pointers that are *not* passed as argument, like this:

f(i8* %p) {
  load %p  ; implies it's dereferenceable
  call @g() nofree
  ; is %p still dereferenceable or not?
}

This patch states that yes, %p is still dereferenceable after the call to @g as it's tagged with nofree. That's it.

[jdoerfert]

In D101701#2747492, @nlopes wrote:

In D101701#2746949, @jdoerfert wrote:

In D101701#2746841, @nlopes wrote:

@jdoerfert a function that syncs with another thread may not free anything itself and the other thread may not free anything either.
If you require an optimization to have nofree + nosync in a call to preserve dereferenceability then you can't optimize this case.

I disagree, and I think this is the conceptual differences we have here.

If one does only look at a function in isolation then I agree, nofree alone is not sufficient to make statements about all call sites and arguments.
However, if you look at a call site of a nofree function the situation is different because you have context information about the arguments.

Let's go back to my last example:

a = malloc
b = malloc
unknown(a);                  // no attributes 0-> escapes
nofree_nocapture_only(a, b); // `nofree`, `nocapture` on args

I know that at the end of this sequence b has not been freed, even though there is no nosync in sight.
I can also derive nofree for nofree_nocapture_only without worrying about atomics, for example.
(Here is the sequence in action with heap2stack kicking in for b: https://godbolt.org/z/hjYrhaEvW)

So, with nofree and nosync being completely separated, as it was in the very beginning, you can:

1. Optimize even if only one is present, given additional call site information.
2. Derive nofree even if nosync is not present.

Your examples are around nofree arguments, not nofree functions, which is what this patch is about.

nofree functions imply nofree arguments so it very much makes a difference if we make it harder to infer
and annotate the former. As we already moved to a more semantic-based definition of escaped we can actually
look at an example where this makes a difference. Take pointers passed via memory to see how you cannot just
move the nofree to account for the change made by this patch:

struct { int *a } s;
s.a = malloc()               // this is a store.
nofree_nocapture_only(&s)    // we can potentially show `s.a` is not captured in the function but we cannot
                             // annotate that fact as a `nofree` argument without argument promotion, which
                             // we cannot always do.
// s.a is still known to be dereferenceable even without `nosync`. The function `nofree` is needed, `nofree`
// argument attributes are not involved.

nofree in functions is useful for pointers that are *not* passed as argument, like this:

f(i8* %p) {
  load %p  ; implies it's dereferenceable
  call @g() nofree
  ; is %p still dereferenceable or not?
}

This patch states that yes, %p is still dereferenceable after the call to @g as it's tagged with nofree. That's it.

Let's not ignore the arguments that are somehow passed though. Anyway, this patch does not actually add anything you
need for you example. If g is nofree & nosync you get exactly the same effect already. I hope we agree on that.

If we allow user feedback you can also make your @f nosync and get the effect you want even if @g is not nosync,
This is especially useful if @g is an intrinsic users cannot actually annotate.

In addition to the examples I brought up that are impacted, let me reiterate what I said in my first post:
Other attributes work in the same composable way:

void foo(int * __restrict__ flag, char* p) {
  argmemonly(flag);                 // Says argmemonly and p is not passed nor does p alias flag, still p is potentially written.
                                    // This is like a call to a `nofree` function which might still free pointers via synchronization.
                                    // `nosync` is a orthogonal component to these attributes as we can otherwise not derive them.
                                    // However, as with `nofree`, we can use the attributes even without `nosync` in some situations.
}

[nhaehnle]

Hi Johannes,

before I give a more complete response, I'd like to understand your position more fully. To that end:

In D101701#2747864, @jdoerfert wrote:

nofree functions imply nofree arguments so it very much makes a difference if we make it harder to infer
and annotate the former. As we already moved to a more semantic-based definition of escaped we can actually
look at an example where this makes a difference. Take pointers passed via memory to see how you cannot just
move the nofree to account for the change made by this patch:

struct { int *a } s;
s.a = malloc()               // this is a store.
nofree_nocapture_only(&s)    // we can potentially show `s.a` is not captured in the function but we cannot
                             // annotate that fact as a `nofree` argument without argument promotion, which
                             // we cannot always do.
// s.a is still known to be dereferenceable even without `nosync`. The function `nofree` is needed, `nofree`
// argument attributes are not involved.

Is that actually true? Regardless of the nocapture flag, s.a may be passed to another thread which then frees it. (nocapture only applies to &s in the first place, and even then, it does not say anything about temporary copies of the pointer that may be passed to other threads.)

In addition to the examples I brought up that are impacted, let me reiterate what I said in my first post:
Other attributes work in the same composable way:

void foo(int * __restrict__ flag, char* p) {
  argmemonly(flag);                 // Says argmemonly and p is not passed nor does p alias flag, still p is potentially written.
                                    // This is like a call to a `nofree` function which might still free pointers via synchronization.
                                    // `nosync` is a orthogonal component to these attributes as we can otherwise not derive them.
                                    // However, as with `nofree`, we can use the attributes even without `nosync` in some situations.
}

I don't think this is true. LangRef certainly doesn't support that claim as far as I can tell (the definition of argmemonly talks about there being no side effects at all, without any exception for side effects triggered via other threads), and it turns out that due to confusion about this in the attributor, I can actually provoke a miscompilation fairly easily. So there may be a bigger issue at play there. If you do think that there is consensus and/or documentation about argmemonly working the way you think it should work, can you please point to it?

[nhaehnle]

In D101701#2750507, @nhaehnle wrote:

In D101701#2747864, @jdoerfert wrote:

nofree functions imply nofree arguments so it very much makes a difference if we make it harder to infer
and annotate the former. As we already moved to a more semantic-based definition of escaped we can actually
look at an example where this makes a difference. Take pointers passed via memory to see how you cannot just
move the nofree to account for the change made by this patch:

struct { int *a } s;
s.a = malloc()               // this is a store.
nofree_nocapture_only(&s)    // we can potentially show `s.a` is not captured in the function but we cannot
                             // annotate that fact as a `nofree` argument without argument promotion, which
                             // we cannot always do.
// s.a is still known to be dereferenceable even without `nosync`. The function `nofree` is needed, `nofree`
// argument attributes are not involved.

Is that actually true? Regardless of the nocapture flag, s.a may be passed to another thread which then frees it. (nocapture only applies to &s in the first place, and even then, it does not say anything about temporary copies of the pointer that may be passed to other threads.)

I realize now that I was partially wrong about this: the definition of the nocapture attribute does say that the function cannot send the pointer to another thread, but the pointer in question is &s. So it still seems to me that in the example, the callee is allowed to send s.a to another thread which then frees it (given today's definition of nofree).

If this example does fall like I think it does, is there still an optimization benefit to having the function attribute nofree as defined today vs. as defined in this patch? As I see it, there were three arguments:

1. Inference doesn't have to worry about synchronization.
2. Other attributes work the same way; however, this is false at least for argmemonly and arguably also for inaccessiblememonly, except that one presumably never gets inferred?
3. Today's nofree enables annotations and optimizations that the proposed change would no longer allow. I can't say for certain whether this is false, but at least the examples given so far seem to fail (the first one because you can just use the nofree argument attribute instead, and the second is discussed above in this comment).

That leaves as a single argument the complexity of inference, but how strong of an argument is that, really?

P.S.: The example I have in mind where confusion about argmemonly can be used to trigger a miscompile is at https://godbolt.org/z/dEG8n6W3E. Current main merges the two loads from %q, which is incorrect since @setup could arrange for a second thread to be created which changes its value in between.

[nhaehnle]

Split up the patch as per @reames' request

[jdoerfert]

[EDIT: Added response to newest comment in the end.]

In D101701#2750507, @nhaehnle wrote:

Hi Johannes,

before I give a more complete response, I'd like to understand your position more fully. To that end:

In D101701#2747864, @jdoerfert wrote:

nofree functions imply nofree arguments so it very much makes a difference if we make it harder to infer
and annotate the former. As we already moved to a more semantic-based definition of escaped we can actually
look at an example where this makes a difference. Take pointers passed via memory to see how you cannot just
move the nofree to account for the change made by this patch:

struct { int *a } s;
s.a = malloc()               // this is a store.
nofree_nocapture_only(&s)    // we can potentially show `s.a` is not captured in the function but we cannot
                             // annotate that fact as a `nofree` argument without argument promotion, which
                             // we cannot always do.
// s.a is still known to be dereferenceable even without `nosync`. The function `nofree` is needed, `nofree`
// argument attributes are not involved.

Is that actually true? Regardless of the nocapture flag, s.a may be passed to another thread which then frees it. (nocapture only applies to &s in the first place, and even then, it does not say anything about temporary copies of the pointer that may be passed to other threads.)

I am not aware of a way to pass to another thread that does not capture a pointer. Please feel free to show me one.

In addition to the examples I brought up that are impacted, let me reiterate what I said in my first post:
Other attributes work in the same composable way:

void foo(int * __restrict__ flag, char* p) {
  argmemonly(flag);                 // Says argmemonly and p is not passed nor does p alias flag, still p is potentially written.
                                    // This is like a call to a `nofree` function which might still free pointers via synchronization.
                                    // `nosync` is a orthogonal component to these attributes as we can otherwise not derive them.
                                    // However, as with `nofree`, we can use the attributes even without `nosync` in some situations.
}

I don't think this is true. LangRef certainly doesn't support that claim as far as I can tell (the definition of argmemonly talks about there being no side effects at all, without any exception for side effects triggered via other threads), and it turns out that due to confusion about this in the attributor, I can actually provoke a miscompilation fairly easily. So there may be a bigger issue at play there. If you do think that there is consensus and/or documentation about argmemonly working the way you think it should work, can you please point to it?

So you are arguing armemonly is also implying nosync? Then we get into the same problems we have here. You don't actually gain expressiveness, after all you can check if both attribute X and nosync are present, but you loose the ability to derive and utilize them separately. One conceptual thing to consider is that almost all of this predates nosync in the first place. That said, I don't see how you would interpret the text as there are no side effects by other threads:

argmemonly

    This attribute indicates that the only memory accesses inside function are loads and stores from objects pointed to by its pointer-typed arguments, with arbitrary offsets. Or in other words, all memory operations in the function can refer to memory only using pointers based on its function arguments.

    Note that argmemonly can be used together with readonly attribute in order to specify that function reads only from its arguments.

    If an argmemonly function reads or writes memory other than the pointer arguments, or has other side-effects, the behavior is undefined.

What in the above definition prevents me from doing this:

void foo(atomic flag) { atomic_write(flag, 1); while(atomic_read(flag) == 1); atomic_write(flag, 2); }

Inside the function all memory that is accesses are loads/stores from objects pointed by pointer-type arguments (with 0 offset). Do you disagree?

FWIW, this basically breaks down with stuff like malloc which we assume is inaccessiblememonly but it is in fact *not*, and cannot be, nosync. So if we require attributes to imply nosync, malloc cannot be inaccessiblememonly anymore. (see https://reviews.llvm.org/D98605#2625243)

---

In D101701#2752305, @nhaehnle wrote:

In D101701#2750507, @nhaehnle wrote:

In D101701#2747864, @jdoerfert wrote:

nofree functions imply nofree arguments so it very much makes a difference if we make it harder to infer
and annotate the former. As we already moved to a more semantic-based definition of escaped we can actually
look at an example where this makes a difference. Take pointers passed via memory to see how you cannot just
move the nofree to account for the change made by this patch:

struct { int *a } s;
s.a = malloc()               // this is a store.
nofree_nocapture_only(&s)    // we can potentially show `s.a` is not captured in the function but we cannot
                             // annotate that fact as a `nofree` argument without argument promotion, which
                             // we cannot always do.
// s.a is still known to be dereferenceable even without `nosync`. The function `nofree` is needed, `nofree`
// argument attributes are not involved.

Is that actually true? Regardless of the nocapture flag, s.a may be passed to another thread which then frees it. (nocapture only applies to &s in the first place, and even then, it does not say anything about temporary copies of the pointer that may be passed to other threads.)

I realize now that I was partially wrong about this: the definition of the nocapture attribute does say that the function cannot send the pointer to another thread, but the pointer in question is &s. So it still seems to me that in the example, the callee is allowed to send s.a to another thread which then frees it (given today's definition of nofree).

As stated in my text on the right, we can potentially derive s.a is not captured and we can derive, or read from attributes, &s is not captured. If we cannot derive the either, we can certainly expect someone to free it s.a. However, if we can derive both, we cannot actually put the nofree on the s.a pointer to manifest the information. So there is no place to put it and with a stronger nofree on the function we have less chance to put that one. [While right now there is no place for the "not captured" of the &s.a pointer, we are already working on such ways, e.g., https://reviews.llvm.org/D93189 (and there is an RFC thread).]

If this example does fall like I think it does, is there still an optimization benefit to having the function attribute nofree as defined today vs. as defined in this patch? As I see it, there were three arguments:

1. Inference doesn't have to worry about synchronization.

Agreed. Split the problem. Though, to be fair, it is trivial to require nosync for nofree to be deducible in the first place.

2. Other attributes work the same way; however, this is false at least for argmemonly and arguably also for inaccessiblememonly, except that one presumably never gets inferred?

I don't think it is.

3. Today's nofree enables annotations and optimizations that the proposed change would no longer allow. I can't say for certain whether this is false, but at least the examples given so far seem to fail (the first one because you can just use the nofree argument attribute instead, and the second is discussed above in this comment).

I think once I manage to explain the examples you will reconsider this point. To give you another one:

__attribute__((nosync)) // or __attribute__((assume("nosync")) or #pragma omp assume ext_no_synchronization
void user_code() {
  a = malloc();
  b = malloc();
  unknown_function_with_a_now_nosync_call_site(a, b);
  ...
  free(a);
}

That leaves as a single argument the complexity of inference, but how strong of an argument is that, really?

I think there are a lot of reasons to keep it separated, the examples above still stand. That said, why would
we combine it? It saves one attribute lookup?

P.S.: The example I have in mind where confusion about argmemonly can be used to trigger a miscompile is at https://godbolt.org/z/dEG8n6W3E. Current main merges the two loads from %q, which is incorrect since @setup could arrange for a second thread to be created which changes its value in between.

Agreed this is a bug. Though, it's in instcombine (or probably MemorySSA) not the Attributor. If you disagree you have to tell me which part of the argmemonly definition is violated by release: "This attribute indicates that the only memory accesses inside function are loads and stores from objects pointed to by its pointer-typed arguments, with arbitrary offsets. Or in other words, all memory operations in the function can refer to memory only using pointers based on its function arguments."

[nlopes]

3. Today's nofree enables annotations and optimizations that the proposed change would no longer allow. I can't say for certain whether this is false, but at least the examples given so far seem to fail (the first one because you can just use the nofree argument attribute instead, and the second is discussed above in this comment).

I think once I manage to explain the examples you will reconsider this point. To give you another one:

__attribute__((nosync)) // or __attribute__((assume("nosync")) or #pragma omp assume ext_no_synchronization
void user_code() {
  a = malloc();
  b = malloc();
  unknown_function_with_a_now_nosync_call_site(a, b);
  ...
  free(a);
}

This is a good example, that shows that if the user annotates a function with nosync then inferring nofree becomes easier. So the proposed semantics doesn't require nosync, but inference can be aided by its presence (not in this patch yet).

I think all the reviewers' concerns have been addresses at this point. Please let us know if there's some remaining concern regarding the proposed semantics.
The semantics proposed in this patch makes a lot of sense to me. And to make things clear, this proposal *does not* make nofree imply nosync (nor the other way around).

[jdoerfert]

In D101701#2754648, @nlopes wrote:

3. Today's nofree enables annotations and optimizations that the proposed change would no longer allow. I can't say for certain whether this is false, but at least the examples given so far seem to fail (the first one because you can just use the nofree argument attribute instead, and the second is discussed above in this comment).

I think once I manage to explain the examples you will reconsider this point. To give you another one:

__attribute__((nosync)) // or __attribute__((assume("nosync")) or #pragma omp assume ext_no_synchronization
void user_code() {
  a = malloc();
  b = malloc();
  unknown_function_with_a_now_nosync_call_site(a, b);
  ...
  free(a);
}

This is a good example, that shows that if the user annotates a function with nosync then inferring nofree becomes easier. So the proposed semantics doesn't require nosync, but inference can be aided by its presence (not in this patch yet).

This is not at all what the example shows. The example shows that we cannot infer nofree for unknown_function_with_a_now_nosync_call_site with the new semantics but with the old semantics we could.
Only with the existing semantics you can optimize this example, not with the new one. I would have assumed this is implied given that I provided the example and I am arguing the proposed semantics are useless and prevent optimizations.

I think all the reviewers' concerns have been addresses at this point. Please let us know if there's some remaining concern regarding the proposed semantics.

My concerns have not changed at all. Unsure why you would assume they have been addressed.

The semantics proposed in this patch makes a lot of sense to me. And to make things clear, this proposal *does not* make nofree imply nosync (nor the other way around).

For deduction purposes it effectively does imply/require nosync. If you disagree, please provide an example where we can derive nofree without nosync under the proposed semantics.

[nlopes]

In D101701#2754739, @jdoerfert wrote:

In D101701#2754648, @nlopes wrote:

3. Today's nofree enables annotations and optimizations that the proposed change would no longer allow. I can't say for certain whether this is false, but at least the examples given so far seem to fail (the first one because you can just use the nofree argument attribute instead, and the second is discussed above in this comment).

I think once I manage to explain the examples you will reconsider this point. To give you another one:

__attribute__((nosync)) // or __attribute__((assume("nosync")) or #pragma omp assume ext_no_synchronization
void user_code() {
  a = malloc();
  b = malloc();
  unknown_function_with_a_now_nosync_call_site(a, b);
  ...
  free(a);
}

This is a good example, that shows that if the user annotates a function with nosync then inferring nofree becomes easier. So the proposed semantics doesn't require nosync, but inference can be aided by its presence (not in this patch yet).

This is not at all what the example shows. The example shows that we cannot infer nofree for unknown_function_with_a_now_nosync_call_site with the new semantics but with the old semantics we could.
Only with the existing semantics you can optimize this example, not with the new one. I would have assumed this is implied given that I provided the example and I am arguing the proposed semantics are useless and prevent optimizations.

For the example above, I don't see how you can deduce nofree for user_code or for unknown_function_with_a_now_nosync_call_site without further information that is not given in this example. Without knowing anything else, unknown_function_with_a_now_nosync_call_site may free some pointer stored in a global var. Who knows?
If my reading is wrong, please make the example more explicit and explain things more slowly, otherwise I'm unable to understand it. These things are hard and nothing is implied or implicit.

The semantics proposed in this patch makes a lot of sense to me. And to make things clear, this proposal *does not* make nofree imply nosync (nor the other way around).

For deduction purposes it effectively does imply/require nosync. If you disagree, please provide an example where we can derive nofree without nosync under the proposed semantics.

I already gave an example that shows that the semantics proposed in this patch is more expressive that the old one. Please don't mix semantics and some inference algorithm you have in mind (that hasn't been shared with us).
A simple example: consider a program with 2 threads, a main one and a helper thread. The helper thread doesn't free anything. The main thread may sync with the helper thread, so some function are not nosync, but you can still tag them as nofree if they don't free up anything.
So the proposed semantics is strictly more expressive than the old one. Plus it doesn't make it any harder to infer than before.

Even if the current patch cannot infer nofree for the example I've provided, there's nothing preventing someone writing an algorithm that could infer that in future. Plus, using your own argument, users may provide that information.

[nhaehnle]

In D101701#2752587, @jdoerfert wrote:

So you are arguing armemonly is also implying nosync? Then we get into the same problems we have here. You don't actually gain expressiveness, after all you can check if both attribute X and nosync are present, but you loose the ability to derive and utilize them separately. One conceptual thing to consider is that almost all of this predates nosync in the first place. That said, I don't see how you would interpret the text as there are no side effects by other threads:

argmemonly

    This attribute indicates that the only memory accesses inside function are loads and stores from objects pointed to by its pointer-typed arguments, with arbitrary offsets. Or in other words, all memory operations in the function can refer to memory only using pointers based on its function arguments.

    Note that argmemonly can be used together with readonly attribute in order to specify that function reads only from its arguments.

    If an argmemonly function reads or writes memory other than the pointer arguments, or has other side-effects, the behavior is undefined.

What in the above definition prevents me from doing this:

void foo(atomic flag) { atomic_write(flag, 1); while(atomic_read(flag) == 1); atomic_write(flag, 2); }

Inside the function all memory that is accesses are loads/stores from objects pointed by pointer-type arguments (with 0 offset). Do you disagree?

The part of the definition that I would argue prevents you from doing this is the "or has other side-effects".

FWIW, this basically breaks down with stuff like malloc which we assume is inaccessiblememonly but it is in fact *not*, and cannot be, nosync. So if we require attributes to imply nosync, malloc cannot be inaccessiblememonly anymore. (see https://reviews.llvm.org/D98605#2625243)

There are two directions in which one can take this.

First, your desired path forward appears to be that argmemonly on a callee can only be taken at face value if the callee is also nosync. Presumably, you would want the same treatment to apply to inaccessiblememonly. So then if malloc cannot be nosync, what's the point of making it inaccessiblememonly? What would that still allow you to deduce that you cannot deduce even without the inaccessiblememonly?

Second, perhaps malloc can be nosync. I see the quote from the C standard, but it's unclear to me whether that language is good for anything other than ensuring no data races in a formal model, and surely there are other means to achieve the same goal, e.g. saying that a re-allocated portion of memory is a different memory location as far as the memory model is concerned. The only way I can see to perform meaningful synchronization through free and malloc would be to compare the result of malloc with some pointer that was allocated earlier (if they're equal, this implies that the earlier allocation was freed, and we have a synchronization edge that can be relied upon). It may be possible to make this undefined somehow, perhaps involving the non-determinism trick that is proposed for pointer provenance can be applied here as well.

[...]

3. Today's nofree enables annotations and optimizations that the proposed change would no longer allow. I can't say for certain whether this is false, but at least the examples given so far seem to fail (the first one because you can just use the nofree argument attribute instead, and the second is discussed above in this comment).

I think once I manage to explain the examples you will reconsider this point. To give you another one:

__attribute__((nosync)) // or __attribute__((assume("nosync")) or #pragma omp assume ext_no_synchronization
void user_code() {
  a = malloc();
  b = malloc();
  unknown_function_with_a_now_nosync_call_site(a, b);
  ...
  free(a);
}

Not sure what you're saying here. Do you want the unknown function to be nofree but it *does* contain synchronization, except that then the external nosync "overrides" that fact and we pray that the programmer knew what they were doing?

That leaves as a single argument the complexity of inference, but how strong of an argument is that, really?

I think there are a lot of reasons to keep it separated, the examples above still stand. That said, why would
we combine it? It saves one attribute lookup?

To me the fundamental problem is having an attribute that says "calling this function doesn't free memory" on a call that does, in fact, free memory. Why would/should the caller care about whether the freeing happens in the same thread or not? I think Nuno's line of argument about separating the semantics from the implementation goes in a similar direction.

This doesn't mean that we can't have the more structural (as opposed to semantic) attribute you want to have, but I'd be in favor of naming it more accurately, e.g. nothreadlocalfree.

P.S.: The example I have in mind where confusion about argmemonly can be used to trigger a miscompile is at https://godbolt.org/z/dEG8n6W3E. Current main merges the two loads from %q, which is incorrect since @setup could arrange for a second thread to be created which changes its value in between.

Agreed this is a bug. Though, it's in instcombine (or probably MemorySSA) not the Attributor. If you disagree you have to tell me which part of the argmemonly definition is violated by release: "This attribute indicates that the only memory accesses inside function are loads and stores from objects pointed to by its pointer-typed arguments, with arbitrary offsets. Or in other words, all memory operations in the function can refer to memory only using pointers based on its function arguments."

As stated above, it's at the very least the part that says there can be no other side effects. Synchronizing with another thread which then modifies other memory is surely a side effect.

[jdoerfert]

In D101701#2902142, @nhaehnle wrote:

In D101701#2752587, @jdoerfert wrote:

So you are arguing armemonly is also implying nosync? Then we get into the same problems we have here. You don't actually gain expressiveness, after all you can check if both attribute X and nosync are present, but you loose the ability to derive and utilize them separately. One conceptual thing to consider is that almost all of this predates nosync in the first place. That said, I don't see how you would interpret the text as there are no side effects by other threads:

argmemonly

    This attribute indicates that the only memory accesses inside function are loads and stores from objects pointed to by its pointer-typed arguments, with arbitrary offsets. Or in other words, all memory operations in the function can refer to memory only using pointers based on its function arguments.

    Note that argmemonly can be used together with readonly attribute in order to specify that function reads only from its arguments.

    If an argmemonly function reads or writes memory other than the pointer arguments, or has other side-effects, the behavior is undefined.

What in the above definition prevents me from doing this:

void foo(atomic flag) { atomic_write(flag, 1); while(atomic_read(flag) == 1); atomic_write(flag, 2); }

Inside the function all memory that is accesses are loads/stores from objects pointed by pointer-type arguments (with 0 offset). Do you disagree?

The part of the definition that I would argue prevents you from doing this is the "or has other side-effects".

This reading defines FunctionAttr (and others) are wrong right now when deducing almost any attribute in the absence of nosync.
Further, it should not be "other side-effects" as a general statement anyway. It would subsume nounwind and interact badly with infinite loops (D106749), both of which would interact badly with C++ and pure/const functions, as an example.

Long story short, there is still no good reason for attributes not to be composed instead of somehow defined with overlapping semantics.

FWIW, this basically breaks down with stuff like malloc which we assume is inaccessiblememonly but it is in fact *not*, and cannot be, nosync. So if we require attributes to imply nosync, malloc cannot be inaccessiblememonly anymore. (see https://reviews.llvm.org/D98605#2625243)

There are two directions in which one can take this.

First, your desired path forward appears to be that argmemonly on a callee can only be taken at face value if the callee is also nosync. Presumably, you would want the same treatment to apply to inaccessiblememonly. So then if malloc cannot be nosync, what's the point of making it inaccessiblememonly? What would that still allow you to deduce that you cannot deduce even without the inaccessiblememonly?

As I mentioned before, (1) this comes from a time where we did not think about synchronization much (BuildLibCalls.cpp does not once set nosync to this day)
and it was ignored widely, and (2) it helps you at the call site if you have nosync there. I provided call site examples before, most of them apply again.
If you combine call site information with nofree for the function, or inaccessiblememonly for the function you can actually derive things. If nofree,
inaccessiblememonly, readonly, ... cannot be derived in the presence of nosync we loose that ability. Let's make a new example though.

Let's assume this is our entire module:

static int *X = nullptr;

int readX() { return *X; }

void foo() {
  if (!X)
    X = malloc(4);  // let it be known in the module.
}

void bar() {
  *X = 1;
  unknown_inaccessible_mem_only_but_not_nosync();   // e.g. malloc
  argmemonly_nofree_but_not_nosync(X);              // can be derived from the definition of the function and attribute can be made available through HTO or thinLTO.
  // X is still deref here because no thread could have freed it.
}

X is in the entire module deref_or_null(4) but only because we have inaccessible_mem_only (malloc) and argmemonly + nofree (definition + HTO/thinLTO).
nosync is not set for any of the functions.

Second, perhaps malloc can be nosync. I see the quote from the C standard, but it's unclear to me whether that language is good for anything other than ensuring no data races in a formal model, and surely there are other means to achieve the same goal, e.g. saying that a re-allocated portion of memory is a different memory location as far as the memory model is concerned. The only way I can see to perform meaningful synchronization through free and malloc would be to compare the result of malloc with some pointer that was allocated earlier (if they're equal, this implies that the earlier allocation was freed, and we have a synchronization edge that can be relied upon). It may be possible to make this undefined somehow, perhaps involving the non-determinism trick that is proposed for pointer provenance can be applied here as well.

You basically described the side-channel that makes malloc/free not nosync, didn't you?

T0: foo() /* nosync */; while(1) { p = malloc(); atomic_relaxed_record(p); free(p); }
T1: do { p = malloc(); found = atomic_relaxed_lookup(p); free(p); } while (!found); print("foo is done!");

[...]

3. Today's nofree enables annotations and optimizations that the proposed change would no longer allow. I can't say for certain whether this is false, but at least the examples given so far seem to fail (the first one because you can just use the nofree argument attribute instead, and the second is discussed above in this comment).

I think once I manage to explain the examples you will reconsider this point. To give you another one:

__attribute__((nosync)) // or __attribute__((assume("nosync")) or #pragma omp assume ext_no_synchronization
void user_code() {
  a = malloc();
  b = malloc();
  unknown_function_with_a_now_nosync_call_site(a, b);
  ...
  free(a);
}

Not sure what you're saying here. Do you want the unknown function to be nofree but it *does* contain synchronization, except that then the external nosync "overrides" that fact and we pray that the programmer knew what they were doing?

I'm not sure about pray but I am sure we already assume annotations by the user are correct. We also explicitly query them for
annotations (https://openmp.llvm.org/docs/remarks/OMP133.html, loop vectorizer remarks, ...) and I strongly expect this to become more frequent in the future.

I can also see us, and others, annotate libraries that use things like volatile/atomic accesses and malloc to employ nosync annotations
if we know they are sound from the callers perspective.

Finally, we started to track threads explicitly already, partially using domain knowledge, which allows us to reason about the interaction between threads
(https://reviews.llvm.org/D106397#C2702144NL1110). So even in the presence of synchronizations (atomics, barriers, etc), we can use other attributes
(argmemonly, nofree, ...) and such thread tracking to make useful deductions. This is not possible if we interleave the argmemonly/nofree/... semantics
with nosync. The above optimization is a real thing for a very common scenario on GPUs and also CPUs:

run_in_parallel {
  if (threadid == 0)
    effect();
  barrier();

  ... parallel stuff

  if (threadid == 0)
    effect();
  barrier();
 ...
}

That leaves as a single argument the complexity of inference, but how strong of an argument is that, really?

I think there are a lot of reasons to keep it separated, the examples above still stand. That said, why would
we combine it? It saves one attribute lookup?

To me the fundamental problem is having an attribute that says "calling this function doesn't free memory" on a call that does, in fact, free memory. Why would/should the caller care about whether the freeing happens in the same thread or not? I think Nuno's line of argument about separating the semantics from the implementation goes in a similar direction.

While I understand your argument it breaks a lot of things not just nofree. So if we wanted to do this it had to be way more involved or it is just inconsistent.
We had inaccessible_mem_only earlier or argmemonly. As noted before, the definition talks about the "memory operations in the function". We also do not annotate nosync
for any known builtin, etc. There is soo many things that would need to happen to do this transition in a consistent way. Instead, this picks nofree and argues it is
somewhat special even though it is not. See next paragraph.

This doesn't mean that we can't have the more structural (as opposed to semantic) attribute you want to have, but I'd be in favor of naming it more accurately, e.g. nothreadlocalfree.

Almost all our attributes are "local" not "global". They are local because we can derive them only locally in a reasonable way and some of them make sense only locally anyway as they have
an explicit scope, most often the function. Local information can be combined with call site information, e.g., in a subsequent pass or via HTO/thinLTO, to create actionable information (see
my examples in this thread and above). Making local deduction harder/impossible is not helpful as it prevents us to combine it with other information sources, e.g., domain knowledge or explicit
thread tracking.

P.S.: The example I have in mind where confusion about argmemonly can be used to trigger a miscompile is at https://godbolt.org/z/dEG8n6W3E. Current main merges the two loads from %q, which is incorrect since @setup could arrange for a second thread to be created which changes its value in between.

Agreed this is a bug. Though, it's in instcombine (or probably MemorySSA) not the Attributor. If you disagree you have to tell me which part of the argmemonly definition is violated by release: "This attribute indicates that the only memory accesses inside function are loads and stores from objects pointed to by its pointer-typed arguments, with arbitrary offsets. Or in other words, all memory operations in the function can refer to memory only using pointers based on its function arguments."

As stated above, it's at the very least the part that says there can be no other side effects. Synchronizing with another thread which then modifies other memory is surely a side effect.

The function writes pointer arguments, which is explicitly allowed in the text multiple times before it describes what it shall not do.
It writes them atomically, but that is not disallowed in any way. As I stated above, I see your point but this patch is not even close to what would be required to bake synchronization into everything. You can
read "no synchronization" into some of the lang ref wording but you have to admit argmemonly does talk about "accesses inside the function" twice and does not mention synchronization at all. Further,
you attribute the @setup side-effect to @release, so you argue that the @release function can have a side-effect on arbitrary memory including %q even though "the write to %q" is arguably not in @release.

Instead, the model that I see us using already and which we should embrace is:
@release is not nosync and therefore we can see effects at the call site that were performed by other functions with which @release synchronized.
That attributes the effect properly to the "other function", makes local deduction possible, and composes the attributes we have.

Only with such a model we can hope to build and use a "synchronizes-with graph" that compose well with other arguments.
As https://reviews.llvm.org/D106397#C2702144NL1110 shows, once we stop treating synchronization as a complete black box it is crucial the rest of the system
does not fallback to a pessimistic/unknown state if synchronization may be present.

[nhaehnle]

Quick clarification:

In D101701#2902713, @jdoerfert wrote:

Let's assume this is our entire module:

static int *X = nullptr;

int readX() { return *X; }

void foo() {
  if (!X)
    X = malloc(4);  // let it be known in the module.
}

void bar() {
  *X = 1;
  unknown_inaccessible_mem_only_but_not_nosync();   // e.g. malloc
  argmemonly_nofree_but_not_nosync(X);              // can be derived from the definition of the function and attribute can be made available through HTO or thinLTO.
  // X is still deref here because no thread could have freed it.
}

X is in the entire module deref_or_null(4) but only because we have inaccessible_mem_only (malloc) and argmemonly + nofree (definition + HTO/thinLTO).
nosync is not set for any of the functions.

You really also need nocapture on the argument of argmemonly_nofree_but_not_nosync for this to work, right?

[nhaehnle]

In D101701#2902713, @jdoerfert wrote:

Second, perhaps malloc can be nosync. I see the quote from the C standard, but it's unclear to me whether that language is good for anything other than ensuring no data races in a formal model, and surely there are other means to achieve the same goal, e.g. saying that a re-allocated portion of memory is a different memory location as far as the memory model is concerned. The only way I can see to perform meaningful synchronization through free and malloc would be to compare the result of malloc with some pointer that was allocated earlier (if they're equal, this implies that the earlier allocation was freed, and we have a synchronization edge that can be relied upon). It may be possible to make this undefined somehow, perhaps involving the non-determinism trick that is proposed for pointer provenance can be applied here as well.

You basically described the side-channel that makes malloc/free not nosync, didn't you?

T0: foo() /* nosync */; while(1) { p = malloc(); atomic_relaxed_record(p); free(p); }
T1: do { p = malloc(); found = atomic_relaxed_lookup(p); free(p); } while (!found); print("foo is done!");

I'm not sure what atomic_relaxed_record/lookup are supposed to be. If they work by dereferencing p, then no, that's not what I had in mind. I was thinking along the lines of:

Common setup: p = malloc(); x = 0
T0: { x = 1; free(p); }
T1: { while ((q = malloc()) != p) free(q); assert(x == 1) }

But maybe that's just a variation on what you had in mind. In any case, this kind of side channel is clearly ridiculous and should just be closed. I doubt many people would oppose that :)

[nhaehnle]

Finally, we started to track threads explicitly already, partially using domain knowledge, which allows us to reason about the interaction between threads
(https://reviews.llvm.org/D106397#C2702144NL1110). So even in the presence of synchronizations (atomics, barriers, etc), we can use other attributes
(argmemonly, nofree, ...) and such thread tracking to make useful deductions. This is not possible if we interleave the argmemonly/nofree/... semantics
with nosync. The above optimization is a real thing for a very common scenario on GPUs and also CPUs:

run_in_parallel {
  if (threadid == 0)
    effect();
  barrier();

  ... parallel stuff

  if (threadid == 0)
    effect();
  barrier();
 ...
}

I've been staring at this for quite some time now and I don't understand how it relates to this discussion. Can you be more explicit about which functions here have e.g. argmemonly but not nosync, and how that is used in an optimization?

[jdoerfert]

In D101701#2902884, @nhaehnle wrote:

You really also need nocapture on the argument of argmemonly_nofree_but_not_nosync for this to work, right?

yes, probably.

In D101701#2903310, @nhaehnle wrote:

Finally, we started to track threads explicitly already, partially using domain knowledge, which allows us to reason about the interaction between threads
(https://reviews.llvm.org/D106397#C2702144NL1110). So even in the presence of synchronizations (atomics, barriers, etc), we can use other attributes
(argmemonly, nofree, ...) and such thread tracking to make useful deductions. This is not possible if we interleave the argmemonly/nofree/... semantics
with nosync. The above optimization is a real thing for a very common scenario on GPUs and also CPUs:

run_in_parallel {
  if (threadid == 0)
    effect();
  barrier();

  ... parallel stuff

  if (threadid == 0)
    effect();
  barrier();
 ...
}

I've been staring at this for quite some time now and I don't understand how it relates to this discussion. Can you be more explicit about which functions here have e.g. argmemonly but not nosync, and how that is used in an optimization?

If we merge the semantics of nosync into nofree, argmemonly, etc. to make them "global" instead of local, anything that contains a barrier/atomic/volatile/convergent operation will loose those attributes. Do you agree?
Now, if we start to look at barrier/atomic/convergent in more detail, e.g., by tracking the main thread on a GPU device to basically ensure there is no concurrent access to things, we would loose out on the nofree, argmemonly, etc. attributes of the functions the main thread calls in "critical regions".
In my example, let's assume effect is called only by the main thread in the two critical regions and it contains an atomic update of a global. Backing nosync into nofree, ... will prevent us to annotate effect with such arguments as it is locally not decidable if it is always called from critical regions. We can however determine it doesn't itself call free. Later, when we determine that the call sites are in critical regions we have the nofree, ... attributes available and we can act on them.

In D101701#2902902, @nhaehnle wrote:

But maybe that's just a variation on what you had in mind. In any case, this kind of side channel is clearly ridiculous and should just be closed. I doubt many people would oppose that :)

I would not oppose it, I want it to be nosync, though I gave up on my patch. I fear that opens up security problems because the real malloc/free reuse memory while the abstract machine does not need to. Either way, this is something to keep in mind.

[nhaehnle]

In D101701#2903331, @jdoerfert wrote:

In D101701#2903310, @nhaehnle wrote:

Finally, we started to track threads explicitly already, partially using domain knowledge, which allows us to reason about the interaction between threads
(https://reviews.llvm.org/D106397#C2702144NL1110). So even in the presence of synchronizations (atomics, barriers, etc), we can use other attributes
(argmemonly, nofree, ...) and such thread tracking to make useful deductions. This is not possible if we interleave the argmemonly/nofree/... semantics
with nosync. The above optimization is a real thing for a very common scenario on GPUs and also CPUs:

run_in_parallel {
  if (threadid == 0)
    effect();
  barrier();

  ... parallel stuff

  if (threadid == 0)
    effect();
  barrier();
 ...
}

I've been staring at this for quite some time now and I don't understand how it relates to this discussion. Can you be more explicit about which functions here have e.g. argmemonly but not nosync, and how that is used in an optimization?

If we merge the semantics of nosync into nofree, argmemonly, etc. to make them "global" instead of local, anything that contains a barrier/atomic/volatile/convergent operation will loose those attributes. Do you agree?

Yes (convergent operations can be nosync, but the overall point remains).

Now, if we start to look at barrier/atomic/convergent in more detail, e.g., by tracking the main thread on a GPU device to basically ensure there is no concurrent access to things, we would loose out on the nofree, argmemonly, etc. attributes of the functions the main thread calls in "critical regions".
In my example, let's assume effect is called only by the main thread in the two critical regions and it contains an atomic update of a global. Backing nosync into nofree, ... will prevent us to annotate effect with such arguments as it is locally not decidable if it is always called from critical regions. We can however determine it doesn't itself call free. Later, when we determine that the call sites are in critical regions we have the nofree, ... attributes available and we can act on them.

Okay, I see now where you're coming from. From the caller's perspective, effect isn't nosync, so it may synchronize with some other thread. There's in general no reason why that thread has to be part of the same workgroup or wave. However:

1. One could envision a future refinement of nosync with an attribute that labels effect as not communicating outside e.g. a workgroup.

2. There are other caller-based ways in which the possible reach of synchronization could be limited. For example, if there was a way to indicate that all synchronization is tied to memory locations, and effect is argmemonly and called with an uncaptured pointer, then it can't synchronize with any thread outside of the parallel region either and the argmemonly is still useful.

So I think this a good argument in favor of having attributes like nofree and argmemonly talk only about what happens in the calling thread.

llvm/docs/LangRef.rst

``noduplicate``
 
     A function containing a ``noduplicate`` call may still
     be an inlining candidate, provided that the call is not
     duplicated by inlining. That implies that the function has
     internal linkage and only has one call site, so the original
     call is dead after inlining.
 ``nofree``
     This function attribute indicates that the function does not, directly or
-    transitively, call a memory-deallocation function (``free``, for example)
-    on a memory allocation which existed before the call.
-
-    As a result, uncaptured pointers that are known to be dereferenceable
-    prior to a call to a function with the ``nofree`` attribute are still
-    known to be dereferenceable after the call. The capturing condition is
-    necessary in environments where the function might communicate the
-    pointer to another thread which then deallocates the memory.  Alternatively,
-    ``nosync`` would ensure such communication cannot happen and even captured
-    pointers cannot be freed by the function.
+    transitively, call a memory-deallocation function (``free``, for example),
+    or cause such a function to be called by another thread, on a memory
+    allocation which existed before the call.
+
+    As a result, pointers that are known to be dereferenceable prior to a call
+    to a function with the ``nofree`` attribute are still known to be
+    dereferenceable after the call.
 
     A ``nofree`` function is explicitly allowed to free memory which it
-    allocated or (if not ``nosync``) arrange for another thread to free
-    memory on it's behalf.  As a result, perhaps surprisingly, a ``nofree``
-    function can return a pointer to a previously deallocated memory object.
+    allocated.  As a result, perhaps surprisingly, a ``nofree`` function can
+    return a pointer to a previously deallocated memory object.
 ``noimplicitfloat``
     This attributes disables implicit floating-point instructions.
 ``noinline``
     This attribute indicates that the inliner should never inline this
     function in any situation. This attribute may not be used together
     with the ``alwaysinline`` attribute.
 ``nomerge``
     This attribute indicates that calls to this function should never be merged

llvm/lib/IR/Value.cpp

 //===-- Value.cpp - Implement the Value class -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (auto *A = dyn_cast<Argument>(this)) {
     if (A->hasPointeeInMemoryValueAttr())
       return false;
     // A pointer to an object in a function which neither frees, nor can arrange
     // for another thread to free on its behalf, can not be freed in the scope
     // of the function.  Note that this logic is restricted to memory
     // allocations in existance before the call; a nofree function *is* allowed
     // to free memory it allocated.
     const Function *F = A->getParent();
-    if (F->doesNotFreeMemory() && F->hasNoSync())
+    if (F->doesNotFreeMemory())
       return false;
   }
 
   const Function *F = nullptr;
   if (auto *I = dyn_cast<Instruction>(this))
     F = I->getFunction();
   if (auto *A = dyn_cast<Argument>(this))
     F = A->getParent();

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

 //===- AttributorAttributes.cpp - Attributes for Attributor deduction -----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
struct AANoSyncImpl : AANoSync {
 
   const std::string getAsStr() const override {
     return getAssumed() ? "nosync" : "may-sync";
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override;
 
-  /// Helper function used to determine whether an instruction is non-relaxed
-  /// atomic. In other words, if an atomic instruction does not have unordered
-  /// or monotonic ordering
-  static bool isNonRelaxedAtomic(Instruction *I);
-
   /// Helper function specific for intrinsics which are potentially volatile
   static bool isNoSyncIntrinsic(Instruction *I);
 };
 
-bool AANoSyncImpl::isNonRelaxedAtomic(Instruction *I) {
+static bool isNonRelaxedAtomic(Instruction *I) {
   if (!I->isAtomic())
     return false;
 
   if (auto *FI = dyn_cast<FenceInst>(I))
     // All legal orderings for fence are stronger than monotonic.
     return FI->getSyncScopeID() != SyncScope::SingleThread;
   else if (auto *AI = dyn_cast<AtomicCmpXchgInst>(I)) {
     // Unordered is not a legal ordering for cmpxchg.
struct AANoSyncCallSite final : AANoSyncImpl {
   void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(nosync); }
 };
 
 /// ------------------------ No-Free Attributes ----------------------------
 
 struct AANoFreeImpl : public AANoFree {
   AANoFreeImpl(const IRPosition &IRP, Attributor &A) : AANoFree(IRP, A) {}
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     auto CheckForNoFree = [&](Instruction &I) {
       const auto &CB = cast<CallBase>(I);
       if (CB.hasFnAttr(Attribute::NoFree))
         return true;
 
       const auto &NoFreeAA = A.getAAFor<AANoFree>(
           *this, IRPosition::callsite_function(CB), DepClassTy::REQUIRED);
       return NoFreeAA.isAssumedNoFree();
     };
 
-    if (!A.checkForAllCallLikeInstructions(CheckForNoFree, *this))
+    auto CheckForNoRemoteFree = [&](Instruction &I) {
+      if (I.isVolatile() || isNonRelaxedAtomic(&I))
+        return false;
+
+      return true;
+    };
+
+    if (!A.checkForAllCallLikeInstructions(CheckForNoFree, *this) ||
+        !A.checkForAllReadWriteInstructions(CheckForNoRemoteFree, *this))
       return indicatePessimisticFixpoint();
     return ChangeStatus::UNCHANGED;
   }
 
   /// See AbstractAttribute::getAsStr().
   const std::string getAsStr() const override {
     return getAssumed() ? "nofree" : "may-free";
   }
 };
 
 struct AANoFreeFunction final : public AANoFreeImpl {
   AANoFreeFunction(const IRPosition &IRP, Attributor &A)
       : AANoFreeImpl(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(nofree) }
 };
 
 /// NoFree attribute deduction for a call sites.
 struct AANoFreeCallSite final : AANoFreeImpl {
   AANoFreeCallSite(const IRPosition &IRP, Attributor &A)
       : AANoFreeImpl(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     AANoFreeImpl::initialize(A);
     Function *F = getAssociatedFunction();
     if (!F || F->isDeclaration())
       indicatePessimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(...).

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

 //===- FunctionAttrs.cpp - Pass which marks functions attributes ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 
 struct SCCNodesResult {
   SCCNodeSet SCCNodes;
   bool HasUnknownCall;
 };
 
 } // end anonymous namespace
 
+// Return true if this is an atomic which has an ordering stronger than
+// unordered.  Note that this is different than the predicate we use in
+// Attributor.  Here we chose to be conservative and consider monotonic
+// operations potentially synchronizing.  We generally don't do much with
+// monotonic operations, so this is simply risk reduction.
+static bool isOrderedAtomic(Instruction *I) {
+  if (!I->isAtomic())
+    return false;
+
+  if (auto *FI = dyn_cast<FenceInst>(I))
+    // All legal orderings for fence are stronger than monotonic.
+    return FI->getSyncScopeID() != SyncScope::SingleThread;
+  else if (isa<AtomicCmpXchgInst>(I) || isa<AtomicRMWInst>(I))
+    return true;
+  else if (auto *SI = dyn_cast<StoreInst>(I))
+    return !SI->isUnordered();
+  else if (auto *LI = dyn_cast<LoadInst>(I))
+    return !LI->isUnordered();
+  else {
+    llvm_unreachable("unknown atomic instruction?");
+  }
+}
+
 /// Helper for non-Convergent inference predicate InstrBreaksAttribute.
 static bool InstrBreaksNonConvergent(Instruction &I,
                                      const SCCNodeSet &SCCNodes) {
   const CallBase *CB = dyn_cast<CallBase>(&I);
   // Breaks non-convergent assumption if CS is a convergent call to a function
   // not in the SCC.
   return CB && CB->isConvergent() &&
          SCCNodes.count(CB->getCalledFunction()) == 0;
if (Function *Callee = CI->getCalledFunction()) {
         return false;
     }
   }
   return true;
 }
 
 /// Helper for NoFree inference predicate InstrBreaksAttribute.
 static bool InstrBreaksNoFree(Instruction &I, const SCCNodeSet &SCCNodes) {
-  CallBase *CB = dyn_cast<CallBase>(&I);
-  if (!CB)
-    return false;
+  if (I.isVolatile())
+    return true;
+
+  if (isOrderedAtomic(&I))
+    return true;
 
+  if (CallBase *CB = dyn_cast<CallBase>(&I)) {
     if (CB->hasFnAttr(Attribute::NoFree))
       return false;
 
     // Speculatively assume in SCC.
     if (Function *Callee = CB->getCalledFunction())
       if (SCCNodes.contains(Callee))
         return false;
 
     return true;
   }
 
+  return false;
+}
+
 /// Attempt to remove convergent function attribute when possible.
 ///
 /// Returns true if any changes to function attributes were made.
 static bool inferConvergent(const SCCNodeSet &SCCNodes) {
   AttributeInferer AI;
 
   // Request to remove the convergent attribute from all functions in the SCC
   // if every callsite within the SCC is not convergent (except for calls
for (Function *F : SCCNodes) {
     F->setWillReturn();
     NumWillReturn++;
     Changed = true;
   }
 
   return Changed;
 }
 
-// Return true if this is an atomic which has an ordering stronger than
-// unordered.  Note that this is different than the predicate we use in
-// Attributor.  Here we chose to be conservative and consider monotonic
-// operations potentially synchronizing.  We generally don't do much with
-// monotonic operations, so this is simply risk reduction.
-static bool isOrderedAtomic(Instruction *I) {
-  if (!I->isAtomic())
-    return false;
-
-  if (auto *FI = dyn_cast<FenceInst>(I))
-    // All legal orderings for fence are stronger than monotonic.
-    return FI->getSyncScopeID() != SyncScope::SingleThread;
-  else if (isa<AtomicCmpXchgInst>(I) || isa<AtomicRMWInst>(I))
-    return true;
-  else if (auto *SI = dyn_cast<StoreInst>(I))
-    return !SI->isUnordered();
-  else if (auto *LI = dyn_cast<LoadInst>(I))
-    return !LI->isUnordered();
-  else {
-    llvm_unreachable("unknown atomic instruction?");
-  }
-}
-
 static bool InstrBreaksNoSync(Instruction &I, const SCCNodeSet &SCCNodes) {
   // Volatile may synchronize
   if (I.isVolatile())
     return true;
 
   // An ordered atomic may synchronize.  (See comment about on monotonic.)
   if (isOrderedAtomic(&I))
     return true;

llvm/test/Analysis/ValueTracking/memory-dereferenceable.ll

 ; CHECK: %p
 define void @infer_func_attrs1(i32* dereferenceable(8) %p) nofree nosync {
   call void @mayfree()
   %v = load i32, i32* %p
   ret void
 }
 
 ; CHECK-LABEL: 'infer_func_attrs2'
-; GLOBAL: %p
-; POINT-NOT: %p
-; FIXME: Can be inferred from attributes
+; CHECK: %p
 define void @infer_func_attrs2(i32* dereferenceable(8) %p) readonly {
   call void @mayfree()
   %v = load i32, i32* %p
   ret void
 }
 
 ; CHECK-LABEL: 'infer_noalias1'
 ; GLOBAL: %p

llvm/test/Transforms/Attributor/dereferenceable-2-inseltpoison.ll

 exit:
   ret void
 }
 
 ; The volatile load can't be used to prove a non-volatile access is allowed.
 ; The 2nd and 3rd loads may never execute.
 
 define void @volatile_is_not_dereferenceable(i16* %ptr) {
-; IS__TUNIT____: Function Attrs: argmemonly nofree nounwind willreturn
+; IS__TUNIT____: Function Attrs: argmemonly nounwind willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@volatile_is_not_dereferenceable
-; IS__TUNIT____-SAME: (i16* nofree align 2 [[PTR:%.*]]) #[[ATTR3:[0-9]+]] {
+; IS__TUNIT____-SAME: (i16* align 2 [[PTR:%.*]]) #[[ATTR3:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i16, i16* [[PTR]], i64 0
 ; IS__TUNIT____-NEXT:    [[T0:%.*]] = load volatile i16, i16* [[ARRAYIDX0]], align 2
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nounwind willreturn
+; IS__CGSCC____: Function Attrs: argmemonly norecurse nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@volatile_is_not_dereferenceable
-; IS__CGSCC____-SAME: (i16* nofree align 2 [[PTR:%.*]]) #[[ATTR3:[0-9]+]] {
+; IS__CGSCC____-SAME: (i16* align 2 [[PTR:%.*]]) #[[ATTR3:[0-9]+]] {
 ; IS__CGSCC____-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i16, i16* [[PTR]], i64 0
 ; IS__CGSCC____-NEXT:    [[T0:%.*]] = load volatile i16, i16* [[ARRAYIDX0]], align 2
 ; IS__CGSCC____-NEXT:    ret void
 ;
   %arrayidx0 = getelementptr i16, i16* %ptr, i64 0
   %arrayidx1 = getelementptr i16, i16* %ptr, i64 1
   %arrayidx2 = getelementptr i16, i16* %ptr, i64 2
   %t0 = load volatile i16, i16* %arrayidx0
l7:
   br label %end
 end:
   ret i32 1
 }
 ;.
 ; IS__TUNIT____: attributes #[[ATTR0]] = { argmemonly nofree nosync nounwind readonly willreturn }
 ; IS__TUNIT____: attributes #[[ATTR1]] = { argmemonly nofree nosync nounwind willreturn }
 ; IS__TUNIT____: attributes #[[ATTR2]] = { nofree nosync nounwind readnone willreturn }
-; IS__TUNIT____: attributes #[[ATTR3]] = { argmemonly nofree nounwind willreturn }
+; IS__TUNIT____: attributes #[[ATTR3]] = { argmemonly nounwind willreturn }
 ; IS__TUNIT____: attributes #[[ATTR4]] = { argmemonly nofree nosync nounwind willreturn writeonly }
 ;.
 ; IS__CGSCC____: attributes #[[ATTR0]] = { argmemonly nofree norecurse nosync nounwind readonly willreturn }
 ; IS__CGSCC____: attributes #[[ATTR1]] = { argmemonly nofree norecurse nosync nounwind willreturn }
 ; IS__CGSCC____: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind readnone willreturn }
-; IS__CGSCC____: attributes #[[ATTR3]] = { argmemonly nofree norecurse nounwind willreturn }
+; IS__CGSCC____: attributes #[[ATTR3]] = { argmemonly norecurse nounwind willreturn }
 ; IS__CGSCC____: attributes #[[ATTR4]] = { argmemonly nofree norecurse nosync nounwind willreturn writeonly }
 ;.

llvm/test/Transforms/Attributor/dereferenceable-2.ll

 exit:
   ret void
 }
 
 ; The volatile load can't be used to prove a non-volatile access is allowed.
 ; The 2nd and 3rd loads may never execute.
 
 define void @volatile_is_not_dereferenceable(i16* %ptr) {
-; IS__TUNIT____: Function Attrs: argmemonly nofree nounwind willreturn
+; IS__TUNIT____: Function Attrs: argmemonly nounwind willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@volatile_is_not_dereferenceable
-; IS__TUNIT____-SAME: (i16* nofree align 2 [[PTR:%.*]]) #[[ATTR3:[0-9]+]] {
+; IS__TUNIT____-SAME: (i16* align 2 [[PTR:%.*]]) #[[ATTR3:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i16, i16* [[PTR]], i64 0
 ; IS__TUNIT____-NEXT:    [[T0:%.*]] = load volatile i16, i16* [[ARRAYIDX0]], align 2
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nounwind willreturn
+; IS__CGSCC____: Function Attrs: argmemonly norecurse nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@volatile_is_not_dereferenceable
-; IS__CGSCC____-SAME: (i16* nofree align 2 [[PTR:%.*]]) #[[ATTR3:[0-9]+]] {
+; IS__CGSCC____-SAME: (i16* align 2 [[PTR:%.*]]) #[[ATTR3:[0-9]+]] {
 ; IS__CGSCC____-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i16, i16* [[PTR]], i64 0
 ; IS__CGSCC____-NEXT:    [[T0:%.*]] = load volatile i16, i16* [[ARRAYIDX0]], align 2
 ; IS__CGSCC____-NEXT:    ret void
 ;
   %arrayidx0 = getelementptr i16, i16* %ptr, i64 0
   %arrayidx1 = getelementptr i16, i16* %ptr, i64 1
   %arrayidx2 = getelementptr i16, i16* %ptr, i64 2
   %t0 = load volatile i16, i16* %arrayidx0
l7:
   br label %end
 end:
   ret i32 1
 }
 ;.
 ; IS__TUNIT____: attributes #[[ATTR0]] = { argmemonly nofree nosync nounwind readonly willreturn }
 ; IS__TUNIT____: attributes #[[ATTR1]] = { argmemonly nofree nosync nounwind willreturn }
 ; IS__TUNIT____: attributes #[[ATTR2]] = { nofree nosync nounwind readnone willreturn }
-; IS__TUNIT____: attributes #[[ATTR3]] = { argmemonly nofree nounwind willreturn }
+; IS__TUNIT____: attributes #[[ATTR3]] = { argmemonly nounwind willreturn }
 ; IS__TUNIT____: attributes #[[ATTR4]] = { argmemonly nofree nosync nounwind willreturn writeonly }
 ;.
 ; IS__CGSCC____: attributes #[[ATTR0]] = { argmemonly nofree norecurse nosync nounwind readonly willreturn }
 ; IS__CGSCC____: attributes #[[ATTR1]] = { argmemonly nofree norecurse nosync nounwind willreturn }
 ; IS__CGSCC____: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind readnone willreturn }
-; IS__CGSCC____: attributes #[[ATTR3]] = { argmemonly nofree norecurse nounwind willreturn }
+; IS__CGSCC____: attributes #[[ATTR3]] = { argmemonly norecurse nounwind willreturn }
 ; IS__CGSCC____: attributes #[[ATTR4]] = { argmemonly nofree norecurse nosync nounwind willreturn writeonly }
 ;.

llvm/test/Transforms/Attributor/liveness.ll

; <label>:5:                                      ; preds = %1, %5
   %7 = phi i32 [ %8, %5 ], [ 1, %1 ]
   %8 = mul nsw i32 %6, %7
   %9 = add nuw nsw i32 %6, 1
   %10 = icmp eq i32 %6, %0
   br i1 %10, label %3, label %5
 }
 
 define i32 @volatile_load(i32*) norecurse nounwind uwtable {
-; NOT_CGSCC_NPM: Function Attrs: argmemonly nofree norecurse nounwind uwtable willreturn
+; NOT_CGSCC_NPM: Function Attrs: argmemonly norecurse nounwind uwtable willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@volatile_load
-; NOT_CGSCC_NPM-SAME: (i32* nofree align 4 [[TMP0:%.*]]) #[[ATTR6:[0-9]+]] {
+; NOT_CGSCC_NPM-SAME: (i32* align 4 [[TMP0:%.*]]) #[[ATTR6:[0-9]+]] {
 ; NOT_CGSCC_NPM-NEXT:    [[TMP2:%.*]] = load volatile i32, i32* [[TMP0]], align 4
 ; NOT_CGSCC_NPM-NEXT:    ret i32 [[TMP2]]
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nounwind uwtable willreturn
+; IS__CGSCC____: Function Attrs: argmemonly norecurse nounwind uwtable willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@volatile_load
-; IS__CGSCC____-SAME: (i32* nofree align 4 [[TMP0:%.*]]) #[[ATTR7:[0-9]+]] {
+; IS__CGSCC____-SAME: (i32* align 4 [[TMP0:%.*]]) #[[ATTR7:[0-9]+]] {
 ; IS__CGSCC____-NEXT:    [[TMP2:%.*]] = load volatile i32, i32* [[TMP0]], align 4
 ; IS__CGSCC____-NEXT:    ret i32 [[TMP2]]
 ;
   %2 = load volatile i32, i32* %0, align 4
   ret i32 %2
 }
 
 define internal i32 @internal_load(i32*) norecurse nounwind uwtable {

 declare void @llvm.lifetime.end.p0i8(i64 %0, i8* %1)
 ;.
 ; NOT_CGSCC_NPM: attributes #[[ATTR0]] = { nofree noreturn nosync nounwind }
 ; NOT_CGSCC_NPM: attributes #[[ATTR1:[0-9]+]] = { readnone }
 ; NOT_CGSCC_NPM: attributes #[[ATTR2]] = { nounwind }
 ; NOT_CGSCC_NPM: attributes #[[ATTR3]] = { noreturn nounwind }
 ; NOT_CGSCC_NPM: attributes #[[ATTR4]] = { noreturn }
 ; NOT_CGSCC_NPM: attributes #[[ATTR5]] = { nosync readnone }
-; NOT_CGSCC_NPM: attributes #[[ATTR6]] = { argmemonly nofree norecurse nounwind uwtable willreturn }
+; NOT_CGSCC_NPM: attributes #[[ATTR6]] = { argmemonly norecurse nounwind uwtable willreturn }
 ; NOT_CGSCC_NPM: attributes #[[ATTR7]] = { nosync }
 ; NOT_CGSCC_NPM: attributes #[[ATTR8]] = { argmemonly nofree nosync nounwind willreturn writeonly }
 ; NOT_CGSCC_NPM: attributes #[[ATTR9]] = { nofree noreturn nosync nounwind readnone }
 ; NOT_CGSCC_NPM: attributes #[[ATTR10]] = { nofree noreturn nosync nounwind readnone willreturn }
 ; NOT_CGSCC_NPM: attributes #[[ATTR11]] = { nofree nosync nounwind willreturn }
 ; NOT_CGSCC_NPM: attributes #[[ATTR12]] = { nofree nosync nounwind readnone willreturn }
 ; NOT_CGSCC_NPM: attributes #[[ATTR13:[0-9]+]] = { argmemonly nofree nosync nounwind willreturn }
 ; NOT_CGSCC_NPM: attributes #[[ATTR14]] = { nounwind willreturn }
 ; NOT_CGSCC_NPM: attributes #[[ATTR15]] = { willreturn }
 ;.
 ; IS__CGSCC____: attributes #[[ATTR0]] = { nofree noreturn nosync nounwind }
 ; IS__CGSCC____: attributes #[[ATTR1:[0-9]+]] = { readnone }
 ; IS__CGSCC____: attributes #[[ATTR2]] = { nounwind }
 ; IS__CGSCC____: attributes #[[ATTR3]] = { noreturn nounwind }
 ; IS__CGSCC____: attributes #[[ATTR4]] = { noreturn }
 ; IS__CGSCC____: attributes #[[ATTR5]] = { nosync readnone }
 ; IS__CGSCC____: attributes #[[ATTR6]] = { nofree norecurse nosync nounwind readnone willreturn }
-; IS__CGSCC____: attributes #[[ATTR7]] = { argmemonly nofree norecurse nounwind uwtable willreturn }
+; IS__CGSCC____: attributes #[[ATTR7]] = { argmemonly norecurse nounwind uwtable willreturn }
 ; IS__CGSCC____: attributes #[[ATTR8]] = { nofree norecurse nosync nounwind readnone uwtable willreturn }
 ; IS__CGSCC____: attributes #[[ATTR9]] = { nosync }
 ; IS__CGSCC____: attributes #[[ATTR10]] = { argmemonly nofree norecurse nosync nounwind willreturn writeonly }
 ; IS__CGSCC____: attributes #[[ATTR11]] = { nofree norecurse noreturn nosync nounwind readnone }
 ; IS__CGSCC____: attributes #[[ATTR12]] = { nofree norecurse noreturn nosync nounwind readnone willreturn }
 ; IS__CGSCC____: attributes #[[ATTR13]] = { nofree nosync nounwind willreturn }
 ; IS__CGSCC____: attributes #[[ATTR14]] = { nofree norecurse nosync nounwind readnone }
 ; IS__CGSCC____: attributes #[[ATTR15]] = { nofree nosync nounwind readnone willreturn }
 ; IS__CGSCC____: attributes #[[ATTR16:[0-9]+]] = { argmemonly nofree nosync nounwind willreturn }
 ; IS__CGSCC____: attributes #[[ATTR17]] = { nounwind willreturn }
 ; IS__CGSCC____: attributes #[[ATTR18]] = { willreturn }
 ;.

llvm/test/Transforms/Attributor/nocapture-1.ll

 ; CHECK-NEXT:    ret void
 ;
   call void (i8*, i8*, ...) @test6_1(i8* %x6_2, i8* %y6_2, i8* %z6_2)
   store i32* null, i32** @g
   ret void
 }
 
 define void @test_cmpxchg(i32* %p) {
-; IS__TUNIT____: Function Attrs: argmemonly nofree nounwind willreturn
+; IS__TUNIT____: Function Attrs: argmemonly nounwind willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test_cmpxchg
-; IS__TUNIT____-SAME: (i32* nocapture nofree noundef nonnull dereferenceable(4) [[P:%.*]]) #[[ATTR9:[0-9]+]] {
+; IS__TUNIT____-SAME: (i32* nocapture noundef nonnull dereferenceable(4) [[P:%.*]]) #[[ATTR9:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    [[TMP1:%.*]] = cmpxchg i32* [[P]], i32 0, i32 1 acquire monotonic, align 4
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nounwind willreturn
+; IS__CGSCC____: Function Attrs: argmemonly norecurse nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@test_cmpxchg
-; IS__CGSCC____-SAME: (i32* nocapture nofree noundef nonnull dereferenceable(4) [[P:%.*]]) #[[ATTR9:[0-9]+]] {
+; IS__CGSCC____-SAME: (i32* nocapture noundef nonnull dereferenceable(4) [[P:%.*]]) #[[ATTR9:[0-9]+]] {
 ; IS__CGSCC____-NEXT:    [[TMP1:%.*]] = cmpxchg i32* [[P]], i32 0, i32 1 acquire monotonic, align 4
 ; IS__CGSCC____-NEXT:    ret void
 ;
   cmpxchg i32* %p, i32 0, i32 1 acquire monotonic
   ret void
 }
 
 define void @test_cmpxchg_ptr(i32** %p, i32* %q) {
-; IS__TUNIT____: Function Attrs: argmemonly nofree nounwind willreturn
+; IS__TUNIT____: Function Attrs: argmemonly nounwind willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test_cmpxchg_ptr
-; IS__TUNIT____-SAME: (i32** nocapture nofree noundef nonnull dereferenceable(8) [[P:%.*]], i32* nofree [[Q:%.*]]) #[[ATTR9]] {
+; IS__TUNIT____-SAME: (i32** nocapture noundef nonnull dereferenceable(8) [[P:%.*]], i32* [[Q:%.*]]) #[[ATTR9]] {
 ; IS__TUNIT____-NEXT:    [[TMP1:%.*]] = cmpxchg i32** [[P]], i32* null, i32* [[Q]] acquire monotonic, align 8
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nounwind willreturn
+; IS__CGSCC____: Function Attrs: argmemonly norecurse nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@test_cmpxchg_ptr
-; IS__CGSCC____-SAME: (i32** nocapture nofree noundef nonnull dereferenceable(8) [[P:%.*]], i32* nofree [[Q:%.*]]) #[[ATTR9]] {
+; IS__CGSCC____-SAME: (i32** nocapture noundef nonnull dereferenceable(8) [[P:%.*]], i32* [[Q:%.*]]) #[[ATTR9]] {
 ; IS__CGSCC____-NEXT:    [[TMP1:%.*]] = cmpxchg i32** [[P]], i32* null, i32* [[Q]] acquire monotonic, align 8
 ; IS__CGSCC____-NEXT:    ret void
 ;
   cmpxchg i32** %p, i32* null, i32* %q acquire monotonic
   ret void
 }
 
 define void @test_atomicrmw(i32* %p) {
-; IS__TUNIT____: Function Attrs: argmemonly nofree nounwind willreturn
+; IS__TUNIT____: Function Attrs: argmemonly nounwind willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test_atomicrmw
-; IS__TUNIT____-SAME: (i32* nocapture nofree noundef nonnull dereferenceable(4) [[P:%.*]]) #[[ATTR9]] {
+; IS__TUNIT____-SAME: (i32* nocapture noundef nonnull dereferenceable(4) [[P:%.*]]) #[[ATTR9]] {
 ; IS__TUNIT____-NEXT:    [[TMP1:%.*]] = atomicrmw add i32* [[P]], i32 1 seq_cst, align 4
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nounwind willreturn
+; IS__CGSCC____: Function Attrs: argmemonly norecurse nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@test_atomicrmw
-; IS__CGSCC____-SAME: (i32* nocapture nofree noundef nonnull dereferenceable(4) [[P:%.*]]) #[[ATTR9]] {
+; IS__CGSCC____-SAME: (i32* nocapture noundef nonnull dereferenceable(4) [[P:%.*]]) #[[ATTR9]] {
 ; IS__CGSCC____-NEXT:    [[TMP1:%.*]] = atomicrmw add i32* [[P]], i32 1 seq_cst, align 4
 ; IS__CGSCC____-NEXT:    ret void
 ;
   atomicrmw add i32* %p, i32 1 seq_cst
   ret void
 }
 
 define void @test_volatile(i32* %x) {
-; IS__TUNIT____: Function Attrs: argmemonly nofree nounwind willreturn
+; IS__TUNIT____: Function Attrs: argmemonly nounwind willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test_volatile
-; IS__TUNIT____-SAME: (i32* nofree align 4 [[X:%.*]]) #[[ATTR9]] {
+; IS__TUNIT____-SAME: (i32* align 4 [[X:%.*]]) #[[ATTR9]] {
 ; IS__TUNIT____-NEXT:  entry:
 ; IS__TUNIT____-NEXT:    [[GEP:%.*]] = getelementptr i32, i32* [[X]], i64 1
 ; IS__TUNIT____-NEXT:    store volatile i32 0, i32* [[GEP]], align 4
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nounwind willreturn
+; IS__CGSCC____: Function Attrs: argmemonly norecurse nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@test_volatile
-; IS__CGSCC____-SAME: (i32* nofree align 4 [[X:%.*]]) #[[ATTR9]] {
+; IS__CGSCC____-SAME: (i32* align 4 [[X:%.*]]) #[[ATTR9]] {
 ; IS__CGSCC____-NEXT:  entry:
 ; IS__CGSCC____-NEXT:    [[GEP:%.*]] = getelementptr i32, i32* [[X]], i64 1
 ; IS__CGSCC____-NEXT:    store volatile i32 0, i32* [[GEP]], align 4
 ; IS__CGSCC____-NEXT:    ret void
 ;
 entry:
   %gep = getelementptr i32, i32* %x, i64 1
   store volatile i32 0, i32* %gep, align 4

 ; IS__TUNIT____: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn writeonly }
 ; IS__TUNIT____: attributes #[[ATTR2]] = { nofree nosync nounwind readonly willreturn }
 ; IS__TUNIT____: attributes #[[ATTR3]] = { readonly }
 ; IS__TUNIT____: attributes #[[ATTR4]] = { nounwind readonly }
 ; IS__TUNIT____: attributes #[[ATTR5]] = { nofree nosync nounwind willreturn }
 ; IS__TUNIT____: attributes #[[ATTR6]] = { argmemonly nounwind }
 ; IS__TUNIT____: attributes #[[ATTR7]] = { nofree nosync nounwind writeonly }
 ; IS__TUNIT____: attributes #[[ATTR8]] = { nofree noreturn nosync nounwind readnone willreturn }
-; IS__TUNIT____: attributes #[[ATTR9]] = { argmemonly nofree nounwind willreturn }
+; IS__TUNIT____: attributes #[[ATTR9]] = { argmemonly nounwind willreturn }
 ; IS__TUNIT____: attributes #[[ATTR10]] = { nofree nosync nounwind null_pointer_is_valid readnone willreturn }
 ; IS__TUNIT____: attributes #[[ATTR11:[0-9]+]] = { nounwind readonly willreturn }
 ; IS__TUNIT____: attributes #[[ATTR12]] = { nounwind willreturn }
 ; IS__TUNIT____: attributes #[[ATTR13:[0-9]+]] = { inaccessiblememonly nofree nosync nounwind speculatable willreturn }
 ; IS__TUNIT____: attributes #[[ATTR14:[0-9]+]] = { nofree nosync nounwind readnone speculatable willreturn }
 ; IS__TUNIT____: attributes #[[ATTR15]] = { nofree nounwind readnone willreturn }
 ; IS__TUNIT____: attributes #[[ATTR16]] = { nounwind }
 ; IS__TUNIT____: attributes #[[ATTR17]] = { willreturn }
 ; IS__TUNIT____: attributes #[[ATTR18]] = { readnone willreturn }
 ;.
 ; IS__CGSCC____: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind readnone willreturn }
 ; IS__CGSCC____: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn writeonly }
 ; IS__CGSCC____: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind readonly willreturn }
 ; IS__CGSCC____: attributes #[[ATTR3]] = { readonly }
 ; IS__CGSCC____: attributes #[[ATTR4]] = { nounwind readonly }
 ; IS__CGSCC____: attributes #[[ATTR5]] = { nofree norecurse nosync nounwind willreturn }
 ; IS__CGSCC____: attributes #[[ATTR6]] = { argmemonly nounwind }
 ; IS__CGSCC____: attributes #[[ATTR7]] = { nofree nosync nounwind writeonly }
 ; IS__CGSCC____: attributes #[[ATTR8]] = { nofree norecurse noreturn nosync nounwind readnone willreturn }
-; IS__CGSCC____: attributes #[[ATTR9]] = { argmemonly nofree norecurse nounwind willreturn }
+; IS__CGSCC____: attributes #[[ATTR9]] = { argmemonly norecurse nounwind willreturn }
 ; IS__CGSCC____: attributes #[[ATTR10]] = { nofree nosync nounwind willreturn }
 ; IS__CGSCC____: attributes #[[ATTR11]] = { nofree nosync nounwind willreturn writeonly }
 ; IS__CGSCC____: attributes #[[ATTR12]] = { nofree norecurse nosync nounwind null_pointer_is_valid readnone willreturn }
 ; IS__CGSCC____: attributes #[[ATTR13:[0-9]+]] = { nounwind readonly willreturn }
 ; IS__CGSCC____: attributes #[[ATTR14]] = { nounwind willreturn }
 ; IS__CGSCC____: attributes #[[ATTR15:[0-9]+]] = { inaccessiblememonly nofree nosync nounwind speculatable willreturn }
 ; IS__CGSCC____: attributes #[[ATTR16:[0-9]+]] = { nofree nosync nounwind readnone speculatable willreturn }
 ; IS__CGSCC____: attributes #[[ATTR17]] = { nounwind willreturn writeonly }
 ; IS__CGSCC____: attributes #[[ATTR18]] = { readnone willreturn }
 ; IS__CGSCC____: attributes #[[ATTR19]] = { nounwind }
 ; IS__CGSCC____: attributes #[[ATTR20]] = { willreturn }
 ;.

llvm/test/Transforms/Attributor/nofree.ll

;
   tail call float @llvm.floor.f32(float %a)
   ret void
 }
 
 define float @call_floor2(float %a) #0 {
 ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@call_floor2
 ; IS__TUNIT____-SAME: (float [[A:%.*]]) #[[ATTR3]] {
-; IS__TUNIT____-NEXT:    [[C:%.*]] = tail call float @llvm.floor.f32(float [[A]]) #[[ATTR13:[0-9]+]]
+; IS__TUNIT____-NEXT:    [[C:%.*]] = tail call float @llvm.floor.f32(float [[A]]) #[[ATTR14:[0-9]+]]
 ; IS__TUNIT____-NEXT:    ret float [[C]]
 ;
 ; IS__CGSCC____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@call_floor2
 ; IS__CGSCC____-SAME: (float [[A:%.*]]) #[[ATTR7:[0-9]+]] {
-; IS__CGSCC____-NEXT:    [[C:%.*]] = tail call float @llvm.floor.f32(float [[A]]) #[[ATTR14:[0-9]+]]
+; IS__CGSCC____-NEXT:    [[C:%.*]] = tail call float @llvm.floor.f32(float [[A]]) #[[ATTR15:[0-9]+]]
 ; IS__CGSCC____-NEXT:    ret float [[C]]
 ;
   %c = tail call float @llvm.floor.f32(float %a)
   ret float %c
 }
 
 ; TEST 11 (positive case)
 ; Check propagation.

 ; CHECK-SAME: (i8* nocapture [[TMP0:%.*]], i8* nocapture nofree readnone [[TMP1:%.*]]) #[[ATTR0]] {
 ; CHECK-NEXT:    tail call void @free(i8* nocapture [[TMP0]]) #[[ATTR0]]
 ; CHECK-NEXT:    ret void
 ;
   tail call void @free(i8* %0) #1
   ret void
 }
 
-; TEST 15: Use an acquire atomic (positive)
+; TEST 15: Use an acquire atomic (negative)
 define void @test15(i8* %p) {
-; IS__TUNIT____: Function Attrs: argmemonly nofree nounwind willreturn
+; IS__TUNIT____: Function Attrs: argmemonly nounwind willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test15
-; IS__TUNIT____-SAME: (i8* nocapture nofree noundef nonnull dereferenceable(1) [[P:%.*]]) #[[ATTR9:[0-9]+]] {
+; IS__TUNIT____-SAME: (i8* nocapture noundef nonnull dereferenceable(1) [[P:%.*]]) #[[ATTR9:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    [[X:%.*]] = atomicrmw add i8* [[P]], i8 1 acquire, align 1
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nounwind willreturn
+; IS__CGSCC____: Function Attrs: argmemonly norecurse nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@test15
-; IS__CGSCC____-SAME: (i8* nocapture nofree noundef nonnull dereferenceable(1) [[P:%.*]]) #[[ATTR10:[0-9]+]] {
+; IS__CGSCC____-SAME: (i8* nocapture noundef nonnull dereferenceable(1) [[P:%.*]]) #[[ATTR10:[0-9]+]] {
 ; IS__CGSCC____-NEXT:    [[X:%.*]] = atomicrmw add i8* [[P]], i8 1 acquire, align 1
 ; IS__CGSCC____-NEXT:    ret void
 ;
   %x = atomicrmw add i8* %p, i8 1 acquire
   ret void
 }
 
-; TEST 16: Use a release atomic (positive)
-; TODO: Should this be negative? See discussion on https://reviews.llvm.org/D100676
-; and https://reviews.llvm.org/D101701.
+; TEST 16: Use a release atomic (negative)
 define void @test16(i8* %p) {
-; IS__TUNIT____: Function Attrs: argmemonly nofree nounwind willreturn
+; IS__TUNIT____: Function Attrs: argmemonly nounwind willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test16
-; IS__TUNIT____-SAME: (i8* nocapture nofree noundef nonnull dereferenceable(1) [[P:%.*]]) #[[ATTR9]] {
+; IS__TUNIT____-SAME: (i8* nocapture noundef nonnull dereferenceable(1) [[P:%.*]]) #[[ATTR9]] {
 ; IS__TUNIT____-NEXT:    [[X:%.*]] = atomicrmw add i8* [[P]], i8 1 release, align 1
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nounwind willreturn
+; IS__CGSCC____: Function Attrs: argmemonly norecurse nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@test16
-; IS__CGSCC____-SAME: (i8* nocapture nofree noundef nonnull dereferenceable(1) [[P:%.*]]) #[[ATTR10]] {
+; IS__CGSCC____-SAME: (i8* nocapture noundef nonnull dereferenceable(1) [[P:%.*]]) #[[ATTR10]] {
 ; IS__CGSCC____-NEXT:    [[X:%.*]] = atomicrmw add i8* [[P]], i8 1 release, align 1
 ; IS__CGSCC____-NEXT:    ret void
 ;
   %x = atomicrmw add i8* %p, i8 1 release
   ret void
 }
 
 declare void @llvm.memset(i8* %dest, i8 %val, i32 %len, i1 %isvolatile)
 
 ; TEST 17: Non-volatile memset (positive)
 define void @test17(i8* %p, i8 %val) {
 ; IS__TUNIT____: Function Attrs: argmemonly nofree nosync nounwind willreturn writeonly
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test17
 ; IS__TUNIT____-SAME: (i8* nocapture nofree writeonly [[P:%.*]], i8 [[VAL:%.*]]) #[[ATTR10:[0-9]+]] {
-; IS__TUNIT____-NEXT:    call void @llvm.memset.p0i8.i32(i8* nocapture nofree writeonly [[P]], i8 [[VAL]], i32 noundef 8, i1 noundef false) #[[ATTR14:[0-9]+]]
+; IS__TUNIT____-NEXT:    call void @llvm.memset.p0i8.i32(i8* nocapture nofree writeonly [[P]], i8 [[VAL]], i32 noundef 8, i1 noundef false) #[[ATTR15:[0-9]+]]
 ; IS__TUNIT____-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: argmemonly nofree nosync nounwind willreturn writeonly
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@test17
 ; IS__CGSCC____-SAME: (i8* nocapture nofree writeonly [[P:%.*]], i8 [[VAL:%.*]]) #[[ATTR11:[0-9]+]] {
-; IS__CGSCC____-NEXT:    call void @llvm.memset.p0i8.i32(i8* nocapture nofree writeonly [[P]], i8 [[VAL]], i32 noundef 8, i1 noundef false) #[[ATTR15:[0-9]+]]
+; IS__CGSCC____-NEXT:    call void @llvm.memset.p0i8.i32(i8* nocapture nofree writeonly [[P]], i8 [[VAL]], i32 noundef 8, i1 noundef false) #[[ATTR16:[0-9]+]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @llvm.memset(i8* %p, i8 %val, i32 8, i1 0)
   ret void
 }
 
 ; TEST 18: Volatile memset
 ; Should this be negative? See discussion on https://reviews.llvm.org/D100676
 ; and https://reviews.llvm.org/D101701.
 define void @test18(i8* %p, i8 %val) {
-; IS__TUNIT____: Function Attrs: argmemonly nofree nosync nounwind willreturn writeonly
+; IS__TUNIT____: Function Attrs: argmemonly nosync nounwind willreturn writeonly
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test18
-; IS__TUNIT____-SAME: (i8* nocapture nofree writeonly [[P:%.*]], i8 [[VAL:%.*]]) #[[ATTR10]] {
-; IS__TUNIT____-NEXT:    call void @llvm.memset.p0i8.i32(i8* nocapture nofree writeonly [[P]], i8 [[VAL]], i32 noundef 8, i1 noundef true) #[[ATTR14]]
+; IS__TUNIT____-SAME: (i8* nocapture nofree writeonly [[P:%.*]], i8 [[VAL:%.*]]) #[[ATTR11:[0-9]+]] {
+; IS__TUNIT____-NEXT:    call void @llvm.memset.p0i8.i32(i8* nocapture nofree writeonly [[P]], i8 [[VAL]], i32 noundef 8, i1 noundef true) #[[ATTR15]]
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree nosync nounwind willreturn writeonly
+; IS__CGSCC____: Function Attrs: argmemonly nosync nounwind willreturn writeonly
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@test18
-; IS__CGSCC____-SAME: (i8* nocapture nofree writeonly [[P:%.*]], i8 [[VAL:%.*]]) #[[ATTR11]] {
-; IS__CGSCC____-NEXT:    call void @llvm.memset.p0i8.i32(i8* nocapture nofree writeonly [[P]], i8 [[VAL]], i32 noundef 8, i1 noundef true) #[[ATTR15]]
+; IS__CGSCC____-SAME: (i8* nocapture nofree writeonly [[P:%.*]], i8 [[VAL:%.*]]) #[[ATTR12:[0-9]+]] {
+; IS__CGSCC____-NEXT:    call void @llvm.memset.p0i8.i32(i8* nocapture nofree writeonly [[P]], i8 [[VAL]], i32 noundef 8, i1 noundef true) #[[ATTR16]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @llvm.memset(i8* %p, i8 %val, i32 8, i1 1)
   ret void
 }
 
 ; UTC_ARGS: --enable
 
 define void @nonnull_assume_pos(i8* %arg1, i8* %arg2, i8* %arg3, i8* %arg4) {
 ; ATTRIBUTOR-LABEL: define {{[^@]+}}@nonnull_assume_pos
 ; ATTRIBUTOR-SAME: (i8* nofree [[ARG1:%.*]], i8* [[ARG2:%.*]], i8* nofree [[ARG3:%.*]], i8* [[ARG4:%.*]])
 ; ATTRIBUTOR-NEXT:    call void @llvm.assume(i1 true) #11 [ "nofree"(i8* [[ARG1]]), "nofree"(i8* [[ARG3]]) ]
 ; ATTRIBUTOR-NEXT:    call void @unknown(i8* nofree [[ARG1]], i8* [[ARG2]], i8* nofree [[ARG3]], i8* [[ARG4]])
 ; ATTRIBUTOR-NEXT:    ret void
 ;
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@nonnull_assume_pos
 ; IS__TUNIT____-SAME: (i8* nofree [[ARG1:%.*]], i8* [[ARG2:%.*]], i8* nofree [[ARG3:%.*]], i8* [[ARG4:%.*]]) {
-; IS__TUNIT____-NEXT:    call void @llvm.assume(i1 noundef true) #[[ATTR15:[0-9]+]] [ "nofree"(i8* [[ARG1]]), "nofree"(i8* [[ARG3]]) ]
+; IS__TUNIT____-NEXT:    call void @llvm.assume(i1 noundef true) #[[ATTR16:[0-9]+]] [ "nofree"(i8* [[ARG1]]), "nofree"(i8* [[ARG3]]) ]
 ; IS__TUNIT____-NEXT:    call void @unknown(i8* nofree [[ARG1]], i8* [[ARG2]], i8* nofree [[ARG3]], i8* [[ARG4]])
 ; IS__TUNIT____-NEXT:    ret void
 ;
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@nonnull_assume_pos
 ; IS__CGSCC____-SAME: (i8* nofree [[ARG1:%.*]], i8* [[ARG2:%.*]], i8* nofree [[ARG3:%.*]], i8* [[ARG4:%.*]]) {
-; IS__CGSCC____-NEXT:    call void @llvm.assume(i1 noundef true) #[[ATTR16:[0-9]+]] [ "nofree"(i8* [[ARG1]]), "nofree"(i8* [[ARG3]]) ]
+; IS__CGSCC____-NEXT:    call void @llvm.assume(i1 noundef true) #[[ATTR17:[0-9]+]] [ "nofree"(i8* [[ARG1]]), "nofree"(i8* [[ARG3]]) ]
 ; IS__CGSCC____-NEXT:    call void @unknown(i8* nofree [[ARG1]], i8* [[ARG2]], i8* nofree [[ARG3]], i8* [[ARG4]])
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @llvm.assume(i1 true) ["nofree"(i8* %arg1), "nofree"(i8* %arg3)]
   call void @unknown(i8* %arg1, i8* %arg2, i8* %arg3, i8* %arg4)
   ret void
 }
 define void @nonnull_assume_neg(i8* %arg1, i8* %arg2, i8* %arg3, i8* %arg4) {

 ; IS__TUNIT____: attributes #[[ATTR1]] = { noinline nounwind uwtable }
 ; IS__TUNIT____: attributes #[[ATTR2]] = { nobuiltin nounwind }
 ; IS__TUNIT____: attributes #[[ATTR3]] = { nofree noinline nosync nounwind readnone uwtable willreturn }
 ; IS__TUNIT____: attributes #[[ATTR4]] = { nofree noinline noreturn nosync nounwind readnone uwtable willreturn }
 ; IS__TUNIT____: attributes #[[ATTR5:[0-9]+]] = { nofree noinline nounwind readnone uwtable }
 ; IS__TUNIT____: attributes #[[ATTR6:[0-9]+]] = { nofree nosync nounwind readnone speculatable willreturn }
 ; IS__TUNIT____: attributes #[[ATTR7]] = { nofree nounwind }
 ; IS__TUNIT____: attributes #[[ATTR8:[0-9]+]] = { nobuiltin nofree nounwind }
-; IS__TUNIT____: attributes #[[ATTR9]] = { argmemonly nofree nounwind willreturn }
+; IS__TUNIT____: attributes #[[ATTR9]] = { argmemonly nounwind willreturn }
 ; IS__TUNIT____: attributes #[[ATTR10]] = { argmemonly nofree nosync nounwind willreturn writeonly }
-; IS__TUNIT____: attributes #[[ATTR11:[0-9]+]] = { inaccessiblememonly nofree nosync nounwind willreturn }
-; IS__TUNIT____: attributes #[[ATTR12:[0-9]+]] = { nounwind willreturn }
-; IS__TUNIT____: attributes #[[ATTR13]] = { readnone willreturn }
-; IS__TUNIT____: attributes #[[ATTR14]] = { willreturn writeonly }
-; IS__TUNIT____: attributes #[[ATTR15]] = { willreturn }
+; IS__TUNIT____: attributes #[[ATTR11]] = { argmemonly nosync nounwind willreturn writeonly }
+; IS__TUNIT____: attributes #[[ATTR12:[0-9]+]] = { inaccessiblememonly nofree nosync nounwind willreturn }
+; IS__TUNIT____: attributes #[[ATTR13:[0-9]+]] = { nounwind willreturn }
+; IS__TUNIT____: attributes #[[ATTR14]] = { readnone willreturn }
+; IS__TUNIT____: attributes #[[ATTR15]] = { willreturn writeonly }
+; IS__TUNIT____: attributes #[[ATTR16]] = { willreturn }
 ;.
 ; IS__CGSCC_OPM: attributes #[[ATTR0]] = { nounwind }
 ; IS__CGSCC_OPM: attributes #[[ATTR1]] = { noinline nounwind uwtable }
 ; IS__CGSCC_OPM: attributes #[[ATTR2]] = { nobuiltin nounwind }
 ; IS__CGSCC_OPM: attributes #[[ATTR3]] = { nofree noinline norecurse nosync nounwind readnone uwtable willreturn }
 ; IS__CGSCC_OPM: attributes #[[ATTR4]] = { nofree noinline noreturn nosync nounwind readnone uwtable willreturn }
 ; IS__CGSCC_OPM: attributes #[[ATTR5:[0-9]+]] = { nofree noinline nounwind readnone uwtable }
 ; IS__CGSCC_OPM: attributes #[[ATTR6:[0-9]+]] = { nofree nosync nounwind readnone speculatable willreturn }
 ; IS__CGSCC_OPM: attributes #[[ATTR7]] = { nofree noinline nosync nounwind readnone uwtable willreturn }
 ; IS__CGSCC_OPM: attributes #[[ATTR8]] = { nofree nounwind }
 ; IS__CGSCC_OPM: attributes #[[ATTR9:[0-9]+]] = { nobuiltin nofree nounwind }
-; IS__CGSCC_OPM: attributes #[[ATTR10]] = { argmemonly nofree norecurse nounwind willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR10]] = { argmemonly norecurse nounwind willreturn }
 ; IS__CGSCC_OPM: attributes #[[ATTR11]] = { argmemonly nofree nosync nounwind willreturn writeonly }
-; IS__CGSCC_OPM: attributes #[[ATTR12:[0-9]+]] = { inaccessiblememonly nofree nosync nounwind willreturn }
-; IS__CGSCC_OPM: attributes #[[ATTR13:[0-9]+]] = { nounwind willreturn }
-; IS__CGSCC_OPM: attributes #[[ATTR14]] = { readnone willreturn }
-; IS__CGSCC_OPM: attributes #[[ATTR15]] = { willreturn writeonly }
-; IS__CGSCC_OPM: attributes #[[ATTR16]] = { willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR12]] = { argmemonly nosync nounwind willreturn writeonly }
+; IS__CGSCC_OPM: attributes #[[ATTR13:[0-9]+]] = { inaccessiblememonly nofree nosync nounwind willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR14:[0-9]+]] = { nounwind willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR15]] = { readnone willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR16]] = { willreturn writeonly }
+; IS__CGSCC_OPM: attributes #[[ATTR17]] = { willreturn }
 ;.
 ; IS__CGSCC_NPM: attributes #[[ATTR0]] = { nounwind }
 ; IS__CGSCC_NPM: attributes #[[ATTR1]] = { noinline nounwind uwtable }
 ; IS__CGSCC_NPM: attributes #[[ATTR2]] = { nobuiltin nounwind }
 ; IS__CGSCC_NPM: attributes #[[ATTR3]] = { nofree noinline norecurse nosync nounwind readnone uwtable willreturn }
 ; IS__CGSCC_NPM: attributes #[[ATTR4]] = { nofree noinline norecurse noreturn nosync nounwind readnone uwtable willreturn }
 ; IS__CGSCC_NPM: attributes #[[ATTR5:[0-9]+]] = { nofree noinline nounwind readnone uwtable }
 ; IS__CGSCC_NPM: attributes #[[ATTR6:[0-9]+]] = { nofree nosync nounwind readnone speculatable willreturn }
 ; IS__CGSCC_NPM: attributes #[[ATTR7]] = { nofree noinline nosync nounwind readnone uwtable willreturn }
 ; IS__CGSCC_NPM: attributes #[[ATTR8]] = { nofree nounwind }
 ; IS__CGSCC_NPM: attributes #[[ATTR9:[0-9]+]] = { nobuiltin nofree nounwind }
-; IS__CGSCC_NPM: attributes #[[ATTR10]] = { argmemonly nofree norecurse nounwind willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR10]] = { argmemonly norecurse nounwind willreturn }
 ; IS__CGSCC_NPM: attributes #[[ATTR11]] = { argmemonly nofree nosync nounwind willreturn writeonly }
-; IS__CGSCC_NPM: attributes #[[ATTR12:[0-9]+]] = { inaccessiblememonly nofree nosync nounwind willreturn }
-; IS__CGSCC_NPM: attributes #[[ATTR13:[0-9]+]] = { nounwind willreturn }
-; IS__CGSCC_NPM: attributes #[[ATTR14]] = { readnone willreturn }
-; IS__CGSCC_NPM: attributes #[[ATTR15]] = { willreturn writeonly }
-; IS__CGSCC_NPM: attributes #[[ATTR16]] = { willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR12]] = { argmemonly nosync nounwind willreturn writeonly }
+; IS__CGSCC_NPM: attributes #[[ATTR13:[0-9]+]] = { inaccessiblememonly nofree nosync nounwind willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR14:[0-9]+]] = { nounwind willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR15]] = { readnone willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR16]] = { willreturn writeonly }
+; IS__CGSCC_NPM: attributes #[[ATTR17]] = { willreturn }
 ;.

llvm/test/Transforms/Attributor/nosync.ll

 ; TEST 4 - negative, should not deduce nosync
 ; atomic load with acquire ordering.
 ; int load_acquire(_Atomic int *num) {
 ;   int n = atomic_load_explicit(num, memory_order_acquire);
 ;   return n;
 ; }
 
 define i32 @load_acquire(i32* nocapture readonly %0) norecurse nounwind uwtable {
-; CHECK: Function Attrs: argmemonly nofree norecurse nounwind uwtable willreturn
+; CHECK: Function Attrs: argmemonly norecurse nounwind uwtable willreturn
 ; CHECK-LABEL: define {{[^@]+}}@load_acquire
-; CHECK-SAME: (i32* nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[TMP0:%.*]]) #[[ATTR2:[0-9]+]] {
+; CHECK-SAME: (i32* nocapture noundef nonnull readonly align 4 dereferenceable(4) [[TMP0:%.*]]) #[[ATTR2:[0-9]+]] {
 ; CHECK-NEXT:    [[TMP2:%.*]] = load atomic i32, i32* [[TMP0]] acquire, align 4
 ; CHECK-NEXT:    ret i32 [[TMP2]]
 ;
   %2 = load atomic i32, i32* %0 acquire, align 4
   ret i32 %2
 }
 
 ; TEST 5 - negative, should not deduce nosync
 ; atomic load with release ordering
 ; void load_release(_Atomic int *num) {
 ;   atomic_store_explicit(num, 10, memory_order_release);
 ; }
 
 define void @load_release(i32* nocapture %0) norecurse nounwind uwtable {
-; CHECK: Function Attrs: argmemonly nofree norecurse nounwind uwtable willreturn
+; CHECK: Function Attrs: argmemonly norecurse nounwind uwtable willreturn
 ; CHECK-LABEL: define {{[^@]+}}@load_release
-; CHECK-SAME: (i32* nocapture nofree noundef writeonly align 4 [[TMP0:%.*]]) #[[ATTR2]] {
+; CHECK-SAME: (i32* nocapture noundef writeonly align 4 [[TMP0:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    store atomic volatile i32 10, i32* [[TMP0]] release, align 4
 ; CHECK-NEXT:    ret void
 ;
   store atomic volatile i32 10, i32* %0 release, align 4
   ret void
 }
 
 ; TEST 6 - negative volatile, relaxed atomic
 
 define void @load_volatile_release(i32* nocapture %0) norecurse nounwind uwtable {
-; CHECK: Function Attrs: argmemonly nofree norecurse nounwind uwtable willreturn
+; CHECK: Function Attrs: argmemonly norecurse nounwind uwtable willreturn
 ; CHECK-LABEL: define {{[^@]+}}@load_volatile_release
-; CHECK-SAME: (i32* nocapture nofree noundef writeonly align 4 [[TMP0:%.*]]) #[[ATTR2]] {
+; CHECK-SAME: (i32* nocapture noundef writeonly align 4 [[TMP0:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    store atomic volatile i32 10, i32* [[TMP0]] release, align 4
 ; CHECK-NEXT:    ret void
 ;
   store atomic volatile i32 10, i32* %0 release, align 4
   ret void
 }
 
 ; TEST 7 - negative, should not deduce nosync
 ; volatile store.
 ; void volatile_store(volatile int *num) {
 ;   *num = 14;
 ; }
 
 define void @volatile_store(i32* %0) norecurse nounwind uwtable {
-; CHECK: Function Attrs: argmemonly nofree norecurse nounwind uwtable willreturn
+; CHECK: Function Attrs: argmemonly norecurse nounwind uwtable willreturn
 ; CHECK-LABEL: define {{[^@]+}}@volatile_store
-; CHECK-SAME: (i32* nofree noundef align 4 [[TMP0:%.*]]) #[[ATTR2]] {
+; CHECK-SAME: (i32* noundef align 4 [[TMP0:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    store volatile i32 14, i32* [[TMP0]], align 4
 ; CHECK-NEXT:    ret void
 ;
   store volatile i32 14, i32* %0, align 4
   ret void
 }
 
 ; TEST 8 - negative, should not deduce nosync
 ; volatile load.
 ; int volatile_load(volatile int *num) {
 ;   int n = *num;
 ;   return n;
 ; }
 
 define i32 @volatile_load(i32* %0) norecurse nounwind uwtable {
-; CHECK: Function Attrs: argmemonly nofree norecurse nounwind uwtable willreturn
+; CHECK: Function Attrs: argmemonly norecurse nounwind uwtable willreturn
 ; CHECK-LABEL: define {{[^@]+}}@volatile_load
-; CHECK-SAME: (i32* nofree align 4 [[TMP0:%.*]]) #[[ATTR2]] {
+; CHECK-SAME: (i32* align 4 [[TMP0:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    [[TMP2:%.*]] = load volatile i32, i32* [[TMP0]], align 4
 ; CHECK-NEXT:    ret i32 [[TMP2]]
 ;
   %2 = load volatile i32, i32* %0, align 4
   ret i32 %2
 }
 
 ; TEST 9

 ;   atomic_thread_fence(std::memory_order_acquire);
 ;   int b = *a;
 ; }
 
 %"struct.std::atomic" = type { %"struct.std::__atomic_base" }
 %"struct.std::__atomic_base" = type { i8 }
 
 define void @foo1(i32* %0, %"struct.std::atomic"* %1) {
-; IS__TUNIT____: Function Attrs: nofree nounwind willreturn
+; IS__TUNIT____: Function Attrs: nounwind willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@foo1
-; IS__TUNIT____-SAME: (i32* nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[TMP0:%.*]], %"struct.std::atomic"* nocapture nofree nonnull writeonly dereferenceable(1) [[TMP1:%.*]]) #[[ATTR6:[0-9]+]] {
+; IS__TUNIT____-SAME: (i32* nocapture noundef nonnull writeonly align 4 dereferenceable(4) [[TMP0:%.*]], %"struct.std::atomic"* nocapture nonnull writeonly dereferenceable(1) [[TMP1:%.*]]) #[[ATTR6:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    store i32 100, i32* [[TMP0]], align 4
 ; IS__TUNIT____-NEXT:    fence release
 ; IS__TUNIT____-NEXT:    [[TMP3:%.*]] = getelementptr inbounds %"struct.std::atomic", %"struct.std::atomic"* [[TMP1]], i64 0, i32 0, i32 0
 ; IS__TUNIT____-NEXT:    store atomic i8 1, i8* [[TMP3]] monotonic, align 1
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: nofree norecurse nounwind willreturn
+; IS__CGSCC____: Function Attrs: norecurse nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@foo1
-; IS__CGSCC____-SAME: (i32* nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[TMP0:%.*]], %"struct.std::atomic"* nocapture nofree nonnull writeonly dereferenceable(1) [[TMP1:%.*]]) #[[ATTR6:[0-9]+]] {
+; IS__CGSCC____-SAME: (i32* nocapture noundef nonnull writeonly align 4 dereferenceable(4) [[TMP0:%.*]], %"struct.std::atomic"* nocapture nonnull writeonly dereferenceable(1) [[TMP1:%.*]]) #[[ATTR6:[0-9]+]] {
 ; IS__CGSCC____-NEXT:    store i32 100, i32* [[TMP0]], align 4
 ; IS__CGSCC____-NEXT:    fence release
 ; IS__CGSCC____-NEXT:    [[TMP3:%.*]] = getelementptr inbounds %"struct.std::atomic", %"struct.std::atomic"* [[TMP1]], i64 0, i32 0, i32 0
 ; IS__CGSCC____-NEXT:    store atomic i8 1, i8* [[TMP3]] monotonic, align 1
 ; IS__CGSCC____-NEXT:    ret void
 ;
   store i32 100, i32* %0, align 4
   fence release
   %3 = getelementptr inbounds %"struct.std::atomic", %"struct.std::atomic"* %1, i64 0, i32 0, i32 0
   store atomic i8 1, i8* %3 monotonic, align 1
   ret void
 }
 
 define void @bar(i32* %0, %"struct.std::atomic"* %1) {
-; IS__TUNIT____: Function Attrs: nofree nounwind
+; IS__TUNIT____: Function Attrs: nounwind
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@bar
-; IS__TUNIT____-SAME: (i32* nocapture nofree readnone [[TMP0:%.*]], %"struct.std::atomic"* nocapture nofree nonnull readonly dereferenceable(1) [[TMP1:%.*]]) #[[ATTR7:[0-9]+]] {
+; IS__TUNIT____-SAME: (i32* nocapture nofree readnone [[TMP0:%.*]], %"struct.std::atomic"* nocapture nonnull readonly dereferenceable(1) [[TMP1:%.*]]) #[[ATTR7:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    [[TMP3:%.*]] = getelementptr inbounds %"struct.std::atomic", %"struct.std::atomic"* [[TMP1]], i64 0, i32 0, i32 0
 ; IS__TUNIT____-NEXT:    br label [[TMP4:%.*]]
 ; IS__TUNIT____:       4:
 ; IS__TUNIT____-NEXT:    [[TMP5:%.*]] = load atomic i8, i8* [[TMP3]] monotonic, align 1
 ; IS__TUNIT____-NEXT:    [[TMP6:%.*]] = and i8 [[TMP5]], 1
 ; IS__TUNIT____-NEXT:    [[TMP7:%.*]] = icmp eq i8 [[TMP6]], 0
 ; IS__TUNIT____-NEXT:    br i1 [[TMP7]], label [[TMP4]], label [[TMP8:%.*]]
 ; IS__TUNIT____:       8:
 ; IS__TUNIT____-NEXT:    fence acquire
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: nofree norecurse nounwind
+; IS__CGSCC____: Function Attrs: norecurse nounwind
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@bar
-; IS__CGSCC____-SAME: (i32* nocapture nofree readnone [[TMP0:%.*]], %"struct.std::atomic"* nocapture nofree nonnull readonly dereferenceable(1) [[TMP1:%.*]]) #[[ATTR7:[0-9]+]] {
+; IS__CGSCC____-SAME: (i32* nocapture nofree readnone [[TMP0:%.*]], %"struct.std::atomic"* nocapture nonnull readonly dereferenceable(1) [[TMP1:%.*]]) #[[ATTR7:[0-9]+]] {
 ; IS__CGSCC____-NEXT:    [[TMP3:%.*]] = getelementptr inbounds %"struct.std::atomic", %"struct.std::atomic"* [[TMP1]], i64 0, i32 0, i32 0
 ; IS__CGSCC____-NEXT:    br label [[TMP4:%.*]]
 ; IS__CGSCC____:       4:
 ; IS__CGSCC____-NEXT:    [[TMP5:%.*]] = load atomic i8, i8* [[TMP3]] monotonic, align 1
 ; IS__CGSCC____-NEXT:    [[TMP6:%.*]] = and i8 [[TMP5]], 1
 ; IS__CGSCC____-NEXT:    [[TMP7:%.*]] = icmp eq i8 [[TMP6]], 0
 ; IS__CGSCC____-NEXT:    br i1 [[TMP7]], label [[TMP4]], label [[TMP8:%.*]]
 ; IS__CGSCC____:       8:

 declare void @llvm.memcpy(i8* %dest, i8* %src, i32 %len, i1 %isvolatile)
 declare void @llvm.memset(i8* %dest, i8 %val, i32 %len, i1 %isvolatile)
 
 ; TEST 14 - negative, checking volatile intrinsics.
 
 ; It is odd to add nocapture but a result of the llvm.memcpy nocapture.
 ;
 define i32 @memcpy_volatile(i8* %ptr1, i8* %ptr2) {
-; IS__TUNIT____: Function Attrs: argmemonly nofree nosync nounwind willreturn
+; IS__TUNIT____: Function Attrs: argmemonly nosync nounwind willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@memcpy_volatile
 ; IS__TUNIT____-SAME: (i8* nocapture nofree writeonly [[PTR1:%.*]], i8* nocapture nofree readonly [[PTR2:%.*]]) #[[ATTR10:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias nocapture nofree writeonly [[PTR1]], i8* noalias nocapture nofree readonly [[PTR2]], i32 noundef 8, i1 noundef true) #[[ATTR17:[0-9]+]]
 ; IS__TUNIT____-NEXT:    ret i32 4
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree nosync nounwind willreturn
+; IS__CGSCC____: Function Attrs: argmemonly nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@memcpy_volatile
 ; IS__CGSCC____-SAME: (i8* nocapture nofree writeonly [[PTR1:%.*]], i8* nocapture nofree readonly [[PTR2:%.*]]) #[[ATTR10:[0-9]+]] {
-; IS__CGSCC____-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias nocapture nofree writeonly [[PTR1]], i8* noalias nocapture nofree readonly [[PTR2]], i32 noundef 8, i1 noundef true) #[[ATTR18:[0-9]+]]
+; IS__CGSCC____-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias nocapture nofree writeonly [[PTR1]], i8* noalias nocapture nofree readonly [[PTR2]], i32 noundef 8, i1 noundef true) #[[ATTR19:[0-9]+]]
 ; IS__CGSCC____-NEXT:    ret i32 4
 ;
   call void @llvm.memcpy(i8* %ptr1, i8* %ptr2, i32 8, i1 1)
   ret i32 4
 }
 
 ; TEST 15 - positive, non-volatile intrinsic.
 
 ; It is odd to add nocapture but a result of the llvm.memset nocapture.
 ;
 define i32 @memset_non_volatile(i8* %ptr1, i8 %val) {
 ; IS__TUNIT____: Function Attrs: argmemonly nofree nosync nounwind willreturn writeonly
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@memset_non_volatile
 ; IS__TUNIT____-SAME: (i8* nocapture nofree writeonly [[PTR1:%.*]], i8 [[VAL:%.*]]) #[[ATTR11:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    call void @llvm.memset.p0i8.i32(i8* nocapture nofree writeonly [[PTR1]], i8 [[VAL]], i32 noundef 8, i1 noundef false) #[[ATTR18:[0-9]+]]
 ; IS__TUNIT____-NEXT:    ret i32 4
 ;
 ; IS__CGSCC____: Function Attrs: argmemonly nofree nosync nounwind willreturn writeonly
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@memset_non_volatile
 ; IS__CGSCC____-SAME: (i8* nocapture nofree writeonly [[PTR1:%.*]], i8 [[VAL:%.*]]) #[[ATTR11:[0-9]+]] {
-; IS__CGSCC____-NEXT:    call void @llvm.memset.p0i8.i32(i8* nocapture nofree writeonly [[PTR1]], i8 [[VAL]], i32 noundef 8, i1 noundef false) #[[ATTR19:[0-9]+]]
+; IS__CGSCC____-NEXT:    call void @llvm.memset.p0i8.i32(i8* nocapture nofree writeonly [[PTR1]], i8 [[VAL]], i32 noundef 8, i1 noundef false) #[[ATTR20:[0-9]+]]
 ; IS__CGSCC____-NEXT:    ret i32 4
 ;
   call void @llvm.memset(i8* %ptr1, i8 %val, i32 8, i1 0)
   ret i32 4
 }
 
 ; TEST 16 - negative, inline assembly.
 

 ; CHECK: Function Attrs: nounwind
 ; CHECK-NEXT: declare void @llvm.x86.sse2.clflush(i8*)
 declare void @llvm.x86.sse2.clflush(i8*)
 @a = common global i32 0, align 4
 
 ; TEST 18 - negative. Synchronizing intrinsic
 
 define void @i_totally_sync() {
-; CHECK: Function Attrs: nounwind
-; CHECK-LABEL: define {{[^@]+}}@i_totally_sync
-; CHECK-SAME: () #[[ATTR14:[0-9]+]] {
-; CHECK-NEXT:    tail call void @llvm.x86.sse2.clflush(i8* noundef nonnull align 4 dereferenceable(4) bitcast (i32* @a to i8*))
-; CHECK-NEXT:    ret void
+; IS__TUNIT____: Function Attrs: nounwind
+; IS__TUNIT____-LABEL: define {{[^@]+}}@i_totally_sync
+; IS__TUNIT____-SAME: () #[[ATTR7]] {
+; IS__TUNIT____-NEXT:    tail call void @llvm.x86.sse2.clflush(i8* noundef nonnull align 4 dereferenceable(4) bitcast (i32* @a to i8*))
+; IS__TUNIT____-NEXT:    ret void
+;
+; IS__CGSCC____: Function Attrs: nounwind
+; IS__CGSCC____-LABEL: define {{[^@]+}}@i_totally_sync
+; IS__CGSCC____-SAME: () #[[ATTR14:[0-9]+]] {
+; IS__CGSCC____-NEXT:    tail call void @llvm.x86.sse2.clflush(i8* noundef nonnull align 4 dereferenceable(4) bitcast (i32* @a to i8*))
+; IS__CGSCC____-NEXT:    ret void
 ;
   tail call void @llvm.x86.sse2.clflush(i8* bitcast (i32* @a to i8*))
   ret void
 }
 
 declare float @llvm.cos(float %val) readnone
 
 ; TEST 19 - positive, readnone & non-convergent intrinsic.
 
 define i32 @cos_test(float %x) {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@cos_test
-; IS__TUNIT____-SAME: (float [[X:%.*]]) #[[ATTR15:[0-9]+]] {
+; IS__TUNIT____-SAME: (float [[X:%.*]]) #[[ATTR14:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    ret i32 4
 ;
 ; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@cos_test
 ; IS__CGSCC____-SAME: (float [[X:%.*]]) #[[ATTR15:[0-9]+]] {
 ; IS__CGSCC____-NEXT:    ret i32 4
 ;
   call float @llvm.cos(float %x)
   ret i32 4
 }
 
 define float @cos_test2(float %x) {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@cos_test2
-; IS__TUNIT____-SAME: (float [[X:%.*]]) #[[ATTR15]] {
+; IS__TUNIT____-SAME: (float [[X:%.*]]) #[[ATTR14]] {
 ; IS__TUNIT____-NEXT:    [[C:%.*]] = call float @llvm.cos.f32(float [[X]]) #[[ATTR19:[0-9]+]]
 ; IS__TUNIT____-NEXT:    ret float [[C]]
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@cos_test2
 ; IS__CGSCC____-SAME: (float [[X:%.*]]) #[[ATTR16:[0-9]+]] {
-; IS__CGSCC____-NEXT:    [[C:%.*]] = call float @llvm.cos.f32(float [[X]]) #[[ATTR20:[0-9]+]]
+; IS__CGSCC____-NEXT:    [[C:%.*]] = call float @llvm.cos.f32(float [[X]]) #[[ATTR21:[0-9]+]]
 ; IS__CGSCC____-NEXT:    ret float [[C]]
 ;
   %c = call float @llvm.cos(float %x)
   ret float %c
 }
 ;.
 ; IS__TUNIT____: attributes #[[ATTR0]] = { nofree nosync nounwind optsize readnone ssp uwtable willreturn }
 ; IS__TUNIT____: attributes #[[ATTR1]] = { argmemonly nofree norecurse nosync nounwind uwtable willreturn }
-; IS__TUNIT____: attributes #[[ATTR2]] = { argmemonly nofree norecurse nounwind uwtable willreturn }
+; IS__TUNIT____: attributes #[[ATTR2]] = { argmemonly norecurse nounwind uwtable willreturn }
 ; IS__TUNIT____: attributes #[[ATTR3]] = { noinline nosync nounwind uwtable }
 ; IS__TUNIT____: attributes #[[ATTR4]] = { noinline nounwind uwtable }
 ; IS__TUNIT____: attributes #[[ATTR5]] = { nofree noinline noreturn nosync nounwind readnone uwtable willreturn }
-; IS__TUNIT____: attributes #[[ATTR6]] = { nofree nounwind willreturn }
-; IS__TUNIT____: attributes #[[ATTR7]] = { nofree nounwind }
+; IS__TUNIT____: attributes #[[ATTR6]] = { nounwind willreturn }
+; IS__TUNIT____: attributes #[[ATTR7]] = { nounwind }
 ; IS__TUNIT____: attributes #[[ATTR8]] = { nofree nosync nounwind willreturn }
 ; IS__TUNIT____: attributes #[[ATTR9]] = { nofree nosync nounwind }
-; IS__TUNIT____: attributes #[[ATTR10]] = { argmemonly nofree nosync nounwind willreturn }
+; IS__TUNIT____: attributes #[[ATTR10]] = { argmemonly nosync nounwind willreturn }
 ; IS__TUNIT____: attributes #[[ATTR11]] = { argmemonly nofree nosync nounwind willreturn writeonly }
 ; IS__TUNIT____: attributes #[[ATTR12:[0-9]+]] = { convergent readnone }
 ; IS__TUNIT____: attributes #[[ATTR13]] = { readnone }
-; IS__TUNIT____: attributes #[[ATTR14]] = { nounwind }
-; IS__TUNIT____: attributes #[[ATTR15]] = { nofree nosync nounwind readnone willreturn }
+; IS__TUNIT____: attributes #[[ATTR14]] = { nofree nosync nounwind readnone willreturn }
+; IS__TUNIT____: attributes #[[ATTR15:[0-9]+]] = { argmemonly nofree nosync nounwind willreturn }
 ; IS__TUNIT____: attributes #[[ATTR16:[0-9]+]] = { nofree nosync nounwind readnone speculatable willreturn }
 ; IS__TUNIT____: attributes #[[ATTR17]] = { willreturn }
 ; IS__TUNIT____: attributes #[[ATTR18]] = { willreturn writeonly }
 ; IS__TUNIT____: attributes #[[ATTR19]] = { readnone willreturn }
 ;.
 ; IS__CGSCC_OPM: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind optsize readnone ssp uwtable willreturn }
 ; IS__CGSCC_OPM: attributes #[[ATTR1]] = { argmemonly nofree norecurse nosync nounwind uwtable willreturn }
-; IS__CGSCC_OPM: attributes #[[ATTR2]] = { argmemonly nofree norecurse nounwind uwtable willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR2]] = { argmemonly norecurse nounwind uwtable willreturn }
 ; IS__CGSCC_OPM: attributes #[[ATTR3]] = { noinline nosync nounwind uwtable }
 ; IS__CGSCC_OPM: attributes #[[ATTR4]] = { noinline nounwind uwtable }
 ; IS__CGSCC_OPM: attributes #[[ATTR5]] = { nofree noinline noreturn nosync nounwind readnone uwtable willreturn }
-; IS__CGSCC_OPM: attributes #[[ATTR6]] = { nofree norecurse nounwind willreturn }
-; IS__CGSCC_OPM: attributes #[[ATTR7]] = { nofree norecurse nounwind }
+; IS__CGSCC_OPM: attributes #[[ATTR6]] = { norecurse nounwind willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR7]] = { norecurse nounwind }
 ; IS__CGSCC_OPM: attributes #[[ATTR8]] = { nofree norecurse nosync nounwind willreturn }
 ; IS__CGSCC_OPM: attributes #[[ATTR9]] = { nofree norecurse nosync nounwind }
-; IS__CGSCC_OPM: attributes #[[ATTR10]] = { argmemonly nofree nosync nounwind willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR10]] = { argmemonly nosync nounwind willreturn }
 ; IS__CGSCC_OPM: attributes #[[ATTR11]] = { argmemonly nofree nosync nounwind willreturn writeonly }
 ; IS__CGSCC_OPM: attributes #[[ATTR12:[0-9]+]] = { convergent readnone }
 ; IS__CGSCC_OPM: attributes #[[ATTR13]] = { readnone }
 ; IS__CGSCC_OPM: attributes #[[ATTR14]] = { nounwind }
 ; IS__CGSCC_OPM: attributes #[[ATTR15]] = { nofree norecurse nosync nounwind readnone willreturn }
 ; IS__CGSCC_OPM: attributes #[[ATTR16]] = { nofree nosync nounwind readnone willreturn }
-; IS__CGSCC_OPM: attributes #[[ATTR17:[0-9]+]] = { nofree nosync nounwind readnone speculatable willreturn }
-; IS__CGSCC_OPM: attributes #[[ATTR18]] = { willreturn }
-; IS__CGSCC_OPM: attributes #[[ATTR19]] = { willreturn writeonly }
-; IS__CGSCC_OPM: attributes #[[ATTR20]] = { readnone willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR17:[0-9]+]] = { argmemonly nofree nosync nounwind willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR18:[0-9]+]] = { nofree nosync nounwind readnone speculatable willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR19]] = { willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR20]] = { willreturn writeonly }
+; IS__CGSCC_OPM: attributes #[[ATTR21]] = { readnone willreturn }
 ;.
 ; IS__CGSCC_NPM: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind optsize readnone ssp uwtable willreturn }
 ; IS__CGSCC_NPM: attributes #[[ATTR1]] = { argmemonly nofree norecurse nosync nounwind uwtable willreturn }
-; IS__CGSCC_NPM: attributes #[[ATTR2]] = { argmemonly nofree norecurse nounwind uwtable willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR2]] = { argmemonly norecurse nounwind uwtable willreturn }
 ; IS__CGSCC_NPM: attributes #[[ATTR3]] = { noinline nosync nounwind uwtable }
 ; IS__CGSCC_NPM: attributes #[[ATTR4]] = { noinline nounwind uwtable }
 ; IS__CGSCC_NPM: attributes #[[ATTR5]] = { nofree noinline norecurse noreturn nosync nounwind readnone uwtable willreturn }
-; IS__CGSCC_NPM: attributes #[[ATTR6]] = { nofree norecurse nounwind willreturn }
-; IS__CGSCC_NPM: attributes #[[ATTR7]] = { nofree norecurse nounwind }
+; IS__CGSCC_NPM: attributes #[[ATTR6]] = { norecurse nounwind willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR7]] = { norecurse nounwind }
 ; IS__CGSCC_NPM: attributes #[[ATTR8]] = { nofree norecurse nosync nounwind willreturn }
 ; IS__CGSCC_NPM: attributes #[[ATTR9]] = { nofree norecurse nosync nounwind }
-; IS__CGSCC_NPM: attributes #[[ATTR10]] = { argmemonly nofree nosync nounwind willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR10]] = { argmemonly nosync nounwind willreturn }
 ; IS__CGSCC_NPM: attributes #[[ATTR11]] = { argmemonly nofree nosync nounwind willreturn writeonly }
 ; IS__CGSCC_NPM: attributes #[[ATTR12:[0-9]+]] = { convergent readnone }
 ; IS__CGSCC_NPM: attributes #[[ATTR13]] = { readnone }
 ; IS__CGSCC_NPM: attributes #[[ATTR14]] = { nounwind }
 ; IS__CGSCC_NPM: attributes #[[ATTR15]] = { nofree norecurse nosync nounwind readnone willreturn }
 ; IS__CGSCC_NPM: attributes #[[ATTR16]] = { nofree nosync nounwind readnone willreturn }
-; IS__CGSCC_NPM: attributes #[[ATTR17:[0-9]+]] = { nofree nosync nounwind readnone speculatable willreturn }
-; IS__CGSCC_NPM: attributes #[[ATTR18]] = { willreturn }
-; IS__CGSCC_NPM: attributes #[[ATTR19]] = { willreturn writeonly }
-; IS__CGSCC_NPM: attributes #[[ATTR20]] = { readnone willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR17:[0-9]+]] = { argmemonly nofree nosync nounwind willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR18:[0-9]+]] = { nofree nosync nounwind readnone speculatable willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR19]] = { willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR20]] = { willreturn writeonly }
+; IS__CGSCC_NPM: attributes #[[ATTR21]] = { readnone willreturn }
 ;.

llvm/test/Transforms/Attributor/readattrs.ll

 ; IS__CGSCC____-NEXT:    [[RES:%.*]] = call <4 x i32> @test12_1(<4 x i32*> [[PTRS]]) #[[ATTR14:[0-9]+]]
 ; IS__CGSCC____-NEXT:    ret <4 x i32> [[RES]]
 ;
   %res = call <4 x i32> @test12_1(<4 x i32*> %ptrs)
   ret <4 x i32> %res
 }
 
 define i32 @volatile_load(i32* %p) {
-; IS__TUNIT____: Function Attrs: argmemonly nofree nounwind willreturn
+; IS__TUNIT____: Function Attrs: argmemonly nounwind willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@volatile_load
-; IS__TUNIT____-SAME: (i32* nofree noundef align 4 [[P:%.*]]) #[[ATTR7:[0-9]+]] {
+; IS__TUNIT____-SAME: (i32* noundef align 4 [[P:%.*]]) #[[ATTR7:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    [[LOAD:%.*]] = load volatile i32, i32* [[P]], align 4
 ; IS__TUNIT____-NEXT:    ret i32 [[LOAD]]
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nounwind willreturn
+; IS__CGSCC____: Function Attrs: argmemonly norecurse nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@volatile_load
-; IS__CGSCC____-SAME: (i32* nofree noundef align 4 [[P:%.*]]) #[[ATTR8:[0-9]+]] {
+; IS__CGSCC____-SAME: (i32* noundef align 4 [[P:%.*]]) #[[ATTR8:[0-9]+]] {
 ; IS__CGSCC____-NEXT:    [[LOAD:%.*]] = load volatile i32, i32* [[P]], align 4
 ; IS__CGSCC____-NEXT:    ret i32 [[LOAD]]
 ;
   %load = load volatile i32, i32* %p
   ret i32 %load
 }
 
 declare void @escape_readnone_ptr(i8** %addr, i8* readnone %ptr)

 ;.
 ; IS__TUNIT____: attributes #[[ATTR0]] = { nofree nosync nounwind willreturn writeonly }
 ; IS__TUNIT____: attributes #[[ATTR1]] = { nofree nosync nounwind readnone willreturn }
 ; IS__TUNIT____: attributes #[[ATTR2]] = { readonly }
 ; IS__TUNIT____: attributes #[[ATTR3]] = { argmemonly nofree nosync nounwind willreturn writeonly }
 ; IS__TUNIT____: attributes #[[ATTR4]] = { nofree nosync nounwind readonly willreturn }
 ; IS__TUNIT____: attributes #[[ATTR5]] = { argmemonly nounwind readonly }
 ; IS__TUNIT____: attributes #[[ATTR6]] = { argmemonly nounwind }
-; IS__TUNIT____: attributes #[[ATTR7]] = { argmemonly nofree nounwind willreturn }
+; IS__TUNIT____: attributes #[[ATTR7]] = { argmemonly nounwind willreturn }
 ; IS__TUNIT____: attributes #[[ATTR8]] = { readnone }
 ; IS__TUNIT____: attributes #[[ATTR9]] = { nounwind readonly }
 ; IS__TUNIT____: attributes #[[ATTR10]] = { willreturn writeonly }
 ; IS__TUNIT____: attributes #[[ATTR11]] = { readonly willreturn }
 ; IS__TUNIT____: attributes #[[ATTR12]] = { nounwind }
 ;.
 ; IS__CGSCC____: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn writeonly }
 ; IS__CGSCC____: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind readnone willreturn }
 ; IS__CGSCC____: attributes #[[ATTR2]] = { readonly }
 ; IS__CGSCC____: attributes #[[ATTR3]] = { argmemonly nofree norecurse nosync nounwind willreturn writeonly }
 ; IS__CGSCC____: attributes #[[ATTR4]] = { nofree nosync nounwind willreturn writeonly }
 ; IS__CGSCC____: attributes #[[ATTR5]] = { nofree nosync nounwind readonly willreturn }
 ; IS__CGSCC____: attributes #[[ATTR6]] = { argmemonly nounwind readonly }
 ; IS__CGSCC____: attributes #[[ATTR7]] = { argmemonly nounwind }
-; IS__CGSCC____: attributes #[[ATTR8]] = { argmemonly nofree norecurse nounwind willreturn }
+; IS__CGSCC____: attributes #[[ATTR8]] = { argmemonly norecurse nounwind willreturn }
 ; IS__CGSCC____: attributes #[[ATTR9]] = { readnone }
 ; IS__CGSCC____: attributes #[[ATTR10]] = { nounwind readonly }
 ; IS__CGSCC____: attributes #[[ATTR11]] = { readnone willreturn }
 ; IS__CGSCC____: attributes #[[ATTR12]] = { willreturn writeonly }
 ; IS__CGSCC____: attributes #[[ATTR13]] = { readonly willreturn }
 ; IS__CGSCC____: attributes #[[ATTR14]] = { nounwind }
 ;.

llvm/test/Transforms/Attributor/undefined_behavior.ll

;
   %ptr = call i32* @ret_null()
   store i32 5, i32* %ptr
   ret void
 }
 
 ; -- AtomicRMW tests --
 
 define void @atomicrmw_wholly_unreachable() {
-; IS__TUNIT____: Function Attrs: nofree nounwind readnone willreturn
+; IS__TUNIT____: Function Attrs: nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@atomicrmw_wholly_unreachable
 ; IS__TUNIT____-SAME: () #[[ATTR3:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    unreachable
 ;
-; IS__CGSCC____: Function Attrs: nofree norecurse nounwind readnone willreturn
+; IS__CGSCC____: Function Attrs: norecurse nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@atomicrmw_wholly_unreachable
 ; IS__CGSCC____-SAME: () #[[ATTR3:[0-9]+]] {
 ; IS__CGSCC____-NEXT:    unreachable
 ;
   %a = atomicrmw add i32* null, i32 1 acquire
   ret void
 }
 
 define void @atomicrmw_single_bb_unreachable(i1 %cond) {
-; IS__TUNIT____: Function Attrs: nofree nounwind readnone willreturn
+; IS__TUNIT____: Function Attrs: nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@atomicrmw_single_bb_unreachable
 ; IS__TUNIT____-SAME: (i1 [[COND:%.*]]) #[[ATTR3]] {
 ; IS__TUNIT____-NEXT:    br i1 [[COND]], label [[T:%.*]], label [[E:%.*]]
 ; IS__TUNIT____:       t:
 ; IS__TUNIT____-NEXT:    unreachable
 ; IS__TUNIT____:       e:
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: nofree norecurse nounwind readnone willreturn
+; IS__CGSCC____: Function Attrs: norecurse nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@atomicrmw_single_bb_unreachable
 ; IS__CGSCC____-SAME: (i1 [[COND:%.*]]) #[[ATTR3]] {
 ; IS__CGSCC____-NEXT:    br i1 [[COND]], label [[T:%.*]], label [[E:%.*]]
 ; IS__CGSCC____:       t:
 ; IS__CGSCC____-NEXT:    unreachable
 ; IS__CGSCC____:       e:
 ; IS__CGSCC____-NEXT:    ret void
 ;
   br i1 %cond, label %t, label %e
 t:
   %a = atomicrmw add i32* null, i32 1 acquire
   br label %e
 e:
   ret void
 }
 
 define void @atomicrmw_null_pointer_is_defined() null_pointer_is_valid {
-; IS__TUNIT____: Function Attrs: nofree nounwind null_pointer_is_valid willreturn
+; IS__TUNIT____: Function Attrs: nounwind null_pointer_is_valid willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@atomicrmw_null_pointer_is_defined
 ; IS__TUNIT____-SAME: () #[[ATTR4:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    [[A:%.*]] = atomicrmw add i32* null, i32 1 acquire, align 4
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: nofree norecurse nounwind null_pointer_is_valid willreturn
+; IS__CGSCC____: Function Attrs: norecurse nounwind null_pointer_is_valid willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@atomicrmw_null_pointer_is_defined
 ; IS__CGSCC____-SAME: () #[[ATTR4:[0-9]+]] {
 ; IS__CGSCC____-NEXT:    [[A:%.*]] = atomicrmw add i32* null, i32 1 acquire, align 4
 ; IS__CGSCC____-NEXT:    ret void
 ;
   %a = atomicrmw add i32* null, i32 1 acquire
   ret void
 }
 
 define void @atomicrmw_null_propagated() {
 ; ATTRIBUTOR-LABEL: @atomicrmw_null_propagated(
 ; ATTRIBUTOR-NEXT:    unreachable
 ;
-; IS__TUNIT____: Function Attrs: nofree nounwind readnone willreturn
+; IS__TUNIT____: Function Attrs: nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@atomicrmw_null_propagated
 ; IS__TUNIT____-SAME: () #[[ATTR3]] {
 ; IS__TUNIT____-NEXT:    unreachable
 ;
-; IS__CGSCC____: Function Attrs: nofree norecurse nounwind readnone willreturn
+; IS__CGSCC____: Function Attrs: norecurse nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@atomicrmw_null_propagated
 ; IS__CGSCC____-SAME: () #[[ATTR3]] {
 ; IS__CGSCC____-NEXT:    unreachable
 ;
   %ptr = call i32* @ret_null()
   %a = atomicrmw add i32* %ptr, i32 1 acquire
   ret void
 }
 
 ; -- AtomicCmpXchg tests --
 
 define void @atomiccmpxchg_wholly_unreachable() {
-; IS__TUNIT____: Function Attrs: nofree nounwind readnone willreturn
+; IS__TUNIT____: Function Attrs: nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@atomiccmpxchg_wholly_unreachable
 ; IS__TUNIT____-SAME: () #[[ATTR3]] {
 ; IS__TUNIT____-NEXT:    unreachable
 ;
-; IS__CGSCC____: Function Attrs: nofree norecurse nounwind readnone willreturn
+; IS__CGSCC____: Function Attrs: norecurse nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@atomiccmpxchg_wholly_unreachable
 ; IS__CGSCC____-SAME: () #[[ATTR3]] {
 ; IS__CGSCC____-NEXT:    unreachable
 ;
   %a = cmpxchg i32* null, i32 2, i32 3 acq_rel monotonic
   ret void
 }
 
 define void @atomiccmpxchg_single_bb_unreachable(i1 %cond) {
-; IS__TUNIT____: Function Attrs: nofree nounwind readnone willreturn
+; IS__TUNIT____: Function Attrs: nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@atomiccmpxchg_single_bb_unreachable
 ; IS__TUNIT____-SAME: (i1 [[COND:%.*]]) #[[ATTR3]] {
 ; IS__TUNIT____-NEXT:    br i1 [[COND]], label [[T:%.*]], label [[E:%.*]]
 ; IS__TUNIT____:       t:
 ; IS__TUNIT____-NEXT:    unreachable
 ; IS__TUNIT____:       e:
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: nofree norecurse nounwind readnone willreturn
+; IS__CGSCC____: Function Attrs: norecurse nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@atomiccmpxchg_single_bb_unreachable
 ; IS__CGSCC____-SAME: (i1 [[COND:%.*]]) #[[ATTR3]] {
 ; IS__CGSCC____-NEXT:    br i1 [[COND]], label [[T:%.*]], label [[E:%.*]]
 ; IS__CGSCC____:       t:
 ; IS__CGSCC____-NEXT:    unreachable
 ; IS__CGSCC____:       e:
 ; IS__CGSCC____-NEXT:    ret void
 ;
   br i1 %cond, label %t, label %e
 t:
   %a = cmpxchg i32* null, i32 2, i32 3 acq_rel monotonic
   br label %e
 e:
   ret void
 }
 
 define void @atomiccmpxchg_null_pointer_is_defined() null_pointer_is_valid {
-; IS__TUNIT____: Function Attrs: nofree nounwind null_pointer_is_valid willreturn
+; IS__TUNIT____: Function Attrs: nounwind null_pointer_is_valid willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@atomiccmpxchg_null_pointer_is_defined
 ; IS__TUNIT____-SAME: () #[[ATTR4]] {
 ; IS__TUNIT____-NEXT:    [[A:%.*]] = cmpxchg i32* null, i32 2, i32 3 acq_rel monotonic, align 4
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: nofree norecurse nounwind null_pointer_is_valid willreturn
+; IS__CGSCC____: Function Attrs: norecurse nounwind null_pointer_is_valid willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@atomiccmpxchg_null_pointer_is_defined
 ; IS__CGSCC____-SAME: () #[[ATTR4]] {
 ; IS__CGSCC____-NEXT:    [[A:%.*]] = cmpxchg i32* null, i32 2, i32 3 acq_rel monotonic, align 4
 ; IS__CGSCC____-NEXT:    ret void
 ;
   %a = cmpxchg i32* null, i32 2, i32 3 acq_rel monotonic
   ret void
 }
 
 define void @atomiccmpxchg_null_propagated() {
 ; ATTRIBUTOR-LABEL: @atomiccmpxchg_null_propagated(
 ; ATTRIBUTOR-NEXT:    unreachable
 ;
-; IS__TUNIT____: Function Attrs: nofree nounwind readnone willreturn
+; IS__TUNIT____: Function Attrs: nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@atomiccmpxchg_null_propagated
 ; IS__TUNIT____-SAME: () #[[ATTR3]] {
 ; IS__TUNIT____-NEXT:    unreachable
 ;
-; IS__CGSCC____: Function Attrs: nofree norecurse nounwind readnone willreturn
+; IS__CGSCC____: Function Attrs: norecurse nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@atomiccmpxchg_null_propagated
 ; IS__CGSCC____-SAME: () #[[ATTR3]] {
 ; IS__CGSCC____-NEXT:    unreachable
 ;
   %ptr = call i32* @ret_null()
   %a = cmpxchg i32* %ptr, i32 2, i32 3 acq_rel monotonic
   ret void
 }

 ;
   %ret = call i32* @argument_noundef2(i32* undef)
   ret i32* %ret
 }
 ;.
 ; IS__TUNIT____: attributes #[[ATTR0]] = { nofree nosync nounwind readnone willreturn }
 ; IS__TUNIT____: attributes #[[ATTR1]] = { nofree nosync nounwind null_pointer_is_valid readnone willreturn }
 ; IS__TUNIT____: attributes #[[ATTR2]] = { nofree nosync nounwind null_pointer_is_valid willreturn writeonly }
-; IS__TUNIT____: attributes #[[ATTR3]] = { nofree nounwind readnone willreturn }
-; IS__TUNIT____: attributes #[[ATTR4]] = { nofree nounwind null_pointer_is_valid willreturn }
+; IS__TUNIT____: attributes #[[ATTR3]] = { nounwind readnone willreturn }
+; IS__TUNIT____: attributes #[[ATTR4]] = { nounwind null_pointer_is_valid willreturn }
 ; IS__TUNIT____: attributes #[[ATTR5]] = { nofree noreturn nosync nounwind readnone willreturn }
 ; IS__TUNIT____: attributes #[[ATTR6]] = { argmemonly nofree nosync nounwind willreturn writeonly }
 ; IS__TUNIT____: attributes #[[ATTR7]] = { nofree nosync nounwind willreturn writeonly }
 ;.
 ; IS__CGSCC____: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind readnone willreturn }
 ; IS__CGSCC____: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind null_pointer_is_valid readnone willreturn }
 ; IS__CGSCC____: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind null_pointer_is_valid willreturn writeonly }
-; IS__CGSCC____: attributes #[[ATTR3]] = { nofree norecurse nounwind readnone willreturn }
-; IS__CGSCC____: attributes #[[ATTR4]] = { nofree norecurse nounwind null_pointer_is_valid willreturn }
+; IS__CGSCC____: attributes #[[ATTR3]] = { norecurse nounwind readnone willreturn }
+; IS__CGSCC____: attributes #[[ATTR4]] = { norecurse nounwind null_pointer_is_valid willreturn }
 ; IS__CGSCC____: attributes #[[ATTR5]] = { nofree norecurse noreturn nosync nounwind readnone willreturn }
 ; IS__CGSCC____: attributes #[[ATTR6]] = { argmemonly nofree norecurse nosync nounwind willreturn writeonly }
 ; IS__CGSCC____: attributes #[[ATTR7]] = { nounwind willreturn writeonly }
 ;.

llvm/test/Transforms/FunctionAttrs/atomic.ll

 ; A function with an Acquire load is not readonly.
 define i32 @test2(i32* %x) uwtable ssp {
 ; CHECK: define i32 @test2(i32* nocapture readonly %x) #1 {
 entry:
   %r = load atomic i32, i32* %x seq_cst, align 4
   ret i32 %r
 }
 
-; TODO: Should a function with a Release store be nofree? See discussion on
-; https://reviews.llvm.org/D100676 and https://reviews.llvm.org/D101701.
+; A function with a Release store is not nofree.
 define void @test3(i32* %x) uwtable ssp {
 ; CHECK: define void @test3(i32* nocapture %x) #1 {
 entry:
   store atomic i32 0, i32* %x seq_cst, align 4
   ret void
 }
 
 ; CHECK: attributes #0 = { nofree norecurse nosync nounwind readnone ssp uwtable willreturn mustprogress }
-; CHECK: attributes #1 = { nofree norecurse nounwind ssp uwtable willreturn mustprogress }
+; CHECK: attributes #1 = { norecurse nounwind ssp uwtable willreturn mustprogress }

llvm/test/Transforms/FunctionAttrs/nofree.ll

 ; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* [[P:%.*]], i8 [[VAL:%.*]], i32 8, i1 false)
 ; CHECK-NEXT:    ret void
 ;
   call void @llvm.memset(i8* %p, i8 %val, i32 8, i1 0)
   ret void
 }
 
 define void @memset_volatile(i8* %p, i8 %val) {
-; CHECK: Function Attrs: nofree nounwind willreturn writeonly mustprogress
+; CHECK: Function Attrs: nounwind willreturn writeonly mustprogress
 ; CHECK-LABEL: @memset_volatile(
 ; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* [[P:%.*]], i8 [[VAL:%.*]], i32 8, i1 true)
 ; CHECK-NEXT:    ret void
 ;
   call void @llvm.memset(i8* %p, i8 %val, i32 8, i1 1)
   ret void
 }
 
 declare void @_ZdaPv(i8*) local_unnamed_addr #4
 
 attributes #0 = { uwtable }
 attributes #1 = { nounwind uwtable }
 attributes #2 = { nounwind }
 attributes #3 = { norecurse nounwind readonly uwtable }
 attributes #4 = { nobuiltin nounwind }
 attributes #5 = { builtin nounwind }

llvm/test/Transforms/FunctionAttrs/nosync.ll

 ; CHECK-NEXT:    ret i32 [[A]]
 ;
   %add = add i32 %a, %b
   ret i32 %a
 }
 
 ; negative case - explicit sync
 define void @test5(i8* %p) {
-; CHECK: Function Attrs: nofree norecurse nounwind willreturn mustprogress
+; CHECK: Function Attrs: norecurse nounwind willreturn mustprogress
 ; CHECK-LABEL: @test5(
 ; CHECK-NEXT:    store atomic i8 0, i8* [[P:%.*]] seq_cst, align 1
 ; CHECK-NEXT:    ret void
 ;
   store atomic i8 0, i8* %p seq_cst, align 1
   ret void
 }
 
 ; negative case - explicit sync
 define i8 @test6(i8* %p) {
-; CHECK: Function Attrs: nofree norecurse nounwind willreturn mustprogress
+; CHECK: Function Attrs: norecurse nounwind willreturn mustprogress
 ; CHECK-LABEL: @test6(
 ; CHECK-NEXT:    [[V:%.*]] = load atomic i8, i8* [[P:%.*]] seq_cst, align 1
 ; CHECK-NEXT:    ret i8 [[V]]
 ;
   %v = load atomic i8, i8* %p seq_cst, align 1
   ret i8 %v
 }
 
 ; negative case - explicit sync
 define void @test7(i8* %p) {
-; CHECK: Function Attrs: nofree norecurse nounwind willreturn mustprogress
+; CHECK: Function Attrs: norecurse nounwind willreturn mustprogress
 ; CHECK-LABEL: @test7(
 ; CHECK-NEXT:    [[TMP1:%.*]] = atomicrmw add i8* [[P:%.*]], i8 0 seq_cst, align 1
 ; CHECK-NEXT:    ret void
 ;
   atomicrmw add i8* %p, i8 0 seq_cst, align 1
   ret void
 }
 
 ; negative case - explicit sync
 define void @test8(i8* %p) {
-; CHECK: Function Attrs: nofree norecurse nounwind willreturn mustprogress
+; CHECK: Function Attrs: norecurse nounwind willreturn mustprogress
 ; CHECK-LABEL: @test8(
 ; CHECK-NEXT:    fence seq_cst
 ; CHECK-NEXT:    ret void
 ;
   fence seq_cst
   ret void
 }
 
 ; singlethread fences are okay
 define void @test9(i8* %p) {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn mustprogress
 ; CHECK-LABEL: @test9(
 ; CHECK-NEXT:    fence syncscope("singlethread") seq_cst
 ; CHECK-NEXT:    ret void
 ;
   fence syncscope("singlethread") seq_cst
   ret void
 }
 
 ; atomic load with monotonic ordering
 define i32 @load_monotonic(i32* nocapture readonly %0) norecurse nounwind uwtable {
-; CHECK: Function Attrs: nofree norecurse nounwind uwtable willreturn mustprogress
+; CHECK: Function Attrs: norecurse nounwind uwtable willreturn mustprogress
 ; CHECK-LABEL: @load_monotonic(
 ; CHECK-NEXT:    [[TMP2:%.*]] = load atomic i32, i32* [[TMP0:%.*]] monotonic, align 4
 ; CHECK-NEXT:    ret i32 [[TMP2]]
 ;
   %2 = load atomic i32, i32* %0 monotonic, align 4
   ret i32 %2
 }
 
 ; atomic store with monotonic ordering.
 define void @store_monotonic(i32* nocapture %0) norecurse nounwind uwtable {
-; CHECK: Function Attrs: nofree norecurse nounwind uwtable willreturn mustprogress
+; CHECK: Function Attrs: norecurse nounwind uwtable willreturn mustprogress
 ; CHECK-LABEL: @store_monotonic(
 ; CHECK-NEXT:    store atomic i32 10, i32* [[TMP0:%.*]] monotonic, align 4
 ; CHECK-NEXT:    ret void
 ;
   store atomic i32 10, i32* %0 monotonic, align 4
   ret void
 }
 
 ; negative, should not deduce nosync
 ; atomic load with acquire ordering.
 define i32 @load_acquire(i32* nocapture readonly %0) norecurse nounwind uwtable {
-; CHECK: Function Attrs: nofree norecurse nounwind uwtable willreturn mustprogress
+; CHECK: Function Attrs: norecurse nounwind uwtable willreturn mustprogress
 ; CHECK-LABEL: @load_acquire(
 ; CHECK-NEXT:    [[TMP2:%.*]] = load atomic i32, i32* [[TMP0:%.*]] acquire, align 4
 ; CHECK-NEXT:    ret i32 [[TMP2]]
 ;
   %2 = load atomic i32, i32* %0 acquire, align 4
   ret i32 %2
 }
 
;
   store atomic i32 10, i32* %0 unordered, align 4
   ret void
 }
 
 
 ; negative, should not deduce nosync
 ; atomic load with release ordering
 define void @load_release(i32* nocapture %0) norecurse nounwind uwtable {
-; CHECK: Function Attrs: nofree norecurse nounwind uwtable willreturn mustprogress
+; CHECK: Function Attrs: norecurse nounwind uwtable willreturn mustprogress
 ; CHECK-LABEL: @load_release(
 ; CHECK-NEXT:    store atomic volatile i32 10, i32* [[TMP0:%.*]] release, align 4
 ; CHECK-NEXT:    ret void
 ;
   store atomic volatile i32 10, i32* %0 release, align 4
   ret void
 }
 
 ; negative volatile, relaxed atomic
 define void @load_volatile_release(i32* nocapture %0) norecurse nounwind uwtable {
-; CHECK: Function Attrs: nofree norecurse nounwind uwtable willreturn mustprogress
+; CHECK: Function Attrs: norecurse nounwind uwtable willreturn mustprogress
 ; CHECK-LABEL: @load_volatile_release(
 ; CHECK-NEXT:    store atomic volatile i32 10, i32* [[TMP0:%.*]] release, align 4
 ; CHECK-NEXT:    ret void
 ;
   store atomic volatile i32 10, i32* %0 release, align 4
   ret void
 }
 
 ; volatile store.
 define void @volatile_store(i32* %0) norecurse nounwind uwtable {
-; CHECK: Function Attrs: nofree norecurse nounwind uwtable willreturn mustprogress
+; CHECK: Function Attrs: norecurse nounwind uwtable willreturn mustprogress
 ; CHECK-LABEL: @volatile_store(
 ; CHECK-NEXT:    store volatile i32 14, i32* [[TMP0:%.*]], align 4
 ; CHECK-NEXT:    ret void
 ;
   store volatile i32 14, i32* %0, align 4
   ret void
 }
 
 ; negative, should not deduce nosync
 ; volatile load.
 define i32 @volatile_load(i32* %0) norecurse nounwind uwtable {
-; CHECK: Function Attrs: nofree norecurse nounwind uwtable willreturn mustprogress
+; CHECK: Function Attrs: norecurse nounwind uwtable willreturn mustprogress
 ; CHECK-LABEL: @volatile_load(
 ; CHECK-NEXT:    [[TMP2:%.*]] = load volatile i32, i32* [[TMP0:%.*]], align 4
 ; CHECK-NEXT:    ret i32 [[TMP2]]
 ;
   %2 = load volatile i32, i32* %0, align 4
   ret i32 %2
 }