[IR] Allow the 'align' param attr on vectors of pointers

[frasercrmck]

Summary

This patch extends the available uses of the 'align' parameter attribute
to include vectors of pointers. The attribute specifies pointer
alignment element-wise.

This change was previously requested and discussed in D87304.

The vector predication (VP) intrinsics intend to use this for scatter
and gather operations, as they lack the explicit alignment parameter
that the masked versions use.

[arsenm]

I think this needs some more changes down in codegen to pass them through

[frasercrmck]

In D115161#3173792, @arsenm wrote:

I think this needs some more changes down in codegen to pass them through

Specifically for the VP intrinsics, I have D114423 to fix the missing codegen translation. Is that what you were referring to?

[anna]

Change LGTM. @jdoerfert any additional comments?

[frasercrmck]

• rebase

ping

[nikic]

Makes sense to me.

llvm/test/Bitcode/attributes.ll

514

Shouldn't this be @f83?

[frasercrmck]

• fix test and update for typed/opaque split

[frasercrmck]

llvm/test/Bitcode/attributes.ll

514

Yes it should, thanks. I also needed to update for CHECK-TYPED and CHECK-OPAQUE which I've now done.

llvm/docs/LangRef.rst

``elementtype(<ty>)``
     The attribute may only be applied to pointer typed arguments of intrinsic
     calls. It cannot be applied to non-intrinsic calls, and cannot be applied
     to parameters on function declarations. For non-opaque pointers, the type
     passed to ``elementtype`` must match the pointer element type.
 
 .. _attr_align:
 
 ``align <n>`` or ``align(<n>)``
-    This indicates that the pointer value has the specified alignment.
-    If the pointer value does not have the specified alignment,
-    :ref:`poison value <poisonvalues>` is returned or passed instead. The
-    ``align`` attribute should be combined with the ``noundef`` attribute to
-    ensure a pointer is aligned, or otherwise the behavior is undefined. Note
-    that ``align 1`` has no effect on non-byval, non-preallocated arguments.
+    This indicates that the pointer value or vector of pointers has the
+    specified alignment. If applied to a vector of pointers, *all* pointers
+    (elements) have the specified alignment. If the pointer value does not have
+    the specified alignment, :ref:`poison value <poisonvalues>` is returned or
+    passed instead.  The ``align`` attribute should be combined with the
+    ``noundef`` attribute to ensure a pointer is aligned, or otherwise the
+    behavior is undefined. Note that ``align 1`` has no effect on non-byval,
+    non-preallocated arguments.
 
     Note that this attribute has additional semantics when combined with the
     ``byval`` or ``preallocated`` attribute, which are documented there.
 
 .. _noalias:
 
 ``noalias``
     This indicates that memory locations accessed via pointer values

llvm/lib/IR/Attributes.cpp

 // AttributeFuncs Function Defintions
 //===----------------------------------------------------------------------===//
 
 /// Which attributes cannot be applied to a type.
 AttrBuilder AttributeFuncs::typeIncompatible(Type *Ty) {
   AttrBuilder Incompatible;
 
   if (!Ty->isIntegerTy())
-    // Attribute that only apply to integers.
+    // Attributes that only apply to integers.
     Incompatible.addAttribute(Attribute::SExt)
       .addAttribute(Attribute::ZExt);
 
   if (!Ty->isPointerTy())
-    // Attribute that only apply to pointers.
+    // Attributes that only apply to pointers.
     Incompatible.addAttribute(Attribute::Nest)
         .addAttribute(Attribute::NoAlias)
         .addAttribute(Attribute::NoCapture)
         .addAttribute(Attribute::NonNull)
         .addAttribute(Attribute::ReadNone)
         .addAttribute(Attribute::ReadOnly)
         .addAttribute(Attribute::SwiftError)
-        .addAlignmentAttr(1)             // the int here is ignored
         .addDereferenceableAttr(1)       // the int here is ignored
         .addDereferenceableOrNullAttr(1) // the int here is ignored
         .addPreallocatedAttr(Ty)
         .addInAllocaAttr(Ty)
         .addByValAttr(Ty)
         .addStructRetAttr(Ty)
         .addByRefAttr(Ty)
         .addTypeAttr(Attribute::ElementType, Ty);
 
+  if (!Ty->isPtrOrPtrVectorTy())
+    // Attributes that only apply to pointers or vectors of pointers.
+    Incompatible.addAlignmentAttr(1); // the int here is ignored
+
   // Some attributes can apply to all "values" but there are no `void` values.
   if (Ty->isVoidTy())
     Incompatible.addAttribute(Attribute::NoUndef);
 
   return Incompatible;
 }
 
 AttrBuilder AttributeFuncs::getUBImplyingAttributes() {

llvm/test/Bitcode/attributes.ll

 ; CHECK-OPAQUE: define void @f82(ptr %0)
 {
 ; CHECK-TYPED: call void @llvm.some.intrinsic(i32* sret(i32) %0)
 ; CHECK-OPAQUE: call void @llvm.some.intrinsic(ptr sret(i32) %0)
         call void @llvm.some.intrinsic(i32* sret(i32) %0)
         ret void;
 }
 
+; CHECK-TYPED: define void @f83(<4 x i8*> align 32 %0, <vscale x 1 x double*> align 64 %1)
+; CHECK-OPQUE: define void @f83(<4 x ptr> align 32 %0, <vscale x 1 x ptr> align 64 %1)
+define void @f83(<4 x i8*> align 32 %0, <vscale x 1 x double*> align 64 %1) {
+  ret void
+}
+
 ; 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 }