[Attr] Introduce dereferenceable_globally

[jdoerfert]

Summary

The current uses of the "dereferenceable" attribute throughout
LLVM/Clang are not consistent in their interpretation of the semantics.

Clang, and some parts of LLVM, assume the annotated pointer value to be
dereferenceable "now", thus at the program point where the annotation is
(which happens to be the definition of the value).

LLVM optimizations and high-level front-ends tend to interpret the
dereferenceable attribute as a persistent property for the pointer.

Now having different interpretations is obviously problematic [1].

There has been ample discussion about which definition we should use and
which one should get its very own attribute [1,2]. (That we need both
seems to be unanimously accepted.)

With this patch we limit the meaning of "dereferenceable" to
"dereferenceable at the definition of the value".
For dereferenceability stretching the whole lifetime of a pointer value,
or at least all program points where the SSA value can be accessed, we
introduced "dereferenceable_in_globally".

Some pros and cons where summarized by @hfinkel [6].

The most important reason why we should go this way is that this
change is conservatively correct with regards to existing/currently
produced IR. This is especially important because auto-update is not
applicable when we keep the original dereferenceable name around (what
was updated what wasn't?). Again, this will not break front-ends that
produce dereferenceable attributes/metadata, regardless of which (of the
two) interpretations they use. This way forward was also "suggested" by
@rsmith [3] and @chandlerc [4]. The alternative approach, which was
preferred by people as well ([5] to highlight only one), gives us
"correct" and "better" optimizations but defines existing IR as broken.

Either way, it is clear that we need to fix something and introduce a
new attribute.

[1] http://lists.llvm.org/pipermail/llvm-dev/2018-July/124555.html
[2] https://reviews.llvm.org/D48239
[3] https://reviews.llvm.org/D48239#1135582
[4] https://reviews.llvm.org/D48239#1155026
[5] https://reviews.llvm.org/D48239#1134816
[6] http://lists.llvm.org/pipermail/llvm-dev/2018-July/124557.html

[jdoerfert]

This patch goes the opposite way as proposed by D48239 and adds the new attribute we will need either way.

[jdoerfert]

ping

[efriedma]

I'm fine with this. Probably worth adding a release note.

[sanjoy]

llvm/docs/LangRef.rst

1166

I'm not sure if this is a good semantic property. Consider (the CFG form of):

if (cond) {
  a = dereferenceable_in_scope(4) ...
} else {
  ...
}
side_effect_that_frees_a()

I think this program above is well defined because the definition of a does not dominate side_effect_that_frees_a(). But that means we can't tail duplicate the program into:

if (cond) {
  a = dereferenceable_in_scope(4) ...
  side_effect_that_frees_a()
} else {
  ...
  side_effect_that_frees_a()
}

Same applies for inlining. Any transform that can extend the dominance region of some value needs to be audited.

What is the use case for this attribute? Can we do something more targeted for this use case?

[jdoerfert]

llvm/docs/LangRef.rst

1166

What is the use case for this attribute? Can we do something more targeted for this use case?

My "use case" is basically the clang interpretation of (current) derferenceable which I tried to replicate with the new derferenceable definition. There are users of (current) derferenceable that interpret it as derferenceable_in_scope and they should have a way to do so.

I think this program above is well defined because the definition of a does not dominate
Same applies for inlining. Any transform that can extend the dominance region of some value needs to be audited.

I agree that there is a problem with the current wording wrt. inlining. I'll try to fix that.
Maybe @reames can help me define what they want/need.

For the record, the example above is not sufficient to expose the inlining problem though. Above, a was "accessible" at the location where a was freed, so the dereferenceable_in_scope was violated already. Thinking about it, even if we inline, SSA dominance property should be combined with reachability to a user to give you what you want.

[sanjoy]

llvm/docs/LangRef.rst

1166

I agree that there is a problem with the current wording wrt. inlining. I'll try to fix that. Maybe @reames can help me define what they want/need.

Maybe we need something stronger that says that a pointer is always dereferenceable(n), like a global variable?

Thinking about it, even if we inline, SSA dominance property should be combined with reachability to a user to give you what you want.

I was thinking about something like:

void f() {
  a = dereferenceable_in_scope(4) ...
}

void main() {
  f();
  free_a();
}

I think this is well defined according to the current wording since the free_a does not lie within the scope of a? If yes, then inlining becomes illegal.

[jdoerfert]

llvm/docs/LangRef.rst

1166

What do you think about dereferenceable_globally(<n>), which would be the wording without the "in its scope (asdefined by the SSA dominance property)"?

So:

This indicates that the annotated pointer value has the
``dereferenceable(<n>)`` property *at any program point*. Thus, unlike pointer values
annotated with ``dereferenceable(<n>)``, ``dereferenceable_in_scope(<n>)``
pointer values can never lose the ``dereferenceable(<n>)``.

[sanjoy]

llvm/docs/LangRef.rst

1166

I think this is implied, but how about "the annotated pointer value has the
`dereferenceable(<n>)` starting from the definition of the value to the termination of the program."?

[reames]

I think the framing of this in terms of scopes is likely to be problematic. The current definition of dereferenceable is (I think) *stronger* than a simple assertion of the dereferenceability within a particular scope. As an example, consider:
call void @foo(i8* dereferenceable(8) %p)
call void @may_trap_but_not_write()
%val = load i64, i64 @G

In this example, the current semantic seem to allow the load to be lifted above the second call, even though it is *not* contained within any scope marked dereferenceable. Now, that's my understanding of the current wording, but I have to admit, I can't find an optimization which actually does that style of reasoning, so maybe I'm mistaken.

Switching topics, I have a much more fundamental objection to your patch which comes in two parts.

Part 1 - By introducing a new attribute and not switching *all* users within the optimizer over, you are implicitly a) causing a bunch of miscompiles and b) setting up a situation where optimizations are likely to be weakened to "fix" bugs. This to me is a showstopper with the current patch, and on this basis I *strongly object* to this landing without this being addressed.

Part 2 - It's really not clear to me that your weaker "deref on entry" is strong enough for any useful optimization. This seems conceptually similar to a "llvm.mark_deref_here" intrinsic which just happens to be placed at the begining of each function. The problem with such a marker is that you can't (by the intention you've laid out), use it's presence for any path insensative reasoning. So for instance, you *can't* use isSafeToSpeculate's context free speculation or LICM's path insensative hoisting/sinking.

My concern here is purely a generic "is this worth the complexity" one. If you and others are strongly motivated to have a semantic like this, I will not resist. In your shoes, I would want to prototype out some key pieces, and would maybe start with an intrinsic before moving straight to an attribute/metadata.

[jdoerfert]

Replace "scope" with "globally" (or global scope).

[jdoerfert]

In D61652#1504093, @reames wrote:

I think the framing of this in terms of scopes is likely to be problematic. The current definition of dereferenceable is (I think) *stronger* than a simple assertion of the dereferenceability within a particular scope. As an example, consider:
call void @foo(i8* dereferenceable(8) %p)
call void @may_trap_but_not_write()
%val = load i64, i64 @G

In this example, the current semantic seem to allow the load to be lifted above the second call, even though it is *not* contained within any scope marked dereferenceable. Now, that's my understanding of the current wording, but I have to admit, I can't find an optimization which actually does that style of reasoning, so maybe I'm mistaken.

The discussion with @sanjoy lead to the change from scope to globally, maybe that resolves this?

Switching topics, I have a much more fundamental objection to your patch which comes in two parts.

Part 1 - By introducing a new attribute and not switching *all* users within the optimizer over, you are implicitly a) causing a bunch of miscompiles and b) setting up a situation where optimizations are likely to be weakened to "fix" bugs. This to me is a showstopper with the current patch, and on this basis I *strongly object* to this landing without this being addressed.

The situation right now is that LLVM is broken. The front-end and middle-end disagree over the definition of dereferenceable. That is a problem because we cannot even "fix" because we don't know what part is "right" and what part is "wrong".

The situation after this patch would be the same but we would define which parts of LLVM are "wrong", the front-end or the middle-end (it would be the middle-end). This is a prerequirement to fixing LLVM as it is.

The only alternative (I see) is to define dereferenceable as dereferenceable_globally and introduce dereferenceable_here which would encode what Clang uses dereferenceable today for. I'd prefer it this way but at the end of the day, I need some disambiguation to start fixing the existing code.

Part 2 - It's really not clear to me that your weaker "deref on entry" is strong enough for any useful optimization. This seems conceptually similar to a "llvm.mark_deref_here" intrinsic which just happens to be placed at the begining of each function. The problem with such a marker is that you can't (by the intention you've laid out), use it's presence for any path insensative reasoning. So for instance, you *can't* use isSafeToSpeculate's context free speculation or LICM's path insensative hoisting/sinking.

You can't use this reasoning, correct. However, we do right now when Clang uses dereferenceable for dereferenceable_on_entry for lowering C++ references.

I wan this because I assume we have "deref on entry" annotation and an analysis that could reason about "no-free" for functions (D49165 integrated into D59918), we could propagate this annotation to pointer uses which would make it useful. Agreed?

My concern here is purely a generic "is this worth the complexity" one. If you and others are strongly motivated to have a semantic like this, I will not resist. In your shoes, I would want to prototype out some key pieces, and would maybe start with an intrinsic before moving straight to an attribute/metadata.

The main motivation is that this is broken right now. If we start to deduce and propagate dereferenceable we will expose these inconsistencies. I want to get ahead and make the semantics clear so we can decide which parts have to be fixed.

[jdoerfert]

Grammar + reintroduce existing "pointer only" restriction

[jdoerfert]

ping (@reames ?)

[reames]

In D61652#1504840, @jdoerfert wrote:

In D61652#1504093, @reames wrote:

I think the framing of this in terms of scopes is likely to be problematic. The current definition of dereferenceable is (I think) *stronger* than a simple assertion of the dereferenceability within a particular scope. As an example, consider:
call void @foo(i8* dereferenceable(8) %p)
call void @may_trap_but_not_write()
%val = load i64, i64 @G

In this example, the current semantic seem to allow the load to be lifted above the second call, even though it is *not* contained within any scope marked dereferenceable. Now, that's my understanding of the current wording, but I have to admit, I can't find an optimization which actually does that style of reasoning, so maybe I'm mistaken.

The discussion with @sanjoy lead to the change from scope to globally, maybe that resolves this?

It does. The globally wording seems broad enough. You're missing a bunch of detail from the original spec which needs to be preserved, but the basic notion seems reasonable.

Switching topics, I have a much more fundamental objection to your patch which comes in two parts.

Part 1 - By introducing a new attribute and not switching *all* users within the optimizer over, you are implicitly a) causing a bunch of miscompiles and b) setting up a situation where optimizations are likely to be weakened to "fix" bugs. This to me is a showstopper with the current patch, and on this basis I *strongly object* to this landing without this being addressed.

The situation right now is that LLVM is broken. The front-end and middle-end disagree over the definition of dereferenceable. That is a problem because we cannot even "fix" because we don't know what part is "right" and what part is "wrong".

Ok, no. I'm going to have to be really pedantic about this. *Clang* might be broken, but LLVM is not. Clang is simple one of several frontends which target LLVM. If Clang chose to ignore the documented meaning of an attribute, well, that's too bad for Clang.

To be clear here, I am not objecting to the addition of an attribute which fits the behaviour Clang wants. I am *strongly* objecting to the notion that it's okay to break other frontends which got it right because Clang didn't. To be very explicit, this patch as currently posted would badly break our Java frontend.

I would strongly suggest that you leave the existing attribute with the existing meaning and introduce a new dereferenceable_at_entry attribute with your desired semantics. I won't actively object to introducing a new attribute with the prior semantics and requiring a rename for frontends which used the old one correctly, but even that feels distinctly hostile to other frontends. It's not an acute issue for us, so I won't fight it actively, but the attitude it conveys is not exactly welcoming for new frontends.

[jdoerfert]

In D61652#1520190, @reames wrote:

In D61652#1504840, @jdoerfert wrote:

In D61652#1504093, @reames wrote:

I think the framing of this in terms of scopes is likely to be problematic. The current definition of dereferenceable is (I think) *stronger* than a simple assertion of the dereferenceability within a particular scope. As an example, consider:
call void @foo(i8* dereferenceable(8) %p)
call void @may_trap_but_not_write()
%val = load i64, i64 @G

In this example, the current semantic seem to allow the load to be lifted above the second call, even though it is *not* contained within any scope marked dereferenceable. Now, that's my understanding of the current wording, but I have to admit, I can't find an optimization which actually does that style of reasoning, so maybe I'm mistaken.

The discussion with @sanjoy lead to the change from scope to globally, maybe that resolves this?

It does. The globally wording seems broad enough. You're missing a bunch of detail from the original spec which needs to be preserved, but the basic notion seems reasonable.

Please elaborate on the details I'm missing, I want to get this "right". Even if we do not take this approach but the opposite one, I think we should clarify everything as good as possible. I say this also because I personally do not think the Clang interpretation violates the current wording of dereferenceable. While the intention is not 100% known to me [1], the wording right now is vague enough to be interpreted either way, or maybe even some other way. With the proposed patch, both versions have the same wording "a pointer is dereferenceable" as the current attribute has. The meaning is disambiguated only due to the added specifiers.

