[Type] Extend VectorType to support scalable vectors. [IR support for SVE scalable vectors 1/4]

[paulwalker-arm]

Summary

VT::NumElements is replaced by VT::ElementCount with the later holding
the minimum #Elements along with a scalable flag.  This leads to three
scenarios:

1. The vector length is treated as opaque and thus calls to
getNumElements become getElementCount.
2. The vector length is being scaled (doubled/halved) in which case
calls to getNumElements become getElementCount and the arithmetic
remains the same.
3. The code does not support scalable vectors in which case it is
protected by !isScalable() and operates on getNumElements as it does
today.

This patch extends VectorType with an ElementCount based interface along
with IR parsing/writing and bitcode changes to support scalable vector
types.

[mkuper]

Hi Paul,

I think this is not the right set of reviewers for this part of the patch sequence.

I'll be happy to review vectorizer changes to support SVE, but for the initial sweeping IR level changes, you'll want more people with a high-level view - this doesn't only affect the vectorizer, this is something the entire midend has to deal with.

[rengolin]

Hi Paul,

I have a few inline comments, but there are two huge questions about this patch:

1. Is this the right move?

This will be answered by a more thorough review on all the possibilities, representations and future expansions of the IR. I haven't spotted any backwards incompatibility, but I could be wrong. There is the obvious forwards incompatibility, which is less serious but non-trivial.

I'll let people comment on that, but from my side, the new representation looks good for what's intended.

2. Can we do it now?

With the release 4.0 branching off any time in December, we may be asked to hold off big IR changes if they have any visible impact on everyone else's work. Your PackedEC representation is a big one, because it will produce large values for those IR readers that don't understand it (ie. all projects that follow releases or old trunk and have to interact with upstream IR).

I don't know off the top of my head which problems they are or who has them, so we'll have to wait for people to shed some light on that, here.

Finally, tests. I'm surprised if those two new lines are all we have on vector parsing, printing and validating. I don't really know where the tests are, but we probably have more than that. We'll need tests parsing different types of vectors, different types of failures (like <4 x n x i32>), etc. Also, make sure to include an example of scalable vectors on each new LangRef topic.

cheers,
--renato

docs/LangRef.rst

6722

For purely notational reasons, we may want to keep the "n" as the primary multiplier, since it's already widely commented and documented across the code and docs. Pick another unambiguous constant symbol, like "k", or even "m" (from "multiples" of vectors).

6806

I'm uncertain about this one. How will the masks look like?

Say, for instance, on a zip operation. On normal vectors, it's something like:

%tmp = shufflevector <4 x i32> %v1, <4 x i32> %v2,
                     <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
%newv1 = shufflevector <8 x i32> %tmp, <8 x i32> undef,
                       <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%newv2 = shufflevector <8 x i32> %tmp, <8 x i32> undef,
                       <4 x i32> <i32 4, i32 5, i32 6, i32 7>

and can only be represented in IR because the length is known at compile time. Anything based on "vscale" will be a really complicated pattern and won't work for all cases even if some of them are simple.

include/llvm/IR/DerivedTypes.h

368

Same here, keep the old notation to avoid mismatch with current comments.

372

You mention the "latter" but gives an example of each. I think you can stop at "discarded", then mention examples below.

419

I don't think ElementCount should be exposed to the user. The constructor below is essentially identical.

lib/IR/Type.cpp

641

unsigned int is not guaranteed to be 32-bits

[rengolin]

Hi Paul,

I want to restart the scalable vector discussion. My original inline comments are still valid and I have a few more.

I think the general idea is sound and in line with a generic "scalable" vector, as well as with how SVE vectors should be represented.

cheers,
--renato

lib/Bitcode/Reader/BitcodeReader.cpp

2125

I think this would be much clearer if you stick to 0, 1, 2 indexes rather than "Size - x". We guarantee (in the language) that size is either 2 or 3 or invalid.

2133

Why "Record[Size - 3]"? I'd say...

bool Scalable = Size > 2 ? true : false;

