Make intrinsic signature iAny work with arrays

[artagnon]

Summary

iAny current works for integers and integer vectors, but not for integer
arrays. Fix this assymmetry.

While at it, open the door for a possible aAny corresponding to vAny.

[artagnon]

Rebase to include statepoint-example gc.

[artagnon]

Abandoning: it's not important enough; I have no dependent changes.

include/llvm/IR/Intrinsics.h

#undef GET_INTRINSIC_ENUM_VALUES
   /// Map a MS builtin name to an intrinsic ID.
   ID getIntrinsicForMSBuiltin(const char *Prefix, const char *BuiltinName);
   
   /// This is a type descriptor which explains the type requirements of an
   /// intrinsic. This is returned by getIntrinsicInfoTableEntries.
   struct IITDescriptor {
     enum IITDescriptorKind {
       Void, VarArg, MMX, Metadata, Half, Float, Double,
-      Integer, Vector, Pointer, Struct,
+      Integer, Array, Vector, Pointer, Struct,
       Argument, ExtendArgument, TruncArgument, HalfVecArgument,
       SameVecWidthArgument, PtrToArgument
     } Kind;
     
     union {
       unsigned Integer_Width;
       unsigned Float_Width;
+      unsigned Array_Width;
       unsigned Vector_Width;
       unsigned Pointer_AddressSpace;
       unsigned Struct_NumElements;
       unsigned Argument_Info;
     };
     
     enum ArgKind {
       AK_AnyInteger,

include/llvm/IR/Type.h

public:
 
   /// isIntegerTy - Return true if this is an IntegerType of the given width.
   bool isIntegerTy(unsigned Bitwidth) const;
 
   /// isIntOrIntVectorTy - Return true if this is an integer type or a vector of
   /// integer types.
   ///
   bool isIntOrIntVectorTy() const { return getScalarType()->isIntegerTy(); }
-  
+  /// isIntOrIntVectorOrArVecTy - Return true if this is an integer type or a
+  /// vector of integer types, or n array of integer types.
+  ///
+  bool isIntOrIntArVecTy() const { return getArVecElementType()->isIntegerTy(); }
+
   /// isFunctionTy - True if this is an instance of FunctionType.
   ///
   bool isFunctionTy() const { return getTypeID() == FunctionTyID; }
 
   /// isStructTy - True if this is an instance of StructType.
   ///
   bool isStructTy() const { return getTypeID() == StructTyID; }
 
public:
   /// have a stable mantissa (e.g. ppc long double), this method returns -1.
   int getFPMantissaWidth() const;
 
   /// getScalarType - If this is a vector type, return the element type,
   /// otherwise return 'this'.
   const Type *getScalarType() const LLVM_READONLY;
   Type *getScalarType() LLVM_READONLY;
 
+  /// getScalarType - If this is a vector or array type, return the element
+  /// type, otherwise return 'this'.
+  const Type *getArVecElementType() const LLVM_READONLY;
+  Type *getArVecElementType() LLVM_READONLY;
+
   //===--------------------------------------------------------------------===//
   // Type Iteration support.
   //
   typedef Type * const *subtype_iterator;
   subtype_iterator subtype_begin() const { return ContainedTys; }
   subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];}
   ArrayRef<Type*> subtypes() const {
     return makeArrayRef(subtype_begin(), subtype_end());

lib/IR/Function.cpp

enum IIT_Info {
   IIT_STRUCT5 = 23,
   IIT_EXTEND_ARG = 24,
   IIT_TRUNC_ARG = 25,
   IIT_ANYPTR = 26,
   IIT_V1   = 27,
   IIT_VARARG = 28,
   IIT_HALF_VEC_ARG = 29,
   IIT_SAME_VEC_WIDTH_ARG = 30,
-  IIT_PTR_TO_ARG = 31
+  IIT_PTR_TO_ARG = 31,
+  IIT_A1 = 32,
+  IIT_A2 = 33,
+  IIT_A4 = 34,
+  IIT_A8 = 35,
+  IIT_A16 = 36,
+  IIT_A32 = 37,
+  IIT_A64 = 38
 };
 
 
 static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos,
                       SmallVectorImpl<Intrinsic::IITDescriptor> &OutputTable) {
   IIT_Info Info = IIT_Info(Infos[NextElt++]);
   unsigned StructElts = 2;
   using namespace Intrinsic;
case IIT_I16:
     OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer,16));
     return;
   case IIT_I32:
     OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32));
     return;
   case IIT_I64:
     OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64));
     return;
