Add ConstantDataVector::getRaw() to create a constant data vector from raw data.

[nickwasmer]

Summary

This parallels ConstantDataArray::getRaw() and can be used with ConstantDataSequential::getRawDataValues() in the base class for both types.

Update BuildConstantData{Array,Vector} test to use the getRaw API. Also removes its unused Module and update some variable names.

In passing, update some comments to include the support for half and bfloat. Update tests to include testing for bfloat.

[nickwasmer]

Apply formatting changes raised by "llvm-premerge-checks".

[nickwasmer]

Remove one blank line pointed out by clang-format.

[nickwasmer]

Phab mangled my patch from:

index 96d3672647e8..8d0e06a62d36 100644
--- llvm/unittests/IR/ConstantsTest.cpp
+++ llvm/unittests/IR/ConstantsTest.cpp
@@ -1,717 +1,725 @@

to

diff --git a/llvm/unittests/IR/ConstantsTest.cpp b/unittests/IR/ConstantsTest.cpp
--- a/llvm/unittests/IR/ConstantsTest.cpp
+++ b/unittests/IR/ConstantsTest.cpp
@@ -23,11 +23,11 @@

breaking the build.

Try regenerating the patch without the --no-prefix flag.

[nickwasmer]

Fix clang-tidy-diff complaints from the builder.

[spatel]

Can you push all of the formatting changes before adding the new API and its tests? No Phab pre-commit review needed for no-functional-change cosmetic diffs.

[nickwasmer]

Rebase on top of main after landing the formatting changes separately.

[spatel]

LGTM - I'm not sure about the intended usage for these APIs, but this looks like a straightforward extension of the existing functionality. See inline for a couple of minor points.

llvm/include/llvm/IR/Constants.h

561 ↗

