Home | History | Annotate | Download | only in IR 
      1 //===- llvm/unittest/IR/InstructionsTest.cpp - Instructions 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/IR/Instructions.h"
     11 #include "llvm/ADT/STLExtras.h"
     12 #include "llvm/Analysis/ValueTracking.h"
     13 #include "llvm/IR/BasicBlock.h"
     14 #include "llvm/IR/Constants.h"
     15 #include "llvm/IR/DataLayout.h"
     16 #include "llvm/IR/DerivedTypes.h"
     17 #include "llvm/IR/Function.h"
     18 #include "llvm/IR/IRBuilder.h"
     19 #include "llvm/IR/LLVMContext.h"
     20 #include "llvm/IR/MDBuilder.h"
     21 #include "llvm/IR/Module.h"
     22 #include "llvm/IR/Operator.h"
     23 #include "gtest/gtest.h"
     24 #include <memory>
     25 
     26 namespace llvm {
     27 namespace {
     28 
     29 TEST(InstructionsTest, ReturnInst) {
     30   LLVMContext &C(getGlobalContext());
     31 
     32   // test for PR6589
     33   const ReturnInst* r0 = ReturnInst::Create(C);
     34   EXPECT_EQ(r0->getNumOperands(), 0U);
     35   EXPECT_EQ(r0->op_begin(), r0->op_end());
     36 
     37   IntegerType* Int1 = IntegerType::get(C, 1);
     38   Constant* One = ConstantInt::get(Int1, 1, true);
     39   const ReturnInst* r1 = ReturnInst::Create(C, One);
     40   EXPECT_EQ(1U, r1->getNumOperands());
     41   User::const_op_iterator b(r1->op_begin());
     42   EXPECT_NE(r1->op_end(), b);
     43   EXPECT_EQ(One, *b);
     44   EXPECT_EQ(One, r1->getOperand(0));
     45   ++b;
     46   EXPECT_EQ(r1->op_end(), b);
     47 
     48   // clean up
     49   delete r0;
     50   delete r1;
     51 }
     52 
     53 // Test fixture that provides a module and a single function within it. Useful
     54 // for tests that need to refer to the function in some way.
     55 class ModuleWithFunctionTest : public testing::Test {
     56 protected:
     57   ModuleWithFunctionTest() : M(new Module("MyModule", Ctx)) {
     58     FArgTypes.push_back(Type::getInt8Ty(Ctx));
     59     FArgTypes.push_back(Type::getInt32Ty(Ctx));
     60     FArgTypes.push_back(Type::getInt64Ty(Ctx));
     61     FunctionType *FTy =
     62         FunctionType::get(Type::getVoidTy(Ctx), FArgTypes, false);
     63     F = Function::Create(FTy, Function::ExternalLinkage, "", M.get());
     64   }
     65 
     66   LLVMContext Ctx;
     67   std::unique_ptr<Module> M;
     68   SmallVector<Type *, 3> FArgTypes;
     69   Function *F;
     70 };
     71 
     72 TEST_F(ModuleWithFunctionTest, CallInst) {
     73   Value *Args[] = {ConstantInt::get(Type::getInt8Ty(Ctx), 20),
     74                    ConstantInt::get(Type::getInt32Ty(Ctx), 9999),
     75                    ConstantInt::get(Type::getInt64Ty(Ctx), 42)};
     76   std::unique_ptr<CallInst> Call(CallInst::Create(F, Args));
     77 
     78   // Make sure iteration over a call's arguments works as expected.
     79   unsigned Idx = 0;
     80   for (Value *Arg : Call->arg_operands()) {
     81     EXPECT_EQ(FArgTypes[Idx], Arg->getType());
     82     EXPECT_EQ(Call->getArgOperand(Idx)->getType(), Arg->getType());
     83     Idx++;
     84   }
     85 }
     86 
     87 TEST_F(ModuleWithFunctionTest, InvokeInst) {
     88   BasicBlock *BB1 = BasicBlock::Create(Ctx, "", F);
     89   BasicBlock *BB2 = BasicBlock::Create(Ctx, "", F);
     90 
     91   Value *Args[] = {ConstantInt::get(Type::getInt8Ty(Ctx), 20),
     92                    ConstantInt::get(Type::getInt32Ty(Ctx), 9999),
     93                    ConstantInt::get(Type::getInt64Ty(Ctx), 42)};
     94   std::unique_ptr<InvokeInst> Invoke(InvokeInst::Create(F, BB1, BB2, Args));
     95 
     96   // Make sure iteration over invoke's arguments works as expected.
     97   unsigned Idx = 0;
     98   for (Value *Arg : Invoke->arg_operands()) {
     99     EXPECT_EQ(FArgTypes[Idx], Arg->getType());
    100     EXPECT_EQ(Invoke->getArgOperand(Idx)->getType(), Arg->getType());
    101     Idx++;
    102   }
    103 }
    104 
    105 TEST(InstructionsTest, BranchInst) {
    106   LLVMContext &C(getGlobalContext());
    107 
    108   // Make a BasicBlocks
    109   BasicBlock* bb0 = BasicBlock::Create(C);
    110   BasicBlock* bb1 = BasicBlock::Create(C);
    111 
    112   // Mandatory BranchInst
    113   const BranchInst* b0 = BranchInst::Create(bb0);
    114 
    115   EXPECT_TRUE(b0->isUnconditional());
    116   EXPECT_FALSE(b0->isConditional());
    117   EXPECT_EQ(1U, b0->getNumSuccessors());
    118 
    119   // check num operands
    120   EXPECT_EQ(1U, b0->getNumOperands());
    121 
    122   EXPECT_NE(b0->op_begin(), b0->op_end());
    123   EXPECT_EQ(b0->op_end(), std::next(b0->op_begin()));
    124 
    125   EXPECT_EQ(b0->op_end(), std::next(b0->op_begin()));
    126 
    127   IntegerType* Int1 = IntegerType::get(C, 1);
    128   Constant* One = ConstantInt::get(Int1, 1, true);
    129 
    130   // Conditional BranchInst
    131   BranchInst* b1 = BranchInst::Create(bb0, bb1, One);
    132 
    133   EXPECT_FALSE(b1->isUnconditional());
    134   EXPECT_TRUE(b1->isConditional());
    135   EXPECT_EQ(2U, b1->getNumSuccessors());
    136 
    137   // check num operands
    138   EXPECT_EQ(3U, b1->getNumOperands());
    139 
    140   User::const_op_iterator b(b1->op_begin());
    141 
    142   // check COND
    143   EXPECT_NE(b, b1->op_end());
    144   EXPECT_EQ(One, *b);
    145   EXPECT_EQ(One, b1->getOperand(0));
    146   EXPECT_EQ(One, b1->getCondition());
    147   ++b;
    148 
    149   // check ELSE
    150   EXPECT_EQ(bb1, *b);
    151   EXPECT_EQ(bb1, b1->getOperand(1));
    152   EXPECT_EQ(bb1, b1->getSuccessor(1));
    153   ++b;
    154 
    155   // check THEN
    156   EXPECT_EQ(bb0, *b);
    157   EXPECT_EQ(bb0, b1->getOperand(2));
    158   EXPECT_EQ(bb0, b1->getSuccessor(0));
    159   ++b;
    160 
    161   EXPECT_EQ(b1->op_end(), b);
    162 
    163   // clean up
    164   delete b0;
    165   delete b1;
    166 
    167   delete bb0;
    168   delete bb1;
    169 }
    170 
    171 TEST(InstructionsTest, CastInst) {
    172   LLVMContext &C(getGlobalContext());
    173 
    174   Type *Int8Ty = Type::getInt8Ty(C);
    175   Type *Int16Ty = Type::getInt16Ty(C);
    176   Type *Int32Ty = Type::getInt32Ty(C);
    177   Type *Int64Ty = Type::getInt64Ty(C);
    178   Type *V8x8Ty = VectorType::get(Int8Ty, 8);
    179   Type *V8x64Ty = VectorType::get(Int64Ty, 8);
    180   Type *X86MMXTy = Type::getX86_MMXTy(C);
    181 
    182   Type *HalfTy = Type::getHalfTy(C);
    183   Type *FloatTy = Type::getFloatTy(C);
    184   Type *DoubleTy = Type::getDoubleTy(C);
    185 
    186   Type *V2Int32Ty = VectorType::get(Int32Ty, 2);
    187   Type *V2Int64Ty = VectorType::get(Int64Ty, 2);
    188   Type *V4Int16Ty = VectorType::get(Int16Ty, 4);
    189 
    190   Type *Int32PtrTy = PointerType::get(Int32Ty, 0);
    191   Type *Int64PtrTy = PointerType::get(Int64Ty, 0);
    192 
    193   Type *Int32PtrAS1Ty = PointerType::get(Int32Ty, 1);
    194   Type *Int64PtrAS1Ty = PointerType::get(Int64Ty, 1);
    195 
    196   Type *V2Int32PtrAS1Ty = VectorType::get(Int32PtrAS1Ty, 2);
    197   Type *V2Int64PtrAS1Ty = VectorType::get(Int64PtrAS1Ty, 2);
    198   Type *V4Int32PtrAS1Ty = VectorType::get(Int32PtrAS1Ty, 4);
    199   Type *V4Int64PtrAS1Ty = VectorType::get(Int64PtrAS1Ty, 4);
    200 
    201   Type *V2Int64PtrTy = VectorType::get(Int64PtrTy, 2);
    202   Type *V2Int32PtrTy = VectorType::get(Int32PtrTy, 2);
    203   Type *V4Int32PtrTy = VectorType::get(Int32PtrTy, 4);
    204 
    205   const Constant* c8 = Constant::getNullValue(V8x8Ty);
    206   const Constant* c64 = Constant::getNullValue(V8x64Ty);
    207 
    208   const Constant *v2ptr32 = Constant::getNullValue(V2Int32PtrTy);
    209 
    210   EXPECT_TRUE(CastInst::isCastable(V8x8Ty, X86MMXTy));
    211   EXPECT_TRUE(CastInst::isCastable(X86MMXTy, V8x8Ty));
    212   EXPECT_FALSE(CastInst::isCastable(Int64Ty, X86MMXTy));
    213   EXPECT_TRUE(CastInst::isCastable(V8x64Ty, V8x8Ty));
    214   EXPECT_TRUE(CastInst::isCastable(V8x8Ty, V8x64Ty));
    215   EXPECT_EQ(CastInst::Trunc, CastInst::getCastOpcode(c64, true, V8x8Ty, true));
    216   EXPECT_EQ(CastInst::SExt, CastInst::getCastOpcode(c8, true, V8x64Ty, true));
    217 
    218   EXPECT_FALSE(CastInst::isBitCastable(V8x8Ty, X86MMXTy));
    219   EXPECT_FALSE(CastInst::isBitCastable(X86MMXTy, V8x8Ty));
    220   EXPECT_FALSE(CastInst::isBitCastable(Int64Ty, X86MMXTy));
    221   EXPECT_FALSE(CastInst::isBitCastable(V8x64Ty, V8x8Ty));
    222   EXPECT_FALSE(CastInst::isBitCastable(V8x8Ty, V8x64Ty));
    223 
    224   // Check address space casts are rejected since we don't know the sizes here
    225   EXPECT_FALSE(CastInst::isBitCastable(Int32PtrTy, Int32PtrAS1Ty));
    226   EXPECT_FALSE(CastInst::isBitCastable(Int32PtrAS1Ty, Int32PtrTy));
    227   EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrTy, V2Int32PtrAS1Ty));
    228   EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V2Int32PtrTy));
    229   EXPECT_TRUE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V2Int64PtrAS1Ty));
    230   EXPECT_TRUE(CastInst::isCastable(V2Int32PtrAS1Ty, V2Int32PtrTy));
    231   EXPECT_EQ(CastInst::AddrSpaceCast, CastInst::getCastOpcode(v2ptr32, true,
    232                                                              V2Int32PtrAS1Ty,
    233                                                              true));
    234 
    235   // Test mismatched number of elements for pointers
    236   EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V4Int64PtrAS1Ty));
    237   EXPECT_FALSE(CastInst::isBitCastable(V4Int64PtrAS1Ty, V2Int32PtrAS1Ty));
    238   EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V4Int32PtrAS1Ty));
    239   EXPECT_FALSE(CastInst::isBitCastable(Int32PtrTy, V2Int32PtrTy));
    240   EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrTy, Int32PtrTy));
    241 
    242   EXPECT_TRUE(CastInst::isBitCastable(Int32PtrTy, Int64PtrTy));
    243   EXPECT_FALSE(CastInst::isBitCastable(DoubleTy, FloatTy));
    244   EXPECT_FALSE(CastInst::isBitCastable(FloatTy, DoubleTy));
    245   EXPECT_TRUE(CastInst::isBitCastable(FloatTy, FloatTy));
    246   EXPECT_TRUE(CastInst::isBitCastable(FloatTy, FloatTy));
    247   EXPECT_TRUE(CastInst::isBitCastable(FloatTy, Int32Ty));
    248   EXPECT_TRUE(CastInst::isBitCastable(Int16Ty, HalfTy));
    249   EXPECT_TRUE(CastInst::isBitCastable(Int32Ty, FloatTy));
    250   EXPECT_TRUE(CastInst::isBitCastable(V2Int32Ty, Int64Ty));
    251 
    252   EXPECT_TRUE(CastInst::isBitCastable(V2Int32Ty, V4Int16Ty));
    253   EXPECT_FALSE(CastInst::isBitCastable(Int32Ty, Int64Ty));
    254   EXPECT_FALSE(CastInst::isBitCastable(Int64Ty, Int32Ty));
    255 
    256   EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrTy, Int64Ty));
    257   EXPECT_FALSE(CastInst::isBitCastable(Int64Ty, V2Int32PtrTy));
    258   EXPECT_TRUE(CastInst::isBitCastable(V2Int64PtrTy, V2Int32PtrTy));
    259   EXPECT_TRUE(CastInst::isBitCastable(V2Int32PtrTy, V2Int64PtrTy));
    260   EXPECT_FALSE(CastInst::isBitCastable(V2Int32Ty, V2Int64Ty));
    261   EXPECT_FALSE(CastInst::isBitCastable(V2Int64Ty, V2Int32Ty));
    262 
    263 
    264   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
    265                                      Constant::getNullValue(V4Int32PtrTy),
    266                                      V2Int32PtrTy));
    267   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
    268                                      Constant::getNullValue(V2Int32PtrTy),
    269                                      V4Int32PtrTy));
    270 
    271   EXPECT_FALSE(CastInst::castIsValid(Instruction::AddrSpaceCast,
    272                                      Constant::getNullValue(V4Int32PtrAS1Ty),
    273                                      V2Int32PtrTy));
    274   EXPECT_FALSE(CastInst::castIsValid(Instruction::AddrSpaceCast,
    275                                      Constant::getNullValue(V2Int32PtrTy),
    276                                      V4Int32PtrAS1Ty));
    277 
    278 
    279   // Check that assertion is not hit when creating a cast with a vector of
    280   // pointers
    281   // First form
    282   BasicBlock *BB = BasicBlock::Create(C);
    283   Constant *NullV2I32Ptr = Constant::getNullValue(V2Int32PtrTy);
    284   CastInst::CreatePointerCast(NullV2I32Ptr, V2Int32Ty, "foo", BB);
    285 
    286   // Second form
    287   CastInst::CreatePointerCast(NullV2I32Ptr, V2Int32Ty);
    288 }
    289 
    290 TEST(InstructionsTest, VectorGep) {
    291   LLVMContext &C(getGlobalContext());
    292 
    293   // Type Definitions
    294   PointerType *Ptri8Ty = PointerType::get(IntegerType::get(C, 8), 0);
    295   PointerType *Ptri32Ty = PointerType::get(IntegerType::get(C, 32), 0);
    296 
    297   VectorType *V2xi8PTy = VectorType::get(Ptri8Ty, 2);
    298   VectorType *V2xi32PTy = VectorType::get(Ptri32Ty, 2);
    299 
    300   // Test different aspects of the vector-of-pointers type
    301   // and GEPs which use this type.
    302   ConstantInt *Ci32a = ConstantInt::get(C, APInt(32, 1492));
    303   ConstantInt *Ci32b = ConstantInt::get(C, APInt(32, 1948));
    304   std::vector<Constant*> ConstVa(2, Ci32a);
    305   std::vector<Constant*> ConstVb(2, Ci32b);
    306   Constant *C2xi32a = ConstantVector::get(ConstVa);
    307   Constant *C2xi32b = ConstantVector::get(ConstVb);
    308 
    309   CastInst *PtrVecA = new IntToPtrInst(C2xi32a, V2xi32PTy);
    310   CastInst *PtrVecB = new IntToPtrInst(C2xi32b, V2xi32PTy);
    311 
    312   ICmpInst *ICmp0 = new ICmpInst(ICmpInst::ICMP_SGT, PtrVecA, PtrVecB);
    313   ICmpInst *ICmp1 = new ICmpInst(ICmpInst::ICMP_ULT, PtrVecA, PtrVecB);
    314   EXPECT_NE(ICmp0, ICmp1); // suppress warning.
    315 
    316   BasicBlock* BB0 = BasicBlock::Create(C);
    317   // Test InsertAtEnd ICmpInst constructor.
    318   ICmpInst *ICmp2 = new ICmpInst(*BB0, ICmpInst::ICMP_SGE, PtrVecA, PtrVecB);
    319   EXPECT_NE(ICmp0, ICmp2); // suppress warning.
    320 
    321   GetElementPtrInst *Gep0 = GetElementPtrInst::Create(PtrVecA, C2xi32a);
    322   GetElementPtrInst *Gep1 = GetElementPtrInst::Create(PtrVecA, C2xi32b);
    323   GetElementPtrInst *Gep2 = GetElementPtrInst::Create(PtrVecB, C2xi32a);
    324   GetElementPtrInst *Gep3 = GetElementPtrInst::Create(PtrVecB, C2xi32b);
    325 
    326   CastInst *BTC0 = new BitCastInst(Gep0, V2xi8PTy);
    327   CastInst *BTC1 = new BitCastInst(Gep1, V2xi8PTy);
    328   CastInst *BTC2 = new BitCastInst(Gep2, V2xi8PTy);
    329   CastInst *BTC3 = new BitCastInst(Gep3, V2xi8PTy);
    330 
    331   Value *S0 = BTC0->stripPointerCasts();
    332   Value *S1 = BTC1->stripPointerCasts();
    333   Value *S2 = BTC2->stripPointerCasts();
    334   Value *S3 = BTC3->stripPointerCasts();
    335 
    336   EXPECT_NE(S0, Gep0);
    337   EXPECT_NE(S1, Gep1);
    338   EXPECT_NE(S2, Gep2);
    339   EXPECT_NE(S3, Gep3);
    340 
    341   int64_t Offset;
    342   DataLayout TD("e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f3"
    343                 "2:32:32-f64:64:64-v64:64:64-v128:128:128-a:0:64-s:64:64-f80"
    344                 ":128:128-n8:16:32:64-S128");
    345   // Make sure we don't crash
    346   GetPointerBaseWithConstantOffset(Gep0, Offset, &TD);
    347   GetPointerBaseWithConstantOffset(Gep1, Offset, &TD);
    348   GetPointerBaseWithConstantOffset(Gep2, Offset, &TD);
    349   GetPointerBaseWithConstantOffset(Gep3, Offset, &TD);
    350 
    351   // Gep of Geps
    352   GetElementPtrInst *GepII0 = GetElementPtrInst::Create(Gep0, C2xi32b);
    353   GetElementPtrInst *GepII1 = GetElementPtrInst::Create(Gep1, C2xi32a);
    354   GetElementPtrInst *GepII2 = GetElementPtrInst::Create(Gep2, C2xi32b);
    355   GetElementPtrInst *GepII3 = GetElementPtrInst::Create(Gep3, C2xi32a);
    356 
    357   EXPECT_EQ(GepII0->getNumIndices(), 1u);
    358   EXPECT_EQ(GepII1->getNumIndices(), 1u);
    359   EXPECT_EQ(GepII2->getNumIndices(), 1u);
    360   EXPECT_EQ(GepII3->getNumIndices(), 1u);
    361 
    362   EXPECT_FALSE(GepII0->hasAllZeroIndices());
    363   EXPECT_FALSE(GepII1->hasAllZeroIndices());
    364   EXPECT_FALSE(GepII2->hasAllZeroIndices());
    365   EXPECT_FALSE(GepII3->hasAllZeroIndices());
    366 
    367   delete GepII0;
    368   delete GepII1;
    369   delete GepII2;
    370   delete GepII3;
    371 
    372   delete BTC0;
    373   delete BTC1;
    374   delete BTC2;
    375   delete BTC3;
    376 
    377   delete Gep0;
    378   delete Gep1;
    379   delete Gep2;
    380   delete Gep3;
    381 
    382   ICmp2->eraseFromParent();
    383   delete BB0;
    384 
    385   delete ICmp0;
    386   delete ICmp1;
    387   delete PtrVecA;
    388   delete PtrVecB;
    389 }
    390 
    391 TEST(InstructionsTest, FPMathOperator) {
    392   LLVMContext &Context = getGlobalContext();
    393   IRBuilder<> Builder(Context);
    394   MDBuilder MDHelper(Context);
    395   Instruction *I = Builder.CreatePHI(Builder.getDoubleTy(), 0);
    396   MDNode *MD1 = MDHelper.createFPMath(1.0);
    397   Value *V1 = Builder.CreateFAdd(I, I, "", MD1);
    398   EXPECT_TRUE(isa<FPMathOperator>(V1));
    399   FPMathOperator *O1 = cast<FPMathOperator>(V1);
    400   EXPECT_EQ(O1->getFPAccuracy(), 1.0);
    401   delete V1;
    402   delete I;
    403 }
    404 
    405 
    406 TEST(InstructionsTest, isEliminableCastPair) {
    407   LLVMContext &C(getGlobalContext());
    408 
    409   Type* Int16Ty = Type::getInt16Ty(C);
    410   Type* Int32Ty = Type::getInt32Ty(C);
    411   Type* Int64Ty = Type::getInt64Ty(C);
    412   Type* Int64PtrTy = Type::getInt64PtrTy(C);
    413 
    414   // Source and destination pointers have same size -> bitcast.
    415   EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::PtrToInt,
    416                                            CastInst::IntToPtr,
    417                                            Int64PtrTy, Int64Ty, Int64PtrTy,
    418                                            Int32Ty, nullptr, Int32Ty),
    419             CastInst::BitCast);
    420 
    421   // Source and destination have unknown sizes, but the same address space and
    422   // the intermediate int is the maximum pointer size -> bitcast
    423   EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::PtrToInt,
    424                                            CastInst::IntToPtr,
    425                                            Int64PtrTy, Int64Ty, Int64PtrTy,
    426                                            nullptr, nullptr, nullptr),
    427             CastInst::BitCast);
    428 
    429   // Source and destination have unknown sizes, but the same address space and
    430   // the intermediate int is not the maximum pointer size -> nothing
    431   EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::PtrToInt,
    432                                            CastInst::IntToPtr,
    433                                            Int64PtrTy, Int32Ty, Int64PtrTy,
    434                                            nullptr, nullptr, nullptr),
    435             0U);
    436 
    437   // Middle pointer big enough -> bitcast.
    438   EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr,
    439                                            CastInst::PtrToInt,
    440                                            Int64Ty, Int64PtrTy, Int64Ty,
    441                                            nullptr, Int64Ty, nullptr),
    442             CastInst::BitCast);
    443 
    444   // Middle pointer too small -> fail.
    445   EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr,
    446                                            CastInst::PtrToInt,
    447                                            Int64Ty, Int64PtrTy, Int64Ty,
    448                                            nullptr, Int32Ty, nullptr),
    449             0U);
    450 
    451   // Test that we don't eliminate bitcasts between different address spaces,
    452   // or if we don't have available pointer size information.
    453   DataLayout DL("e-p:32:32:32-p1:16:16:16-p2:64:64:64-i1:8:8-i8:8:8-i16:16:16"
    454                 "-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64"
    455                 "-v128:128:128-a:0:64-s:64:64-f80:128:128-n8:16:32:64-S128");
    456 
    457   Type* Int64PtrTyAS1 = Type::getInt64PtrTy(C, 1);
    458   Type* Int64PtrTyAS2 = Type::getInt64PtrTy(C, 2);
    459 
    460   IntegerType *Int16SizePtr = DL.getIntPtrType(C, 1);
    461   IntegerType *Int64SizePtr = DL.getIntPtrType(C, 2);
    462 
    463   // Cannot simplify inttoptr, addrspacecast
    464   EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr,
    465                                            CastInst::AddrSpaceCast,
    466                                            Int16Ty, Int64PtrTyAS1, Int64PtrTyAS2,
    467                                            nullptr, Int16SizePtr, Int64SizePtr),
    468             0U);
    469 
    470   // Cannot simplify addrspacecast, ptrtoint
    471   EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::AddrSpaceCast,
    472                                            CastInst::PtrToInt,
    473                                            Int64PtrTyAS1, Int64PtrTyAS2, Int16Ty,
    474                                            Int64SizePtr, Int16SizePtr, nullptr),
    475             0U);
    476 
    477   // Pass since the bitcast address spaces are the same
    478   EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr,
    479                                            CastInst::BitCast,
    480                                            Int16Ty, Int64PtrTyAS1, Int64PtrTyAS1,
    481                                            nullptr, nullptr, nullptr),
    482             CastInst::IntToPtr);
    483 
    484 }
    485 
    486 TEST(InstructionsTest, CloneCall) {
    487   LLVMContext &C(getGlobalContext());
    488   Type *Int32Ty = Type::getInt32Ty(C);
    489   Type *ArgTys[] = {Int32Ty, Int32Ty, Int32Ty};
    490   Type *FnTy = FunctionType::get(Int32Ty, ArgTys, /*isVarArg=*/false);
    491   Value *Callee = Constant::getNullValue(FnTy->getPointerTo());
    492   Value *Args[] = {
    493     ConstantInt::get(Int32Ty, 1),
    494     ConstantInt::get(Int32Ty, 2),
    495     ConstantInt::get(Int32Ty, 3)
    496   };
    497   std::unique_ptr<CallInst> Call(CallInst::Create(Callee, Args, "result"));
    498 
    499   // Test cloning the tail call kind.
    500   CallInst::TailCallKind Kinds[] = {CallInst::TCK_None, CallInst::TCK_Tail,
    501                                     CallInst::TCK_MustTail};
    502   for (CallInst::TailCallKind TCK : Kinds) {
    503     Call->setTailCallKind(TCK);
    504     std::unique_ptr<CallInst> Clone(cast<CallInst>(Call->clone()));
    505     EXPECT_EQ(Call->getTailCallKind(), Clone->getTailCallKind());
    506   }
    507   Call->setTailCallKind(CallInst::TCK_None);
    508 
    509   // Test cloning an attribute.
    510   {
    511     AttrBuilder AB;
    512     AB.addAttribute(Attribute::ReadOnly);
    513     Call->setAttributes(AttributeSet::get(C, AttributeSet::FunctionIndex, AB));
    514     std::unique_ptr<CallInst> Clone(cast<CallInst>(Call->clone()));
    515     EXPECT_TRUE(Clone->onlyReadsMemory());
    516   }
    517 }
    518 
    519 }  // end anonymous namespace
    520 }  // end namespace llvm
    521 
    522 
    523