Home | History | Annotate | Download | only in IR 
      1 //===- llvm/unittest/IR/ConstantsTest.cpp - Constants unit tests ----------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 #include "llvm/AsmParser/Parser.h"
     11 #include "llvm/IR/Constants.h"
     12 #include "llvm/IR/DerivedTypes.h"
     13 #include "llvm/IR/InstrTypes.h"
     14 #include "llvm/IR/Instruction.h"
     15 #include "llvm/IR/LLVMContext.h"
     16 #include "llvm/IR/Module.h"
     17 #include "llvm/Support/SourceMgr.h"
     18 #include "llvm-c/Core.h"
     19 #include "gtest/gtest.h"
     20 
     21 namespace llvm {
     22 namespace {
     23 
     24 TEST(ConstantsTest, Integer_i1) {
     25   LLVMContext Context;
     26   IntegerType *Int1 = IntegerType::get(Context, 1);
     27   Constant* One = ConstantInt::get(Int1, 1, true);
     28   Constant* Zero = ConstantInt::get(Int1, 0);
     29   Constant* NegOne = ConstantInt::get(Int1, static_cast<uint64_t>(-1), true);
     30   EXPECT_EQ(NegOne, ConstantInt::getSigned(Int1, -1));
     31   Constant* Undef = UndefValue::get(Int1);
     32 
     33   // Input:  @b = constant i1 add(i1 1 , i1 1)
     34   // Output: @b = constant i1 false
     35   EXPECT_EQ(Zero, ConstantExpr::getAdd(One, One));
     36 
     37   // @c = constant i1 add(i1 -1, i1 1)
     38   // @c = constant i1 false
     39   EXPECT_EQ(Zero, ConstantExpr::getAdd(NegOne, One));
     40 
     41   // @d = constant i1 add(i1 -1, i1 -1)
     42   // @d = constant i1 false
     43   EXPECT_EQ(Zero, ConstantExpr::getAdd(NegOne, NegOne));
     44 
     45   // @e = constant i1 sub(i1 -1, i1 1)
     46   // @e = constant i1 false
     47   EXPECT_EQ(Zero, ConstantExpr::getSub(NegOne, One));
     48 
     49   // @f = constant i1 sub(i1 1 , i1 -1)
     50   // @f = constant i1 false
     51   EXPECT_EQ(Zero, ConstantExpr::getSub(One, NegOne));
     52 
     53   // @g = constant i1 sub(i1 1 , i1 1)
     54   // @g = constant i1 false
     55   EXPECT_EQ(Zero, ConstantExpr::getSub(One, One));
     56 
     57   // @h = constant i1 shl(i1 1 , i1 1)  ; undefined
     58   // @h = constant i1 undef
     59   EXPECT_EQ(Undef, ConstantExpr::getShl(One, One));
     60 
     61   // @i = constant i1 shl(i1 1 , i1 0)
     62   // @i = constant i1 true
     63   EXPECT_EQ(One, ConstantExpr::getShl(One, Zero));
     64 
     65   // @j = constant i1 lshr(i1 1, i1 1)  ; undefined
     66   // @j = constant i1 undef
     67   EXPECT_EQ(Undef, ConstantExpr::getLShr(One, One));
     68 
     69   // @m = constant i1 ashr(i1 1, i1 1)  ; undefined
     70   // @m = constant i1 undef
     71   EXPECT_EQ(Undef, ConstantExpr::getAShr(One, One));
     72 
     73   // @n = constant i1 mul(i1 -1, i1 1)
     74   // @n = constant i1 true
     75   EXPECT_EQ(One, ConstantExpr::getMul(NegOne, One));
     76 
     77   // @o = constant i1 sdiv(i1 -1, i1 1) ; overflow
     78   // @o = constant i1 true
     79   EXPECT_EQ(One, ConstantExpr::getSDiv(NegOne, One));
     80 
     81   // @p = constant i1 sdiv(i1 1 , i1 -1); overflow
     82   // @p = constant i1 true
     83   EXPECT_EQ(One, ConstantExpr::getSDiv(One, NegOne));
     84 
     85   // @q = constant i1 udiv(i1 -1, i1 1)
     86   // @q = constant i1 true
     87   EXPECT_EQ(One, ConstantExpr::getUDiv(NegOne, One));
     88 
     89   // @r = constant i1 udiv(i1 1, i1 -1)
     90   // @r = constant i1 true
     91   EXPECT_EQ(One, ConstantExpr::getUDiv(One, NegOne));
     92 
     93   // @s = constant i1 srem(i1 -1, i1 1) ; overflow
     94   // @s = constant i1 false
     95   EXPECT_EQ(Zero, ConstantExpr::getSRem(NegOne, One));
     96 
     97   // @t = constant i1 urem(i1 -1, i1 1)
     98   // @t = constant i1 false
     99   EXPECT_EQ(Zero, ConstantExpr::getURem(NegOne, One));
    100 
    101   // @u = constant i1 srem(i1  1, i1 -1) ; overflow
    102   // @u = constant i1 false
    103   EXPECT_EQ(Zero, ConstantExpr::getSRem(One, NegOne));
    104 }
    105 
    106 TEST(ConstantsTest, IntSigns) {
    107   LLVMContext Context;
    108   IntegerType *Int8Ty = Type::getInt8Ty(Context);
    109   EXPECT_EQ(100, ConstantInt::get(Int8Ty, 100, false)->getSExtValue());
    110   EXPECT_EQ(100, ConstantInt::get(Int8Ty, 100, true)->getSExtValue());
    111   EXPECT_EQ(100, ConstantInt::getSigned(Int8Ty, 100)->getSExtValue());
    112   EXPECT_EQ(-50, ConstantInt::get(Int8Ty, 206)->getSExtValue());
    113   EXPECT_EQ(-50, ConstantInt::getSigned(Int8Ty, -50)->getSExtValue());
    114   EXPECT_EQ(206U, ConstantInt::getSigned(Int8Ty, -50)->getZExtValue());
    115 
    116   // Overflow is handled by truncation.
    117   EXPECT_EQ(0x3b, ConstantInt::get(Int8Ty, 0x13b)->getSExtValue());
    118 }
    119 
    120 TEST(ConstantsTest, FP128Test) {
    121   LLVMContext Context;
    122   Type *FP128Ty = Type::getFP128Ty(Context);
    123 
    124   IntegerType *Int128Ty = Type::getIntNTy(Context, 128);
    125   Constant *Zero128 = Constant::getNullValue(Int128Ty);
    126   Constant *X = ConstantExpr::getUIToFP(Zero128, FP128Ty);
    127   EXPECT_TRUE(isa<ConstantFP>(X));
    128 }
    129 
    130 TEST(ConstantsTest, PointerCast) {
    131   LLVMContext C;
    132   Type *Int8PtrTy = Type::getInt8PtrTy(C);
    133   Type *Int32PtrTy = Type::getInt32PtrTy(C);
    134   Type *Int64Ty = Type::getInt64Ty(C);
    135   VectorType *Int8PtrVecTy = VectorType::get(Int8PtrTy, 4);
    136   VectorType *Int32PtrVecTy = VectorType::get(Int32PtrTy, 4);
    137   VectorType *Int64VecTy = VectorType::get(Int64Ty, 4);
    138 
    139   // ptrtoint i8* to i64
    140   EXPECT_EQ(Constant::getNullValue(Int64Ty),
    141             ConstantExpr::getPointerCast(
    142               Constant::getNullValue(Int8PtrTy), Int64Ty));
    143 
    144   // bitcast i8* to i32*
    145   EXPECT_EQ(Constant::getNullValue(Int32PtrTy),
    146             ConstantExpr::getPointerCast(
    147               Constant::getNullValue(Int8PtrTy), Int32PtrTy));
    148 
    149   // ptrtoint <4 x i8*> to <4 x i64>
    150   EXPECT_EQ(Constant::getNullValue(Int64VecTy),
    151             ConstantExpr::getPointerCast(
    152               Constant::getNullValue(Int8PtrVecTy), Int64VecTy));
    153 
    154   // bitcast <4 x i8*> to <4 x i32*>
    155   EXPECT_EQ(Constant::getNullValue(Int32PtrVecTy),
    156             ConstantExpr::getPointerCast(
    157               Constant::getNullValue(Int8PtrVecTy), Int32PtrVecTy));
    158 
    159   Type *Int32Ptr1Ty = Type::getInt32PtrTy(C, 1);
    160   ConstantInt *K = ConstantInt::get(Type::getInt64Ty(C), 1234);
    161 
    162   // Make sure that addrspacecast of inttoptr is not folded away.
    163   EXPECT_NE(K,
    164             ConstantExpr::getAddrSpaceCast(
    165               ConstantExpr::getIntToPtr(K, Int32PtrTy), Int32Ptr1Ty));
    166   EXPECT_NE(K,
    167             ConstantExpr::getAddrSpaceCast(
    168               ConstantExpr::getIntToPtr(K, Int32Ptr1Ty), Int32PtrTy));
    169 
    170   Constant *NullInt32Ptr0 = Constant::getNullValue(Int32PtrTy);
    171   Constant *NullInt32Ptr1 = Constant::getNullValue(Int32Ptr1Ty);
    172 
    173   // Make sure that addrspacecast of null is not folded away.
    174   EXPECT_NE(Constant::getNullValue(Int32PtrTy),
    175             ConstantExpr::getAddrSpaceCast(NullInt32Ptr0, Int32Ptr1Ty));
    176 
    177   EXPECT_NE(Constant::getNullValue(Int32Ptr1Ty),
    178             ConstantExpr::getAddrSpaceCast(NullInt32Ptr1, Int32PtrTy));
    179 }
    180 
    181 #define CHECK(x, y) {                                         		\
    182     std::string __s;                                            	\
    183     raw_string_ostream __o(__s);                                	\
    184     Instruction *__I = cast<ConstantExpr>(x)->getAsInstruction();	\
    185     __I->print(__o);      						\
    186     delete __I; 							\
    187     __o.flush();                                                	\
    188     EXPECT_EQ(std::string("  <badref> = " y), __s);             	\
    189   }
    190 
    191 TEST(ConstantsTest, AsInstructionsTest) {
    192   LLVMContext Context;
    193   std::unique_ptr<Module> M(new Module("MyModule", Context));
    194 
    195   Type *Int64Ty = Type::getInt64Ty(Context);
    196   Type *Int32Ty = Type::getInt32Ty(Context);
    197   Type *Int16Ty = Type::getInt16Ty(Context);
    198   Type *Int1Ty = Type::getInt1Ty(Context);
    199   Type *FloatTy = Type::getFloatTy(Context);
    200   Type *DoubleTy = Type::getDoubleTy(Context);
    201 
    202   Constant *Global = M->getOrInsertGlobal("dummy",
    203                                          PointerType::getUnqual(Int32Ty));
    204   Constant *Global2 = M->getOrInsertGlobal("dummy2",
    205                                          PointerType::getUnqual(Int32Ty));
    206 
    207   Constant *P0 = ConstantExpr::getPtrToInt(Global, Int32Ty);
    208   Constant *P1 = ConstantExpr::getUIToFP(P0, FloatTy);
    209   Constant *P2 = ConstantExpr::getUIToFP(P0, DoubleTy);
    210   Constant *P3 = ConstantExpr::getTrunc(P0, Int1Ty);
    211   Constant *P4 = ConstantExpr::getPtrToInt(Global2, Int32Ty);
    212   Constant *P5 = ConstantExpr::getUIToFP(P4, FloatTy);
    213   Constant *P6 = ConstantExpr::getBitCast(P4, VectorType::get(Int16Ty, 2));
    214 
    215   Constant *One = ConstantInt::get(Int32Ty, 1);
    216   Constant *Two = ConstantInt::get(Int64Ty, 2);
    217   Constant *Big = ConstantInt::get(Context, APInt{256, uint64_t(-1), true});
    218   Constant *Elt = ConstantInt::get(Int16Ty, 2015);
    219   Constant *Undef16  = UndefValue::get(Int16Ty);
    220   Constant *Undef64  = UndefValue::get(Int64Ty);
    221   Constant *UndefV16 = UndefValue::get(P6->getType());
    222 
    223   #define P0STR "ptrtoint (i32** @dummy to i32)"
    224   #define P1STR "uitofp (i32 ptrtoint (i32** @dummy to i32) to float)"
    225   #define P2STR "uitofp (i32 ptrtoint (i32** @dummy to i32) to double)"
    226   #define P3STR "ptrtoint (i32** @dummy to i1)"
    227   #define P4STR "ptrtoint (i32** @dummy2 to i32)"
    228   #define P5STR "uitofp (i32 ptrtoint (i32** @dummy2 to i32) to float)"
    229   #define P6STR "bitcast (i32 ptrtoint (i32** @dummy2 to i32) to <2 x i16>)"
    230 
    231   CHECK(ConstantExpr::getNeg(P0), "sub i32 0, " P0STR);
    232   CHECK(ConstantExpr::getFNeg(P1), "fsub float -0.000000e+00, " P1STR);
    233   CHECK(ConstantExpr::getNot(P0), "xor i32 " P0STR ", -1");
    234   CHECK(ConstantExpr::getAdd(P0, P0), "add i32 " P0STR ", " P0STR);
    235   CHECK(ConstantExpr::getAdd(P0, P0, false, true), "add nsw i32 " P0STR ", "
    236         P0STR);
    237   CHECK(ConstantExpr::getAdd(P0, P0, true, true), "add nuw nsw i32 " P0STR ", "
    238         P0STR);
    239   CHECK(ConstantExpr::getFAdd(P1, P1), "fadd float " P1STR ", " P1STR);
    240   CHECK(ConstantExpr::getSub(P0, P0), "sub i32 " P0STR ", " P0STR);
    241   CHECK(ConstantExpr::getFSub(P1, P1), "fsub float " P1STR ", " P1STR);
    242   CHECK(ConstantExpr::getMul(P0, P0), "mul i32 " P0STR ", " P0STR);
    243   CHECK(ConstantExpr::getFMul(P1, P1), "fmul float " P1STR ", " P1STR);
    244   CHECK(ConstantExpr::getUDiv(P0, P0), "udiv i32 " P0STR ", " P0STR);
    245   CHECK(ConstantExpr::getSDiv(P0, P0), "sdiv i32 " P0STR ", " P0STR);
    246   CHECK(ConstantExpr::getFDiv(P1, P1), "fdiv float " P1STR ", " P1STR);
    247   CHECK(ConstantExpr::getURem(P0, P0), "urem i32 " P0STR ", " P0STR);
    248   CHECK(ConstantExpr::getSRem(P0, P0), "srem i32 " P0STR ", " P0STR);
    249   CHECK(ConstantExpr::getFRem(P1, P1), "frem float " P1STR ", " P1STR);
    250   CHECK(ConstantExpr::getAnd(P0, P0), "and i32 " P0STR ", " P0STR);
    251   CHECK(ConstantExpr::getOr(P0, P0), "or i32 " P0STR ", " P0STR);
    252   CHECK(ConstantExpr::getXor(P0, P0), "xor i32 " P0STR ", " P0STR);
    253   CHECK(ConstantExpr::getShl(P0, P0), "shl i32 " P0STR ", " P0STR);
    254   CHECK(ConstantExpr::getShl(P0, P0, true), "shl nuw i32 " P0STR ", " P0STR);
    255   CHECK(ConstantExpr::getShl(P0, P0, false, true), "shl nsw i32 " P0STR ", "
    256         P0STR);
    257   CHECK(ConstantExpr::getLShr(P0, P0, false), "lshr i32 " P0STR ", " P0STR);
    258   CHECK(ConstantExpr::getLShr(P0, P0, true), "lshr exact i32 " P0STR ", " P0STR);
    259   CHECK(ConstantExpr::getAShr(P0, P0, false), "ashr i32 " P0STR ", " P0STR);
    260   CHECK(ConstantExpr::getAShr(P0, P0, true), "ashr exact i32 " P0STR ", " P0STR);
    261 
    262   CHECK(ConstantExpr::getSExt(P0, Int64Ty), "sext i32 " P0STR " to i64");
    263   CHECK(ConstantExpr::getZExt(P0, Int64Ty), "zext i32 " P0STR " to i64");
    264   CHECK(ConstantExpr::getFPTrunc(P2, FloatTy), "fptrunc double " P2STR
    265         " to float");
    266   CHECK(ConstantExpr::getFPExtend(P1, DoubleTy), "fpext float " P1STR
    267         " to double");
    268 
    269   CHECK(ConstantExpr::getExactUDiv(P0, P0), "udiv exact i32 " P0STR ", " P0STR);
    270 
    271   CHECK(ConstantExpr::getSelect(P3, P0, P4), "select i1 " P3STR ", i32 " P0STR
    272         ", i32 " P4STR);
    273   CHECK(ConstantExpr::getICmp(CmpInst::ICMP_EQ, P0, P4), "icmp eq i32 " P0STR
    274         ", " P4STR);
    275   CHECK(ConstantExpr::getFCmp(CmpInst::FCMP_ULT, P1, P5), "fcmp ult float "
    276         P1STR ", " P5STR);
    277 
    278   std::vector<Constant*> V;
    279   V.push_back(One);
    280   // FIXME: getGetElementPtr() actually creates an inbounds ConstantGEP,
    281   //        not a normal one!
    282   //CHECK(ConstantExpr::getGetElementPtr(Global, V, false),
    283   //      "getelementptr i32*, i32** @dummy, i32 1");
    284   CHECK(ConstantExpr::getInBoundsGetElementPtr(PointerType::getUnqual(Int32Ty),
    285                                                Global, V),
    286         "getelementptr inbounds i32*, i32** @dummy, i32 1");
    287 
    288   CHECK(ConstantExpr::getExtractElement(P6, One), "extractelement <2 x i16> "
    289         P6STR ", i32 1");
    290 
    291   EXPECT_EQ(Undef16, ConstantExpr::getExtractElement(P6, Two));
    292   EXPECT_EQ(Undef16, ConstantExpr::getExtractElement(P6, Big));
    293   EXPECT_EQ(Undef16, ConstantExpr::getExtractElement(P6, Undef64));
    294 
    295   EXPECT_EQ(Elt, ConstantExpr::getExtractElement(
    296                  ConstantExpr::getInsertElement(P6, Elt, One), One));
    297   EXPECT_EQ(UndefV16, ConstantExpr::getInsertElement(P6, Elt, Two));
    298   EXPECT_EQ(UndefV16, ConstantExpr::getInsertElement(P6, Elt, Big));
    299   EXPECT_EQ(UndefV16, ConstantExpr::getInsertElement(P6, Elt, Undef64));
    300 }
    301 
    302 #ifdef GTEST_HAS_DEATH_TEST
    303 #ifndef NDEBUG
    304 TEST(ConstantsTest, ReplaceWithConstantTest) {
    305   LLVMContext Context;
    306   std::unique_ptr<Module> M(new Module("MyModule", Context));
    307 
    308   Type *Int32Ty = Type::getInt32Ty(Context);
    309   Constant *One = ConstantInt::get(Int32Ty, 1);
    310 
    311   Constant *Global =
    312       M->getOrInsertGlobal("dummy", PointerType::getUnqual(Int32Ty));
    313   Constant *GEP = ConstantExpr::getGetElementPtr(
    314       PointerType::getUnqual(Int32Ty), Global, One);
    315   EXPECT_DEATH(Global->replaceAllUsesWith(GEP),
    316                "this->replaceAllUsesWith\\(expr\\(this\\)\\) is NOT valid!");
    317 }
    318 
    319 #endif
    320 #endif
    321 
    322 #undef CHECK
    323 
    324 TEST(ConstantsTest, ConstantArrayReplaceWithConstant) {
    325   LLVMContext Context;
    326   std::unique_ptr<Module> M(new Module("MyModule", Context));
    327 
    328   Type *IntTy = Type::getInt8Ty(Context);
    329   ArrayType *ArrayTy = ArrayType::get(IntTy, 2);
    330   Constant *A01Vals[2] = {ConstantInt::get(IntTy, 0),
    331                           ConstantInt::get(IntTy, 1)};
    332   Constant *A01 = ConstantArray::get(ArrayTy, A01Vals);
    333 
    334   Constant *Global = new GlobalVariable(*M, IntTy, false,
    335                                         GlobalValue::ExternalLinkage, nullptr);
    336   Constant *GlobalInt = ConstantExpr::getPtrToInt(Global, IntTy);
    337   Constant *A0GVals[2] = {ConstantInt::get(IntTy, 0), GlobalInt};
    338   Constant *A0G = ConstantArray::get(ArrayTy, A0GVals);
    339   ASSERT_NE(A01, A0G);
    340 
    341   GlobalVariable *RefArray =
    342       new GlobalVariable(*M, ArrayTy, false, GlobalValue::ExternalLinkage, A0G);
    343   ASSERT_EQ(A0G, RefArray->getInitializer());
    344 
    345   GlobalInt->replaceAllUsesWith(ConstantInt::get(IntTy, 1));
    346   ASSERT_EQ(A01, RefArray->getInitializer());
    347 }
    348 
    349 TEST(ConstantsTest, ConstantExprReplaceWithConstant) {
    350   LLVMContext Context;
    351   std::unique_ptr<Module> M(new Module("MyModule", Context));
    352 
    353   Type *IntTy = Type::getInt8Ty(Context);
    354   Constant *G1 = new GlobalVariable(*M, IntTy, false,
    355                                     GlobalValue::ExternalLinkage, nullptr);
    356   Constant *G2 = new GlobalVariable(*M, IntTy, false,
    357                                     GlobalValue::ExternalLinkage, nullptr);
    358   ASSERT_NE(G1, G2);
    359 
    360   Constant *Int1 = ConstantExpr::getPtrToInt(G1, IntTy);
    361   Constant *Int2 = ConstantExpr::getPtrToInt(G2, IntTy);
    362   ASSERT_NE(Int1, Int2);
    363 
    364   GlobalVariable *Ref =
    365       new GlobalVariable(*M, IntTy, false, GlobalValue::ExternalLinkage, Int1);
    366   ASSERT_EQ(Int1, Ref->getInitializer());
    367 
    368   G1->replaceAllUsesWith(G2);
    369   ASSERT_EQ(Int2, Ref->getInitializer());
    370 }
    371 
    372 TEST(ConstantsTest, GEPReplaceWithConstant) {
    373   LLVMContext Context;
    374   std::unique_ptr<Module> M(new Module("MyModule", Context));
    375 
    376   Type *IntTy = Type::getInt32Ty(Context);
    377   Type *PtrTy = PointerType::get(IntTy, 0);
    378   auto *C1 = ConstantInt::get(IntTy, 1);
    379   auto *Placeholder = new GlobalVariable(
    380       *M, IntTy, false, GlobalValue::ExternalWeakLinkage, nullptr);
    381   auto *GEP = ConstantExpr::getGetElementPtr(IntTy, Placeholder, C1);
    382   ASSERT_EQ(GEP->getOperand(0), Placeholder);
    383 
    384   auto *Ref =
    385       new GlobalVariable(*M, PtrTy, false, GlobalValue::ExternalLinkage, GEP);
    386   ASSERT_EQ(GEP, Ref->getInitializer());
    387 
    388   auto *Global = new GlobalVariable(*M, PtrTy, false,
    389                                     GlobalValue::ExternalLinkage, nullptr);
    390   auto *Alias = GlobalAlias::create(IntTy, 0, GlobalValue::ExternalLinkage,
    391                                     "alias", Global, M.get());
    392   Placeholder->replaceAllUsesWith(Alias);
    393   ASSERT_EQ(GEP, Ref->getInitializer());
    394   ASSERT_EQ(GEP->getOperand(0), Alias);
    395 }
    396 
    397 TEST(ConstantsTest, AliasCAPI) {
    398   LLVMContext Context;
    399   SMDiagnostic Error;
    400   std::unique_ptr<Module> M =
    401       parseAssemblyString("@g = global i32 42", Error, Context);
    402   GlobalVariable *G = M->getGlobalVariable("g");
    403   Type *I16Ty = Type::getInt16Ty(Context);
    404   Type *I16PTy = PointerType::get(I16Ty, 0);
    405   Constant *Aliasee = ConstantExpr::getBitCast(G, I16PTy);
    406   LLVMValueRef AliasRef =
    407       LLVMAddAlias(wrap(M.get()), wrap(I16PTy), wrap(Aliasee), "a");
    408   ASSERT_EQ(unwrap<GlobalAlias>(AliasRef)->getAliasee(), Aliasee);
    409 }
    410 
    411 static std::string getNameOfType(Type *T) {
    412   std::string S;
    413   raw_string_ostream RSOS(S);
    414   T->print(RSOS);
    415   return S;
    416 }
    417 
    418 TEST(ConstantsTest, BuildConstantDataArrays) {
    419   LLVMContext Context;
    420   std::unique_ptr<Module> M(new Module("MyModule", Context));
    421 
    422   for (Type *T : {Type::getInt8Ty(Context), Type::getInt16Ty(Context),
    423                   Type::getInt32Ty(Context), Type::getInt64Ty(Context)}) {
    424     ArrayType *ArrayTy = ArrayType::get(T, 2);
    425     Constant *Vals[] = {ConstantInt::get(T, 0), ConstantInt::get(T, 1)};
    426     Constant *CDV = ConstantArray::get(ArrayTy, Vals);
    427     ASSERT_TRUE(dyn_cast<ConstantDataArray>(CDV) != nullptr)
    428         << " T = " << getNameOfType(T);
    429   }
    430 
    431   for (Type *T : {Type::getHalfTy(Context), Type::getFloatTy(Context),
    432                   Type::getDoubleTy(Context)}) {
    433     ArrayType *ArrayTy = ArrayType::get(T, 2);
    434     Constant *Vals[] = {ConstantFP::get(T, 0), ConstantFP::get(T, 1)};
    435     Constant *CDV = ConstantArray::get(ArrayTy, Vals);
    436     ASSERT_TRUE(dyn_cast<ConstantDataArray>(CDV) != nullptr)
    437         << " T = " << getNameOfType(T);
    438   }
    439 }
    440 
    441 TEST(ConstantsTest, BuildConstantDataVectors) {
    442   LLVMContext Context;
    443   std::unique_ptr<Module> M(new Module("MyModule", Context));
    444 
    445   for (Type *T : {Type::getInt8Ty(Context), Type::getInt16Ty(Context),
    446                   Type::getInt32Ty(Context), Type::getInt64Ty(Context)}) {
    447     Constant *Vals[] = {ConstantInt::get(T, 0), ConstantInt::get(T, 1)};
    448     Constant *CDV = ConstantVector::get(Vals);
    449     ASSERT_TRUE(dyn_cast<ConstantDataVector>(CDV) != nullptr)
    450         << " T = " << getNameOfType(T);
    451   }
    452 
    453   for (Type *T : {Type::getHalfTy(Context), Type::getFloatTy(Context),
    454                   Type::getDoubleTy(Context)}) {
    455     Constant *Vals[] = {ConstantFP::get(T, 0), ConstantFP::get(T, 1)};
    456     Constant *CDV = ConstantVector::get(Vals);
    457     ASSERT_TRUE(dyn_cast<ConstantDataVector>(CDV) != nullptr)
    458         << " T = " << getNameOfType(T);
    459   }
    460 }
    461 
    462 TEST(ConstantsTest, BitcastToGEP) {
    463   LLVMContext Context;
    464   std::unique_ptr<Module> M(new Module("MyModule", Context));
    465 
    466   auto *i32 = Type::getInt32Ty(Context);
    467   auto *U = StructType::create(Context, "Unsized");
    468   Type *EltTys[] = {i32, U};
    469   auto *S = StructType::create(EltTys);
    470 
    471   auto *G = new GlobalVariable(*M, S, false,
    472                                GlobalValue::ExternalLinkage, nullptr);
    473   auto *PtrTy = PointerType::get(i32, 0);
    474   auto *C = ConstantExpr::getBitCast(G, PtrTy);
    475   ASSERT_EQ(dyn_cast<ConstantExpr>(C)->getOpcode(),
    476             Instruction::BitCast);
    477 }
    478 
    479 }  // end anonymous namespace
    480 }  // end namespace llvm
    481