Make ConstantDataArray::get constructor templated. Will support signed integers.

[asbirlea]

Summary

Make ConstantDataArray::get() constructors a single templated one.

[timshen]

include/llvm/IR/Constants.h

706

Would it be good to create Type::getTyByScalar:

class Type {
  template <typename ScalarType>
  Type* getTyByScalar(LLVMContext*) {
    switch (sizeof(ScalarType)) { ... }
  }

Also, it'd be better to expand getTyByScalar to pointer and all sorts of other crazy types, but Scalar would be a good start.

Then ConstantDataArray::get will be like

return ArrayType::get(Type::getTyByScalar<ElementTy>(Context), Elts.size());

[sanjoy]

Minor drive by comments.

include/llvm/IR/Constants.h

701

I'm not sure of the rules here, but perhaps this needs to be sizeof(ElementTy) * CHAR_BIT / 8 to be technically correct?

708

There is a Type::getIntNTy that you can use here.

732

Use llvm_unreachable.

[asbirlea]

Address comments.

include/llvm/IR/Constants.h

701

It made sense to add * CHAR_BIT when passing no of bits to getIntNTy.
But having no_bytes = sizeof * CHAR_BIT / 8, and no bits = no_bytes *CHAR_BIT together doesn't make sense. I dropped the first, but I'm not clear if that's correct.

[asbirlea]

Switch to noOfBits in Type.h.

[timshen]

LGTM with some nits.

include/llvm/IR/Constants.h

704

Maybe just Elts.size() * sizeof(ElementTy)?

include/llvm/IR/Type.h

410

getScalarTy seems a more consistent name.

[asbirlea]

Address comments.
Thank you for the review!

include/llvm/IR/Constants.h

class ConstantDataArray final : public ConstantDataSequential {
   friend class ConstantDataSequential;
 
   explicit ConstantDataArray(Type *ty, const char *Data)
       : ConstantDataSequential(ty, ConstantDataArrayVal, Data) {}
 
 public:
   ConstantDataArray(const ConstantDataArray &) = delete;
 
-  /// get() constructors - Return a constant with array type with an element
+  /// get() constructor - Return a constant with array type with an element
   /// count and element type matching the ArrayRef passed in.  Note that this
   /// can return a ConstantAggregateZero object.
-  static Constant *get(LLVMContext &Context, ArrayRef<uint8_t> Elts);
-  static Constant *get(LLVMContext &Context, ArrayRef<uint16_t> Elts);
-  static Constant *get(LLVMContext &Context, ArrayRef<uint32_t> Elts);
-  static Constant *get(LLVMContext &Context, ArrayRef<uint64_t> Elts);
-  static Constant *get(LLVMContext &Context, ArrayRef<float> Elts);
-  static Constant *get(LLVMContext &Context, ArrayRef<double> Elts);
+  template <typename ElementTy>
+  static Constant *get(LLVMContext &Context, ArrayRef<ElementTy> Elts) {
+    const char *Data = reinterpret_cast<const char *>(Elts.data());
+    int noOfBytes = sizeof(ElementTy);
+    Type *Ty =
+        ArrayType::get(Type::getTyByScalar<ElementTy>(Context), Elts.size());
+    return getImpl(StringRef(Data, Elts.size() * noOfBytes), Ty);
+  }
+
+  /// get() constructor - ArrayTy needs to be compatible with
+  /// ArrayRef<ElementTy>. Calls get(LLVMContext, ArrayRef<ElementTy>).
+  template <typename ArrayTy>
+  static Constant *get(LLVMContext &Context, ArrayTy &Elts) {
+    return ConstantDataArray::get(Context, makeArrayRef(Elts));
+  }
 
   /// getFP() constructors - Return a constant with array type with an element
   /// count and element type of float with precision matching the number of
   /// bits in the ArrayRef passed in. (i.e. half for 16bits, float for 32bits,
   /// double for 64bits) Note that this can return a ConstantAggregateZero
   /// object.
   static Constant *getFP(LLVMContext &Context, ArrayRef<uint16_t> Elts);
   static Constant *getFP(LLVMContext &Context, ArrayRef<uint32_t> Elts);
   static Constant *getFP(LLVMContext &Context, ArrayRef<uint64_t> Elts);
 
   /// This method constructs a CDS and initializes it with a text string.
   /// The default behavior (AddNull==true) causes a null terminator to
   /// be placed at the end of the array (increasing the length of the string by
   /// one more than the StringRef would normally indicate.  Pass AddNull=false
   /// to disable this behavior.
   static Constant *getString(LLVMContext &Context, StringRef Initializer,
                              bool AddNull = true);
 
