I hit this problem using an out of tree backend.
A single libcxx test related to std::vector was failing.

The wording from the LangRef is bit unclear about this case.

"If the inbounds keyword is present, the result value of the getelementptr is a poison value if the base pointer is not an in bounds address of an allocated object, or if any of the addresses that would be formed by successive addition of the offsets implied by the indices to the base address with infinitely precise signed arithmetic are not an in bounds address of that allocated object. The in bounds addresses for an allocated object are all the addresses that point into the object, plus the address one byte past the end. The only in bounds address for a null pointer in the default address-space is the null pointer itself. In cases where the base is a vector of pointers the inbounds keyword applies to each of the computations element-wise."

"If the inbounds keyword is not present, the offsets are added to the base address with silently-wrapping two’s complement arithmetic. If the offsets have a different width from the pointer, they are sign-extended or truncated to the width of the pointer. The result value of the getelementptr may be outside the object pointed to by the base pointer. The result value may not necessarily be used to access memory though, even if it happens to point into allocated storage. See the Pointer Aliasing Rules section for more information."

What does "infinitely precise signed arithmetic" mean? Does it mean interpretation as abstract integers? Or something more restrictive?

Secondly, we never actually describe how to compute an inbounds GEP. :) I'm pretty sure the second paragraph should apply to all geps, not just inbound ones. It feels very strange to have any difference in address computation between the inbounds and not-inbounds variants.

Looking at the implementation doesn't add much clarity. SelectionDAG interprets inbounds as meaning that only the additions (not the multiplications) implied by the addressing are NUW if offsets can be proven non-negative. The code in Analysis/Local.h EmitGEPOffset inteprets the NUW as applying to the muls and nt the adds. So, no consistency there...

Anyone want to make a guess as to what the LangRef should say?

Given the lowering done and that indexes and considered signed integers, my take on the semantics for inbounds is:

• idx * sizeof(*ptr) cannot overflow signed (NSW)
• ptr + (idx * sizeof(*ptr)) cannot overflow signed (NSW)

LLVM assumes that objsize it at most half of the address space (in several places, including here). So none of the above constraints limits expressiblility of valid programs.
The infinite precision argument is not needed because each of the add/mul operations can be done with the same bitwidth as the pointer without loss of precision. E.g. for 64 bits we have -2^63 <= idx * sizeof(*ptr) <= 2^63 (well, technically we cannot have 1 past the object if we allow obj size to go up to 2^63-1; it needs to be 2^63-2)

Fixed in https://reviews.llvm.org/rGb6534b2a26fa94e4d09d271faf538b1e4b19ab5d
Thanks!