[IR][Verifier] Allow IntToPtrInst to be !dereferenceable

[rtaylor]

Summary

Allow IntToPtrInst to carry !dereferenceable metadata tag.
This is valid since !dereferenceable can be only be applied to
pointer type values.

Change-Id: If8a6e3c616f073d51eaff52ab74535c29ed497b4

[arsenm]

test/Verifier/dereferenceable-md.ll

88–90

Can you also add a test for defeferencable_or_null

[jdoerfert]

test/Verifier/dereferenceable-md.ll

91

And all other tests as well, e.g., a positive test (not here), wrong type, wrong number of operands, etc.

[arsenm]

Also needs a langref update

[rtaylor]

Added tests and updated LangRef

[arsenm]

test/Verifier/dereferenceable-md-inttoptr.ll

2–5

Verifier tests should not run llc and cannot depend on a target. Most verifier just uses llvm-as

[rtaylor]

Added !dereferenceable_or_null to syntax of inttoptr in LangRef

[rtaylor]

Fixed test to use llvm-as and to just check for passing.

[jdoerfert]

Are you planning to teach Value::getPointerDereferenceableBytes about this? The rest of the pipeline "should" then "just work" and use the information.

docs/LangRef.rst

9679

Copy & Paste, these are no loads. Remove last sentence and add load metadata to the list of analogous things.

lib/IR/Verifier.cpp

3986

Why ^? I personally find that confusing. || should do just fine.

[rtaylor]

Changed LangRef.rst to reflect !dereferenceable is applicable to pointer types not
just load types.

Changed logic in verifier.

[rtaylor]

Added IntToPtrInst to case statement in Value::getPointerDereferenceableBytes

[jdoerfert]

I'm fine with this, let's give @arsenm a chance to look at it as well.

[arsenm]

LGTM

[nhaehnle]

Thanks! Could you please also add a test to Analysis/ValueTracking/memory-dereferenceable.ll?

docs/LangRef.rst

8642–8643

Propose a change of the wording here to: This metadata can only be applied to certain instructions producing a pointer value.

After all, the metadata is not applied to the type itself. Same goes in the next paragraph.

[rtaylor]

docs/LangRef.rst

8642–8643

Are there certain instructions that produce a pointer value in which !dereferenceable cannot be applied? If so, then maybe we should list the instructions in the description(s) that it can be applied, for clarity? I'd rather not leave this as vague as "certain instructions" because the reader's first thoughts are going to be "which instructions?" Certainly if the description exists for every instruction than one could deduce it by why be vague if we don't have to?

[rtaylor]

docs/LangRef.rst

8642–8643

Also, the current Parameter Attributes reads quite simliar: This attribute may only be applied to pointer typed parameters.

So in this case, it's actually attached to the type and not the instruction?

[arsenm]

docs/LangRef.rst

8642–8643

Calls aren't allowed because they have matching attributes that are superior to the metadata. Other cases I think are less clear and may make sense to allow it in the future.

I think this section should be split out. As is, you are just updating the notes on metadata allowed for loads. The load and inttoptr can then reference the !dereferencable section

[rtaylor]

docs/LangRef.rst

8642–8643

Agree. I think these should probably have their own '`....`' Metadata section?

[rtaylor]

Changed LangRef.rst: Moved !dereferenceable and !dereferenceable_or_null to their
own section in Metadata and pointed inttoptr and load to that section.

Added test for Analysis/ValueTracking.

[nhaehnle]

docs/LangRef.rst

5306–5324

Could you add the incantations for hyperlinks? ".. _blahblah" for the anchor and :ref:.... <blahblah> for the link.

[rtaylor]

Added hyperlinks to LangRef.rst

[nhaehnle]

LGTM, though I believe the hyperlinks in :ref: need to be without the underscore (and other examples of :ref: use seem to corroborate that).

[rtaylor]

Removed preceding underline to ref hyperlink.

[rtaylor]

Remove underline to ref hyperlink from invariant.group

docs/LangRef.rst

 
 ``unpredictable`` metadata may be attached to any branch or switch
 instruction. It can be used to express the unpredictability of control
 flow. Similar to the llvm.expect intrinsic, it may be used to alter
 optimizations related to compare and branch instructions. The metadata
 is treated as a boolean value; if it exists, it signals that the branch
 or switch that it is attached to is completely unpredictable.
 
+.. _md_dereferenceable:
+
+'``dereferenceable``' Metadata
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+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.
+
+.. _md_dereferenceable_or_null:
+
+'``dereferenceable_or_null``' Metadata
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+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.
+
 .. _llvm.loop:
 
 '``llvm.loop``'
 ^^^^^^^^^^^^^^^
 
 It is sometimes useful to attach information to loop constructs. Currently,
 loop metadata is implemented as metadata attached to the branch instruction
 in the loop latch block. This type of metadata refer to a metadata node that is
.. code-block:: llvm
     ...
     br i1 %cmp, label %t1, label %t2, !irr_loop !0
 
     ...
     !0 = !{"loop_header_weight", i64 100}
 
 Irreducible loop header weights are typically based on profile data.
 