+  case IIT_A1:
+    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Array, 1));
+    DecodeIITType(NextElt, Infos, OutputTable);
+    return;
+  case IIT_A2:
+    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Array, 2));
+    DecodeIITType(NextElt, Infos, OutputTable);
+    return;
+  case IIT_A4:
+    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Array, 4));
+    DecodeIITType(NextElt, Infos, OutputTable);
+    return;
+  case IIT_A8:
+    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Array, 8));
+    DecodeIITType(NextElt, Infos, OutputTable);
+    return;
+  case IIT_A16:
+    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Array, 16));
+    DecodeIITType(NextElt, Infos, OutputTable);
+    return;
+  case IIT_A32:
+    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Array, 32));
+    DecodeIITType(NextElt, Infos, OutputTable);
+    return;
+  case IIT_A64:
+    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Array, 64));
+    DecodeIITType(NextElt, Infos, OutputTable);
+    return;
   case IIT_V1:
     OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1));
     DecodeIITType(NextElt, Infos, OutputTable);
     return;
   case IIT_V2:
     OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 2));
     DecodeIITType(NextElt, Infos, OutputTable);
     return;
static Type *DecodeFixedType(ArrayRef<Intrinsic::IITDescriptor> &Infos,
   case IITDescriptor::MMX: return Type::getX86_MMXTy(Context);
   case IITDescriptor::Metadata: return Type::getMetadataTy(Context);
   case IITDescriptor::Half: return Type::getHalfTy(Context);
   case IITDescriptor::Float: return Type::getFloatTy(Context);
   case IITDescriptor::Double: return Type::getDoubleTy(Context);
 
   case IITDescriptor::Integer:
     return IntegerType::get(Context, D.Integer_Width);
+  case IITDescriptor::Array:
+    return ArrayType::get(DecodeFixedType(Infos, Tys, Context), D.Array_Width);
   case IITDescriptor::Vector:
     return VectorType::get(DecodeFixedType(Infos, Tys, Context),D.Vector_Width);
   case IITDescriptor::Pointer:
     return PointerType::get(DecodeFixedType(Infos, Tys, Context),
                             D.Pointer_AddressSpace);
   case IITDescriptor::Struct: {
     Type *Elts[5];
     assert(D.Struct_NumElements <= 5 && "Can't handle this yet");

lib/IR/Type.cpp

 }
 
 const Type *Type::getScalarType() const {
   if (const VectorType *VTy = dyn_cast<VectorType>(this))
     return VTy->getElementType();
   return this;
 }
 
+/// getScalarType - If this is a vector or array type, return the element type,
+/// otherwise return this.
+Type *Type::getArVecElementType() {
+  if (VectorType *VTy = dyn_cast<VectorType>(this))
+    return VTy->getElementType();
+  if (ArrayType *ATy = dyn_cast<ArrayType>(this))
+    return ATy->getElementType();
+  return this;
+}
+
+const Type *Type::getArVecElementType() const {
+  if (const VectorType *VTy = dyn_cast<VectorType>(this))
+    return VTy->getElementType();
+  if (const ArrayType *ATy = dyn_cast<ArrayType>(this))
+    return ATy->getElementType();
+  return this;
+}
+
 /// isIntegerTy - Return true if this is an IntegerType of the specified width.
 bool Type::isIntegerTy(unsigned Bitwidth) const {
   return isIntegerTy() && cast<IntegerType>(this)->getBitWidth() == Bitwidth;
 }
 
 // canLosslesslyBitCastTo - Return true if this type can be converted to
 // 'Ty' without any reinterpretation of bits.  For example, i8* to i32*.
 //

lib/IR/Verifier.cpp

bool Verifier::VerifyIntrinsicType(Type *Ty,
   case IITDescriptor::Void: return !Ty->isVoidTy();
   case IITDescriptor::VarArg: return true;
   case IITDescriptor::MMX:  return !Ty->isX86_MMXTy();
   case IITDescriptor::Metadata: return !Ty->isMetadataTy();
   case IITDescriptor::Half: return !Ty->isHalfTy();
   case IITDescriptor::Float: return !Ty->isFloatTy();
   case IITDescriptor::Double: return !Ty->isDoubleTy();
   case IITDescriptor::Integer: return !Ty->isIntegerTy(D.Integer_Width);
+  case IITDescriptor::Array: {
+    ArrayType *AT = dyn_cast<ArrayType>(Ty);
+    return !AT || AT->getNumElements() != D.Array_Width ||
+           VerifyIntrinsicType(AT->getElementType(), Infos, ArgTys);
+  }
   case IITDescriptor::Vector: {
     VectorType *VT = dyn_cast<VectorType>(Ty);
     return !VT || VT->getNumElements() != D.Vector_Width ||
            VerifyIntrinsicType(VT->getElementType(), Infos, ArgTys);
   }
   case IITDescriptor::Pointer: {
     PointerType *PT = dyn_cast<PointerType>(Ty);
     return !PT || PT->getAddressSpace() != D.Pointer_AddressSpace ||
if (D.getArgumentNumber() < ArgTys.size())
       return Ty != ArgTys[D.getArgumentNumber()];
 
     // Otherwise, if this is the first instance of an argument, record it and
     // verify the "Any" kind.
     assert(D.getArgumentNumber() == ArgTys.size() && "Table consistency error");
     ArgTys.push_back(Ty);
 
     switch (D.getArgumentKind()) {
-    case IITDescriptor::AK_AnyInteger: return !Ty->isIntOrIntVectorTy();
+    case IITDescriptor::AK_AnyInteger: return !Ty->isIntOrIntArVecTy();
     case IITDescriptor::AK_AnyFloat:   return !Ty->isFPOrFPVectorTy();
     case IITDescriptor::AK_AnyVector:  return !isa<VectorType>(Ty);
     case IITDescriptor::AK_AnyPointer: return !isa<PointerType>(Ty);
     }
     llvm_unreachable("all argument kinds not covered");
 
   case IITDescriptor::ExtendArgument: {
     // This may only be used when referring to a previous vector argument.

test/CodeGen/X86/statepoint-call-lowering.ll

 ; RUN: llc < %s | FileCheck %s
 ; This file contains a collection of basic tests to ensure we didn't
 ; screw up normal call lowering when there are no deopt or gc arguments.
 
 target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-linux-gnu"
 
 declare zeroext i1 @return_i1()
 declare zeroext i32 @return_i32()
+declare [2 x i32] @return_i32ar()
 declare i32* @return_i32ptr()
 declare float @return_float()
 
 define i1 @test_i1_return() gc "statepoint-example" {
 ; CHECK-LABEL: test_i1_return
 ; This is just checking that a i1 gets lowered normally when there's no extra
 ; state arguments to the statepoint
 ; CHECK: pushq %rax

 ; CHECK: popq %rdx
 ; CHECK: retq
 entry:
   %safepoint_token = tail call i32 (i32 ()*, i32, i32, ...)* @llvm.experimental.gc.statepoint.p0f_i32f(i32 ()* @return_i32, i32 0, i32 0, i32 0)
   %call1 = call zeroext i32 @llvm.experimental.gc.result.int.i32(i32 %safepoint_token)
   ret i32 %call1
 }
 
+define [2 x i32] @test_i32ar_return() gc "statepoint-example" {
+; CHECK-LABEL: test_i32ar_return
+; CHECK: pushq %rax
+; CHECK: callq return_i32ar
+; CHECK: popq %rcx
+; CHECK: retq
+entry:
+  %safepoint_token = tail call i32 ([2 x i32] ()*, i32, i32, ...)* @llvm.experimental.gc.statepoint.p0f_a2i32f([2 x i32] ()* @return_i32ar, i32 0, i32 0, i32 0)
+  %call1 = call [2 x i32] @llvm.experimental.gc.result.int.a2i32(i32 %safepoint_token)
+  ret [2 x i32] %call1
+}
+
 define i32* @test_i32ptr_return() gc "statepoint-example" {
 ; CHECK-LABEL: test_i32ptr_return
 ; CHECK: pushq %rax
 ; CHECK: callq return_i32ptr
 ; CHECK: popq %rdx
 ; CHECK: retq
 entry:
   %safepoint_token = tail call i32 (i32* ()*, i32, i32, ...)* @llvm.experimental.gc.statepoint.p0f_p0i32f(i32* ()* @return_i32ptr, i32 0, i32 0, i32 0)
   %call1 = call i32* @llvm.experimental.gc.result.ptr.p0i32(i32 %safepoint_token)
   ret i32* %call1
 }
 
 define float @test_float_return() gc "statepoint-example" {
 ; CHECK-LABEL: test_float_return
 ; CHECK: pushq %rax
 ; CHECK: callq return_float
 ; CHECK: popq %rax
 ; CHECK: retq
 entry:
   %safepoint_token = tail call i32 (float ()*, i32, i32, ...)* @llvm.experimental.gc.statepoint.p0f_f32f(float ()* @return_float, i32 0, i32 0, i32 0)
   %call1 = call float @llvm.experimental.gc.result.float.f32(i32 %safepoint_token)
   ret float %call1
 }
 
-define i1 @test_relocate(i32 addrspace(1)* %a) gc "statepoint-example" {
+define i1 @test_relocate_noop(i32 addrspace(1)* %a) gc "statepoint-example" {
 ; CHECK-LABEL: test_relocate
 ; Check that an ununsed relocate has no code-generation impact
 ; CHECK: pushq %rax
 ; CHECK: callq return_i1
-; CHECK-NEXT: .Ltmp13:
+; CHECK-NEXT: .Ltmp16:
 ; CHECK-NEXT: popq %rdx
 ; CHECK-NEXT: retq
 entry:
   %safepoint_token = tail call i32 (i1 ()*, i32, i32, ...)* @llvm.experimental.gc.statepoint.p0f_i1f(i1 ()* @return_i1, i32 0, i32 0, i32 0, i32 addrspace(1)* %a)
   %call1 = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 4, i32 4)
   %call2 = call zeroext i1 @llvm.experimental.gc.result.int.i1(i32 %safepoint_token)
   ret i1 %call2
 }
 
 declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i1 ()*, i32, i32, ...)
 declare i1 @llvm.experimental.gc.result.int.i1(i32)
 
 declare i32 @llvm.experimental.gc.statepoint.p0f_i32f(i32 ()*, i32, i32, ...)
 declare i32 @llvm.experimental.gc.result.int.i32(i32)
 
+declare i32 @llvm.experimental.gc.statepoint.p0f_a2i32f([2 x i32] ()*, i32, i32, ...)
+declare [2 x i32] @llvm.experimental.gc.result.int.a2i32(i32)
+
 declare i32 @llvm.experimental.gc.statepoint.p0f_p0i32f(i32* ()*, i32, i32, ...)
 declare i32* @llvm.experimental.gc.result.ptr.p0i32(i32)
 
 declare i32 @llvm.experimental.gc.statepoint.p0f_f32f(float ()*, i32, i32, ...)
 declare float @llvm.experimental.gc.result.float.f32(i32)
 
 declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32)

utils/TableGen/IntrinsicEmitter.cpp

enum IIT_Info {
   IIT_STRUCT5 = 23,
   IIT_EXTEND_ARG = 24,
   IIT_TRUNC_ARG = 25,
   IIT_ANYPTR = 26,
   IIT_V1   = 27,
   IIT_VARARG = 28,
   IIT_HALF_VEC_ARG = 29,
   IIT_SAME_VEC_WIDTH_ARG = 30,
-  IIT_PTR_TO_ARG = 31
+  IIT_PTR_TO_ARG = 31,
+  IIT_A1 = 32,
+  IIT_A2 = 33,
+  IIT_A4 = 34,
+  IIT_A8 = 35,
+  IIT_A16 = 36,
+  IIT_A32 = 37,
+  IIT_A64 = 38
 };
 
 
 static void EncodeFixedValueType(MVT::SimpleValueType VT,
                                  std::vector<unsigned char> &Sig) {
   if (MVT(VT).isInteger()) {
     unsigned BitWidth = MVT(VT).getSizeInBits();
     switch (BitWidth) {