Add a factory method to ConstantDataArray that allows to pass in the data as StringRef

[akuegel]

Summary

This simplifies the case if we already have access to the raw data that we need to store in a ConstantDataArray.
The new factor method can also be reused for implementing the factory method that gets the data as ArrayRef.

[efriedma]

getImpl is private because it's a confusing API; it's very easy to mess up endianness, and ConstantDataArray doesn't work with arbitrary LLVM types (only i8/i16/i32/i64/float/double). This wrapper isn't really much better.

What use case isn't covered by the existing get() APIs?

[akuegel]

We want to use it for XLA, simplifying the ConvertLiteralToIrConstant method:
https://github.com/tensorflow/tensorflow/blob/master/tensorflow/compiler/xla/service/llvm_ir/llvm_util.cc#L374
Essentially we already have a buffer that we want to store as-is, and we can compute the type we want to store based on the XLA PrimitiveType. Then we could get rid of the switch, and it would make our code easier.

[efriedma]

Oh, you're translating from your Constant abstraction to LLVM's Constant abstraction. Makes sense.

Please rename this to getRaw or something, so it's clear it's not type-safe. And please fix the doc comment to specify what element types are allowed, and note how it deals with endianness.

[akuegel]

Addressed review comments:

• renamed method to getRaw
• added more comments regarding supported types and endianness

[akuegel]

Friendly ping?

[bkramer]

I think this is fine to go in. It's not the most pretty API, but not really more unsafe than what's already there.

llvm/trunk/include/llvm/IR/Constants.h

public:
   ConstantDataArray(const ConstantDataArray &) = delete;
 
   /// 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.
   template <typename ElementTy>
   static Constant *get(LLVMContext &Context, ArrayRef<ElementTy> Elts) {
     const char *Data = reinterpret_cast<const char *>(Elts.data());
-    Type *Ty =
-        ArrayType::get(Type::getScalarTy<ElementTy>(Context), Elts.size());
-    return getImpl(StringRef(Data, Elts.size() * sizeof(ElementTy)), Ty);
+    return getRaw(StringRef(Data, Elts.size() * sizeof(ElementTy)), Elts.size(),
+                  Type::getScalarTy<ElementTy>(Context));
   }
 
   /// 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));
   }
 
+  /// get() constructor - Return a constant with array type with an element
+  /// count and element type matching the NumElements and ElementTy parameters
+  /// passed in. Note that this can return a ConstantAggregateZero object.
+  /// ElementTy needs to be one of i8/i16/i32/i64/float/double. Data is the
+  /// buffer containing the elements. Be careful to make sure Data uses the
+  /// right endianness, the buffer will be used as-is.
+  static Constant *getRaw(StringRef Data, uint64_t NumElements, Type *ElementTy) {
+    Type *Ty = ArrayType::get(ElementTy, NumElements);
+    return getImpl(Data, 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.
   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);