Introduce !value.align metadata for load instruction

[apilipenko]

Summary

Since D9791 we take alignment into account to decide if it's safe to speculate load. Now pointer has to be both dereferenceable and properly aligned to be speculative loadable. It means that we want to support align attribute everywhere we support dereferenceable attribute.

Introduce new !value.align metadata for load instruction. This metadata specifies alignment of the loaded pointer value.

[sanjoy]

docs/LangRef.rst

6856

Is it restricted to be a power of two (I'd guess so)? If so, that should be noted here.

lib/Analysis/ValueTracking.cpp

2962

With your changes, does this bit remain necessary? I think this part is unsound anyway (since it relies on differentiating different pointer types of the same address space).

[apilipenko]

Add a sentence to LangRef to require alignment to be a power of 2.

lib/Analysis/ValueTracking.cpp

2962

I'm going to remove this in a separate patch.

[hfinkel]

I assume that you want to call this '!value.align' to differentiate it from the existing 'align' argument to the load. This is syntactically unnecessary, and while I agree that it could seem confusing, is also inconsistent with the other similar metadata. We don't have value.nonnull or value.dereferenceable, and I'm inclined to think that we should just call this !align for consistency.

[apilipenko]

Rename !value.align to !align.

[hfinkel]

This LGTM; I agree this is a common case and worth representing using metadata instead of calls to @llvm.assume (just as with !nonnull). However, as with !nonnull, if we add this metadata, the associated follow-up work needs to be done:

1. Add code that canonicalizes @llvm.assume calls to this metadata when possible.
2. Audit all places where we combine and/or drop metadata on loads, and preserve / combine this metadata when possible.

If you'll do those things as follow-up, then go ahead.

docs/LangRef.rst

 '``load``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      <result> = load [volatile] <ty>, <ty>* <pointer>[, align <alignment>][, !nontemporal !<index>][, !invariant.load !<index>][, !nonnull !<index>][, !dereferenceable !<index>][, !dereferenceable_or_null !<index>]
+      <result> = load [volatile] <ty>, <ty>* <pointer>[, align <alignment>][, !nontemporal !<index>][, !invariant.load !<index>][, !nonnull !<index>][, !dereferenceable !<index>][, !dereferenceable_or_null !<index>][, !value.align !<value_align_node>]
       <result> = load atomic [volatile] <ty>* <pointer> [singlethread] <ordering>, align <alignment>
       !<index> = !{ i32 1 }
+      !<value_align_node> = !{ i64 <alignment> }
 
 Overview:
 """""""""
 
 The '``load``' instruction is used to read from memory.
 
 Arguments:
 """"""""""

 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.
 
+The optional ``!value.align`` metadata must reference a single
+metadata name ``<value_align_node>`` corresponding to a metadata node with one
+``i64`` entry. The existence of the ``!value.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.
+
 Semantics:
 """"""""""
 
 The location of memory pointed to is loaded. If the value being loaded
 is of scalar type then the number of bytes read does not exceed the
 minimum number of bytes needed to hold all bits of the type. For
 example, loading an ``i24`` reads at most three bytes. When loading a
 value of a type like ``i20`` with a size that is not an integral number

include/llvm/IR/LLVMContext.h

enum {
     MD_alias_scope = 7, // "alias.scope"
     MD_noalias = 8, // "noalias",
     MD_nontemporal = 9, // "nontemporal"
     MD_mem_parallel_loop_access = 10, // "llvm.mem.parallel_loop_access"
     MD_nonnull = 11, // "nonnull"
     MD_dereferenceable = 12, // "dereferenceable"
     MD_dereferenceable_or_null = 13, // "dereferenceable_or_null"
     MD_make_implicit = 14, // "make.implicit"
-    MD_unpredictable = 15 // "unpredictable"
+    MD_unpredictable = 15, // "unpredictable"
+    MD_value_align = 16 // "value.align"
   };
 
   /// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
   /// This ID is uniqued across modules in the current LLVMContext.
   unsigned getMDKindID(StringRef Name) const;
 
   /// getMDKindNames - Populate client supplied SmallVector with the name for
   /// custom metadata IDs registered in this LLVMContext.

lib/Analysis/ValueTracking.cpp

static bool isAligned(const Value *Base, APInt Offset, unsigned Align,
                       const DataLayout &DL) {
   APInt BaseAlign(Offset.getBitWidth(), 0);
   if (const AllocaInst *AI = dyn_cast<AllocaInst>(Base))
     BaseAlign = AI->getAlignment();
   else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(Base))
     BaseAlign = GV->getAlignment();
   else if (const Argument *A = dyn_cast<Argument>(Base))
     BaseAlign = A->getParamAlignment();
+  else if (const LoadInst *LI = dyn_cast<LoadInst>(Base))
+    if (MDNode *MD = LI->getMetadata(LLVMContext::MD_value_align)) {
+      ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
+      BaseAlign = CI->getLimitedValue();
+    }
 
   if (!BaseAlign) {
     Type *Ty = Base->getType()->getPointerElementType();
     BaseAlign = DL.getABITypeAlignment(Ty);
   }
 
   APInt Alignment(Offset.getBitWidth(), Align);
 
   assert(Alignment.isPowerOf2() && "must be a power of 2!");
   return BaseAlign.uge(Alignment) && !(Offset & (Alignment-1));
 }

lib/IR/LLVMContext.cpp

assert(MakeImplicitID == MD_make_implicit &&
          "make.implicit kind id drifted");
   (void)MakeImplicitID;
 
   // Create the 'unpredictable' metadata kind.
   unsigned UnpredictableID = getMDKindID("unpredictable");
   assert(UnpredictableID == MD_unpredictable &&
          "unpredictable kind id drifted");
   (void)UnpredictableID;
+
+  // Create the 'value.align' metadata kind.
+  unsigned ValueAlignID = getMDKindID("value.align");
+  assert(ValueAlignID == MD_value_align &&
+         "value.align kind id drifted");
+  (void)ValueAlignID;
 }
 LLVMContext::~LLVMContext() { delete pImpl; }
 
 void LLVMContext::addModule(Module *M) {
   pImpl->OwnedModules.insert(M);
 }
 
 void LLVMContext::removeModule(Module *M) {

test/Analysis/ValueTracking/memory-dereferenceable.ll

; CHECK: %gep.align16.offset16{{.*}}(aligned)
     %gep.align16.offset1 = getelementptr inbounds i8, i8 addrspace(1)* %dparam.align16, i32 1
     %gep.align1.offset16 = getelementptr inbounds i8, i8 addrspace(1)* %dparam.align1, i32 16
     %gep.align16.offset16 = getelementptr inbounds i8, i8 addrspace(1)* %dparam.align16, i32 16
     %load19 = load i8, i8 addrspace(1)* %gep.align1.offset1, align 16
     %load20 = load i8, i8 addrspace(1)* %gep.align16.offset1, align 16
     %load21 = load i8, i8 addrspace(1)* %gep.align1.offset16, align 16
     %load22 = load i8, i8 addrspace(1)* %gep.align16.offset16, align 16
 
+    ; Load from a dereferenceable and aligned load
+; CHECK: %d4_unaligned_load{{.*}}(unaligned)
+; CHECK: %d4_aligned_load{{.*}}(aligned)
+    %d4_unaligned_load = load i32*, i32** @globali32ptr, !dereferenceable !0
+    %d4_aligned_load = load i32*, i32** @globali32ptr, !dereferenceable !0, !value.align !{i64 16}
+    %load23 = load i32, i32* %d4_unaligned_load, align 16
+    %load24 = load i32, i32* %d4_aligned_load, align 16
+
     ret void
 }
 
 declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i64, i32, i1 ()*, i32, i32, ...)
 declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32)
 
 !0 = !{i64 4}
 !1 = !{i64 2}
 !2 = !{}