[1] According to r213385, the commit that introduced the attribute, C++ references were a use case. This would make the Clang interpretation the intended one. Though, the problems that come with that interpretation were not discussed/considered at that time.

Switching topics, I have a much more fundamental objection to your patch which comes in two parts.

Part 1 - By introducing a new attribute and not switching *all* users within the optimizer over, you are implicitly a) causing a bunch of miscompiles and b) setting up a situation where optimizations are likely to be weakened to "fix" bugs. This to me is a showstopper with the current patch, and on this basis I *strongly object* to this landing without this being addressed.

The situation right now is that LLVM is broken. The front-end and middle-end disagree over the definition of dereferenceable. That is a problem because we cannot even "fix" because we don't know what part is "right" and what part is "wrong".

Ok, no. I'm going to have to be really pedantic about this. *Clang* might be broken, but LLVM is not. Clang is simple one of several frontends which target LLVM. If Clang chose to ignore the documented meaning of an attribute, well, that's too bad for Clang.

I guess my comment from above represents my view point. Though, I actually do not care who is right and wrong (see below).

To be clear here, I am not objecting to the addition of an attribute which fits the behaviour Clang wants. I am *strongly* objecting to the notion that it's okay to break other frontends which got it right because Clang didn't. To be very explicit, this patch as currently posted would badly break our Java frontend.

I would strongly suggest that you leave the existing attribute with the existing meaning and introduce a new dereferenceable_at_entry attribute with your desired semantics. I won't actively object to introducing a new attribute with the prior semantics and requiring a rename for frontends which used the old one correctly, but even that feels distinctly hostile to other frontends. It's not an acute issue for us, so I won't fight it actively, but the attitude it conveys is not exactly welcoming for new frontends.

By making the existing attribute spelling less powerful I take away optimization opportunities for front-ends until they moved to deref_globally but I don't see how that would break them.
I proposed this solution not to make "Clang correct" but because I think it does not "break" anything. Doing it the other way around, however, would make old Clang code definitively invalid.

[jdoerfert]

@reames What do you think?

[jdoerfert]

@reames Ping?

[jdoerfert]

Remove the alignment part

[hfinkel]

This LGTM. I suggest that we commit this along with the implementation.

llvm/docs/LangRef.rst

1158

We also need to add the "at its definition" qualifier here?

1158

Ignore this (old comment).

[jdoerfert]

Add argument definitions

[reames]

Sorry for the late reply. Replying selectively to key points.

In D61652#1520287, @jdoerfert wrote:

The discussion with @sanjoy lead to the change from scope to globally, maybe that resolves this?

It does. The globally wording seems broad enough. You're missing a bunch of detail from the original spec which needs to be preserved, but the basic notion seems reasonable.

Please elaborate on the details I'm missing,

The main thing is your missing the wording about restrictions on where the attribute can be applied (i.e. pointer types). Reading the existing dereferenceable_or_null wording more careful, we have precedent for just assuming it carries over to other dereferenceable* flavours, so I'll drop this objection. I may separately post a patch to refine the wording, but this is not a key issue.

Now, my remaining concern. This patch, as structured, introduces a number of purely definitional miscompiles into LLVM. There are existing transformations which assume the dereferenceable global property for correctness. By introducing a new attribute with the old semantics, and not updating all of the existing code to use the new attribute (code, tests, etc..), you're are defining (via the langref change) existing optimizations to be incorrect.

I really don't think that's okay. Particular, since it should be very easy to fix. A simple find replace in source and tests which replaces checks for dereferenceable with checks for dereferenceable_globally should be all that's needed.

I'm specifically asking that this change not be committed - despite Hal's LGTM - before this point is addressed.

p.s. I wouldn't be thrilled by it, but I'd even be okay with a clear statement of intent to handle this in follow up changes. It is more of a theoretical problem than a practical one in the near term.

[hfinkel]

I'm specifically asking that this change not be committed - despite Hal's LGTM - before this point is addressed.

I'm fine with this too. We'll soon have the nofree/nosync patches/functionality which can be used to change everything over in a hopefully-reasonable fashion.

[jdoerfert]

In D61652#1540722, @reames wrote:

Sorry for the late reply. Replying selectively to key points.

In D61652#1520287, @jdoerfert wrote:

The discussion with @sanjoy lead to the change from scope to globally, maybe that resolves this?

It does. The globally wording seems broad enough. You're missing a bunch of detail from the original spec which needs to be preserved, but the basic notion seems reasonable.

Please elaborate on the details I'm missing,

The main thing is your missing the wording about restrictions on where the attribute can be applied (i.e. pointer types). Reading the existing dereferenceable_or_null wording more careful, we have precedent for just assuming it carries over to other dereferenceable* flavours, so I'll drop this objection. I may separately post a patch to refine the wording, but this is not a key issue.

Now, my remaining concern. This patch, as structured, introduces a number of purely definitional miscompiles into LLVM. There are existing transformations which assume the dereferenceable global property for correctness. By introducing a new attribute with the old semantics, and not updating all of the existing code to use the new attribute (code, tests, etc..), you're are defining (via the langref change) existing optimizations to be incorrect.

I really don't think that's okay. Particular, since it should be very easy to fix. A simple find replace in source and tests which replaces checks for dereferenceable with checks for dereferenceable_globally should be all that's needed.

I'm specifically asking that this change not be committed - despite Hal's LGTM - before this point is addressed.

p.s. I wouldn't be thrilled by it, but I'd even be okay with a clear statement of intent to handle this in follow up changes. It is more of a theoretical problem than a practical one in the near term.

I'm working on all the remaining changes now and I'll update this patch with the mechanics first before I create a new one to move the users.
We can wait with committing both until we merged the nofree and nosync patches and I updated the isDerefPointer helper function to use them.
Would that be OK?

[reames]

In D61652#1540764, @jdoerfert wrote:

I'm working on all the remaining changes now and I'll update this patch with the mechanics first before I create a new one to move the users.
We can wait with committing both until we merged the nofree and nosync patches and I updated the isDerefPointer helper function to use them.
Would that be OK?

Absolutely. That's exactly what I'm asking for.

[jdoerfert]

Add all the mechanics for dereferenceable_globally we have for dereferenceable

[jdoerfert]

The getter/setter functions are called "DereferenceableBytesGlobally" not "DereferenceableGloballyBytes". I would like to get some feedback on this.

[reames]

Wow, we have a huge amount of boilerplate when adding an attribute.

Minor comments only. Seems straight forward and I didn't see any copy paste errors.

llvm/include/llvm/IR/Argument.h

67

For consistency, I'd prefer getDereferenableGloballyBytes. Doesn't read well, but it's consistent with all the other naming.

llvm/lib/IR/Verifier.cpp

4114–4115

Very minor style item, since we have multple of these now, maybe:
for (auto ID : {MD_...})

if (MDNode ...)
  visitDeref(...)

[jdoerfert]

Addressed comments: Getter/Setter rename + for loop

[jdoerfert]

In D61652#1540888, @reames wrote:

Wow, we have a huge amount of boilerplate when adding an attribute.

I agree...

Minor comments only. Seems straight forward and I didn't see any copy paste errors.

Thanks for checking, I passed run test and including the new ones for the new attributes but you never know.

[jdoerfert]

Minor fixes

[jdoerfert]

DereferenceableOrNullBytesGlobally -> DereferenceableOrNullGloballyBytes

[jdoerfert]