   /// Specialize the getType() method to always return an ArrayType,
   /// which reduces the amount of casting needed in parts of the compiler.
   inline ArrayType *getType() const {
     return cast<ArrayType>(Value::getType());
   }
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Value *V) {
     return V->getValueID() == ConstantDataArrayVal;
   }

include/llvm/IR/Type.h

public:
   static Type *getTokenTy(LLVMContext &C);
   static IntegerType *getIntNTy(LLVMContext &C, unsigned N);
   static IntegerType *getInt1Ty(LLVMContext &C);
   static IntegerType *getInt8Ty(LLVMContext &C);
   static IntegerType *getInt16Ty(LLVMContext &C);
   static IntegerType *getInt32Ty(LLVMContext &C);
   static IntegerType *getInt64Ty(LLVMContext &C);
   static IntegerType *getInt128Ty(LLVMContext &C);
+  template <typename ScalarTy> static Type *getTyByScalar(LLVMContext &C) {
+    int noOfBytes = sizeof(ScalarTy);
+    if (std::is_integral<ScalarTy>::value) {
+      return Type::getIntNTy(C, noOfBytes * CHAR_BIT);
+    } else if (std::is_floating_point<ScalarTy>::value) {
+      switch (noOfBytes) {
+      case 4:
+        return Type::getFloatTy(C);
+      case 8:
+        return Type::getDoubleTy(C);
+      }
+    }
+    llvm_unreachable("Unsupported type in Type::getTyByScalar");
+  }
 
   //===--------------------------------------------------------------------===//
   // Convenience methods for getting pointer types with one of the above builtin
   // types as pointee.
   //
   static PointerType *getHalfPtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getFloatPtrTy(LLVMContext &C, unsigned AS = 0);
   static PointerType *getDoublePtrTy(LLVMContext &C, unsigned AS = 0);

lib/IR/Constants.cpp

if (!(*Entry)->Next) {
     }
   }
 
   // If we were part of a list, make sure that we don't delete the list that is
   // still owned by the uniquing map.
   Next = nullptr;
 }
 
-/// get() constructors - Return a constant with array type with an element
-/// count and element type matching the ArrayRef passed in.  Note that this
-/// can return a ConstantAggregateZero object.
-Constant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<uint8_t> Elts) {
-  Type *Ty = ArrayType::get(Type::getInt8Ty(Context), Elts.size());
-  const char *Data = reinterpret_cast<const char *>(Elts.data());
-  return getImpl(StringRef(Data, Elts.size() * 1), Ty);
-}
-Constant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<uint16_t> Elts){
-  Type *Ty = ArrayType::get(Type::getInt16Ty(Context), Elts.size());
-  const char *Data = reinterpret_cast<const char *>(Elts.data());
-  return getImpl(StringRef(Data, Elts.size() * 2), Ty);
-}
-Constant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<uint32_t> Elts){
-  Type *Ty = ArrayType::get(Type::getInt32Ty(Context), Elts.size());
-  const char *Data = reinterpret_cast<const char *>(Elts.data());
-  return getImpl(StringRef(Data, Elts.size() * 4), Ty);
-}
-Constant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<uint64_t> Elts){
-  Type *Ty = ArrayType::get(Type::getInt64Ty(Context), Elts.size());
-  const char *Data = reinterpret_cast<const char *>(Elts.data());
-  return getImpl(StringRef(Data, Elts.size() * 8), Ty);
-}
-Constant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<float> Elts) {
-  Type *Ty = ArrayType::get(Type::getFloatTy(Context), Elts.size());
-  const char *Data = reinterpret_cast<const char *>(Elts.data());
-  return getImpl(StringRef(Data, Elts.size() * 4), Ty);
-}
-Constant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<double> Elts) {
-  Type *Ty = ArrayType::get(Type::getDoubleTy(Context), Elts.size());
-  const char *Data = reinterpret_cast<const char *>(Elts.data());
-  return getImpl(StringRef(Data, Elts.size() * 8), Ty);
-}
-
 /// getFP() constructors - Return a constant with array type with an element
 /// count and element type of float with precision matching the number of
 /// bits in the ArrayRef passed in. (i.e. half for 16bits, float for 32bits,
 /// double for 64bits) Note that this can return a ConstantAggregateZero
 /// object.
 Constant *ConstantDataArray::getFP(LLVMContext &Context,
                                    ArrayRef<uint16_t> Elts) {
   Type *Ty = ArrayType::get(Type::getHalfTy(Context), Elts.size());