(On Diff #330812)

bloat -> bfloat

706 ↗

(On Diff #330812)

Does it make sense to assert that the type is one of the expected values inside here?

[nickwasmer]

I'm not sure about the intended usage for these APIs, but this looks like a straightforward extension of the existing functionality.

It's broken out of https://github.com/wasmerio/llvm-project/compare/main...wasmerio:feature/parallel-link which is a work in progress (only known issue is that Metadata isn't handled yet). I'm using the API to clone the data of the constant across to a different LLVMContext.

llvm/include/llvm/IR/Constants.h

706 ↗

(On Diff #330812)

Yes, I don't see why not. The rule applies to the base class which has a static isElementTypeCompatible method we could use. Let me land this first and then I'll try the assert and make sure it works and we can do that in a small separate review.

[nickwasmer]

llvm/include/llvm/IR/Constants.h

706 ↗

(On Diff #330812)

The assert is there after all, it's in ConstantDataSequential::getImpl.

include/llvm/IR/Constants.h

 /// This is the shared class of boolean and integer constants. This class
 /// represents both boolean and integral constants.
 /// Class for constant integers.
 class ConstantInt final : public ConstantData {
   friend class Constant;
 
   APInt Val;
 
-  ConstantInt(IntegerType *Ty, const APInt& V);
+  ConstantInt(IntegerType *Ty, const APInt &V);
 
   void destroyConstantImpl();
 
 public:
   ConstantInt(const ConstantInt &) = delete;
 
   static ConstantInt *getTrue(LLVMContext &Context);
   static ConstantInt *getFalse(LLVMContext &Context);
   static ConstantInt *getBool(LLVMContext &Context, bool V);
   static Constant *getTrue(Type *Ty);
   static Constant *getFalse(Type *Ty);
   static Constant *getBool(Type *Ty, bool V);
 
   /// If Ty is a vector type, return a Constant with a splat of the given
   /// value. Otherwise return a ConstantInt for the given value.
   static Constant *get(Type *Ty, uint64_t V, bool isSigned = false);
 
   /// Return a ConstantInt with the specified integer value for the specified
   /// type. If the type is wider than 64 bits, the value will be zero-extended
   /// to fit the type, unless isSigned is true, in which case the value will
   /// be interpreted as a 64-bit signed integer and sign-extended to fit
   /// the type.
   /// Get a ConstantInt for a specific value.
-  static ConstantInt *get(IntegerType *Ty, uint64_t V,
-                          bool isSigned = false);
+  static ConstantInt *get(IntegerType *Ty, uint64_t V, bool isSigned = false);
 
   /// Return a ConstantInt with the specified value for the specified type. The
   /// value V will be canonicalized to a an unsigned APInt. Accessing it with
   /// either getSExtValue() or getZExtValue() will yield a correctly sized and
   /// signed value for the type Ty.
   /// Get a ConstantInt for a specific signed value.
   static ConstantInt *getSigned(IntegerType *Ty, int64_t V);
   static Constant *getSigned(Type *Ty, int64_t V);
 
   /// Return a ConstantInt with the specified value and an implied Type. The
   /// type is the integer type that corresponds to the bit width of the value.
   static ConstantInt *get(LLVMContext &Context, const APInt &V);
 
   /// Return a ConstantInt constructed from the string strStart with the given
   /// radix.
-  static ConstantInt *get(IntegerType *Ty, StringRef Str,
-                          uint8_t radix);
+  static ConstantInt *get(IntegerType *Ty, StringRef Str, uint8_t radix);
 
   /// If Ty is a vector type, return a Constant with a splat of the given
   /// value. Otherwise return a ConstantInt for the given value.
-  static Constant *get(Type* Ty, const APInt& V);
+  static Constant *get(Type *Ty, const APInt &V);
 
   /// Return the constant as an APInt value reference. This allows clients to
   /// obtain a full-precision copy of the value.
   /// Return the constant's value.
-  inline const APInt &getValue() const {
-    return Val;
-  }
+  inline const APInt &getValue() const { return Val; }
 
   /// getBitWidth - Return the bitwidth of this constant.
   unsigned getBitWidth() const { return Val.getBitWidth(); }
 
   /// Return the constant as a 64-bit unsigned integer value after it
   /// has been zero extended as appropriate for the type of this constant. Note
   /// that this method can assert if the value does not fit in 64 bits.
   /// Return the zero extended value.
-  inline uint64_t getZExtValue() const {
-    return Val.getZExtValue();
-  }
+  inline uint64_t getZExtValue() const { return Val.getZExtValue(); }
 
   /// Return the constant as a 64-bit integer value after it has been sign
   /// extended as appropriate for the type of this constant. Note that
   /// this method can assert if the value does not fit in 64 bits.
   /// Return the sign extended value.
-  inline int64_t getSExtValue() const {
-    return Val.getSExtValue();
-  }
+  inline int64_t getSExtValue() const { return Val.getSExtValue(); }
 
   /// Return the constant as an llvm::MaybeAlign.
   /// Note that this method can assert if the value does not fit in 64 bits or
   /// is not a power of two.
   inline MaybeAlign getMaybeAlignValue() const {
     return MaybeAlign(getZExtValue());
   }
 
   /// Return the constant as an llvm::Align, interpreting `0` as `Align(1)`.
   /// Note that this method can assert if the value does not fit in 64 bits or
   /// is not a power of two.
   inline Align getAlignValue() const {
     return getMaybeAlignValue().valueOrOne();
   }
 
   /// A helper method that can be used to determine if the constant contained
   /// within is equal to a constant.  This only works for very small values,
   /// because this is all that can be represented with all types.
   /// Determine if this constant's value is same as an unsigned char.
-  bool equalsInt(uint64_t V) const {
-    return Val == V;
-  }
+  bool equalsInt(uint64_t V) const { return Val == V; }
 
   /// getType - Specialize the getType() method to always return an IntegerType,
   /// which reduces the amount of casting needed in parts of the compiler.
   ///
   inline IntegerType *getType() const {
     return cast<IntegerType>(Value::getType());
   }
 
public:
   static bool isValueValidForType(Type *Ty, uint64_t V);
   static bool isValueValidForType(Type *Ty, int64_t V);
 
   bool isNegative() const { return Val.isNegative(); }
 
   /// This is just a convenience method to make client code smaller for a
   /// common code. It also correctly performs the comparison without the
   /// potential for an assertion from getZExtValue().
-  bool isZero() const {
-    return Val.isNullValue();
-  }
+  bool isZero() const { return Val.isNullValue(); }
 
   /// This is just a convenience method to make client code smaller for a
   /// common case. It also correctly performs the comparison without the
   /// potential for an assertion from getZExtValue().
   /// Determine if the value is one.
-  bool isOne() const {
-    return Val.isOneValue();
-  }
+  bool isOne() const { return Val.isOneValue(); }
 
   /// This function will return true iff every bit in this constant is set
   /// to true.
   /// @returns true iff this constant's bits are all set to true.
   /// Determine if the value is all ones.
-  bool isMinusOne() const {
-    return Val.isAllOnesValue();
-  }
+  bool isMinusOne() const { return Val.isAllOnesValue(); }
 
   /// This function will return true iff this constant represents the largest
   /// value that may be represented by the constant's type.
   /// @returns true iff this is the largest value that may be represented
   /// by this type.
   /// Determine if the value is maximal.
   bool isMaxValue(bool isSigned) const {
     if (isSigned)
else
       return Val.isMinValue();
   }
 
   /// This function will return true iff this constant represents a value with
   /// active bits bigger than 64 bits or a value greater than the given uint64_t
   /// value.
   /// @returns true iff this constant is greater or equal to the given number.
   /// Determine if the value is greater or equal to the given number.
-  bool uge(uint64_t Num) const {
-    return Val.uge(Num);
-  }
+  bool uge(uint64_t Num) const { return Val.uge(Num); }
 
   /// getLimitedValue - If the value is smaller than the specified limit,
   /// return it, otherwise return the limit value.  This causes the value
   /// to saturate to the limit.
   /// @returns the min of the value of the constant and the specified value
   /// Get the constant's value with a saturation limit
   uint64_t getLimitedValue(uint64_t Limit = ~0ULL) const {
     return Val.getLimitedValue(Limit);
   }
 
   /// Methods to support type inquiry through isa, cast, and dyn_cast.
   static bool classof(const Value *V) {
     return V->getValueID() == ConstantIntVal;
   }
 };
 
 //===----------------------------------------------------------------------===//
 /// ConstantFP - Floating Point Values [float, double]
 ///
 class ConstantFP final : public ConstantData {
   friend class Constant;
 
   APFloat Val;
 
-  ConstantFP(Type *Ty, const APFloat& V);
+  ConstantFP(Type *Ty, const APFloat &V);
 
   void destroyConstantImpl();
 
 public:
   ConstantFP(const ConstantFP &) = delete;
 
   /// Floating point negation must be implemented with f(x) = -0.0 - x. This
   /// method returns the negative zero constant for floating point or vector
   /// floating point types; for all other types, it returns the null value.
   static Constant *getZeroValueForNegation(Type *Ty);
 
   /// This returns a ConstantFP, or a vector containing a splat of a ConstantFP,
   /// for the specified value in the specified type. This should only be used
   /// for simple constant values like 2.0/1.0 etc, that are known-valid both as
   /// host double and as the target format.
-  static Constant *get(Type* Ty, double V);
+  static Constant *get(Type *Ty, double V);
 
   /// If Ty is a vector type, return a Constant with a splat of the given
   /// value. Otherwise return a ConstantFP for the given value.
   static Constant *get(Type *Ty, const APFloat &V);
 
-  static Constant *get(Type* Ty, StringRef Str);
+  static Constant *get(Type *Ty, StringRef Str);
   static ConstantFP *get(LLVMContext &Context, const APFloat &V);
-  static Constant *getNaN(Type *Ty, bool Negative = false, uint64_t Payload = 0);
+  static Constant *getNaN(Type *Ty, bool Negative = false,
+                          uint64_t Payload = 0);
   static Constant *getQNaN(Type *Ty, bool Negative = false,
                            APInt *Payload = nullptr);
   static Constant *getSNaN(Type *Ty, bool Negative = false,
                            APInt *Payload = nullptr);
   static Constant *getNegativeZero(Type *Ty);
   static Constant *getInfinity(Type *Ty, bool Negative = false);
 
   /// Return true if Ty is big enough to represent V.
class ConstantArray final : public ConstantAggregate {
 
   ConstantArray(ArrayType *T, ArrayRef<Constant *> Val);
 
   void destroyConstantImpl();
   Value *handleOperandChangeImpl(Value *From, Value *To);
 
 public:
   // ConstantArray accessors
-  static Constant *get(ArrayType *T, ArrayRef<Constant*> V);
+  static Constant *get(ArrayType *T, ArrayRef<Constant *> V);
 
 private:
   static Constant *getImpl(ArrayType *T, ArrayRef<Constant *> V);
 
 public:
   /// 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 {
class ConstantStruct final : public ConstantAggregate {
 
   ConstantStruct(StructType *T, ArrayRef<Constant *> Val);
 
   void destroyConstantImpl();
   Value *handleOperandChangeImpl(Value *From, Value *To);
 
 public:
   // ConstantStruct accessors
-  static Constant *get(StructType *T, ArrayRef<Constant*> V);
+  static Constant *get(StructType *T, ArrayRef<Constant *> V);
 
   template <typename... Csts>
   static std::enable_if_t<are_base_of<Constant, Csts...>::value, Constant *>
   get(StructType *T, Csts *... Vs) {
     SmallVector<Constant *, 8> Values({Vs...});
     return get(T, Values);
   }
 
   /// Return an anonymous struct that has the specified elements.
   /// If the struct is possibly empty, then you must specify a context.
-  static Constant *getAnon(ArrayRef<Constant*> V, bool Packed = false) {
+  static Constant *getAnon(ArrayRef<Constant *> V, bool Packed = false) {
     return get(getTypeForElements(V, Packed), V);
   }
-  static Constant *getAnon(LLVMContext &Ctx,
-                           ArrayRef<Constant*> V, bool Packed = false) {
+  static Constant *getAnon(LLVMContext &Ctx, ArrayRef<Constant *> V,
+                           bool Packed = false) {
     return get(getTypeForElements(Ctx, V, Packed), V);
   }
 
   /// Return an anonymous struct type to use for a constant with the specified
   /// set of elements. The list must not be empty.
-  static StructType *getTypeForElements(ArrayRef<Constant*> V,
+  static StructType *getTypeForElements(ArrayRef<Constant *> V,
                                         bool Packed = false);
   /// This version of the method allows an empty list.
   static StructType *getTypeForElements(LLVMContext &Ctx,
-                                        ArrayRef<Constant*> V,
+                                        ArrayRef<Constant *> V,
                                         bool Packed = false);
 
   /// Specialization - reduce amount of casting.
   inline StructType *getType() const {
     return cast<StructType>(Value::getType());
   }
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
class ConstantVector final : public ConstantAggregate {
 
   ConstantVector(VectorType *T, ArrayRef<Constant *> Val);
 
   void destroyConstantImpl();
   Value *handleOperandChangeImpl(Value *From, Value *To);
 
 public:
   // ConstantVector accessors
-  static Constant *get(ArrayRef<Constant*> V);
+  static Constant *get(ArrayRef<Constant *> V);
 
 private:
   static Constant *getImpl(ArrayRef<Constant *> V);
 
 public:
   /// Return a ConstantVector with the specified constant in each element.
   /// Note that this might not return an instance of ConstantVector
   static Constant *getSplat(ElementCount EC, Constant *Elt);
public:
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Value *V) {
     return V->getValueID() == ConstantPointerNullVal;
   }
 };
 
 //===----------------------------------------------------------------------===//
 /// ConstantDataSequential - A vector or array constant whose element type is a
-/// simple 1/2/4/8-byte integer or float/double, and whose elements are just
-/// simple data values (i.e. ConstantInt/ConstantFP).  This Constant node has no
-/// operands because it stores all of the elements of the constant as densely
-/// packed data, instead of as Value*'s.
+/// simple 1/2/4/8-byte integer or half/bloat/float/double, and whose elements
+/// are just simple data values (i.e. ConstantInt/ConstantFP).  This Constant
+/// node has no operands because it stores all of the elements of the constant
+/// as densely packed data, instead of as Value*'s.
 ///
 /// This is the common base class of ConstantDataArray and ConstantDataVector.
 ///
 class ConstantDataSequential : public ConstantData {
   friend class LLVMContextImpl;
   friend class Constant;
 
   /// A pointer to the bytes underlying this constant (which is owned by the
StringRef getAsString() const {
     return getRawDataValues();
   }
 
   /// If this array is isCString(), then this method returns the array (without
   /// the trailing null byte) as a StringRef. Otherwise, it asserts out.
   StringRef getAsCString() const {
     assert(isCString() && "Isn't a C string");
     StringRef Str = getAsString();
-    return Str.substr(0, Str.size()-1);
+    return Str.substr(0, Str.size() - 1);
   }
 
   /// Return the raw, underlying, bytes of this data. Note that this is an
   /// extremely tricky thing to work with, as it exposes the host endianness of
   /// the data elements.
   StringRef getRawDataValues() const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
public:
 
   /// 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
+  /// getRaw() 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
+  /// ElementTy must be one of i8/i16/i32/i64/half/bfloat/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) {
+  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 of array type with a float
   /// element type taken from argument `ElementType', and count taken from
   /// argument `Elts'.  The amount of bits of the contained type must match the
   /// number of bits of the type contained in the passed in ArrayRef.
public:
   /// 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);
 
+  /// getRaw() constructor - Return a constant with vector 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 must be one of i8/i16/i32/i64/half/bfloat/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 = VectorType::get(ElementTy, ElementCount::getFixed(NumElements));
+    return getImpl(Data, Ty);
+  }
+
   /// getFP() constructors - Return a constant of vector type with a float
   /// element type taken from argument `ElementType', and count taken from
   /// argument `Elts'.  The amount of bits of the contained type must match the
   /// number of bits of the type contained in the passed in ArrayRef.
   /// (i.e. half or bfloat for 16bits, float for 32bits, double for 64bits) Note
   /// that this can return a ConstantAggregateZero object.
   static Constant *getFP(Type *ElementType, ArrayRef<uint16_t> Elts);
   static Constant *getFP(Type *ElementType, ArrayRef<uint32_t> Elts);
   static Constant *getFP(Type *ElementType, ArrayRef<uint64_t> Elts);
 
   /// Return a ConstantVector with the specified constant in each element.
   /// The specified constant has to be a of a compatible type (i8/i16/
-  /// i32/i64/float/double) and must be a ConstantFP or ConstantInt.
+  /// i32/i64/half/bfloat/float/double) and must be a ConstantFP or ConstantInt.
   static Constant *getSplat(unsigned NumElts, Constant *Elt);
 
   /// Returns true if this is a splat constant, meaning that all elements have
   /// the same value.
   bool isSplat() const;
 
   /// If this is a splat constant, meaning that all of the elements have the
   /// same value, return that value. Otherwise return NULL.
public:
   /// Lookup an existing \c BlockAddress constant for the given BasicBlock.
   ///
   /// \returns 0 if \c !BB->hasAddressTaken(), otherwise the \c BlockAddress.
   static BlockAddress *lookup(const BasicBlock *BB);
 
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
-  Function *getFunction() const { return (Function*)Op<0>().get(); }
-  BasicBlock *getBasicBlock() const { return (BasicBlock*)Op<1>().get(); }
+  Function *getFunction() const { return (Function *)Op<0>().get(); }
+  BasicBlock *getBasicBlock() const { return (BasicBlock *)Op<1>().get(); }
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Value *V) {
     return V->getValueID() == BlockAddressVal;
   }
 };
 
 template <>
-struct OperandTraits<BlockAddress> :
-  public FixedNumOperandTraits<BlockAddress, 2> {
-};
+struct OperandTraits<BlockAddress>
+    : public FixedNumOperandTraits<BlockAddress, 2> {};
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BlockAddress, Value)
 
 /// Wrapper for a function that represents a value that
 /// functionally represents the original function. This can be a function,
 /// global alias to a function, or an ifunc.
 class DSOLocalEquivalent final : public Constant {
   friend class Constant;
public:
   ///
   static Constant *getOffsetOf(StructType *STy, unsigned FieldNo);
 
   /// getOffsetOf constant expr - This is a generalized form of getOffsetOf,
   /// which supports any aggregate type, and any Constant index.
   ///
   static Constant *getOffsetOf(Type *Ty, Constant *FieldNo);
 
-  static Constant *getNeg(Constant *C, bool HasNUW = false, bool HasNSW =false);
+  static Constant *getNeg(Constant *C, bool HasNUW = false,
+                          bool HasNSW = false);
   static Constant *getFNeg(Constant *C);
   static Constant *getNot(Constant *C);
-  static Constant *getAdd(Constant *C1, Constant *C2,
-                          bool HasNUW = false, bool HasNSW = false);
+  static Constant *getAdd(Constant *C1, Constant *C2, bool HasNUW = false,
+                          bool HasNSW = false);
   static Constant *getFAdd(Constant *C1, Constant *C2);
-  static Constant *getSub(Constant *C1, Constant *C2,
-                          bool HasNUW = false, bool HasNSW = false);
+  static Constant *getSub(Constant *C1, Constant *C2, bool HasNUW = false,
+                          bool HasNSW = false);
   static Constant *getFSub(Constant *C1, Constant *C2);
-  static Constant *getMul(Constant *C1, Constant *C2,
-                          bool HasNUW = false, bool HasNSW = false);
+  static Constant *getMul(Constant *C1, Constant *C2, bool HasNUW = false,
+                          bool HasNSW = false);
   static Constant *getFMul(Constant *C1, Constant *C2);
   static Constant *getUDiv(Constant *C1, Constant *C2, bool isExact = false);
   static Constant *getSDiv(Constant *C1, Constant *C2, bool isExact = false);
   static Constant *getFDiv(Constant *C1, Constant *C2);
   static Constant *getURem(Constant *C1, Constant *C2);
   static Constant *getSRem(Constant *C1, Constant *C2);
   static Constant *getFRem(Constant *C1, Constant *C2);
   static Constant *getAnd(Constant *C1, Constant *C2);
   static Constant *getOr(Constant *C1, Constant *C2);
   static Constant *getXor(Constant *C1, Constant *C2);
   static Constant *getUMin(Constant *C1, Constant *C2);
-  static Constant *getShl(Constant *C1, Constant *C2,
-                          bool HasNUW = false, bool HasNSW = false);
+  static Constant *getShl(Constant *C1, Constant *C2, bool HasNUW = false,
+                          bool HasNSW = false);
   static Constant *getLShr(Constant *C1, Constant *C2, bool isExact = false);
   static Constant *getAShr(Constant *C1, Constant *C2, bool isExact = false);
   static Constant *getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced = false);
   static Constant *getSExt(Constant *C, Type *Ty, bool OnlyIfReduced = false);
   static Constant *getZExt(Constant *C, Type *Ty, bool OnlyIfReduced = false);
   static Constant *getFPTrunc(Constant *C, Type *Ty,
                               bool OnlyIfReduced = false);
   static Constant *getFPExtend(Constant *C, Type *Ty,
public:
   /// \param ops The opcode for the conversion
   /// \param C  The constant to be converted
   /// \param Ty The type to which the constant is converted
   /// \param OnlyIfReduced see \a getWithOperands() docs.
   static Constant *getCast(unsigned ops, Constant *C, Type *Ty,
                            bool OnlyIfReduced = false);
 
   // Create a ZExt or BitCast cast constant expression
-  static Constant *getZExtOrBitCast(
-    Constant *C,   ///< The constant to zext or bitcast
-    Type *Ty ///< The type to zext or bitcast C to
+  static Constant *
+  getZExtOrBitCast(Constant *C, ///< The constant to zext or bitcast
+                   Type *Ty     ///< The type to zext or bitcast C to
   );
 
   // Create a SExt or BitCast cast constant expression
-  static Constant *getSExtOrBitCast(
-    Constant *C,   ///< The constant to sext or bitcast
-    Type *Ty ///< The type to sext or bitcast C to
+  static Constant *
+  getSExtOrBitCast(Constant *C, ///< The constant to sext or bitcast
+                   Type *Ty     ///< The type to sext or bitcast C to
   );
 
   // Create a Trunc or BitCast cast constant expression
-  static Constant *getTruncOrBitCast(
-    Constant *C,   ///< The constant to trunc or bitcast
-    Type *Ty ///< The type to trunc or bitcast C to
+  static Constant *
+  getTruncOrBitCast(Constant *C, ///< The constant to trunc or bitcast
+                    Type *Ty     ///< The type to trunc or bitcast C to
   );
 
   /// Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant
   /// expression.
-  static Constant *getPointerCast(
-    Constant *C,   ///< The pointer value to be casted (operand 0)
-    Type *Ty ///< The type to which cast should be made
+  static Constant *
+  getPointerCast(Constant *C, ///< The pointer value to be casted (operand 0)
+                 Type *Ty     ///< The type to which cast should be made
   );
 
   /// Create a BitCast or AddrSpaceCast for a pointer type depending on
   /// the address space.
   static Constant *getPointerBitCastOrAddrSpaceCast(
-    Constant *C,   ///< The constant to addrspacecast or bitcast
-    Type *Ty ///< The type to bitcast or addrspacecast C to
+      Constant *C, ///< The constant to addrspacecast or bitcast
+      Type *Ty     ///< The type to bitcast or addrspacecast C to
   );
 
   /// Create a ZExt, Bitcast or Trunc for integer -> integer casts
-  static Constant *getIntegerCast(
-    Constant *C,    ///< The integer constant to be casted
-    Type *Ty, ///< The integer type to cast to
-    bool isSigned   ///< Whether C should be treated as signed or not
+  static Constant *
+  getIntegerCast(Constant *C,  ///< The integer constant to be casted
+                 Type *Ty,     ///< The integer type to cast to
+                 bool isSigned ///< Whether C should be treated as signed or not
   );
 
   /// Create a FPExt, Bitcast or FPTrunc for fp -> fp casts
-  static Constant *getFPCast(
-    Constant *C,    ///< The integer constant to be casted
-    Type *Ty ///< The integer type to cast to
+  static Constant *getFPCast(Constant *C, ///< The integer constant to be casted
+                             Type *Ty     ///< The integer type to cast to
   );
 
   /// Return true if this is a convert constant expression
   bool isCast() const;
 
   /// Return true if this is a compare constant expression
   bool isCompare() const;
 
public:
   /// \param OnlyIfReducedTy see \a getWithOperands() docs.
   static Constant *getSelect(Constant *C, Constant *V1, Constant *V2,
                              Type *OnlyIfReducedTy = nullptr);
 
   /// get - Return a unary operator constant expression,
   /// folding if possible.
   ///
   /// \param OnlyIfReducedTy see \a getWithOperands() docs.
-  static Constant *get(unsigned Opcode, Constant *C1, unsigned Flags = 0, 
+  static Constant *get(unsigned Opcode, Constant *C1, unsigned Flags = 0,
                        Type *OnlyIfReducedTy = nullptr);
 
   /// get - Return a binary or shift operator constant expression,
   /// folding if possible.
   ///
   /// \param OnlyIfReducedTy see \a getWithOperands() docs.
   static Constant *get(unsigned Opcode, Constant *C1, Constant *C2,
                        unsigned Flags = 0, Type *OnlyIfReducedTy = nullptr);
public:
   /// \param InRangeIndex the inrange index if present or None.
   /// \param OnlyIfReducedTy see \a getWithOperands() docs.
   static Constant *getGetElementPtr(Type *Ty, Constant *C,
                                     ArrayRef<Constant *> IdxList,
                                     bool InBounds = false,
                                     Optional<unsigned> InRangeIndex = None,
                                     Type *OnlyIfReducedTy = nullptr) {
     return getGetElementPtr(
-        Ty, C, makeArrayRef((Value * const *)IdxList.data(), IdxList.size()),
+        Ty, C, makeArrayRef((Value *const *)IdxList.data(), IdxList.size()),
         InBounds, InRangeIndex, OnlyIfReducedTy);
   }
   static Constant *getGetElementPtr(Type *Ty, Constant *C, Constant *Idx,
                                     bool InBounds = false,
                                     Optional<unsigned> InRangeIndex = None,
                                     Type *OnlyIfReducedTy = nullptr) {
     // This form of the function only exists to avoid ambiguous overload
     // warnings about whether to convert Idx to ArrayRef<Constant *> or
public:
 
   /// Return a constant expression identical to this one, but with the specified
   /// operand set to the specified value.
   Constant *getWithOperandReplaced(unsigned OpNo, Constant *Op) const;
 
   /// This returns the current constant expression with the operands replaced
   /// with the specified values. The specified array must have the same number
   /// of operands as our current one.
-  Constant *getWithOperands(ArrayRef<Constant*> Ops) const {
+  Constant *getWithOperands(ArrayRef<Constant *> Ops) const {
     return getWithOperands(Ops, getType());
   }
 
   /// Get the current expression with the operands replaced.
   ///
   /// Return the current constant expression with the operands replaced with \c
   /// Ops and the type with \c Ty.  The new operands must have the same number
   /// as the current ones.
private:
   // Shadow Value::setValueSubclassData with a private forwarding method so that
   // subclasses cannot accidentally use it.
   void setValueSubclassData(unsigned short D) {
     Value::setValueSubclassData(D);
   }
 };
 
 template <>
-struct OperandTraits<ConstantExpr> :
-  public VariadicOperandTraits<ConstantExpr, 1> {
-};
+struct OperandTraits<ConstantExpr>
+    : public VariadicOperandTraits<ConstantExpr, 1> {};
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantExpr, Constant)
 
 //===----------------------------------------------------------------------===//
 /// 'undef' values are things that do not have specified contents.
 /// These are used for a variety of purposes, including global variable
 /// initializers and operands to instructions.  'undef' values can occur with
 /// any first-class type.

unittests/IR/ConstantsTest.cpp

 #include "gtest/gtest.h"
 
 namespace llvm {
 namespace {
 
 TEST(ConstantsTest, Integer_i1) {
   LLVMContext Context;
   IntegerType *Int1 = IntegerType::get(Context, 1);
-  Constant* One = ConstantInt::get(Int1, 1, true);
-  Constant* Zero = ConstantInt::get(Int1, 0);
-  Constant* NegOne = ConstantInt::get(Int1, static_cast<uint64_t>(-1), true);
+  Constant *One = ConstantInt::get(Int1, 1, true);
+  Constant *Zero = ConstantInt::get(Int1, 0);
+  Constant *NegOne = ConstantInt::get(Int1, static_cast<uint64_t>(-1), true);
   EXPECT_EQ(NegOne, ConstantInt::getSigned(Int1, -1));
-  Constant* Undef = UndefValue::get(Int1);
+  Constant *Undef = UndefValue::get(Int1);
 
   // Input:  @b = constant i1 add(i1 1 , i1 1)
   // Output: @b = constant i1 false
   EXPECT_EQ(Zero, ConstantExpr::getAdd(One, One));
 
   // @c = constant i1 add(i1 -1, i1 1)
   // @c = constant i1 false
   EXPECT_EQ(Zero, ConstantExpr::getAdd(NegOne, One));
TEST(ConstantsTest, PointerCast) {
   Type *Int8PtrTy = Type::getInt8PtrTy(C);
   Type *Int32PtrTy = Type::getInt32PtrTy(C);
   Type *Int64Ty = Type::getInt64Ty(C);
   VectorType *Int8PtrVecTy = FixedVectorType::get(Int8PtrTy, 4);
   VectorType *Int32PtrVecTy = FixedVectorType::get(Int32PtrTy, 4);
   VectorType *Int64VecTy = FixedVectorType::get(Int64Ty, 4);
 
   // ptrtoint i8* to i64
-  EXPECT_EQ(Constant::getNullValue(Int64Ty),
-            ConstantExpr::getPointerCast(
-              Constant::getNullValue(Int8PtrTy), Int64Ty));
+  EXPECT_EQ(
+      Constant::getNullValue(Int64Ty),
+      ConstantExpr::getPointerCast(Constant::getNullValue(Int8PtrTy), Int64Ty));
 
   // bitcast i8* to i32*
   EXPECT_EQ(Constant::getNullValue(Int32PtrTy),
-            ConstantExpr::getPointerCast(
-              Constant::getNullValue(Int8PtrTy), Int32PtrTy));
+            ConstantExpr::getPointerCast(Constant::getNullValue(Int8PtrTy),
+                                         Int32PtrTy));
 
   // ptrtoint <4 x i8*> to <4 x i64>
   EXPECT_EQ(Constant::getNullValue(Int64VecTy),
-            ConstantExpr::getPointerCast(
-              Constant::getNullValue(Int8PtrVecTy), Int64VecTy));
+            ConstantExpr::getPointerCast(Constant::getNullValue(Int8PtrVecTy),
+                                         Int64VecTy));
 
   // bitcast <4 x i8*> to <4 x i32*>
   EXPECT_EQ(Constant::getNullValue(Int32PtrVecTy),
-            ConstantExpr::getPointerCast(
-              Constant::getNullValue(Int8PtrVecTy), Int32PtrVecTy));
+            ConstantExpr::getPointerCast(Constant::getNullValue(Int8PtrVecTy),
+                                         Int32PtrVecTy));
 
   Type *Int32Ptr1Ty = Type::getInt32PtrTy(C, 1);
   ConstantInt *K = ConstantInt::get(Type::getInt64Ty(C), 1234);
 
   // Make sure that addrspacecast of inttoptr is not folded away.
-  EXPECT_NE(K,
-            ConstantExpr::getAddrSpaceCast(
+  EXPECT_NE(K, ConstantExpr::getAddrSpaceCast(
                    ConstantExpr::getIntToPtr(K, Int32PtrTy), Int32Ptr1Ty));
-  EXPECT_NE(K,
-            ConstantExpr::getAddrSpaceCast(
+  EXPECT_NE(K, ConstantExpr::getAddrSpaceCast(
                    ConstantExpr::getIntToPtr(K, Int32Ptr1Ty), Int32PtrTy));
 
   Constant *NullInt32Ptr0 = Constant::getNullValue(Int32PtrTy);
   Constant *NullInt32Ptr1 = Constant::getNullValue(Int32Ptr1Ty);
 
   // Make sure that addrspacecast of null is not folded away.
   EXPECT_NE(Constant::getNullValue(Int32PtrTy),
             ConstantExpr::getAddrSpaceCast(NullInt32Ptr0, Int32Ptr1Ty));
 
TEST(ConstantsTest, AsInstructionsTest) {
 
   Type *Int64Ty = Type::getInt64Ty(Context);
   Type *Int32Ty = Type::getInt32Ty(Context);
   Type *Int16Ty = Type::getInt16Ty(Context);
   Type *Int1Ty = Type::getInt1Ty(Context);
   Type *FloatTy = Type::getFloatTy(Context);
   Type *DoubleTy = Type::getDoubleTy(Context);
 
-  Constant *Global = M->getOrInsertGlobal("dummy",
-                                         PointerType::getUnqual(Int32Ty));
-  Constant *Global2 = M->getOrInsertGlobal("dummy2",
-                                         PointerType::getUnqual(Int32Ty));
+  Constant *Global =
+      M->getOrInsertGlobal("dummy", PointerType::getUnqual(Int32Ty));
+  Constant *Global2 =
+      M->getOrInsertGlobal("dummy2", PointerType::getUnqual(Int32Ty));
 
   Constant *P0 = ConstantExpr::getPtrToInt(Global, Int32Ty);
   Constant *P1 = ConstantExpr::getUIToFP(P0, FloatTy);
   Constant *P2 = ConstantExpr::getUIToFP(P0, DoubleTy);
   Constant *P3 = ConstantExpr::getTrunc(P0, Int1Ty);
   Constant *P4 = ConstantExpr::getPtrToInt(Global2, Int32Ty);
   Constant *P5 = ConstantExpr::getUIToFP(P4, FloatTy);
   Constant *P6 = ConstantExpr::getBitCast(P4, FixedVectorType::get(Int16Ty, 2));
 
   Constant *One = ConstantInt::get(Int32Ty, 1);
   Constant *Two = ConstantInt::get(Int64Ty, 2);
   Constant *Big = ConstantInt::get(Context, APInt{256, uint64_t(-1), true});
   Constant *Elt = ConstantInt::get(Int16Ty, 2015);
   Constant *Poison16 = PoisonValue::get(Int16Ty);
-  Constant *Undef64  = UndefValue::get(Int64Ty);
+  Constant *Undef64 = UndefValue::get(Int64Ty);
   Constant *UndefV16 = UndefValue::get(P6->getType());
   Constant *PoisonV16 = PoisonValue::get(P6->getType());
 
-  #define P0STR "ptrtoint (i32** @dummy to i32)"
-  #define P1STR "uitofp (i32 ptrtoint (i32** @dummy to i32) to float)"
-  #define P2STR "uitofp (i32 ptrtoint (i32** @dummy to i32) to double)"
-  #define P3STR "ptrtoint (i32** @dummy to i1)"
-  #define P4STR "ptrtoint (i32** @dummy2 to i32)"
-  #define P5STR "uitofp (i32 ptrtoint (i32** @dummy2 to i32) to float)"
-  #define P6STR "bitcast (i32 ptrtoint (i32** @dummy2 to i32) to <2 x i16>)"
 
   CHECK(ConstantExpr::getNeg(P0), "sub i32 0, " P0STR);
   CHECK(ConstantExpr::getFNeg(P1), "fneg float " P1STR);
   CHECK(ConstantExpr::getNot(P0), "xor i32 " P0STR ", -1");
   CHECK(ConstantExpr::getAdd(P0, P0), "add i32 " P0STR ", " P0STR);
-  CHECK(ConstantExpr::getAdd(P0, P0, false, true), "add nsw i32 " P0STR ", "
-        P0STR);
-  CHECK(ConstantExpr::getAdd(P0, P0, true, true), "add nuw nsw i32 " P0STR ", "
-        P0STR);
+  CHECK(ConstantExpr::getAdd(P0, P0, false, true),
+        "add nsw i32 " P0STR ", " P0STR);
+  CHECK(ConstantExpr::getAdd(P0, P0, true, true),
+        "add nuw nsw i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getFAdd(P1, P1), "fadd float " P1STR ", " P1STR);
   CHECK(ConstantExpr::getSub(P0, P0), "sub i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getFSub(P1, P1), "fsub float " P1STR ", " P1STR);
   CHECK(ConstantExpr::getMul(P0, P0), "mul i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getFMul(P1, P1), "fmul float " P1STR ", " P1STR);
   CHECK(ConstantExpr::getUDiv(P0, P0), "udiv i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getSDiv(P0, P0), "sdiv i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getFDiv(P1, P1), "fdiv float " P1STR ", " P1STR);
   CHECK(ConstantExpr::getURem(P0, P0), "urem i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getSRem(P0, P0), "srem i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getFRem(P1, P1), "frem float " P1STR ", " P1STR);
   CHECK(ConstantExpr::getAnd(P0, P0), "and i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getOr(P0, P0), "or i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getXor(P0, P0), "xor i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getShl(P0, P0), "shl i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getShl(P0, P0, true), "shl nuw i32 " P0STR ", " P0STR);
-  CHECK(ConstantExpr::getShl(P0, P0, false, true), "shl nsw i32 " P0STR ", "
-        P0STR);
+  CHECK(ConstantExpr::getShl(P0, P0, false, true),
+        "shl nsw i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getLShr(P0, P0, false), "lshr i32 " P0STR ", " P0STR);
-  CHECK(ConstantExpr::getLShr(P0, P0, true), "lshr exact i32 " P0STR ", " P0STR);
+  CHECK(ConstantExpr::getLShr(P0, P0, true),
+        "lshr exact i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getAShr(P0, P0, false), "ashr i32 " P0STR ", " P0STR);
-  CHECK(ConstantExpr::getAShr(P0, P0, true), "ashr exact i32 " P0STR ", " P0STR);
+  CHECK(ConstantExpr::getAShr(P0, P0, true),
+        "ashr exact i32 " P0STR ", " P0STR);
 
   CHECK(ConstantExpr::getSExt(P0, Int64Ty), "sext i32 " P0STR " to i64");
   CHECK(ConstantExpr::getZExt(P0, Int64Ty), "zext i32 " P0STR " to i64");
-  CHECK(ConstantExpr::getFPTrunc(P2, FloatTy), "fptrunc double " P2STR
-        " to float");
-  CHECK(ConstantExpr::getFPExtend(P1, DoubleTy), "fpext float " P1STR
-        " to double");
+  CHECK(ConstantExpr::getFPTrunc(P2, FloatTy),
+        "fptrunc double " P2STR " to float");
+  CHECK(ConstantExpr::getFPExtend(P1, DoubleTy),
+        "fpext float " P1STR " to double");
 
   CHECK(ConstantExpr::getExactUDiv(P0, P0), "udiv exact i32 " P0STR ", " P0STR);
 
-  CHECK(ConstantExpr::getSelect(P3, P0, P4), "select i1 " P3STR ", i32 " P0STR
-        ", i32 " P4STR);
-  CHECK(ConstantExpr::getICmp(CmpInst::ICMP_EQ, P0, P4), "icmp eq i32 " P0STR
-        ", " P4STR);
-  CHECK(ConstantExpr::getFCmp(CmpInst::FCMP_ULT, P1, P5), "fcmp ult float "
-        P1STR ", " P5STR);
+  CHECK(ConstantExpr::getSelect(P3, P0, P4),
+        "select i1 " P3STR ", i32 " P0STR ", i32 " P4STR);
+  CHECK(ConstantExpr::getICmp(CmpInst::ICMP_EQ, P0, P4),
+        "icmp eq i32 " P0STR ", " P4STR);
+  CHECK(ConstantExpr::getFCmp(CmpInst::FCMP_ULT, P1, P5),
+        "fcmp ult float " P1STR ", " P5STR);
 
-  std::vector<Constant*> V;
+  std::vector<Constant *> V;
   V.push_back(One);
   // FIXME: getGetElementPtr() actually creates an inbounds ConstantGEP,
   //        not a normal one!
-  //CHECK(ConstantExpr::getGetElementPtr(Global, V, false),
-  //      "getelementptr i32*, i32** @dummy, i32 1");
+  //  CHECK(ConstantExpr::getGetElementPtr(Global, V, false),
+  //        "getelementptr i32*, i32** @dummy, i32 1");
   CHECK(ConstantExpr::getInBoundsGetElementPtr(PointerType::getUnqual(Int32Ty),
                                                Global, V),
         "getelementptr inbounds i32*, i32** @dummy, i32 1");
 
-  CHECK(ConstantExpr::getExtractElement(P6, One), "extractelement <2 x i16> "
-        P6STR ", i32 1");
+  CHECK(ConstantExpr::getExtractElement(P6, One),
+        "extractelement <2 x i16> " P6STR ", i32 1");
 
   EXPECT_EQ(Poison16, ConstantExpr::getExtractElement(P6, Two));
   EXPECT_EQ(Poison16, ConstantExpr::getExtractElement(P6, Big));
   EXPECT_EQ(Poison16, ConstantExpr::getExtractElement(P6, Undef64));
 
   EXPECT_EQ(Elt, ConstantExpr::getExtractElement(
                      ConstantExpr::getInsertElement(P6, Elt, One), One));
   EXPECT_EQ(UndefV16, ConstantExpr::getInsertElement(P6, Elt, Two));
   EXPECT_EQ(UndefV16, ConstantExpr::getInsertElement(P6, Elt, Big));
   EXPECT_EQ(PoisonV16, ConstantExpr::getInsertElement(P6, Elt, Undef64));
 }
 
 #ifdef GTEST_HAS_DEATH_TEST
 #ifndef NDEBUG
 TEST(ConstantsTest, ReplaceWithConstantTest) {
static std::string getNameOfType(Type *T) {
   std::string S;
   raw_string_ostream RSOS(S);
   T->print(RSOS);
   return S;
 }
 
 TEST(ConstantsTest, BuildConstantDataArrays) {
   LLVMContext Context;
-  std::unique_ptr<Module> M(new Module("MyModule", Context));
 
   for (Type *T : {Type::getInt8Ty(Context), Type::getInt16Ty(Context),
                   Type::getInt32Ty(Context), Type::getInt64Ty(Context)}) {
     ArrayType *ArrayTy = ArrayType::get(T, 2);
     Constant *Vals[] = {ConstantInt::get(T, 0), ConstantInt::get(T, 1)};
-    Constant *CDV = ConstantArray::get(ArrayTy, Vals);
-    ASSERT_TRUE(dyn_cast<ConstantDataArray>(CDV) != nullptr)
-        << " T = " << getNameOfType(T);
+    Constant *CA = ConstantArray::get(ArrayTy, Vals);
+    ASSERT_TRUE(isa<ConstantDataArray>(CA)) << " T = " << getNameOfType(T);
+    auto CDA = cast<ConstantDataArray>(CA);
+    Constant *CA2 = ConstantDataArray::getRaw(
+        CDA->getRawDataValues(), CDA->getNumElements(), CDA->getElementType());
+    ASSERT_TRUE(CA == CA2) << " T = " << getNameOfType(T);
   }
 
-  for (Type *T : {Type::getHalfTy(Context), Type::getFloatTy(Context),
-                  Type::getDoubleTy(Context)}) {
+  for (Type *T : {Type::getHalfTy(Context), Type::getBFloatTy(Context),
+                  Type::getFloatTy(Context), Type::getDoubleTy(Context)}) {
     ArrayType *ArrayTy = ArrayType::get(T, 2);
     Constant *Vals[] = {ConstantFP::get(T, 0), ConstantFP::get(T, 1)};
-    Constant *CDV = ConstantArray::get(ArrayTy, Vals);
-    ASSERT_TRUE(dyn_cast<ConstantDataArray>(CDV) != nullptr)
-        << " T = " << getNameOfType(T);
+    Constant *CA = ConstantArray::get(ArrayTy, Vals);
+    ASSERT_TRUE(isa<ConstantDataArray>(CA)) << " T = " << getNameOfType(T);
+    auto CDA = cast<ConstantDataArray>(CA);
+    Constant *CA2 = ConstantDataArray::getRaw(
+        CDA->getRawDataValues(), CDA->getNumElements(), CDA->getElementType());
+    ASSERT_TRUE(CA == CA2) << " T = " << getNameOfType(T);
   }
 }
 
 TEST(ConstantsTest, BuildConstantDataVectors) {
   LLVMContext Context;
-  std::unique_ptr<Module> M(new Module("MyModule", Context));
 
   for (Type *T : {Type::getInt8Ty(Context), Type::getInt16Ty(Context),
                   Type::getInt32Ty(Context), Type::getInt64Ty(Context)}) {
     Constant *Vals[] = {ConstantInt::get(T, 0), ConstantInt::get(T, 1)};
-    Constant *CDV = ConstantVector::get(Vals);
-    ASSERT_TRUE(dyn_cast<ConstantDataVector>(CDV) != nullptr)
-        << " T = " << getNameOfType(T);
+    Constant *CV = ConstantVector::get(Vals);
+    ASSERT_TRUE(isa<ConstantDataVector>(CV)) << " T = " << getNameOfType(T);
+    auto CDV = cast<ConstantDataVector>(CV);
+    Constant *CV2 = ConstantDataVector::getRaw(
+        CDV->getRawDataValues(), CDV->getNumElements(), CDV->getElementType());
+    ASSERT_TRUE(CV == CV2) << " T = " << getNameOfType(T);
   }
 
-  for (Type *T : {Type::getHalfTy(Context), Type::getFloatTy(Context),
-                  Type::getDoubleTy(Context)}) {
+  for (Type *T : {Type::getHalfTy(Context), Type::getBFloatTy(Context),
+                  Type::getFloatTy(Context), Type::getDoubleTy(Context)}) {
     Constant *Vals[] = {ConstantFP::get(T, 0), ConstantFP::get(T, 1)};
-    Constant *CDV = ConstantVector::get(Vals);
-    ASSERT_TRUE(dyn_cast<ConstantDataVector>(CDV) != nullptr)
-        << " T = " << getNameOfType(T);
+    Constant *CV = ConstantVector::get(Vals);
+    ASSERT_TRUE(isa<ConstantDataVector>(CV)) << " T = " << getNameOfType(T);
+    auto CDV = cast<ConstantDataVector>(CV);
+    Constant *CV2 = ConstantDataVector::getRaw(
+        CDV->getRawDataValues(), CDV->getNumElements(), CDV->getElementType());
+    ASSERT_TRUE(CV == CV2) << " T = " << getNameOfType(T);
   }
 }
 
 TEST(ConstantsTest, BitcastToGEP) {
   LLVMContext Context;
   std::unique_ptr<Module> M(new Module("MyModule", Context));
 
   auto *i32 = Type::getInt32Ty(Context);
   auto *U = StructType::create(Context, "Unsized");
   Type *EltTys[] = {i32, U};
   auto *S = StructType::create(EltTys);
 
-  auto *G = new GlobalVariable(*M, S, false,
-                               GlobalValue::ExternalLinkage, nullptr);
+  auto *G =
+      new GlobalVariable(*M, S, false, GlobalValue::ExternalLinkage, nullptr);
   auto *PtrTy = PointerType::get(i32, 0);
   auto *C = ConstantExpr::getBitCast(G, PtrTy);
   ASSERT_EQ(cast<ConstantExpr>(C)->getOpcode(), Instruction::BitCast);
 }
 
 bool foldFuncPtrAndConstToNull(LLVMContext &Context, Module *TheModule,
                                uint64_t AndValue,
                                MaybeAlign FunctionAlign = llvm::None) {
   Type *VoidType(Type::getVoidTy(Context));
   FunctionType *FuncType(FunctionType::get(VoidType, false));
-  Function *Func(Function::Create(
-      FuncType, GlobalValue::ExternalLinkage, "", TheModule));
+  Function *Func(
+      Function::Create(FuncType, GlobalValue::ExternalLinkage, "", TheModule));
 
   if (FunctionAlign)
     Func->setAlignment(*FunctionAlign);
 
   IntegerType *ConstantIntType(Type::getInt32Ty(Context));
   ConstantInt *TheConstant(ConstantInt::get(ConstantIntType, AndValue));
 
-  Constant *TheConstantExpr(
-      ConstantExpr::getPtrToInt(Func, ConstantIntType));
+  Constant *TheConstantExpr(ConstantExpr::getPtrToInt(Func, ConstantIntType));
 
 
-  bool result = ConstantExpr::get(Instruction::And, TheConstantExpr,
-                           TheConstant)->isNullValue();
+  bool result =
+      ConstantExpr::get(Instruction::And, TheConstantExpr, TheConstant)
+          ->isNullValue();
 
   if (!TheModule) {
     // If the Module exists then it will delete the Function.
     delete Func;
   }
 
   return result;
 }
TEST(ConstantsTest, DontFoldFunctionPtrAlignUnknownAnd4) {
   LLVMContext Context;
   Module TheModule("TestModule", Context);
   ASSERT_FALSE(foldFuncPtrAndConstToNull(Context, &TheModule, 4));
 }
 
 TEST(ConstantsTest, FoldFunctionPtrAlign4) {
   LLVMContext Context;
   Module TheModule("TestModule", Context);
-  const char* AlignmentStrings[] = { "Fi32", "Fn32" };
+  const char *AlignmentStrings[] = {"Fi32", "Fn32"};
 
   for (unsigned AndValue = 1; AndValue <= 2; ++AndValue) {
     for (const char *AlignmentString : AlignmentStrings) {
       TheModule.setDataLayout(AlignmentString);
       ASSERT_TRUE(foldFuncPtrAndConstToNull(Context, &TheModule, AndValue));
     }
   }
 }
 
 TEST(ConstantsTest, DontFoldFunctionPtrAlign1) {
   LLVMContext Context;
   Module TheModule("TestModule", Context);
-  const char* AlignmentStrings[] = { "Fi8", "Fn8" };
+  const char *AlignmentStrings[] = {"Fi8", "Fn8"};
 
-  for (const char* AlignmentString : AlignmentStrings) {
+  for (const char *AlignmentString : AlignmentStrings) {
     TheModule.setDataLayout(AlignmentString);
     ASSERT_FALSE(foldFuncPtrAndConstToNull(Context, &TheModule, 2));
   }
 }
 
 TEST(ConstantsTest, FoldFunctionAlign4PtrAlignMultiple) {
   LLVMContext Context;
   Module TheModule("TestModule", Context);
TEST(ConstantsTest, FoldGlobalVariablePtr) {
 
   std::unique_ptr<GlobalVariable> Global(
       new GlobalVariable(IntType, true, GlobalValue::ExternalLinkage));
 
   Global->setAlignment(Align(4));
 
   ConstantInt *TheConstant(ConstantInt::get(IntType, 2));
 
-  Constant *TheConstantExpr(
-      ConstantExpr::getPtrToInt(Global.get(), IntType));
+  Constant *TheConstantExpr(ConstantExpr::getPtrToInt(Global.get(), IntType));
 
-  ASSERT_TRUE(ConstantExpr::get( \
-      Instruction::And, TheConstantExpr, TheConstant)->isNullValue());
+  ASSERT_TRUE(ConstantExpr::get(Instruction::And, TheConstantExpr, TheConstant)
+                  ->isNullValue());
 }
 
 // Check that containsUndefOrPoisonElement and containsPoisonElement is working
 // great
 
 TEST(ConstantsTest, containsUndefElemTest) {
   LLVMContext Context;
 
for (auto EC : {ScalableEC, FixedEC}) {
           EXPECT_NE(nullptr, SplatVal);
           EXPECT_EQ(SplatVal, C);
         }
       }
     }
   }
 }
 
-}  // end anonymous namespace
-}  // end namespace llvm
+} // end anonymous namespace
+} // end namespace llvm