+.. _md_invariant.group:
+
 '``invariant.group``' Metadata
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 The experimental ``invariant.group`` metadata may be attached to
 ``load``/``store`` instructions referencing a single metadata with no entries.
 The existence of the ``invariant.group`` metadata on the instruction tells
 the optimizer that every ``load`` and ``store`` to the same pointer operand
 can be assumed to load or store the same

 entries. If a load instruction tagged with the ``!invariant.load``
 metadata is executed, the optimizer may assume the memory location
 referenced by the load contains the same value at all points in the
 program where the memory location is known to be dereferenceable;
 otherwise, the behavior is undefined.
 
 The optional ``!invariant.group`` metadata must reference a single metadata name
  ``<index>`` corresponding to a metadata node with no entries.
- See ``invariant.group`` metadata.
+ See ``invariant.group`` metadata :ref:`invariant.group <_md_invariant.group>`
 
 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
 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.
+entry.
+See ``dereferenceable`` metadata :ref:`dereferenceable <_md_dereferenceable>`
 
 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.
+``i64`` entry.
+See ``dereferenceable_or_null`` metadata :ref:`dereferenceable_or_null
+<_md_dereferenceable_or_null>`
 
 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

 '``inttoptr .. to``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      <result> = inttoptr <ty> <value> to <ty2>             ; yields ty2
+      <result> = inttoptr <ty> <value> to <ty2>[, !dereferenceable !<deref_bytes_node>][, !dereferenceable_or_null !<deref_bytes_node]             ; yields ty2
 
 Overview:
 """""""""
 
 The '``inttoptr``' instruction converts an integer ``value`` to a
 pointer type, ``ty2``.
 
 Arguments:
 """"""""""
 
 The '``inttoptr``' instruction takes an :ref:`integer <t_integer>` value to
 cast, and a type to cast it to, which must be a :ref:`pointer <t_pointer>`
 type.
 