as guaranteed by the language reference (and your comment in DerivedTypes.h.

docs/LangRef.rst

 """""""""""
 
 :Overview:
 
 A vector type is a simple derived type that represents a vector of
 elements. Vector types are used when multiple primitive data are
 operated in parallel using a single instruction (SIMD). A vector type
 requires a size (number of elements) and an underlying primitive data
-type. Vector types are considered :ref:`first class <t_firstclass>`.
+type. A vector type has an optional scalable property to represent a
+vector of unknown length. Vector types are considered :ref:`first class <t_firstclass>`.
 
 :Syntax:
 
 ::
 
-      < <# elements> x <elementtype> >
+      < <# elements> x <elementtype> >     ; vector
+      < n x <# elements> x <elementtype> > ; scalable vector
 
 The number of elements is a constant integer value larger than 0;
 elementtype may be any integer, floating point or pointer type. Vectors
-of size zero are not allowed.
+of size zero are not allowed. For scalable vectors the real number of
+elements is an unknown integer multiple of #elements.
 
 :Examples:
 
-+-------------------+--------------------------------------------------+
-| ``<4 x i32>``     | Vector of 4 32-bit integer values.               |
-+-------------------+--------------------------------------------------+
-| ``<8 x float>``   | Vector of 8 32-bit floating-point values.        |
-+-------------------+--------------------------------------------------+
-| ``<2 x i64>``     | Vector of 2 64-bit integer values.               |
-+-------------------+--------------------------------------------------+
-| ``<4 x i64*>``    | Vector of 4 pointers to 64-bit integer values.   |
-+-------------------+--------------------------------------------------+
++-------------------+----------------------------------------------------+
+| ``<4 x i32>``     | Vector of 4 32-bit integer values.                 |
++-------------------+----------------------------------------------------+
+| ``<8 x float>``   | Vector of 8 32-bit floating-point values.          |
++-------------------+----------------------------------------------------+
+| ``<2 x i64>``     | Vector of 2 64-bit integer values.                 |
++-------------------+----------------------------------------------------+
+| ``<4 x i64*>``    | Vector of 4 pointers to 64-bit integer values.     |
++-------------------+----------------------------------------------------+
+| ``<n x 4 x i32>`` | Vector with a multiple of 4 32-bit integer values. |
++-------------------+----------------------------------------------------+
 
 .. _t_label:
 
 Label Type
 ^^^^^^^^^^
 
 :Overview:
 

 '``extractelement``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      <result> = extractelement <n x <ty>> <val>, <ty2> <idx>  ; yields <ty>
+      <result> = extractelement <M x <ty>> <val>, <ty2> <idx>      ; yields <ty>
+      <result> = extractelement <n x M x <ty>> <val>, <ty2> <idx>  ; yields <ty>
 
 Overview:
 """""""""
 
 The '``extractelement``' instruction extracts a single scalar element
 from a vector at a specified index.
 
 Arguments:

 '``insertelement``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      <result> = insertelement <n x <ty>> <val>, <ty> <elt>, <ty2> <idx>    ; yields <n x <ty>>
+      <result> = insertelement <M x <ty>> <val>, <ty> <elt>, <ty2> <idx>        ; yields <M x <ty>>
+      <result> = insertelement <n x M x <ty>> <val>, <ty> <elt>, <ty2> <idx>    ; yields <n x M x <ty>>
 
 Overview:
 """""""""
 
 The '``insertelement``' instruction inserts a scalar element into a
 vector at a specified index.
 
 Arguments:

 '``shufflevector``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      <result> = shufflevector <n x <ty>> <v1>, <n x <ty>> <v2>, <m x i32> <mask>    ; yields <m x <ty>>
+      <result> = shufflevector <M x <ty>> <v1>, <M x <ty>> <v2>, <M2 x i32> <mask>                ; yields <M2 x <ty>>
+      <result> = shufflevector <n x M x <ty>> <v1>, <n x M x <ty>> <v2>, <n x M2 x i32> <mask>    ; yields <n x M2 x <ty>>
 
 Overview:
 """""""""
 
 The '``shufflevector``' instruction constructs a permutation of elements
 from two input vectors, returning a vector with the same element type as
 the input and length that is the same as the shuffle mask.
 

include/llvm/IR/DerivedTypes.h

 };
 
 uint64_t Type::getArrayNumElements() const {
   return cast<ArrayType>(this)->getNumElements();
 }
 
 /// Class to represent vector types.
 class VectorType : public SequentialType {
-  unsigned NumElements;
+public:
+  /// A VectorType is of the form <N x M x Ty>.  M is the minimum number of
+  /// elements of type Ty contained within the vector, with the actual element
+  /// count being N * M. However, for all targets N is either statically unknown
+  /// or guaranteed to be one.  For the latter case the extra complication is
+  /// discarded leading to:
+  ///
+  /// <4 x i32>     - a vector of four i32s
+  /// <n x 4 x i32> - a vector with an unknown integer multiple of four i32s
+  class ElementCount {
+  private:
+    unsigned Min;  // Minimum number of vector elements.
+    bool Scalable; // NumElements != MinNumElements
+
+  public:
+    ElementCount(unsigned MinElts, bool IsScalable)
+      : Min(MinElts), Scalable(IsScalable) {}
+
+    ElementCount operator*(unsigned RHS) {
+      return { Min * RHS, Scalable };
+    }
+    ElementCount operator/(unsigned RHS) {
+      return { Min / RHS, Scalable };
+    }
+
+    bool operator==(const ElementCount& RHS) {
+      return Min == RHS.Min && Scalable == RHS.Scalable;
+    }
+
+    unsigned getMinNumElements() const {
+      return Min;
+    }
+
+    unsigned getNumElements() const {
+      assert(!Scalable && "NumElements is unknown for scalable vector!");
+      return Min;
+    }
+
+    bool isScalable() const {
+      return Scalable;
+    }
+  };
+
+private:
+  ElementCount EC;
 
   VectorType(const VectorType &) = delete;
   const VectorType &operator=(const VectorType &) = delete;
-  VectorType(Type *ElType, unsigned NumEl);
+  VectorType(Type *ElType, ElementCount EC);
 
 public:
   /// This static method is the primary way to construct an VectorType.
-  static VectorType *get(Type *ElementType, unsigned NumElements);
+  static VectorType *get(Type *ElType, ElementCount EC);
+  static VectorType *get(Type *ElType, unsigned NumEls, bool Scalable=false) {
+    return VectorType::get(ElType, { NumEls, Scalable });
+  }
 
   /// This static method gets a VectorType with the same number of elements as
   /// the input type, and the element type is an integer type of the same width
   /// as the input element type.
   static VectorType *getInteger(VectorType *VTy) {
     unsigned EltBits = VTy->getElementType()->getPrimitiveSizeInBits();
     assert(EltBits && "Element size must be of a non-zero size");
     Type *EltTy = IntegerType::get(VTy->getContext(), EltBits);
-    return VectorType::get(EltTy, VTy->getNumElements());
+    return VectorType::get(EltTy, VTy->getElementCount());
   }
 
   /// This static method is like getInteger except that the element types are
   /// twice as wide as the elements in the input type.
   static VectorType *getExtendedElementVectorType(VectorType *VTy) {
     unsigned EltBits = VTy->getElementType()->getPrimitiveSizeInBits();
     Type *EltTy = IntegerType::get(VTy->getContext(), EltBits * 2);
-    return VectorType::get(EltTy, VTy->getNumElements());
+    return VectorType::get(EltTy, VTy->getElementCount());
   }
 
   /// This static method is like getInteger except that the element types are
   /// half as wide as the elements in the input type.
   static VectorType *getTruncatedElementVectorType(VectorType *VTy) {
     unsigned EltBits = VTy->getElementType()->getPrimitiveSizeInBits();
     assert((EltBits & 1) == 0 &&
            "Cannot truncate vector element with odd bit-width");
     Type *EltTy = IntegerType::get(VTy->getContext(), EltBits / 2);
-    return VectorType::get(EltTy, VTy->getNumElements());
+    return VectorType::get(EltTy, VTy->getElementCount());
   }
 
   /// This static method returns a VectorType with half as many elements as the
   /// input type and the same element type.
   static VectorType *getHalfElementsVectorType(VectorType *VTy) {
-    unsigned NumElts = VTy->getNumElements();
-    assert ((NumElts & 1) == 0 &&
+    auto NumElts = VTy->getElementCount();
+    assert ((NumElts.getMinNumElements() & 1) == 0 &&
             "Cannot halve vector with odd number of elements.");
     return VectorType::get(VTy->getElementType(), NumElts/2);
   }
 
   /// This static method returns a VectorType with twice as many elements as the
   /// input type and the same element type.
   static VectorType *getDoubleElementsVectorType(VectorType *VTy) {
-    unsigned NumElts = VTy->getNumElements();
+    auto NumElts = VTy->getElementCount();
     return VectorType::get(VTy->getElementType(), NumElts*2);
   }
 
   /// Return true if the specified type is valid as a element type.
   static bool isValidElementType(Type *ElemTy);
 
   /// Return the number of elements in the Vector type.
-  unsigned getNumElements() const { return NumElements; }
+  ElementCount getElementCount() const { return EC; }
+
+  /// Return the minimum number of elements in the Vector type to maintain
+  /// compatibility with existing code during the transition to ElementCount.
+  unsigned getNumElements() const { return EC.getMinNumElements(); }
+
+  /// Return true when the number of elements is only known at runtime.
+  bool isScalable() const { return EC.isScalable(); }
 
-  /// Return the number of bits in the Vector type.
+  /// Return the minimum number of bits in the Vector type.
   /// Returns zero when the vector is a vector of pointers.
   unsigned getBitWidth() const {
-    return NumElements * getElementType()->getPrimitiveSizeInBits();
+    return EC.getMinNumElements() * getElementType()->getPrimitiveSizeInBits();
   }
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static inline bool classof(const Type *T) {
     return T->getTypeID() == VectorTyID;
   }
 };
 
 unsigned Type::getVectorNumElements() const {
   return cast<VectorType>(this)->getNumElements();
 }
 
+unsigned Type::getVectorIsScalable() const {
+  return cast<VectorType>(this)->isScalable();
+}
+
 /// Class to represent pointers.
 class PointerType : public SequentialType {
   PointerType(const PointerType &) = delete;
   const PointerType &operator=(const PointerType &) = delete;
   explicit PointerType(Type *ElType, unsigned AddrSpace);
 
 public:
   /// This constructs a pointer to an object of the specified type in a numbered

include/llvm/IR/Type.h

public:
   }
 
   inline uint64_t getArrayNumElements() const;
   Type *getArrayElementType() const {
     assert(getTypeID() == ArrayTyID);
     return ContainedTys[0];
   }
 
+  inline unsigned getVectorIsScalable() const;
   inline unsigned getVectorNumElements() const;
   Type *getVectorElementType() const {
     assert(getTypeID() == VectorTyID);
     return ContainedTys[0];
   }
 
   Type *getPointerElementType() const {
     assert(getTypeID() == PointerTyID);

lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(eq); KEYWORD(ne); KEYWORD(slt); KEYWORD(sgt); KEYWORD(sle);
   KEYWORD(sge); KEYWORD(ult); KEYWORD(ugt); KEYWORD(ule); KEYWORD(uge);
   KEYWORD(oeq); KEYWORD(one); KEYWORD(olt); KEYWORD(ogt); KEYWORD(ole);
   KEYWORD(oge); KEYWORD(ord); KEYWORD(uno); KEYWORD(ueq); KEYWORD(une);
 
   KEYWORD(xchg); KEYWORD(nand); KEYWORD(max); KEYWORD(min); KEYWORD(umax);
   KEYWORD(umin);
 
+  KEYWORD(n);
   KEYWORD(x);
   KEYWORD(blockaddress);
 
   // Metadata types.
   KEYWORD(distinct);
 
   // Use-list order directives.
   KEYWORD(uselistorder);

lib/AsmParser/LLParser.cpp

bool LLParser::ParseStructBody(SmallVectorImpl<Type*> &Body) {
   return ParseToken(lltok::rbrace, "expected '}' at end of struct");
 }
 
 /// ParseArrayVectorType - Parse an array or vector type, assuming the first
 /// token has already been consumed.
 ///   Type
 ///     ::= '[' APSINTVAL 'x' Types ']'
 ///     ::= '<' APSINTVAL 'x' Types '>'
+///     ::= '<' 'n' 'x' APSINTVAL 'x' Types '>'
 bool LLParser::ParseArrayVectorType(Type *&Result, bool isVector) {
+  bool Scalable = false; /* assume fixed length vectors */
+
+  if (isVector && Lex.getKind() == lltok::kw_n) {
+    Lex.Lex(); // consume the 'n'
+
+    if (ParseToken(lltok::kw_x, "expected 'x' after scalable vector specifier"))
+      return true;
+
+    Scalable = true; /* scalable vector */
+  }
+
   if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned() ||
       Lex.getAPSIntVal().getBitWidth() > 64)
     return TokError("expected number in address space");
 
   LocTy SizeLoc = Lex.getLoc();
   uint64_t Size = Lex.getAPSIntVal().getZExtValue();
   Lex.Lex();
 
   if (ParseToken(lltok::kw_x, "expected 'x' after element count"))
-      return true;
 
   LocTy TypeLoc = Lex.getLoc();
   Type *EltTy = nullptr;
   if (ParseType(EltTy)) return true;
 
   if (ParseToken(isVector ? lltok::greater : lltok::rsquare,
                  "expected end of sequential type"))
     return true;
 
   if (isVector) {
     if (Size == 0)
       return Error(SizeLoc, "zero element vector is illegal");
     if ((unsigned)Size != Size)
       return Error(SizeLoc, "size too large for vector");
     if (!VectorType::isValidElementType(EltTy))
       return Error(TypeLoc, "invalid vector element type");
-    Result = VectorType::get(EltTy, unsigned(Size));
+    Result = VectorType::get(EltTy, unsigned(Size), Scalable);
   } else {
     if (!ArrayType::isValidElementType(EltTy))
       return Error(TypeLoc, "invalid array element type");
     Result = ArrayType::get(EltTy, Size);
   }
   return false;
 }
 

lib/AsmParser/LLToken.h

enum Kind {
   rbrace, // {  }
   less,
   greater, // <  >
   lparen,
   rparen,  // (  )
   exclaim, // !
   bar,     // |
 
+  kw_n,
   kw_x,
   kw_true,
   kw_false,
   kw_declare,
   kw_define,
   kw_global,
   kw_constant,
 

lib/Bitcode/Reader/BitcodeReader.cpp

while (true) {
     case bitc::TYPE_CODE_ARRAY:     // ARRAY: [numelts, eltty]
       if (Record.size() < 2)
         return error("Invalid record");
       ResultTy = getTypeByID(Record[1]);
       if (!ResultTy || !ArrayType::isValidElementType(ResultTy))
         return error("Invalid type");
       ResultTy = ArrayType::get(ResultTy, Record[0]);
       break;
-    case bitc::TYPE_CODE_VECTOR:    // VECTOR: [numelts, eltty]
-      if (Record.size() < 2)
+    case bitc::TYPE_CODE_VECTOR: {  // VECTOR: [scalable, numelts, eltty]
+      unsigned Size = Record.size();
+      if (Size < 2)
         return error("Invalid record");
-      if (Record[0] == 0)
+      if (Record[Size - 2] == 0)
         return error("Invalid vector length");
-      ResultTy = getTypeByID(Record[1]);
+      ResultTy = getTypeByID(Record[Size - 1]);
       if (!ResultTy || !StructType::isValidElementType(ResultTy))
         return error("Invalid type");
-      ResultTy = VectorType::get(ResultTy, Record[0]);
+      bool Scalable = Size > 2 ? Record[Size - 3] : false;
+      ResultTy = VectorType::get(ResultTy, Record[Size - 2], Scalable);
       break;
     }
+    }
 
     if (NumRecords >= TypeList.size())
       return error("Invalid TYPE table");
     if (TypeList[NumRecords])
       return error(
           "Invalid TYPE table: Only named structs can be forward referenced");
     assert(ResultTy && "Didn't read a type?");
     TypeList[NumRecords++] = ResultTy;

lib/Bitcode/Writer/BitcodeWriter.cpp

case Type::ArrayTyID: {
       Code = bitc::TYPE_CODE_ARRAY;
       TypeVals.push_back(AT->getNumElements());
       TypeVals.push_back(VE.getTypeID(AT->getElementType()));
       AbbrevToUse = ArrayAbbrev;
       break;
     }
     case Type::VectorTyID: {
       VectorType *VT = cast<VectorType>(T);
-      // VECTOR [numelts, eltty]
+      // VECTOR [scalable, numelts, eltty]
       Code = bitc::TYPE_CODE_VECTOR;
+      TypeVals.push_back(VT->isScalable());
       TypeVals.push_back(VT->getNumElements());
       TypeVals.push_back(VE.getTypeID(VT->getElementType()));
       break;
     }
     }
 
     // Emit the finished record.
     Stream.EmitRecord(Code, TypeVals, AbbrevToUse);

lib/IR/AsmWriter.cpp

case Type::ArrayTyID: {
     ArrayType *ATy = cast<ArrayType>(Ty);
     OS << '[' << ATy->getNumElements() << " x ";
     print(ATy->getElementType(), OS);
     OS << ']';
     return;
   }
   case Type::VectorTyID: {
     VectorType *PTy = cast<VectorType>(Ty);
-    OS << "<" << PTy->getNumElements() << " x ";
+    OS << '<';
+    if (PTy->isScalable())
+      OS << "n x ";
+    OS << PTy->getNumElements() << " x ";
     print(PTy->getElementType(), OS);
     OS << '>';
     return;
   }
   }
   llvm_unreachable("Invalid TypeID");
 }
 

