1 //===-- Instructions.cpp - Implement the LLVM instructions ----------------===// 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 // This file implements all of the non-inline methods for the LLVM instruction 11 // classes. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "llvm/IR/Instructions.h" 16 #include "LLVMContextImpl.h" 17 #include "llvm/IR/CallSite.h" 18 #include "llvm/IR/ConstantRange.h" 19 #include "llvm/IR/Constants.h" 20 #include "llvm/IR/DataLayout.h" 21 #include "llvm/IR/DerivedTypes.h" 22 #include "llvm/IR/Function.h" 23 #include "llvm/IR/Module.h" 24 #include "llvm/IR/Operator.h" 25 #include "llvm/Support/ErrorHandling.h" 26 #include "llvm/Support/MathExtras.h" 27 using namespace llvm; 28 29 //===----------------------------------------------------------------------===// 30 // CallSite Class 31 //===----------------------------------------------------------------------===// 32 33 User::op_iterator CallSite::getCallee() const { 34 Instruction *II(getInstruction()); 35 return isCall() 36 ? cast<CallInst>(II)->op_end() - 1 // Skip Callee 37 : cast<InvokeInst>(II)->op_end() - 3; // Skip BB, BB, Callee 38 } 39 40 //===----------------------------------------------------------------------===// 41 // TerminatorInst Class 42 //===----------------------------------------------------------------------===// 43 44 // Out of line virtual method, so the vtable, etc has a home. 45 TerminatorInst::~TerminatorInst() { 46 } 47 48 //===----------------------------------------------------------------------===// 49 // UnaryInstruction Class 50 //===----------------------------------------------------------------------===// 51 52 // Out of line virtual method, so the vtable, etc has a home. 53 UnaryInstruction::~UnaryInstruction() { 54 } 55 56 //===----------------------------------------------------------------------===// 57 // SelectInst Class 58 //===----------------------------------------------------------------------===// 59 60 /// areInvalidOperands - Return a string if the specified operands are invalid 61 /// for a select operation, otherwise return null. 62 const char *SelectInst::areInvalidOperands(Value *Op0, Value *Op1, Value *Op2) { 63 if (Op1->getType() != Op2->getType()) 64 return "both values to select must have same type"; 65 66 if (VectorType *VT = dyn_cast<VectorType>(Op0->getType())) { 67 // Vector select. 68 if (VT->getElementType() != Type::getInt1Ty(Op0->getContext())) 69 return "vector select condition element type must be i1"; 70 VectorType *ET = dyn_cast<VectorType>(Op1->getType()); 71 if (!ET) 72 return "selected values for vector select must be vectors"; 73 if (ET->getNumElements() != VT->getNumElements()) 74 return "vector select requires selected vectors to have " 75 "the same vector length as select condition"; 76 } else if (Op0->getType() != Type::getInt1Ty(Op0->getContext())) { 77 return "select condition must be i1 or <n x i1>"; 78 } 79 return nullptr; 80 } 81 82 83 //===----------------------------------------------------------------------===// 84 // PHINode Class 85 //===----------------------------------------------------------------------===// 86 87 PHINode::PHINode(const PHINode &PN) 88 : Instruction(PN.getType(), Instruction::PHI, 89 allocHungoffUses(PN.getNumOperands()), PN.getNumOperands()), 90 ReservedSpace(PN.getNumOperands()) { 91 std::copy(PN.op_begin(), PN.op_end(), op_begin()); 92 std::copy(PN.block_begin(), PN.block_end(), block_begin()); 93 SubclassOptionalData = PN.SubclassOptionalData; 94 } 95 96 PHINode::~PHINode() { 97 dropHungoffUses(); 98 } 99 100 Use *PHINode::allocHungoffUses(unsigned N) const { 101 // Allocate the array of Uses of the incoming values, followed by a pointer 102 // (with bottom bit set) to the User, followed by the array of pointers to 103 // the incoming basic blocks. 104 size_t size = N * sizeof(Use) + sizeof(Use::UserRef) 105 + N * sizeof(BasicBlock*); 106 Use *Begin = static_cast<Use*>(::operator new(size)); 107 Use *End = Begin + N; 108 (void) new(End) Use::UserRef(const_cast<PHINode*>(this), 1); 109 return Use::initTags(Begin, End); 110 } 111 112 // removeIncomingValue - Remove an incoming value. This is useful if a 113 // predecessor basic block is deleted. 114 Value *PHINode::removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty) { 115 Value *Removed = getIncomingValue(Idx); 116 117 // Move everything after this operand down. 118 // 119 // FIXME: we could just swap with the end of the list, then erase. However, 120 // clients might not expect this to happen. The code as it is thrashes the 121 // use/def lists, which is kinda lame. 122 std::copy(op_begin() + Idx + 1, op_end(), op_begin() + Idx); 123 std::copy(block_begin() + Idx + 1, block_end(), block_begin() + Idx); 124 125 // Nuke the last value. 126 Op<-1>().set(nullptr); 127 --NumOperands; 128 129 // If the PHI node is dead, because it has zero entries, nuke it now. 130 if (getNumOperands() == 0 && DeletePHIIfEmpty) { 131 // If anyone is using this PHI, make them use a dummy value instead... 132 replaceAllUsesWith(UndefValue::get(getType())); 133 eraseFromParent(); 134 } 135 return Removed; 136 } 137 138 /// growOperands - grow operands - This grows the operand list in response 139 /// to a push_back style of operation. This grows the number of ops by 1.5 140 /// times. 141 /// 142 void PHINode::growOperands() { 143 unsigned e = getNumOperands(); 144 unsigned NumOps = e + e / 2; 145 if (NumOps < 2) NumOps = 2; // 2 op PHI nodes are VERY common. 146 147 Use *OldOps = op_begin(); 148 BasicBlock **OldBlocks = block_begin(); 149 150 ReservedSpace = NumOps; 151 OperandList = allocHungoffUses(ReservedSpace); 152 153 std::copy(OldOps, OldOps + e, op_begin()); 154 std::copy(OldBlocks, OldBlocks + e, block_begin()); 155 156 Use::zap(OldOps, OldOps + e, true); 157 } 158 159 /// hasConstantValue - If the specified PHI node always merges together the same 160 /// value, return the value, otherwise return null. 161 Value *PHINode::hasConstantValue() const { 162 // Exploit the fact that phi nodes always have at least one entry. 163 Value *ConstantValue = getIncomingValue(0); 164 for (unsigned i = 1, e = getNumIncomingValues(); i != e; ++i) 165 if (getIncomingValue(i) != ConstantValue && getIncomingValue(i) != this) { 166 if (ConstantValue != this) 167 return nullptr; // Incoming values not all the same. 168 // The case where the first value is this PHI. 169 ConstantValue = getIncomingValue(i); 170 } 171 if (ConstantValue == this) 172 return UndefValue::get(getType()); 173 return ConstantValue; 174 } 175 176 //===----------------------------------------------------------------------===// 177 // LandingPadInst Implementation 178 //===----------------------------------------------------------------------===// 179 180 LandingPadInst::LandingPadInst(Type *RetTy, Value *PersonalityFn, 181 unsigned NumReservedValues, const Twine &NameStr, 182 Instruction *InsertBefore) 183 : Instruction(RetTy, Instruction::LandingPad, nullptr, 0, InsertBefore) { 184 init(PersonalityFn, 1 + NumReservedValues, NameStr); 185 } 186 187 LandingPadInst::LandingPadInst(Type *RetTy, Value *PersonalityFn, 188 unsigned NumReservedValues, const Twine &NameStr, 189 BasicBlock *InsertAtEnd) 190 : Instruction(RetTy, Instruction::LandingPad, nullptr, 0, InsertAtEnd) { 191 init(PersonalityFn, 1 + NumReservedValues, NameStr); 192 } 193 194 LandingPadInst::LandingPadInst(const LandingPadInst &LP) 195 : Instruction(LP.getType(), Instruction::LandingPad, 196 allocHungoffUses(LP.getNumOperands()), LP.getNumOperands()), 197 ReservedSpace(LP.getNumOperands()) { 198 Use *OL = OperandList, *InOL = LP.OperandList; 199 for (unsigned I = 0, E = ReservedSpace; I != E; ++I) 200 OL[I] = InOL[I]; 201 202 setCleanup(LP.isCleanup()); 203 } 204 205 LandingPadInst::~LandingPadInst() { 206 dropHungoffUses(); 207 } 208 209 LandingPadInst *LandingPadInst::Create(Type *RetTy, Value *PersonalityFn, 210 unsigned NumReservedClauses, 211 const Twine &NameStr, 212 Instruction *InsertBefore) { 213 return new LandingPadInst(RetTy, PersonalityFn, NumReservedClauses, NameStr, 214 InsertBefore); 215 } 216 217 LandingPadInst *LandingPadInst::Create(Type *RetTy, Value *PersonalityFn, 218 unsigned NumReservedClauses, 219 const Twine &NameStr, 220 BasicBlock *InsertAtEnd) { 221 return new LandingPadInst(RetTy, PersonalityFn, NumReservedClauses, NameStr, 222 InsertAtEnd); 223 } 224 225 void LandingPadInst::init(Value *PersFn, unsigned NumReservedValues, 226 const Twine &NameStr) { 227 ReservedSpace = NumReservedValues; 228 NumOperands = 1; 229 OperandList = allocHungoffUses(ReservedSpace); 230 OperandList[0] = PersFn; 231 setName(NameStr); 232 setCleanup(false); 233 } 234 235 /// growOperands - grow operands - This grows the operand list in response to a 236 /// push_back style of operation. This grows the number of ops by 2 times. 237 void LandingPadInst::growOperands(unsigned Size) { 238 unsigned e = getNumOperands(); 239 if (ReservedSpace >= e + Size) return; 240 ReservedSpace = (e + Size / 2) * 2; 241 242 Use *NewOps = allocHungoffUses(ReservedSpace); 243 Use *OldOps = OperandList; 244 for (unsigned i = 0; i != e; ++i) 245 NewOps[i] = OldOps[i]; 246 247 OperandList = NewOps; 248 Use::zap(OldOps, OldOps + e, true); 249 } 250 251 void LandingPadInst::addClause(Constant *Val) { 252 unsigned OpNo = getNumOperands(); 253 growOperands(1); 254 assert(OpNo < ReservedSpace && "Growing didn't work!"); 255 ++NumOperands; 256 OperandList[OpNo] = Val; 257 } 258 259 //===----------------------------------------------------------------------===// 260 // CallInst Implementation 261 //===----------------------------------------------------------------------===// 262 263 CallInst::~CallInst() { 264 } 265 266 void CallInst::init(Value *Func, ArrayRef<Value *> Args, const Twine &NameStr) { 267 assert(NumOperands == Args.size() + 1 && "NumOperands not set up?"); 268 Op<-1>() = Func; 269 270 #ifndef NDEBUG 271 FunctionType *FTy = 272 cast<FunctionType>(cast<PointerType>(Func->getType())->getElementType()); 273 274 assert((Args.size() == FTy->getNumParams() || 275 (FTy->isVarArg() && Args.size() > FTy->getNumParams())) && 276 "Calling a function with bad signature!"); 277 278 for (unsigned i = 0; i != Args.size(); ++i) 279 assert((i >= FTy->getNumParams() || 280 FTy->getParamType(i) == Args[i]->getType()) && 281 "Calling a function with a bad signature!"); 282 #endif 283 284 std::copy(Args.begin(), Args.end(), op_begin()); 285 setName(NameStr); 286 } 287 288 void CallInst::init(Value *Func, const Twine &NameStr) { 289 assert(NumOperands == 1 && "NumOperands not set up?"); 290 Op<-1>() = Func; 291 292 #ifndef NDEBUG 293 FunctionType *FTy = 294 cast<FunctionType>(cast<PointerType>(Func->getType())->getElementType()); 295 296 assert(FTy->getNumParams() == 0 && "Calling a function with bad signature"); 297 #endif 298 299 setName(NameStr); 300 } 301 302 CallInst::CallInst(Value *Func, const Twine &Name, 303 Instruction *InsertBefore) 304 : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType()) 305 ->getElementType())->getReturnType(), 306 Instruction::Call, 307 OperandTraits<CallInst>::op_end(this) - 1, 308 1, InsertBefore) { 309 init(Func, Name); 310 } 311 312 CallInst::CallInst(Value *Func, const Twine &Name, 313 BasicBlock *InsertAtEnd) 314 : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType()) 315 ->getElementType())->getReturnType(), 316 Instruction::Call, 317 OperandTraits<CallInst>::op_end(this) - 1, 318 1, InsertAtEnd) { 319 init(Func, Name); 320 } 321 322 CallInst::CallInst(const CallInst &CI) 323 : Instruction(CI.getType(), Instruction::Call, 324 OperandTraits<CallInst>::op_end(this) - CI.getNumOperands(), 325 CI.getNumOperands()) { 326 setAttributes(CI.getAttributes()); 327 setTailCallKind(CI.getTailCallKind()); 328 setCallingConv(CI.getCallingConv()); 329 330 std::copy(CI.op_begin(), CI.op_end(), op_begin()); 331 SubclassOptionalData = CI.SubclassOptionalData; 332 } 333 334 void CallInst::addAttribute(unsigned i, Attribute::AttrKind attr) { 335 AttributeSet PAL = getAttributes(); 336 PAL = PAL.addAttribute(getContext(), i, attr); 337 setAttributes(PAL); 338 } 339 340 void CallInst::removeAttribute(unsigned i, Attribute attr) { 341 AttributeSet PAL = getAttributes(); 342 AttrBuilder B(attr); 343 LLVMContext &Context = getContext(); 344 PAL = PAL.removeAttributes(Context, i, 345 AttributeSet::get(Context, i, B)); 346 setAttributes(PAL); 347 } 348 349 bool CallInst::hasFnAttrImpl(Attribute::AttrKind A) const { 350 if (AttributeList.hasAttribute(AttributeSet::FunctionIndex, A)) 351 return true; 352 if (const Function *F = getCalledFunction()) 353 return F->getAttributes().hasAttribute(AttributeSet::FunctionIndex, A); 354 return false; 355 } 356 357 bool CallInst::paramHasAttr(unsigned i, Attribute::AttrKind A) const { 358 if (AttributeList.hasAttribute(i, A)) 359 return true; 360 if (const Function *F = getCalledFunction()) 361 return F->getAttributes().hasAttribute(i, A); 362 return false; 363 } 364 365 /// IsConstantOne - Return true only if val is constant int 1 366 static bool IsConstantOne(Value *val) { 367 assert(val && "IsConstantOne does not work with nullptr val"); 368 const ConstantInt *CVal = dyn_cast<ConstantInt>(val); 369 return CVal && CVal->isOne(); 370 } 371 372 static Instruction *createMalloc(Instruction *InsertBefore, 373 BasicBlock *InsertAtEnd, Type *IntPtrTy, 374 Type *AllocTy, Value *AllocSize, 375 Value *ArraySize, Function *MallocF, 376 const Twine &Name) { 377 assert(((!InsertBefore && InsertAtEnd) || (InsertBefore && !InsertAtEnd)) && 378 "createMalloc needs either InsertBefore or InsertAtEnd"); 379 380 // malloc(type) becomes: 381 // bitcast (i8* malloc(typeSize)) to type* 382 // malloc(type, arraySize) becomes: 383 // bitcast (i8 *malloc(typeSize*arraySize)) to type* 384 if (!ArraySize) 385 ArraySize = ConstantInt::get(IntPtrTy, 1); 386 else if (ArraySize->getType() != IntPtrTy) { 387 if (InsertBefore) 388 ArraySize = CastInst::CreateIntegerCast(ArraySize, IntPtrTy, false, 389 "", InsertBefore); 390 else 391 ArraySize = CastInst::CreateIntegerCast(ArraySize, IntPtrTy, false, 392 "", InsertAtEnd); 393 } 394 395 if (!IsConstantOne(ArraySize)) { 396 if (IsConstantOne(AllocSize)) { 397 AllocSize = ArraySize; // Operand * 1 = Operand 398 } else if (Constant *CO = dyn_cast<Constant>(ArraySize)) { 399 Constant *Scale = ConstantExpr::getIntegerCast(CO, IntPtrTy, 400 false /*ZExt*/); 401 // Malloc arg is constant product of type size and array size 402 AllocSize = ConstantExpr::getMul(Scale, cast<Constant>(AllocSize)); 403 } else { 404 // Multiply type size by the array size... 405 if (InsertBefore) 406 AllocSize = BinaryOperator::CreateMul(ArraySize, AllocSize, 407 "mallocsize", InsertBefore); 408 else 409 AllocSize = BinaryOperator::CreateMul(ArraySize, AllocSize, 410 "mallocsize", InsertAtEnd); 411 } 412 } 413 414 assert(AllocSize->getType() == IntPtrTy && "malloc arg is wrong size"); 415 // Create the call to Malloc. 416 BasicBlock* BB = InsertBefore ? InsertBefore->getParent() : InsertAtEnd; 417 Module* M = BB->getParent()->getParent(); 418 Type *BPTy = Type::getInt8PtrTy(BB->getContext()); 419 Value *MallocFunc = MallocF; 420 if (!MallocFunc) 421 // prototype malloc as "void *malloc(size_t)" 422 MallocFunc = M->getOrInsertFunction("malloc", BPTy, IntPtrTy, nullptr); 423 PointerType *AllocPtrType = PointerType::getUnqual(AllocTy); 424 CallInst *MCall = nullptr; 425 Instruction *Result = nullptr; 426 if (InsertBefore) { 427 MCall = CallInst::Create(MallocFunc, AllocSize, "malloccall", InsertBefore); 428 Result = MCall; 429 if (Result->getType() != AllocPtrType) 430 // Create a cast instruction to convert to the right type... 431 Result = new BitCastInst(MCall, AllocPtrType, Name, InsertBefore); 432 } else { 433 MCall = CallInst::Create(MallocFunc, AllocSize, "malloccall"); 434 Result = MCall; 435 if (Result->getType() != AllocPtrType) { 436 InsertAtEnd->getInstList().push_back(MCall); 437 // Create a cast instruction to convert to the right type... 438 Result = new BitCastInst(MCall, AllocPtrType, Name); 439 } 440 } 441 MCall->setTailCall(); 442 if (Function *F = dyn_cast<Function>(MallocFunc)) { 443 MCall->setCallingConv(F->getCallingConv()); 444 if (!F->doesNotAlias(0)) F->setDoesNotAlias(0); 445 } 446 assert(!MCall->getType()->isVoidTy() && "Malloc has void return type"); 447 448 return Result; 449 } 450 451 /// CreateMalloc - Generate the IR for a call to malloc: 452 /// 1. Compute the malloc call's argument as the specified type's size, 453 /// possibly multiplied by the array size if the array size is not 454 /// constant 1. 455 /// 2. Call malloc with that argument. 456 /// 3. Bitcast the result of the malloc call to the specified type. 457 Instruction *CallInst::CreateMalloc(Instruction *InsertBefore, 458 Type *IntPtrTy, Type *AllocTy, 459 Value *AllocSize, Value *ArraySize, 460 Function * MallocF, 461 const Twine &Name) { 462 return createMalloc(InsertBefore, nullptr, IntPtrTy, AllocTy, AllocSize, 463 ArraySize, MallocF, Name); 464 } 465 466 /// CreateMalloc - Generate the IR for a call to malloc: 467 /// 1. Compute the malloc call's argument as the specified type's size, 468 /// possibly multiplied by the array size if the array size is not 469 /// constant 1. 470 /// 2. Call malloc with that argument. 471 /// 3. Bitcast the result of the malloc call to the specified type. 472 /// Note: This function does not add the bitcast to the basic block, that is the 473 /// responsibility of the caller. 474 Instruction *CallInst::CreateMalloc(BasicBlock *InsertAtEnd, 475 Type *IntPtrTy, Type *AllocTy, 476 Value *AllocSize, Value *ArraySize, 477 Function *MallocF, const Twine &Name) { 478 return createMalloc(nullptr, InsertAtEnd, IntPtrTy, AllocTy, AllocSize, 479 ArraySize, MallocF, Name); 480 } 481 482 static Instruction* createFree(Value* Source, Instruction *InsertBefore, 483 BasicBlock *InsertAtEnd) { 484 assert(((!InsertBefore && InsertAtEnd) || (InsertBefore && !InsertAtEnd)) && 485 "createFree needs either InsertBefore or InsertAtEnd"); 486 assert(Source->getType()->isPointerTy() && 487 "Can not free something of nonpointer type!"); 488 489 BasicBlock* BB = InsertBefore ? InsertBefore->getParent() : InsertAtEnd; 490 Module* M = BB->getParent()->getParent(); 491 492 Type *VoidTy = Type::getVoidTy(M->getContext()); 493 Type *IntPtrTy = Type::getInt8PtrTy(M->getContext()); 494 // prototype free as "void free(void*)" 495 Value *FreeFunc = M->getOrInsertFunction("free", VoidTy, IntPtrTy, nullptr); 496 CallInst* Result = nullptr; 497 Value *PtrCast = Source; 498 if (InsertBefore) { 499 if (Source->getType() != IntPtrTy) 500 PtrCast = new BitCastInst(Source, IntPtrTy, "", InsertBefore); 501 Result = CallInst::Create(FreeFunc, PtrCast, "", InsertBefore); 502 } else { 503 if (Source->getType() != IntPtrTy) 504 PtrCast = new BitCastInst(Source, IntPtrTy, "", InsertAtEnd); 505 Result = CallInst::Create(FreeFunc, PtrCast, ""); 506 } 507 Result->setTailCall(); 508 if (Function *F = dyn_cast<Function>(FreeFunc)) 509 Result->setCallingConv(F->getCallingConv()); 510 511 return Result; 512 } 513 514 /// CreateFree - Generate the IR for a call to the builtin free function. 515 Instruction * CallInst::CreateFree(Value* Source, Instruction *InsertBefore) { 516 return createFree(Source, InsertBefore, nullptr); 517 } 518 519 /// CreateFree - Generate the IR for a call to the builtin free function. 520 /// Note: This function does not add the call to the basic block, that is the 521 /// responsibility of the caller. 522 Instruction* CallInst::CreateFree(Value* Source, BasicBlock *InsertAtEnd) { 523 Instruction* FreeCall = createFree(Source, nullptr, InsertAtEnd); 524 assert(FreeCall && "CreateFree did not create a CallInst"); 525 return FreeCall; 526 } 527 528 //===----------------------------------------------------------------------===// 529 // InvokeInst Implementation 530 //===----------------------------------------------------------------------===// 531 532 void InvokeInst::init(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException, 533 ArrayRef<Value *> Args, const Twine &NameStr) { 534 assert(NumOperands == 3 + Args.size() && "NumOperands not set up?"); 535 Op<-3>() = Fn; 536 Op<-2>() = IfNormal; 537 Op<-1>() = IfException; 538 539 #ifndef NDEBUG 540 FunctionType *FTy = 541 cast<FunctionType>(cast<PointerType>(Fn->getType())->getElementType()); 542 543 assert(((Args.size() == FTy->getNumParams()) || 544 (FTy->isVarArg() && Args.size() > FTy->getNumParams())) && 545 "Invoking a function with bad signature"); 546 547 for (unsigned i = 0, e = Args.size(); i != e; i++) 548 assert((i >= FTy->getNumParams() || 549 FTy->getParamType(i) == Args[i]->getType()) && 550 "Invoking a function with a bad signature!"); 551 #endif 552 553 std::copy(Args.begin(), Args.end(), op_begin()); 554 setName(NameStr); 555 } 556 557 InvokeInst::InvokeInst(const InvokeInst &II) 558 : TerminatorInst(II.getType(), Instruction::Invoke, 559 OperandTraits<InvokeInst>::op_end(this) 560 - II.getNumOperands(), 561 II.getNumOperands()) { 562 setAttributes(II.getAttributes()); 563 setCallingConv(II.getCallingConv()); 564 std::copy(II.op_begin(), II.op_end(), op_begin()); 565 SubclassOptionalData = II.SubclassOptionalData; 566 } 567 568 BasicBlock *InvokeInst::getSuccessorV(unsigned idx) const { 569 return getSuccessor(idx); 570 } 571 unsigned InvokeInst::getNumSuccessorsV() const { 572 return getNumSuccessors(); 573 } 574 void InvokeInst::setSuccessorV(unsigned idx, BasicBlock *B) { 575 return setSuccessor(idx, B); 576 } 577 578 bool InvokeInst::hasFnAttrImpl(Attribute::AttrKind A) const { 579 if (AttributeList.hasAttribute(AttributeSet::FunctionIndex, A)) 580 return true; 581 if (const Function *F = getCalledFunction()) 582 return F->getAttributes().hasAttribute(AttributeSet::FunctionIndex, A); 583 return false; 584 } 585 586 bool InvokeInst::paramHasAttr(unsigned i, Attribute::AttrKind A) const { 587 if (AttributeList.hasAttribute(i, A)) 588 return true; 589 if (const Function *F = getCalledFunction()) 590 return F->getAttributes().hasAttribute(i, A); 591 return false; 592 } 593 594 void InvokeInst::addAttribute(unsigned i, Attribute::AttrKind attr) { 595 AttributeSet PAL = getAttributes(); 596 PAL = PAL.addAttribute(getContext(), i, attr); 597 setAttributes(PAL); 598 } 599 600 void InvokeInst::removeAttribute(unsigned i, Attribute attr) { 601 AttributeSet PAL = getAttributes(); 602 AttrBuilder B(attr); 603 PAL = PAL.removeAttributes(getContext(), i, 604 AttributeSet::get(getContext(), i, B)); 605 setAttributes(PAL); 606 } 607 608 LandingPadInst *InvokeInst::getLandingPadInst() const { 609 return cast<LandingPadInst>(getUnwindDest()->getFirstNonPHI()); 610 } 611 612 //===----------------------------------------------------------------------===// 613 // ReturnInst Implementation 614 //===----------------------------------------------------------------------===// 615 616 ReturnInst::ReturnInst(const ReturnInst &RI) 617 : TerminatorInst(Type::getVoidTy(RI.getContext()), Instruction::Ret, 618 OperandTraits<ReturnInst>::op_end(this) - 619 RI.getNumOperands(), 620 RI.getNumOperands()) { 621 if (RI.getNumOperands()) 622 Op<0>() = RI.Op<0>(); 623 SubclassOptionalData = RI.SubclassOptionalData; 624 } 625 626 ReturnInst::ReturnInst(LLVMContext &C, Value *retVal, Instruction *InsertBefore) 627 : TerminatorInst(Type::getVoidTy(C), Instruction::Ret, 628 OperandTraits<ReturnInst>::op_end(this) - !!retVal, !!retVal, 629 InsertBefore) { 630 if (retVal) 631 Op<0>() = retVal; 632 } 633 ReturnInst::ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd) 634 : TerminatorInst(Type::getVoidTy(C), Instruction::Ret, 635 OperandTraits<ReturnInst>::op_end(this) - !!retVal, !!retVal, 636 InsertAtEnd) { 637 if (retVal) 638 Op<0>() = retVal; 639 } 640 ReturnInst::ReturnInst(LLVMContext &Context, BasicBlock *InsertAtEnd) 641 : TerminatorInst(Type::getVoidTy(Context), Instruction::Ret, 642 OperandTraits<ReturnInst>::op_end(this), 0, InsertAtEnd) { 643 } 644 645 unsigned ReturnInst::getNumSuccessorsV() const { 646 return getNumSuccessors(); 647 } 648 649 /// Out-of-line ReturnInst method, put here so the C++ compiler can choose to 650 /// emit the vtable for the class in this translation unit. 651 void ReturnInst::setSuccessorV(unsigned idx, BasicBlock *NewSucc) { 652 llvm_unreachable("ReturnInst has no successors!"); 653 } 654 655 BasicBlock *ReturnInst::getSuccessorV(unsigned idx) const { 656 llvm_unreachable("ReturnInst has no successors!"); 657 } 658 659 ReturnInst::~ReturnInst() { 660 } 661 662 //===----------------------------------------------------------------------===// 663 // ResumeInst Implementation 664 //===----------------------------------------------------------------------===// 665 666 ResumeInst::ResumeInst(const ResumeInst &RI) 667 : TerminatorInst(Type::getVoidTy(RI.getContext()), Instruction::Resume, 668 OperandTraits<ResumeInst>::op_begin(this), 1) { 669 Op<0>() = RI.Op<0>(); 670 } 671 672 ResumeInst::ResumeInst(Value *Exn, Instruction *InsertBefore) 673 : TerminatorInst(Type::getVoidTy(Exn->getContext()), Instruction::Resume, 674 OperandTraits<ResumeInst>::op_begin(this), 1, InsertBefore) { 675 Op<0>() = Exn; 676 } 677 678 ResumeInst::ResumeInst(Value *Exn, BasicBlock *InsertAtEnd) 679 : TerminatorInst(Type::getVoidTy(Exn->getContext()), Instruction::Resume, 680 OperandTraits<ResumeInst>::op_begin(this), 1, InsertAtEnd) { 681 Op<0>() = Exn; 682 } 683 684 unsigned ResumeInst::getNumSuccessorsV() const { 685 return getNumSuccessors(); 686 } 687 688 void ResumeInst::setSuccessorV(unsigned idx, BasicBlock *NewSucc) { 689 llvm_unreachable("ResumeInst has no successors!"); 690 } 691 692 BasicBlock *ResumeInst::getSuccessorV(unsigned idx) const { 693 llvm_unreachable("ResumeInst has no successors!"); 694 } 695 696 //===----------------------------------------------------------------------===// 697 // UnreachableInst Implementation 698 //===----------------------------------------------------------------------===// 699 700 UnreachableInst::UnreachableInst(LLVMContext &Context, 701 Instruction *InsertBefore) 702 : TerminatorInst(Type::getVoidTy(Context), Instruction::Unreachable, 703 nullptr, 0, InsertBefore) { 704 } 705 UnreachableInst::UnreachableInst(LLVMContext &Context, BasicBlock *InsertAtEnd) 706 : TerminatorInst(Type::getVoidTy(Context), Instruction::Unreachable, 707 nullptr, 0, InsertAtEnd) { 708 } 709 710 unsigned UnreachableInst::getNumSuccessorsV() const { 711 return getNumSuccessors(); 712 } 713 714 void UnreachableInst::setSuccessorV(unsigned idx, BasicBlock *NewSucc) { 715 llvm_unreachable("UnreachableInst has no successors!"); 716 } 717 718 BasicBlock *UnreachableInst::getSuccessorV(unsigned idx) const { 719 llvm_unreachable("UnreachableInst has no successors!"); 720 } 721 722 //===----------------------------------------------------------------------===// 723 // BranchInst Implementation 724 //===----------------------------------------------------------------------===// 725 726 void BranchInst::AssertOK() { 727 if (isConditional()) 728 assert(getCondition()->getType()->isIntegerTy(1) && 729 "May only branch on boolean predicates!"); 730 } 731 732 BranchInst::BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore) 733 : TerminatorInst(Type::getVoidTy(IfTrue->getContext()), Instruction::Br, 734 OperandTraits<BranchInst>::op_end(this) - 1, 735 1, InsertBefore) { 736 assert(IfTrue && "Branch destination may not be null!"); 737 Op<-1>() = IfTrue; 738 } 739 BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond, 740 Instruction *InsertBefore) 741 : TerminatorInst(Type::getVoidTy(IfTrue->getContext()), Instruction::Br, 742 OperandTraits<BranchInst>::op_end(this) - 3, 743 3, InsertBefore) { 744 Op<-1>() = IfTrue; 745 Op<-2>() = IfFalse; 746 Op<-3>() = Cond; 747 #ifndef NDEBUG 748 AssertOK(); 749 #endif 750 } 751 752 BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd) 753 : TerminatorInst(Type::getVoidTy(IfTrue->getContext()), Instruction::Br, 754 OperandTraits<BranchInst>::op_end(this) - 1, 755 1, InsertAtEnd) { 756 assert(IfTrue && "Branch destination may not be null!"); 757 Op<-1>() = IfTrue; 758 } 759 760 BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond, 761 BasicBlock *InsertAtEnd) 762 : TerminatorInst(Type::getVoidTy(IfTrue->getContext()), Instruction::Br, 763 OperandTraits<BranchInst>::op_end(this) - 3, 764 3, InsertAtEnd) { 765 Op<-1>() = IfTrue; 766 Op<-2>() = IfFalse; 767 Op<-3>() = Cond; 768 #ifndef NDEBUG 769 AssertOK(); 770 #endif 771 } 772 773 774 BranchInst::BranchInst(const BranchInst &BI) : 775 TerminatorInst(Type::getVoidTy(BI.getContext()), Instruction::Br, 776 OperandTraits<BranchInst>::op_end(this) - BI.getNumOperands(), 777 BI.getNumOperands()) { 778 Op<-1>() = BI.Op<-1>(); 779 if (BI.getNumOperands() != 1) { 780 assert(BI.getNumOperands() == 3 && "BR can have 1 or 3 operands!"); 781 Op<-3>() = BI.Op<-3>(); 782 Op<-2>() = BI.Op<-2>(); 783 } 784 SubclassOptionalData = BI.SubclassOptionalData; 785 } 786 787 void BranchInst::swapSuccessors() { 788 assert(isConditional() && 789 "Cannot swap successors of an unconditional branch"); 790 Op<-1>().swap(Op<-2>()); 791 792 // Update profile metadata if present and it matches our structural 793 // expectations. 794 MDNode *ProfileData = getMetadata(LLVMContext::MD_prof); 795 if (!ProfileData || ProfileData->getNumOperands() != 3) 796 return; 797 798 // The first operand is the name. Fetch them backwards and build a new one. 799 Metadata *Ops[] = {ProfileData->getOperand(0), ProfileData->getOperand(2), 800 ProfileData->getOperand(1)}; 801 setMetadata(LLVMContext::MD_prof, 802 MDNode::get(ProfileData->getContext(), Ops)); 803 } 804 805 BasicBlock *BranchInst::getSuccessorV(unsigned idx) const { 806 return getSuccessor(idx); 807 } 808 unsigned BranchInst::getNumSuccessorsV() const { 809 return getNumSuccessors(); 810 } 811 void BranchInst::setSuccessorV(unsigned idx, BasicBlock *B) { 812 setSuccessor(idx, B); 813 } 814 815 816 //===----------------------------------------------------------------------===// 817 // AllocaInst Implementation 818 //===----------------------------------------------------------------------===// 819 820 static Value *getAISize(LLVMContext &Context, Value *Amt) { 821 if (!Amt) 822 Amt = ConstantInt::get(Type::getInt32Ty(Context), 1); 823 else { 824 assert(!isa<BasicBlock>(Amt) && 825 "Passed basic block into allocation size parameter! Use other ctor"); 826 assert(Amt->getType()->isIntegerTy() && 827 "Allocation array size is not an integer!"); 828 } 829 return Amt; 830 } 831 832 AllocaInst::AllocaInst(Type *Ty, Value *ArraySize, 833 const Twine &Name, Instruction *InsertBefore) 834 : UnaryInstruction(PointerType::getUnqual(Ty), Alloca, 835 getAISize(Ty->getContext(), ArraySize), InsertBefore) { 836 setAlignment(0); 837 assert(!Ty->isVoidTy() && "Cannot allocate void!"); 838 setName(Name); 839 } 840 841 AllocaInst::AllocaInst(Type *Ty, Value *ArraySize, 842 const Twine &Name, BasicBlock *InsertAtEnd) 843 : UnaryInstruction(PointerType::getUnqual(Ty), Alloca, 844 getAISize(Ty->getContext(), ArraySize), InsertAtEnd) { 845 setAlignment(0); 846 assert(!Ty->isVoidTy() && "Cannot allocate void!"); 847 setName(Name); 848 } 849 850 AllocaInst::AllocaInst(Type *Ty, const Twine &Name, 851 Instruction *InsertBefore) 852 : UnaryInstruction(PointerType::getUnqual(Ty), Alloca, 853 getAISize(Ty->getContext(), nullptr), InsertBefore) { 854 setAlignment(0); 855 assert(!Ty->isVoidTy() && "Cannot allocate void!"); 856 setName(Name); 857 } 858 859 AllocaInst::AllocaInst(Type *Ty, const Twine &Name, 860 BasicBlock *InsertAtEnd) 861 : UnaryInstruction(PointerType::getUnqual(Ty), Alloca, 862 getAISize(Ty->getContext(), nullptr), InsertAtEnd) { 863 setAlignment(0); 864 assert(!Ty->isVoidTy() && "Cannot allocate void!"); 865 setName(Name); 866 } 867 868 AllocaInst::AllocaInst(Type *Ty, Value *ArraySize, unsigned Align, 869 const Twine &Name, Instruction *InsertBefore) 870 : UnaryInstruction(PointerType::getUnqual(Ty), Alloca, 871 getAISize(Ty->getContext(), ArraySize), InsertBefore) { 872 setAlignment(Align); 873 assert(!Ty->isVoidTy() && "Cannot allocate void!"); 874 setName(Name); 875 } 876 877 AllocaInst::AllocaInst(Type *Ty, Value *ArraySize, unsigned Align, 878 const Twine &Name, BasicBlock *InsertAtEnd) 879 : UnaryInstruction(PointerType::getUnqual(Ty), Alloca, 880 getAISize(Ty->getContext(), ArraySize), InsertAtEnd) { 881 setAlignment(Align); 882 assert(!Ty->isVoidTy() && "Cannot allocate void!"); 883 setName(Name); 884 } 885 886 // Out of line virtual method, so the vtable, etc has a home. 887 AllocaInst::~AllocaInst() { 888 } 889 890 void AllocaInst::setAlignment(unsigned Align) { 891 assert((Align & (Align-1)) == 0 && "Alignment is not a power of 2!"); 892 assert(Align <= MaximumAlignment && 893 "Alignment is greater than MaximumAlignment!"); 894 setInstructionSubclassData((getSubclassDataFromInstruction() & ~31) | 895 (Log2_32(Align) + 1)); 896 assert(getAlignment() == Align && "Alignment representation error!"); 897 } 898 899 bool AllocaInst::isArrayAllocation() const { 900 if (ConstantInt *CI = dyn_cast<ConstantInt>(getOperand(0))) 901 return !CI->isOne(); 902 return true; 903 } 904 905 Type *AllocaInst::getAllocatedType() const { 906 return getType()->getElementType(); 907 } 908 909 /// isStaticAlloca - Return true if this alloca is in the entry block of the 910 /// function and is a constant size. If so, the code generator will fold it 911 /// into the prolog/epilog code, so it is basically free. 912 bool AllocaInst::isStaticAlloca() const { 913 // Must be constant size. 914 if (!isa<ConstantInt>(getArraySize())) return false; 915 916 // Must be in the entry block. 917 const BasicBlock *Parent = getParent(); 918 return Parent == &Parent->getParent()->front() && !isUsedWithInAlloca(); 919 } 920 921 //===----------------------------------------------------------------------===// 922 // LoadInst Implementation 923 //===----------------------------------------------------------------------===// 924 925 void LoadInst::AssertOK() { 926 assert(getOperand(0)->getType()->isPointerTy() && 927 "Ptr must have pointer type."); 928 assert(!(isAtomic() && getAlignment() == 0) && 929 "Alignment required for atomic load"); 930 } 931 932 LoadInst::LoadInst(Value *Ptr, const Twine &Name, Instruction *InsertBef) 933 : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(), 934 Load, Ptr, InsertBef) { 935 setVolatile(false); 936 setAlignment(0); 937 setAtomic(NotAtomic); 938 AssertOK(); 939 setName(Name); 940 } 941 942 LoadInst::LoadInst(Value *Ptr, const Twine &Name, BasicBlock *InsertAE) 943 : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(), 944 Load, Ptr, InsertAE) { 945 setVolatile(false); 946 setAlignment(0); 947 setAtomic(NotAtomic); 948 AssertOK(); 949 setName(Name); 950 } 951 952 LoadInst::LoadInst(Value *Ptr, const Twine &Name, bool isVolatile, 953 Instruction *InsertBef) 954 : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(), 955 Load, Ptr, InsertBef) { 956 setVolatile(isVolatile); 957 setAlignment(0); 958 setAtomic(NotAtomic); 959 AssertOK(); 960 setName(Name); 961 } 962 963 LoadInst::LoadInst(Value *Ptr, const Twine &Name, bool isVolatile, 964 BasicBlock *InsertAE) 965 : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(), 966 Load, Ptr, InsertAE) { 967 setVolatile(isVolatile); 968 setAlignment(0); 969 setAtomic(NotAtomic); 970 AssertOK(); 971 setName(Name); 972 } 973 974 LoadInst::LoadInst(Value *Ptr, const Twine &Name, bool isVolatile, 975 unsigned Align, Instruction *InsertBef) 976 : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(), 977 Load, Ptr, InsertBef) { 978 setVolatile(isVolatile); 979 setAlignment(Align); 980 setAtomic(NotAtomic); 981 AssertOK(); 982 setName(Name); 983 } 984 985 LoadInst::LoadInst(Value *Ptr, const Twine &Name, bool isVolatile, 986 unsigned Align, BasicBlock *InsertAE) 987 : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(), 988 Load, Ptr, InsertAE) { 989 setVolatile(isVolatile); 990 setAlignment(Align); 991 setAtomic(NotAtomic); 992 AssertOK(); 993 setName(Name); 994 } 995 996 LoadInst::LoadInst(Value *Ptr, const Twine &Name, bool isVolatile, 997 unsigned Align, AtomicOrdering Order, 998 SynchronizationScope SynchScope, 999 Instruction *InsertBef) 1000 : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(), 1001 Load, Ptr, InsertBef) { 1002 setVolatile(isVolatile); 1003 setAlignment(Align); 1004 setAtomic(Order, SynchScope); 1005 AssertOK(); 1006 setName(Name); 1007 } 1008 1009 LoadInst::LoadInst(Value *Ptr, const Twine &Name, bool isVolatile, 1010 unsigned Align, AtomicOrdering Order, 1011 SynchronizationScope SynchScope, 1012 BasicBlock *InsertAE) 1013 : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(), 1014 Load, Ptr, InsertAE) { 1015 setVolatile(isVolatile); 1016 setAlignment(Align); 1017 setAtomic(Order, SynchScope); 1018 AssertOK(); 1019 setName(Name); 1020 } 1021 1022 LoadInst::LoadInst(Value *Ptr, const char *Name, Instruction *InsertBef) 1023 : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(), 1024 Load, Ptr, InsertBef) { 1025 setVolatile(false); 1026 setAlignment(0); 1027 setAtomic(NotAtomic); 1028 AssertOK(); 1029 if (Name && Name[0]) setName(Name); 1030 } 1031 1032 LoadInst::LoadInst(Value *Ptr, const char *Name, BasicBlock *InsertAE) 1033 : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(), 1034 Load, Ptr, InsertAE) { 1035 setVolatile(false); 1036 setAlignment(0); 1037 setAtomic(NotAtomic); 1038 AssertOK(); 1039 if (Name && Name[0]) setName(Name); 1040 } 1041 1042 LoadInst::LoadInst(Value *Ptr, const char *Name, bool isVolatile, 1043 Instruction *InsertBef) 1044 : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(), 1045 Load, Ptr, InsertBef) { 1046 setVolatile(isVolatile); 1047 setAlignment(0); 1048 setAtomic(NotAtomic); 1049 AssertOK(); 1050 if (Name && Name[0]) setName(Name); 1051 } 1052 1053 LoadInst::LoadInst(Value *Ptr, const char *Name, bool isVolatile, 1054 BasicBlock *InsertAE) 1055 : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(), 1056 Load, Ptr, InsertAE) { 1057 setVolatile(isVolatile); 1058 setAlignment(0); 1059 setAtomic(NotAtomic); 1060 AssertOK(); 1061 if (Name && Name[0]) setName(Name); 1062 } 1063 1064 void LoadInst::setAlignment(unsigned Align) { 1065 assert((Align & (Align-1)) == 0 && "Alignment is not a power of 2!"); 1066 assert(Align <= MaximumAlignment && 1067 "Alignment is greater than MaximumAlignment!"); 1068 setInstructionSubclassData((getSubclassDataFromInstruction() & ~(31 << 1)) | 1069 ((Log2_32(Align)+1)<<1)); 1070 assert(getAlignment() == Align && "Alignment representation error!"); 1071 } 1072 1073 //===----------------------------------------------------------------------===// 1074 // StoreInst Implementation 1075 //===----------------------------------------------------------------------===// 1076 1077 void StoreInst::AssertOK() { 1078 assert(getOperand(0) && getOperand(1) && "Both operands must be non-null!"); 1079 assert(getOperand(1)->getType()->isPointerTy() && 1080 "Ptr must have pointer type!"); 1081 assert(getOperand(0)->getType() == 1082 cast<PointerType>(getOperand(1)->getType())->getElementType() 1083 && "Ptr must be a pointer to Val type!"); 1084 assert(!(isAtomic() && getAlignment() == 0) && 1085 "Alignment required for atomic store"); 1086 } 1087 1088 1089 StoreInst::StoreInst(Value *val, Value *addr, Instruction *InsertBefore) 1090 : Instruction(Type::getVoidTy(val->getContext()), Store, 1091 OperandTraits<StoreInst>::op_begin(this), 1092 OperandTraits<StoreInst>::operands(this), 1093 InsertBefore) { 1094 Op<0>() = val; 1095 Op<1>() = addr; 1096 setVolatile(false); 1097 setAlignment(0); 1098 setAtomic(NotAtomic); 1099 AssertOK(); 1100 } 1101 1102 StoreInst::StoreInst(Value *val, Value *addr, BasicBlock *InsertAtEnd) 1103 : Instruction(Type::getVoidTy(val->getContext()), Store, 1104 OperandTraits<StoreInst>::op_begin(this), 1105 OperandTraits<StoreInst>::operands(this), 1106 InsertAtEnd) { 1107 Op<0>() = val; 1108 Op<1>() = addr; 1109 setVolatile(false); 1110 setAlignment(0); 1111 setAtomic(NotAtomic); 1112 AssertOK(); 1113 } 1114 1115 StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, 1116 Instruction *InsertBefore) 1117 : Instruction(Type::getVoidTy(val->getContext()), Store, 1118 OperandTraits<StoreInst>::op_begin(this), 1119 OperandTraits<StoreInst>::operands(this), 1120 InsertBefore) { 1121 Op<0>() = val; 1122 Op<1>() = addr; 1123 setVolatile(isVolatile); 1124 setAlignment(0); 1125 setAtomic(NotAtomic); 1126 AssertOK(); 1127 } 1128 1129 StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, 1130 unsigned Align, Instruction *InsertBefore) 1131 : Instruction(Type::getVoidTy(val->getContext()), Store, 1132 OperandTraits<StoreInst>::op_begin(this), 1133 OperandTraits<StoreInst>::operands(this), 1134 InsertBefore) { 1135 Op<0>() = val; 1136 Op<1>() = addr; 1137 setVolatile(isVolatile); 1138 setAlignment(Align); 1139 setAtomic(NotAtomic); 1140 AssertOK(); 1141 } 1142 1143 StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, 1144 unsigned Align, AtomicOrdering Order, 1145 SynchronizationScope SynchScope, 1146 Instruction *InsertBefore) 1147 : Instruction(Type::getVoidTy(val->getContext()), Store, 1148 OperandTraits<StoreInst>::op_begin(this), 1149 OperandTraits<StoreInst>::operands(this), 1150 InsertBefore) { 1151 Op<0>() = val; 1152 Op<1>() = addr; 1153 setVolatile(isVolatile); 1154 setAlignment(Align); 1155 setAtomic(Order, SynchScope); 1156 AssertOK(); 1157 } 1158 1159 StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, 1160 BasicBlock *InsertAtEnd) 1161 : Instruction(Type::getVoidTy(val->getContext()), Store, 1162 OperandTraits<StoreInst>::op_begin(this), 1163 OperandTraits<StoreInst>::operands(this), 1164 InsertAtEnd) { 1165 Op<0>() = val; 1166 Op<1>() = addr; 1167 setVolatile(isVolatile); 1168 setAlignment(0); 1169 setAtomic(NotAtomic); 1170 AssertOK(); 1171 } 1172 1173 StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, 1174 unsigned Align, BasicBlock *InsertAtEnd) 1175 : Instruction(Type::getVoidTy(val->getContext()), Store, 1176 OperandTraits<StoreInst>::op_begin(this), 1177 OperandTraits<StoreInst>::operands(this), 1178 InsertAtEnd) { 1179 Op<0>() = val; 1180 Op<1>() = addr; 1181 setVolatile(isVolatile); 1182 setAlignment(Align); 1183 setAtomic(NotAtomic); 1184 AssertOK(); 1185 } 1186 1187 StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, 1188 unsigned Align, AtomicOrdering Order, 1189 SynchronizationScope SynchScope, 1190 BasicBlock *InsertAtEnd) 1191 : Instruction(Type::getVoidTy(val->getContext()), Store, 1192 OperandTraits<StoreInst>::op_begin(this), 1193 OperandTraits<StoreInst>::operands(this), 1194 InsertAtEnd) { 1195 Op<0>() = val; 1196 Op<1>() = addr; 1197 setVolatile(isVolatile); 1198 setAlignment(Align); 1199 setAtomic(Order, SynchScope); 1200 AssertOK(); 1201 } 1202 1203 void StoreInst::setAlignment(unsigned Align) { 1204 assert((Align & (Align-1)) == 0 && "Alignment is not a power of 2!"); 1205 assert(Align <= MaximumAlignment && 1206 "Alignment is greater than MaximumAlignment!"); 1207 setInstructionSubclassData((getSubclassDataFromInstruction() & ~(31 << 1)) | 1208 ((Log2_32(Align)+1) << 1)); 1209 assert(getAlignment() == Align && "Alignment representation error!"); 1210 } 1211 1212 //===----------------------------------------------------------------------===// 1213 // AtomicCmpXchgInst Implementation 1214 //===----------------------------------------------------------------------===// 1215 1216 void AtomicCmpXchgInst::Init(Value *Ptr, Value *Cmp, Value *NewVal, 1217 AtomicOrdering SuccessOrdering, 1218 AtomicOrdering FailureOrdering, 1219 SynchronizationScope SynchScope) { 1220 Op<0>() = Ptr; 1221 Op<1>() = Cmp; 1222 Op<2>() = NewVal; 1223 setSuccessOrdering(SuccessOrdering); 1224 setFailureOrdering(FailureOrdering); 1225 setSynchScope(SynchScope); 1226 1227 assert(getOperand(0) && getOperand(1) && getOperand(2) && 1228 "All operands must be non-null!"); 1229 assert(getOperand(0)->getType()->isPointerTy() && 1230 "Ptr must have pointer type!"); 1231 assert(getOperand(1)->getType() == 1232 cast<PointerType>(getOperand(0)->getType())->getElementType() 1233 && "Ptr must be a pointer to Cmp type!"); 1234 assert(getOperand(2)->getType() == 1235 cast<PointerType>(getOperand(0)->getType())->getElementType() 1236 && "Ptr must be a pointer to NewVal type!"); 1237 assert(SuccessOrdering != NotAtomic && 1238 "AtomicCmpXchg instructions must be atomic!"); 1239 assert(FailureOrdering != NotAtomic && 1240 "AtomicCmpXchg instructions must be atomic!"); 1241 assert(SuccessOrdering >= FailureOrdering && 1242 "AtomicCmpXchg success ordering must be at least as strong as fail"); 1243 assert(FailureOrdering != Release && FailureOrdering != AcquireRelease && 1244 "AtomicCmpXchg failure ordering cannot include release semantics"); 1245 } 1246 1247 AtomicCmpXchgInst::AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, 1248 AtomicOrdering SuccessOrdering, 1249 AtomicOrdering FailureOrdering, 1250 SynchronizationScope SynchScope, 1251 Instruction *InsertBefore) 1252 : Instruction( 1253 StructType::get(Cmp->getType(), Type::getInt1Ty(Cmp->getContext()), 1254 nullptr), 1255 AtomicCmpXchg, OperandTraits<AtomicCmpXchgInst>::op_begin(this), 1256 OperandTraits<AtomicCmpXchgInst>::operands(this), InsertBefore) { 1257 Init(Ptr, Cmp, NewVal, SuccessOrdering, FailureOrdering, SynchScope); 1258 } 1259 1260 AtomicCmpXchgInst::AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, 1261 AtomicOrdering SuccessOrdering, 1262 AtomicOrdering FailureOrdering, 1263 SynchronizationScope SynchScope, 1264 BasicBlock *InsertAtEnd) 1265 : Instruction( 1266 StructType::get(Cmp->getType(), Type::getInt1Ty(Cmp->getContext()), 1267 nullptr), 1268 AtomicCmpXchg, OperandTraits<AtomicCmpXchgInst>::op_begin(this), 1269 OperandTraits<AtomicCmpXchgInst>::operands(this), InsertAtEnd) { 1270 Init(Ptr, Cmp, NewVal, SuccessOrdering, FailureOrdering, SynchScope); 1271 } 1272 1273 //===----------------------------------------------------------------------===// 1274 // AtomicRMWInst Implementation 1275 //===----------------------------------------------------------------------===// 1276 1277 void AtomicRMWInst::Init(BinOp Operation, Value *Ptr, Value *Val, 1278 AtomicOrdering Ordering, 1279 SynchronizationScope SynchScope) { 1280 Op<0>() = Ptr; 1281 Op<1>() = Val; 1282 setOperation(Operation); 1283 setOrdering(Ordering); 1284 setSynchScope(SynchScope); 1285 1286 assert(getOperand(0) && getOperand(1) && 1287 "All operands must be non-null!"); 1288 assert(getOperand(0)->getType()->isPointerTy() && 1289 "Ptr must have pointer type!"); 1290 assert(getOperand(1)->getType() == 1291 cast<PointerType>(getOperand(0)->getType())->getElementType() 1292 && "Ptr must be a pointer to Val type!"); 1293 assert(Ordering != NotAtomic && 1294 "AtomicRMW instructions must be atomic!"); 1295 } 1296 1297 AtomicRMWInst::AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, 1298 AtomicOrdering Ordering, 1299 SynchronizationScope SynchScope, 1300 Instruction *InsertBefore) 1301 : Instruction(Val->getType(), AtomicRMW, 1302 OperandTraits<AtomicRMWInst>::op_begin(this), 1303 OperandTraits<AtomicRMWInst>::operands(this), 1304 InsertBefore) { 1305 Init(Operation, Ptr, Val, Ordering, SynchScope); 1306 } 1307 1308 AtomicRMWInst::AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, 1309 AtomicOrdering Ordering, 1310 SynchronizationScope SynchScope, 1311 BasicBlock *InsertAtEnd) 1312 : Instruction(Val->getType(), AtomicRMW, 1313 OperandTraits<AtomicRMWInst>::op_begin(this), 1314 OperandTraits<AtomicRMWInst>::operands(this), 1315 InsertAtEnd) { 1316 Init(Operation, Ptr, Val, Ordering, SynchScope); 1317 } 1318 1319 //===----------------------------------------------------------------------===// 1320 // FenceInst Implementation 1321 //===----------------------------------------------------------------------===// 1322 1323 FenceInst::FenceInst(LLVMContext &C, AtomicOrdering Ordering, 1324 SynchronizationScope SynchScope, 1325 Instruction *InsertBefore) 1326 : Instruction(Type::getVoidTy(C), Fence, nullptr, 0, InsertBefore) { 1327 setOrdering(Ordering); 1328 setSynchScope(SynchScope); 1329 } 1330 1331 FenceInst::FenceInst(LLVMContext &C, AtomicOrdering Ordering, 1332 SynchronizationScope SynchScope, 1333 BasicBlock *InsertAtEnd) 1334 : Instruction(Type::getVoidTy(C), Fence, nullptr, 0, InsertAtEnd) { 1335 setOrdering(Ordering); 1336 setSynchScope(SynchScope); 1337 } 1338 1339 //===----------------------------------------------------------------------===// 1340 // GetElementPtrInst Implementation 1341 //===----------------------------------------------------------------------===// 1342 1343 void GetElementPtrInst::init(Value *Ptr, ArrayRef<Value *> IdxList, 1344 const Twine &Name) { 1345 assert(NumOperands == 1 + IdxList.size() && "NumOperands not initialized?"); 1346 OperandList[0] = Ptr; 1347 std::copy(IdxList.begin(), IdxList.end(), op_begin() + 1); 1348 setName(Name); 1349 } 1350 1351 GetElementPtrInst::GetElementPtrInst(const GetElementPtrInst &GEPI) 1352 : Instruction(GEPI.getType(), GetElementPtr, 1353 OperandTraits<GetElementPtrInst>::op_end(this) 1354 - GEPI.getNumOperands(), 1355 GEPI.getNumOperands()) { 1356 std::copy(GEPI.op_begin(), GEPI.op_end(), op_begin()); 1357 SubclassOptionalData = GEPI.SubclassOptionalData; 1358 } 1359 1360 /// getIndexedType - Returns the type of the element that would be accessed with 1361 /// a gep instruction with the specified parameters. 1362 /// 1363 /// The Idxs pointer should point to a continuous piece of memory containing the 1364 /// indices, either as Value* or uint64_t. 1365 /// 1366 /// A null type is returned if the indices are invalid for the specified 1367 /// pointer type. 1368 /// 1369 template <typename IndexTy> 1370 static Type *getIndexedTypeInternal(Type *Ptr, ArrayRef<IndexTy> IdxList) { 1371 PointerType *PTy = dyn_cast<PointerType>(Ptr->getScalarType()); 1372 if (!PTy) return nullptr; // Type isn't a pointer type! 1373 Type *Agg = PTy->getElementType(); 1374 1375 // Handle the special case of the empty set index set, which is always valid. 1376 if (IdxList.empty()) 1377 return Agg; 1378 1379 // If there is at least one index, the top level type must be sized, otherwise 1380 // it cannot be 'stepped over'. 1381 if (!Agg->isSized()) 1382 return nullptr; 1383 1384 unsigned CurIdx = 1; 1385 for (; CurIdx != IdxList.size(); ++CurIdx) { 1386 CompositeType *CT = dyn_cast<CompositeType>(Agg); 1387 if (!CT || CT->isPointerTy()) return nullptr; 1388 IndexTy Index = IdxList[CurIdx]; 1389 if (!CT->indexValid(Index)) return nullptr; 1390 Agg = CT->getTypeAtIndex(Index); 1391 } 1392 return CurIdx == IdxList.size() ? Agg : nullptr; 1393 } 1394 1395 Type *GetElementPtrInst::getIndexedType(Type *Ptr, ArrayRef<Value *> IdxList) { 1396 return getIndexedTypeInternal(Ptr, IdxList); 1397 } 1398 1399 Type *GetElementPtrInst::getIndexedType(Type *Ptr, 1400 ArrayRef<Constant *> IdxList) { 1401 return getIndexedTypeInternal(Ptr, IdxList); 1402 } 1403 1404 Type *GetElementPtrInst::getIndexedType(Type *Ptr, ArrayRef<uint64_t> IdxList) { 1405 return getIndexedTypeInternal(Ptr, IdxList); 1406 } 1407 1408 /// hasAllZeroIndices - Return true if all of the indices of this GEP are 1409 /// zeros. If so, the result pointer and the first operand have the same 1410 /// value, just potentially different types. 1411 bool GetElementPtrInst::hasAllZeroIndices() const { 1412 for (unsigned i = 1, e = getNumOperands(); i != e; ++i) { 1413 if (ConstantInt *CI = dyn_cast<ConstantInt>(getOperand(i))) { 1414 if (!CI->isZero()) return false; 1415 } else { 1416 return false; 1417 } 1418 } 1419 return true; 1420 } 1421 1422 /// hasAllConstantIndices - Return true if all of the indices of this GEP are 1423 /// constant integers. If so, the result pointer and the first operand have 1424 /// a constant offset between them. 1425 bool GetElementPtrInst::hasAllConstantIndices() const { 1426 for (unsigned i = 1, e = getNumOperands(); i != e; ++i) { 1427 if (!isa<ConstantInt>(getOperand(i))) 1428 return false; 1429 } 1430 return true; 1431 } 1432 1433 void GetElementPtrInst::setIsInBounds(bool B) { 1434 cast<GEPOperator>(this)->setIsInBounds(B); 1435 } 1436 1437 bool GetElementPtrInst::isInBounds() const { 1438 return cast<GEPOperator>(this)->isInBounds(); 1439 } 1440 1441 bool GetElementPtrInst::accumulateConstantOffset(const DataLayout &DL, 1442 APInt &Offset) const { 1443 // Delegate to the generic GEPOperator implementation. 1444 return cast<GEPOperator>(this)->accumulateConstantOffset(DL, Offset); 1445 } 1446 1447 //===----------------------------------------------------------------------===// 1448 // ExtractElementInst Implementation 1449 //===----------------------------------------------------------------------===// 1450 1451 ExtractElementInst::ExtractElementInst(Value *Val, Value *Index, 1452 const Twine &Name, 1453 Instruction *InsertBef) 1454 : Instruction(cast<VectorType>(Val->getType())->getElementType(), 1455 ExtractElement, 1456 OperandTraits<ExtractElementInst>::op_begin(this), 1457 2, InsertBef) { 1458 assert(isValidOperands(Val, Index) && 1459 "Invalid extractelement instruction operands!"); 1460 Op<0>() = Val; 1461 Op<1>() = Index; 1462 setName(Name); 1463 } 1464 1465 ExtractElementInst::ExtractElementInst(Value *Val, Value *Index, 1466 const Twine &Name, 1467 BasicBlock *InsertAE) 1468 : Instruction(cast<VectorType>(Val->getType())->getElementType(), 1469 ExtractElement, 1470 OperandTraits<ExtractElementInst>::op_begin(this), 1471 2, InsertAE) { 1472 assert(isValidOperands(Val, Index) && 1473 "Invalid extractelement instruction operands!"); 1474 1475 Op<0>() = Val; 1476 Op<1>() = Index; 1477 setName(Name); 1478 } 1479 1480 1481 bool ExtractElementInst::isValidOperands(const Value *Val, const Value *Index) { 1482 if (!Val->getType()->isVectorTy() || !Index->getType()->isIntegerTy()) 1483 return false; 1484 return true; 1485 } 1486 1487 1488 //===----------------------------------------------------------------------===// 1489 // InsertElementInst Implementation 1490 //===----------------------------------------------------------------------===// 1491 1492 InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index, 1493 const Twine &Name, 1494 Instruction *InsertBef) 1495 : Instruction(Vec->getType(), InsertElement, 1496 OperandTraits<InsertElementInst>::op_begin(this), 1497 3, InsertBef) { 1498 assert(isValidOperands(Vec, Elt, Index) && 1499 "Invalid insertelement instruction operands!"); 1500 Op<0>() = Vec; 1501 Op<1>() = Elt; 1502 Op<2>() = Index; 1503 setName(Name); 1504 } 1505 1506 InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index, 1507 const Twine &Name, 1508 BasicBlock *InsertAE) 1509 : Instruction(Vec->getType(), InsertElement, 1510 OperandTraits<InsertElementInst>::op_begin(this), 1511 3, InsertAE) { 1512 assert(isValidOperands(Vec, Elt, Index) && 1513 "Invalid insertelement instruction operands!"); 1514 1515 Op<0>() = Vec; 1516 Op<1>() = Elt; 1517 Op<2>() = Index; 1518 setName(Name); 1519 } 1520 1521 bool InsertElementInst::isValidOperands(const Value *Vec, const Value *Elt, 1522 const Value *Index) { 1523 if (!Vec->getType()->isVectorTy()) 1524 return false; // First operand of insertelement must be vector type. 1525 1526 if (Elt->getType() != cast<VectorType>(Vec->getType())->getElementType()) 1527 return false;// Second operand of insertelement must be vector element type. 1528 1529 if (!Index->getType()->isIntegerTy()) 1530 return false; // Third operand of insertelement must be i32. 1531 return true; 1532 } 1533 1534 1535 //===----------------------------------------------------------------------===// 1536 // ShuffleVectorInst Implementation 1537 //===----------------------------------------------------------------------===// 1538 1539 ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, Value *Mask, 1540 const Twine &Name, 1541 Instruction *InsertBefore) 1542 : Instruction(VectorType::get(cast<VectorType>(V1->getType())->getElementType(), 1543 cast<VectorType>(Mask->getType())->getNumElements()), 1544 ShuffleVector, 1545 OperandTraits<ShuffleVectorInst>::op_begin(this), 1546 OperandTraits<ShuffleVectorInst>::operands(this), 1547 InsertBefore) { 1548 assert(isValidOperands(V1, V2, Mask) && 1549 "Invalid shuffle vector instruction operands!"); 1550 Op<0>() = V1; 1551 Op<1>() = V2; 1552 Op<2>() = Mask; 1553 setName(Name); 1554 } 1555 1556 ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, Value *Mask, 1557 const Twine &Name, 1558 BasicBlock *InsertAtEnd) 1559 : Instruction(VectorType::get(cast<VectorType>(V1->getType())->getElementType(), 1560 cast<VectorType>(Mask->getType())->getNumElements()), 1561 ShuffleVector, 1562 OperandTraits<ShuffleVectorInst>::op_begin(this), 1563 OperandTraits<ShuffleVectorInst>::operands(this), 1564 InsertAtEnd) { 1565 assert(isValidOperands(V1, V2, Mask) && 1566 "Invalid shuffle vector instruction operands!"); 1567 1568 Op<0>() = V1; 1569 Op<1>() = V2; 1570 Op<2>() = Mask; 1571 setName(Name); 1572 } 1573 1574 bool ShuffleVectorInst::isValidOperands(const Value *V1, const Value *V2, 1575 const Value *Mask) { 1576 // V1 and V2 must be vectors of the same type. 1577 if (!V1->getType()->isVectorTy() || V1->getType() != V2->getType()) 1578 return false; 1579 1580 // Mask must be vector of i32. 1581 VectorType *MaskTy = dyn_cast<VectorType>(Mask->getType()); 1582 if (!MaskTy || !MaskTy->getElementType()->isIntegerTy(32)) 1583 return false; 1584 1585 // Check to see if Mask is valid. 1586 if (isa<UndefValue>(Mask) || isa<ConstantAggregateZero>(Mask)) 1587 return true; 1588 1589 if (const ConstantVector *MV = dyn_cast<ConstantVector>(Mask)) { 1590 unsigned V1Size = cast<VectorType>(V1->getType())->getNumElements(); 1591 for (Value *Op : MV->operands()) { 1592 if (ConstantInt *CI = dyn_cast<ConstantInt>(Op)) { 1593 if (CI->uge(V1Size*2)) 1594 return false; 1595 } else if (!isa<UndefValue>(Op)) { 1596 return false; 1597 } 1598 } 1599 return true; 1600 } 1601 1602 if (const ConstantDataSequential *CDS = 1603 dyn_cast<ConstantDataSequential>(Mask)) { 1604 unsigned V1Size = cast<VectorType>(V1->getType())->getNumElements(); 1605 for (unsigned i = 0, e = MaskTy->getNumElements(); i != e; ++i) 1606 if (CDS->getElementAsInteger(i) >= V1Size*2) 1607 return false; 1608 return true; 1609 } 1610 1611 // The bitcode reader can create a place holder for a forward reference 1612 // used as the shuffle mask. When this occurs, the shuffle mask will 1613 // fall into this case and fail. To avoid this error, do this bit of 1614 // ugliness to allow such a mask pass. 1615 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(Mask)) 1616 if (CE->getOpcode() == Instruction::UserOp1) 1617 return true; 1618 1619 return false; 1620 } 1621 1622 /// getMaskValue - Return the index from the shuffle mask for the specified 1623 /// output result. This is either -1 if the element is undef or a number less 1624 /// than 2*numelements. 1625 int ShuffleVectorInst::getMaskValue(Constant *Mask, unsigned i) { 1626 assert(i < Mask->getType()->getVectorNumElements() && "Index out of range"); 1627 if (ConstantDataSequential *CDS =dyn_cast<ConstantDataSequential>(Mask)) 1628 return CDS->getElementAsInteger(i); 1629 Constant *C = Mask->getAggregateElement(i); 1630 if (isa<UndefValue>(C)) 1631 return -1; 1632 return cast<ConstantInt>(C)->getZExtValue(); 1633 } 1634 1635 /// getShuffleMask - Return the full mask for this instruction, where each 1636 /// element is the element number and undef's are returned as -1. 1637 void ShuffleVectorInst::getShuffleMask(Constant *Mask, 1638 SmallVectorImpl<int> &Result) { 1639 unsigned NumElts = Mask->getType()->getVectorNumElements(); 1640 1641 if (ConstantDataSequential *CDS=dyn_cast<ConstantDataSequential>(Mask)) { 1642 for (unsigned i = 0; i != NumElts; ++i) 1643 Result.push_back(CDS->getElementAsInteger(i)); 1644 return; 1645 } 1646 for (unsigned i = 0; i != NumElts; ++i) { 1647 Constant *C = Mask->getAggregateElement(i); 1648 Result.push_back(isa<UndefValue>(C) ? -1 : 1649 cast<ConstantInt>(C)->getZExtValue()); 1650 } 1651 } 1652 1653 1654 //===----------------------------------------------------------------------===// 1655 // InsertValueInst Class 1656 //===----------------------------------------------------------------------===// 1657 1658 void InsertValueInst::init(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs, 1659 const Twine &Name) { 1660 assert(NumOperands == 2 && "NumOperands not initialized?"); 1661 1662 // There's no fundamental reason why we require at least one index 1663 // (other than weirdness with &*IdxBegin being invalid; see 1664 // getelementptr's init routine for example). But there's no 1665 // present need to support it. 1666 assert(Idxs.size() > 0 && "InsertValueInst must have at least one index"); 1667 1668 assert(ExtractValueInst::getIndexedType(Agg->getType(), Idxs) == 1669 Val->getType() && "Inserted value must match indexed type!"); 1670 Op<0>() = Agg; 1671 Op<1>() = Val; 1672 1673 Indices.append(Idxs.begin(), Idxs.end()); 1674 setName(Name); 1675 } 1676 1677 InsertValueInst::InsertValueInst(const InsertValueInst &IVI) 1678 : Instruction(IVI.getType(), InsertValue, 1679 OperandTraits<InsertValueInst>::op_begin(this), 2), 1680 Indices(IVI.Indices) { 1681 Op<0>() = IVI.getOperand(0); 1682 Op<1>() = IVI.getOperand(1); 1683 SubclassOptionalData = IVI.SubclassOptionalData; 1684 } 1685 1686 //===----------------------------------------------------------------------===// 1687 // ExtractValueInst Class 1688 //===----------------------------------------------------------------------===// 1689 1690 void ExtractValueInst::init(ArrayRef<unsigned> Idxs, const Twine &Name) { 1691 assert(NumOperands == 1 && "NumOperands not initialized?"); 1692 1693 // There's no fundamental reason why we require at least one index. 1694 // But there's no present need to support it. 1695 assert(Idxs.size() > 0 && "ExtractValueInst must have at least one index"); 1696 1697 Indices.append(Idxs.begin(), Idxs.end()); 1698 setName(Name); 1699 } 1700 1701 ExtractValueInst::ExtractValueInst(const ExtractValueInst &EVI) 1702 : UnaryInstruction(EVI.getType(), ExtractValue, EVI.getOperand(0)), 1703 Indices(EVI.Indices) { 1704 SubclassOptionalData = EVI.SubclassOptionalData; 1705 } 1706 1707 // getIndexedType - Returns the type of the element that would be extracted 1708 // with an extractvalue instruction with the specified parameters. 1709 // 1710 // A null type is returned if the indices are invalid for the specified 1711 // pointer type. 1712 // 1713 Type *ExtractValueInst::getIndexedType(Type *Agg, 1714 ArrayRef<unsigned> Idxs) { 1715 for (unsigned Index : Idxs) { 1716 // We can't use CompositeType::indexValid(Index) here. 1717 // indexValid() always returns true for arrays because getelementptr allows 1718 // out-of-bounds indices. Since we don't allow those for extractvalue and 1719 // insertvalue we need to check array indexing manually. 1720 // Since the only other types we can index into are struct types it's just 1721 // as easy to check those manually as well. 1722 if (ArrayType *AT = dyn_cast<ArrayType>(Agg)) { 1723 if (Index >= AT->getNumElements()) 1724 return nullptr; 1725 } else if (StructType *ST = dyn_cast<StructType>(Agg)) { 1726 if (Index >= ST->getNumElements()) 1727 return nullptr; 1728 } else { 1729 // Not a valid type to index into. 1730 return nullptr; 1731 } 1732 1733 Agg = cast<CompositeType>(Agg)->getTypeAtIndex(Index); 1734 } 1735 return const_cast<Type*>(Agg); 1736 } 1737 1738 //===----------------------------------------------------------------------===// 1739 // BinaryOperator Class 1740 //===----------------------------------------------------------------------===// 1741 1742 BinaryOperator::BinaryOperator(BinaryOps iType, Value *S1, Value *S2, 1743 Type *Ty, const Twine &Name, 1744 Instruction *InsertBefore) 1745 : Instruction(Ty, iType, 1746 OperandTraits<BinaryOperator>::op_begin(this), 1747 OperandTraits<BinaryOperator>::operands(this), 1748 InsertBefore) { 1749 Op<0>() = S1; 1750 Op<1>() = S2; 1751 init(iType); 1752 setName(Name); 1753 } 1754 1755 BinaryOperator::BinaryOperator(BinaryOps iType, Value *S1, Value *S2, 1756 Type *Ty, const Twine &Name, 1757 BasicBlock *InsertAtEnd) 1758 : Instruction(Ty, iType, 1759 OperandTraits<BinaryOperator>::op_begin(this), 1760 OperandTraits<BinaryOperator>::operands(this), 1761 InsertAtEnd) { 1762 Op<0>() = S1; 1763 Op<1>() = S2; 1764 init(iType); 1765 setName(Name); 1766 } 1767 1768 1769 void BinaryOperator::init(BinaryOps iType) { 1770 Value *LHS = getOperand(0), *RHS = getOperand(1); 1771 (void)LHS; (void)RHS; // Silence warnings. 1772 assert(LHS->getType() == RHS->getType() && 1773 "Binary operator operand types must match!"); 1774 #ifndef NDEBUG 1775 switch (iType) { 1776 case Add: case Sub: 1777 case Mul: 1778 assert(getType() == LHS->getType() && 1779 "Arithmetic operation should return same type as operands!"); 1780 assert(getType()->isIntOrIntVectorTy() && 1781 "Tried to create an integer operation on a non-integer type!"); 1782 break; 1783 case FAdd: case FSub: 1784 case FMul: 1785 assert(getType() == LHS->getType() && 1786 "Arithmetic operation should return same type as operands!"); 1787 assert(getType()->isFPOrFPVectorTy() && 1788 "Tried to create a floating-point operation on a " 1789 "non-floating-point type!"); 1790 break; 1791 case UDiv: 1792 case SDiv: 1793 assert(getType() == LHS->getType() && 1794 "Arithmetic operation should return same type as operands!"); 1795 assert((getType()->isIntegerTy() || (getType()->isVectorTy() && 1796 cast<VectorType>(getType())->getElementType()->isIntegerTy())) && 1797 "Incorrect operand type (not integer) for S/UDIV"); 1798 break; 1799 case FDiv: 1800 assert(getType() == LHS->getType() && 1801 "Arithmetic operation should return same type as operands!"); 1802 assert(getType()->isFPOrFPVectorTy() && 1803 "Incorrect operand type (not floating point) for FDIV"); 1804 break; 1805 case URem: 1806 case SRem: 1807 assert(getType() == LHS->getType() && 1808 "Arithmetic operation should return same type as operands!"); 1809 assert((getType()->isIntegerTy() || (getType()->isVectorTy() && 1810 cast<VectorType>(getType())->getElementType()->isIntegerTy())) && 1811 "Incorrect operand type (not integer) for S/UREM"); 1812 break; 1813 case FRem: 1814 assert(getType() == LHS->getType() && 1815 "Arithmetic operation should return same type as operands!"); 1816 assert(getType()->isFPOrFPVectorTy() && 1817 "Incorrect operand type (not floating point) for FREM"); 1818 break; 1819 case Shl: 1820 case LShr: 1821 case AShr: 1822 assert(getType() == LHS->getType() && 1823 "Shift operation should return same type as operands!"); 1824 assert((getType()->isIntegerTy() || 1825 (getType()->isVectorTy() && 1826 cast<VectorType>(getType())->getElementType()->isIntegerTy())) && 1827 "Tried to create a shift operation on a non-integral type!"); 1828 break; 1829 case And: case Or: 1830 case Xor: 1831 assert(getType() == LHS->getType() && 1832 "Logical operation should return same type as operands!"); 1833 assert((getType()->isIntegerTy() || 1834 (getType()->isVectorTy() && 1835 cast<VectorType>(getType())->getElementType()->isIntegerTy())) && 1836 "Tried to create a logical operation on a non-integral type!"); 1837 break; 1838 default: 1839 break; 1840 } 1841 #endif 1842 } 1843 1844 BinaryOperator *BinaryOperator::Create(BinaryOps Op, Value *S1, Value *S2, 1845 const Twine &Name, 1846 Instruction *InsertBefore) { 1847 assert(S1->getType() == S2->getType() && 1848 "Cannot create binary operator with two operands of differing type!"); 1849 return new BinaryOperator(Op, S1, S2, S1->getType(), Name, InsertBefore); 1850 } 1851 1852 BinaryOperator *BinaryOperator::Create(BinaryOps Op, Value *S1, Value *S2, 1853 const Twine &Name, 1854 BasicBlock *InsertAtEnd) { 1855 BinaryOperator *Res = Create(Op, S1, S2, Name); 1856 InsertAtEnd->getInstList().push_back(Res); 1857 return Res; 1858 } 1859 1860 BinaryOperator *BinaryOperator::CreateNeg(Value *Op, const Twine &Name, 1861 Instruction *InsertBefore) { 1862 Value *zero = ConstantFP::getZeroValueForNegation(Op->getType()); 1863 return new BinaryOperator(Instruction::Sub, 1864 zero, Op, 1865 Op->getType(), Name, InsertBefore); 1866 } 1867 1868 BinaryOperator *BinaryOperator::CreateNeg(Value *Op, const Twine &Name, 1869 BasicBlock *InsertAtEnd) { 1870 Value *zero = ConstantFP::getZeroValueForNegation(Op->getType()); 1871 return new BinaryOperator(Instruction::Sub, 1872 zero, Op, 1873 Op->getType(), Name, InsertAtEnd); 1874 } 1875 1876 BinaryOperator *BinaryOperator::CreateNSWNeg(Value *Op, const Twine &Name, 1877 Instruction *InsertBefore) { 1878 Value *zero = ConstantFP::getZeroValueForNegation(Op->getType()); 1879 return BinaryOperator::CreateNSWSub(zero, Op, Name, InsertBefore); 1880 } 1881 1882 BinaryOperator *BinaryOperator::CreateNSWNeg(Value *Op, const Twine &Name, 1883 BasicBlock *InsertAtEnd) { 1884 Value *zero = ConstantFP::getZeroValueForNegation(Op->getType()); 1885 return BinaryOperator::CreateNSWSub(zero, Op, Name, InsertAtEnd); 1886 } 1887 1888 BinaryOperator *BinaryOperator::CreateNUWNeg(Value *Op, const Twine &Name, 1889 Instruction *InsertBefore) { 1890 Value *zero = ConstantFP::getZeroValueForNegation(Op->getType()); 1891 return BinaryOperator::CreateNUWSub(zero, Op, Name, InsertBefore); 1892 } 1893 1894 BinaryOperator *BinaryOperator::CreateNUWNeg(Value *Op, const Twine &Name, 1895 BasicBlock *InsertAtEnd) { 1896 Value *zero = ConstantFP::getZeroValueForNegation(Op->getType()); 1897 return BinaryOperator::CreateNUWSub(zero, Op, Name, InsertAtEnd); 1898 } 1899 1900 BinaryOperator *BinaryOperator::CreateFNeg(Value *Op, const Twine &Name, 1901 Instruction *InsertBefore) { 1902 Value *zero = ConstantFP::getZeroValueForNegation(Op->getType()); 1903 return new BinaryOperator(Instruction::FSub, zero, Op, 1904 Op->getType(), Name, InsertBefore); 1905 } 1906 1907 BinaryOperator *BinaryOperator::CreateFNeg(Value *Op, const Twine &Name, 1908 BasicBlock *InsertAtEnd) { 1909 Value *zero = ConstantFP::getZeroValueForNegation(Op->getType()); 1910 return new BinaryOperator(Instruction::FSub, zero, Op, 1911 Op->getType(), Name, InsertAtEnd); 1912 } 1913 1914 BinaryOperator *BinaryOperator::CreateNot(Value *Op, const Twine &Name, 1915 Instruction *InsertBefore) { 1916 Constant *C = Constant::getAllOnesValue(Op->getType()); 1917 return new BinaryOperator(Instruction::Xor, Op, C, 1918 Op->getType(), Name, InsertBefore); 1919 } 1920 1921 BinaryOperator *BinaryOperator::CreateNot(Value *Op, const Twine &Name, 1922 BasicBlock *InsertAtEnd) { 1923 Constant *AllOnes = Constant::getAllOnesValue(Op->getType()); 1924 return new BinaryOperator(Instruction::Xor, Op, AllOnes, 1925 Op->getType(), Name, InsertAtEnd); 1926 } 1927 1928 1929 // isConstantAllOnes - Helper function for several functions below 1930 static inline bool isConstantAllOnes(const Value *V) { 1931 if (const Constant *C = dyn_cast<Constant>(V)) 1932 return C->isAllOnesValue(); 1933 return false; 1934 } 1935 1936 bool BinaryOperator::isNeg(const Value *V) { 1937 if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(V)) 1938 if (Bop->getOpcode() == Instruction::Sub) 1939 if (Constant* C = dyn_cast<Constant>(Bop->getOperand(0))) 1940 return C->isNegativeZeroValue(); 1941 return false; 1942 } 1943 1944 bool BinaryOperator::isFNeg(const Value *V, bool IgnoreZeroSign) { 1945 if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(V)) 1946 if (Bop->getOpcode() == Instruction::FSub) 1947 if (Constant* C = dyn_cast<Constant>(Bop->getOperand(0))) { 1948 if (!IgnoreZeroSign) 1949 IgnoreZeroSign = cast<Instruction>(V)->hasNoSignedZeros(); 1950 return !IgnoreZeroSign ? C->isNegativeZeroValue() : C->isZeroValue(); 1951 } 1952 return false; 1953 } 1954 1955 bool BinaryOperator::isNot(const Value *V) { 1956 if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(V)) 1957 return (Bop->getOpcode() == Instruction::Xor && 1958 (isConstantAllOnes(Bop->getOperand(1)) || 1959 isConstantAllOnes(Bop->getOperand(0)))); 1960 return false; 1961 } 1962 1963 Value *BinaryOperator::getNegArgument(Value *BinOp) { 1964 return cast<BinaryOperator>(BinOp)->getOperand(1); 1965 } 1966 1967 const Value *BinaryOperator::getNegArgument(const Value *BinOp) { 1968 return getNegArgument(const_cast<Value*>(BinOp)); 1969 } 1970 1971 Value *BinaryOperator::getFNegArgument(Value *BinOp) { 1972 return cast<BinaryOperator>(BinOp)->getOperand(1); 1973 } 1974 1975 const Value *BinaryOperator::getFNegArgument(const Value *BinOp) { 1976 return getFNegArgument(const_cast<Value*>(BinOp)); 1977 } 1978 1979 Value *BinaryOperator::getNotArgument(Value *BinOp) { 1980 assert(isNot(BinOp) && "getNotArgument on non-'not' instruction!"); 1981 BinaryOperator *BO = cast<BinaryOperator>(BinOp); 1982 Value *Op0 = BO->getOperand(0); 1983 Value *Op1 = BO->getOperand(1); 1984 if (isConstantAllOnes(Op0)) return Op1; 1985 1986 assert(isConstantAllOnes(Op1)); 1987 return Op0; 1988 } 1989 1990 const Value *BinaryOperator::getNotArgument(const Value *BinOp) { 1991 return getNotArgument(const_cast<Value*>(BinOp)); 1992 } 1993 1994 1995 // swapOperands - Exchange the two operands to this instruction. This 1996 // instruction is safe to use on any binary instruction and does not 1997 // modify the semantics of the instruction. If the instruction is 1998 // order dependent (SetLT f.e.) the opcode is changed. 1999 // 2000 bool BinaryOperator::swapOperands() { 2001 if (!isCommutative()) 2002 return true; // Can't commute operands 2003 Op<0>().swap(Op<1>()); 2004 return false; 2005 } 2006 2007 void BinaryOperator::setHasNoUnsignedWrap(bool b) { 2008 cast<OverflowingBinaryOperator>(this)->setHasNoUnsignedWrap(b); 2009 } 2010 2011 void BinaryOperator::setHasNoSignedWrap(bool b) { 2012 cast<OverflowingBinaryOperator>(this)->setHasNoSignedWrap(b); 2013 } 2014 2015 void BinaryOperator::setIsExact(bool b) { 2016 cast<PossiblyExactOperator>(this)->setIsExact(b); 2017 } 2018 2019 bool BinaryOperator::hasNoUnsignedWrap() const { 2020 return cast<OverflowingBinaryOperator>(this)->hasNoUnsignedWrap(); 2021 } 2022 2023 bool BinaryOperator::hasNoSignedWrap() const { 2024 return cast<OverflowingBinaryOperator>(this)->hasNoSignedWrap(); 2025 } 2026 2027 bool BinaryOperator::isExact() const { 2028 return cast<PossiblyExactOperator>(this)->isExact(); 2029 } 2030 2031 void BinaryOperator::copyIRFlags(const Value *V) { 2032 // Copy the wrapping flags. 2033 if (auto *OB = dyn_cast<OverflowingBinaryOperator>(V)) { 2034 setHasNoSignedWrap(OB->hasNoSignedWrap()); 2035 setHasNoUnsignedWrap(OB->hasNoUnsignedWrap()); 2036 } 2037 2038 // Copy the exact flag. 2039 if (auto *PE = dyn_cast<PossiblyExactOperator>(V)) 2040 setIsExact(PE->isExact()); 2041 2042 // Copy the fast-math flags. 2043 if (auto *FP = dyn_cast<FPMathOperator>(V)) 2044 copyFastMathFlags(FP->getFastMathFlags()); 2045 } 2046 2047 void BinaryOperator::andIRFlags(const Value *V) { 2048 if (auto *OB = dyn_cast<OverflowingBinaryOperator>(V)) { 2049 setHasNoSignedWrap(hasNoSignedWrap() & OB->hasNoSignedWrap()); 2050 setHasNoUnsignedWrap(hasNoUnsignedWrap() & OB->hasNoUnsignedWrap()); 2051 } 2052 2053 if (auto *PE = dyn_cast<PossiblyExactOperator>(V)) 2054 setIsExact(isExact() & PE->isExact()); 2055 2056 if (auto *FP = dyn_cast<FPMathOperator>(V)) { 2057 FastMathFlags FM = getFastMathFlags(); 2058 FM &= FP->getFastMathFlags(); 2059 copyFastMathFlags(FM); 2060 } 2061 } 2062 2063 2064 //===----------------------------------------------------------------------===// 2065 // FPMathOperator Class 2066 //===----------------------------------------------------------------------===// 2067 2068 /// getFPAccuracy - Get the maximum error permitted by this operation in ULPs. 2069 /// An accuracy of 0.0 means that the operation should be performed with the 2070 /// default precision. 2071 float FPMathOperator::getFPAccuracy() const { 2072 const MDNode *MD = 2073 cast<Instruction>(this)->getMetadata(LLVMContext::MD_fpmath); 2074 if (!MD) 2075 return 0.0; 2076 ConstantFP *Accuracy = mdconst::extract<ConstantFP>(MD->getOperand(0)); 2077 return Accuracy->getValueAPF().convertToFloat(); 2078 } 2079 2080 2081 //===----------------------------------------------------------------------===// 2082 // CastInst Class 2083 //===----------------------------------------------------------------------===// 2084 2085 void CastInst::anchor() {} 2086 2087 // Just determine if this cast only deals with integral->integral conversion. 2088 bool CastInst::isIntegerCast() const { 2089 switch (getOpcode()) { 2090 default: return false; 2091 case Instruction::ZExt: 2092 case Instruction::SExt: 2093 case Instruction::Trunc: 2094 return true; 2095 case Instruction::BitCast: 2096 return getOperand(0)->getType()->isIntegerTy() && 2097 getType()->isIntegerTy(); 2098 } 2099 } 2100 2101 bool CastInst::isLosslessCast() const { 2102 // Only BitCast can be lossless, exit fast if we're not BitCast 2103 if (getOpcode() != Instruction::BitCast) 2104 return false; 2105 2106 // Identity cast is always lossless 2107 Type* SrcTy = getOperand(0)->getType(); 2108 Type* DstTy = getType(); 2109 if (SrcTy == DstTy) 2110 return true; 2111 2112 // Pointer to pointer is always lossless. 2113 if (SrcTy->isPointerTy()) 2114 return DstTy->isPointerTy(); 2115 return false; // Other types have no identity values 2116 } 2117 2118 /// This function determines if the CastInst does not require any bits to be 2119 /// changed in order to effect the cast. Essentially, it identifies cases where 2120 /// no code gen is necessary for the cast, hence the name no-op cast. For 2121 /// example, the following are all no-op casts: 2122 /// # bitcast i32* %x to i8* 2123 /// # bitcast <2 x i32> %x to <4 x i16> 2124 /// # ptrtoint i32* %x to i32 ; on 32-bit plaforms only 2125 /// @brief Determine if the described cast is a no-op. 2126 bool CastInst::isNoopCast(Instruction::CastOps Opcode, 2127 Type *SrcTy, 2128 Type *DestTy, 2129 Type *IntPtrTy) { 2130 switch (Opcode) { 2131 default: llvm_unreachable("Invalid CastOp"); 2132 case Instruction::Trunc: 2133 case Instruction::ZExt: 2134 case Instruction::SExt: 2135 case Instruction::FPTrunc: 2136 case Instruction::FPExt: 2137 case Instruction::UIToFP: 2138 case Instruction::SIToFP: 2139 case Instruction::FPToUI: 2140 case Instruction::FPToSI: 2141 case Instruction::AddrSpaceCast: 2142 // TODO: Target informations may give a more accurate answer here. 2143 return false; 2144 case Instruction::BitCast: 2145 return true; // BitCast never modifies bits. 2146 case Instruction::PtrToInt: 2147 return IntPtrTy->getScalarSizeInBits() == 2148 DestTy->getScalarSizeInBits(); 2149 case Instruction::IntToPtr: 2150 return IntPtrTy->getScalarSizeInBits() == 2151 SrcTy->getScalarSizeInBits(); 2152 } 2153 } 2154 2155 /// @brief Determine if a cast is a no-op. 2156 bool CastInst::isNoopCast(Type *IntPtrTy) const { 2157 return isNoopCast(getOpcode(), getOperand(0)->getType(), getType(), IntPtrTy); 2158 } 2159 2160 bool CastInst::isNoopCast(const DataLayout *DL) const { 2161 if (!DL) { 2162 // Assume maximum pointer size. 2163 return isNoopCast(Type::getInt64Ty(getContext())); 2164 } 2165 2166 Type *PtrOpTy = nullptr; 2167 if (getOpcode() == Instruction::PtrToInt) 2168 PtrOpTy = getOperand(0)->getType(); 2169 else if (getOpcode() == Instruction::IntToPtr) 2170 PtrOpTy = getType(); 2171 2172 Type *IntPtrTy = PtrOpTy 2173 ? DL->getIntPtrType(PtrOpTy) 2174 : DL->getIntPtrType(getContext(), 0); 2175 2176 return isNoopCast(getOpcode(), getOperand(0)->getType(), getType(), IntPtrTy); 2177 } 2178 2179 /// This function determines if a pair of casts can be eliminated and what 2180 /// opcode should be used in the elimination. This assumes that there are two 2181 /// instructions like this: 2182 /// * %F = firstOpcode SrcTy %x to MidTy 2183 /// * %S = secondOpcode MidTy %F to DstTy 2184 /// The function returns a resultOpcode so these two casts can be replaced with: 2185 /// * %Replacement = resultOpcode %SrcTy %x to DstTy 2186 /// If no such cast is permited, the function returns 0. 2187 unsigned CastInst::isEliminableCastPair( 2188 Instruction::CastOps firstOp, Instruction::CastOps secondOp, 2189 Type *SrcTy, Type *MidTy, Type *DstTy, Type *SrcIntPtrTy, Type *MidIntPtrTy, 2190 Type *DstIntPtrTy) { 2191 // Define the 144 possibilities for these two cast instructions. The values 2192 // in this matrix determine what to do in a given situation and select the 2193 // case in the switch below. The rows correspond to firstOp, the columns 2194 // correspond to secondOp. In looking at the table below, keep in mind 2195 // the following cast properties: 2196 // 2197 // Size Compare Source Destination 2198 // Operator Src ? Size Type Sign Type Sign 2199 // -------- ------------ ------------------- --------------------- 2200 // TRUNC > Integer Any Integral Any 2201 // ZEXT < Integral Unsigned Integer Any 2202 // SEXT < Integral Signed Integer Any 2203 // FPTOUI n/a FloatPt n/a Integral Unsigned 2204 // FPTOSI n/a FloatPt n/a Integral Signed 2205 // UITOFP n/a Integral Unsigned FloatPt n/a 2206 // SITOFP n/a Integral Signed FloatPt n/a 2207 // FPTRUNC > FloatPt n/a FloatPt n/a 2208 // FPEXT < FloatPt n/a FloatPt n/a 2209 // PTRTOINT n/a Pointer n/a Integral Unsigned 2210 // INTTOPTR n/a Integral Unsigned Pointer n/a 2211 // BITCAST = FirstClass n/a FirstClass n/a 2212 // ADDRSPCST n/a Pointer n/a Pointer n/a 2213 // 2214 // NOTE: some transforms are safe, but we consider them to be non-profitable. 2215 // For example, we could merge "fptoui double to i32" + "zext i32 to i64", 2216 // into "fptoui double to i64", but this loses information about the range 2217 // of the produced value (we no longer know the top-part is all zeros). 2218 // Further this conversion is often much more expensive for typical hardware, 2219 // and causes issues when building libgcc. We disallow fptosi+sext for the 2220 // same reason. 2221 const unsigned numCastOps = 2222 Instruction::CastOpsEnd - Instruction::CastOpsBegin; 2223 static const uint8_t CastResults[numCastOps][numCastOps] = { 2224 // T F F U S F F P I B A -+ 2225 // R Z S P P I I T P 2 N T S | 2226 // U E E 2 2 2 2 R E I T C C +- secondOp 2227 // N X X U S F F N X N 2 V V | 2228 // C T T I I P P C T T P T T -+ 2229 { 1, 0, 0,99,99, 0, 0,99,99,99, 0, 3, 0}, // Trunc -+ 2230 { 8, 1, 9,99,99, 2, 0,99,99,99, 2, 3, 0}, // ZExt | 2231 { 8, 0, 1,99,99, 0, 2,99,99,99, 0, 3, 0}, // SExt | 2232 { 0, 0, 0,99,99, 0, 0,99,99,99, 0, 3, 0}, // FPToUI | 2233 { 0, 0, 0,99,99, 0, 0,99,99,99, 0, 3, 0}, // FPToSI | 2234 { 99,99,99, 0, 0,99,99, 0, 0,99,99, 4, 0}, // UIToFP +- firstOp 2235 { 99,99,99, 0, 0,99,99, 0, 0,99,99, 4, 0}, // SIToFP | 2236 { 99,99,99, 0, 0,99,99, 1, 0,99,99, 4, 0}, // FPTrunc | 2237 { 99,99,99, 2, 2,99,99,10, 2,99,99, 4, 0}, // FPExt | 2238 { 1, 0, 0,99,99, 0, 0,99,99,99, 7, 3, 0}, // PtrToInt | 2239 { 99,99,99,99,99,99,99,99,99,11,99,15, 0}, // IntToPtr | 2240 { 5, 5, 5, 6, 6, 5, 5, 6, 6,16, 5, 1,14}, // BitCast | 2241 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,13,12}, // AddrSpaceCast -+ 2242 }; 2243 2244 // If either of the casts are a bitcast from scalar to vector, disallow the 2245 // merging. However, bitcast of A->B->A are allowed. 2246 bool isFirstBitcast = (firstOp == Instruction::BitCast); 2247 bool isSecondBitcast = (secondOp == Instruction::BitCast); 2248 bool chainedBitcast = (SrcTy == DstTy && isFirstBitcast && isSecondBitcast); 2249 2250 // Check if any of the bitcasts convert scalars<->vectors. 2251 if ((isFirstBitcast && isa<VectorType>(SrcTy) != isa<VectorType>(MidTy)) || 2252 (isSecondBitcast && isa<VectorType>(MidTy) != isa<VectorType>(DstTy))) 2253 // Unless we are bitcasing to the original type, disallow optimizations. 2254 if (!chainedBitcast) return 0; 2255 2256 int ElimCase = CastResults[firstOp-Instruction::CastOpsBegin] 2257 [secondOp-Instruction::CastOpsBegin]; 2258 switch (ElimCase) { 2259 case 0: 2260 // Categorically disallowed. 2261 return 0; 2262 case 1: 2263 // Allowed, use first cast's opcode. 2264 return firstOp; 2265 case 2: 2266 // Allowed, use second cast's opcode. 2267 return secondOp; 2268 case 3: 2269 // No-op cast in second op implies firstOp as long as the DestTy 2270 // is integer and we are not converting between a vector and a 2271 // non-vector type. 2272 if (!SrcTy->isVectorTy() && DstTy->isIntegerTy()) 2273 return firstOp; 2274 return 0; 2275 case 4: 2276 // No-op cast in second op implies firstOp as long as the DestTy 2277 // is floating point. 2278 if (DstTy->isFloatingPointTy()) 2279 return firstOp; 2280 return 0; 2281 case 5: 2282 // No-op cast in first op implies secondOp as long as the SrcTy 2283 // is an integer. 2284 if (SrcTy->isIntegerTy()) 2285 return secondOp; 2286 return 0; 2287 case 6: 2288 // No-op cast in first op implies secondOp as long as the SrcTy 2289 // is a floating point. 2290 if (SrcTy->isFloatingPointTy()) 2291 return secondOp; 2292 return 0; 2293 case 7: { 2294 // Cannot simplify if address spaces are different! 2295 if (SrcTy->getPointerAddressSpace() != DstTy->getPointerAddressSpace()) 2296 return 0; 2297 2298 unsigned MidSize = MidTy->getScalarSizeInBits(); 2299 // We can still fold this without knowing the actual sizes as long we 2300 // know that the intermediate pointer is the largest possible 2301 // pointer size. 2302 // FIXME: Is this always true? 2303 if (MidSize == 64) 2304 return Instruction::BitCast; 2305 2306 // ptrtoint, inttoptr -> bitcast (ptr -> ptr) if int size is >= ptr size. 2307 if (!SrcIntPtrTy || DstIntPtrTy != SrcIntPtrTy) 2308 return 0; 2309 unsigned PtrSize = SrcIntPtrTy->getScalarSizeInBits(); 2310 if (MidSize >= PtrSize) 2311 return Instruction::BitCast; 2312 return 0; 2313 } 2314 case 8: { 2315 // ext, trunc -> bitcast, if the SrcTy and DstTy are same size 2316 // ext, trunc -> ext, if sizeof(SrcTy) < sizeof(DstTy) 2317 // ext, trunc -> trunc, if sizeof(SrcTy) > sizeof(DstTy) 2318 unsigned SrcSize = SrcTy->getScalarSizeInBits(); 2319 unsigned DstSize = DstTy->getScalarSizeInBits(); 2320 if (SrcSize == DstSize) 2321 return Instruction::BitCast; 2322 else if (SrcSize < DstSize) 2323 return firstOp; 2324 return secondOp; 2325 } 2326 case 9: 2327 // zext, sext -> zext, because sext can't sign extend after zext 2328 return Instruction::ZExt; 2329 case 10: 2330 // fpext followed by ftrunc is allowed if the bit size returned to is 2331 // the same as the original, in which case its just a bitcast 2332 if (SrcTy == DstTy) 2333 return Instruction::BitCast; 2334 return 0; // If the types are not the same we can't eliminate it. 2335 case 11: { 2336 // inttoptr, ptrtoint -> bitcast if SrcSize<=PtrSize and SrcSize==DstSize 2337 if (!MidIntPtrTy) 2338 return 0; 2339 unsigned PtrSize = MidIntPtrTy->getScalarSizeInBits(); 2340 unsigned SrcSize = SrcTy->getScalarSizeInBits(); 2341 unsigned DstSize = DstTy->getScalarSizeInBits(); 2342 if (SrcSize <= PtrSize && SrcSize == DstSize) 2343 return Instruction::BitCast; 2344 return 0; 2345 } 2346 case 12: { 2347 // addrspacecast, addrspacecast -> bitcast, if SrcAS == DstAS 2348 // addrspacecast, addrspacecast -> addrspacecast, if SrcAS != DstAS 2349 if (SrcTy->getPointerAddressSpace() != DstTy->getPointerAddressSpace()) 2350 return Instruction::AddrSpaceCast; 2351 return Instruction::BitCast; 2352 } 2353 case 13: 2354 // FIXME: this state can be merged with (1), but the following assert 2355 // is useful to check the correcteness of the sequence due to semantic 2356 // change of bitcast. 2357 assert( 2358 SrcTy->isPtrOrPtrVectorTy() && 2359 MidTy->isPtrOrPtrVectorTy() && 2360 DstTy->isPtrOrPtrVectorTy() && 2361 SrcTy->getPointerAddressSpace() != MidTy->getPointerAddressSpace() && 2362 MidTy->getPointerAddressSpace() == DstTy->getPointerAddressSpace() && 2363 "Illegal addrspacecast, bitcast sequence!"); 2364 // Allowed, use first cast's opcode 2365 return firstOp; 2366 case 14: 2367 // bitcast, addrspacecast -> addrspacecast if the element type of 2368 // bitcast's source is the same as that of addrspacecast's destination. 2369 if (SrcTy->getPointerElementType() == DstTy->getPointerElementType()) 2370 return Instruction::AddrSpaceCast; 2371 return 0; 2372 2373 case 15: 2374 // FIXME: this state can be merged with (1), but the following assert 2375 // is useful to check the correcteness of the sequence due to semantic 2376 // change of bitcast. 2377 assert( 2378 SrcTy->isIntOrIntVectorTy() && 2379 MidTy->isPtrOrPtrVectorTy() && 2380 DstTy->isPtrOrPtrVectorTy() && 2381 MidTy->getPointerAddressSpace() == DstTy->getPointerAddressSpace() && 2382 "Illegal inttoptr, bitcast sequence!"); 2383 // Allowed, use first cast's opcode 2384 return firstOp; 2385 case 16: 2386 // FIXME: this state can be merged with (2), but the following assert 2387 // is useful to check the correcteness of the sequence due to semantic 2388 // change of bitcast. 2389 assert( 2390 SrcTy->isPtrOrPtrVectorTy() && 2391 MidTy->isPtrOrPtrVectorTy() && 2392 DstTy->isIntOrIntVectorTy() && 2393 SrcTy->getPointerAddressSpace() == MidTy->getPointerAddressSpace() && 2394 "Illegal bitcast, ptrtoint sequence!"); 2395 // Allowed, use second cast's opcode 2396 return secondOp; 2397 case 99: 2398 // Cast combination can't happen (error in input). This is for all cases 2399 // where the MidTy is not the same for the two cast instructions. 2400 llvm_unreachable("Invalid Cast Combination"); 2401 default: 2402 llvm_unreachable("Error in CastResults table!!!"); 2403 } 2404 } 2405 2406 CastInst *CastInst::Create(Instruction::CastOps op, Value *S, Type *Ty, 2407 const Twine &Name, Instruction *InsertBefore) { 2408 assert(castIsValid(op, S, Ty) && "Invalid cast!"); 2409 // Construct and return the appropriate CastInst subclass 2410 switch (op) { 2411 case Trunc: return new TruncInst (S, Ty, Name, InsertBefore); 2412 case ZExt: return new ZExtInst (S, Ty, Name, InsertBefore); 2413 case SExt: return new SExtInst (S, Ty, Name, InsertBefore); 2414 case FPTrunc: return new FPTruncInst (S, Ty, Name, InsertBefore); 2415 case FPExt: return new FPExtInst (S, Ty, Name, InsertBefore); 2416 case UIToFP: return new UIToFPInst (S, Ty, Name, InsertBefore); 2417 case SIToFP: return new SIToFPInst (S, Ty, Name, InsertBefore); 2418 case FPToUI: return new FPToUIInst (S, Ty, Name, InsertBefore); 2419 case FPToSI: return new FPToSIInst (S, Ty, Name, InsertBefore); 2420 case PtrToInt: return new PtrToIntInst (S, Ty, Name, InsertBefore); 2421 case IntToPtr: return new IntToPtrInst (S, Ty, Name, InsertBefore); 2422 case BitCast: return new BitCastInst (S, Ty, Name, InsertBefore); 2423 case AddrSpaceCast: return new AddrSpaceCastInst (S, Ty, Name, InsertBefore); 2424 default: llvm_unreachable("Invalid opcode provided"); 2425 } 2426 } 2427 2428 CastInst *CastInst::Create(Instruction::CastOps op, Value *S, Type *Ty, 2429 const Twine &Name, BasicBlock *InsertAtEnd) { 2430 assert(castIsValid(op, S, Ty) && "Invalid cast!"); 2431 // Construct and return the appropriate CastInst subclass 2432 switch (op) { 2433 case Trunc: return new TruncInst (S, Ty, Name, InsertAtEnd); 2434 case ZExt: return new ZExtInst (S, Ty, Name, InsertAtEnd); 2435 case SExt: return new SExtInst (S, Ty, Name, InsertAtEnd); 2436 case FPTrunc: return new FPTruncInst (S, Ty, Name, InsertAtEnd); 2437 case FPExt: return new FPExtInst (S, Ty, Name, InsertAtEnd); 2438 case UIToFP: return new UIToFPInst (S, Ty, Name, InsertAtEnd); 2439 case SIToFP: return new SIToFPInst (S, Ty, Name, InsertAtEnd); 2440 case FPToUI: return new FPToUIInst (S, Ty, Name, InsertAtEnd); 2441 case FPToSI: return new FPToSIInst (S, Ty, Name, InsertAtEnd); 2442 case PtrToInt: return new PtrToIntInst (S, Ty, Name, InsertAtEnd); 2443 case IntToPtr: return new IntToPtrInst (S, Ty, Name, InsertAtEnd); 2444 case BitCast: return new BitCastInst (S, Ty, Name, InsertAtEnd); 2445 case AddrSpaceCast: return new AddrSpaceCastInst (S, Ty, Name, InsertAtEnd); 2446 default: llvm_unreachable("Invalid opcode provided"); 2447 } 2448 } 2449 2450 CastInst *CastInst::CreateZExtOrBitCast(Value *S, Type *Ty, 2451 const Twine &Name, 2452 Instruction *InsertBefore) { 2453 if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) 2454 return Create(Instruction::BitCast, S, Ty, Name, InsertBefore); 2455 return Create(Instruction::ZExt, S, Ty, Name, InsertBefore); 2456 } 2457 2458 CastInst *CastInst::CreateZExtOrBitCast(Value *S, Type *Ty, 2459 const Twine &Name, 2460 BasicBlock *InsertAtEnd) { 2461 if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) 2462 return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd); 2463 return Create(Instruction::ZExt, S, Ty, Name, InsertAtEnd); 2464 } 2465 2466 CastInst *CastInst::CreateSExtOrBitCast(Value *S, Type *Ty, 2467 const Twine &Name, 2468 Instruction *InsertBefore) { 2469 if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) 2470 return Create(Instruction::BitCast, S, Ty, Name, InsertBefore); 2471 return Create(Instruction::SExt, S, Ty, Name, InsertBefore); 2472 } 2473 2474 CastInst *CastInst::CreateSExtOrBitCast(Value *S, Type *Ty, 2475 const Twine &Name, 2476 BasicBlock *InsertAtEnd) { 2477 if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) 2478 return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd); 2479 return Create(Instruction::SExt, S, Ty, Name, InsertAtEnd); 2480 } 2481 2482 CastInst *CastInst::CreateTruncOrBitCast(Value *S, Type *Ty, 2483 const Twine &Name, 2484 Instruction *InsertBefore) { 2485 if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) 2486 return Create(Instruction::BitCast, S, Ty, Name, InsertBefore); 2487 return Create(Instruction::Trunc, S, Ty, Name, InsertBefore); 2488 } 2489 2490 CastInst *CastInst::CreateTruncOrBitCast(Value *S, Type *Ty, 2491 const Twine &Name, 2492 BasicBlock *InsertAtEnd) { 2493 if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) 2494 return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd); 2495 return Create(Instruction::Trunc, S, Ty, Name, InsertAtEnd); 2496 } 2497 2498 CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty, 2499 const Twine &Name, 2500 BasicBlock *InsertAtEnd) { 2501 assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast"); 2502 assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) && 2503 "Invalid cast"); 2504 assert(Ty->isVectorTy() == S->getType()->isVectorTy() && "Invalid cast"); 2505 assert((!Ty->isVectorTy() || 2506 Ty->getVectorNumElements() == S->getType()->getVectorNumElements()) && 2507 "Invalid cast"); 2508 2509 if (Ty->isIntOrIntVectorTy()) 2510 return Create(Instruction::PtrToInt, S, Ty, Name, InsertAtEnd); 2511 2512 return CreatePointerBitCastOrAddrSpaceCast(S, Ty, Name, InsertAtEnd); 2513 } 2514 2515 /// @brief Create a BitCast or a PtrToInt cast instruction 2516 CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty, 2517 const Twine &Name, 2518 Instruction *InsertBefore) { 2519 assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast"); 2520 assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) && 2521 "Invalid cast"); 2522 assert(Ty->isVectorTy() == S->getType()->isVectorTy() && "Invalid cast"); 2523 assert((!Ty->isVectorTy() || 2524 Ty->getVectorNumElements() == S->getType()->getVectorNumElements()) && 2525 "Invalid cast"); 2526 2527 if (Ty->isIntOrIntVectorTy()) 2528 return Create(Instruction::PtrToInt, S, Ty, Name, InsertBefore); 2529 2530 return CreatePointerBitCastOrAddrSpaceCast(S, Ty, Name, InsertBefore); 2531 } 2532 2533 CastInst *CastInst::CreatePointerBitCastOrAddrSpaceCast( 2534 Value *S, Type *Ty, 2535 const Twine &Name, 2536 BasicBlock *InsertAtEnd) { 2537 assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast"); 2538 assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast"); 2539 2540 if (S->getType()->getPointerAddressSpace() != Ty->getPointerAddressSpace()) 2541 return Create(Instruction::AddrSpaceCast, S, Ty, Name, InsertAtEnd); 2542 2543 return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd); 2544 } 2545 2546 CastInst *CastInst::CreatePointerBitCastOrAddrSpaceCast( 2547 Value *S, Type *Ty, 2548 const Twine &Name, 2549 Instruction *InsertBefore) { 2550 assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast"); 2551 assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast"); 2552 2553 if (S->getType()->getPointerAddressSpace() != Ty->getPointerAddressSpace()) 2554 return Create(Instruction::AddrSpaceCast, S, Ty, Name, InsertBefore); 2555 2556 return Create(Instruction::BitCast, S, Ty, Name, InsertBefore); 2557 } 2558 2559 CastInst *CastInst::CreateBitOrPointerCast(Value *S, Type *Ty, 2560 const Twine &Name, 2561 Instruction *InsertBefore) { 2562 if (S->getType()->isPointerTy() && Ty->isIntegerTy()) 2563 return Create(Instruction::PtrToInt, S, Ty, Name, InsertBefore); 2564 if (S->getType()->isIntegerTy() && Ty->isPointerTy()) 2565 return Create(Instruction::IntToPtr, S, Ty, Name, InsertBefore); 2566 2567 return Create(Instruction::BitCast, S, Ty, Name, InsertBefore); 2568 } 2569 2570 CastInst *CastInst::CreateIntegerCast(Value *C, Type *Ty, 2571 bool isSigned, const Twine &Name, 2572 Instruction *InsertBefore) { 2573 assert(C->getType()->isIntOrIntVectorTy() && Ty->isIntOrIntVectorTy() && 2574 "Invalid integer cast"); 2575 unsigned SrcBits = C->getType()->getScalarSizeInBits(); 2576 unsigned DstBits = Ty->getScalarSizeInBits(); 2577 Instruction::CastOps opcode = 2578 (SrcBits == DstBits ? Instruction::BitCast : 2579 (SrcBits > DstBits ? Instruction::Trunc : 2580 (isSigned ? Instruction::SExt : Instruction::ZExt))); 2581 return Create(opcode, C, Ty, Name, InsertBefore); 2582 } 2583 2584 CastInst *CastInst::CreateIntegerCast(Value *C, Type *Ty, 2585 bool isSigned, const Twine &Name, 2586 BasicBlock *InsertAtEnd) { 2587 assert(C->getType()->isIntOrIntVectorTy() && Ty->isIntOrIntVectorTy() && 2588 "Invalid cast"); 2589 unsigned SrcBits = C->getType()->getScalarSizeInBits(); 2590 unsigned DstBits = Ty->getScalarSizeInBits(); 2591 Instruction::CastOps opcode = 2592 (SrcBits == DstBits ? Instruction::BitCast : 2593 (SrcBits > DstBits ? Instruction::Trunc : 2594 (isSigned ? Instruction::SExt : Instruction::ZExt))); 2595 return Create(opcode, C, Ty, Name, InsertAtEnd); 2596 } 2597 2598 CastInst *CastInst::CreateFPCast(Value *C, Type *Ty, 2599 const Twine &Name, 2600 Instruction *InsertBefore) { 2601 assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() && 2602 "Invalid cast"); 2603 unsigned SrcBits = C->getType()->getScalarSizeInBits(); 2604 unsigned DstBits = Ty->getScalarSizeInBits(); 2605 Instruction::CastOps opcode = 2606 (SrcBits == DstBits ? Instruction::BitCast : 2607 (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt)); 2608 return Create(opcode, C, Ty, Name, InsertBefore); 2609 } 2610 2611 CastInst *CastInst::CreateFPCast(Value *C, Type *Ty, 2612 const Twine &Name, 2613 BasicBlock *InsertAtEnd) { 2614 assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() && 2615 "Invalid cast"); 2616 unsigned SrcBits = C->getType()->getScalarSizeInBits(); 2617 unsigned DstBits = Ty->getScalarSizeInBits(); 2618 Instruction::CastOps opcode = 2619 (SrcBits == DstBits ? Instruction::BitCast : 2620 (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt)); 2621 return Create(opcode, C, Ty, Name, InsertAtEnd); 2622 } 2623 2624 // Check whether it is valid to call getCastOpcode for these types. 2625 // This routine must be kept in sync with getCastOpcode. 2626 bool CastInst::isCastable(Type *SrcTy, Type *DestTy) { 2627 if (!SrcTy->isFirstClassType() || !DestTy->isFirstClassType()) 2628 return false; 2629 2630 if (SrcTy == DestTy) 2631 return true; 2632 2633 if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy)) 2634 if (VectorType *DestVecTy = dyn_cast<VectorType>(DestTy)) 2635 if (SrcVecTy->getNumElements() == DestVecTy->getNumElements()) { 2636 // An element by element cast. Valid if casting the elements is valid. 2637 SrcTy = SrcVecTy->getElementType(); 2638 DestTy = DestVecTy->getElementType(); 2639 } 2640 2641 // Get the bit sizes, we'll need these 2642 unsigned SrcBits = SrcTy->getPrimitiveSizeInBits(); // 0 for ptr 2643 unsigned DestBits = DestTy->getPrimitiveSizeInBits(); // 0 for ptr 2644 2645 // Run through the possibilities ... 2646 if (DestTy->isIntegerTy()) { // Casting to integral 2647 if (SrcTy->isIntegerTy()) { // Casting from integral 2648 return true; 2649 } else if (SrcTy->isFloatingPointTy()) { // Casting from floating pt 2650 return true; 2651 } else if (SrcTy->isVectorTy()) { // Casting from vector 2652 return DestBits == SrcBits; 2653 } else { // Casting from something else 2654 return SrcTy->isPointerTy(); 2655 } 2656 } else if (DestTy->isFloatingPointTy()) { // Casting to floating pt 2657 if (SrcTy->isIntegerTy()) { // Casting from integral 2658 return true; 2659 } else if (SrcTy->isFloatingPointTy()) { // Casting from floating pt 2660 return true; 2661 } else if (SrcTy->isVectorTy()) { // Casting from vector 2662 return DestBits == SrcBits; 2663 } else { // Casting from something else 2664 return false; 2665 } 2666 } else if (DestTy->isVectorTy()) { // Casting to vector 2667 return DestBits == SrcBits; 2668 } else if (DestTy->isPointerTy()) { // Casting to pointer 2669 if (SrcTy->isPointerTy()) { // Casting from pointer 2670 return true; 2671 } else if (SrcTy->isIntegerTy()) { // Casting from integral 2672 return true; 2673 } else { // Casting from something else 2674 return false; 2675 } 2676 } else if (DestTy->isX86_MMXTy()) { 2677 if (SrcTy->isVectorTy()) { 2678 return DestBits == SrcBits; // 64-bit vector to MMX 2679 } else { 2680 return false; 2681 } 2682 } else { // Casting to something else 2683 return false; 2684 } 2685 } 2686 2687 bool CastInst::isBitCastable(Type *SrcTy, Type *DestTy) { 2688 if (!SrcTy->isFirstClassType() || !DestTy->isFirstClassType()) 2689 return false; 2690 2691 if (SrcTy == DestTy) 2692 return true; 2693 2694 if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy)) { 2695 if (VectorType *DestVecTy = dyn_cast<VectorType>(DestTy)) { 2696 if (SrcVecTy->getNumElements() == DestVecTy->getNumElements()) { 2697 // An element by element cast. Valid if casting the elements is valid. 2698 SrcTy = SrcVecTy->getElementType(); 2699 DestTy = DestVecTy->getElementType(); 2700 } 2701 } 2702 } 2703 2704 if (PointerType *DestPtrTy = dyn_cast<PointerType>(DestTy)) { 2705 if (PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy)) { 2706 return SrcPtrTy->getAddressSpace() == DestPtrTy->getAddressSpace(); 2707 } 2708 } 2709 2710 unsigned SrcBits = SrcTy->getPrimitiveSizeInBits(); // 0 for ptr 2711 unsigned DestBits = DestTy->getPrimitiveSizeInBits(); // 0 for ptr 2712 2713 // Could still have vectors of pointers if the number of elements doesn't 2714 // match 2715 if (SrcBits == 0 || DestBits == 0) 2716 return false; 2717 2718 if (SrcBits != DestBits) 2719 return false; 2720 2721 if (DestTy->isX86_MMXTy() || SrcTy->isX86_MMXTy()) 2722 return false; 2723 2724 return true; 2725 } 2726 2727 bool CastInst::isBitOrNoopPointerCastable(Type *SrcTy, Type *DestTy, 2728 const DataLayout *DL) { 2729 if (auto *PtrTy = dyn_cast<PointerType>(SrcTy)) 2730 if (auto *IntTy = dyn_cast<IntegerType>(DestTy)) 2731 return DL && IntTy->getBitWidth() == DL->getPointerTypeSizeInBits(PtrTy); 2732 if (auto *PtrTy = dyn_cast<PointerType>(DestTy)) 2733 if (auto *IntTy = dyn_cast<IntegerType>(SrcTy)) 2734 return DL && IntTy->getBitWidth() == DL->getPointerTypeSizeInBits(PtrTy); 2735 2736 return isBitCastable(SrcTy, DestTy); 2737 } 2738 2739 // Provide a way to get a "cast" where the cast opcode is inferred from the 2740 // types and size of the operand. This, basically, is a parallel of the 2741 // logic in the castIsValid function below. This axiom should hold: 2742 // castIsValid( getCastOpcode(Val, Ty), Val, Ty) 2743 // should not assert in castIsValid. In other words, this produces a "correct" 2744 // casting opcode for the arguments passed to it. 2745 // This routine must be kept in sync with isCastable. 2746 Instruction::CastOps 2747 CastInst::getCastOpcode( 2748 const Value *Src, bool SrcIsSigned, Type *DestTy, bool DestIsSigned) { 2749 Type *SrcTy = Src->getType(); 2750 2751 assert(SrcTy->isFirstClassType() && DestTy->isFirstClassType() && 2752 "Only first class types are castable!"); 2753 2754 if (SrcTy == DestTy) 2755 return BitCast; 2756 2757 // FIXME: Check address space sizes here 2758 if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy)) 2759 if (VectorType *DestVecTy = dyn_cast<VectorType>(DestTy)) 2760 if (SrcVecTy->getNumElements() == DestVecTy->getNumElements()) { 2761 // An element by element cast. Find the appropriate opcode based on the 2762 // element types. 2763 SrcTy = SrcVecTy->getElementType(); 2764 DestTy = DestVecTy->getElementType(); 2765 } 2766 2767 // Get the bit sizes, we'll need these 2768 unsigned SrcBits = SrcTy->getPrimitiveSizeInBits(); // 0 for ptr 2769 unsigned DestBits = DestTy->getPrimitiveSizeInBits(); // 0 for ptr 2770 2771 // Run through the possibilities ... 2772 if (DestTy->isIntegerTy()) { // Casting to integral 2773 if (SrcTy->isIntegerTy()) { // Casting from integral 2774 if (DestBits < SrcBits) 2775 return Trunc; // int -> smaller int 2776 else if (DestBits > SrcBits) { // its an extension 2777 if (SrcIsSigned) 2778 return SExt; // signed -> SEXT 2779 else 2780 return ZExt; // unsigned -> ZEXT 2781 } else { 2782 return BitCast; // Same size, No-op cast 2783 } 2784 } else if (SrcTy->isFloatingPointTy()) { // Casting from floating pt 2785 if (DestIsSigned) 2786 return FPToSI; // FP -> sint 2787 else 2788 return FPToUI; // FP -> uint 2789 } else if (SrcTy->isVectorTy()) { 2790 assert(DestBits == SrcBits && 2791 "Casting vector to integer of different width"); 2792 return BitCast; // Same size, no-op cast 2793 } else { 2794 assert(SrcTy->isPointerTy() && 2795 "Casting from a value that is not first-class type"); 2796 return PtrToInt; // ptr -> int 2797 } 2798 } else if (DestTy->isFloatingPointTy()) { // Casting to floating pt 2799 if (SrcTy->isIntegerTy()) { // Casting from integral 2800 if (SrcIsSigned) 2801 return SIToFP; // sint -> FP 2802 else 2803 return UIToFP; // uint -> FP 2804 } else if (SrcTy->isFloatingPointTy()) { // Casting from floating pt 2805 if (DestBits < SrcBits) { 2806 return FPTrunc; // FP -> smaller FP 2807 } else if (DestBits > SrcBits) { 2808 return FPExt; // FP -> larger FP 2809 } else { 2810 return BitCast; // same size, no-op cast 2811 } 2812 } else if (SrcTy->isVectorTy()) { 2813 assert(DestBits == SrcBits && 2814 "Casting vector to floating point of different width"); 2815 return BitCast; // same size, no-op cast 2816 } 2817 llvm_unreachable("Casting pointer or non-first class to float"); 2818 } else if (DestTy->isVectorTy()) { 2819 assert(DestBits == SrcBits && 2820 "Illegal cast to vector (wrong type or size)"); 2821 return BitCast; 2822 } else if (DestTy->isPointerTy()) { 2823 if (SrcTy->isPointerTy()) { 2824 if (DestTy->getPointerAddressSpace() != SrcTy->getPointerAddressSpace()) 2825 return AddrSpaceCast; 2826 return BitCast; // ptr -> ptr 2827 } else if (SrcTy->isIntegerTy()) { 2828 return IntToPtr; // int -> ptr 2829 } 2830 llvm_unreachable("Casting pointer to other than pointer or int"); 2831 } else if (DestTy->isX86_MMXTy()) { 2832 if (SrcTy->isVectorTy()) { 2833 assert(DestBits == SrcBits && "Casting vector of wrong width to X86_MMX"); 2834 return BitCast; // 64-bit vector to MMX 2835 } 2836 llvm_unreachable("Illegal cast to X86_MMX"); 2837 } 2838 llvm_unreachable("Casting to type that is not first-class"); 2839 } 2840 2841 //===----------------------------------------------------------------------===// 2842 // CastInst SubClass Constructors 2843 //===----------------------------------------------------------------------===// 2844 2845 /// Check that the construction parameters for a CastInst are correct. This 2846 /// could be broken out into the separate constructors but it is useful to have 2847 /// it in one place and to eliminate the redundant code for getting the sizes 2848 /// of the types involved. 2849 bool 2850 CastInst::castIsValid(Instruction::CastOps op, Value *S, Type *DstTy) { 2851 2852 // Check for type sanity on the arguments 2853 Type *SrcTy = S->getType(); 2854 2855 // If this is a cast to the same type then it's trivially true. 2856 if (SrcTy == DstTy) 2857 return true; 2858 2859 if (!SrcTy->isFirstClassType() || !DstTy->isFirstClassType() || 2860 SrcTy->isAggregateType() || DstTy->isAggregateType()) 2861 return false; 2862 2863 // Get the size of the types in bits, we'll need this later 2864 unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); 2865 unsigned DstBitSize = DstTy->getScalarSizeInBits(); 2866 2867 // If these are vector types, get the lengths of the vectors (using zero for 2868 // scalar types means that checking that vector lengths match also checks that 2869 // scalars are not being converted to vectors or vectors to scalars). 2870 unsigned SrcLength = SrcTy->isVectorTy() ? 2871 cast<VectorType>(SrcTy)->getNumElements() : 0; 2872 unsigned DstLength = DstTy->isVectorTy() ? 2873 cast<VectorType>(DstTy)->getNumElements() : 0; 2874 2875 // Switch on the opcode provided 2876 switch (op) { 2877 default: return false; // This is an input error 2878 case Instruction::Trunc: 2879 return SrcTy->isIntOrIntVectorTy() && DstTy->isIntOrIntVectorTy() && 2880 SrcLength == DstLength && SrcBitSize > DstBitSize; 2881 case Instruction::ZExt: 2882 return SrcTy->isIntOrIntVectorTy() && DstTy->isIntOrIntVectorTy() && 2883 SrcLength == DstLength && SrcBitSize < DstBitSize; 2884 case Instruction::SExt: 2885 return SrcTy->isIntOrIntVectorTy() && DstTy->isIntOrIntVectorTy() && 2886 SrcLength == DstLength && SrcBitSize < DstBitSize; 2887 case Instruction::FPTrunc: 2888 return SrcTy->isFPOrFPVectorTy() && DstTy->isFPOrFPVectorTy() && 2889 SrcLength == DstLength && SrcBitSize > DstBitSize; 2890 case Instruction::FPExt: 2891 return SrcTy->isFPOrFPVectorTy() && DstTy->isFPOrFPVectorTy() && 2892 SrcLength == DstLength && SrcBitSize < DstBitSize; 2893 case Instruction::UIToFP: 2894 case Instruction::SIToFP: 2895 return SrcTy->isIntOrIntVectorTy() && DstTy->isFPOrFPVectorTy() && 2896 SrcLength == DstLength; 2897 case Instruction::FPToUI: 2898 case Instruction::FPToSI: 2899 return SrcTy->isFPOrFPVectorTy() && DstTy->isIntOrIntVectorTy() && 2900 SrcLength == DstLength; 2901 case Instruction::PtrToInt: 2902 if (isa<VectorType>(SrcTy) != isa<VectorType>(DstTy)) 2903 return false; 2904 if (VectorType *VT = dyn_cast<VectorType>(SrcTy)) 2905 if (VT->getNumElements() != cast<VectorType>(DstTy)->getNumElements()) 2906 return false; 2907 return SrcTy->getScalarType()->isPointerTy() && 2908 DstTy->getScalarType()->isIntegerTy(); 2909 case Instruction::IntToPtr: 2910 if (isa<VectorType>(SrcTy) != isa<VectorType>(DstTy)) 2911 return false; 2912 if (VectorType *VT = dyn_cast<VectorType>(SrcTy)) 2913 if (VT->getNumElements() != cast<VectorType>(DstTy)->getNumElements()) 2914 return false; 2915 return SrcTy->getScalarType()->isIntegerTy() && 2916 DstTy->getScalarType()->isPointerTy(); 2917 case Instruction::BitCast: { 2918 PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy->getScalarType()); 2919 PointerType *DstPtrTy = dyn_cast<PointerType>(DstTy->getScalarType()); 2920 2921 // BitCast implies a no-op cast of type only. No bits change. 2922 // However, you can't cast pointers to anything but pointers. 2923 if (!SrcPtrTy != !DstPtrTy) 2924 return false; 2925 2926 // For non-pointer cases, the cast is okay if the source and destination bit 2927 // widths are identical. 2928 if (!SrcPtrTy) 2929 return SrcTy->getPrimitiveSizeInBits() == DstTy->getPrimitiveSizeInBits(); 2930 2931 // If both are pointers then the address spaces must match. 2932 if (SrcPtrTy->getAddressSpace() != DstPtrTy->getAddressSpace()) 2933 return false; 2934 2935 // A vector of pointers must have the same number of elements. 2936 if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy)) { 2937 if (VectorType *DstVecTy = dyn_cast<VectorType>(DstTy)) 2938 return (SrcVecTy->getNumElements() == DstVecTy->getNumElements()); 2939 2940 return false; 2941 } 2942 2943 return true; 2944 } 2945 case Instruction::AddrSpaceCast: { 2946 PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy->getScalarType()); 2947 if (!SrcPtrTy) 2948 return false; 2949 2950 PointerType *DstPtrTy = dyn_cast<PointerType>(DstTy->getScalarType()); 2951 if (!DstPtrTy) 2952 return false; 2953 2954 if (SrcPtrTy->getAddressSpace() == DstPtrTy->getAddressSpace()) 2955 return false; 2956 2957 if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy)) { 2958 if (VectorType *DstVecTy = dyn_cast<VectorType>(DstTy)) 2959 return (SrcVecTy->getNumElements() == DstVecTy->getNumElements()); 2960 2961 return false; 2962 } 2963 2964 return true; 2965 } 2966 } 2967 } 2968 2969 TruncInst::TruncInst( 2970 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 2971 ) : CastInst(Ty, Trunc, S, Name, InsertBefore) { 2972 assert(castIsValid(getOpcode(), S, Ty) && "Illegal Trunc"); 2973 } 2974 2975 TruncInst::TruncInst( 2976 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 2977 ) : CastInst(Ty, Trunc, S, Name, InsertAtEnd) { 2978 assert(castIsValid(getOpcode(), S, Ty) && "Illegal Trunc"); 2979 } 2980 2981 ZExtInst::ZExtInst( 2982 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 2983 ) : CastInst(Ty, ZExt, S, Name, InsertBefore) { 2984 assert(castIsValid(getOpcode(), S, Ty) && "Illegal ZExt"); 2985 } 2986 2987 ZExtInst::ZExtInst( 2988 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 2989 ) : CastInst(Ty, ZExt, S, Name, InsertAtEnd) { 2990 assert(castIsValid(getOpcode(), S, Ty) && "Illegal ZExt"); 2991 } 2992 SExtInst::SExtInst( 2993 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 2994 ) : CastInst(Ty, SExt, S, Name, InsertBefore) { 2995 assert(castIsValid(getOpcode(), S, Ty) && "Illegal SExt"); 2996 } 2997 2998 SExtInst::SExtInst( 2999 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3000 ) : CastInst(Ty, SExt, S, Name, InsertAtEnd) { 3001 assert(castIsValid(getOpcode(), S, Ty) && "Illegal SExt"); 3002 } 3003 3004 FPTruncInst::FPTruncInst( 3005 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3006 ) : CastInst(Ty, FPTrunc, S, Name, InsertBefore) { 3007 assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPTrunc"); 3008 } 3009 3010 FPTruncInst::FPTruncInst( 3011 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3012 ) : CastInst(Ty, FPTrunc, S, Name, InsertAtEnd) { 3013 assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPTrunc"); 3014 } 3015 3016 FPExtInst::FPExtInst( 3017 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3018 ) : CastInst(Ty, FPExt, S, Name, InsertBefore) { 3019 assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPExt"); 3020 } 3021 3022 FPExtInst::FPExtInst( 3023 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3024 ) : CastInst(Ty, FPExt, S, Name, InsertAtEnd) { 3025 assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPExt"); 3026 } 3027 3028 UIToFPInst::UIToFPInst( 3029 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3030 ) : CastInst(Ty, UIToFP, S, Name, InsertBefore) { 3031 assert(castIsValid(getOpcode(), S, Ty) && "Illegal UIToFP"); 3032 } 3033 3034 UIToFPInst::UIToFPInst( 3035 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3036 ) : CastInst(Ty, UIToFP, S, Name, InsertAtEnd) { 3037 assert(castIsValid(getOpcode(), S, Ty) && "Illegal UIToFP"); 3038 } 3039 3040 SIToFPInst::SIToFPInst( 3041 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3042 ) : CastInst(Ty, SIToFP, S, Name, InsertBefore) { 3043 assert(castIsValid(getOpcode(), S, Ty) && "Illegal SIToFP"); 3044 } 3045 3046 SIToFPInst::SIToFPInst( 3047 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3048 ) : CastInst(Ty, SIToFP, S, Name, InsertAtEnd) { 3049 assert(castIsValid(getOpcode(), S, Ty) && "Illegal SIToFP"); 3050 } 3051 3052 FPToUIInst::FPToUIInst( 3053 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3054 ) : CastInst(Ty, FPToUI, S, Name, InsertBefore) { 3055 assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToUI"); 3056 } 3057 3058 FPToUIInst::FPToUIInst( 3059 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3060 ) : CastInst(Ty, FPToUI, S, Name, InsertAtEnd) { 3061 assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToUI"); 3062 } 3063 3064 FPToSIInst::FPToSIInst( 3065 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3066 ) : CastInst(Ty, FPToSI, S, Name, InsertBefore) { 3067 assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToSI"); 3068 } 3069 3070 FPToSIInst::FPToSIInst( 3071 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3072 ) : CastInst(Ty, FPToSI, S, Name, InsertAtEnd) { 3073 assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToSI"); 3074 } 3075 3076 PtrToIntInst::PtrToIntInst( 3077 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3078 ) : CastInst(Ty, PtrToInt, S, Name, InsertBefore) { 3079 assert(castIsValid(getOpcode(), S, Ty) && "Illegal PtrToInt"); 3080 } 3081 3082 PtrToIntInst::PtrToIntInst( 3083 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3084 ) : CastInst(Ty, PtrToInt, S, Name, InsertAtEnd) { 3085 assert(castIsValid(getOpcode(), S, Ty) && "Illegal PtrToInt"); 3086 } 3087 3088 IntToPtrInst::IntToPtrInst( 3089 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3090 ) : CastInst(Ty, IntToPtr, S, Name, InsertBefore) { 3091 assert(castIsValid(getOpcode(), S, Ty) && "Illegal IntToPtr"); 3092 } 3093 3094 IntToPtrInst::IntToPtrInst( 3095 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3096 ) : CastInst(Ty, IntToPtr, S, Name, InsertAtEnd) { 3097 assert(castIsValid(getOpcode(), S, Ty) && "Illegal IntToPtr"); 3098 } 3099 3100 BitCastInst::BitCastInst( 3101 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3102 ) : CastInst(Ty, BitCast, S, Name, InsertBefore) { 3103 assert(castIsValid(getOpcode(), S, Ty) && "Illegal BitCast"); 3104 } 3105 3106 BitCastInst::BitCastInst( 3107 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3108 ) : CastInst(Ty, BitCast, S, Name, InsertAtEnd) { 3109 assert(castIsValid(getOpcode(), S, Ty) && "Illegal BitCast"); 3110 } 3111 3112 AddrSpaceCastInst::AddrSpaceCastInst( 3113 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3114 ) : CastInst(Ty, AddrSpaceCast, S, Name, InsertBefore) { 3115 assert(castIsValid(getOpcode(), S, Ty) && "Illegal AddrSpaceCast"); 3116 } 3117 3118 AddrSpaceCastInst::AddrSpaceCastInst( 3119 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3120 ) : CastInst(Ty, AddrSpaceCast, S, Name, InsertAtEnd) { 3121 assert(castIsValid(getOpcode(), S, Ty) && "Illegal AddrSpaceCast"); 3122 } 3123 3124 //===----------------------------------------------------------------------===// 3125 // CmpInst Classes 3126 //===----------------------------------------------------------------------===// 3127 3128 void CmpInst::anchor() {} 3129 3130 CmpInst::CmpInst(Type *ty, OtherOps op, unsigned short predicate, 3131 Value *LHS, Value *RHS, const Twine &Name, 3132 Instruction *InsertBefore) 3133 : Instruction(ty, op, 3134 OperandTraits<CmpInst>::op_begin(this), 3135 OperandTraits<CmpInst>::operands(this), 3136 InsertBefore) { 3137 Op<0>() = LHS; 3138 Op<1>() = RHS; 3139 setPredicate((Predicate)predicate); 3140 setName(Name); 3141 } 3142 3143 CmpInst::CmpInst(Type *ty, OtherOps op, unsigned short predicate, 3144 Value *LHS, Value *RHS, const Twine &Name, 3145 BasicBlock *InsertAtEnd) 3146 : Instruction(ty, op, 3147 OperandTraits<CmpInst>::op_begin(this), 3148 OperandTraits<CmpInst>::operands(this), 3149 InsertAtEnd) { 3150 Op<0>() = LHS; 3151 Op<1>() = RHS; 3152 setPredicate((Predicate)predicate); 3153 setName(Name); 3154 } 3155 3156 CmpInst * 3157 CmpInst::Create(OtherOps Op, unsigned short predicate, 3158 Value *S1, Value *S2, 3159 const Twine &Name, Instruction *InsertBefore) { 3160 if (Op == Instruction::ICmp) { 3161 if (InsertBefore) 3162 return new ICmpInst(InsertBefore, CmpInst::Predicate(predicate), 3163 S1, S2, Name); 3164 else 3165 return new ICmpInst(CmpInst::Predicate(predicate), 3166 S1, S2, Name); 3167 } 3168 3169 if (InsertBefore) 3170 return new FCmpInst(InsertBefore, CmpInst::Predicate(predicate), 3171 S1, S2, Name); 3172 else 3173 return new FCmpInst(CmpInst::Predicate(predicate), 3174 S1, S2, Name); 3175 } 3176 3177 CmpInst * 3178 CmpInst::Create(OtherOps Op, unsigned short predicate, Value *S1, Value *S2, 3179 const Twine &Name, BasicBlock *InsertAtEnd) { 3180 if (Op == Instruction::ICmp) { 3181 return new ICmpInst(*InsertAtEnd, CmpInst::Predicate(predicate), 3182 S1, S2, Name); 3183 } 3184 return new FCmpInst(*InsertAtEnd, CmpInst::Predicate(predicate), 3185 S1, S2, Name); 3186 } 3187 3188 void CmpInst::swapOperands() { 3189 if (ICmpInst *IC = dyn_cast<ICmpInst>(this)) 3190 IC->swapOperands(); 3191 else 3192 cast<FCmpInst>(this)->swapOperands(); 3193 } 3194 3195 bool CmpInst::isCommutative() const { 3196 if (const ICmpInst *IC = dyn_cast<ICmpInst>(this)) 3197 return IC->isCommutative(); 3198 return cast<FCmpInst>(this)->isCommutative(); 3199 } 3200 3201 bool CmpInst::isEquality() const { 3202 if (const ICmpInst *IC = dyn_cast<ICmpInst>(this)) 3203 return IC->isEquality(); 3204 return cast<FCmpInst>(this)->isEquality(); 3205 } 3206 3207 3208 CmpInst::Predicate CmpInst::getInversePredicate(Predicate pred) { 3209 switch (pred) { 3210 default: llvm_unreachable("Unknown cmp predicate!"); 3211 case ICMP_EQ: return ICMP_NE; 3212 case ICMP_NE: return ICMP_EQ; 3213 case ICMP_UGT: return ICMP_ULE; 3214 case ICMP_ULT: return ICMP_UGE; 3215 case ICMP_UGE: return ICMP_ULT; 3216 case ICMP_ULE: return ICMP_UGT; 3217 case ICMP_SGT: return ICMP_SLE; 3218 case ICMP_SLT: return ICMP_SGE; 3219 case ICMP_SGE: return ICMP_SLT; 3220 case ICMP_SLE: return ICMP_SGT; 3221 3222 case FCMP_OEQ: return FCMP_UNE; 3223 case FCMP_ONE: return FCMP_UEQ; 3224 case FCMP_OGT: return FCMP_ULE; 3225 case FCMP_OLT: return FCMP_UGE; 3226 case FCMP_OGE: return FCMP_ULT; 3227 case FCMP_OLE: return FCMP_UGT; 3228 case FCMP_UEQ: return FCMP_ONE; 3229 case FCMP_UNE: return FCMP_OEQ; 3230 case FCMP_UGT: return FCMP_OLE; 3231 case FCMP_ULT: return FCMP_OGE; 3232 case FCMP_UGE: return FCMP_OLT; 3233 case FCMP_ULE: return FCMP_OGT; 3234 case FCMP_ORD: return FCMP_UNO; 3235 case FCMP_UNO: return FCMP_ORD; 3236 case FCMP_TRUE: return FCMP_FALSE; 3237 case FCMP_FALSE: return FCMP_TRUE; 3238 } 3239 } 3240 3241 ICmpInst::Predicate ICmpInst::getSignedPredicate(Predicate pred) { 3242 switch (pred) { 3243 default: llvm_unreachable("Unknown icmp predicate!"); 3244 case ICMP_EQ: case ICMP_NE: 3245 case ICMP_SGT: case ICMP_SLT: case ICMP_SGE: case ICMP_SLE: 3246 return pred; 3247 case ICMP_UGT: return ICMP_SGT; 3248 case ICMP_ULT: return ICMP_SLT; 3249 case ICMP_UGE: return ICMP_SGE; 3250 case ICMP_ULE: return ICMP_SLE; 3251 } 3252 } 3253 3254 ICmpInst::Predicate ICmpInst::getUnsignedPredicate(Predicate pred) { 3255 switch (pred) { 3256 default: llvm_unreachable("Unknown icmp predicate!"); 3257 case ICMP_EQ: case ICMP_NE: 3258 case ICMP_UGT: case ICMP_ULT: case ICMP_UGE: case ICMP_ULE: 3259 return pred; 3260 case ICMP_SGT: return ICMP_UGT; 3261 case ICMP_SLT: return ICMP_ULT; 3262 case ICMP_SGE: return ICMP_UGE; 3263 case ICMP_SLE: return ICMP_ULE; 3264 } 3265 } 3266 3267 /// Initialize a set of values that all satisfy the condition with C. 3268 /// 3269 ConstantRange 3270 ICmpInst::makeConstantRange(Predicate pred, const APInt &C) { 3271 APInt Lower(C); 3272 APInt Upper(C); 3273 uint32_t BitWidth = C.getBitWidth(); 3274 switch (pred) { 3275 default: llvm_unreachable("Invalid ICmp opcode to ConstantRange ctor!"); 3276 case ICmpInst::ICMP_EQ: ++Upper; break; 3277 case ICmpInst::ICMP_NE: ++Lower; break; 3278 case ICmpInst::ICMP_ULT: 3279 Lower = APInt::getMinValue(BitWidth); 3280 // Check for an empty-set condition. 3281 if (Lower == Upper) 3282 return ConstantRange(BitWidth, /*isFullSet=*/false); 3283 break; 3284 case ICmpInst::ICMP_SLT: 3285 Lower = APInt::getSignedMinValue(BitWidth); 3286 // Check for an empty-set condition. 3287 if (Lower == Upper) 3288 return ConstantRange(BitWidth, /*isFullSet=*/false); 3289 break; 3290 case ICmpInst::ICMP_UGT: 3291 ++Lower; Upper = APInt::getMinValue(BitWidth); // Min = Next(Max) 3292 // Check for an empty-set condition. 3293 if (Lower == Upper) 3294 return ConstantRange(BitWidth, /*isFullSet=*/false); 3295 break; 3296 case ICmpInst::ICMP_SGT: 3297 ++Lower; Upper = APInt::getSignedMinValue(BitWidth); // Min = Next(Max) 3298 // Check for an empty-set condition. 3299 if (Lower == Upper) 3300 return ConstantRange(BitWidth, /*isFullSet=*/false); 3301 break; 3302 case ICmpInst::ICMP_ULE: 3303 Lower = APInt::getMinValue(BitWidth); ++Upper; 3304 // Check for a full-set condition. 3305 if (Lower == Upper) 3306 return ConstantRange(BitWidth, /*isFullSet=*/true); 3307 break; 3308 case ICmpInst::ICMP_SLE: 3309 Lower = APInt::getSignedMinValue(BitWidth); ++Upper; 3310 // Check for a full-set condition. 3311 if (Lower == Upper) 3312 return ConstantRange(BitWidth, /*isFullSet=*/true); 3313 break; 3314 case ICmpInst::ICMP_UGE: 3315 Upper = APInt::getMinValue(BitWidth); // Min = Next(Max) 3316 // Check for a full-set condition. 3317 if (Lower == Upper) 3318 return ConstantRange(BitWidth, /*isFullSet=*/true); 3319 break; 3320 case ICmpInst::ICMP_SGE: 3321 Upper = APInt::getSignedMinValue(BitWidth); // Min = Next(Max) 3322 // Check for a full-set condition. 3323 if (Lower == Upper) 3324 return ConstantRange(BitWidth, /*isFullSet=*/true); 3325 break; 3326 } 3327 return ConstantRange(Lower, Upper); 3328 } 3329 3330 CmpInst::Predicate CmpInst::getSwappedPredicate(Predicate pred) { 3331 switch (pred) { 3332 default: llvm_unreachable("Unknown cmp predicate!"); 3333 case ICMP_EQ: case ICMP_NE: 3334 return pred; 3335 case ICMP_SGT: return ICMP_SLT; 3336 case ICMP_SLT: return ICMP_SGT; 3337 case ICMP_SGE: return ICMP_SLE; 3338 case ICMP_SLE: return ICMP_SGE; 3339 case ICMP_UGT: return ICMP_ULT; 3340 case ICMP_ULT: return ICMP_UGT; 3341 case ICMP_UGE: return ICMP_ULE; 3342 case ICMP_ULE: return ICMP_UGE; 3343 3344 case FCMP_FALSE: case FCMP_TRUE: 3345 case FCMP_OEQ: case FCMP_ONE: 3346 case FCMP_UEQ: case FCMP_UNE: 3347 case FCMP_ORD: case FCMP_UNO: 3348 return pred; 3349 case FCMP_OGT: return FCMP_OLT; 3350 case FCMP_OLT: return FCMP_OGT; 3351 case FCMP_OGE: return FCMP_OLE; 3352 case FCMP_OLE: return FCMP_OGE; 3353 case FCMP_UGT: return FCMP_ULT; 3354 case FCMP_ULT: return FCMP_UGT; 3355 case FCMP_UGE: return FCMP_ULE; 3356 case FCMP_ULE: return FCMP_UGE; 3357 } 3358 } 3359 3360 bool CmpInst::isUnsigned(unsigned short predicate) { 3361 switch (predicate) { 3362 default: return false; 3363 case ICmpInst::ICMP_ULT: case ICmpInst::ICMP_ULE: case ICmpInst::ICMP_UGT: 3364 case ICmpInst::ICMP_UGE: return true; 3365 } 3366 } 3367 3368 bool CmpInst::isSigned(unsigned short predicate) { 3369 switch (predicate) { 3370 default: return false; 3371 case ICmpInst::ICMP_SLT: case ICmpInst::ICMP_SLE: case ICmpInst::ICMP_SGT: 3372 case ICmpInst::ICMP_SGE: return true; 3373 } 3374 } 3375 3376 bool CmpInst::isOrdered(unsigned short predicate) { 3377 switch (predicate) { 3378 default: return false; 3379 case FCmpInst::FCMP_OEQ: case FCmpInst::FCMP_ONE: case FCmpInst::FCMP_OGT: 3380 case FCmpInst::FCMP_OLT: case FCmpInst::FCMP_OGE: case FCmpInst::FCMP_OLE: 3381 case FCmpInst::FCMP_ORD: return true; 3382 } 3383 } 3384 3385 bool CmpInst::isUnordered(unsigned short predicate) { 3386 switch (predicate) { 3387 default: return false; 3388 case FCmpInst::FCMP_UEQ: case FCmpInst::FCMP_UNE: case FCmpInst::FCMP_UGT: 3389 case FCmpInst::FCMP_ULT: case FCmpInst::FCMP_UGE: case FCmpInst::FCMP_ULE: 3390 case FCmpInst::FCMP_UNO: return true; 3391 } 3392 } 3393 3394 bool CmpInst::isTrueWhenEqual(unsigned short predicate) { 3395 switch(predicate) { 3396 default: return false; 3397 case ICMP_EQ: case ICMP_UGE: case ICMP_ULE: case ICMP_SGE: case ICMP_SLE: 3398 case FCMP_TRUE: case FCMP_UEQ: case FCMP_UGE: case FCMP_ULE: return true; 3399 } 3400 } 3401 3402 bool CmpInst::isFalseWhenEqual(unsigned short predicate) { 3403 switch(predicate) { 3404 case ICMP_NE: case ICMP_UGT: case ICMP_ULT: case ICMP_SGT: case ICMP_SLT: 3405 case FCMP_FALSE: case FCMP_ONE: case FCMP_OGT: case FCMP_OLT: return true; 3406 default: return false; 3407 } 3408 } 3409 3410 3411 //===----------------------------------------------------------------------===// 3412 // SwitchInst Implementation 3413 //===----------------------------------------------------------------------===// 3414 3415 void SwitchInst::init(Value *Value, BasicBlock *Default, unsigned NumReserved) { 3416 assert(Value && Default && NumReserved); 3417 ReservedSpace = NumReserved; 3418 NumOperands = 2; 3419 OperandList = allocHungoffUses(ReservedSpace); 3420 3421 OperandList[0] = Value; 3422 OperandList[1] = Default; 3423 } 3424 3425 /// SwitchInst ctor - Create a new switch instruction, specifying a value to 3426 /// switch on and a default destination. The number of additional cases can 3427 /// be specified here to make memory allocation more efficient. This 3428 /// constructor can also autoinsert before another instruction. 3429 SwitchInst::SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases, 3430 Instruction *InsertBefore) 3431 : TerminatorInst(Type::getVoidTy(Value->getContext()), Instruction::Switch, 3432 nullptr, 0, InsertBefore) { 3433 init(Value, Default, 2+NumCases*2); 3434 } 3435 3436 /// SwitchInst ctor - Create a new switch instruction, specifying a value to 3437 /// switch on and a default destination. The number of additional cases can 3438 /// be specified here to make memory allocation more efficient. This 3439 /// constructor also autoinserts at the end of the specified BasicBlock. 3440 SwitchInst::SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases, 3441 BasicBlock *InsertAtEnd) 3442 : TerminatorInst(Type::getVoidTy(Value->getContext()), Instruction::Switch, 3443 nullptr, 0, InsertAtEnd) { 3444 init(Value, Default, 2+NumCases*2); 3445 } 3446 3447 SwitchInst::SwitchInst(const SwitchInst &SI) 3448 : TerminatorInst(SI.getType(), Instruction::Switch, nullptr, 0) { 3449 init(SI.getCondition(), SI.getDefaultDest(), SI.getNumOperands()); 3450 NumOperands = SI.getNumOperands(); 3451 Use *OL = OperandList, *InOL = SI.OperandList; 3452 for (unsigned i = 2, E = SI.getNumOperands(); i != E; i += 2) { 3453 OL[i] = InOL[i]; 3454 OL[i+1] = InOL[i+1]; 3455 } 3456 SubclassOptionalData = SI.SubclassOptionalData; 3457 } 3458 3459 SwitchInst::~SwitchInst() { 3460 dropHungoffUses(); 3461 } 3462 3463 3464 /// addCase - Add an entry to the switch instruction... 3465 /// 3466 void SwitchInst::addCase(ConstantInt *OnVal, BasicBlock *Dest) { 3467 unsigned NewCaseIdx = getNumCases(); 3468 unsigned OpNo = NumOperands; 3469 if (OpNo+2 > ReservedSpace) 3470 growOperands(); // Get more space! 3471 // Initialize some new operands. 3472 assert(OpNo+1 < ReservedSpace && "Growing didn't work!"); 3473 NumOperands = OpNo+2; 3474 CaseIt Case(this, NewCaseIdx); 3475 Case.setValue(OnVal); 3476 Case.setSuccessor(Dest); 3477 } 3478 3479 /// removeCase - This method removes the specified case and its successor 3480 /// from the switch instruction. 3481 void SwitchInst::removeCase(CaseIt i) { 3482 unsigned idx = i.getCaseIndex(); 3483 3484 assert(2 + idx*2 < getNumOperands() && "Case index out of range!!!"); 3485 3486 unsigned NumOps = getNumOperands(); 3487 Use *OL = OperandList; 3488 3489 // Overwrite this case with the end of the list. 3490 if (2 + (idx + 1) * 2 != NumOps) { 3491 OL[2 + idx * 2] = OL[NumOps - 2]; 3492 OL[2 + idx * 2 + 1] = OL[NumOps - 1]; 3493 } 3494 3495 // Nuke the last value. 3496 OL[NumOps-2].set(nullptr); 3497 OL[NumOps-2+1].set(nullptr); 3498 NumOperands = NumOps-2; 3499 } 3500 3501 /// growOperands - grow operands - This grows the operand list in response 3502 /// to a push_back style of operation. This grows the number of ops by 3 times. 3503 /// 3504 void SwitchInst::growOperands() { 3505 unsigned e = getNumOperands(); 3506 unsigned NumOps = e*3; 3507 3508 ReservedSpace = NumOps; 3509 Use *NewOps = allocHungoffUses(NumOps); 3510 Use *OldOps = OperandList; 3511 for (unsigned i = 0; i != e; ++i) { 3512 NewOps[i] = OldOps[i]; 3513 } 3514 OperandList = NewOps; 3515 Use::zap(OldOps, OldOps + e, true); 3516 } 3517 3518 3519 BasicBlock *SwitchInst::getSuccessorV(unsigned idx) const { 3520 return getSuccessor(idx); 3521 } 3522 unsigned SwitchInst::getNumSuccessorsV() const { 3523 return getNumSuccessors(); 3524 } 3525 void SwitchInst::setSuccessorV(unsigned idx, BasicBlock *B) { 3526 setSuccessor(idx, B); 3527 } 3528 3529 //===----------------------------------------------------------------------===// 3530 // IndirectBrInst Implementation 3531 //===----------------------------------------------------------------------===// 3532 3533 void IndirectBrInst::init(Value *Address, unsigned NumDests) { 3534 assert(Address && Address->getType()->isPointerTy() && 3535 "Address of indirectbr must be a pointer"); 3536 ReservedSpace = 1+NumDests; 3537 NumOperands = 1; 3538 OperandList = allocHungoffUses(ReservedSpace); 3539 3540 OperandList[0] = Address; 3541 } 3542 3543 3544 /// growOperands - grow operands - This grows the operand list in response 3545 /// to a push_back style of operation. This grows the number of ops by 2 times. 3546 /// 3547 void IndirectBrInst::growOperands() { 3548 unsigned e = getNumOperands(); 3549 unsigned NumOps = e*2; 3550 3551 ReservedSpace = NumOps; 3552 Use *NewOps = allocHungoffUses(NumOps); 3553 Use *OldOps = OperandList; 3554 for (unsigned i = 0; i != e; ++i) 3555 NewOps[i] = OldOps[i]; 3556 OperandList = NewOps; 3557 Use::zap(OldOps, OldOps + e, true); 3558 } 3559 3560 IndirectBrInst::IndirectBrInst(Value *Address, unsigned NumCases, 3561 Instruction *InsertBefore) 3562 : TerminatorInst(Type::getVoidTy(Address->getContext()),Instruction::IndirectBr, 3563 nullptr, 0, InsertBefore) { 3564 init(Address, NumCases); 3565 } 3566 3567 IndirectBrInst::IndirectBrInst(Value *Address, unsigned NumCases, 3568 BasicBlock *InsertAtEnd) 3569 : TerminatorInst(Type::getVoidTy(Address->getContext()),Instruction::IndirectBr, 3570 nullptr, 0, InsertAtEnd) { 3571 init(Address, NumCases); 3572 } 3573 3574 IndirectBrInst::IndirectBrInst(const IndirectBrInst &IBI) 3575 : TerminatorInst(Type::getVoidTy(IBI.getContext()), Instruction::IndirectBr, 3576 allocHungoffUses(IBI.getNumOperands()), 3577 IBI.getNumOperands()) { 3578 Use *OL = OperandList, *InOL = IBI.OperandList; 3579 for (unsigned i = 0, E = IBI.getNumOperands(); i != E; ++i) 3580 OL[i] = InOL[i]; 3581 SubclassOptionalData = IBI.SubclassOptionalData; 3582 } 3583 3584 IndirectBrInst::~IndirectBrInst() { 3585 dropHungoffUses(); 3586 } 3587 3588 /// addDestination - Add a destination. 3589 /// 3590 void IndirectBrInst::addDestination(BasicBlock *DestBB) { 3591 unsigned OpNo = NumOperands; 3592 if (OpNo+1 > ReservedSpace) 3593 growOperands(); // Get more space! 3594 // Initialize some new operands. 3595 assert(OpNo < ReservedSpace && "Growing didn't work!"); 3596 NumOperands = OpNo+1; 3597 OperandList[OpNo] = DestBB; 3598 } 3599 3600 /// removeDestination - This method removes the specified successor from the 3601 /// indirectbr instruction. 3602 void IndirectBrInst::removeDestination(unsigned idx) { 3603 assert(idx < getNumOperands()-1 && "Successor index out of range!"); 3604 3605 unsigned NumOps = getNumOperands(); 3606 Use *OL = OperandList; 3607 3608 // Replace this value with the last one. 3609 OL[idx+1] = OL[NumOps-1]; 3610 3611 // Nuke the last value. 3612 OL[NumOps-1].set(nullptr); 3613 NumOperands = NumOps-1; 3614 } 3615 3616 BasicBlock *IndirectBrInst::getSuccessorV(unsigned idx) const { 3617 return getSuccessor(idx); 3618 } 3619 unsigned IndirectBrInst::getNumSuccessorsV() const { 3620 return getNumSuccessors(); 3621 } 3622 void IndirectBrInst::setSuccessorV(unsigned idx, BasicBlock *B) { 3623 setSuccessor(idx, B); 3624 } 3625 3626 //===----------------------------------------------------------------------===// 3627 // clone_impl() implementations 3628 //===----------------------------------------------------------------------===// 3629 3630 // Define these methods here so vtables don't get emitted into every translation 3631 // unit that uses these classes. 3632 3633 GetElementPtrInst *GetElementPtrInst::clone_impl() const { 3634 return new (getNumOperands()) GetElementPtrInst(*this); 3635 } 3636 3637 BinaryOperator *BinaryOperator::clone_impl() const { 3638 return Create(getOpcode(), Op<0>(), Op<1>()); 3639 } 3640 3641 FCmpInst* FCmpInst::clone_impl() const { 3642 return new FCmpInst(getPredicate(), Op<0>(), Op<1>()); 3643 } 3644 3645 ICmpInst* ICmpInst::clone_impl() const { 3646 return new ICmpInst(getPredicate(), Op<0>(), Op<1>()); 3647 } 3648 3649 ExtractValueInst *ExtractValueInst::clone_impl() const { 3650 return new ExtractValueInst(*this); 3651 } 3652 3653 InsertValueInst *InsertValueInst::clone_impl() const { 3654 return new InsertValueInst(*this); 3655 } 3656 3657 AllocaInst *AllocaInst::clone_impl() const { 3658 AllocaInst *Result = new AllocaInst(getAllocatedType(), 3659 (Value *)getOperand(0), getAlignment()); 3660 Result->setUsedWithInAlloca(isUsedWithInAlloca()); 3661 return Result; 3662 } 3663 3664 LoadInst *LoadInst::clone_impl() const { 3665 return new LoadInst(getOperand(0), Twine(), isVolatile(), 3666 getAlignment(), getOrdering(), getSynchScope()); 3667 } 3668 3669 StoreInst *StoreInst::clone_impl() const { 3670 return new StoreInst(getOperand(0), getOperand(1), isVolatile(), 3671 getAlignment(), getOrdering(), getSynchScope()); 3672 3673 } 3674 3675 AtomicCmpXchgInst *AtomicCmpXchgInst::clone_impl() const { 3676 AtomicCmpXchgInst *Result = 3677 new AtomicCmpXchgInst(getOperand(0), getOperand(1), getOperand(2), 3678 getSuccessOrdering(), getFailureOrdering(), 3679 getSynchScope()); 3680 Result->setVolatile(isVolatile()); 3681 Result->setWeak(isWeak()); 3682 return Result; 3683 } 3684 3685 AtomicRMWInst *AtomicRMWInst::clone_impl() const { 3686 AtomicRMWInst *Result = 3687 new AtomicRMWInst(getOperation(),getOperand(0), getOperand(1), 3688 getOrdering(), getSynchScope()); 3689 Result->setVolatile(isVolatile()); 3690 return Result; 3691 } 3692 3693 FenceInst *FenceInst::clone_impl() const { 3694 return new FenceInst(getContext(), getOrdering(), getSynchScope()); 3695 } 3696 3697 TruncInst *TruncInst::clone_impl() const { 3698 return new TruncInst(getOperand(0), getType()); 3699 } 3700 3701 ZExtInst *ZExtInst::clone_impl() const { 3702 return new ZExtInst(getOperand(0), getType()); 3703 } 3704 3705 SExtInst *SExtInst::clone_impl() const { 3706 return new SExtInst(getOperand(0), getType()); 3707 } 3708 3709 FPTruncInst *FPTruncInst::clone_impl() const { 3710 return new FPTruncInst(getOperand(0), getType()); 3711 } 3712 3713 FPExtInst *FPExtInst::clone_impl() const { 3714 return new FPExtInst(getOperand(0), getType()); 3715 } 3716 3717 UIToFPInst *UIToFPInst::clone_impl() const { 3718 return new UIToFPInst(getOperand(0), getType()); 3719 } 3720 3721 SIToFPInst *SIToFPInst::clone_impl() const { 3722 return new SIToFPInst(getOperand(0), getType()); 3723 } 3724 3725 FPToUIInst *FPToUIInst::clone_impl() const { 3726 return new FPToUIInst(getOperand(0), getType()); 3727 } 3728 3729 FPToSIInst *FPToSIInst::clone_impl() const { 3730 return new FPToSIInst(getOperand(0), getType()); 3731 } 3732 3733 PtrToIntInst *PtrToIntInst::clone_impl() const { 3734 return new PtrToIntInst(getOperand(0), getType()); 3735 } 3736 3737 IntToPtrInst *IntToPtrInst::clone_impl() const { 3738 return new IntToPtrInst(getOperand(0), getType()); 3739 } 3740 3741 BitCastInst *BitCastInst::clone_impl() const { 3742 return new BitCastInst(getOperand(0), getType()); 3743 } 3744 3745 AddrSpaceCastInst *AddrSpaceCastInst::clone_impl() const { 3746 return new AddrSpaceCastInst(getOperand(0), getType()); 3747 } 3748 3749 CallInst *CallInst::clone_impl() const { 3750 return new(getNumOperands()) CallInst(*this); 3751 } 3752 3753 SelectInst *SelectInst::clone_impl() const { 3754 return SelectInst::Create(getOperand(0), getOperand(1), getOperand(2)); 3755 } 3756 3757 VAArgInst *VAArgInst::clone_impl() const { 3758 return new VAArgInst(getOperand(0), getType()); 3759 } 3760 3761 ExtractElementInst *ExtractElementInst::clone_impl() const { 3762 return ExtractElementInst::Create(getOperand(0), getOperand(1)); 3763 } 3764 3765 InsertElementInst *InsertElementInst::clone_impl() const { 3766 return InsertElementInst::Create(getOperand(0), getOperand(1), getOperand(2)); 3767 } 3768 3769 ShuffleVectorInst *ShuffleVectorInst::clone_impl() const { 3770 return new ShuffleVectorInst(getOperand(0), getOperand(1), getOperand(2)); 3771 } 3772 3773 PHINode *PHINode::clone_impl() const { 3774 return new PHINode(*this); 3775 } 3776 3777 LandingPadInst *LandingPadInst::clone_impl() const { 3778 return new LandingPadInst(*this); 3779 } 3780 3781 ReturnInst *ReturnInst::clone_impl() const { 3782 return new(getNumOperands()) ReturnInst(*this); 3783 } 3784 3785 BranchInst *BranchInst::clone_impl() const { 3786 return new(getNumOperands()) BranchInst(*this); 3787 } 3788 3789 SwitchInst *SwitchInst::clone_impl() const { 3790 return new SwitchInst(*this); 3791 } 3792 3793 IndirectBrInst *IndirectBrInst::clone_impl() const { 3794 return new IndirectBrInst(*this); 3795 } 3796 3797 3798 InvokeInst *InvokeInst::clone_impl() const { 3799 return new(getNumOperands()) InvokeInst(*this); 3800 } 3801 3802 ResumeInst *ResumeInst::clone_impl() const { 3803 return new(1) ResumeInst(*this); 3804 } 3805 3806 UnreachableInst *UnreachableInst::clone_impl() const { 3807 LLVMContext &Context = getContext(); 3808 return new UnreachableInst(Context); 3809 } 3810