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/IRBuilder.h" 18 #include "llvm/IR/LLVMContext.h" 19 #include "llvm/IR/MDBuilder.h" 20 #include "llvm/IR/Operator.h" 21 #include "gtest/gtest.h" 22 23 namespace llvm { 24 namespace { 25 26 TEST(InstructionsTest, ReturnInst) { 27 LLVMContext &C(getGlobalContext()); 28 29 // test for PR6589 30 const ReturnInst* r0 = ReturnInst::Create(C); 31 EXPECT_EQ(r0->getNumOperands(), 0U); 32 EXPECT_EQ(r0->op_begin(), r0->op_end()); 33 34 IntegerType* Int1 = IntegerType::get(C, 1); 35 Constant* One = ConstantInt::get(Int1, 1, true); 36 const ReturnInst* r1 = ReturnInst::Create(C, One); 37 EXPECT_EQ(1U, r1->getNumOperands()); 38 User::const_op_iterator b(r1->op_begin()); 39 EXPECT_NE(r1->op_end(), b); 40 EXPECT_EQ(One, *b); 41 EXPECT_EQ(One, r1->getOperand(0)); 42 ++b; 43 EXPECT_EQ(r1->op_end(), b); 44 45 // clean up 46 delete r0; 47 delete r1; 48 } 49 50 TEST(InstructionsTest, BranchInst) { 51 LLVMContext &C(getGlobalContext()); 52 53 // Make a BasicBlocks 54 BasicBlock* bb0 = BasicBlock::Create(C); 55 BasicBlock* bb1 = BasicBlock::Create(C); 56 57 // Mandatory BranchInst 58 const BranchInst* b0 = BranchInst::Create(bb0); 59 60 EXPECT_TRUE(b0->isUnconditional()); 61 EXPECT_FALSE(b0->isConditional()); 62 EXPECT_EQ(1U, b0->getNumSuccessors()); 63 64 // check num operands 65 EXPECT_EQ(1U, b0->getNumOperands()); 66 67 EXPECT_NE(b0->op_begin(), b0->op_end()); 68 EXPECT_EQ(b0->op_end(), llvm::next(b0->op_begin())); 69 70 EXPECT_EQ(b0->op_end(), llvm::next(b0->op_begin())); 71 72 IntegerType* Int1 = IntegerType::get(C, 1); 73 Constant* One = ConstantInt::get(Int1, 1, true); 74 75 // Conditional BranchInst 76 BranchInst* b1 = BranchInst::Create(bb0, bb1, One); 77 78 EXPECT_FALSE(b1->isUnconditional()); 79 EXPECT_TRUE(b1->isConditional()); 80 EXPECT_EQ(2U, b1->getNumSuccessors()); 81 82 // check num operands 83 EXPECT_EQ(3U, b1->getNumOperands()); 84 85 User::const_op_iterator b(b1->op_begin()); 86 87 // check COND 88 EXPECT_NE(b, b1->op_end()); 89 EXPECT_EQ(One, *b); 90 EXPECT_EQ(One, b1->getOperand(0)); 91 EXPECT_EQ(One, b1->getCondition()); 92 ++b; 93 94 // check ELSE 95 EXPECT_EQ(bb1, *b); 96 EXPECT_EQ(bb1, b1->getOperand(1)); 97 EXPECT_EQ(bb1, b1->getSuccessor(1)); 98 ++b; 99 100 // check THEN 101 EXPECT_EQ(bb0, *b); 102 EXPECT_EQ(bb0, b1->getOperand(2)); 103 EXPECT_EQ(bb0, b1->getSuccessor(0)); 104 ++b; 105 106 EXPECT_EQ(b1->op_end(), b); 107 108 // clean up 109 delete b0; 110 delete b1; 111 112 delete bb0; 113 delete bb1; 114 } 115 116 TEST(InstructionsTest, CastInst) { 117 LLVMContext &C(getGlobalContext()); 118 119 Type *Int8Ty = Type::getInt8Ty(C); 120 Type *Int16Ty = Type::getInt16Ty(C); 121 Type *Int32Ty = Type::getInt32Ty(C); 122 Type *Int64Ty = Type::getInt64Ty(C); 123 Type *V8x8Ty = VectorType::get(Int8Ty, 8); 124 Type *V8x64Ty = VectorType::get(Int64Ty, 8); 125 Type *X86MMXTy = Type::getX86_MMXTy(C); 126 127 Type *HalfTy = Type::getHalfTy(C); 128 Type *FloatTy = Type::getFloatTy(C); 129 Type *DoubleTy = Type::getDoubleTy(C); 130 131 Type *V2Int32Ty = VectorType::get(Int32Ty, 2); 132 Type *V2Int64Ty = VectorType::get(Int64Ty, 2); 133 Type *V4Int16Ty = VectorType::get(Int16Ty, 4); 134 135 Type *Int32PtrTy = PointerType::get(Int32Ty, 0); 136 Type *Int64PtrTy = PointerType::get(Int64Ty, 0); 137 138 Type *Int32PtrAS1Ty = PointerType::get(Int32Ty, 1); 139 Type *Int64PtrAS1Ty = PointerType::get(Int64Ty, 1); 140 141 Type *V2Int32PtrAS1Ty = VectorType::get(Int32PtrAS1Ty, 2); 142 Type *V2Int64PtrAS1Ty = VectorType::get(Int64PtrAS1Ty, 2); 143 Type *V4Int32PtrAS1Ty = VectorType::get(Int32PtrAS1Ty, 4); 144 Type *V4Int64PtrAS1Ty = VectorType::get(Int64PtrAS1Ty, 4); 145 146 Type *V2Int64PtrTy = VectorType::get(Int64PtrTy, 2); 147 Type *V2Int32PtrTy = VectorType::get(Int32PtrTy, 2); 148 149 const Constant* c8 = Constant::getNullValue(V8x8Ty); 150 const Constant* c64 = Constant::getNullValue(V8x64Ty); 151 152 const Constant *v2ptr32 = Constant::getNullValue(V2Int32PtrTy); 153 154 EXPECT_TRUE(CastInst::isCastable(V8x8Ty, X86MMXTy)); 155 EXPECT_TRUE(CastInst::isCastable(X86MMXTy, V8x8Ty)); 156 EXPECT_FALSE(CastInst::isCastable(Int64Ty, X86MMXTy)); 157 EXPECT_TRUE(CastInst::isCastable(V8x64Ty, V8x8Ty)); 158 EXPECT_TRUE(CastInst::isCastable(V8x8Ty, V8x64Ty)); 159 EXPECT_EQ(CastInst::Trunc, CastInst::getCastOpcode(c64, true, V8x8Ty, true)); 160 EXPECT_EQ(CastInst::SExt, CastInst::getCastOpcode(c8, true, V8x64Ty, true)); 161 162 EXPECT_FALSE(CastInst::isBitCastable(V8x8Ty, X86MMXTy)); 163 EXPECT_FALSE(CastInst::isBitCastable(X86MMXTy, V8x8Ty)); 164 EXPECT_FALSE(CastInst::isBitCastable(Int64Ty, X86MMXTy)); 165 EXPECT_FALSE(CastInst::isBitCastable(V8x64Ty, V8x8Ty)); 166 EXPECT_FALSE(CastInst::isBitCastable(V8x8Ty, V8x64Ty)); 167 168 // Check address space casts are rejected since we don't know the sizes here 169 EXPECT_FALSE(CastInst::isBitCastable(Int32PtrTy, Int32PtrAS1Ty)); 170 EXPECT_FALSE(CastInst::isBitCastable(Int32PtrAS1Ty, Int32PtrTy)); 171 EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrTy, V2Int32PtrAS1Ty)); 172 EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V2Int32PtrTy)); 173 EXPECT_TRUE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V2Int64PtrAS1Ty)); 174 EXPECT_TRUE(CastInst::isCastable(V2Int32PtrAS1Ty, V2Int32PtrTy)); 175 EXPECT_EQ(CastInst::AddrSpaceCast, CastInst::getCastOpcode(v2ptr32, true, 176 V2Int32PtrAS1Ty, 177 true)); 178 179 // Test mismatched number of elements for pointers 180 EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V4Int64PtrAS1Ty)); 181 EXPECT_FALSE(CastInst::isBitCastable(V4Int64PtrAS1Ty, V2Int32PtrAS1Ty)); 182 EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V4Int32PtrAS1Ty)); 183 EXPECT_FALSE(CastInst::isBitCastable(Int32PtrTy, V2Int32PtrTy)); 184 EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrTy, Int32PtrTy)); 185 186 EXPECT_TRUE(CastInst::isBitCastable(Int32PtrTy, Int64PtrTy)); 187 EXPECT_FALSE(CastInst::isBitCastable(DoubleTy, FloatTy)); 188 EXPECT_FALSE(CastInst::isBitCastable(FloatTy, DoubleTy)); 189 EXPECT_TRUE(CastInst::isBitCastable(FloatTy, FloatTy)); 190 EXPECT_TRUE(CastInst::isBitCastable(FloatTy, FloatTy)); 191 EXPECT_TRUE(CastInst::isBitCastable(FloatTy, Int32Ty)); 192 EXPECT_TRUE(CastInst::isBitCastable(Int16Ty, HalfTy)); 193 EXPECT_TRUE(CastInst::isBitCastable(Int32Ty, FloatTy)); 194 EXPECT_TRUE(CastInst::isBitCastable(V2Int32Ty, Int64Ty)); 195 196 EXPECT_TRUE(CastInst::isBitCastable(V2Int32Ty, V4Int16Ty)); 197 EXPECT_FALSE(CastInst::isBitCastable(Int32Ty, Int64Ty)); 198 EXPECT_FALSE(CastInst::isBitCastable(Int64Ty, Int32Ty)); 199 200 EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrTy, Int64Ty)); 201 EXPECT_FALSE(CastInst::isBitCastable(Int64Ty, V2Int32PtrTy)); 202 EXPECT_TRUE(CastInst::isBitCastable(V2Int64PtrTy, V2Int32PtrTy)); 203 EXPECT_TRUE(CastInst::isBitCastable(V2Int32PtrTy, V2Int64PtrTy)); 204 EXPECT_FALSE(CastInst::isBitCastable(V2Int32Ty, V2Int64Ty)); 205 EXPECT_FALSE(CastInst::isBitCastable(V2Int64Ty, V2Int32Ty)); 206 207 208 // Check that assertion is not hit when creating a cast with a vector of 209 // pointers 210 // First form 211 BasicBlock *BB = BasicBlock::Create(C); 212 Constant *NullV2I32Ptr = Constant::getNullValue(V2Int32PtrTy); 213 CastInst::CreatePointerCast(NullV2I32Ptr, V2Int32Ty, "foo", BB); 214 215 // Second form 216 CastInst::CreatePointerCast(NullV2I32Ptr, V2Int32Ty); 217 } 218 219 TEST(InstructionsTest, VectorGep) { 220 LLVMContext &C(getGlobalContext()); 221 222 // Type Definitions 223 PointerType *Ptri8Ty = PointerType::get(IntegerType::get(C, 8), 0); 224 PointerType *Ptri32Ty = PointerType::get(IntegerType::get(C, 32), 0); 225 226 VectorType *V2xi8PTy = VectorType::get(Ptri8Ty, 2); 227 VectorType *V2xi32PTy = VectorType::get(Ptri32Ty, 2); 228 229 // Test different aspects of the vector-of-pointers type 230 // and GEPs which use this type. 231 ConstantInt *Ci32a = ConstantInt::get(C, APInt(32, 1492)); 232 ConstantInt *Ci32b = ConstantInt::get(C, APInt(32, 1948)); 233 std::vector<Constant*> ConstVa(2, Ci32a); 234 std::vector<Constant*> ConstVb(2, Ci32b); 235 Constant *C2xi32a = ConstantVector::get(ConstVa); 236 Constant *C2xi32b = ConstantVector::get(ConstVb); 237 238 CastInst *PtrVecA = new IntToPtrInst(C2xi32a, V2xi32PTy); 239 CastInst *PtrVecB = new IntToPtrInst(C2xi32b, V2xi32PTy); 240 241 ICmpInst *ICmp0 = new ICmpInst(ICmpInst::ICMP_SGT, PtrVecA, PtrVecB); 242 ICmpInst *ICmp1 = new ICmpInst(ICmpInst::ICMP_ULT, PtrVecA, PtrVecB); 243 EXPECT_NE(ICmp0, ICmp1); // suppress warning. 244 245 BasicBlock* BB0 = BasicBlock::Create(C); 246 // Test InsertAtEnd ICmpInst constructor. 247 ICmpInst *ICmp2 = new ICmpInst(*BB0, ICmpInst::ICMP_SGE, PtrVecA, PtrVecB); 248 EXPECT_NE(ICmp0, ICmp2); // suppress warning. 249 250 GetElementPtrInst *Gep0 = GetElementPtrInst::Create(PtrVecA, C2xi32a); 251 GetElementPtrInst *Gep1 = GetElementPtrInst::Create(PtrVecA, C2xi32b); 252 GetElementPtrInst *Gep2 = GetElementPtrInst::Create(PtrVecB, C2xi32a); 253 GetElementPtrInst *Gep3 = GetElementPtrInst::Create(PtrVecB, C2xi32b); 254 255 CastInst *BTC0 = new BitCastInst(Gep0, V2xi8PTy); 256 CastInst *BTC1 = new BitCastInst(Gep1, V2xi8PTy); 257 CastInst *BTC2 = new BitCastInst(Gep2, V2xi8PTy); 258 CastInst *BTC3 = new BitCastInst(Gep3, V2xi8PTy); 259 260 Value *S0 = BTC0->stripPointerCasts(); 261 Value *S1 = BTC1->stripPointerCasts(); 262 Value *S2 = BTC2->stripPointerCasts(); 263 Value *S3 = BTC3->stripPointerCasts(); 264 265 EXPECT_NE(S0, Gep0); 266 EXPECT_NE(S1, Gep1); 267 EXPECT_NE(S2, Gep2); 268 EXPECT_NE(S3, Gep3); 269 270 int64_t Offset; 271 DataLayout TD("e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f3" 272 "2:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80" 273 ":128:128-n8:16:32:64-S128"); 274 // Make sure we don't crash 275 GetPointerBaseWithConstantOffset(Gep0, Offset, &TD); 276 GetPointerBaseWithConstantOffset(Gep1, Offset, &TD); 277 GetPointerBaseWithConstantOffset(Gep2, Offset, &TD); 278 GetPointerBaseWithConstantOffset(Gep3, Offset, &TD); 279 280 // Gep of Geps 281 GetElementPtrInst *GepII0 = GetElementPtrInst::Create(Gep0, C2xi32b); 282 GetElementPtrInst *GepII1 = GetElementPtrInst::Create(Gep1, C2xi32a); 283 GetElementPtrInst *GepII2 = GetElementPtrInst::Create(Gep2, C2xi32b); 284 GetElementPtrInst *GepII3 = GetElementPtrInst::Create(Gep3, C2xi32a); 285 286 EXPECT_EQ(GepII0->getNumIndices(), 1u); 287 EXPECT_EQ(GepII1->getNumIndices(), 1u); 288 EXPECT_EQ(GepII2->getNumIndices(), 1u); 289 EXPECT_EQ(GepII3->getNumIndices(), 1u); 290 291 EXPECT_FALSE(GepII0->hasAllZeroIndices()); 292 EXPECT_FALSE(GepII1->hasAllZeroIndices()); 293 EXPECT_FALSE(GepII2->hasAllZeroIndices()); 294 EXPECT_FALSE(GepII3->hasAllZeroIndices()); 295 296 delete GepII0; 297 delete GepII1; 298 delete GepII2; 299 delete GepII3; 300 301 delete BTC0; 302 delete BTC1; 303 delete BTC2; 304 delete BTC3; 305 306 delete Gep0; 307 delete Gep1; 308 delete Gep2; 309 delete Gep3; 310 311 ICmp2->eraseFromParent(); 312 delete BB0; 313 314 delete ICmp0; 315 delete ICmp1; 316 delete PtrVecA; 317 delete PtrVecB; 318 } 319 320 TEST(InstructionsTest, FPMathOperator) { 321 LLVMContext &Context = getGlobalContext(); 322 IRBuilder<> Builder(Context); 323 MDBuilder MDHelper(Context); 324 Instruction *I = Builder.CreatePHI(Builder.getDoubleTy(), 0); 325 MDNode *MD1 = MDHelper.createFPMath(1.0); 326 Value *V1 = Builder.CreateFAdd(I, I, "", MD1); 327 EXPECT_TRUE(isa<FPMathOperator>(V1)); 328 FPMathOperator *O1 = cast<FPMathOperator>(V1); 329 EXPECT_EQ(O1->getFPAccuracy(), 1.0); 330 delete V1; 331 delete I; 332 } 333 334 335 TEST(InstructionsTest, isEliminableCastPair) { 336 LLVMContext &C(getGlobalContext()); 337 338 Type* Int16Ty = Type::getInt16Ty(C); 339 Type* Int32Ty = Type::getInt32Ty(C); 340 Type* Int64Ty = Type::getInt64Ty(C); 341 Type* Int64PtrTy = Type::getInt64PtrTy(C); 342 343 // Source and destination pointers have same size -> bitcast. 344 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::PtrToInt, 345 CastInst::IntToPtr, 346 Int64PtrTy, Int64Ty, Int64PtrTy, 347 Int32Ty, 0, Int32Ty), 348 CastInst::BitCast); 349 350 // Source and destination have unknown sizes, but the same address space and 351 // the intermediate int is the maximum pointer size -> bitcast 352 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::PtrToInt, 353 CastInst::IntToPtr, 354 Int64PtrTy, Int64Ty, Int64PtrTy, 355 0, 0, 0), 356 CastInst::BitCast); 357 358 // Source and destination have unknown sizes, but the same address space and 359 // the intermediate int is not the maximum pointer size -> nothing 360 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::PtrToInt, 361 CastInst::IntToPtr, 362 Int64PtrTy, Int32Ty, Int64PtrTy, 363 0, 0, 0), 364 0U); 365 366 // Middle pointer big enough -> bitcast. 367 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr, 368 CastInst::PtrToInt, 369 Int64Ty, Int64PtrTy, Int64Ty, 370 0, Int64Ty, 0), 371 CastInst::BitCast); 372 373 // Middle pointer too small -> fail. 374 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr, 375 CastInst::PtrToInt, 376 Int64Ty, Int64PtrTy, Int64Ty, 377 0, Int32Ty, 0), 378 0U); 379 380 // Test that we don't eliminate bitcasts between different address spaces, 381 // or if we don't have available pointer size information. 382 DataLayout DL("e-p:32:32:32-p1:16:16:16-p2:64:64:64-i1:8:8-i8:8:8-i16:16:16" 383 "-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64" 384 "-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"); 385 386 Type* Int64PtrTyAS1 = Type::getInt64PtrTy(C, 1); 387 Type* Int64PtrTyAS2 = Type::getInt64PtrTy(C, 2); 388 389 IntegerType *Int16SizePtr = DL.getIntPtrType(C, 1); 390 IntegerType *Int64SizePtr = DL.getIntPtrType(C, 2); 391 392 // Cannot simplify inttoptr, addrspacecast 393 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr, 394 CastInst::AddrSpaceCast, 395 Int16Ty, Int64PtrTyAS1, Int64PtrTyAS2, 396 0, Int16SizePtr, Int64SizePtr), 397 0U); 398 399 // Cannot simplify addrspacecast, ptrtoint 400 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::AddrSpaceCast, 401 CastInst::PtrToInt, 402 Int64PtrTyAS1, Int64PtrTyAS2, Int16Ty, 403 Int64SizePtr, Int16SizePtr, 0), 404 0U); 405 406 // Pass since the bitcast address spaces are the same 407 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr, 408 CastInst::BitCast, 409 Int16Ty, Int64PtrTyAS1, Int64PtrTyAS1, 410 0, 0, 0), 411 CastInst::IntToPtr); 412 413 } 414 415 } // end anonymous namespace 416 } // end namespace llvm 417 418 419