+The optional ``!dereferenceable`` metadata must reference a single metadata
+name ``<deref_bytes_node>`` corresponding to a metadata node with one ``i64``
+entry.
+See ``dereferenceable`` metadata.
+
+The optional ``!dereferenceable_or_null`` metadata must reference a single
+metadata name ``<deref_bytes_node>`` corresponding to a metadata node with one
+``i64`` entry.
+See ``dereferenceable_or_null`` metadata.
+
 Semantics:
 """"""""""
 
 The '``inttoptr``' instruction converts ``value`` to type ``ty2`` by
 applying either a zero extension or a truncation depending on the size
 of the integer ``value``. If ``value`` is larger than the size of a
 pointer then a truncation is done. If ``value`` is smaller than the size
 of a pointer then a zero extension is done. If they are the same size,
 nothing is done (*no-op cast*).
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
       %X = inttoptr i32 255 to i32*          ; yields zero extension on 64-bit architecture
       %Y = inttoptr i32 255 to i32*          ; yields no-op on 32-bit architecture

lib/IR/Value.cpp

if (const Argument *A = dyn_cast<Argument>(this)) {
     if (DerefBytes == 0) {
       if (MDNode *MD =
               LI->getMetadata(LLVMContext::MD_dereferenceable_or_null)) {
         ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
         DerefBytes = CI->getLimitedValue();
       }
       CanBeNull = true;
     }
+  } else if (auto *IP = dyn_cast<IntToPtrInst>(this)) {
+    if (MDNode *MD = IP->getMetadata(LLVMContext::MD_dereferenceable)) {
+      ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
+      DerefBytes = CI->getLimitedValue();
+    }
+    if (DerefBytes == 0) {
+      if (MDNode *MD =
+              IP->getMetadata(LLVMContext::MD_dereferenceable_or_null)) {
+        ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
+        DerefBytes = CI->getLimitedValue();
+      }
+      CanBeNull = true;
+    }
   } else if (auto *AI = dyn_cast<AllocaInst>(this)) {
     if (!AI->isArrayAllocation()) {
       DerefBytes = DL.getTypeStoreSize(AI->getAllocatedType());
       CanBeNull = false;
     }
   } else if (auto *GV = dyn_cast<GlobalVariable>(this)) {
     if (GV->getValueType()->isSized() && !GV->hasExternalWeakLinkage()) {
       // TODO: Don't outright reject hasExternalWeakLinkage but set the

lib/IR/Verifier.cpp

void Verifier::verifyDominatesUse(Instruction &I, unsigned i) {
   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(isa<LoadInst>(I),
+  Assert((isa<LoadInst>(I) || isa<IntToPtrInst>(I)),
          "dereferenceable, dereferenceable_or_null apply only to load"
-         " instructions, use attributes for calls or invokes", &I);
+         " and inttoptr instructions, use attributes for calls or invokes", &I);
   Assert(MD->getNumOperands() == 1, "dereferenceable, dereferenceable_or_null "
          "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);
 }
 
 /// verifyInstruction - Verify that an instruction is well formed.

test/Analysis/ValueTracking/memory-dereferenceable.ll

; CHECK: %d4_aligned_load{{.*}}(aligned)
    ; the type (specified by datalayout string).
 ; CHECK: %alloca.noalign{{.*}}(aligned)
     %alloca.noalign = alloca i32
     %load28 = load i32, i32* %alloca.noalign, align 8
 
     ret void
 }
 
+; CHECK: The following are dereferenceable:
+; CHECK: %ptr = inttoptr i32 %val to i32*, !dereferenceable !0
+define i32 @f_0(i32 %val) {
+  %ptr = inttoptr i32 %val to i32*, !dereferenceable !0
+  %load29 = load i32, i32* %ptr, align 8
+  ret i32 %load29 
+}
+
 ; Just check that we don't crash.
 ; CHECK-LABEL: 'opaque_type_crasher'
 define void @opaque_type_crasher(%TypeOpaque* dereferenceable(16) %a) {
 entry:
   %bc = bitcast %TypeOpaque* %a to i8*
   %ptr8 = getelementptr inbounds i8, i8* %bc, i32 8
   %ptr32 = bitcast i8* %ptr8 to i32*
   br i1 undef, label %if.then, label %if.end

test/Verifier/dereferenceable-md-inttoptr.ll

+; RUN: llvm-as < %s -o /dev/null
+
+define i8* @f_0(i8 %val) {
+  %ptr = inttoptr i8 %val to i8*, !dereferenceable_or_null !{i64 2}
+  ret i8* %ptr 
+}

test/Verifier/dereferenceable-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 !{i64 2}
   ret void
 }
-; CHECK: dereferenceable, dereferenceable_or_null apply only to load instructions, use attributes for calls or invokes
+; CHECK: dereferenceable, dereferenceable_or_null apply only to load and inttoptr instructions, use attributes for calls or invokes
 ; CHECK-NEXT: call i8* @foo()
 
 define void @f2() {
 entry:
   call i8* @foo(), !dereferenceable_or_null !{i64 2}
   ret void
 }
-; CHECK: dereferenceable, dereferenceable_or_null apply only to load instructions, use attributes for calls or invokes
+; CHECK: dereferenceable, dereferenceable_or_null apply only to load and inttoptr instructions, use attributes for calls or invokes
 ; CHECK-NEXT: call i8* @foo()
 
 define i8 @f3(i8* %x) {
 entry:
   %y = load i8, i8* %x, !dereferenceable !{i64 2}
   ret i8 %y
 }
 ; CHECK: dereferenceable, dereferenceable_or_null apply only to pointer types

 
 
 define i8* @f10(i8** %x) {
 entry:
   %y = load i8*, i8** %x, !dereferenceable_or_null !{i32 2}
   ret i8* %y
 }
 ; CHECK: dereferenceable, dereferenceable_or_null metadata value must be an i64!
-; CHECK-NEXT: load i8*, i8** %x
+; CHECK-NEXT: load i8*, i8** %x
+
+define i8* @f_11(i8 %val) {
+  %ptr = inttoptr i8 %val to i8*, !dereferenceable !{i32 2}
+  ret i8* %ptr
+}
+; CHECK: dereferenceable, dereferenceable_or_null metadata value must be an i64!
+; CHECK-NEXT: %ptr = inttoptr i8 %val to i8*, !dereferenceable !3
+
+define i8* @f_12(i8 %val) {
+  %ptr = inttoptr i8 %val to i8*, !dereferenceable_or_null !{i32 2}
+  ret i8* %ptr
+}
+; CHECK: dereferenceable, dereferenceable_or_null metadata value must be an i64!
+; CHECK-NEXT: %ptr = inttoptr i8 %val to i8*, !dereferenceable_or_null !3
+
+define i8* @f_13(i8 %val) {
+  %ptr = inttoptr i8 %val to i8*, !dereferenceable !{}
+  ret i8* %ptr
+}
+; CHECK: dereferenceable, dereferenceable_or_null take one operand
+; CHECK-NEXT: %ptr = inttoptr i8 %val to i8*, !dereferenceable !1
+
+define i8* @f_14(i8 %val) {
+  %ptr = inttoptr i8 %val to i8*, !dereferenceable_or_null !{}
+  ret i8* %ptr
+}
+; CHECK: dereferenceable, dereferenceable_or_null take one operand
+; CHECK-NEXT: %ptr = inttoptr i8 %val to i8*, !dereferenceable_or_null !1
+
+define i8* @f_15(i8 %val) {
+  %ptr = inttoptr i8 %val to i8*, !dereferenceable !{!"str"}
+  ret i8* %ptr
+}
+; CHECK: dereferenceable, dereferenceable_or_null metadata value must be an i64!
+; CHECK-NEXT: %ptr = inttoptr i8 %val to i8*, !dereferenceable !2
+
+define i8* @f_16(i8 %val) {
+  %ptr = inttoptr i8 %val to i8*, !dereferenceable_or_null !{!"str"}
+  ret i8* %ptr
+}
+; CHECK: dereferenceable, dereferenceable_or_null metadata value must be an i64!
+; CHECK-NEXT: %ptr = inttoptr i8 %val to i8*, !dereferenceable_or_null !2