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