Add support for vector types and vector constants.

src/llvm2ice.cpp

 //===- subzero/src/llvm2ice.cpp - Driver for testing ----------------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a driver that uses LLVM capabilities to parse a
@@ skipping 101 matching lines @@
     } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(Const)) {
       Ice::Type Type = convertType(CFP->getType());
       if (Type == Ice::IceType_f32)
         return Ctx->getConstantFloat(CFP->getValueAPF().convertToFloat());
       else if (Type == Ice::IceType_f64)
         return Ctx->getConstantDouble(CFP->getValueAPF().convertToDouble());
       llvm_unreachable("Unexpected floating point type");
       return NULL;
     } else if (const UndefValue *CU = dyn_cast<UndefValue>(Const)) {
       return Ctx->getConstantUndef(convertType(CU->getType()));
+    } else if (const ConstantDataVector *CDV =
+                   dyn_cast<ConstantDataVector>(Const)) {
+      // This case will never be encountered when processing valid PNaCl
+      // IR.  Constants of vector type (except for undef) do not appear
+      // in PNaCl IR.

[JF, 2014/06/30 17:48:50]

Why handle these if they never occur, instead of asserting?

[wala, 2014/06/30 22:13:24]

This was useful to me to test parts of my implementation, but it isn't necessary
for PNaCl support. I can remove it.

+      llvm::StringRef Data = CDV->getRawDataValues();
+      assert(Data.size() == Ice::VECT128_BYTES);
+      Ice::Vect128 Value(Ice::VECT128_BYTES);
+      std::memcpy(Value.data(), Data.data(), Ice::VECT128_BYTES);
+      return Ctx->getConstantVector(convertType(CDV->getType()), Value);
+    } else if (const ConstantVector *CV = dyn_cast<ConstantVector>(Const)) {
+      // This case will never be encountered when processing valid PNaCl
+      // IR (see comment above in ConstantDataVector).
+      Ice::Type Type = convertType(CV->getType());
+      // Only i1 vectors should be represented as ConstantVectors.
+      assert(Type == Ice::IceType_v4i1 || Type == Ice::IceType_v8i1 ||
+             Type == Ice::IceType_v16i1);
+      unsigned NumElements = typeNumElements(Type);
+      Ice::BitVect Value(NumElements);
+      for (unsigned Elt = 0; Elt != NumElements; ++Elt) {
+        Value[Elt] =
+            cast<ConstantInt>(CV->getAggregateElement(Elt))->getZExtValue();
+      }
+      return Ctx->getConstantBitVector(Type, Value);
+    } else if (const ConstantAggregateZero *CZ =
+                   dyn_cast<ConstantAggregateZero>(Const)) {
+      // This case will never be encountered when processing valid PNaCl
+      // IR (see comment above in ConstantDataVector).
+      return Ctx->getConstantZero(convertType(CZ->getType()));
     } else {
       llvm_unreachable("Unhandled constant type");
       return NULL;
     }
   }
 
 private:
   // LLVM values (instructions, etc.) are mapped directly to ICE variables.
   // mapValueToIceVar has a version that forces an ICE type on the variable,
   // and a version that just uses convertType on V.
@@ skipping 30 matching lines @@
       return Ice::IceType_i32;
     case 64:
       return Ice::IceType_i64;
     default:
       report_fatal_error(std::string("Invalid PNaCl int type: ") +
                          LLVMObjectAsString(IntTy));
       return Ice::IceType_void;
     }
   }
 
+  Ice::Type convertVectorType(const VectorType *VecTy) const {
+    unsigned NumElements = VecTy->getNumElements();
+    const Type *ElementType = VecTy->getElementType();
+
+    if (ElementType->isFloatTy()) {
+      if (NumElements == 4)
+        return Ice::IceType_v4f32;
+    } else if (ElementType->isIntegerTy()) {
+      switch (cast<IntegerType>(ElementType)->getBitWidth()) {
+      case 1:
+        if (NumElements == 4)
+          return Ice::IceType_v4i1;
+        if (NumElements == 8)
+          return Ice::IceType_v8i1;
+        if (NumElements == 16)
+          return Ice::IceType_v16i1;
+        break;
+      case 8:
+        if (NumElements == 16)
+          return Ice::IceType_v16i8;
+        break;
+      case 16:
+        if (NumElements == 8)
+          return Ice::IceType_v8i16;
+        break;
+      case 32:
+        if (NumElements == 4)
+          return Ice::IceType_v4i32;
+        break;
+      }
+    }
+
+    report_fatal_error(std::string("Unhandled vector type: ") +
+                       LLVMObjectAsString(VecTy));
+    return Ice::IceType_void;
+  }
+
   Ice::Type convertType(const Type *Ty) const {
     switch (Ty->getTypeID()) {
     case Type::VoidTyID:
       return Ice::IceType_void;
     case Type::IntegerTyID:
       return convertIntegerType(cast<IntegerType>(Ty));
     case Type::FloatTyID:
       return Ice::IceType_f32;
     case Type::DoubleTyID:
       return Ice::IceType_f64;
     case Type::PointerTyID:
       return SubzeroPointerType;
     case Type::FunctionTyID:
       return SubzeroPointerType;
+    case Type::VectorTyID:
+      return convertVectorType(cast<VectorType>(Ty));
     default:
       report_fatal_error(std::string("Invalid PNaCl type: ") +
                          LLVMObjectAsString(Ty));
     }
 
     llvm_unreachable("convertType");
     return Ice::IceType_void;
   }
 
   // Given an LLVM instruction and an operand number, produce the
@@ skipping 580 matching lines @@
                   << " sec\n";
       }
     }
   }
 
   if (!DisableTranslation && Func)
     Func->getTarget()->emitConstants();
 
   return ExitStatus;
 }