lib/IR/Type.cpp

return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
          !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() &&
          !ElemTy->isTokenTy();
 }
 
 //===----------------------------------------------------------------------===//
 //                          VectorType Implementation
 //===----------------------------------------------------------------------===//
 
-VectorType::VectorType(Type *ElType, unsigned NumEl)
-  : SequentialType(VectorTyID, ElType) {
-  NumElements = NumEl;
+VectorType::VectorType(Type *ElType, ElementCount ElCount)
+  : SequentialType(VectorTyID, ElType), EC(ElCount) {
 }
 
-VectorType *VectorType::get(Type *ElementType, unsigned NumElements) {
-  assert(NumElements > 0 && "#Elements of a VectorType must be greater than 0");
+VectorType *VectorType::get(Type *ElementType, ElementCount EC) {
+  assert(EC.getMinNumElements() > 0 &&
+         "Minimum #Elements of a VectorType must be greater than 0.");
   assert(isValidElementType(ElementType) && "Element type of a VectorType must "
                                             "be an integer, floating point, or "
                                             "pointer type.");
 
+  unsigned PackedEC = EC.getMinNumElements() | ((unsigned)EC.isScalable()<<31);
   LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
   VectorType *&Entry = ElementType->getContext().pImpl
-    ->VectorTypes[std::make_pair(ElementType, NumElements)];
+    ->VectorTypes[std::make_pair(ElementType, PackedEC)];
 
   if (!Entry)
-    Entry = new (pImpl->TypeAllocator) VectorType(ElementType, NumElements);
+    Entry = new (pImpl->TypeAllocator) VectorType(ElementType, EC);
   return Entry;
 }
 
 bool VectorType::isValidElementType(Type *ElemTy) {
   return ElemTy->isIntegerTy() || ElemTy->isFloatingPointTy() ||
     ElemTy->isPointerTy();
 }
 

test/Bitcode/compatibility.ll

define void @typesystem() {
   %t5 = alloca x86_fp80
   ; CHECK: %t5 = alloca x86_fp80
   %t6 = alloca ppc_fp128
   ; CHECK: %t6 = alloca ppc_fp128
   %t7 = alloca x86_mmx
   ; CHECK: %t7 = alloca x86_mmx
   %t8 = alloca %opaquety*
   ; CHECK: %t8 = alloca %opaquety*
+  %t9 = alloca <4 x i32>
+  ; CHECK: %t9 = alloca <4 x i32>
+  %t10 = alloca <n x 4 x i32>
+  ; CHECK: %t10 = alloca <n x 4 x i32>
 
   ret void
 }
 
 declare void @llvm.token(token)
 ; CHECK: declare void @llvm.token(token)
 
 ;; Inline Assembler Expressions