@reames Was the last comment a "LGTM"? I need to start getting these patches of my plate :(

[reames]

In D61652#1555590, @jdoerfert wrote:

@reames Was the last comment a "LGTM"? I need to start getting these patches of my plate :(

Yes.

[jdoerfert]

Rename leftover cases

[uenoku]

Hi, how is this patch going?

[RalfJung]

llvm/docs/LangRef.rst

1170

In Rust, we are using the existing dereferenceable attribute on function parameters, and we are generally happy with its semantics, which we interpreted to be "this pointer is dereferenceable for the entire duration of this function call". We automatically set this attribute for all references passed to a function, which in Rust (unlike in C++) are guaranteed to not be deallocated while the function is ongoing.

However, the new dereferenceable_globally that is being proposed here is useless for us: even memory pointed to by references *does* eventually get deallocated. We hence cannot set that attribute. So, the patch as proposed constitutes a big regression in terms of the kind of information that the Rust frontend can provide to LLVM.

[jdoerfert]

llvm/docs/LangRef.rst

1170

My first thought: dereferenceable + nofree on the argument should give you the semantics you think dereferenceable has now.

I will ping you once I rebase the updated users of dereferenceable which will then look at the new ones (nofree, dereferenceable_globally, ..) as well.

[jdoerfert]

llvm/docs/LangRef.rst

1170

Slight correction:
dereferenceable + nosync (on the function) + nofree (on the arg or function) should do it, same as
dereferenceable + noalias (on the argument) + nofree (on the argument or function)

We might want to have a nosync on an argument as well to allow fine granularity here.

[xbolva00]

Hello,

please update CodeGen/Analysis.cpp too - attributesPermitTailCall.

[rkruppe]

llvm/docs/LangRef.rst

1170

Rust can't really emit nosync, at least not without doing just as much IPO and analysis as LLVM would have to infer it by itself (and failing to infer it at least as often). Nothing about the language rules out synchronization happening anywhere. Furthermore, the majority of Rust code can't possibly be nosync even with perfect attribute inference, because a ton of code can potentially panic and (in most configurations) panicking involves some synchronization.

I also doubt nosync can usefully be made more granular (e.g. restricted to individual allocations): happens-before is a superset of inter-thread program order, so any synchronization at all will make all previous non-atomic stores visible to other threads, regardless of what parts of memory they affected.

Luckily, the second option (dereferenceable + noalias + nofree on argument) is feasible for Rust. At least for immutable references. There are too many miscompiles with noalias+mutation, so we don't currently add noalias or anything like that to mutable references. That needs to be fixed eventually, but as long as it lasts, we can't emit dereferenceable+noalias+nofree for mutable references. But maybe it won't be worse than before the change to dereferenceable, since exploiting dereferenceability is difficult without aliasing information in any case.

[RalfJung]

llvm/docs/LangRef.rst

1170

My first thought: dereferenceable + nofree on the argument should give you the semantics you think dereferenceable has now.

Ah, I as not aware that nofree was an attribute for function arguments. That is good to know.

However, doesn't nofree have all the same hard questions of scope as dereferencable_in_scope? In other words, couldn't the stronger "dereferencable" that gets added as a substitute for the current semantics also be tied to the scope of the current function, as opposed to tying it somehow to the liveness of an SSE value (which did not work out)?

[jdoerfert]

llvm/docs/LangRef.rst

1170

However, doesn't nofree have all the same hard questions of scope as dereferencable_in_scope? In other words, couldn't the stronger "dereferencable" that gets added as a substitute for the current semantics also be tied to the scope of the current function, as opposed to tying it somehow to the liveness of an SSE value (which did not work out)?

We reasonably could, that was my first approach actually. Arguably we could even have 3 deref attributes. The difference compared to other attributes is that people want "deref globally" in other contexts (which also implies "nofree globally" for example).

@rkruppe Can you point me to the bug reports wrt. noalias?

[rkruppe]

llvm/docs/LangRef.rst

1170

Can you point me to the bug reports wrt. noalias?

https://bugs.llvm.org/show_bug.cgi?id=39282

(if you mean the Rust issues, the above bug report references them)

[reames]

Removing self from old stale review.

llvm/docs/LangRef.rst

 
 ``nonnull``
     This indicates that the parameter or return pointer is not null. This
     attribute may only be applied to pointer typed parameters. This is not
     checked or enforced by LLVM; if the parameter or return pointer is null,
     the behavior is undefined.
 
 ``dereferenceable(<n>)``
-    This indicates that the parameter or return pointer is dereferenceable. This
-    attribute may only be applied to pointer typed parameters. A pointer that
-    is dereferenceable can be loaded from speculatively without a risk of
-    trapping. The number of bytes known to be dereferenceable must be provided
-    in parentheses. It is legal for the number of bytes to be less than the
-    size of the pointee type. The ``nonnull`` attribute does not imply
-    dereferenceability (consider a pointer to one element past the end of an
-    array), however ``dereferenceable(<n>)`` does imply ``nonnull`` in
-    ``addrspace(0)`` (which is the default address space).
+    This indicates that the annotated value, e.g., a parameter or return
+    value, is dereferenceable *at its definition*, which would be the beginning
+    of the function entry or the call site for annotated parameters and return
+    values respectively. This attribute may only be applied to values with
+    pointer type. A pointer that is known to be dereferenceable can be loaded
+    from speculatively without a risk of trapping. The number of bytes known to
+    be dereferenceable must be provided in parentheses. It is legal for the
+    number of bytes to be less than the size of the pointee type. If, at
+    runtime, the annotated pointer is not dereferenceable, the behavior is
+    undefined. The ``nonnull`` attribute does not imply dereferenceability
+    (consider a pointer to one element past the end of an array), however
+    ``dereferenceable(<n>)`` does imply ``nonnull`` in ``addrspace(0)`` (which
+    is the default address space). The dereferenceability property provided
+    through this argument is tied to the definition because it can be lost,
+    e.g., via a call to ``free``. Use ``dereferenceable_globally(<n>)`` for
+    pointer values that cannot be deallocated.
 
 ``dereferenceable_or_null(<n>)``
     This indicates that the parameter or return value isn't both
     non-null and non-dereferenceable (up to ``<n>`` bytes) at the same
     time. All non-null pointers tagged with
     ``dereferenceable_or_null(<n>)`` are ``dereferenceable(<n>)``.
     For address space 0 ``dereferenceable_or_null(<n>)`` implies that
     a pointer is exactly one of ``dereferenceable(<n>)`` or ``null``,
     and in other address spaces ``dereferenceable_or_null(<n>)``
     implies that a pointer is at least one of ``dereferenceable(<n>)``
-    or ``null`` (i.e. it may be both ``null`` and
-    ``dereferenceable(<n>)``). This attribute may only be applied to
-    pointer typed parameters.
+    or ``null`` (i.e. it may be both ``null`` and ``dereferenceable(<n>)``).
+    This attribute may only be applied to pointer typed parameters.
+
+``dereferenceable_globally(<n>)``
+    This indicates that the annotated pointer value has the
+    ``dereferenceable(<n>)`` property *at any program point*, starting from the
+    definition of the value to the termination of the program. Thus, unlike
+    pointer values annotated with ``dereferenceable(<n>)``,
+    ``dereferenceable_globally(<n>)`` pointer values can never lose the
+    ``dereferenceable(<n>)`` property.
+
+``dereferenceable_or_null_globally(<n>)``
+    This indicates that the annotated pointer value has the
+    ``dereferenceable_or_null(<n>)`` property *at any program point*, starting
+    from the definition of the value to the termination of the program. Thus,
+    unlike pointer values annotated with ``dereferenceable_or_null(<n>)``,
+    ``dereferenceable_or_null_globally(<n>)`` pointer values can never lose the
+    ``dereferenceable_or_null(<n>)`` property.
 
 ``swiftself``
     This indicates that the parameter is the self/context parameter. This is not
     a valid attribute for return values and can only be applied to one
     parameter.
 
 ``swifterror``
     This attribute is motivated to model and optimize Swift error handling. It

 '``load``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      <result> = load [volatile] <ty>, <ty>* <pointer>[, align <alignment>][, !nontemporal !<index>][, !invariant.load !<index>][, !invariant.group !<index>][, !nonnull !<index>][, !dereferenceable !<deref_bytes_node>][, !dereferenceable_or_null !<deref_bytes_node>][, !align !<align_node>]
+      <result> = load [volatile] <ty>, <ty>* <pointer>[, align <alignment>][, !nontemporal !<index>][, !invariant.load !<index>][, !invariant.group !<index>][, !nonnull !<index>][, !dereferenceable !<deref_bytes_node>][, !dereferenceable_or_null !<deref_bytes_node>][, !dereferenceable_globally !<deref_bytes_node>][, !dereferenceable_or_null_globally !<deref_bytes_node>][, !align !<align_node>]
       <result> = load atomic [volatile] <ty>, <ty>* <pointer> [syncscope("<target-scope>")] <ordering>, align <alignment> [, !invariant.group !<index>]
       !<index> = !{ i32 1 }
       !<deref_bytes_node> = !{i64 <dereferenceable_bytes>}
       !<align_node> = !{ i64 <value_alignment> }
 
 Overview:
 """""""""
 

 The optional ``!nonnull`` metadata must reference a single
 metadata name ``<index>`` corresponding to a metadata node with no
 entries. The existence of the ``!nonnull`` metadata on the
 instruction tells the optimizer that the value loaded is known to
 never be null. If the value is null at runtime, the behavior is undefined.
 This is analogous to the ``nonnull`` attribute on parameters and return
 values. This metadata can only be applied to loads of a pointer type.
 
-The optional ``!dereferenceable`` metadata must reference a single metadata
+The optional ``!dereferenceable`` and ``!dereferenceable_globally`` metadata
+must reference a single metadata name ``<deref_bytes_node>`` corresponding to a
+metadata node with one ``i64`` entry. The existence of the ``!dereferenceable``
+or ``!dereferenceable_globally`` metadata on the instruction tells the
+optimizer that the value loaded is known to be dereferenceable at its
+definition, in the case of ``!dereferenceable``, or globally, in the case of
+``!dereferenceable_globally``. The number of bytes known to be dereferenceable
+is specified by the integer value in the metadata node. This is analogous to
+the ''dereferenceable'' and ''dereferenceable_globally'' attribute on
+parameters and return values. This metadata can only be applied to loads of a
+pointer type.
+
+The optional ``!dereferenceable_or_null`` and
+``!dereferenceable_or_null_globally`` metadata must reference a single metadata
 name ``<deref_bytes_node>`` corresponding to a metadata node with one ``i64``
-entry. The existence of the ``!dereferenceable`` metadata on the instruction
-tells the optimizer that the value loaded is known to be dereferenceable.
-The number of bytes known to be dereferenceable is specified by the integer
-value in the metadata node. This is analogous to the ''dereferenceable''
-attribute on parameters and return values. This metadata can only be applied
-to loads of a pointer type.
-
-The optional ``!dereferenceable_or_null`` metadata must reference a single
-metadata name ``<deref_bytes_node>`` corresponding to a metadata node with one
-``i64`` entry. The existence of the ``!dereferenceable_or_null`` metadata on the
-instruction tells the optimizer that the value loaded is known to be either
-dereferenceable or null.
-The number of bytes known to be dereferenceable is specified by the integer
-value in the metadata node. This is analogous to the ''dereferenceable_or_null''
-attribute on parameters and return values. This metadata can only be applied
-to loads of a pointer type.
+entry. The existence of the ``!dereferenceable_or_null`` or
+``!dereferenceable_or_null_globally`` metadata on the instruction tells the
+optimizer that the value loaded is known to be either dereferenceable or null
+at its definition, in the case of ``!dereferenceable``, or globally, in the
+case of ``!dereferenceable_globally``. The number of bytes known to be
+dereferenceable is specified by the integer value in the metadata node. This is
+analogous to the ''dereferenceable_or_null'' and
+''dereferenceable_or_null_globally'' attribute on parameters and return values.
+This metadata can only be applied to loads of a pointer type.
 
 The optional ``!align`` metadata must reference a single metadata name
 ``<align_node>`` corresponding to a metadata node with one ``i64`` entry.
 The existence of the ``!align`` metadata on the instruction tells the
 optimizer that the value loaded is known to be aligned to a boundary specified
 by the integer value in the metadata node. The alignment must be a power of 2.
 This is analogous to the ''align'' attribute on parameters and return values.
 This metadata can only be applied to loads of a pointer type. If the returned

llvm/include/llvm/Bitcode/LLVMBitCodes.h

enum AttributeKindCodes {
   ATTR_KIND_WRITEONLY = 52,
   ATTR_KIND_SPECULATABLE = 53,
   ATTR_KIND_STRICT_FP = 54,
   ATTR_KIND_SANITIZE_HWADDRESS = 55,
   ATTR_KIND_NOCF_CHECK = 56,
   ATTR_KIND_OPT_FOR_FUZZING = 57,
   ATTR_KIND_SHADOWCALLSTACK = 58,
   ATTR_KIND_SPECULATIVE_LOAD_HARDENING = 59,
-  ATTR_KIND_IMMARG = 60
+  ATTR_KIND_IMMARG = 60,
+  ATTR_KIND_DEREFERENCEABLE_GLOBALLY = 61,
+  ATTR_KIND_DEREFERENCEABLE_OR_NULL_GLOBALLY = 62,
 };
 
 enum ComdatSelectionKindCodes {
   COMDAT_SELECTION_KIND_ANY = 1,
   COMDAT_SELECTION_KIND_EXACT_MATCH = 2,
   COMDAT_SELECTION_KIND_LARGEST = 3,
   COMDAT_SELECTION_KIND_NO_DUPLICATES = 4,
   COMDAT_SELECTION_KIND_SAME_SIZE = 5,

llvm/include/llvm/IR/Argument.h

public:
   /// If this argument has the dereferenceable attribute, return the number of
   /// bytes known to be dereferenceable. Otherwise, zero is returned.
   uint64_t getDereferenceableBytes() const;
 
   /// If this argument has the dereferenceable_or_null attribute, return the
   /// number of bytes known to be dereferenceable. Otherwise, zero is returned.
   uint64_t getDereferenceableOrNullBytes() const;
 
+  /// If this argument has the dereferenceable_globally attribute, return the
+  /// number of bytes known to be dereferenceable. Otherwise, zero is returned.
+  uint64_t getDereferenceableGloballyBytes() const;
+
+  /// If this argument has the dereferenceable_or_null_globally attribute,
+  /// return the number of bytes known to be dereferenceable. Otherwise, zero is
+  /// returned.
+  uint64_t getDereferenceableOrNullGloballyBytes() const;
+
   /// Return true if this argument has the byval attribute.
   bool hasByValAttr() const;
 
   /// Return true if this argument has the swiftself attribute.
   bool hasSwiftSelfAttr() const;
 
   /// Return true if this argument has the swifterror attribute.
   bool hasSwiftErrorAttr() const;

llvm/include/llvm/IR/Attributes.h

public:
   /// Return a uniquified Attribute object that has the specific
   /// alignment set.
   static Attribute getWithAlignment(LLVMContext &Context, uint64_t Align);
   static Attribute getWithStackAlignment(LLVMContext &Context, uint64_t Align);
   static Attribute getWithDereferenceableBytes(LLVMContext &Context,
                                               uint64_t Bytes);
   static Attribute getWithDereferenceableOrNullBytes(LLVMContext &Context,
                                                      uint64_t Bytes);
+  static Attribute getWithDereferenceableGloballyBytes(LLVMContext &Context,
+                                                       uint64_t Bytes);
+  static Attribute
+  getWithDereferenceableOrNullGloballyBytes(LLVMContext &Context,
+                                            uint64_t Bytes);
   static Attribute getWithAllocSizeArgs(LLVMContext &Context,
                                         unsigned ElemSizeArg,
                                         const Optional<unsigned> &NumElemsArg);
   static Attribute getWithByValType(LLVMContext &Context, Type *Ty);
 
   //===--------------------------------------------------------------------===//
   // Attribute Accessors
   //===--------------------------------------------------------------------===//
public:
   /// Returns the number of dereferenceable bytes from the
   /// dereferenceable attribute.
   uint64_t getDereferenceableBytes() const;
 
   /// Returns the number of dereferenceable_or_null bytes from the
   /// dereferenceable_or_null attribute.
   uint64_t getDereferenceableOrNullBytes() const;
 
+  /// Returns the number of globally dereferenceable bytes from the
+  /// dereferenceable_globally attribute.
+  uint64_t getDereferenceableGloballyBytes() const;
+
+  /// Returns the number of globally dereferenceable_or_null bytes from the
+  /// dereferenceable_or_null_globally attribute.
+  uint64_t getDereferenceableOrNullGloballyBytes() const;
+
   /// Returns the argument numbers for the allocsize attribute (or pair(0, 0)
   /// if not known).
   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
 
   /// The Attribute is converted to a string of equivalent mnemonic. This
   /// is, presumably, for writing out the mnemonics for the assembly writer.
   std::string getAsString(bool InAttrGrp = false) const;
 
public:
 
   /// Return the target-dependent attribute object.
   Attribute getAttribute(StringRef Kind) const;
 
   unsigned getAlignment() const;
   unsigned getStackAlignment() const;
   uint64_t getDereferenceableBytes() const;
   uint64_t getDereferenceableOrNullBytes() const;
+  uint64_t getDereferenceableGloballyBytes() const;
+  uint64_t getDereferenceableOrNullGloballyBytes() const;
   Type *getByValType() const;
   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
   std::string getAsString(bool InAttrGrp = false) const;
 
   using iterator = const Attribute *;
 
   iterator begin() const;
   iterator end() const;
public:
   /// Add the dereferenceable_or_null attribute to the attribute set at
   /// the given arg index. Returns a new list because attribute lists are
   /// immutable.
   LLVM_NODISCARD AttributeList addDereferenceableOrNullParamAttr(
       LLVMContext &C, unsigned ArgNo, uint64_t Bytes) const {
     return addDereferenceableOrNullAttr(C, ArgNo + FirstArgIndex, Bytes);
   }
 
+  /// Add the dereferenceable_globally attribute to the attribute set at the
+  /// given index. Returns a new list because attribute lists are immutable.
+  LLVM_NODISCARD AttributeList addDereferenceableGloballyAttr(
+      LLVMContext &C, unsigned Index, uint64_t Bytes) const;
+
+  /// Add the dereferenceable_globally attribute to the attribute set at the
+  /// given arg index. Returns a new list because attribute lists are immutable.
+  LLVM_NODISCARD AttributeList addDereferenceableGloballyParamAttr(
+      LLVMContext &C, unsigned ArgNo, uint64_t Bytes) const {
+    return addDereferenceableGloballyAttr(C, ArgNo + FirstArgIndex, Bytes);
+  }
+
+  /// Add the dereferenceable_or_null_globally attribute to the attribute set at
+  /// the given index. Returns a new list because attribute lists are immutable.
+  LLVM_NODISCARD AttributeList addDereferenceableOrNullGloballyAttr(
+      LLVMContext &C, unsigned Index, uint64_t Bytes) const;
+
+  /// Add the dereferenceable_or_null_globally attribute to the attribute set at
+  /// the given arg index. Returns a new list because attribute lists are
+  /// immutable.
+  LLVM_NODISCARD AttributeList addDereferenceableOrNullGloballyParamAttr(
+      LLVMContext &C, unsigned ArgNo, uint64_t Bytes) const {
+    return addDereferenceableOrNullGloballyAttr(C, ArgNo + FirstArgIndex,
+                                                Bytes);
+  }
+
   /// Add the allocsize attribute to the attribute set at the given index.
   /// Returns a new list because attribute lists are immutable.
   LLVM_NODISCARD AttributeList
   addAllocSizeAttr(LLVMContext &C, unsigned Index, unsigned ElemSizeArg,
                    const Optional<unsigned> &NumElemsArg);
 
   /// Add the allocsize attribute to the attribute set at the given arg index.
   /// Returns a new list because attribute lists are immutable.
public:
   uint64_t getDereferenceableOrNullBytes(unsigned Index) const;
 
   /// Get the number of dereferenceable_or_null bytes (or zero if
   /// unknown) of an arg.
   uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const {
     return getDereferenceableOrNullBytes(ArgNo + FirstArgIndex);
   }
 
+  /// Get the number of globally dereferenceable bytes (or zero if unknown).
+  uint64_t getDereferenceableGloballyBytes(unsigned Index) const;
+
+  /// Get the number of globally dereferenceable bytes (or zero if unknown) of
+  /// an arg.
+  uint64_t getParamDereferenceableGloballyBytes(unsigned ArgNo) const {
+    return getDereferenceableGloballyBytes(ArgNo + FirstArgIndex);
+  }
+
+  /// Get the number of globally dereferenceable_or_null bytes (or zero if
+  /// unknown).
+  uint64_t getDereferenceableOrNullGloballyBytes(unsigned Index) const;
+
+  /// Get the number of globally dereferenceable_or_null bytes (or zero if
+  /// unknown) of an arg.
+  uint64_t getParamDereferenceableOrNullGloballyBytes(unsigned ArgNo) const {
+    return getDereferenceableOrNullGloballyBytes(ArgNo + FirstArgIndex);
+  }
+
   /// Get the allocsize argument numbers (or pair(0, 0) if unknown).
   std::pair<unsigned, Optional<unsigned>>
   getAllocSizeArgs(unsigned Index) const;
 
   /// Return the attributes at the index as a string.
   std::string getAsString(unsigned Index, bool InAttrGrp = false) const;
 
   //===--------------------------------------------------------------------===//

 /// equality, presence of attributes, etc.
 class AttrBuilder {
   std::bitset<Attribute::EndAttrKinds> Attrs;
   std::map<std::string, std::string> TargetDepAttrs;
   uint64_t Alignment = 0;
   uint64_t StackAlignment = 0;
   uint64_t DerefBytes = 0;
   uint64_t DerefOrNullBytes = 0;
+  uint64_t DerefBytesGlobally = 0;
+  uint64_t DerefOrNullBytesGlobally = 0;
   uint64_t AllocSizeArgs = 0;
   Type *ByValType = nullptr;
 
 public:
   AttrBuilder() = default;
 
   AttrBuilder(const Attribute &A) {
     addAttribute(A);
public:
   /// Retrieve the number of dereferenceable bytes, if the
   /// dereferenceable attribute exists (zero is returned otherwise).
   uint64_t getDereferenceableBytes() const { return DerefBytes; }
 
   /// Retrieve the number of dereferenceable_or_null bytes, if the
   /// dereferenceable_or_null attribute exists (zero is returned otherwise).
   uint64_t getDereferenceableOrNullBytes() const { return DerefOrNullBytes; }
 
+  /// Retrieve the number of globally dereferenceable bytes, if the
+  /// dereferenceable_globally attribute exists (zero is returned otherwise).
+  uint64_t getDereferenceableGloballyBytes() const {
+    return DerefBytesGlobally;
+  }
+
+  /// Retrieve the number of globally dereferenceable_or_null bytes, if the
+  /// dereferenceable_or_null_globally attribute exists (zero is returned
+  /// otherwise).
+  uint64_t getDereferenceableOrNullGloballyBytes() const {
+    return DerefOrNullBytesGlobally;
+  }
+
   /// Retrieve the byval type.
   Type *getByValType() const { return ByValType; }
 
   /// Retrieve the allocsize args, if the allocsize attribute exists.  If it
   /// doesn't exist, pair(0, 0) is returned.
   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
 
   /// This turns an int alignment (which must be a power of 2) into the
   /// form used internally in Attribute.
   AttrBuilder &addAlignmentAttr(unsigned Align);
 
   /// This turns an int stack alignment (which must be a power of 2) into
   /// the form used internally in Attribute.
   AttrBuilder &addStackAlignmentAttr(unsigned Align);
 
   /// This turns the number of dereferenceable bytes into the form used
   /// internally in Attribute.
   AttrBuilder &addDereferenceableAttr(uint64_t Bytes);
 
   /// This turns the number of dereferenceable_or_null bytes into the
   /// form used internally in Attribute.
   AttrBuilder &addDereferenceableOrNullAttr(uint64_t Bytes);
 
+  /// This turns the number of globally dereferenceable_globally bytes into the
+  /// form used internally in Attribute.
+  AttrBuilder &addDereferenceableGloballyAttr(uint64_t Bytes);
+
+  /// This turns the number of dereferenceable_or_null_globally bytes into the
+  /// form used internally in Attribute.
+  AttrBuilder &addDereferenceableOrNullGloballyAttr(uint64_t Bytes);
+
   /// This turns one (or two) ints into the form used internally in Attribute.
   AttrBuilder &addAllocSizeAttr(unsigned ElemSizeArg,
                                 const Optional<unsigned> &NumElemsArg);
 
   /// This turns a byval type into the form used internally in Attribute.
   AttrBuilder &addByValAttr(Type *Ty);
 
   /// Add an allocsize attribute, using the representation returned by

llvm/include/llvm/IR/Attributes.td

 def Convergent : EnumAttr<"convergent">;
 
 /// Pointer is known to be dereferenceable.
 def Dereferenceable : EnumAttr<"dereferenceable">;
 
 /// Pointer is either null or dereferenceable.
 def DereferenceableOrNull : EnumAttr<"dereferenceable_or_null">;
 
+/// Pointer is known to be dereferenceable_globally.
+def DereferenceableGlobally : EnumAttr<"dereferenceable_globally">;
+
+/// Pointer is either null or dereferenceable_globally.
+def DereferenceableOrNullGlobally : EnumAttr<"dereferenceable_or_null_globally">;
+
 /// Function may only access memory that is inaccessible from IR.
 def InaccessibleMemOnly : EnumAttr<"inaccessiblememonly">;
 
 /// Function may only access memory that is either inaccessible from the IR,
 /// or pointed to by its pointer arguments.
 def InaccessibleMemOrArgMemOnly : EnumAttr<"inaccessiblemem_or_argmemonly">;
 
 /// Pass structure in an alloca.

llvm/include/llvm/IR/CallSite.h

#define CALLSITE_DELEGATE_SETTER(METHOD)                                       \
   }
 
   /// Extract the number of dereferenceable_or_null bytes for a call or
   /// parameter (0=unknown).
   uint64_t getDereferenceableOrNullBytes(unsigned i) const {
     CALLSITE_DELEGATE_GETTER(getDereferenceableOrNullBytes(i));
   }
 
+  /// Extract the number of globally dereferenceable bytes for a call or
+  /// parameter (0=unknown).
+  uint64_t getDereferenceableGloballyBytes(unsigned i) const {
+    CALLSITE_DELEGATE_GETTER(getDereferenceableGloballyBytes(i));
+  }
+
+  /// Extract the number of globally dereferenceable_or_null bytes for a call or
+  /// parameter (0=unknown).
+  uint64_t getDereferenceableOrNullGloballyBytes(unsigned i) const {
+    CALLSITE_DELEGATE_GETTER(getDereferenceableOrNullGloballyBytes(i));
+  }
+
   /// Determine if the return value is marked with NoAlias attribute.
   bool returnDoesNotAlias() const {
     CALLSITE_DELEGATE_GETTER(returnDoesNotAlias());
   }
 
   /// Return true if the call should not be treated as a call to a builtin.
   bool isNoBuiltin() const {
     CALLSITE_DELEGATE_GETTER(isNoBuiltin());

llvm/include/llvm/IR/Function.h

public:
   /// adds the dereferenceable_or_null attribute to the list of
   /// attributes.
   void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes);
 
   /// adds the dereferenceable_or_null attribute to the list of
   /// attributes for the given arg.
   void addDereferenceableOrNullParamAttr(unsigned ArgNo, uint64_t Bytes);
 
+  /// adds the dereferenceable_globally attribute to the list of attributes.
+  void addDereferenceableGloballyAttr(unsigned i, uint64_t Bytes);
+
+  /// adds the dereferenceable_globally attribute to the list of attributes for
+  /// the given arg.
+  void addDereferenceableGloballyParamAttr(unsigned ArgNo, uint64_t Bytes);
+
+  /// adds the dereferenceable_or_null_globally attribute to the list of
+  /// attributes.
+  void addDereferenceableOrNullGloballyAttr(unsigned i, uint64_t Bytes);
+
+  /// adds the dereferenceable_or_null_globally attribute to the list of
+  /// attributes for the given arg.
+  void addDereferenceableOrNullGloballyParamAttr(unsigned ArgNo,
+                                                 uint64_t Bytes);
+
   /// Extract the alignment for a call or parameter (0=unknown).
   unsigned getParamAlignment(unsigned ArgNo) const {
     return AttributeSets.getParamAlignment(ArgNo);
   }
 
   /// Extract the byval type for a parameter.
   Type *getParamByValType(unsigned ArgNo) const {
     Type *Ty = AttributeSets.getParamByValType(ArgNo);
public:
 
   /// Extract the number of dereferenceable_or_null bytes for a
   /// parameter.
   /// @param ArgNo AttributeList ArgNo, referring to an argument.
   uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const {
     return AttributeSets.getParamDereferenceableOrNullBytes(ArgNo);
   }
 
+  /// Extract the number of globally dereferenceable bytes for a call or
+  /// parameter (0=unknown).
+  /// @param i AttributeList index, referring to a return value or argument.
+  uint64_t getDereferenceableGloballyBytes(unsigned i) const {
+    return AttributeSets.getDereferenceableGloballyBytes(i);
+  }
+
+  /// Extract the number of globally dereferenceable bytes for a parameter.
+  /// @param ArgNo Index of an argument, with 0 being the first function arg.
+  uint64_t getParamDereferenceableGloballyBytes(unsigned ArgNo) const {
+    return AttributeSets.getParamDereferenceableGloballyBytes(ArgNo);
+  }
+
+  /// Extract the number of globally dereferenceable_or_null bytes for a call or
+  /// parameter (0=unknown).
+  /// @param i AttributeList index, referring to a return value or argument.
+  uint64_t getDereferenceableOrNullGloballyBytes(unsigned i) const {
+    return AttributeSets.getDereferenceableOrNullGloballyBytes(i);
+  }
+
+  /// Extract the number of globally dereferenceable_or_null bytes for a
+  /// parameter.
+  /// @param ArgNo AttributeList ArgNo, referring to an argument.
+  uint64_t getParamDereferenceableOrNullGloballyBytes(unsigned ArgNo) const {
+    return AttributeSets.getParamDereferenceableOrNullGloballyBytes(ArgNo);
+  }
+
   /// Determine if the function does not access memory.
   bool doesNotAccessMemory() const {
     return hasFnAttribute(Attribute::ReadNone);
   }
   void setDoesNotAccessMemory() {
     addFnAttr(Attribute::ReadNone);
   }
 

llvm/include/llvm/IR/InstrTypes.h

public:
   /// adds the dereferenceable_or_null attribute to the list of
   /// attributes.
   void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) {
     AttributeList PAL = getAttributes();
     PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes);
     setAttributes(PAL);
   }
 
+  /// adds the dereferenceable_globally attribute to the list of attributes.
+  void addDereferenceableGloballyAttr(unsigned i, uint64_t Bytes) {
+    AttributeList PAL = getAttributes();
+    PAL = PAL.addDereferenceableGloballyAttr(getContext(), i, Bytes);
+    setAttributes(PAL);
+  }
+
+  /// adds the dereferenceable_or_null_globally attribute to the list of
+  /// attributes.
+  void addDereferenceableOrNullGloballyAttr(unsigned i, uint64_t Bytes) {
+    AttributeList PAL = getAttributes();
+    PAL = PAL.addDereferenceableOrNullGloballyAttr(getContext(), i, Bytes);
+    setAttributes(PAL);
+  }
+
   /// Determine whether the return value has the given attribute.
   bool hasRetAttr(Attribute::AttrKind Kind) const;
 
   /// Determine whether the argument or parameter has the given attribute.
   bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const;
 
   /// Get the attribute of a given kind at a position.
   Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const {
public:
   }
 
   /// Extract the number of dereferenceable_or_null bytes for a call or
   /// parameter (0=unknown).
   uint64_t getDereferenceableOrNullBytes(unsigned i) const {
     return Attrs.getDereferenceableOrNullBytes(i);
   }
 
+  /// Extract the number of globally dereferenceable bytes for a call or
+  /// parameter (0=unknown).
+  uint64_t getDereferenceableGloballyBytes(unsigned i) const {
+    return Attrs.getDereferenceableGloballyBytes(i);
+  }
+
+  /// Extract the number of globally dereferenceable_or_null bytes for a call or
+  /// parameter (0=unknown).
+  uint64_t getDereferenceableOrNullGloballyBytes(unsigned i) const {
+    return Attrs.getDereferenceableOrNullGloballyBytes(i);
+  }
+
   /// Return true if the return value is known to be not null.
   /// This may be because it has the nonnull attribute, or because at least
   /// one byte is dereferenceable and the pointer is in addrspace(0).
   bool isReturnNonNull() const;
 
   /// Determine if the return value is marked with NoAlias attribute.
   bool returnDoesNotAlias() const {
     return Attrs.hasAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);

llvm/include/llvm/IR/LLVMContext.h

enum : unsigned {
     MD_type = 19,                     // "type"
     MD_section_prefix = 20,           // "section_prefix"
     MD_absolute_symbol = 21,          // "absolute_symbol"
     MD_associated = 22,               // "associated"
     MD_callees = 23,                  // "callees"
     MD_irr_loop = 24,                 // "irr_loop"
     MD_access_group = 25,             // "llvm.access.group"
     MD_callback = 26,                 // "callback"
+    MD_dereferenceable_globally = 27, // "dereferenceable_globally"
+    MD_dereferenceable_or_null_globally =
+        28, // "dereferenceable_or_null_globally"
   };
 
   /// Known operand bundle tag IDs, which always have the same value.  All
   /// operand bundle tags that LLVM has special knowledge of are listed here.
   /// Additionally, this scheme allows LLVM to efficiently check for specific
   /// operand bundle tags without comparing strings.
   enum : unsigned {
     OB_deopt = 0,         // "deopt"

llvm/lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(argmemonly);
   KEYWORD(builtin);
   KEYWORD(byval);
   KEYWORD(inalloca);
   KEYWORD(cold);
   KEYWORD(convergent);
   KEYWORD(dereferenceable);
   KEYWORD(dereferenceable_or_null);
+  KEYWORD(dereferenceable_globally);
+  KEYWORD(dereferenceable_or_null_globally);
   KEYWORD(inaccessiblememonly);
   KEYWORD(inaccessiblemem_or_argmemonly);
   KEYWORD(inlinehint);
   KEYWORD(inreg);
   KEYWORD(jumptable);
   KEYWORD(minsize);
   KEYWORD(naked);
   KEYWORD(nest);

llvm/lib/AsmParser/LLParser.cpp

while (true) {
     case lltok::kw_zeroext:
       HaveError |=
         Error(Lex.getLoc(),
               "invalid use of attribute on a function");
       break;
     case lltok::kw_byval:
     case lltok::kw_dereferenceable:
     case lltok::kw_dereferenceable_or_null:
+    case lltok::kw_dereferenceable_globally:
+    case lltok::kw_dereferenceable_or_null_globally:
     case lltok::kw_inalloca:
     case lltok::kw_nest:
     case lltok::kw_noalias:
     case lltok::kw_nocapture:
     case lltok::kw_nonnull:
     case lltok::kw_returned:
     case lltok::kw_sret:
     case lltok::kw_swifterror:
while (true) {
     }
     case lltok::kw_dereferenceable_or_null: {
       uint64_t Bytes;
       if (ParseOptionalDerefAttrBytes(lltok::kw_dereferenceable_or_null, Bytes))
         return true;
       B.addDereferenceableOrNullAttr(Bytes);
       continue;
     }
+    case lltok::kw_dereferenceable_globally: {
+      uint64_t Bytes;
+      if (ParseOptionalDerefAttrBytes(lltok::kw_dereferenceable_globally,
+                                      Bytes))
+        return true;
+      B.addDereferenceableGloballyAttr(Bytes);
+      continue;
+    }
+    case lltok::kw_dereferenceable_or_null_globally: {
+      uint64_t Bytes;
+      if (ParseOptionalDerefAttrBytes(
+              lltok::kw_dereferenceable_or_null_globally, Bytes))
+        return true;
+      B.addDereferenceableOrNullGloballyAttr(Bytes);
+      continue;
+    }
     case lltok::kw_inalloca:        B.addAttribute(Attribute::InAlloca); break;
     case lltok::kw_inreg:           B.addAttribute(Attribute::InReg); break;
     case lltok::kw_nest:            B.addAttribute(Attribute::Nest); break;
     case lltok::kw_noalias:         B.addAttribute(Attribute::NoAlias); break;
     case lltok::kw_nocapture:       B.addAttribute(Attribute::NoCapture); break;
     case lltok::kw_nonnull:         B.addAttribute(Attribute::NonNull); break;
     case lltok::kw_readnone:        B.addAttribute(Attribute::ReadNone); break;
     case lltok::kw_readonly:        B.addAttribute(Attribute::ReadOnly); break;
while (true) {
     }
     case lltok::kw_dereferenceable_or_null: {
       uint64_t Bytes;
       if (ParseOptionalDerefAttrBytes(lltok::kw_dereferenceable_or_null, Bytes))
         return true;
       B.addDereferenceableOrNullAttr(Bytes);
       continue;
     }
+    case lltok::kw_dereferenceable_globally: {
+      uint64_t Bytes;
+      if (ParseOptionalDerefAttrBytes(lltok::kw_dereferenceable_globally, Bytes))
+        return true;
+      B.addDereferenceableGloballyAttr(Bytes);
+      continue;
+    }
+    case lltok::kw_dereferenceable_or_null_globally: {
+      uint64_t Bytes;
+      if (ParseOptionalDerefAttrBytes(lltok::kw_dereferenceable_or_null_globally, Bytes))
+        return true;
+      B.addDereferenceableOrNullGloballyAttr(Bytes);
+      continue;
+    }
     case lltok::kw_align: {
       unsigned Alignment;
       if (ParseOptionalAlignment(Alignment))
         return true;
       B.addAlignmentAttr(Alignment);
       continue;
     }
     case lltok::kw_inreg:           B.addAttribute(Attribute::InReg); break;
if (Alignment > Value::MaximumAlignment)
     return Error(AlignLoc, "huge alignments are not supported yet");
   return false;
 }
 
 /// ParseOptionalDerefAttrBytes
 ///   ::= /* empty */
 ///   ::= AttrKind '(' 4 ')'
 ///
-/// where AttrKind is either 'dereferenceable' or 'dereferenceable_or_null'.
+/// where AttrKind is either 'dereferenceable', 'dereferenceable_or_null',
+/// 'dereferenceable_globally', or 'dereferenceable_or_null_globally'.
 bool LLParser::ParseOptionalDerefAttrBytes(lltok::Kind AttrKind,
                                            uint64_t &Bytes) {
   assert((AttrKind == lltok::kw_dereferenceable ||
-          AttrKind == lltok::kw_dereferenceable_or_null) &&
+          AttrKind == lltok::kw_dereferenceable_or_null ||
+          AttrKind == lltok::kw_dereferenceable_globally ||
+          AttrKind == lltok::kw_dereferenceable_or_null_globally) &&
          "contract!");
 
   Bytes = 0;
   if (!EatIfPresent(AttrKind))
     return false;
   LocTy ParenLoc = Lex.getLoc();
   if (!EatIfPresent(lltok::lparen))
     return Error(ParenLoc, "expected '('");
if (Opc == Instruction::FCmp) {
       if (!Val0->getType()->isIntOrIntVectorTy() &&
           !Val0->getType()->isPtrOrPtrVectorTy())
         return Error(ID.Loc, "icmp requires pointer or integer operands");
       ID.ConstantVal = ConstantExpr::getICmp(Pred, Val0, Val1);
     }
     ID.Kind = ValID::t_Constant;
     return false;
   }
- 
   // Unary Operators.
   case lltok::kw_fneg: {
     unsigned Opc = Lex.getUIntVal();
     Constant *Val;
     Lex.Lex();
     if (ParseToken(lltok::lparen, "expected '(' in unary constantexpr") ||
         ParseGlobalTypeAndValue(Val) ||
         ParseToken(lltok::rparen, "expected ')' in unary constantexpr"))
       return true;
-    
     // Check that the type is valid for the operator.
     switch (Opc) {
     case Instruction::FNeg:
       if (!Val->getType()->isFPOrFPVectorTy())
         return Error(ID.Loc, "constexpr requires fp operands");
       break;
     default: llvm_unreachable("Unknown unary operator!");
     }

 /// ParseDICommonBlock:
 ///   ::= !DICommonBlock(scope: !0, file: !2, name: "COMMON name", line: 9)
 bool LLParser::ParseDICommonBlock(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, );                                                  \
   OPTIONAL(declaration, MDField, );                                            \
   OPTIONAL(name, MDStringField, );                                             \
   OPTIONAL(file, MDField, );                                                   \
-  OPTIONAL(line, LineField, );                   
+  OPTIONAL(line, LineField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
   Result = GET_OR_DISTINCT(DICommonBlock,
                            (Context, scope.Val, declaration.Val, name.Val,
                             file.Val, line.Val));
   return false;
 }

llvm/lib/AsmParser/LLToken.h

enum Kind {
   kw_sanitize_hwaddress,
   kw_builtin,
   kw_byval,
   kw_inalloca,
   kw_cold,
   kw_convergent,
   kw_dereferenceable,
   kw_dereferenceable_or_null,
+  kw_dereferenceable_globally,
+  kw_dereferenceable_or_null_globally,
   kw_inaccessiblememonly,
   kw_inaccessiblemem_or_argmemonly,
   kw_inlinehint,
   kw_inreg,
   kw_jumptable,
   kw_minsize,
   kw_naked,
   kw_nest,

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

case Attribute::ImmArg:
     return 1ULL << 61;
   case Attribute::Dereferenceable:
     llvm_unreachable("dereferenceable attribute not supported in raw format");
     break;
   case Attribute::DereferenceableOrNull:
     llvm_unreachable("dereferenceable_or_null attribute not supported in raw "
                      "format");
     break;
+  case Attribute::DereferenceableGlobally:
+    llvm_unreachable(
+        "dereferenceable_globally attribute not supported in raw format");
+    break;
+  case Attribute::DereferenceableOrNullGlobally:
+    llvm_unreachable("dereferenceable_or_null_globally attribute not supported "
+                     "in raw format");
+    break;
   case Attribute::ArgMemOnly:
     llvm_unreachable("argmemonly attribute not supported in raw format");
     break;
   case Attribute::AllocSize:
     llvm_unreachable("allocsize not supported in raw format");
     break;
   }
   llvm_unreachable("Unsupported attribute type");
 }
 
 static void addRawAttributeValue(AttrBuilder &B, uint64_t Val) {
   if (!Val) return;
 
   for (Attribute::AttrKind I = Attribute::None; I != Attribute::EndAttrKinds;
        I = Attribute::AttrKind(I + 1)) {
     if (I == Attribute::Dereferenceable ||
         I == Attribute::DereferenceableOrNull ||
+        I == Attribute::DereferenceableGlobally ||
+        I == Attribute::DereferenceableOrNullGlobally ||
         I == Attribute::ArgMemOnly ||
         I == Attribute::AllocSize)
       continue;
     if (uint64_t A = (Val & getRawAttributeMask(I))) {
       if (I == Attribute::Alignment)
         B.addAlignmentAttr(1ULL << ((A >> 16) - 1));
       else if (I == Attribute::StackAlignment)
         B.addStackAlignmentAttr(1ULL << ((A >> 26)-1));
static Attribute::AttrKind getAttrFromCode(uint64_t Code) {
   case bitc::ATTR_KIND_NON_LAZY_BIND:
     return Attribute::NonLazyBind;
   case bitc::ATTR_KIND_NON_NULL:
     return Attribute::NonNull;
   case bitc::ATTR_KIND_DEREFERENCEABLE:
     return Attribute::Dereferenceable;
   case bitc::ATTR_KIND_DEREFERENCEABLE_OR_NULL:
     return Attribute::DereferenceableOrNull;
+  case bitc::ATTR_KIND_DEREFERENCEABLE_GLOBALLY:
+    return Attribute::DereferenceableGlobally;
+  case bitc::ATTR_KIND_DEREFERENCEABLE_OR_NULL_GLOBALLY:
+    return Attribute::DereferenceableOrNullGlobally;
   case bitc::ATTR_KIND_ALLOC_SIZE:
     return Attribute::AllocSize;
   case bitc::ATTR_KIND_NO_RED_ZONE:
     return Attribute::NoRedZone;
   case bitc::ATTR_KIND_NO_RETURN:
     return Attribute::NoReturn;
   case bitc::ATTR_KIND_NOCF_CHECK:
     return Attribute::NoCfCheck;
case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...]
           if (Kind == Attribute::Alignment)
             B.addAlignmentAttr(Record[++i]);
           else if (Kind == Attribute::StackAlignment)
             B.addStackAlignmentAttr(Record[++i]);
           else if (Kind == Attribute::Dereferenceable)
             B.addDereferenceableAttr(Record[++i]);
           else if (Kind == Attribute::DereferenceableOrNull)
             B.addDereferenceableOrNullAttr(Record[++i]);
+          else if (Kind == Attribute::DereferenceableGlobally)
+            B.addDereferenceableGloballyAttr(Record[++i]);
+          else if (Kind == Attribute::DereferenceableOrNullGlobally)
+            B.addDereferenceableOrNullGloballyAttr(Record[++i]);
           else if (Kind == Attribute::AllocSize)
             B.addAllocSizeAttrFromRawRepr(Record[++i]);
         } else if (Record[i] == 3 || Record[i] == 4) { // String attribute
           bool HasValue = (Record[i++] == 4);
           SmallString<64> KindStr;
           SmallString<64> ValStr;
 
           while (Record[i] != 0 && i != e)

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
   case Attribute::NonLazyBind:
     return bitc::ATTR_KIND_NON_LAZY_BIND;
   case Attribute::NonNull:
     return bitc::ATTR_KIND_NON_NULL;
   case Attribute::Dereferenceable:
     return bitc::ATTR_KIND_DEREFERENCEABLE;
   case Attribute::DereferenceableOrNull:
     return bitc::ATTR_KIND_DEREFERENCEABLE_OR_NULL;
+  case Attribute::DereferenceableGlobally:
+    return bitc::ATTR_KIND_DEREFERENCEABLE_GLOBALLY;
+  case Attribute::DereferenceableOrNullGlobally:
+    return bitc::ATTR_KIND_DEREFERENCEABLE_OR_NULL_GLOBALLY;
   case Attribute::NoRedZone:
     return bitc::ATTR_KIND_NO_RED_ZONE;
   case Attribute::NoReturn:
     return bitc::ATTR_KIND_NO_RETURN;
   case Attribute::NoCfCheck:
     return bitc::ATTR_KIND_NOCF_CHECK;
   case Attribute::NoUnwind:
     return bitc::ATTR_KIND_NO_UNWIND;

llvm/lib/IR/AttributeImpl.h

class IntAttributeImpl : public EnumAttributeImpl {
   void anchor() override;
 
 public:
   IntAttributeImpl(Attribute::AttrKind Kind, uint64_t Val)
       : EnumAttributeImpl(IntAttrEntry, Kind), Val(Val) {
     assert((Kind == Attribute::Alignment || Kind == Attribute::StackAlignment ||
             Kind == Attribute::Dereferenceable ||
             Kind == Attribute::DereferenceableOrNull ||
+            Kind == Attribute::DereferenceableGlobally ||
+            Kind == Attribute::DereferenceableOrNullGlobally ||
             Kind == Attribute::AllocSize) &&
            "Wrong kind for int attribute!");
   }
 
   uint64_t getValue() const { return Val; }
 };
 
 class StringAttributeImpl : public AttributeImpl {
public:
 
   Attribute getAttribute(Attribute::AttrKind Kind) const;
   Attribute getAttribute(StringRef Kind) const;
 
   unsigned getAlignment() const;
   unsigned getStackAlignment() const;
   uint64_t getDereferenceableBytes() const;
   uint64_t getDereferenceableOrNullBytes() const;
+  uint64_t getDereferenceableGloballyBytes() const;
+  uint64_t getDereferenceableOrNullGloballyBytes() const;
   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
   std::string getAsString(bool InAttrGrp) const;
   Type *getByValType() const;
 
   using iterator = const Attribute *;
 
   iterator begin() const { return getTrailingObjects<Attribute>(); }
   iterator end() const { return begin() + NumAttrs; }

llvm/lib/IR/Attributes.cpp

 }
 
 Attribute Attribute::getWithDereferenceableOrNullBytes(LLVMContext &Context,
                                                        uint64_t Bytes) {
   assert(Bytes && "Bytes must be non-zero.");
   return get(Context, DereferenceableOrNull, Bytes);
 }
 
+Attribute Attribute::getWithDereferenceableGloballyBytes(LLVMContext &Context,
+                                                         uint64_t Bytes) {
+  assert(Bytes && "Bytes must be non-zero.");
+  return get(Context, DereferenceableGlobally, Bytes);
+}
+
+Attribute
+Attribute::getWithDereferenceableOrNullGloballyBytes(LLVMContext &Context,
+                                                     uint64_t Bytes) {
+  assert(Bytes && "Bytes must be non-zero.");
+  return get(Context, DereferenceableOrNullGlobally, Bytes);
+}
+
 Attribute Attribute::getWithByValType(LLVMContext &Context, Type *Ty) {
   return get(Context, ByVal, Ty);
 }
 
 Attribute
 Attribute::getWithAllocSizeArgs(LLVMContext &Context, unsigned ElemSizeArg,
                                 const Optional<unsigned> &NumElemsArg) {
   assert(!(ElemSizeArg == 0 && NumElemsArg && *NumElemsArg == 0) &&

 
 uint64_t Attribute::getDereferenceableOrNullBytes() const {
   assert(hasAttribute(Attribute::DereferenceableOrNull) &&
          "Trying to get dereferenceable bytes from "
          "non-dereferenceable attribute!");
   return pImpl->getValueAsInt();
 }
 
+uint64_t Attribute::getDereferenceableGloballyBytes() const {
+  assert(hasAttribute(Attribute::DereferenceableGlobally) &&
+         "Trying to get dereferenceable bytes from "
+         "non-dereferenceable attribute!");
+  return pImpl->getValueAsInt();
+}
+
+uint64_t Attribute::getDereferenceableOrNullGloballyBytes() const {
+  assert(hasAttribute(Attribute::DereferenceableOrNullGlobally) &&
+         "Trying to get dereferenceable bytes from "
+         "non-dereferenceable attribute!");
+  return pImpl->getValueAsInt();
+}
+
 std::pair<unsigned, Optional<unsigned>> Attribute::getAllocSizeArgs() const {
   assert(hasAttribute(Attribute::AllocSize) &&
          "Trying to get allocsize args from non-allocsize attribute");
   return unpackAllocSizeArgs(pImpl->getValueAsInt());
 }
 
 std::string Attribute::getAsString(bool InAttrGrp) const {
   if (!pImpl) return {};
if (hasAttribute(Attribute::StackAlignment))
     return AttrWithBytesToString("alignstack");
 
   if (hasAttribute(Attribute::Dereferenceable))
     return AttrWithBytesToString("dereferenceable");
 
   if (hasAttribute(Attribute::DereferenceableOrNull))
     return AttrWithBytesToString("dereferenceable_or_null");
 
+  if (hasAttribute(Attribute::DereferenceableGlobally))
+    return AttrWithBytesToString("dereferenceable_globally");
+
+  if (hasAttribute(Attribute::DereferenceableOrNullGlobally))
+    return AttrWithBytesToString("dereferenceable_or_null_globally");
+
   if (hasAttribute(Attribute::AllocSize)) {
     unsigned ElemSize;
     Optional<unsigned> NumElems;
     std::tie(ElemSize, NumElems) = getAllocSizeArgs();
 
     std::string Result = "allocsize(";
     Result += utostr(ElemSize);
     if (NumElems.hasValue()) {

 uint64_t AttributeSet::getDereferenceableBytes() const {
   return SetNode ? SetNode->getDereferenceableBytes() : 0;
 }
 
 uint64_t AttributeSet::getDereferenceableOrNullBytes() const {
   return SetNode ? SetNode->getDereferenceableOrNullBytes() : 0;
 }
 
+uint64_t AttributeSet::getDereferenceableGloballyBytes() const {
+  return SetNode ? SetNode->getDereferenceableGloballyBytes() : 0;
+}
+
+uint64_t AttributeSet::getDereferenceableOrNullGloballyBytes() const {
+  return SetNode ? SetNode->getDereferenceableOrNullGloballyBytes() : 0;
+}
+
 Type *AttributeSet::getByValType() const {
   return SetNode ? SetNode->getByValType() : nullptr;
 }
 
 std::pair<unsigned, Optional<unsigned>> AttributeSet::getAllocSizeArgs() const {
   return SetNode ? SetNode->getAllocSizeArgs()
                  : std::pair<unsigned, Optional<unsigned>>(0, 0);
 }
for (Attribute::AttrKind Kind = Attribute::None;
     case Attribute::Dereferenceable:
       Attr = Attribute::getWithDereferenceableBytes(
           C, B.getDereferenceableBytes());
       break;
     case Attribute::DereferenceableOrNull:
       Attr = Attribute::getWithDereferenceableOrNullBytes(
           C, B.getDereferenceableOrNullBytes());
       break;
+    case Attribute::DereferenceableGlobally:
+      Attr = Attribute::getWithDereferenceableGloballyBytes(
+          C, B.getDereferenceableGloballyBytes());
+      break;
+    case Attribute::DereferenceableOrNullGlobally:
+      Attr = Attribute::getWithDereferenceableOrNullGloballyBytes(
+          C, B.getDereferenceableOrNullGloballyBytes());
+      break;
     case Attribute::AllocSize: {
       auto A = B.getAllocSizeArgs();
       Attr = Attribute::getWithAllocSizeArgs(C, A.first, A.second);
       break;
     }
     default:
       Attr = Attribute::get(C, Kind);
     }

 
 uint64_t AttributeSetNode::getDereferenceableOrNullBytes() const {
   for (const auto I : *this)
     if (I.hasAttribute(Attribute::DereferenceableOrNull))
       return I.getDereferenceableOrNullBytes();
   return 0;
 }
 
+uint64_t AttributeSetNode::getDereferenceableGloballyBytes() const {
+  for (const auto I : *this)
+    if (I.hasAttribute(Attribute::DereferenceableGlobally))
+      return I.getDereferenceableGloballyBytes();
+  return 0;
+}
+
+uint64_t AttributeSetNode::getDereferenceableOrNullGloballyBytes() const {
+  for (const auto I : *this)
+    if (I.hasAttribute(Attribute::DereferenceableOrNullGlobally))
+      return I.getDereferenceableOrNullGloballyBytes();
+  return 0;
+}
+
 std::pair<unsigned, Optional<unsigned>>
 AttributeSetNode::getAllocSizeArgs() const {
   for (const auto I : *this)
     if (I.hasAttribute(Attribute::AllocSize))
       return I.getAllocSizeArgs();
   return std::make_pair(0, 0);
 }
 

 AttributeList::addDereferenceableOrNullAttr(LLVMContext &C, unsigned Index,
                                             uint64_t Bytes) const {
   AttrBuilder B;
   B.addDereferenceableOrNullAttr(Bytes);
   return addAttributes(C, Index, B);
 }
 
 AttributeList
+AttributeList::addDereferenceableGloballyAttr(LLVMContext &C, unsigned Index,
+                                              uint64_t Bytes) const {
+  AttrBuilder B;
+  B.addDereferenceableGloballyAttr(Bytes);
+  return addAttributes(C, Index, B);
+}
+
+AttributeList AttributeList::addDereferenceableOrNullGloballyAttr(
+    LLVMContext &C, unsigned Index, uint64_t Bytes) const {
+  AttrBuilder B;
+  B.addDereferenceableOrNullGloballyAttr(Bytes);
+  return addAttributes(C, Index, B);
+}
+
+AttributeList
 AttributeList::addAllocSizeAttr(LLVMContext &C, unsigned Index,
                                 unsigned ElemSizeArg,
                                 const Optional<unsigned> &NumElemsArg) {
   AttrBuilder B;
   B.addAllocSizeAttr(ElemSizeArg, NumElemsArg);
   return addAttributes(C, Index, B);
 }
 

 uint64_t AttributeList::getDereferenceableBytes(unsigned Index) const {
   return getAttributes(Index).getDereferenceableBytes();
 }
 
 uint64_t AttributeList::getDereferenceableOrNullBytes(unsigned Index) const {
   return getAttributes(Index).getDereferenceableOrNullBytes();
 }
 
+uint64_t AttributeList::getDereferenceableGloballyBytes(unsigned Index) const {
+  return getAttributes(Index).getDereferenceableGloballyBytes();
+}
+
+uint64_t AttributeList::getDereferenceableOrNullGloballyBytes(unsigned Index) const {
+  return getAttributes(Index).getDereferenceableOrNullGloballyBytes();
+}
+
 std::pair<unsigned, Optional<unsigned>>
 AttributeList::getAllocSizeArgs(unsigned Index) const {
   return getAttributes(Index).getAllocSizeArgs();
 }
 
 std::string AttributeList::getAsString(unsigned Index, bool InAttrGrp) const {
   return getAttributes(Index).getAsString(InAttrGrp);
 }
void AttrBuilder::clear() {
   Alignment = StackAlignment = DerefBytes = DerefOrNullBytes = 0;
   AllocSizeArgs = 0;
   ByValType = nullptr;
 }
 
 AttrBuilder &AttrBuilder::addAttribute(Attribute::AttrKind Val) {
   assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
   assert(Val != Attribute::Alignment && Val != Attribute::StackAlignment &&
-         Val != Attribute::Dereferenceable && Val != Attribute::AllocSize &&
+         Val != Attribute::AllocSize && Val != Attribute::Dereferenceable &&
+         Val != Attribute::DereferenceableOrNull &&
+         Val != Attribute::DereferenceableGlobally &&
+         Val != Attribute::DereferenceableOrNullGlobally &&
          "Adding integer attribute without adding a value!");
   Attrs[Val] = true;
   return *this;
 }
 
 AttrBuilder &AttrBuilder::addAttribute(Attribute Attr) {
   if (Attr.isStringAttribute()) {
     addAttribute(Attr.getKindAsString(), Attr.getValueAsString());
     return *this;
   }
 
   Attribute::AttrKind Kind = Attr.getKindAsEnum();
   Attrs[Kind] = true;
 
   if (Kind == Attribute::Alignment)
     Alignment = Attr.getAlignment();
   else if (Kind == Attribute::StackAlignment)
     StackAlignment = Attr.getStackAlignment();
   else if (Kind == Attribute::ByVal)
     ByValType = Attr.getValueAsType();
   else if (Kind == Attribute::Dereferenceable)
     DerefBytes = Attr.getDereferenceableBytes();
   else if (Kind == Attribute::DereferenceableOrNull)
     DerefOrNullBytes = Attr.getDereferenceableOrNullBytes();
+  else if (Kind == Attribute::DereferenceableGlobally)
+    DerefBytesGlobally = Attr.getDereferenceableGloballyBytes();
+  else if (Kind == Attribute::DereferenceableOrNullGlobally)
+    DerefOrNullBytesGlobally = Attr.getDereferenceableOrNullGloballyBytes();
   else if (Kind == Attribute::AllocSize)
     AllocSizeArgs = Attr.getValueAsInt();
   return *this;
 }
 
 AttrBuilder &AttrBuilder::addAttribute(StringRef A, StringRef V) {
   TargetDepAttrs[A] = V;
   return *this;
 }
 
 AttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrKind Val) {
   assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
   Attrs[Val] = false;
 
   if (Val == Attribute::Alignment)
     Alignment = 0;
   else if (Val == Attribute::StackAlignment)
     StackAlignment = 0;
   else if (Val == Attribute::ByVal)
     ByValType = nullptr;
   else if (Val == Attribute::Dereferenceable)
     DerefBytes = 0;
   else if (Val == Attribute::DereferenceableOrNull)
     DerefOrNullBytes = 0;
+  else if (Val == Attribute::DereferenceableGlobally)
+    DerefBytesGlobally = 0;
+  else if (Val == Attribute::DereferenceableOrNullGlobally)
+    DerefOrNullBytesGlobally = 0;
   else if (Val == Attribute::AllocSize)
     AllocSizeArgs = 0;
 
   return *this;
 }
 
 AttrBuilder &AttrBuilder::removeAttributes(AttributeList A, uint64_t Index) {
   remove(A.getAttributes(Index));
AttrBuilder &AttrBuilder::addDereferenceableOrNullAttr(uint64_t Bytes) {
   if (Bytes == 0)
     return *this;
 
   Attrs[Attribute::DereferenceableOrNull] = true;
   DerefOrNullBytes = Bytes;
   return *this;
 }
 
+AttrBuilder &AttrBuilder::addDereferenceableGloballyAttr(uint64_t Bytes) {
+  if (Bytes == 0) return *this;
+
+  Attrs[Attribute::DereferenceableGlobally] = true;
+  DerefBytesGlobally = Bytes;
+  return *this;
+}
+
+AttrBuilder &AttrBuilder::addDereferenceableOrNullGloballyAttr(uint64_t Bytes) {
+  if (Bytes == 0)
+    return *this;
+
+  Attrs[Attribute::DereferenceableOrNullGlobally] = true;
+  DerefOrNullBytesGlobally = Bytes;
+  return *this;
+}
+
 AttrBuilder &AttrBuilder::addAllocSizeAttr(unsigned ElemSize,
                                            const Optional<unsigned> &NumElems) {
   return addAllocSizeAttrFromRawRepr(packAllocSizeArgs(ElemSize, NumElems));
 }
 
 AttrBuilder &AttrBuilder::addAllocSizeAttrFromRawRepr(uint64_t RawArgs) {
   // (0, 0) is our "not present" value, so we need to check for it here.
   assert(RawArgs && "Invalid allocsize arguments -- given allocsize(0, 0)");
if (!Ty->isPointerTy())
     // Attribute that only apply to pointers.
     Incompatible.addAttribute(Attribute::ByVal)
       .addAttribute(Attribute::Nest)
       .addAttribute(Attribute::NoAlias)
       .addAttribute(Attribute::NoCapture)
       .addAttribute(Attribute::NonNull)
       .addDereferenceableAttr(1) // the int here is ignored
       .addDereferenceableOrNullAttr(1) // the int here is ignored
+      .addDereferenceableGloballyAttr(1) // the int here is ignored
+      .addDereferenceableOrNullGloballyAttr(1) // the int here is ignored
       .addAttribute(Attribute::ReadNone)
       .addAttribute(Attribute::ReadOnly)
       .addAttribute(Attribute::StructRet)
       .addAttribute(Attribute::InAlloca);
 
   return Incompatible;
 }
 

llvm/lib/IR/Function.cpp

 }
 
 uint64_t Argument::getDereferenceableOrNullBytes() const {
   assert(getType()->isPointerTy() &&
          "Only pointers have dereferenceable bytes");
   return getParent()->getParamDereferenceableOrNullBytes(getArgNo());
 }
 
+uint64_t Argument::getDereferenceableGloballyBytes() const {
+  assert(getType()->isPointerTy() &&
+         "Only pointers have dereferenceable bytes");
+  return getParent()->getParamDereferenceableGloballyBytes(getArgNo());
+}
+
+uint64_t Argument::getDereferenceableOrNullGloballyBytes() const {
+  assert(getType()->isPointerTy() &&
+         "Only pointers have dereferenceable bytes");
+  return getParent()->getParamDereferenceableOrNullGloballyBytes(getArgNo());
+}
+
 bool Argument::hasNestAttr() const {
   if (!getType()->isPointerTy()) return false;
   return hasAttribute(Attribute::Nest);
 }
 
 bool Argument::hasNoAliasAttr() const {
   if (!getType()->isPointerTy()) return false;
   return hasAttribute(Attribute::NoAlias);

 
 void Function::addDereferenceableOrNullParamAttr(unsigned ArgNo,
                                                  uint64_t Bytes) {
   AttributeList PAL = getAttributes();
   PAL = PAL.addDereferenceableOrNullParamAttr(getContext(), ArgNo, Bytes);
   setAttributes(PAL);
 }
 
+void Function::addDereferenceableGloballyAttr(unsigned i, uint64_t Bytes) {
+  AttributeList PAL = getAttributes();
+  PAL = PAL.addDereferenceableGloballyAttr(getContext(), i, Bytes);
+  setAttributes(PAL);
+}
+
+void Function::addDereferenceableGloballyParamAttr(unsigned ArgNo, uint64_t Bytes) {
+  AttributeList PAL = getAttributes();
+  PAL = PAL.addDereferenceableGloballyParamAttr(getContext(), ArgNo, Bytes);
+  setAttributes(PAL);
+}
+
+void Function::addDereferenceableOrNullGloballyAttr(unsigned i, uint64_t Bytes) {
+  AttributeList PAL = getAttributes();
+  PAL = PAL.addDereferenceableOrNullGloballyAttr(getContext(), i, Bytes);
+  setAttributes(PAL);
+}
+
+void Function::addDereferenceableOrNullGloballyParamAttr(unsigned ArgNo,
+                                                 uint64_t Bytes) {
+  AttributeList PAL = getAttributes();
+  PAL =
+      PAL.addDereferenceableOrNullGloballyParamAttr(getContext(), ArgNo, Bytes);
+  setAttributes(PAL);
+}
+
 const std::string &Function::getGC() const {
   assert(hasGC() && "Function has no collector");
   return getContext().getGC(*this);
 }
 
 void Function::setGC(std::string Str) {
   setValueSubclassDataBit(14, !Str.empty());
   getContext().setGC(*this, std::move(Str));

llvm/lib/IR/LLVMContext.cpp

std::pair<unsigned, StringRef> MDKinds[] = {
     {MD_type, "type"},
     {MD_section_prefix, "section_prefix"},
     {MD_absolute_symbol, "absolute_symbol"},
     {MD_associated, "associated"},
     {MD_callees, "callees"},
     {MD_irr_loop, "irr_loop"},
     {MD_access_group, "llvm.access.group"},
     {MD_callback, "callback"},
+    {MD_dereferenceable_globally, "dereferenceable_globally"},
+    {MD_dereferenceable_or_null_globally, "dereferenceable_or_null_globally"},
   };
 
   for (auto &MDKind : MDKinds) {
     unsigned ID = getMDKindID(MDKind.second);
     assert(ID == MDKind.first && "metadata kind id drifted");
     (void)ID;
   }
 

llvm/lib/IR/Verifier.cpp

Assert(
       &II);
 
   visitTerminator(II);
 }
 
 /// visitUnaryOperator - Check the argument to the unary operator.
 ///
 void Verifier::visitUnaryOperator(UnaryOperator &U) {
-  Assert(U.getType() == U.getOperand(0)->getType(), 
+  Assert(U.getType() == U.getOperand(0)->getType(),
          "Unary operators must have same type for"
          "operands and result!",
          &U);
 
   switch (U.getOpcode()) {
   // Check that floating-point arithmetic operators are only used with
   // floating-point operands.
   case Instruction::FNeg:
if (!isa<PHINode>(I) && InstsInThisBlock.count(Op))
     return;
 
   const Use &U = I.getOperandUse(i);
   Assert(DT.dominates(Op, U),
          "Instruction does not dominate all uses!", Op, &I);
 }
 
 void Verifier::visitDereferenceableMetadata(Instruction& I, MDNode* MD) {
-  Assert(I.getType()->isPointerTy(), "dereferenceable, dereferenceable_or_null "
-         "apply only to pointer types", &I);
+  Assert(I.getType()->isPointerTy(),
+         "dereferenceable, dereferenceable_or_null, dereferenceable_globally, "
+         "and dereferenceable_or_null_globally apply only to pointer types",
+         &I);
   Assert(isa<LoadInst>(I),
-         "dereferenceable, dereferenceable_or_null apply only to load"
-         " instructions, use attributes for calls or invokes", &I);
-  Assert(MD->getNumOperands() == 1, "dereferenceable, dereferenceable_or_null "
-         "take one operand!", &I);
+         "dereferenceable, dereferenceable_or_null, dereferenceable_globally, "
+         "and dereferenceable_or_null_globally apply only to load "
+         "instructions, use attributes for calls or invokes",
+         &I);
+  Assert(MD->getNumOperands() == 1,
+         "dereferenceable, dereferenceable_or_null, dereferenceable_globally, "
+         "and dereferenceable_or_null_globally take one operand!",
+         &I);
   ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(MD->getOperand(0));
-  Assert(CI && CI->getType()->isIntegerTy(64), "dereferenceable, "
-         "dereferenceable_or_null metadata value must be an i64!", &I);
+  Assert(CI && CI->getType()->isIntegerTy(64),
+         "dereferenceable, "
+         "dereferenceable_or_null, dereferenceable_globally, and "
+         "dereferenceable_or_null_globally metadata value must be an i64!",
+         &I);
 }
 
 /// verifyInstruction - Verify that an instruction is well formed.
 ///
 void Verifier::visitInstruction(Instruction &I) {
   BasicBlock *BB = I.getParent();
   Assert(BB, "Instruction not embedded in basic block!", &I);
 
void Verifier::visitInstruction(Instruction &I) {
   if (I.getMetadata(LLVMContext::MD_nonnull)) {
     Assert(I.getType()->isPointerTy(), "nonnull applies only to pointer types",
            &I);
     Assert(isa<LoadInst>(I),
            "nonnull applies only to load instructions, use attributes"
            " for calls or invokes",
            &I);
   }
 
-  if (MDNode *MD = I.getMetadata(LLVMContext::MD_dereferenceable))
-    visitDereferenceableMetadata(I, MD);
-
-  if (MDNode *MD = I.getMetadata(LLVMContext::MD_dereferenceable_or_null))
+  for (auto ID : {LLVMContext::MD_dereferenceable,
+                  LLVMContext::MD_dereferenceable_or_null,
+                  LLVMContext::MD_dereferenceable_globally,
+                  LLVMContext::MD_dereferenceable_or_null_globally})
+    if (MDNode *MD = I.getMetadata(ID))
       visitDereferenceableMetadata(I, MD);
 
   if (MDNode *TBAA = I.getMetadata(LLVMContext::MD_tbaa))
     TBAAVerifyHelper.visitTBAAMetadata(I, TBAA);
 
   if (MDNode *AlignMD = I.getMetadata(LLVMContext::MD_align)) {
     Assert(I.getType()->isPointerTy(), "align applies only to pointer types",
            &I);
     Assert(isa<LoadInst>(I), "align applies only to load instructions, "
if (FPI.getIntrinsicID() == Intrinsic::experimental_constrained_fptrunc) {
       Assert(OperandTy->getScalarSizeInBits() > ResultTy->getScalarSizeInBits(),
              "Intrinsic first argument's type must be larger than result type",
              &FPI);
     } else {
       Assert(OperandTy->getScalarSizeInBits() < ResultTy->getScalarSizeInBits(),
              "Intrinsic first argument's type must be smaller than result type",
              &FPI);
     }
-  } 
+  }
     break;
 
   default:
     llvm_unreachable("Invalid constrained FP intrinsic!");
   }
 
   // If a non-metadata argument is passed in a metadata slot then the
   // error will be caught earlier when the incorrect argument doesn't
struct VerifierLegacyPass : public FunctionPass {
   bool doInitialization(Module &M) override {
     V = llvm::make_unique<Verifier>(
         &dbgs(), /*ShouldTreatBrokenDebugInfoAsError=*/false, M);
     return false;
   }
 
   bool runOnFunction(Function &F) override {
     if (!V->verify(F) && FatalErrors) {
-      errs() << "in function " << F.getName() << '\n'; 
+      errs() << "in function " << F.getName() << '\n';
       report_fatal_error("Broken function found, compilation aborted!");
     }
     return false;
   }
 
   bool doFinalization(Module &M) override {
     bool HasErrors = false;
     for (Function &F : M)

llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

case LLVMContext::MD_access_group:
       break;
 
     case LLVMContext::MD_nonnull:
       copyNonnullMetadata(LI, N, *NewLoad);
       break;
     case LLVMContext::MD_align:
     case LLVMContext::MD_dereferenceable:
     case LLVMContext::MD_dereferenceable_or_null:
+    case LLVMContext::MD_dereferenceable_globally:
+    case LLVMContext::MD_dereferenceable_or_null_globally:
       // These only directly apply if the new type is also a pointer.
       if (NewTy->isPointerTy())
         NewLoad->setMetadata(ID, N);
       break;
     case LLVMContext::MD_range:
       copyRangeMetadata(IC.getDataLayout(), LI, N, *NewLoad);
       break;
     }
case LLVMContext::MD_access_group:
       NewStore->setMetadata(ID, N);
       break;
     case LLVMContext::MD_invariant_load:
     case LLVMContext::MD_nonnull:
     case LLVMContext::MD_range:
     case LLVMContext::MD_align:
     case LLVMContext::MD_dereferenceable:
     case LLVMContext::MD_dereferenceable_or_null:
+    case LLVMContext::MD_dereferenceable_globally:
+    case LLVMContext::MD_dereferenceable_or_null_globally:
       // These don't apply for stores.
       break;
     }
   }
 
   return NewStore;
 }
 

llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp

unsigned KnownIDs[] = {
     LLVMContext::MD_range,
     LLVMContext::MD_invariant_load,
     LLVMContext::MD_alias_scope,
     LLVMContext::MD_noalias,
     LLVMContext::MD_nonnull,
     LLVMContext::MD_align,
     LLVMContext::MD_dereferenceable,
     LLVMContext::MD_dereferenceable_or_null,
+    LLVMContext::MD_dereferenceable_globally,
+    LLVMContext::MD_dereferenceable_or_null_globally,
     LLVMContext::MD_access_group,
   };
 
   for (unsigned ID : KnownIDs)
     NewLI->setMetadata(ID, FirstLI->getMetadata(ID));
 
   // Add all operands to the new PHI and combine TBAA metadata.
   for (unsigned i = 1, e = PN.getNumIncomingValues(); i != e; ++i) {

llvm/lib/Transforms/Utils/CodeExtractor.cpp

if (Attr.isStringAttribute()) {
       case Attribute::Alignment:
       case Attribute::AllocSize:
       case Attribute::ArgMemOnly:
       case Attribute::Builtin:
       case Attribute::ByVal:
       case Attribute::Convergent:
       case Attribute::Dereferenceable:
       case Attribute::DereferenceableOrNull:
+      case Attribute::DereferenceableGlobally:
+      case Attribute::DereferenceableOrNullGlobally:
       case Attribute::InAlloca:
       case Attribute::InReg:
       case Attribute::InaccessibleMemOnly:
       case Attribute::InaccessibleMemOrArgMemOnly:
       case Attribute::JumpTable:
       case Attribute::Naked:
       case Attribute::Nest:
       case Attribute::NoAlias:

llvm/lib/Transforms/Utils/Local.cpp

switch (Kind) {
         // Preserve !invariant.group in K.
         break;
       case LLVMContext::MD_align:
         K->setMetadata(Kind,
           MDNode::getMostGenericAlignmentOrDereferenceable(JMD, KMD));
         break;
       case LLVMContext::MD_dereferenceable:
       case LLVMContext::MD_dereferenceable_or_null:
+      case LLVMContext::MD_dereferenceable_globally:
+      case LLVMContext::MD_dereferenceable_or_null_globally:
         K->setMetadata(Kind,
           MDNode::getMostGenericAlignmentOrDereferenceable(JMD, KMD));
         break;
     }
   }
   // Set !invariant.group from J if J has it. If both instructions have it
   // then we will just pick it from J - even when they are different.
   // Also make sure that K is load or store - f.e. combining bitcast with load
void llvm::combineMetadataForCSE(Instruction *K, const Instruction *J,
                                  bool KDominatesJ) {
   unsigned KnownIDs[] = {
       LLVMContext::MD_tbaa,            LLVMContext::MD_alias_scope,
       LLVMContext::MD_noalias,         LLVMContext::MD_range,
       LLVMContext::MD_invariant_load,  LLVMContext::MD_nonnull,
       LLVMContext::MD_invariant_group, LLVMContext::MD_align,
       LLVMContext::MD_dereferenceable,
       LLVMContext::MD_dereferenceable_or_null,
+      LLVMContext::MD_dereferenceable_globally,
+      LLVMContext::MD_dereferenceable_or_null_globally,
       LLVMContext::MD_access_group};
   combineMetadata(K, J, KnownIDs, KDominatesJ);
 }
 
 void llvm::patchReplacementInstruction(Instruction *I, Value *Repl) {
   auto *ReplInst = dyn_cast<Instruction>(Repl);
   if (!ReplInst)
     return;

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

if (isa<DbgInfoIntrinsic>(I1) || isa<DbgInfoIntrinsic>(I2)) {
                              LLVMContext::MD_range,
                              LLVMContext::MD_fpmath,
                              LLVMContext::MD_invariant_load,
                              LLVMContext::MD_nonnull,
                              LLVMContext::MD_invariant_group,
                              LLVMContext::MD_align,
                              LLVMContext::MD_dereferenceable,
                              LLVMContext::MD_dereferenceable_or_null,
+                             LLVMContext::MD_dereferenceable_globally,
+                             LLVMContext::MD_dereferenceable_or_null_globally,
                              LLVMContext::MD_mem_parallel_loop_access,
                              LLVMContext::MD_access_group};
       combineMetadata(I1, I2, KnownIDs, true);
 
       // I1 and I2 are being combined into a single instruction.  Its debug
       // location is the merged locations of the original instructions.
       I1->applyMergedLocation(I1->getDebugLoc(), I2->getDebugLoc());
 

llvm/test/Bitcode/attributes.ll

 }
 
 ; CHECK: define void @f59() #35
 define void @f59() shadowcallstack
 {
   ret void
 }
 
+define dereferenceable_globally(2) i8* @f60(i8* dereferenceable_globally(1) %a) {
+; CHECK: define dereferenceable_globally(2) i8* @f39(i8* dereferenceable_globally(1) %a) {
+  ret i8* %a
+}
+
+define dereferenceable_globally(18446744073709551606) i8* @f61(i8* dereferenceable_globally(18446744073709551615) %a) {
+; CHECK: define dereferenceable_globally(18446744073709551606) i8* @f40(i8* dereferenceable_globally(18446744073709551615) %a) {
+  ret i8* %a
+}
+
+; CHECK: define dereferenceable_or_null_globally(8) i8* @f42(i8* dereferenceable_or_null_globally(8) %foo)
+define dereferenceable_or_null_globally(8) i8* @f62(i8* dereferenceable_or_null_globally(8) %foo) {
+  ret i8* %foo
+}
+
+
 ; CHECK: attributes #0 = { noreturn }
 ; CHECK: attributes #1 = { nounwind }
 ; CHECK: attributes #2 = { readnone }
 ; CHECK: attributes #3 = { readonly }
 ; CHECK: attributes #4 = { noinline }
 ; CHECK: attributes #5 = { alwaysinline }
 ; CHECK: attributes #6 = { optsize }
 ; CHECK: attributes #7 = { ssp }

llvm/test/Verifier/dereferenceable-globally-md.ll

+; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
+
+declare i8* @foo()
+
+define void @f1() {
+entry:
+  call i8* @foo(), !dereferenceable_globally !{i64 2}
+  ret void
+}
+; CHECK: dereferenceable_globally, dereferenceable_or_null_globally apply only to load instructions, use attributes for calls or invokes
+; CHECK-NEXT: call i8* @foo()
+
+define void @f2() {
+entry:
+  call i8* @foo(), !dereferenceable_or_null_globally !{i64 2}
+  ret void
+}
+; CHECK: dereferenceable_globally, dereferenceable_or_null_globally apply only to load instructions, use attributes for calls or invokes
+; CHECK-NEXT: call i8* @foo()
+
+define i8 @f3(i8* %x) {
+entry:
+  %y = load i8, i8* %x, !dereferenceable_globally !{i64 2}
+  ret i8 %y
+}
+; CHECK: dereferenceable_globally, dereferenceable_or_null_globally apply only to pointer types
+; CHECK-NEXT: load i8, i8* %x
+
+define i8 @f4(i8* %x) {
+entry:
+  %y = load i8, i8* %x, !dereferenceable_or_null_globally !{i64 2}
+  ret i8 %y
+}
+; CHECK: dereferenceable_globally, dereferenceable_or_null_globally apply only to pointer types
+; CHECK-NEXT: load i8, i8* %x
+
+define i8* @f5(i8** %x) {
+entry:
+  %y = load i8*, i8** %x, !dereferenceable_globally !{}
+  ret i8* %y
+}
+; CHECK: dereferenceable_globally, dereferenceable_or_null_globally take one operand
+; CHECK-NEXT: load i8*, i8** %x
+
+
+define i8* @f6(i8** %x) {
+entry:
+  %y = load i8*, i8** %x, !dereferenceable_or_null_globally !{}
+  ret i8* %y
+}
+; CHECK: dereferenceable_globally, dereferenceable_or_null_globally take one operand
+; CHECK-NEXT: load i8*, i8** %x
+
+define i8* @f7(i8** %x) {
+entry:
+  %y = load i8*, i8** %x, !dereferenceable_globally !{!"str"}
+  ret i8* %y
+}
+; CHECK: dereferenceable_globally, dereferenceable_or_null_globally metadata value must be an i64!
+; CHECK-NEXT: load i8*, i8** %x
+
+
+define i8* @f8(i8** %x) {
+entry:
+  %y = load i8*, i8** %x, !dereferenceable_or_null_globally !{!"str"}
+  ret i8* %y
+}
+; CHECK: dereferenceable_globally, dereferenceable_or_null_globally metadata value must be an i64!
+; CHECK-NEXT: load i8*, i8** %x
+
+define i8* @f9(i8** %x) {
+entry:
+  %y = load i8*, i8** %x, !dereferenceable_globally !{i32 2}
+  ret i8* %y
+}
+; CHECK: dereferenceable_globally, dereferenceable_or_null_globally metadata value must be an i64!
+; CHECK-NEXT: load i8*, i8** %x
+
+
+define i8* @f10(i8** %x) {
+entry:
+  %y = load i8*, i8** %x, !dereferenceable_or_null_globally !{i32 2}
+  ret i8* %y
+}
+; CHECK: dereferenceable_globally, dereferenceable_or_null_globally metadata value must be an i64!
+; CHECK-NEXT: load i8*, i8** %x