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