[llvm] 483a253 - NFC: Formatting changes.
Nick Lewycky via llvm-commits
llvm-commits at lists.llvm.org
Mon Mar 15 14:26:50 PDT 2021
Author: Nick Lewycky
Date: 2021-03-15T14:26:39-07:00
New Revision: 483a253ae9b8de07e058c173419e374a9ccfdd80
URL: https://github.com/llvm/llvm-project/commit/483a253ae9b8de07e058c173419e374a9ccfdd80
DIFF: https://github.com/llvm/llvm-project/commit/483a253ae9b8de07e058c173419e374a9ccfdd80.diff
LOG: NFC: Formatting changes.
Run clang-format over these files.
Capitalize some variable names per clang-tidy's request.
Pulled out to simplify review of D98302.
Added:
Modified:
llvm/include/llvm/IR/Constants.h
llvm/unittests/IR/ConstantsTest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/IR/Constants.h b/llvm/include/llvm/IR/Constants.h
index ac802232c23d..510163abe6eb 100644
--- a/llvm/include/llvm/IR/Constants.h
+++ b/llvm/include/llvm/IR/Constants.h
@@ -79,7 +79,7 @@ class ConstantInt final : public ConstantData {
APInt Val;
- ConstantInt(IntegerType *Ty, const APInt& V);
+ ConstantInt(IntegerType *Ty, const APInt &V);
void destroyConstantImpl();
@@ -95,16 +95,15 @@ class ConstantInt final : public ConstantData {
/// 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);
+ 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
+ /// 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
@@ -120,19 +119,16 @@ class ConstantInt final : public ConstantData {
/// 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(); }
@@ -141,17 +137,13 @@ class ConstantInt final : public ConstantData {
/// 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
@@ -171,9 +163,7 @@ class ConstantInt final : public ConstantData {
/// 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.
@@ -199,33 +189,27 @@ class ConstantInt final : public ConstantData {
/// 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)
+ bool isMaxValue(bool IsSigned) const {
+ if (IsSigned)
return Val.isMaxSignedValue();
else
return Val.isMaxValue();
@@ -236,8 +220,8 @@ class ConstantInt final : public ConstantData {
/// @returns true if this is the smallest value that may be represented by
/// this type.
/// Determine if the value is minimal.
- bool isMinValue(bool isSigned) const {
- if (isSigned)
+ bool isMinValue(bool IsSigned) const {
+ if (IsSigned)
return Val.isMinSignedValue();
else
return Val.isMinValue();
@@ -248,9 +232,7 @@ class ConstantInt final : public ConstantData {
/// 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
@@ -275,7 +257,7 @@ class ConstantFP final : public ConstantData {
APFloat Val;
- ConstantFP(Type *Ty, const APFloat& V);
+ ConstantFP(Type *Ty, const APFloat &V);
void destroyConstantImpl();
@@ -291,15 +273,16 @@ class ConstantFP final : public ConstantData {
/// 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,
@@ -432,7 +415,7 @@ class ConstantArray final : public ConstantAggregate {
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);
@@ -464,32 +447,32 @@ class ConstantStruct final : public ConstantAggregate {
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) {
+ 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.
@@ -517,7 +500,7 @@ class ConstantVector final : public ConstantAggregate {
public:
// ConstantVector accessors
- static Constant *get(ArrayRef<Constant*> V);
+ static Constant *get(ArrayRef<Constant *> V);
private:
static Constant *getImpl(ArrayRef<Constant *> V);
@@ -667,7 +650,7 @@ class ConstantDataSequential : public ConstantData {
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
@@ -723,7 +706,8 @@ class ConstantDataArray final : public ConstantDataSequential {
/// 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) {
+ static Constant *getRaw(StringRef Data, uint64_t NumElements,
+ Type *ElementTy) {
Type *Ty = ArrayType::get(ElementTy, NumElements);
return getImpl(Data, Ty);
}
@@ -874,8 +858,8 @@ class BlockAddress final : public Constant {
/// 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) {
@@ -884,9 +868,8 @@ class BlockAddress final : public Constant {
};
template <>
-struct OperandTraits<BlockAddress> :
- public FixedNumOperandTraits<BlockAddress, 2> {
-};
+struct OperandTraits<BlockAddress>
+ : public FixedNumOperandTraits<BlockAddress, 2> {};
DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BlockAddress, Value)
@@ -975,17 +958,18 @@ class ConstantExpr : public Constant {
///
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);
@@ -997,8 +981,8 @@ class ConstantExpr : public Constant {
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);
@@ -1107,48 +1091,47 @@ class ConstantExpr : public Constant {
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
@@ -1178,7 +1161,7 @@ class ConstantExpr : public Constant {
/// 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,
@@ -1213,7 +1196,7 @@ class ConstantExpr : public Constant {
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,
@@ -1294,7 +1277,7 @@ class ConstantExpr : public Constant {
/// 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());
}
@@ -1334,9 +1317,8 @@ class ConstantExpr : public Constant {
};
template <>
-struct OperandTraits<ConstantExpr> :
- public VariadicOperandTraits<ConstantExpr, 1> {
-};
+struct OperandTraits<ConstantExpr>
+ : public VariadicOperandTraits<ConstantExpr, 1> {};
DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantExpr, Constant)
diff --git a/llvm/unittests/IR/ConstantsTest.cpp b/llvm/unittests/IR/ConstantsTest.cpp
index 96d3672647e8..44dbb90758ad 100644
--- a/llvm/unittests/IR/ConstantsTest.cpp
+++ b/llvm/unittests/IR/ConstantsTest.cpp
@@ -23,11 +23,11 @@ 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
@@ -136,35 +136,33 @@ TEST(ConstantsTest, PointerCast) {
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(
- ConstantExpr::getIntToPtr(K, Int32PtrTy), Int32Ptr1Ty));
- EXPECT_NE(K,
- ConstantExpr::getAddrSpaceCast(
- ConstantExpr::getIntToPtr(K, Int32Ptr1Ty), Int32PtrTy));
+ EXPECT_NE(K, ConstantExpr::getAddrSpaceCast(
+ ConstantExpr::getIntToPtr(K, Int32PtrTy), Int32Ptr1Ty));
+ EXPECT_NE(K, ConstantExpr::getAddrSpaceCast(
+ ConstantExpr::getIntToPtr(K, Int32Ptr1Ty), Int32PtrTy));
Constant *NullInt32Ptr0 = Constant::getNullValue(Int32PtrTy);
Constant *NullInt32Ptr1 = Constant::getNullValue(Int32Ptr1Ty);
@@ -199,10 +197,10 @@ TEST(ConstantsTest, AsInstructionsTest) {
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);
@@ -217,26 +215,26 @@ TEST(ConstantsTest, AsInstructionsTest) {
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>)"
+#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);
@@ -253,48 +251,50 @@ TEST(ConstantsTest, AsInstructionsTest) {
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),
+ // 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));
+ 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));
@@ -469,8 +469,8 @@ TEST(ConstantsTest, BitcastToGEP) {
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);
@@ -481,8 +481,8 @@ bool foldFuncPtrAndConstToNull(LLVMContext &Context, Module *TheModule,
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);
@@ -490,19 +490,18 @@ bool foldFuncPtrAndConstToNull(LLVMContext &Context, Module *TheModule,
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;
+ return Result;
}
TEST(ConstantsTest, FoldFunctionPtrAlignUnknownAnd2) {
@@ -525,7 +524,7 @@ TEST(ConstantsTest, DontFoldFunctionPtrAlignUnknownAnd4) {
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) {
@@ -538,9 +537,9 @@ TEST(ConstantsTest, FoldFunctionPtrAlign4) {
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));
}
@@ -579,11 +578,10 @@ TEST(ConstantsTest, FoldGlobalVariablePtr) {
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
@@ -713,5 +711,5 @@ TEST(ConstantsTest, GetSplatValueRoundTrip) {
}
}
-} // end anonymous namespace
-} // end namespace llvm
+} // end anonymous namespace
+} // end namespace llvm
More information about the llvm-commits
mailing list