[Loads] Globals are dereferenceable, if offset + size <= sizeof(global).

[fhahn]

Summary

Currently we fail to determine whether pointers to globals are
dereferenceable. Unless I am missing something, we can treat constant
expression GEPs as dereferenceable, if all the dereferenced bits fall
within the global's size.

[nlopes]

The reasoning looks good, though the case when offset + size overflows doesn't seem to be considered.

[aqjune]

It may be a silly question, but can lifetime.end intrinsics be applied to global variables, too?
LangRef isn't clear about this, but it makes sense to say that lifetime.end only works for alloca/mallocs IMO.

[efriedma]

I'm not sure I understand why you need a special case here. I think getPointerDereferenceableBytes() and isAligned() should handle global variables without any additional help.

If this does make a difference, it should be possible to write a testcase using LICM or something like that.

[jdoerfert]

IIRC, not all globals are dereferenceable and we have to look at the linkage. Could be wrong though.

This needs a test for sure.

Why * 8 isn't size in bytes too?

Shouldn't we handle gep+global in Value::getPointerDereferenceableBytes instead, that should make this unnecessary, right?

[fhahn]

In D85522#2203414, @efriedma wrote:

I'm not sure I understand why you need a special case here. I think getPointerDereferenceableBytes() and isAligned() should handle global variables without any additional help.

If this does make a difference, it should be possible to write a testcase using LICM or something like that.

You are right, this is already handled, I was just using isDereferenceablePointer with the wrong type, which was why it didn't work initially. Sorry for the noise, this seems not needed after all!

llvm/lib/Analysis/Loads.cpp

if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
     const Value *Base = GEP->getPointerOperand();
 
     APInt Offset(DL.getIndexTypeSizeInBits(GEP->getType()), 0);
     if (!GEP->accumulateConstantOffset(DL, Offset) || Offset.isNegative() ||
         !Offset.urem(APInt(Offset.getBitWidth(), Alignment.value()))
              .isMinValue())
       return false;
 
+    // A pointer to a global value is dereferenceable  if all dereferenced bits
+    // are within the global's size.
+    if (auto *GV = dyn_cast<GlobalValue>(Base)) {
+      if (((Offset + Size.sextOrTrunc(Offset.getBitWidth())) * 8)
+              .ule(
+                  DL.getTypeSizeInBits(GV->getType()->getPointerElementType())))
+        return true;
+    }
+
     // If the base pointer is dereferenceable for Offset+Size bytes, then the
     // GEP (== Base + Offset) is dereferenceable for Size bytes.  If the base
     // pointer is aligned to Align bytes, and the Offset is divisible by Align
     // then the GEP (== Base + Offset == k_0 * Align + k_1 * Align) is also
     // aligned to Align bytes.
 
     // Offset and Size may have different bit widths if we have visited an
     // addrspacecast, so we can't do arithmetic directly on the APInt values.