1//===- Instructions.cpp - Implement the LLVM instructions -----------------===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// This file implements all of the non-inline methods for the LLVM instruction 10// classes. 11// 12//===----------------------------------------------------------------------===// 13 14#include "llvm/IR/Instructions.h" 15#include "LLVMContextImpl.h" 16#include "llvm/ADT/None.h" 17#include "llvm/ADT/SmallVector.h" 18#include "llvm/ADT/Twine.h" 19#include "llvm/IR/Attributes.h" 20#include "llvm/IR/BasicBlock.h" 21#include "llvm/IR/Constant.h" 22#include "llvm/IR/Constants.h" 23#include "llvm/IR/DataLayout.h" 24#include "llvm/IR/DerivedTypes.h" 25#include "llvm/IR/Function.h" 26#include "llvm/IR/InstrTypes.h" 27#include "llvm/IR/Instruction.h" 28#include "llvm/IR/Intrinsics.h" 29#include "llvm/IR/LLVMContext.h" 30#include "llvm/IR/MDBuilder.h" 31#include "llvm/IR/Metadata.h" 32#include "llvm/IR/Module.h" 33#include "llvm/IR/Operator.h" 34#include "llvm/IR/Type.h" 35#include "llvm/IR/Value.h" 36#include "llvm/Support/AtomicOrdering.h" 37#include "llvm/Support/Casting.h" 38#include "llvm/Support/ErrorHandling.h" 39#include "llvm/Support/MathExtras.h" 40#include "llvm/Support/TypeSize.h" 41#include <algorithm> 42#include <cassert> 43#include <cstdint> 44#include <vector> 45 46using namespace llvm; 47 48//===----------------------------------------------------------------------===// 49// AllocaInst Class 50//===----------------------------------------------------------------------===// 51 52Optional<TypeSize> 53AllocaInst::getAllocationSizeInBits(const DataLayout &DL) const { 54 TypeSize Size = DL.getTypeAllocSizeInBits(getAllocatedType()); 55 if (isArrayAllocation()) { 56 auto *C = dyn_cast<ConstantInt>(getArraySize()); 57 if (!C) 58 return None; 59 assert(!Size.isScalable() && "Array elements cannot have a scalable size"); 60 Size *= C->getZExtValue(); 61 } 62 return Size; 63} 64 65//===----------------------------------------------------------------------===// 66// SelectInst Class 67//===----------------------------------------------------------------------===// 68 69/// areInvalidOperands - Return a string if the specified operands are invalid 70/// for a select operation, otherwise return null. 71const char *SelectInst::areInvalidOperands(Value *Op0, Value *Op1, Value *Op2) { 72 if (Op1->getType() != Op2->getType()) 73 return "both values to select must have same type"; 74 75 if (Op1->getType()->isTokenTy()) 76 return "select values cannot have token type"; 77 78 if (VectorType *VT = dyn_cast<VectorType>(Op0->getType())) { 79 // Vector select. 80 if (VT->getElementType() != Type::getInt1Ty(Op0->getContext())) 81 return "vector select condition element type must be i1"; 82 VectorType *ET = dyn_cast<VectorType>(Op1->getType()); 83 if (!ET) 84 return "selected values for vector select must be vectors"; 85 if (ET->getElementCount() != VT->getElementCount()) 86 return "vector select requires selected vectors to have " 87 "the same vector length as select condition"; 88 } else if (Op0->getType() != Type::getInt1Ty(Op0->getContext())) { 89 return "select condition must be i1 or <n x i1>"; 90 } 91 return nullptr; 92} 93 94//===----------------------------------------------------------------------===// 95// PHINode Class 96//===----------------------------------------------------------------------===// 97 98PHINode::PHINode(const PHINode &PN) 99 : Instruction(PN.getType(), Instruction::PHI, nullptr, PN.getNumOperands()), 100 ReservedSpace(PN.getNumOperands()) { 101 allocHungoffUses(PN.getNumOperands()); 102 std::copy(PN.op_begin(), PN.op_end(), op_begin()); 103 std::copy(PN.block_begin(), PN.block_end(), block_begin()); 104 SubclassOptionalData = PN.SubclassOptionalData; 105} 106 107// removeIncomingValue - Remove an incoming value. This is useful if a 108// predecessor basic block is deleted. 109Value *PHINode::removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty) { 110 Value *Removed = getIncomingValue(Idx); 111 112 // Move everything after this operand down. 113 // 114 // FIXME: we could just swap with the end of the list, then erase. However, 115 // clients might not expect this to happen. The code as it is thrashes the 116 // use/def lists, which is kinda lame. 117 std::copy(op_begin() + Idx + 1, op_end(), op_begin() + Idx); 118 std::copy(block_begin() + Idx + 1, block_end(), block_begin() + Idx); 119 120 // Nuke the last value. 121 Op<-1>().set(nullptr); 122 setNumHungOffUseOperands(getNumOperands() - 1); 123 124 // If the PHI node is dead, because it has zero entries, nuke it now. 125 if (getNumOperands() == 0 && DeletePHIIfEmpty) { 126 // If anyone is using this PHI, make them use a dummy value instead... 127 replaceAllUsesWith(UndefValue::get(getType())); 128 eraseFromParent(); 129 } 130 return Removed; 131} 132 133/// growOperands - grow operands - This grows the operand list in response 134/// to a push_back style of operation. This grows the number of ops by 1.5 135/// times. 136/// 137void PHINode::growOperands() { 138 unsigned e = getNumOperands(); 139 unsigned NumOps = e + e / 2; 140 if (NumOps < 2) NumOps = 2; // 2 op PHI nodes are VERY common. 141 142 ReservedSpace = NumOps; 143 growHungoffUses(ReservedSpace, /* IsPhi */ true); 144} 145 146/// hasConstantValue - If the specified PHI node always merges together the same 147/// value, return the value, otherwise return null. 148Value *PHINode::hasConstantValue() const { 149 // Exploit the fact that phi nodes always have at least one entry. 150 Value *ConstantValue = getIncomingValue(0); 151 for (unsigned i = 1, e = getNumIncomingValues(); i != e; ++i) 152 if (getIncomingValue(i) != ConstantValue && getIncomingValue(i) != this) { 153 if (ConstantValue != this) 154 return nullptr; // Incoming values not all the same. 155 // The case where the first value is this PHI. 156 ConstantValue = getIncomingValue(i); 157 } 158 if (ConstantValue == this) 159 return UndefValue::get(getType()); 160 return ConstantValue; 161} 162 163/// hasConstantOrUndefValue - Whether the specified PHI node always merges 164/// together the same value, assuming that undefs result in the same value as 165/// non-undefs. 166/// Unlike \ref hasConstantValue, this does not return a value because the 167/// unique non-undef incoming value need not dominate the PHI node. 168bool PHINode::hasConstantOrUndefValue() const { 169 Value *ConstantValue = nullptr; 170 for (unsigned i = 0, e = getNumIncomingValues(); i != e; ++i) { 171 Value *Incoming = getIncomingValue(i); 172 if (Incoming != this && !isa<UndefValue>(Incoming)) { 173 if (ConstantValue && ConstantValue != Incoming) 174 return false; 175 ConstantValue = Incoming; 176 } 177 } 178 return true; 179} 180 181//===----------------------------------------------------------------------===// 182// LandingPadInst Implementation 183//===----------------------------------------------------------------------===// 184 185LandingPadInst::LandingPadInst(Type *RetTy, unsigned NumReservedValues, 186 const Twine &NameStr, Instruction *InsertBefore) 187 : Instruction(RetTy, Instruction::LandingPad, nullptr, 0, InsertBefore) { 188 init(NumReservedValues, NameStr); 189} 190 191LandingPadInst::LandingPadInst(Type *RetTy, unsigned NumReservedValues, 192 const Twine &NameStr, BasicBlock *InsertAtEnd) 193 : Instruction(RetTy, Instruction::LandingPad, nullptr, 0, InsertAtEnd) { 194 init(NumReservedValues, NameStr); 195} 196 197LandingPadInst::LandingPadInst(const LandingPadInst &LP) 198 : Instruction(LP.getType(), Instruction::LandingPad, nullptr, 199 LP.getNumOperands()), 200 ReservedSpace(LP.getNumOperands()) { 201 allocHungoffUses(LP.getNumOperands()); 202 Use *OL = getOperandList(); 203 const Use *InOL = LP.getOperandList(); 204 for (unsigned I = 0, E = ReservedSpace; I != E; ++I) 205 OL[I] = InOL[I]; 206 207 setCleanup(LP.isCleanup()); 208} 209 210LandingPadInst *LandingPadInst::Create(Type *RetTy, unsigned NumReservedClauses, 211 const Twine &NameStr, 212 Instruction *InsertBefore) { 213 return new LandingPadInst(RetTy, NumReservedClauses, NameStr, InsertBefore); 214} 215 216LandingPadInst *LandingPadInst::Create(Type *RetTy, unsigned NumReservedClauses, 217 const Twine &NameStr, 218 BasicBlock *InsertAtEnd) { 219 return new LandingPadInst(RetTy, NumReservedClauses, NameStr, InsertAtEnd); 220} 221 222void LandingPadInst::init(unsigned NumReservedValues, const Twine &NameStr) { 223 ReservedSpace = NumReservedValues; 224 setNumHungOffUseOperands(0); 225 allocHungoffUses(ReservedSpace); 226 setName(NameStr); 227 setCleanup(false); 228} 229 230/// growOperands - grow operands - This grows the operand list in response to a 231/// push_back style of operation. This grows the number of ops by 2 times. 232void LandingPadInst::growOperands(unsigned Size) { 233 unsigned e = getNumOperands(); 234 if (ReservedSpace >= e + Size) return; 235 ReservedSpace = (std::max(e, 1U) + Size / 2) * 2; 236 growHungoffUses(ReservedSpace); 237} 238 239void LandingPadInst::addClause(Constant *Val) { 240 unsigned OpNo = getNumOperands(); 241 growOperands(1); 242 assert(OpNo < ReservedSpace && "Growing didn't work!"); 243 setNumHungOffUseOperands(getNumOperands() + 1); 244 getOperandList()[OpNo] = Val; 245} 246 247//===----------------------------------------------------------------------===// 248// CallBase Implementation 249//===----------------------------------------------------------------------===// 250 251CallBase *CallBase::Create(CallBase *CB, ArrayRef<OperandBundleDef> Bundles, 252 Instruction *InsertPt) { 253 switch (CB->getOpcode()) { 254 case Instruction::Call: 255 return CallInst::Create(cast<CallInst>(CB), Bundles, InsertPt); 256 case Instruction::Invoke: 257 return InvokeInst::Create(cast<InvokeInst>(CB), Bundles, InsertPt); 258 case Instruction::CallBr: 259 return CallBrInst::Create(cast<CallBrInst>(CB), Bundles, InsertPt); 260 default: 261 llvm_unreachable("Unknown CallBase sub-class!"); 262 } 263} 264 265CallBase *CallBase::Create(CallBase *CI, OperandBundleDef OpB, 266 Instruction *InsertPt) { 267 SmallVector<OperandBundleDef, 2> OpDefs; 268 for (unsigned i = 0, e = CI->getNumOperandBundles(); i < e; ++i) { 269 auto ChildOB = CI->getOperandBundleAt(i); 270 if (ChildOB.getTagName() != OpB.getTag()) 271 OpDefs.emplace_back(ChildOB); 272 } 273 OpDefs.emplace_back(OpB); 274 return CallBase::Create(CI, OpDefs, InsertPt); 275} 276 277 278Function *CallBase::getCaller() { return getParent()->getParent(); } 279 280unsigned CallBase::getNumSubclassExtraOperandsDynamic() const { 281 assert(getOpcode() == Instruction::CallBr && "Unexpected opcode!"); 282 return cast<CallBrInst>(this)->getNumIndirectDests() + 1; 283} 284 285bool CallBase::isIndirectCall() const { 286 const Value *V = getCalledOperand(); 287 if (isa<Function>(V) || isa<Constant>(V)) 288 return false; 289 return !isInlineAsm(); 290} 291 292/// Tests if this call site must be tail call optimized. Only a CallInst can 293/// be tail call optimized. 294bool CallBase::isMustTailCall() const { 295 if (auto *CI = dyn_cast<CallInst>(this)) 296 return CI->isMustTailCall(); 297 return false; 298} 299 300/// Tests if this call site is marked as a tail call. 301bool CallBase::isTailCall() const { 302 if (auto *CI = dyn_cast<CallInst>(this)) 303 return CI->isTailCall(); 304 return false; 305} 306 307Intrinsic::ID CallBase::getIntrinsicID() const { 308 if (auto *F = getCalledFunction()) 309 return F->getIntrinsicID(); 310 return Intrinsic::not_intrinsic; 311} 312 313bool CallBase::isReturnNonNull() const { 314 if (hasRetAttr(Attribute::NonNull)) 315 return true; 316 317 if (getDereferenceableBytes(AttributeList::ReturnIndex) > 0 && 318 !NullPointerIsDefined(getCaller(), 319 getType()->getPointerAddressSpace())) 320 return true; 321 322 return false; 323} 324 325Value *CallBase::getReturnedArgOperand() const { 326 unsigned Index; 327 328 if (Attrs.hasAttrSomewhere(Attribute::Returned, &Index) && Index) 329 return getArgOperand(Index - AttributeList::FirstArgIndex); 330 if (const Function *F = getCalledFunction()) 331 if (F->getAttributes().hasAttrSomewhere(Attribute::Returned, &Index) && 332 Index) 333 return getArgOperand(Index - AttributeList::FirstArgIndex); 334 335 return nullptr; 336} 337 338/// Determine whether the argument or parameter has the given attribute. 339bool CallBase::paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const { 340 assert(ArgNo < getNumArgOperands() && "Param index out of bounds!"); 341 342 if (Attrs.hasParamAttribute(ArgNo, Kind)) 343 return true; 344 if (const Function *F = getCalledFunction()) 345 return F->getAttributes().hasParamAttribute(ArgNo, Kind); 346 return false; 347} 348 349bool CallBase::hasFnAttrOnCalledFunction(Attribute::AttrKind Kind) const { 350 if (const Function *F = getCalledFunction()) 351 return F->getAttributes().hasFnAttribute(Kind); 352 return false; 353} 354 355bool CallBase::hasFnAttrOnCalledFunction(StringRef Kind) const { 356 if (const Function *F = getCalledFunction()) 357 return F->getAttributes().hasFnAttribute(Kind); 358 return false; 359} 360 361void CallBase::getOperandBundlesAsDefs( 362 SmallVectorImpl<OperandBundleDef> &Defs) const { 363 for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) 364 Defs.emplace_back(getOperandBundleAt(i)); 365} 366 367CallBase::op_iterator 368CallBase::populateBundleOperandInfos(ArrayRef<OperandBundleDef> Bundles, 369 const unsigned BeginIndex) { 370 auto It = op_begin() + BeginIndex; 371 for (auto &B : Bundles) 372 It = std::copy(B.input_begin(), B.input_end(), It); 373 374 auto *ContextImpl = getContext().pImpl; 375 auto BI = Bundles.begin(); 376 unsigned CurrentIndex = BeginIndex; 377 378 for (auto &BOI : bundle_op_infos()) { 379 assert(BI != Bundles.end() && "Incorrect allocation?"); 380 381 BOI.Tag = ContextImpl->getOrInsertBundleTag(BI->getTag()); 382 BOI.Begin = CurrentIndex; 383 BOI.End = CurrentIndex + BI->input_size(); 384 CurrentIndex = BOI.End; 385 BI++; 386 } 387 388 assert(BI == Bundles.end() && "Incorrect allocation?"); 389 390 return It; 391} 392 393CallBase::BundleOpInfo &CallBase::getBundleOpInfoForOperand(unsigned OpIdx) { 394 /// When there isn't many bundles, we do a simple linear search. 395 /// Else fallback to a binary-search that use the fact that bundles usually 396 /// have similar number of argument to get faster convergence. 397 if (bundle_op_info_end() - bundle_op_info_begin() < 8) { 398 for (auto &BOI : bundle_op_infos()) 399 if (BOI.Begin <= OpIdx && OpIdx < BOI.End) 400 return BOI; 401 402 llvm_unreachable("Did not find operand bundle for operand!"); 403 } 404 405 assert(OpIdx >= arg_size() && "the Idx is not in the operand bundles"); 406 assert(bundle_op_info_end() - bundle_op_info_begin() > 0 && 407 OpIdx < std::prev(bundle_op_info_end())->End && 408 "The Idx isn't in the operand bundle"); 409 410 /// We need a decimal number below and to prevent using floating point numbers 411 /// we use an intergal value multiplied by this constant. 412 constexpr unsigned NumberScaling = 1024; 413 414 bundle_op_iterator Begin = bundle_op_info_begin(); 415 bundle_op_iterator End = bundle_op_info_end(); 416 bundle_op_iterator Current = Begin; 417 418 while (Begin != End) { 419 unsigned ScaledOperandPerBundle = 420 NumberScaling * (std::prev(End)->End - Begin->Begin) / (End - Begin); 421 Current = Begin + (((OpIdx - Begin->Begin) * NumberScaling) / 422 ScaledOperandPerBundle); 423 if (Current >= End) 424 Current = std::prev(End); 425 assert(Current < End && Current >= Begin && 426 "the operand bundle doesn't cover every value in the range"); 427 if (OpIdx >= Current->Begin && OpIdx < Current->End) 428 break; 429 if (OpIdx >= Current->End) 430 Begin = Current + 1; 431 else 432 End = Current; 433 } 434 435 assert(OpIdx >= Current->Begin && OpIdx < Current->End && 436 "the operand bundle doesn't cover every value in the range"); 437 return *Current; 438} 439 440CallBase *CallBase::addOperandBundle(CallBase *CB, uint32_t ID, 441 OperandBundleDef OB, 442 Instruction *InsertPt) { 443 if (CB->getOperandBundle(ID)) 444 return CB; 445 446 SmallVector<OperandBundleDef, 1> Bundles; 447 CB->getOperandBundlesAsDefs(Bundles); 448 Bundles.push_back(OB); 449 return Create(CB, Bundles, InsertPt); 450} 451 452CallBase *CallBase::removeOperandBundle(CallBase *CB, uint32_t ID, 453 Instruction *InsertPt) { 454 SmallVector<OperandBundleDef, 1> Bundles; 455 bool CreateNew = false; 456 457 for (unsigned I = 0, E = CB->getNumOperandBundles(); I != E; ++I) { 458 auto Bundle = CB->getOperandBundleAt(I); 459 if (Bundle.getTagID() == ID) { 460 CreateNew = true; 461 continue; 462 } 463 Bundles.emplace_back(Bundle); 464 } 465 466 return CreateNew ? Create(CB, Bundles, InsertPt) : CB; 467} 468 469bool CallBase::hasReadingOperandBundles() const { 470 // Implementation note: this is a conservative implementation of operand 471 // bundle semantics, where *any* non-assume operand bundle forces a callsite 472 // to be at least readonly. 473 return hasOperandBundles() && getIntrinsicID() != Intrinsic::assume; 474} 475 476//===----------------------------------------------------------------------===// 477// CallInst Implementation 478//===----------------------------------------------------------------------===// 479 480void CallInst::init(FunctionType *FTy, Value *Func, ArrayRef<Value *> Args, 481 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr) { 482 this->FTy = FTy; 483 assert(getNumOperands() == Args.size() + CountBundleInputs(Bundles) + 1 && 484 "NumOperands not set up?"); 485 setCalledOperand(Func); 486 487#ifndef NDEBUG 488 assert((Args.size() == FTy->getNumParams() || 489 (FTy->isVarArg() && Args.size() > FTy->getNumParams())) && 490 "Calling a function with bad signature!"); 491 492 for (unsigned i = 0; i != Args.size(); ++i) 493 assert((i >= FTy->getNumParams() || 494 FTy->getParamType(i) == Args[i]->getType()) && 495 "Calling a function with a bad signature!"); 496#endif 497 498 llvm::copy(Args, op_begin()); 499 500 auto It = populateBundleOperandInfos(Bundles, Args.size()); 501 (void)It; 502 assert(It + 1 == op_end() && "Should add up!"); 503 504 setName(NameStr); 505} 506 507void CallInst::init(FunctionType *FTy, Value *Func, const Twine &NameStr) { 508 this->FTy = FTy; 509 assert(getNumOperands() == 1 && "NumOperands not set up?"); 510 setCalledOperand(Func); 511 512 assert(FTy->getNumParams() == 0 && "Calling a function with bad signature"); 513 514 setName(NameStr); 515} 516 517CallInst::CallInst(FunctionType *Ty, Value *Func, const Twine &Name, 518 Instruction *InsertBefore) 519 : CallBase(Ty->getReturnType(), Instruction::Call, 520 OperandTraits<CallBase>::op_end(this) - 1, 1, InsertBefore) { 521 init(Ty, Func, Name); 522} 523 524CallInst::CallInst(FunctionType *Ty, Value *Func, const Twine &Name, 525 BasicBlock *InsertAtEnd) 526 : CallBase(Ty->getReturnType(), Instruction::Call, 527 OperandTraits<CallBase>::op_end(this) - 1, 1, InsertAtEnd) { 528 init(Ty, Func, Name); 529} 530 531CallInst::CallInst(const CallInst &CI) 532 : CallBase(CI.Attrs, CI.FTy, CI.getType(), Instruction::Call, 533 OperandTraits<CallBase>::op_end(this) - CI.getNumOperands(), 534 CI.getNumOperands()) { 535 setTailCallKind(CI.getTailCallKind()); 536 setCallingConv(CI.getCallingConv()); 537 538 std::copy(CI.op_begin(), CI.op_end(), op_begin()); 539 std::copy(CI.bundle_op_info_begin(), CI.bundle_op_info_end(), 540 bundle_op_info_begin()); 541 SubclassOptionalData = CI.SubclassOptionalData; 542} 543 544CallInst *CallInst::Create(CallInst *CI, ArrayRef<OperandBundleDef> OpB, 545 Instruction *InsertPt) { 546 std::vector<Value *> Args(CI->arg_begin(), CI->arg_end()); 547 548 auto *NewCI = CallInst::Create(CI->getFunctionType(), CI->getCalledOperand(), 549 Args, OpB, CI->getName(), InsertPt); 550 NewCI->setTailCallKind(CI->getTailCallKind()); 551 NewCI->setCallingConv(CI->getCallingConv()); 552 NewCI->SubclassOptionalData = CI->SubclassOptionalData; 553 NewCI->setAttributes(CI->getAttributes()); 554 NewCI->setDebugLoc(CI->getDebugLoc()); 555 return NewCI; 556} 557 558// Update profile weight for call instruction by scaling it using the ratio 559// of S/T. The meaning of "branch_weights" meta data for call instruction is 560// transfered to represent call count. 561void CallInst::updateProfWeight(uint64_t S, uint64_t T) { 562 auto *ProfileData = getMetadata(LLVMContext::MD_prof); 563 if (ProfileData == nullptr) 564 return; 565 566 auto *ProfDataName = dyn_cast<MDString>(ProfileData->getOperand(0)); 567 if (!ProfDataName || (!ProfDataName->getString().equals("branch_weights") && 568 !ProfDataName->getString().equals("VP"))) 569 return; 570 571 if (T == 0) { 572 LLVM_DEBUG(dbgs() << "Attempting to update profile weights will result in " 573 "div by 0. Ignoring. Likely the function " 574 << getParent()->getParent()->getName() 575 << " has 0 entry count, and contains call instructions " 576 "with non-zero prof info."); 577 return; 578 } 579 580 MDBuilder MDB(getContext()); 581 SmallVector<Metadata *, 3> Vals; 582 Vals.push_back(ProfileData->getOperand(0)); 583 APInt APS(128, S), APT(128, T); 584 if (ProfDataName->getString().equals("branch_weights") && 585 ProfileData->getNumOperands() > 0) { 586 // Using APInt::div may be expensive, but most cases should fit 64 bits. 587 APInt Val(128, mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(1)) 588 ->getValue() 589 .getZExtValue()); 590 Val *= APS; 591 Vals.push_back(MDB.createConstant( 592 ConstantInt::get(Type::getInt32Ty(getContext()), 593 Val.udiv(APT).getLimitedValue(UINT32_MAX)))); 594 } else if (ProfDataName->getString().equals("VP")) 595 for (unsigned i = 1; i < ProfileData->getNumOperands(); i += 2) { 596 // The first value is the key of the value profile, which will not change. 597 Vals.push_back(ProfileData->getOperand(i)); 598 uint64_t Count = 599 mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(i + 1)) 600 ->getValue() 601 .getZExtValue(); 602 // Don't scale the magic number. 603 if (Count == NOMORE_ICP_MAGICNUM) { 604 Vals.push_back(ProfileData->getOperand(i + 1)); 605 continue; 606 } 607 // Using APInt::div may be expensive, but most cases should fit 64 bits. 608 APInt Val(128, Count); 609 Val *= APS; 610 Vals.push_back(MDB.createConstant( 611 ConstantInt::get(Type::getInt64Ty(getContext()), 612 Val.udiv(APT).getLimitedValue()))); 613 } 614 setMetadata(LLVMContext::MD_prof, MDNode::get(getContext(), Vals)); 615} 616 617/// IsConstantOne - Return true only if val is constant int 1 618static bool IsConstantOne(Value *val) { 619 assert(val && "IsConstantOne does not work with nullptr val"); 620 const ConstantInt *CVal = dyn_cast<ConstantInt>(val); 621 return CVal && CVal->isOne(); 622} 623 624static Instruction *createMalloc(Instruction *InsertBefore, 625 BasicBlock *InsertAtEnd, Type *IntPtrTy, 626 Type *AllocTy, Value *AllocSize, 627 Value *ArraySize, 628 ArrayRef<OperandBundleDef> OpB, 629 Function *MallocF, const Twine &Name) { 630 assert(((!InsertBefore && InsertAtEnd) || (InsertBefore && !InsertAtEnd)) && 631 "createMalloc needs either InsertBefore or InsertAtEnd"); 632 633 // malloc(type) becomes: 634 // bitcast (i8* malloc(typeSize)) to type* 635 // malloc(type, arraySize) becomes: 636 // bitcast (i8* malloc(typeSize*arraySize)) to type* 637 if (!ArraySize) 638 ArraySize = ConstantInt::get(IntPtrTy, 1); 639 else if (ArraySize->getType() != IntPtrTy) { 640 if (InsertBefore) 641 ArraySize = CastInst::CreateIntegerCast(ArraySize, IntPtrTy, false, 642 "", InsertBefore); 643 else 644 ArraySize = CastInst::CreateIntegerCast(ArraySize, IntPtrTy, false, 645 "", InsertAtEnd); 646 } 647 648 if (!IsConstantOne(ArraySize)) { 649 if (IsConstantOne(AllocSize)) { 650 AllocSize = ArraySize; // Operand * 1 = Operand 651 } else if (Constant *CO = dyn_cast<Constant>(ArraySize)) { 652 Constant *Scale = ConstantExpr::getIntegerCast(CO, IntPtrTy, 653 false /*ZExt*/); 654 // Malloc arg is constant product of type size and array size 655 AllocSize = ConstantExpr::getMul(Scale, cast<Constant>(AllocSize)); 656 } else { 657 // Multiply type size by the array size... 658 if (InsertBefore) 659 AllocSize = BinaryOperator::CreateMul(ArraySize, AllocSize, 660 "mallocsize", InsertBefore); 661 else 662 AllocSize = BinaryOperator::CreateMul(ArraySize, AllocSize, 663 "mallocsize", InsertAtEnd); 664 } 665 } 666 667 assert(AllocSize->getType() == IntPtrTy && "malloc arg is wrong size"); 668 // Create the call to Malloc. 669 BasicBlock *BB = InsertBefore ? InsertBefore->getParent() : InsertAtEnd; 670 Module *M = BB->getParent()->getParent(); 671 Type *BPTy = Type::getInt8PtrTy(BB->getContext()); 672 FunctionCallee MallocFunc = MallocF; 673 if (!MallocFunc) 674 // prototype malloc as "void *malloc(size_t)" 675 MallocFunc = M->getOrInsertFunction("malloc", BPTy, IntPtrTy); 676 PointerType *AllocPtrType = PointerType::getUnqual(AllocTy); 677 CallInst *MCall = nullptr; 678 Instruction *Result = nullptr; 679 if (InsertBefore) { 680 MCall = CallInst::Create(MallocFunc, AllocSize, OpB, "malloccall", 681 InsertBefore); 682 Result = MCall; 683 if (Result->getType() != AllocPtrType) 684 // Create a cast instruction to convert to the right type... 685 Result = new BitCastInst(MCall, AllocPtrType, Name, InsertBefore); 686 } else { 687 MCall = CallInst::Create(MallocFunc, AllocSize, OpB, "malloccall"); 688 Result = MCall; 689 if (Result->getType() != AllocPtrType) { 690 InsertAtEnd->getInstList().push_back(MCall); 691 // Create a cast instruction to convert to the right type... 692 Result = new BitCastInst(MCall, AllocPtrType, Name); 693 } 694 } 695 MCall->setTailCall(); 696 if (Function *F = dyn_cast<Function>(MallocFunc.getCallee())) { 697 MCall->setCallingConv(F->getCallingConv()); 698 if (!F->returnDoesNotAlias()) 699 F->setReturnDoesNotAlias(); 700 } 701 assert(!MCall->getType()->isVoidTy() && "Malloc has void return type"); 702 703 return Result; 704} 705 706/// CreateMalloc - Generate the IR for a call to malloc: 707/// 1. Compute the malloc call's argument as the specified type's size, 708/// possibly multiplied by the array size if the array size is not 709/// constant 1. 710/// 2. Call malloc with that argument. 711/// 3. Bitcast the result of the malloc call to the specified type. 712Instruction *CallInst::CreateMalloc(Instruction *InsertBefore, 713 Type *IntPtrTy, Type *AllocTy, 714 Value *AllocSize, Value *ArraySize, 715 Function *MallocF, 716 const Twine &Name) { 717 return createMalloc(InsertBefore, nullptr, IntPtrTy, AllocTy, AllocSize, 718 ArraySize, None, MallocF, Name); 719} 720Instruction *CallInst::CreateMalloc(Instruction *InsertBefore, 721 Type *IntPtrTy, Type *AllocTy, 722 Value *AllocSize, Value *ArraySize, 723 ArrayRef<OperandBundleDef> OpB, 724 Function *MallocF, 725 const Twine &Name) { 726 return createMalloc(InsertBefore, nullptr, IntPtrTy, AllocTy, AllocSize, 727 ArraySize, OpB, MallocF, Name); 728} 729 730/// CreateMalloc - Generate the IR for a call to malloc: 731/// 1. Compute the malloc call's argument as the specified type's size, 732/// possibly multiplied by the array size if the array size is not 733/// constant 1. 734/// 2. Call malloc with that argument. 735/// 3. Bitcast the result of the malloc call to the specified type. 736/// Note: This function does not add the bitcast to the basic block, that is the 737/// responsibility of the caller. 738Instruction *CallInst::CreateMalloc(BasicBlock *InsertAtEnd, 739 Type *IntPtrTy, Type *AllocTy, 740 Value *AllocSize, Value *ArraySize, 741 Function *MallocF, const Twine &Name) { 742 return createMalloc(nullptr, InsertAtEnd, IntPtrTy, AllocTy, AllocSize, 743 ArraySize, None, MallocF, Name); 744} 745Instruction *CallInst::CreateMalloc(BasicBlock *InsertAtEnd, 746 Type *IntPtrTy, Type *AllocTy, 747 Value *AllocSize, Value *ArraySize, 748 ArrayRef<OperandBundleDef> OpB, 749 Function *MallocF, const Twine &Name) { 750 return createMalloc(nullptr, InsertAtEnd, IntPtrTy, AllocTy, AllocSize, 751 ArraySize, OpB, MallocF, Name); 752} 753 754static Instruction *createFree(Value *Source, 755 ArrayRef<OperandBundleDef> Bundles, 756 Instruction *InsertBefore, 757 BasicBlock *InsertAtEnd) { 758 assert(((!InsertBefore && InsertAtEnd) || (InsertBefore && !InsertAtEnd)) && 759 "createFree needs either InsertBefore or InsertAtEnd"); 760 assert(Source->getType()->isPointerTy() && 761 "Can not free something of nonpointer type!"); 762 763 BasicBlock *BB = InsertBefore ? InsertBefore->getParent() : InsertAtEnd; 764 Module *M = BB->getParent()->getParent(); 765 766 Type *VoidTy = Type::getVoidTy(M->getContext()); 767 Type *IntPtrTy = Type::getInt8PtrTy(M->getContext()); 768 // prototype free as "void free(void*)" 769 FunctionCallee FreeFunc = M->getOrInsertFunction("free", VoidTy, IntPtrTy); 770 CallInst *Result = nullptr; 771 Value *PtrCast = Source; 772 if (InsertBefore) { 773 if (Source->getType() != IntPtrTy) 774 PtrCast = new BitCastInst(Source, IntPtrTy, "", InsertBefore); 775 Result = CallInst::Create(FreeFunc, PtrCast, Bundles, "", InsertBefore); 776 } else { 777 if (Source->getType() != IntPtrTy) 778 PtrCast = new BitCastInst(Source, IntPtrTy, "", InsertAtEnd); 779 Result = CallInst::Create(FreeFunc, PtrCast, Bundles, ""); 780 } 781 Result->setTailCall(); 782 if (Function *F = dyn_cast<Function>(FreeFunc.getCallee())) 783 Result->setCallingConv(F->getCallingConv()); 784 785 return Result; 786} 787 788/// CreateFree - Generate the IR for a call to the builtin free function. 789Instruction *CallInst::CreateFree(Value *Source, Instruction *InsertBefore) { 790 return createFree(Source, None, InsertBefore, nullptr); 791} 792Instruction *CallInst::CreateFree(Value *Source, 793 ArrayRef<OperandBundleDef> Bundles, 794 Instruction *InsertBefore) { 795 return createFree(Source, Bundles, InsertBefore, nullptr); 796} 797 798/// CreateFree - Generate the IR for a call to the builtin free function. 799/// Note: This function does not add the call to the basic block, that is the 800/// responsibility of the caller. 801Instruction *CallInst::CreateFree(Value *Source, BasicBlock *InsertAtEnd) { 802 Instruction *FreeCall = createFree(Source, None, nullptr, InsertAtEnd); 803 assert(FreeCall && "CreateFree did not create a CallInst"); 804 return FreeCall; 805} 806Instruction *CallInst::CreateFree(Value *Source, 807 ArrayRef<OperandBundleDef> Bundles, 808 BasicBlock *InsertAtEnd) { 809 Instruction *FreeCall = createFree(Source, Bundles, nullptr, InsertAtEnd); 810 assert(FreeCall && "CreateFree did not create a CallInst"); 811 return FreeCall; 812} 813 814//===----------------------------------------------------------------------===// 815// InvokeInst Implementation 816//===----------------------------------------------------------------------===// 817 818void InvokeInst::init(FunctionType *FTy, Value *Fn, BasicBlock *IfNormal, 819 BasicBlock *IfException, ArrayRef<Value *> Args, 820 ArrayRef<OperandBundleDef> Bundles, 821 const Twine &NameStr) { 822 this->FTy = FTy; 823 824 assert((int)getNumOperands() == 825 ComputeNumOperands(Args.size(), CountBundleInputs(Bundles)) && 826 "NumOperands not set up?"); 827 setNormalDest(IfNormal); 828 setUnwindDest(IfException); 829 setCalledOperand(Fn); 830 831#ifndef NDEBUG 832 assert(((Args.size() == FTy->getNumParams()) || 833 (FTy->isVarArg() && Args.size() > FTy->getNumParams())) && 834 "Invoking a function with bad signature"); 835 836 for (unsigned i = 0, e = Args.size(); i != e; i++) 837 assert((i >= FTy->getNumParams() || 838 FTy->getParamType(i) == Args[i]->getType()) && 839 "Invoking a function with a bad signature!"); 840#endif 841 842 llvm::copy(Args, op_begin()); 843 844 auto It = populateBundleOperandInfos(Bundles, Args.size()); 845 (void)It; 846 assert(It + 3 == op_end() && "Should add up!"); 847 848 setName(NameStr); 849} 850 851InvokeInst::InvokeInst(const InvokeInst &II) 852 : CallBase(II.Attrs, II.FTy, II.getType(), Instruction::Invoke, 853 OperandTraits<CallBase>::op_end(this) - II.getNumOperands(), 854 II.getNumOperands()) { 855 setCallingConv(II.getCallingConv()); 856 std::copy(II.op_begin(), II.op_end(), op_begin()); 857 std::copy(II.bundle_op_info_begin(), II.bundle_op_info_end(), 858 bundle_op_info_begin()); 859 SubclassOptionalData = II.SubclassOptionalData; 860} 861 862InvokeInst *InvokeInst::Create(InvokeInst *II, ArrayRef<OperandBundleDef> OpB, 863 Instruction *InsertPt) { 864 std::vector<Value *> Args(II->arg_begin(), II->arg_end()); 865 866 auto *NewII = InvokeInst::Create( 867 II->getFunctionType(), II->getCalledOperand(), II->getNormalDest(), 868 II->getUnwindDest(), Args, OpB, II->getName(), InsertPt); 869 NewII->setCallingConv(II->getCallingConv()); 870 NewII->SubclassOptionalData = II->SubclassOptionalData; 871 NewII->setAttributes(II->getAttributes()); 872 NewII->setDebugLoc(II->getDebugLoc()); 873 return NewII; 874} 875 876LandingPadInst *InvokeInst::getLandingPadInst() const { 877 return cast<LandingPadInst>(getUnwindDest()->getFirstNonPHI()); 878} 879 880//===----------------------------------------------------------------------===// 881// CallBrInst Implementation 882//===----------------------------------------------------------------------===// 883 884void CallBrInst::init(FunctionType *FTy, Value *Fn, BasicBlock *Fallthrough, 885 ArrayRef<BasicBlock *> IndirectDests, 886 ArrayRef<Value *> Args, 887 ArrayRef<OperandBundleDef> Bundles, 888 const Twine &NameStr) { 889 this->FTy = FTy; 890 891 assert((int)getNumOperands() == 892 ComputeNumOperands(Args.size(), IndirectDests.size(), 893 CountBundleInputs(Bundles)) && 894 "NumOperands not set up?"); 895 NumIndirectDests = IndirectDests.size(); 896 setDefaultDest(Fallthrough); 897 for (unsigned i = 0; i != NumIndirectDests; ++i) 898 setIndirectDest(i, IndirectDests[i]); 899 setCalledOperand(Fn); 900 901#ifndef NDEBUG 902 assert(((Args.size() == FTy->getNumParams()) || 903 (FTy->isVarArg() && Args.size() > FTy->getNumParams())) && 904 "Calling a function with bad signature"); 905 906 for (unsigned i = 0, e = Args.size(); i != e; i++) 907 assert((i >= FTy->getNumParams() || 908 FTy->getParamType(i) == Args[i]->getType()) && 909 "Calling a function with a bad signature!"); 910#endif 911 912 std::copy(Args.begin(), Args.end(), op_begin()); 913 914 auto It = populateBundleOperandInfos(Bundles, Args.size()); 915 (void)It; 916 assert(It + 2 + IndirectDests.size() == op_end() && "Should add up!"); 917 918 setName(NameStr); 919} 920 921void CallBrInst::updateArgBlockAddresses(unsigned i, BasicBlock *B) { 922 assert(getNumIndirectDests() > i && "IndirectDest # out of range for callbr"); 923 if (BasicBlock *OldBB = getIndirectDest(i)) { 924 BlockAddress *Old = BlockAddress::get(OldBB); 925 BlockAddress *New = BlockAddress::get(B); 926 for (unsigned ArgNo = 0, e = getNumArgOperands(); ArgNo != e; ++ArgNo) 927 if (dyn_cast<BlockAddress>(getArgOperand(ArgNo)) == Old) 928 setArgOperand(ArgNo, New); 929 } 930} 931 932CallBrInst::CallBrInst(const CallBrInst &CBI) 933 : CallBase(CBI.Attrs, CBI.FTy, CBI.getType(), Instruction::CallBr, 934 OperandTraits<CallBase>::op_end(this) - CBI.getNumOperands(), 935 CBI.getNumOperands()) { 936 setCallingConv(CBI.getCallingConv()); 937 std::copy(CBI.op_begin(), CBI.op_end(), op_begin()); 938 std::copy(CBI.bundle_op_info_begin(), CBI.bundle_op_info_end(), 939 bundle_op_info_begin()); 940 SubclassOptionalData = CBI.SubclassOptionalData; 941 NumIndirectDests = CBI.NumIndirectDests; 942} 943 944CallBrInst *CallBrInst::Create(CallBrInst *CBI, ArrayRef<OperandBundleDef> OpB, 945 Instruction *InsertPt) { 946 std::vector<Value *> Args(CBI->arg_begin(), CBI->arg_end()); 947 948 auto *NewCBI = CallBrInst::Create( 949 CBI->getFunctionType(), CBI->getCalledOperand(), CBI->getDefaultDest(), 950 CBI->getIndirectDests(), Args, OpB, CBI->getName(), InsertPt); 951 NewCBI->setCallingConv(CBI->getCallingConv()); 952 NewCBI->SubclassOptionalData = CBI->SubclassOptionalData; 953 NewCBI->setAttributes(CBI->getAttributes()); 954 NewCBI->setDebugLoc(CBI->getDebugLoc()); 955 NewCBI->NumIndirectDests = CBI->NumIndirectDests; 956 return NewCBI; 957} 958 959//===----------------------------------------------------------------------===// 960// ReturnInst Implementation 961//===----------------------------------------------------------------------===// 962 963ReturnInst::ReturnInst(const ReturnInst &RI) 964 : Instruction(Type::getVoidTy(RI.getContext()), Instruction::Ret, 965 OperandTraits<ReturnInst>::op_end(this) - RI.getNumOperands(), 966 RI.getNumOperands()) { 967 if (RI.getNumOperands()) 968 Op<0>() = RI.Op<0>(); 969 SubclassOptionalData = RI.SubclassOptionalData; 970} 971 972ReturnInst::ReturnInst(LLVMContext &C, Value *retVal, Instruction *InsertBefore) 973 : Instruction(Type::getVoidTy(C), Instruction::Ret, 974 OperandTraits<ReturnInst>::op_end(this) - !!retVal, !!retVal, 975 InsertBefore) { 976 if (retVal) 977 Op<0>() = retVal; 978} 979 980ReturnInst::ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd) 981 : Instruction(Type::getVoidTy(C), Instruction::Ret, 982 OperandTraits<ReturnInst>::op_end(this) - !!retVal, !!retVal, 983 InsertAtEnd) { 984 if (retVal) 985 Op<0>() = retVal; 986} 987 988ReturnInst::ReturnInst(LLVMContext &Context, BasicBlock *InsertAtEnd) 989 : Instruction(Type::getVoidTy(Context), Instruction::Ret, 990 OperandTraits<ReturnInst>::op_end(this), 0, InsertAtEnd) {} 991 992//===----------------------------------------------------------------------===// 993// ResumeInst Implementation 994//===----------------------------------------------------------------------===// 995 996ResumeInst::ResumeInst(const ResumeInst &RI) 997 : Instruction(Type::getVoidTy(RI.getContext()), Instruction::Resume, 998 OperandTraits<ResumeInst>::op_begin(this), 1) { 999 Op<0>() = RI.Op<0>(); 1000} 1001 1002ResumeInst::ResumeInst(Value *Exn, Instruction *InsertBefore) 1003 : Instruction(Type::getVoidTy(Exn->getContext()), Instruction::Resume, 1004 OperandTraits<ResumeInst>::op_begin(this), 1, InsertBefore) { 1005 Op<0>() = Exn; 1006} 1007 1008ResumeInst::ResumeInst(Value *Exn, BasicBlock *InsertAtEnd) 1009 : Instruction(Type::getVoidTy(Exn->getContext()), Instruction::Resume, 1010 OperandTraits<ResumeInst>::op_begin(this), 1, InsertAtEnd) { 1011 Op<0>() = Exn; 1012} 1013 1014//===----------------------------------------------------------------------===// 1015// CleanupReturnInst Implementation 1016//===----------------------------------------------------------------------===// 1017 1018CleanupReturnInst::CleanupReturnInst(const CleanupReturnInst &CRI) 1019 : Instruction(CRI.getType(), Instruction::CleanupRet, 1020 OperandTraits<CleanupReturnInst>::op_end(this) - 1021 CRI.getNumOperands(), 1022 CRI.getNumOperands()) { 1023 setSubclassData<Instruction::OpaqueField>( 1024 CRI.getSubclassData<Instruction::OpaqueField>()); 1025 Op<0>() = CRI.Op<0>(); 1026 if (CRI.hasUnwindDest()) 1027 Op<1>() = CRI.Op<1>(); 1028} 1029 1030void CleanupReturnInst::init(Value *CleanupPad, BasicBlock *UnwindBB) { 1031 if (UnwindBB) 1032 setSubclassData<UnwindDestField>(true); 1033 1034 Op<0>() = CleanupPad; 1035 if (UnwindBB) 1036 Op<1>() = UnwindBB; 1037} 1038 1039CleanupReturnInst::CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, 1040 unsigned Values, Instruction *InsertBefore) 1041 : Instruction(Type::getVoidTy(CleanupPad->getContext()), 1042 Instruction::CleanupRet, 1043 OperandTraits<CleanupReturnInst>::op_end(this) - Values, 1044 Values, InsertBefore) { 1045 init(CleanupPad, UnwindBB); 1046} 1047 1048CleanupReturnInst::CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, 1049 unsigned Values, BasicBlock *InsertAtEnd) 1050 : Instruction(Type::getVoidTy(CleanupPad->getContext()), 1051 Instruction::CleanupRet, 1052 OperandTraits<CleanupReturnInst>::op_end(this) - Values, 1053 Values, InsertAtEnd) { 1054 init(CleanupPad, UnwindBB); 1055} 1056 1057//===----------------------------------------------------------------------===// 1058// CatchReturnInst Implementation 1059//===----------------------------------------------------------------------===// 1060void CatchReturnInst::init(Value *CatchPad, BasicBlock *BB) { 1061 Op<0>() = CatchPad; 1062 Op<1>() = BB; 1063} 1064 1065CatchReturnInst::CatchReturnInst(const CatchReturnInst &CRI) 1066 : Instruction(Type::getVoidTy(CRI.getContext()), Instruction::CatchRet, 1067 OperandTraits<CatchReturnInst>::op_begin(this), 2) { 1068 Op<0>() = CRI.Op<0>(); 1069 Op<1>() = CRI.Op<1>(); 1070} 1071 1072CatchReturnInst::CatchReturnInst(Value *CatchPad, BasicBlock *BB, 1073 Instruction *InsertBefore) 1074 : Instruction(Type::getVoidTy(BB->getContext()), Instruction::CatchRet, 1075 OperandTraits<CatchReturnInst>::op_begin(this), 2, 1076 InsertBefore) { 1077 init(CatchPad, BB); 1078} 1079 1080CatchReturnInst::CatchReturnInst(Value *CatchPad, BasicBlock *BB, 1081 BasicBlock *InsertAtEnd) 1082 : Instruction(Type::getVoidTy(BB->getContext()), Instruction::CatchRet, 1083 OperandTraits<CatchReturnInst>::op_begin(this), 2, 1084 InsertAtEnd) { 1085 init(CatchPad, BB); 1086} 1087 1088//===----------------------------------------------------------------------===// 1089// CatchSwitchInst Implementation 1090//===----------------------------------------------------------------------===// 1091 1092CatchSwitchInst::CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest, 1093 unsigned NumReservedValues, 1094 const Twine &NameStr, 1095 Instruction *InsertBefore) 1096 : Instruction(ParentPad->getType(), Instruction::CatchSwitch, nullptr, 0, 1097 InsertBefore) { 1098 if (UnwindDest) 1099 ++NumReservedValues; 1100 init(ParentPad, UnwindDest, NumReservedValues + 1); 1101 setName(NameStr); 1102} 1103 1104CatchSwitchInst::CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest, 1105 unsigned NumReservedValues, 1106 const Twine &NameStr, BasicBlock *InsertAtEnd) 1107 : Instruction(ParentPad->getType(), Instruction::CatchSwitch, nullptr, 0, 1108 InsertAtEnd) { 1109 if (UnwindDest) 1110 ++NumReservedValues; 1111 init(ParentPad, UnwindDest, NumReservedValues + 1); 1112 setName(NameStr); 1113} 1114 1115CatchSwitchInst::CatchSwitchInst(const CatchSwitchInst &CSI) 1116 : Instruction(CSI.getType(), Instruction::CatchSwitch, nullptr, 1117 CSI.getNumOperands()) { 1118 init(CSI.getParentPad(), CSI.getUnwindDest(), CSI.getNumOperands()); 1119 setNumHungOffUseOperands(ReservedSpace); 1120 Use *OL = getOperandList(); 1121 const Use *InOL = CSI.getOperandList(); 1122 for (unsigned I = 1, E = ReservedSpace; I != E; ++I) 1123 OL[I] = InOL[I]; 1124} 1125 1126void CatchSwitchInst::init(Value *ParentPad, BasicBlock *UnwindDest, 1127 unsigned NumReservedValues) { 1128 assert(ParentPad && NumReservedValues); 1129 1130 ReservedSpace = NumReservedValues; 1131 setNumHungOffUseOperands(UnwindDest ? 2 : 1); 1132 allocHungoffUses(ReservedSpace); 1133 1134 Op<0>() = ParentPad; 1135 if (UnwindDest) { 1136 setSubclassData<UnwindDestField>(true); 1137 setUnwindDest(UnwindDest); 1138 } 1139} 1140 1141/// growOperands - grow operands - This grows the operand list in response to a 1142/// push_back style of operation. This grows the number of ops by 2 times. 1143void CatchSwitchInst::growOperands(unsigned Size) { 1144 unsigned NumOperands = getNumOperands(); 1145 assert(NumOperands >= 1); 1146 if (ReservedSpace >= NumOperands + Size) 1147 return; 1148 ReservedSpace = (NumOperands + Size / 2) * 2; 1149 growHungoffUses(ReservedSpace); 1150} 1151 1152void CatchSwitchInst::addHandler(BasicBlock *Handler) { 1153 unsigned OpNo = getNumOperands(); 1154 growOperands(1); 1155 assert(OpNo < ReservedSpace && "Growing didn't work!"); 1156 setNumHungOffUseOperands(getNumOperands() + 1); 1157 getOperandList()[OpNo] = Handler; 1158} 1159 1160void CatchSwitchInst::removeHandler(handler_iterator HI) { 1161 // Move all subsequent handlers up one. 1162 Use *EndDst = op_end() - 1; 1163 for (Use *CurDst = HI.getCurrent(); CurDst != EndDst; ++CurDst) 1164 *CurDst = *(CurDst + 1); 1165 // Null out the last handler use. 1166 *EndDst = nullptr; 1167 1168 setNumHungOffUseOperands(getNumOperands() - 1); 1169} 1170 1171//===----------------------------------------------------------------------===// 1172// FuncletPadInst Implementation 1173//===----------------------------------------------------------------------===// 1174void FuncletPadInst::init(Value *ParentPad, ArrayRef<Value *> Args, 1175 const Twine &NameStr) { 1176 assert(getNumOperands() == 1 + Args.size() && "NumOperands not set up?"); 1177 llvm::copy(Args, op_begin()); 1178 setParentPad(ParentPad); 1179 setName(NameStr); 1180} 1181 1182FuncletPadInst::FuncletPadInst(const FuncletPadInst &FPI) 1183 : Instruction(FPI.getType(), FPI.getOpcode(), 1184 OperandTraits<FuncletPadInst>::op_end(this) - 1185 FPI.getNumOperands(), 1186 FPI.getNumOperands()) { 1187 std::copy(FPI.op_begin(), FPI.op_end(), op_begin()); 1188 setParentPad(FPI.getParentPad()); 1189} 1190 1191FuncletPadInst::FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad, 1192 ArrayRef<Value *> Args, unsigned Values, 1193 const Twine &NameStr, Instruction *InsertBefore) 1194 : Instruction(ParentPad->getType(), Op, 1195 OperandTraits<FuncletPadInst>::op_end(this) - Values, Values, 1196 InsertBefore) { 1197 init(ParentPad, Args, NameStr); 1198} 1199 1200FuncletPadInst::FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad, 1201 ArrayRef<Value *> Args, unsigned Values, 1202 const Twine &NameStr, BasicBlock *InsertAtEnd) 1203 : Instruction(ParentPad->getType(), Op, 1204 OperandTraits<FuncletPadInst>::op_end(this) - Values, Values, 1205 InsertAtEnd) { 1206 init(ParentPad, Args, NameStr); 1207} 1208 1209//===----------------------------------------------------------------------===// 1210// UnreachableInst Implementation 1211//===----------------------------------------------------------------------===// 1212 1213UnreachableInst::UnreachableInst(LLVMContext &Context, 1214 Instruction *InsertBefore) 1215 : Instruction(Type::getVoidTy(Context), Instruction::Unreachable, nullptr, 1216 0, InsertBefore) {} 1217UnreachableInst::UnreachableInst(LLVMContext &Context, BasicBlock *InsertAtEnd) 1218 : Instruction(Type::getVoidTy(Context), Instruction::Unreachable, nullptr, 1219 0, InsertAtEnd) {} 1220 1221//===----------------------------------------------------------------------===// 1222// BranchInst Implementation 1223//===----------------------------------------------------------------------===// 1224 1225void BranchInst::AssertOK() { 1226 if (isConditional()) 1227 assert(getCondition()->getType()->isIntegerTy(1) && 1228 "May only branch on boolean predicates!"); 1229} 1230 1231BranchInst::BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore) 1232 : Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br, 1233 OperandTraits<BranchInst>::op_end(this) - 1, 1, 1234 InsertBefore) { 1235 assert(IfTrue && "Branch destination may not be null!"); 1236 Op<-1>() = IfTrue; 1237} 1238 1239BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond, 1240 Instruction *InsertBefore) 1241 : Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br, 1242 OperandTraits<BranchInst>::op_end(this) - 3, 3, 1243 InsertBefore) { 1244 Op<-1>() = IfTrue; 1245 Op<-2>() = IfFalse; 1246 Op<-3>() = Cond; 1247#ifndef NDEBUG 1248 AssertOK(); 1249#endif 1250} 1251 1252BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd) 1253 : Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br, 1254 OperandTraits<BranchInst>::op_end(this) - 1, 1, InsertAtEnd) { 1255 assert(IfTrue && "Branch destination may not be null!"); 1256 Op<-1>() = IfTrue; 1257} 1258 1259BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond, 1260 BasicBlock *InsertAtEnd) 1261 : Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br, 1262 OperandTraits<BranchInst>::op_end(this) - 3, 3, InsertAtEnd) { 1263 Op<-1>() = IfTrue; 1264 Op<-2>() = IfFalse; 1265 Op<-3>() = Cond; 1266#ifndef NDEBUG 1267 AssertOK(); 1268#endif 1269} 1270 1271BranchInst::BranchInst(const BranchInst &BI) 1272 : Instruction(Type::getVoidTy(BI.getContext()), Instruction::Br, 1273 OperandTraits<BranchInst>::op_end(this) - BI.getNumOperands(), 1274 BI.getNumOperands()) { 1275 Op<-1>() = BI.Op<-1>(); 1276 if (BI.getNumOperands() != 1) { 1277 assert(BI.getNumOperands() == 3 && "BR can have 1 or 3 operands!"); 1278 Op<-3>() = BI.Op<-3>(); 1279 Op<-2>() = BI.Op<-2>(); 1280 } 1281 SubclassOptionalData = BI.SubclassOptionalData; 1282} 1283 1284void BranchInst::swapSuccessors() { 1285 assert(isConditional() && 1286 "Cannot swap successors of an unconditional branch"); 1287 Op<-1>().swap(Op<-2>()); 1288 1289 // Update profile metadata if present and it matches our structural 1290 // expectations. 1291 swapProfMetadata(); 1292} 1293 1294//===----------------------------------------------------------------------===// 1295// AllocaInst Implementation 1296//===----------------------------------------------------------------------===// 1297 1298static Value *getAISize(LLVMContext &Context, Value *Amt) { 1299 if (!Amt) 1300 Amt = ConstantInt::get(Type::getInt32Ty(Context), 1); 1301 else { 1302 assert(!isa<BasicBlock>(Amt) && 1303 "Passed basic block into allocation size parameter! Use other ctor"); 1304 assert(Amt->getType()->isIntegerTy() && 1305 "Allocation array size is not an integer!"); 1306 } 1307 return Amt; 1308} 1309 1310static Align computeAllocaDefaultAlign(Type *Ty, BasicBlock *BB) { 1311 assert(BB && "Insertion BB cannot be null when alignment not provided!"); 1312 assert(BB->getParent() && 1313 "BB must be in a Function when alignment not provided!"); 1314 const DataLayout &DL = BB->getModule()->getDataLayout(); 1315 return DL.getPrefTypeAlign(Ty); 1316} 1317 1318static Align computeAllocaDefaultAlign(Type *Ty, Instruction *I) { 1319 assert(I && "Insertion position cannot be null when alignment not provided!"); 1320 return computeAllocaDefaultAlign(Ty, I->getParent()); 1321} 1322 1323AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, const Twine &Name, 1324 Instruction *InsertBefore) 1325 : AllocaInst(Ty, AddrSpace, /*ArraySize=*/nullptr, Name, InsertBefore) {} 1326 1327AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, const Twine &Name, 1328 BasicBlock *InsertAtEnd) 1329 : AllocaInst(Ty, AddrSpace, /*ArraySize=*/nullptr, Name, InsertAtEnd) {} 1330 1331AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, 1332 const Twine &Name, Instruction *InsertBefore) 1333 : AllocaInst(Ty, AddrSpace, ArraySize, 1334 computeAllocaDefaultAlign(Ty, InsertBefore), Name, 1335 InsertBefore) {} 1336 1337AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, 1338 const Twine &Name, BasicBlock *InsertAtEnd) 1339 : AllocaInst(Ty, AddrSpace, ArraySize, 1340 computeAllocaDefaultAlign(Ty, InsertAtEnd), Name, 1341 InsertAtEnd) {} 1342 1343AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, 1344 Align Align, const Twine &Name, 1345 Instruction *InsertBefore) 1346 : UnaryInstruction(PointerType::get(Ty, AddrSpace), Alloca, 1347 getAISize(Ty->getContext(), ArraySize), InsertBefore), 1348 AllocatedType(Ty) { 1349 setAlignment(Align); 1350 assert(!Ty->isVoidTy() && "Cannot allocate void!"); 1351 setName(Name); 1352} 1353 1354AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, 1355 Align Align, const Twine &Name, BasicBlock *InsertAtEnd) 1356 : UnaryInstruction(PointerType::get(Ty, AddrSpace), Alloca, 1357 getAISize(Ty->getContext(), ArraySize), InsertAtEnd), 1358 AllocatedType(Ty) { 1359 setAlignment(Align); 1360 assert(!Ty->isVoidTy() && "Cannot allocate void!"); 1361 setName(Name); 1362} 1363 1364 1365bool AllocaInst::isArrayAllocation() const { 1366 if (ConstantInt *CI = dyn_cast<ConstantInt>(getOperand(0))) 1367 return !CI->isOne(); 1368 return true; 1369} 1370 1371/// isStaticAlloca - Return true if this alloca is in the entry block of the 1372/// function and is a constant size. If so, the code generator will fold it 1373/// into the prolog/epilog code, so it is basically free. 1374bool AllocaInst::isStaticAlloca() const { 1375 // Must be constant size. 1376 if (!isa<ConstantInt>(getArraySize())) return false; 1377 1378 // Must be in the entry block. 1379 const BasicBlock *Parent = getParent(); 1380 return Parent == &Parent->getParent()->front() && !isUsedWithInAlloca(); 1381} 1382 1383//===----------------------------------------------------------------------===// 1384// LoadInst Implementation 1385//===----------------------------------------------------------------------===// 1386 1387void LoadInst::AssertOK() { 1388 assert(getOperand(0)->getType()->isPointerTy() && 1389 "Ptr must have pointer type."); 1390 assert(!(isAtomic() && getAlignment() == 0) && 1391 "Alignment required for atomic load"); 1392} 1393 1394static Align computeLoadStoreDefaultAlign(Type *Ty, BasicBlock *BB) { 1395 assert(BB && "Insertion BB cannot be null when alignment not provided!"); 1396 assert(BB->getParent() && 1397 "BB must be in a Function when alignment not provided!"); 1398 const DataLayout &DL = BB->getModule()->getDataLayout(); 1399 return DL.getABITypeAlign(Ty); 1400} 1401 1402static Align computeLoadStoreDefaultAlign(Type *Ty, Instruction *I) { 1403 assert(I && "Insertion position cannot be null when alignment not provided!"); 1404 return computeLoadStoreDefaultAlign(Ty, I->getParent()); 1405} 1406 1407LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, 1408 Instruction *InsertBef) 1409 : LoadInst(Ty, Ptr, Name, /*isVolatile=*/false, InsertBef) {} 1410 1411LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, 1412 BasicBlock *InsertAE) 1413 : LoadInst(Ty, Ptr, Name, /*isVolatile=*/false, InsertAE) {} 1414 1415LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile, 1416 Instruction *InsertBef) 1417 : LoadInst(Ty, Ptr, Name, isVolatile, 1418 computeLoadStoreDefaultAlign(Ty, InsertBef), InsertBef) {} 1419 1420LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile, 1421 BasicBlock *InsertAE) 1422 : LoadInst(Ty, Ptr, Name, isVolatile, 1423 computeLoadStoreDefaultAlign(Ty, InsertAE), InsertAE) {} 1424 1425LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile, 1426 Align Align, Instruction *InsertBef) 1427 : LoadInst(Ty, Ptr, Name, isVolatile, Align, AtomicOrdering::NotAtomic, 1428 SyncScope::System, InsertBef) {} 1429 1430LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile, 1431 Align Align, BasicBlock *InsertAE) 1432 : LoadInst(Ty, Ptr, Name, isVolatile, Align, AtomicOrdering::NotAtomic, 1433 SyncScope::System, InsertAE) {} 1434 1435LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile, 1436 Align Align, AtomicOrdering Order, SyncScope::ID SSID, 1437 Instruction *InsertBef) 1438 : UnaryInstruction(Ty, Load, Ptr, InsertBef) { 1439 assert(cast<PointerType>(Ptr->getType())->isOpaqueOrPointeeTypeMatches(Ty)); 1440 setVolatile(isVolatile); 1441 setAlignment(Align); 1442 setAtomic(Order, SSID); 1443 AssertOK(); 1444 setName(Name); 1445} 1446 1447LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile, 1448 Align Align, AtomicOrdering Order, SyncScope::ID SSID, 1449 BasicBlock *InsertAE) 1450 : UnaryInstruction(Ty, Load, Ptr, InsertAE) { 1451 assert(cast<PointerType>(Ptr->getType())->isOpaqueOrPointeeTypeMatches(Ty)); 1452 setVolatile(isVolatile); 1453 setAlignment(Align); 1454 setAtomic(Order, SSID); 1455 AssertOK(); 1456 setName(Name); 1457} 1458 1459//===----------------------------------------------------------------------===// 1460// StoreInst Implementation 1461//===----------------------------------------------------------------------===// 1462 1463void StoreInst::AssertOK() { 1464 assert(getOperand(0) && getOperand(1) && "Both operands must be non-null!"); 1465 assert(getOperand(1)->getType()->isPointerTy() && 1466 "Ptr must have pointer type!"); 1467 assert(cast<PointerType>(getOperand(1)->getType()) 1468 ->isOpaqueOrPointeeTypeMatches(getOperand(0)->getType()) && 1469 "Ptr must be a pointer to Val type!"); 1470 assert(!(isAtomic() && getAlignment() == 0) && 1471 "Alignment required for atomic store"); 1472} 1473 1474StoreInst::StoreInst(Value *val, Value *addr, Instruction *InsertBefore) 1475 : StoreInst(val, addr, /*isVolatile=*/false, InsertBefore) {} 1476 1477StoreInst::StoreInst(Value *val, Value *addr, BasicBlock *InsertAtEnd) 1478 : StoreInst(val, addr, /*isVolatile=*/false, InsertAtEnd) {} 1479 1480StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, 1481 Instruction *InsertBefore) 1482 : StoreInst(val, addr, isVolatile, 1483 computeLoadStoreDefaultAlign(val->getType(), InsertBefore), 1484 InsertBefore) {} 1485 1486StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, 1487 BasicBlock *InsertAtEnd) 1488 : StoreInst(val, addr, isVolatile, 1489 computeLoadStoreDefaultAlign(val->getType(), InsertAtEnd), 1490 InsertAtEnd) {} 1491 1492StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, Align Align, 1493 Instruction *InsertBefore) 1494 : StoreInst(val, addr, isVolatile, Align, AtomicOrdering::NotAtomic, 1495 SyncScope::System, InsertBefore) {} 1496 1497StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, Align Align, 1498 BasicBlock *InsertAtEnd) 1499 : StoreInst(val, addr, isVolatile, Align, AtomicOrdering::NotAtomic, 1500 SyncScope::System, InsertAtEnd) {} 1501 1502StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, Align Align, 1503 AtomicOrdering Order, SyncScope::ID SSID, 1504 Instruction *InsertBefore) 1505 : Instruction(Type::getVoidTy(val->getContext()), Store, 1506 OperandTraits<StoreInst>::op_begin(this), 1507 OperandTraits<StoreInst>::operands(this), InsertBefore) { 1508 Op<0>() = val; 1509 Op<1>() = addr; 1510 setVolatile(isVolatile); 1511 setAlignment(Align); 1512 setAtomic(Order, SSID); 1513 AssertOK(); 1514} 1515 1516StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, Align Align, 1517 AtomicOrdering Order, SyncScope::ID SSID, 1518 BasicBlock *InsertAtEnd) 1519 : Instruction(Type::getVoidTy(val->getContext()), Store, 1520 OperandTraits<StoreInst>::op_begin(this), 1521 OperandTraits<StoreInst>::operands(this), InsertAtEnd) { 1522 Op<0>() = val; 1523 Op<1>() = addr; 1524 setVolatile(isVolatile); 1525 setAlignment(Align); 1526 setAtomic(Order, SSID); 1527 AssertOK(); 1528} 1529 1530 1531//===----------------------------------------------------------------------===// 1532// AtomicCmpXchgInst Implementation 1533//===----------------------------------------------------------------------===// 1534 1535void AtomicCmpXchgInst::Init(Value *Ptr, Value *Cmp, Value *NewVal, 1536 Align Alignment, AtomicOrdering SuccessOrdering, 1537 AtomicOrdering FailureOrdering, 1538 SyncScope::ID SSID) { 1539 Op<0>() = Ptr; 1540 Op<1>() = Cmp; 1541 Op<2>() = NewVal; 1542 setSuccessOrdering(SuccessOrdering); 1543 setFailureOrdering(FailureOrdering); 1544 setSyncScopeID(SSID); 1545 setAlignment(Alignment); 1546 1547 assert(getOperand(0) && getOperand(1) && getOperand(2) && 1548 "All operands must be non-null!"); 1549 assert(getOperand(0)->getType()->isPointerTy() && 1550 "Ptr must have pointer type!"); 1551 assert(cast<PointerType>(getOperand(0)->getType()) 1552 ->isOpaqueOrPointeeTypeMatches(getOperand(1)->getType()) && 1553 "Ptr must be a pointer to Cmp type!"); 1554 assert(cast<PointerType>(getOperand(0)->getType()) 1555 ->isOpaqueOrPointeeTypeMatches(getOperand(2)->getType()) && 1556 "Ptr must be a pointer to NewVal type!"); 1557 assert(getOperand(1)->getType() == getOperand(2)->getType() && 1558 "Cmp type and NewVal type must be same!"); 1559} 1560 1561AtomicCmpXchgInst::AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, 1562 Align Alignment, 1563 AtomicOrdering SuccessOrdering, 1564 AtomicOrdering FailureOrdering, 1565 SyncScope::ID SSID, 1566 Instruction *InsertBefore) 1567 : Instruction( 1568 StructType::get(Cmp->getType(), Type::getInt1Ty(Cmp->getContext())), 1569 AtomicCmpXchg, OperandTraits<AtomicCmpXchgInst>::op_begin(this), 1570 OperandTraits<AtomicCmpXchgInst>::operands(this), InsertBefore) { 1571 Init(Ptr, Cmp, NewVal, Alignment, SuccessOrdering, FailureOrdering, SSID); 1572} 1573 1574AtomicCmpXchgInst::AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, 1575 Align Alignment, 1576 AtomicOrdering SuccessOrdering, 1577 AtomicOrdering FailureOrdering, 1578 SyncScope::ID SSID, 1579 BasicBlock *InsertAtEnd) 1580 : Instruction( 1581 StructType::get(Cmp->getType(), Type::getInt1Ty(Cmp->getContext())), 1582 AtomicCmpXchg, OperandTraits<AtomicCmpXchgInst>::op_begin(this), 1583 OperandTraits<AtomicCmpXchgInst>::operands(this), InsertAtEnd) { 1584 Init(Ptr, Cmp, NewVal, Alignment, SuccessOrdering, FailureOrdering, SSID); 1585} 1586 1587//===----------------------------------------------------------------------===// 1588// AtomicRMWInst Implementation 1589//===----------------------------------------------------------------------===// 1590 1591void AtomicRMWInst::Init(BinOp Operation, Value *Ptr, Value *Val, 1592 Align Alignment, AtomicOrdering Ordering, 1593 SyncScope::ID SSID) { 1594 Op<0>() = Ptr; 1595 Op<1>() = Val; 1596 setOperation(Operation); 1597 setOrdering(Ordering); 1598 setSyncScopeID(SSID); 1599 setAlignment(Alignment); 1600 1601 assert(getOperand(0) && getOperand(1) && 1602 "All operands must be non-null!"); 1603 assert(getOperand(0)->getType()->isPointerTy() && 1604 "Ptr must have pointer type!"); 1605 assert(cast<PointerType>(getOperand(0)->getType()) 1606 ->isOpaqueOrPointeeTypeMatches(getOperand(1)->getType()) && 1607 "Ptr must be a pointer to Val type!"); 1608 assert(Ordering != AtomicOrdering::NotAtomic && 1609 "AtomicRMW instructions must be atomic!"); 1610} 1611 1612AtomicRMWInst::AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, 1613 Align Alignment, AtomicOrdering Ordering, 1614 SyncScope::ID SSID, Instruction *InsertBefore) 1615 : Instruction(Val->getType(), AtomicRMW, 1616 OperandTraits<AtomicRMWInst>::op_begin(this), 1617 OperandTraits<AtomicRMWInst>::operands(this), InsertBefore) { 1618 Init(Operation, Ptr, Val, Alignment, Ordering, SSID); 1619} 1620 1621AtomicRMWInst::AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, 1622 Align Alignment, AtomicOrdering Ordering, 1623 SyncScope::ID SSID, BasicBlock *InsertAtEnd) 1624 : Instruction(Val->getType(), AtomicRMW, 1625 OperandTraits<AtomicRMWInst>::op_begin(this), 1626 OperandTraits<AtomicRMWInst>::operands(this), InsertAtEnd) { 1627 Init(Operation, Ptr, Val, Alignment, Ordering, SSID); 1628} 1629 1630StringRef AtomicRMWInst::getOperationName(BinOp Op) { 1631 switch (Op) { 1632 case AtomicRMWInst::Xchg: 1633 return "xchg"; 1634 case AtomicRMWInst::Add: 1635 return "add"; 1636 case AtomicRMWInst::Sub: 1637 return "sub"; 1638 case AtomicRMWInst::And: 1639 return "and"; 1640 case AtomicRMWInst::Nand: 1641 return "nand"; 1642 case AtomicRMWInst::Or: 1643 return "or"; 1644 case AtomicRMWInst::Xor: 1645 return "xor"; 1646 case AtomicRMWInst::Max: 1647 return "max"; 1648 case AtomicRMWInst::Min: 1649 return "min"; 1650 case AtomicRMWInst::UMax: 1651 return "umax"; 1652 case AtomicRMWInst::UMin: 1653 return "umin"; 1654 case AtomicRMWInst::FAdd: 1655 return "fadd"; 1656 case AtomicRMWInst::FSub: 1657 return "fsub"; 1658 case AtomicRMWInst::BAD_BINOP: 1659 return "<invalid operation>"; 1660 } 1661 1662 llvm_unreachable("invalid atomicrmw operation"); 1663} 1664 1665//===----------------------------------------------------------------------===// 1666// FenceInst Implementation 1667//===----------------------------------------------------------------------===// 1668 1669FenceInst::FenceInst(LLVMContext &C, AtomicOrdering Ordering, 1670 SyncScope::ID SSID, 1671 Instruction *InsertBefore) 1672 : Instruction(Type::getVoidTy(C), Fence, nullptr, 0, InsertBefore) { 1673 setOrdering(Ordering); 1674 setSyncScopeID(SSID); 1675} 1676 1677FenceInst::FenceInst(LLVMContext &C, AtomicOrdering Ordering, 1678 SyncScope::ID SSID, 1679 BasicBlock *InsertAtEnd) 1680 : Instruction(Type::getVoidTy(C), Fence, nullptr, 0, InsertAtEnd) { 1681 setOrdering(Ordering); 1682 setSyncScopeID(SSID); 1683} 1684 1685//===----------------------------------------------------------------------===// 1686// GetElementPtrInst Implementation 1687//===----------------------------------------------------------------------===// 1688 1689void GetElementPtrInst::init(Value *Ptr, ArrayRef<Value *> IdxList, 1690 const Twine &Name) { 1691 assert(getNumOperands() == 1 + IdxList.size() && 1692 "NumOperands not initialized?"); 1693 Op<0>() = Ptr; 1694 llvm::copy(IdxList, op_begin() + 1); 1695 setName(Name); 1696} 1697 1698GetElementPtrInst::GetElementPtrInst(const GetElementPtrInst &GEPI) 1699 : Instruction(GEPI.getType(), GetElementPtr, 1700 OperandTraits<GetElementPtrInst>::op_end(this) - 1701 GEPI.getNumOperands(), 1702 GEPI.getNumOperands()), 1703 SourceElementType(GEPI.SourceElementType), 1704 ResultElementType(GEPI.ResultElementType) { 1705 std::copy(GEPI.op_begin(), GEPI.op_end(), op_begin()); 1706 SubclassOptionalData = GEPI.SubclassOptionalData; 1707} 1708 1709Type *GetElementPtrInst::getTypeAtIndex(Type *Ty, Value *Idx) { 1710 if (auto *Struct = dyn_cast<StructType>(Ty)) { 1711 if (!Struct->indexValid(Idx)) 1712 return nullptr; 1713 return Struct->getTypeAtIndex(Idx); 1714 } 1715 if (!Idx->getType()->isIntOrIntVectorTy()) 1716 return nullptr; 1717 if (auto *Array = dyn_cast<ArrayType>(Ty)) 1718 return Array->getElementType(); 1719 if (auto *Vector = dyn_cast<VectorType>(Ty)) 1720 return Vector->getElementType(); 1721 return nullptr; 1722} 1723 1724Type *GetElementPtrInst::getTypeAtIndex(Type *Ty, uint64_t Idx) { 1725 if (auto *Struct = dyn_cast<StructType>(Ty)) { 1726 if (Idx >= Struct->getNumElements()) 1727 return nullptr; 1728 return Struct->getElementType(Idx); 1729 } 1730 if (auto *Array = dyn_cast<ArrayType>(Ty)) 1731 return Array->getElementType(); 1732 if (auto *Vector = dyn_cast<VectorType>(Ty)) 1733 return Vector->getElementType(); 1734 return nullptr; 1735} 1736 1737template <typename IndexTy> 1738static Type *getIndexedTypeInternal(Type *Ty, ArrayRef<IndexTy> IdxList) { 1739 if (IdxList.empty()) 1740 return Ty; 1741 for (IndexTy V : IdxList.slice(1)) { 1742 Ty = GetElementPtrInst::getTypeAtIndex(Ty, V); 1743 if (!Ty) 1744 return Ty; 1745 } 1746 return Ty; 1747} 1748 1749Type *GetElementPtrInst::getIndexedType(Type *Ty, ArrayRef<Value *> IdxList) { 1750 return getIndexedTypeInternal(Ty, IdxList); 1751} 1752 1753Type *GetElementPtrInst::getIndexedType(Type *Ty, 1754 ArrayRef<Constant *> IdxList) { 1755 return getIndexedTypeInternal(Ty, IdxList); 1756} 1757 1758Type *GetElementPtrInst::getIndexedType(Type *Ty, ArrayRef<uint64_t> IdxList) { 1759 return getIndexedTypeInternal(Ty, IdxList); 1760} 1761 1762/// hasAllZeroIndices - Return true if all of the indices of this GEP are 1763/// zeros. If so, the result pointer and the first operand have the same 1764/// value, just potentially different types. 1765bool GetElementPtrInst::hasAllZeroIndices() const { 1766 for (unsigned i = 1, e = getNumOperands(); i != e; ++i) { 1767 if (ConstantInt *CI = dyn_cast<ConstantInt>(getOperand(i))) { 1768 if (!CI->isZero()) return false; 1769 } else { 1770 return false; 1771 } 1772 } 1773 return true; 1774} 1775 1776/// hasAllConstantIndices - Return true if all of the indices of this GEP are 1777/// constant integers. If so, the result pointer and the first operand have 1778/// a constant offset between them. 1779bool GetElementPtrInst::hasAllConstantIndices() const { 1780 for (unsigned i = 1, e = getNumOperands(); i != e; ++i) { 1781 if (!isa<ConstantInt>(getOperand(i))) 1782 return false; 1783 } 1784 return true; 1785} 1786 1787void GetElementPtrInst::setIsInBounds(bool B) { 1788 cast<GEPOperator>(this)->setIsInBounds(B); 1789} 1790 1791bool GetElementPtrInst::isInBounds() const { 1792 return cast<GEPOperator>(this)->isInBounds(); 1793} 1794 1795bool GetElementPtrInst::accumulateConstantOffset(const DataLayout &DL, 1796 APInt &Offset) const { 1797 // Delegate to the generic GEPOperator implementation. 1798 return cast<GEPOperator>(this)->accumulateConstantOffset(DL, Offset); 1799} 1800 1801bool GetElementPtrInst::collectOffset( 1802 const DataLayout &DL, unsigned BitWidth, 1803 SmallDenseMap<Value *, APInt, 8> &VariableOffsets, 1804 APInt &ConstantOffset) const { 1805 // Delegate to the generic GEPOperator implementation. 1806 return cast<GEPOperator>(this)->collectOffset(DL, BitWidth, VariableOffsets, 1807 ConstantOffset); 1808} 1809 1810//===----------------------------------------------------------------------===// 1811// ExtractElementInst Implementation 1812//===----------------------------------------------------------------------===// 1813 1814ExtractElementInst::ExtractElementInst(Value *Val, Value *Index, 1815 const Twine &Name, 1816 Instruction *InsertBef) 1817 : Instruction(cast<VectorType>(Val->getType())->getElementType(), 1818 ExtractElement, 1819 OperandTraits<ExtractElementInst>::op_begin(this), 1820 2, InsertBef) { 1821 assert(isValidOperands(Val, Index) && 1822 "Invalid extractelement instruction operands!"); 1823 Op<0>() = Val; 1824 Op<1>() = Index; 1825 setName(Name); 1826} 1827 1828ExtractElementInst::ExtractElementInst(Value *Val, Value *Index, 1829 const Twine &Name, 1830 BasicBlock *InsertAE) 1831 : Instruction(cast<VectorType>(Val->getType())->getElementType(), 1832 ExtractElement, 1833 OperandTraits<ExtractElementInst>::op_begin(this), 1834 2, InsertAE) { 1835 assert(isValidOperands(Val, Index) && 1836 "Invalid extractelement instruction operands!"); 1837 1838 Op<0>() = Val; 1839 Op<1>() = Index; 1840 setName(Name); 1841} 1842 1843bool ExtractElementInst::isValidOperands(const Value *Val, const Value *Index) { 1844 if (!Val->getType()->isVectorTy() || !Index->getType()->isIntegerTy()) 1845 return false; 1846 return true; 1847} 1848 1849//===----------------------------------------------------------------------===// 1850// InsertElementInst Implementation 1851//===----------------------------------------------------------------------===// 1852 1853InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index, 1854 const Twine &Name, 1855 Instruction *InsertBef) 1856 : Instruction(Vec->getType(), InsertElement, 1857 OperandTraits<InsertElementInst>::op_begin(this), 1858 3, InsertBef) { 1859 assert(isValidOperands(Vec, Elt, Index) && 1860 "Invalid insertelement instruction operands!"); 1861 Op<0>() = Vec; 1862 Op<1>() = Elt; 1863 Op<2>() = Index; 1864 setName(Name); 1865} 1866 1867InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index, 1868 const Twine &Name, 1869 BasicBlock *InsertAE) 1870 : Instruction(Vec->getType(), InsertElement, 1871 OperandTraits<InsertElementInst>::op_begin(this), 1872 3, InsertAE) { 1873 assert(isValidOperands(Vec, Elt, Index) && 1874 "Invalid insertelement instruction operands!"); 1875 1876 Op<0>() = Vec; 1877 Op<1>() = Elt; 1878 Op<2>() = Index; 1879 setName(Name); 1880} 1881 1882bool InsertElementInst::isValidOperands(const Value *Vec, const Value *Elt, 1883 const Value *Index) { 1884 if (!Vec->getType()->isVectorTy()) 1885 return false; // First operand of insertelement must be vector type. 1886 1887 if (Elt->getType() != cast<VectorType>(Vec->getType())->getElementType()) 1888 return false;// Second operand of insertelement must be vector element type. 1889 1890 if (!Index->getType()->isIntegerTy()) 1891 return false; // Third operand of insertelement must be i32. 1892 return true; 1893} 1894 1895//===----------------------------------------------------------------------===// 1896// ShuffleVectorInst Implementation 1897//===----------------------------------------------------------------------===// 1898 1899ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, Value *Mask, 1900 const Twine &Name, 1901 Instruction *InsertBefore) 1902 : Instruction( 1903 VectorType::get(cast<VectorType>(V1->getType())->getElementType(), 1904 cast<VectorType>(Mask->getType())->getElementCount()), 1905 ShuffleVector, OperandTraits<ShuffleVectorInst>::op_begin(this), 1906 OperandTraits<ShuffleVectorInst>::operands(this), InsertBefore) { 1907 assert(isValidOperands(V1, V2, Mask) && 1908 "Invalid shuffle vector instruction operands!"); 1909 1910 Op<0>() = V1; 1911 Op<1>() = V2; 1912 SmallVector<int, 16> MaskArr; 1913 getShuffleMask(cast<Constant>(Mask), MaskArr); 1914 setShuffleMask(MaskArr); 1915 setName(Name); 1916} 1917 1918ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, Value *Mask, 1919 const Twine &Name, BasicBlock *InsertAtEnd) 1920 : Instruction( 1921 VectorType::get(cast<VectorType>(V1->getType())->getElementType(), 1922 cast<VectorType>(Mask->getType())->getElementCount()), 1923 ShuffleVector, OperandTraits<ShuffleVectorInst>::op_begin(this), 1924 OperandTraits<ShuffleVectorInst>::operands(this), InsertAtEnd) { 1925 assert(isValidOperands(V1, V2, Mask) && 1926 "Invalid shuffle vector instruction operands!"); 1927 1928 Op<0>() = V1; 1929 Op<1>() = V2; 1930 SmallVector<int, 16> MaskArr; 1931 getShuffleMask(cast<Constant>(Mask), MaskArr); 1932 setShuffleMask(MaskArr); 1933 setName(Name); 1934} 1935 1936ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask, 1937 const Twine &Name, 1938 Instruction *InsertBefore) 1939 : Instruction( 1940 VectorType::get(cast<VectorType>(V1->getType())->getElementType(), 1941 Mask.size(), isa<ScalableVectorType>(V1->getType())), 1942 ShuffleVector, OperandTraits<ShuffleVectorInst>::op_begin(this), 1943 OperandTraits<ShuffleVectorInst>::operands(this), InsertBefore) { 1944 assert(isValidOperands(V1, V2, Mask) && 1945 "Invalid shuffle vector instruction operands!"); 1946 Op<0>() = V1; 1947 Op<1>() = V2; 1948 setShuffleMask(Mask); 1949 setName(Name); 1950} 1951 1952ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask, 1953 const Twine &Name, BasicBlock *InsertAtEnd) 1954 : Instruction( 1955 VectorType::get(cast<VectorType>(V1->getType())->getElementType(), 1956 Mask.size(), isa<ScalableVectorType>(V1->getType())), 1957 ShuffleVector, OperandTraits<ShuffleVectorInst>::op_begin(this), 1958 OperandTraits<ShuffleVectorInst>::operands(this), InsertAtEnd) { 1959 assert(isValidOperands(V1, V2, Mask) && 1960 "Invalid shuffle vector instruction operands!"); 1961 1962 Op<0>() = V1; 1963 Op<1>() = V2; 1964 setShuffleMask(Mask); 1965 setName(Name); 1966} 1967 1968void ShuffleVectorInst::commute() { 1969 int NumOpElts = cast<FixedVectorType>(Op<0>()->getType())->getNumElements(); 1970 int NumMaskElts = ShuffleMask.size(); 1971 SmallVector<int, 16> NewMask(NumMaskElts); 1972 for (int i = 0; i != NumMaskElts; ++i) { 1973 int MaskElt = getMaskValue(i); 1974 if (MaskElt == UndefMaskElem) { 1975 NewMask[i] = UndefMaskElem; 1976 continue; 1977 } 1978 assert(MaskElt >= 0 && MaskElt < 2 * NumOpElts && "Out-of-range mask"); 1979 MaskElt = (MaskElt < NumOpElts) ? MaskElt + NumOpElts : MaskElt - NumOpElts; 1980 NewMask[i] = MaskElt; 1981 } 1982 setShuffleMask(NewMask); 1983 Op<0>().swap(Op<1>()); 1984} 1985 1986bool ShuffleVectorInst::isValidOperands(const Value *V1, const Value *V2, 1987 ArrayRef<int> Mask) { 1988 // V1 and V2 must be vectors of the same type. 1989 if (!isa<VectorType>(V1->getType()) || V1->getType() != V2->getType()) 1990 return false; 1991 1992 // Make sure the mask elements make sense. 1993 int V1Size = 1994 cast<VectorType>(V1->getType())->getElementCount().getKnownMinValue(); 1995 for (int Elem : Mask) 1996 if (Elem != UndefMaskElem && Elem >= V1Size * 2) 1997 return false; 1998 1999 if (isa<ScalableVectorType>(V1->getType())) 2000 if ((Mask[0] != 0 && Mask[0] != UndefMaskElem) || !is_splat(Mask)) 2001 return false; 2002 2003 return true; 2004} 2005 2006bool ShuffleVectorInst::isValidOperands(const Value *V1, const Value *V2, 2007 const Value *Mask) { 2008 // V1 and V2 must be vectors of the same type. 2009 if (!V1->getType()->isVectorTy() || V1->getType() != V2->getType()) 2010 return false; 2011 2012 // Mask must be vector of i32, and must be the same kind of vector as the 2013 // input vectors 2014 auto *MaskTy = dyn_cast<VectorType>(Mask->getType()); 2015 if (!MaskTy || !MaskTy->getElementType()->isIntegerTy(32) || 2016 isa<ScalableVectorType>(MaskTy) != isa<ScalableVectorType>(V1->getType())) 2017 return false; 2018 2019 // Check to see if Mask is valid. 2020 if (isa<UndefValue>(Mask) || isa<ConstantAggregateZero>(Mask)) 2021 return true; 2022 2023 if (const auto *MV = dyn_cast<ConstantVector>(Mask)) { 2024 unsigned V1Size = cast<FixedVectorType>(V1->getType())->getNumElements(); 2025 for (Value *Op : MV->operands()) { 2026 if (auto *CI = dyn_cast<ConstantInt>(Op)) { 2027 if (CI->uge(V1Size*2)) 2028 return false; 2029 } else if (!isa<UndefValue>(Op)) { 2030 return false; 2031 } 2032 } 2033 return true; 2034 } 2035 2036 if (const auto *CDS = dyn_cast<ConstantDataSequential>(Mask)) { 2037 unsigned V1Size = cast<FixedVectorType>(V1->getType())->getNumElements(); 2038 for (unsigned i = 0, e = cast<FixedVectorType>(MaskTy)->getNumElements(); 2039 i != e; ++i) 2040 if (CDS->getElementAsInteger(i) >= V1Size*2) 2041 return false; 2042 return true; 2043 } 2044 2045 return false; 2046} 2047 2048void ShuffleVectorInst::getShuffleMask(const Constant *Mask, 2049 SmallVectorImpl<int> &Result) { 2050 ElementCount EC = cast<VectorType>(Mask->getType())->getElementCount(); 2051 2052 if (isa<ConstantAggregateZero>(Mask)) { 2053 Result.resize(EC.getKnownMinValue(), 0); 2054 return; 2055 } 2056 2057 Result.reserve(EC.getKnownMinValue()); 2058 2059 if (EC.isScalable()) { 2060 assert((isa<ConstantAggregateZero>(Mask) || isa<UndefValue>(Mask)) && 2061 "Scalable vector shuffle mask must be undef or zeroinitializer"); 2062 int MaskVal = isa<UndefValue>(Mask) ? -1 : 0; 2063 for (unsigned I = 0; I < EC.getKnownMinValue(); ++I) 2064 Result.emplace_back(MaskVal); 2065 return; 2066 } 2067 2068 unsigned NumElts = EC.getKnownMinValue(); 2069 2070 if (auto *CDS = dyn_cast<ConstantDataSequential>(Mask)) { 2071 for (unsigned i = 0; i != NumElts; ++i) 2072 Result.push_back(CDS->getElementAsInteger(i)); 2073 return; 2074 } 2075 for (unsigned i = 0; i != NumElts; ++i) { 2076 Constant *C = Mask->getAggregateElement(i); 2077 Result.push_back(isa<UndefValue>(C) ? -1 : 2078 cast<ConstantInt>(C)->getZExtValue()); 2079 } 2080} 2081 2082void ShuffleVectorInst::setShuffleMask(ArrayRef<int> Mask) { 2083 ShuffleMask.assign(Mask.begin(), Mask.end()); 2084 ShuffleMaskForBitcode = convertShuffleMaskForBitcode(Mask, getType()); 2085} 2086Constant *ShuffleVectorInst::convertShuffleMaskForBitcode(ArrayRef<int> Mask, 2087 Type *ResultTy) { 2088 Type *Int32Ty = Type::getInt32Ty(ResultTy->getContext()); 2089 if (isa<ScalableVectorType>(ResultTy)) { 2090 assert(is_splat(Mask) && "Unexpected shuffle"); 2091 Type *VecTy = VectorType::get(Int32Ty, Mask.size(), true); 2092 if (Mask[0] == 0) 2093 return Constant::getNullValue(VecTy); 2094 return UndefValue::get(VecTy); 2095 } 2096 SmallVector<Constant *, 16> MaskConst; 2097 for (int Elem : Mask) { 2098 if (Elem == UndefMaskElem) 2099 MaskConst.push_back(UndefValue::get(Int32Ty)); 2100 else 2101 MaskConst.push_back(ConstantInt::get(Int32Ty, Elem)); 2102 } 2103 return ConstantVector::get(MaskConst); 2104} 2105 2106static bool isSingleSourceMaskImpl(ArrayRef<int> Mask, int NumOpElts) { 2107 assert(!Mask.empty() && "Shuffle mask must contain elements"); 2108 bool UsesLHS = false; 2109 bool UsesRHS = false; 2110 for (int I : Mask) { 2111 if (I == -1) 2112 continue; 2113 assert(I >= 0 && I < (NumOpElts * 2) && 2114 "Out-of-bounds shuffle mask element"); 2115 UsesLHS |= (I < NumOpElts); 2116 UsesRHS |= (I >= NumOpElts); 2117 if (UsesLHS && UsesRHS) 2118 return false; 2119 } 2120 // Allow for degenerate case: completely undef mask means neither source is used. 2121 return UsesLHS || UsesRHS; 2122} 2123 2124bool ShuffleVectorInst::isSingleSourceMask(ArrayRef<int> Mask) { 2125 // We don't have vector operand size information, so assume operands are the 2126 // same size as the mask. 2127 return isSingleSourceMaskImpl(Mask, Mask.size()); 2128} 2129 2130static bool isIdentityMaskImpl(ArrayRef<int> Mask, int NumOpElts) { 2131 if (!isSingleSourceMaskImpl(Mask, NumOpElts)) 2132 return false; 2133 for (int i = 0, NumMaskElts = Mask.size(); i < NumMaskElts; ++i) { 2134 if (Mask[i] == -1) 2135 continue; 2136 if (Mask[i] != i && Mask[i] != (NumOpElts + i)) 2137 return false; 2138 } 2139 return true; 2140} 2141 2142bool ShuffleVectorInst::isIdentityMask(ArrayRef<int> Mask) { 2143 // We don't have vector operand size information, so assume operands are the 2144 // same size as the mask. 2145 return isIdentityMaskImpl(Mask, Mask.size()); 2146} 2147 2148bool ShuffleVectorInst::isReverseMask(ArrayRef<int> Mask) { 2149 if (!isSingleSourceMask(Mask)) 2150 return false; 2151 for (int i = 0, NumElts = Mask.size(); i < NumElts; ++i) { 2152 if (Mask[i] == -1) 2153 continue; 2154 if (Mask[i] != (NumElts - 1 - i) && Mask[i] != (NumElts + NumElts - 1 - i)) 2155 return false; 2156 } 2157 return true; 2158} 2159 2160bool ShuffleVectorInst::isZeroEltSplatMask(ArrayRef<int> Mask) { 2161 if (!isSingleSourceMask(Mask)) 2162 return false; 2163 for (int i = 0, NumElts = Mask.size(); i < NumElts; ++i) { 2164 if (Mask[i] == -1) 2165 continue; 2166 if (Mask[i] != 0 && Mask[i] != NumElts) 2167 return false; 2168 } 2169 return true; 2170} 2171 2172bool ShuffleVectorInst::isSelectMask(ArrayRef<int> Mask) { 2173 // Select is differentiated from identity. It requires using both sources. 2174 if (isSingleSourceMask(Mask)) 2175 return false; 2176 for (int i = 0, NumElts = Mask.size(); i < NumElts; ++i) { 2177 if (Mask[i] == -1) 2178 continue; 2179 if (Mask[i] != i && Mask[i] != (NumElts + i)) 2180 return false; 2181 } 2182 return true; 2183} 2184 2185bool ShuffleVectorInst::isTransposeMask(ArrayRef<int> Mask) { 2186 // Example masks that will return true: 2187 // v1 = <a, b, c, d> 2188 // v2 = <e, f, g, h> 2189 // trn1 = shufflevector v1, v2 <0, 4, 2, 6> = <a, e, c, g> 2190 // trn2 = shufflevector v1, v2 <1, 5, 3, 7> = <b, f, d, h> 2191 2192 // 1. The number of elements in the mask must be a power-of-2 and at least 2. 2193 int NumElts = Mask.size(); 2194 if (NumElts < 2 || !isPowerOf2_32(NumElts)) 2195 return false; 2196 2197 // 2. The first element of the mask must be either a 0 or a 1. 2198 if (Mask[0] != 0 && Mask[0] != 1) 2199 return false; 2200 2201 // 3. The difference between the first 2 elements must be equal to the 2202 // number of elements in the mask. 2203 if ((Mask[1] - Mask[0]) != NumElts) 2204 return false; 2205 2206 // 4. The difference between consecutive even-numbered and odd-numbered 2207 // elements must be equal to 2. 2208 for (int i = 2; i < NumElts; ++i) { 2209 int MaskEltVal = Mask[i]; 2210 if (MaskEltVal == -1) 2211 return false; 2212 int MaskEltPrevVal = Mask[i - 2]; 2213 if (MaskEltVal - MaskEltPrevVal != 2) 2214 return false; 2215 } 2216 return true; 2217} 2218 2219bool ShuffleVectorInst::isExtractSubvectorMask(ArrayRef<int> Mask, 2220 int NumSrcElts, int &Index) { 2221 // Must extract from a single source. 2222 if (!isSingleSourceMaskImpl(Mask, NumSrcElts)) 2223 return false; 2224 2225 // Must be smaller (else this is an Identity shuffle). 2226 if (NumSrcElts <= (int)Mask.size()) 2227 return false; 2228 2229 // Find start of extraction, accounting that we may start with an UNDEF. 2230 int SubIndex = -1; 2231 for (int i = 0, e = Mask.size(); i != e; ++i) { 2232 int M = Mask[i]; 2233 if (M < 0) 2234 continue; 2235 int Offset = (M % NumSrcElts) - i; 2236 if (0 <= SubIndex && SubIndex != Offset) 2237 return false; 2238 SubIndex = Offset; 2239 } 2240 2241 if (0 <= SubIndex && SubIndex + (int)Mask.size() <= NumSrcElts) { 2242 Index = SubIndex; 2243 return true; 2244 } 2245 return false; 2246} 2247 2248bool ShuffleVectorInst::isIdentityWithPadding() const { 2249 if (isa<UndefValue>(Op<2>())) 2250 return false; 2251 2252 // FIXME: Not currently possible to express a shuffle mask for a scalable 2253 // vector for this case. 2254 if (isa<ScalableVectorType>(getType())) 2255 return false; 2256 2257 int NumOpElts = cast<FixedVectorType>(Op<0>()->getType())->getNumElements(); 2258 int NumMaskElts = cast<FixedVectorType>(getType())->getNumElements(); 2259 if (NumMaskElts <= NumOpElts) 2260 return false; 2261 2262 // The first part of the mask must choose elements from exactly 1 source op. 2263 ArrayRef<int> Mask = getShuffleMask(); 2264 if (!isIdentityMaskImpl(Mask, NumOpElts)) 2265 return false; 2266 2267 // All extending must be with undef elements. 2268 for (int i = NumOpElts; i < NumMaskElts; ++i) 2269 if (Mask[i] != -1) 2270 return false; 2271 2272 return true; 2273} 2274 2275bool ShuffleVectorInst::isIdentityWithExtract() const { 2276 if (isa<UndefValue>(Op<2>())) 2277 return false; 2278 2279 // FIXME: Not currently possible to express a shuffle mask for a scalable 2280 // vector for this case. 2281 if (isa<ScalableVectorType>(getType())) 2282 return false; 2283 2284 int NumOpElts = cast<FixedVectorType>(Op<0>()->getType())->getNumElements(); 2285 int NumMaskElts = cast<FixedVectorType>(getType())->getNumElements(); 2286 if (NumMaskElts >= NumOpElts) 2287 return false; 2288 2289 return isIdentityMaskImpl(getShuffleMask(), NumOpElts); 2290} 2291 2292bool ShuffleVectorInst::isConcat() const { 2293 // Vector concatenation is differentiated from identity with padding. 2294 if (isa<UndefValue>(Op<0>()) || isa<UndefValue>(Op<1>()) || 2295 isa<UndefValue>(Op<2>())) 2296 return false; 2297 2298 // FIXME: Not currently possible to express a shuffle mask for a scalable 2299 // vector for this case. 2300 if (isa<ScalableVectorType>(getType())) 2301 return false; 2302 2303 int NumOpElts = cast<FixedVectorType>(Op<0>()->getType())->getNumElements(); 2304 int NumMaskElts = cast<FixedVectorType>(getType())->getNumElements(); 2305 if (NumMaskElts != NumOpElts * 2) 2306 return false; 2307 2308 // Use the mask length rather than the operands' vector lengths here. We 2309 // already know that the shuffle returns a vector twice as long as the inputs, 2310 // and neither of the inputs are undef vectors. If the mask picks consecutive 2311 // elements from both inputs, then this is a concatenation of the inputs. 2312 return isIdentityMaskImpl(getShuffleMask(), NumMaskElts); 2313} 2314 2315//===----------------------------------------------------------------------===// 2316// InsertValueInst Class 2317//===----------------------------------------------------------------------===// 2318 2319void InsertValueInst::init(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs, 2320 const Twine &Name) { 2321 assert(getNumOperands() == 2 && "NumOperands not initialized?"); 2322 2323 // There's no fundamental reason why we require at least one index 2324 // (other than weirdness with &*IdxBegin being invalid; see 2325 // getelementptr's init routine for example). But there's no 2326 // present need to support it. 2327 assert(!Idxs.empty() && "InsertValueInst must have at least one index"); 2328 2329 assert(ExtractValueInst::getIndexedType(Agg->getType(), Idxs) == 2330 Val->getType() && "Inserted value must match indexed type!"); 2331 Op<0>() = Agg; 2332 Op<1>() = Val; 2333 2334 Indices.append(Idxs.begin(), Idxs.end()); 2335 setName(Name); 2336} 2337 2338InsertValueInst::InsertValueInst(const InsertValueInst &IVI) 2339 : Instruction(IVI.getType(), InsertValue, 2340 OperandTraits<InsertValueInst>::op_begin(this), 2), 2341 Indices(IVI.Indices) { 2342 Op<0>() = IVI.getOperand(0); 2343 Op<1>() = IVI.getOperand(1); 2344 SubclassOptionalData = IVI.SubclassOptionalData; 2345} 2346 2347//===----------------------------------------------------------------------===// 2348// ExtractValueInst Class 2349//===----------------------------------------------------------------------===// 2350 2351void ExtractValueInst::init(ArrayRef<unsigned> Idxs, const Twine &Name) { 2352 assert(getNumOperands() == 1 && "NumOperands not initialized?"); 2353 2354 // There's no fundamental reason why we require at least one index. 2355 // But there's no present need to support it. 2356 assert(!Idxs.empty() && "ExtractValueInst must have at least one index"); 2357 2358 Indices.append(Idxs.begin(), Idxs.end()); 2359 setName(Name); 2360} 2361 2362ExtractValueInst::ExtractValueInst(const ExtractValueInst &EVI) 2363 : UnaryInstruction(EVI.getType(), ExtractValue, EVI.getOperand(0)), 2364 Indices(EVI.Indices) { 2365 SubclassOptionalData = EVI.SubclassOptionalData; 2366} 2367 2368// getIndexedType - Returns the type of the element that would be extracted 2369// with an extractvalue instruction with the specified parameters. 2370// 2371// A null type is returned if the indices are invalid for the specified 2372// pointer type. 2373// 2374Type *ExtractValueInst::getIndexedType(Type *Agg, 2375 ArrayRef<unsigned> Idxs) { 2376 for (unsigned Index : Idxs) { 2377 // We can't use CompositeType::indexValid(Index) here. 2378 // indexValid() always returns true for arrays because getelementptr allows 2379 // out-of-bounds indices. Since we don't allow those for extractvalue and 2380 // insertvalue we need to check array indexing manually. 2381 // Since the only other types we can index into are struct types it's just 2382 // as easy to check those manually as well. 2383 if (ArrayType *AT = dyn_cast<ArrayType>(Agg)) { 2384 if (Index >= AT->getNumElements()) 2385 return nullptr; 2386 Agg = AT->getElementType(); 2387 } else if (StructType *ST = dyn_cast<StructType>(Agg)) { 2388 if (Index >= ST->getNumElements()) 2389 return nullptr; 2390 Agg = ST->getElementType(Index); 2391 } else { 2392 // Not a valid type to index into. 2393 return nullptr; 2394 } 2395 } 2396 return const_cast<Type*>(Agg); 2397} 2398 2399//===----------------------------------------------------------------------===// 2400// UnaryOperator Class 2401//===----------------------------------------------------------------------===// 2402 2403UnaryOperator::UnaryOperator(UnaryOps iType, Value *S, 2404 Type *Ty, const Twine &Name, 2405 Instruction *InsertBefore) 2406 : UnaryInstruction(Ty, iType, S, InsertBefore) { 2407 Op<0>() = S; 2408 setName(Name); 2409 AssertOK(); 2410} 2411 2412UnaryOperator::UnaryOperator(UnaryOps iType, Value *S, 2413 Type *Ty, const Twine &Name, 2414 BasicBlock *InsertAtEnd) 2415 : UnaryInstruction(Ty, iType, S, InsertAtEnd) { 2416 Op<0>() = S; 2417 setName(Name); 2418 AssertOK(); 2419} 2420 2421UnaryOperator *UnaryOperator::Create(UnaryOps Op, Value *S, 2422 const Twine &Name, 2423 Instruction *InsertBefore) { 2424 return new UnaryOperator(Op, S, S->getType(), Name, InsertBefore); 2425} 2426 2427UnaryOperator *UnaryOperator::Create(UnaryOps Op, Value *S, 2428 const Twine &Name, 2429 BasicBlock *InsertAtEnd) { 2430 UnaryOperator *Res = Create(Op, S, Name); 2431 InsertAtEnd->getInstList().push_back(Res); 2432 return Res; 2433} 2434 2435void UnaryOperator::AssertOK() { 2436 Value *LHS = getOperand(0); 2437 (void)LHS; // Silence warnings. 2438#ifndef NDEBUG 2439 switch (getOpcode()) { 2440 case FNeg: 2441 assert(getType() == LHS->getType() && 2442 "Unary operation should return same type as operand!"); 2443 assert(getType()->isFPOrFPVectorTy() && 2444 "Tried to create a floating-point operation on a " 2445 "non-floating-point type!"); 2446 break; 2447 default: llvm_unreachable("Invalid opcode provided"); 2448 } 2449#endif 2450} 2451 2452//===----------------------------------------------------------------------===// 2453// BinaryOperator Class 2454//===----------------------------------------------------------------------===// 2455 2456BinaryOperator::BinaryOperator(BinaryOps iType, Value *S1, Value *S2, 2457 Type *Ty, const Twine &Name, 2458 Instruction *InsertBefore) 2459 : Instruction(Ty, iType, 2460 OperandTraits<BinaryOperator>::op_begin(this), 2461 OperandTraits<BinaryOperator>::operands(this), 2462 InsertBefore) { 2463 Op<0>() = S1; 2464 Op<1>() = S2; 2465 setName(Name); 2466 AssertOK(); 2467} 2468 2469BinaryOperator::BinaryOperator(BinaryOps iType, Value *S1, Value *S2, 2470 Type *Ty, const Twine &Name, 2471 BasicBlock *InsertAtEnd) 2472 : Instruction(Ty, iType, 2473 OperandTraits<BinaryOperator>::op_begin(this), 2474 OperandTraits<BinaryOperator>::operands(this), 2475 InsertAtEnd) { 2476 Op<0>() = S1; 2477 Op<1>() = S2; 2478 setName(Name); 2479 AssertOK(); 2480} 2481 2482void BinaryOperator::AssertOK() { 2483 Value *LHS = getOperand(0), *RHS = getOperand(1); 2484 (void)LHS; (void)RHS; // Silence warnings. 2485 assert(LHS->getType() == RHS->getType() && 2486 "Binary operator operand types must match!"); 2487#ifndef NDEBUG 2488 switch (getOpcode()) { 2489 case Add: case Sub: 2490 case Mul: 2491 assert(getType() == LHS->getType() && 2492 "Arithmetic operation should return same type as operands!"); 2493 assert(getType()->isIntOrIntVectorTy() && 2494 "Tried to create an integer operation on a non-integer type!"); 2495 break; 2496 case FAdd: case FSub: 2497 case FMul: 2498 assert(getType() == LHS->getType() && 2499 "Arithmetic operation should return same type as operands!"); 2500 assert(getType()->isFPOrFPVectorTy() && 2501 "Tried to create a floating-point operation on a " 2502 "non-floating-point type!"); 2503 break; 2504 case UDiv: 2505 case SDiv: 2506 assert(getType() == LHS->getType() && 2507 "Arithmetic operation should return same type as operands!"); 2508 assert(getType()->isIntOrIntVectorTy() && 2509 "Incorrect operand type (not integer) for S/UDIV"); 2510 break; 2511 case FDiv: 2512 assert(getType() == LHS->getType() && 2513 "Arithmetic operation should return same type as operands!"); 2514 assert(getType()->isFPOrFPVectorTy() && 2515 "Incorrect operand type (not floating point) for FDIV"); 2516 break; 2517 case URem: 2518 case SRem: 2519 assert(getType() == LHS->getType() && 2520 "Arithmetic operation should return same type as operands!"); 2521 assert(getType()->isIntOrIntVectorTy() && 2522 "Incorrect operand type (not integer) for S/UREM"); 2523 break; 2524 case FRem: 2525 assert(getType() == LHS->getType() && 2526 "Arithmetic operation should return same type as operands!"); 2527 assert(getType()->isFPOrFPVectorTy() && 2528 "Incorrect operand type (not floating point) for FREM"); 2529 break; 2530 case Shl: 2531 case LShr: 2532 case AShr: 2533 assert(getType() == LHS->getType() && 2534 "Shift operation should return same type as operands!"); 2535 assert(getType()->isIntOrIntVectorTy() && 2536 "Tried to create a shift operation on a non-integral type!"); 2537 break; 2538 case And: case Or: 2539 case Xor: 2540 assert(getType() == LHS->getType() && 2541 "Logical operation should return same type as operands!"); 2542 assert(getType()->isIntOrIntVectorTy() && 2543 "Tried to create a logical operation on a non-integral type!"); 2544 break; 2545 default: llvm_unreachable("Invalid opcode provided"); 2546 } 2547#endif 2548} 2549 2550BinaryOperator *BinaryOperator::Create(BinaryOps Op, Value *S1, Value *S2, 2551 const Twine &Name, 2552 Instruction *InsertBefore) { 2553 assert(S1->getType() == S2->getType() && 2554 "Cannot create binary operator with two operands of differing type!"); 2555 return new BinaryOperator(Op, S1, S2, S1->getType(), Name, InsertBefore); 2556} 2557 2558BinaryOperator *BinaryOperator::Create(BinaryOps Op, Value *S1, Value *S2, 2559 const Twine &Name, 2560 BasicBlock *InsertAtEnd) { 2561 BinaryOperator *Res = Create(Op, S1, S2, Name); 2562 InsertAtEnd->getInstList().push_back(Res); 2563 return Res; 2564} 2565 2566BinaryOperator *BinaryOperator::CreateNeg(Value *Op, const Twine &Name, 2567 Instruction *InsertBefore) { 2568 Value *zero = ConstantFP::getZeroValueForNegation(Op->getType()); 2569 return new BinaryOperator(Instruction::Sub, 2570 zero, Op, 2571 Op->getType(), Name, InsertBefore); 2572} 2573 2574BinaryOperator *BinaryOperator::CreateNeg(Value *Op, const Twine &Name, 2575 BasicBlock *InsertAtEnd) { 2576 Value *zero = ConstantFP::getZeroValueForNegation(Op->getType()); 2577 return new BinaryOperator(Instruction::Sub, 2578 zero, Op, 2579 Op->getType(), Name, InsertAtEnd); 2580} 2581 2582BinaryOperator *BinaryOperator::CreateNSWNeg(Value *Op, const Twine &Name, 2583 Instruction *InsertBefore) { 2584 Value *zero = ConstantFP::getZeroValueForNegation(Op->getType()); 2585 return BinaryOperator::CreateNSWSub(zero, Op, Name, InsertBefore); 2586} 2587 2588BinaryOperator *BinaryOperator::CreateNSWNeg(Value *Op, const Twine &Name, 2589 BasicBlock *InsertAtEnd) { 2590 Value *zero = ConstantFP::getZeroValueForNegation(Op->getType()); 2591 return BinaryOperator::CreateNSWSub(zero, Op, Name, InsertAtEnd); 2592} 2593 2594BinaryOperator *BinaryOperator::CreateNUWNeg(Value *Op, const Twine &Name, 2595 Instruction *InsertBefore) { 2596 Value *zero = ConstantFP::getZeroValueForNegation(Op->getType()); 2597 return BinaryOperator::CreateNUWSub(zero, Op, Name, InsertBefore); 2598} 2599 2600BinaryOperator *BinaryOperator::CreateNUWNeg(Value *Op, const Twine &Name, 2601 BasicBlock *InsertAtEnd) { 2602 Value *zero = ConstantFP::getZeroValueForNegation(Op->getType()); 2603 return BinaryOperator::CreateNUWSub(zero, Op, Name, InsertAtEnd); 2604} 2605 2606BinaryOperator *BinaryOperator::CreateNot(Value *Op, const Twine &Name, 2607 Instruction *InsertBefore) { 2608 Constant *C = Constant::getAllOnesValue(Op->getType()); 2609 return new BinaryOperator(Instruction::Xor, Op, C, 2610 Op->getType(), Name, InsertBefore); 2611} 2612 2613BinaryOperator *BinaryOperator::CreateNot(Value *Op, const Twine &Name, 2614 BasicBlock *InsertAtEnd) { 2615 Constant *AllOnes = Constant::getAllOnesValue(Op->getType()); 2616 return new BinaryOperator(Instruction::Xor, Op, AllOnes, 2617 Op->getType(), Name, InsertAtEnd); 2618} 2619 2620// Exchange the two operands to this instruction. This instruction is safe to 2621// use on any binary instruction and does not modify the semantics of the 2622// instruction. If the instruction is order-dependent (SetLT f.e.), the opcode 2623// is changed. 2624bool BinaryOperator::swapOperands() { 2625 if (!isCommutative()) 2626 return true; // Can't commute operands 2627 Op<0>().swap(Op<1>()); 2628 return false; 2629} 2630 2631//===----------------------------------------------------------------------===// 2632// FPMathOperator Class 2633//===----------------------------------------------------------------------===// 2634 2635float FPMathOperator::getFPAccuracy() const { 2636 const MDNode *MD = 2637 cast<Instruction>(this)->getMetadata(LLVMContext::MD_fpmath); 2638 if (!MD) 2639 return 0.0; 2640 ConstantFP *Accuracy = mdconst::extract<ConstantFP>(MD->getOperand(0)); 2641 return Accuracy->getValueAPF().convertToFloat(); 2642} 2643 2644//===----------------------------------------------------------------------===// 2645// CastInst Class 2646//===----------------------------------------------------------------------===// 2647 2648// Just determine if this cast only deals with integral->integral conversion. 2649bool CastInst::isIntegerCast() const { 2650 switch (getOpcode()) { 2651 default: return false; 2652 case Instruction::ZExt: 2653 case Instruction::SExt: 2654 case Instruction::Trunc: 2655 return true; 2656 case Instruction::BitCast: 2657 return getOperand(0)->getType()->isIntegerTy() && 2658 getType()->isIntegerTy(); 2659 } 2660} 2661 2662bool CastInst::isLosslessCast() const { 2663 // Only BitCast can be lossless, exit fast if we're not BitCast 2664 if (getOpcode() != Instruction::BitCast) 2665 return false; 2666 2667 // Identity cast is always lossless 2668 Type *SrcTy = getOperand(0)->getType(); 2669 Type *DstTy = getType(); 2670 if (SrcTy == DstTy) 2671 return true; 2672 2673 // Pointer to pointer is always lossless. 2674 if (SrcTy->isPointerTy()) 2675 return DstTy->isPointerTy(); 2676 return false; // Other types have no identity values 2677} 2678 2679/// This function determines if the CastInst does not require any bits to be 2680/// changed in order to effect the cast. Essentially, it identifies cases where 2681/// no code gen is necessary for the cast, hence the name no-op cast. For 2682/// example, the following are all no-op casts: 2683/// # bitcast i32* %x to i8* 2684/// # bitcast <2 x i32> %x to <4 x i16> 2685/// # ptrtoint i32* %x to i32 ; on 32-bit plaforms only 2686/// Determine if the described cast is a no-op. 2687bool CastInst::isNoopCast(Instruction::CastOps Opcode, 2688 Type *SrcTy, 2689 Type *DestTy, 2690 const DataLayout &DL) { 2691 assert(castIsValid(Opcode, SrcTy, DestTy) && "method precondition"); 2692 switch (Opcode) { 2693 default: llvm_unreachable("Invalid CastOp"); 2694 case Instruction::Trunc: 2695 case Instruction::ZExt: 2696 case Instruction::SExt: 2697 case Instruction::FPTrunc: 2698 case Instruction::FPExt: 2699 case Instruction::UIToFP: 2700 case Instruction::SIToFP: 2701 case Instruction::FPToUI: 2702 case Instruction::FPToSI: 2703 case Instruction::AddrSpaceCast: 2704 // TODO: Target informations may give a more accurate answer here. 2705 return false; 2706 case Instruction::BitCast: 2707 return true; // BitCast never modifies bits. 2708 case Instruction::PtrToInt: 2709 return DL.getIntPtrType(SrcTy)->getScalarSizeInBits() == 2710 DestTy->getScalarSizeInBits(); 2711 case Instruction::IntToPtr: 2712 return DL.getIntPtrType(DestTy)->getScalarSizeInBits() == 2713 SrcTy->getScalarSizeInBits(); 2714 } 2715} 2716 2717bool CastInst::isNoopCast(const DataLayout &DL) const { 2718 return isNoopCast(getOpcode(), getOperand(0)->getType(), getType(), DL); 2719} 2720 2721/// This function determines if a pair of casts can be eliminated and what 2722/// opcode should be used in the elimination. This assumes that there are two 2723/// instructions like this: 2724/// * %F = firstOpcode SrcTy %x to MidTy 2725/// * %S = secondOpcode MidTy %F to DstTy 2726/// The function returns a resultOpcode so these two casts can be replaced with: 2727/// * %Replacement = resultOpcode %SrcTy %x to DstTy 2728/// If no such cast is permitted, the function returns 0. 2729unsigned CastInst::isEliminableCastPair( 2730 Instruction::CastOps firstOp, Instruction::CastOps secondOp, 2731 Type *SrcTy, Type *MidTy, Type *DstTy, Type *SrcIntPtrTy, Type *MidIntPtrTy, 2732 Type *DstIntPtrTy) { 2733 // Define the 144 possibilities for these two cast instructions. The values 2734 // in this matrix determine what to do in a given situation and select the 2735 // case in the switch below. The rows correspond to firstOp, the columns 2736 // correspond to secondOp. In looking at the table below, keep in mind 2737 // the following cast properties: 2738 // 2739 // Size Compare Source Destination 2740 // Operator Src ? Size Type Sign Type Sign 2741 // -------- ------------ ------------------- --------------------- 2742 // TRUNC > Integer Any Integral Any 2743 // ZEXT < Integral Unsigned Integer Any 2744 // SEXT < Integral Signed Integer Any 2745 // FPTOUI n/a FloatPt n/a Integral Unsigned 2746 // FPTOSI n/a FloatPt n/a Integral Signed 2747 // UITOFP n/a Integral Unsigned FloatPt n/a 2748 // SITOFP n/a Integral Signed FloatPt n/a 2749 // FPTRUNC > FloatPt n/a FloatPt n/a 2750 // FPEXT < FloatPt n/a FloatPt n/a 2751 // PTRTOINT n/a Pointer n/a Integral Unsigned 2752 // INTTOPTR n/a Integral Unsigned Pointer n/a 2753 // BITCAST = FirstClass n/a FirstClass n/a 2754 // ADDRSPCST n/a Pointer n/a Pointer n/a 2755 // 2756 // NOTE: some transforms are safe, but we consider them to be non-profitable. 2757 // For example, we could merge "fptoui double to i32" + "zext i32 to i64", 2758 // into "fptoui double to i64", but this loses information about the range 2759 // of the produced value (we no longer know the top-part is all zeros). 2760 // Further this conversion is often much more expensive for typical hardware, 2761 // and causes issues when building libgcc. We disallow fptosi+sext for the 2762 // same reason. 2763 const unsigned numCastOps = 2764 Instruction::CastOpsEnd - Instruction::CastOpsBegin; 2765 static const uint8_t CastResults[numCastOps][numCastOps] = { 2766 // T F F U S F F P I B A -+ 2767 // R Z S P P I I T P 2 N T S | 2768 // U E E 2 2 2 2 R E I T C C +- secondOp 2769 // N X X U S F F N X N 2 V V | 2770 // C T T I I P P C T T P T T -+ 2771 { 1, 0, 0,99,99, 0, 0,99,99,99, 0, 3, 0}, // Trunc -+ 2772 { 8, 1, 9,99,99, 2,17,99,99,99, 2, 3, 0}, // ZExt | 2773 { 8, 0, 1,99,99, 0, 2,99,99,99, 0, 3, 0}, // SExt | 2774 { 0, 0, 0,99,99, 0, 0,99,99,99, 0, 3, 0}, // FPToUI | 2775 { 0, 0, 0,99,99, 0, 0,99,99,99, 0, 3, 0}, // FPToSI | 2776 { 99,99,99, 0, 0,99,99, 0, 0,99,99, 4, 0}, // UIToFP +- firstOp 2777 { 99,99,99, 0, 0,99,99, 0, 0,99,99, 4, 0}, // SIToFP | 2778 { 99,99,99, 0, 0,99,99, 0, 0,99,99, 4, 0}, // FPTrunc | 2779 { 99,99,99, 2, 2,99,99, 8, 2,99,99, 4, 0}, // FPExt | 2780 { 1, 0, 0,99,99, 0, 0,99,99,99, 7, 3, 0}, // PtrToInt | 2781 { 99,99,99,99,99,99,99,99,99,11,99,15, 0}, // IntToPtr | 2782 { 5, 5, 5, 6, 6, 5, 5, 6, 6,16, 5, 1,14}, // BitCast | 2783 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,13,12}, // AddrSpaceCast -+ 2784 }; 2785 2786 // TODO: This logic could be encoded into the table above and handled in the 2787 // switch below. 2788 // If either of the casts are a bitcast from scalar to vector, disallow the 2789 // merging. However, any pair of bitcasts are allowed. 2790 bool IsFirstBitcast = (firstOp == Instruction::BitCast); 2791 bool IsSecondBitcast = (secondOp == Instruction::BitCast); 2792 bool AreBothBitcasts = IsFirstBitcast && IsSecondBitcast; 2793 2794 // Check if any of the casts convert scalars <-> vectors. 2795 if ((IsFirstBitcast && isa<VectorType>(SrcTy) != isa<VectorType>(MidTy)) || 2796 (IsSecondBitcast && isa<VectorType>(MidTy) != isa<VectorType>(DstTy))) 2797 if (!AreBothBitcasts) 2798 return 0; 2799 2800 int ElimCase = CastResults[firstOp-Instruction::CastOpsBegin] 2801 [secondOp-Instruction::CastOpsBegin]; 2802 switch (ElimCase) { 2803 case 0: 2804 // Categorically disallowed. 2805 return 0; 2806 case 1: 2807 // Allowed, use first cast's opcode. 2808 return firstOp; 2809 case 2: 2810 // Allowed, use second cast's opcode. 2811 return secondOp; 2812 case 3: 2813 // No-op cast in second op implies firstOp as long as the DestTy 2814 // is integer and we are not converting between a vector and a 2815 // non-vector type. 2816 if (!SrcTy->isVectorTy() && DstTy->isIntegerTy()) 2817 return firstOp; 2818 return 0; 2819 case 4: 2820 // No-op cast in second op implies firstOp as long as the DestTy 2821 // is floating point. 2822 if (DstTy->isFloatingPointTy()) 2823 return firstOp; 2824 return 0; 2825 case 5: 2826 // No-op cast in first op implies secondOp as long as the SrcTy 2827 // is an integer. 2828 if (SrcTy->isIntegerTy()) 2829 return secondOp; 2830 return 0; 2831 case 6: 2832 // No-op cast in first op implies secondOp as long as the SrcTy 2833 // is a floating point. 2834 if (SrcTy->isFloatingPointTy()) 2835 return secondOp; 2836 return 0; 2837 case 7: { 2838 // Cannot simplify if address spaces are different! 2839 if (SrcTy->getPointerAddressSpace() != DstTy->getPointerAddressSpace()) 2840 return 0; 2841 2842 unsigned MidSize = MidTy->getScalarSizeInBits(); 2843 // We can still fold this without knowing the actual sizes as long we 2844 // know that the intermediate pointer is the largest possible 2845 // pointer size. 2846 // FIXME: Is this always true? 2847 if (MidSize == 64) 2848 return Instruction::BitCast; 2849 2850 // ptrtoint, inttoptr -> bitcast (ptr -> ptr) if int size is >= ptr size. 2851 if (!SrcIntPtrTy || DstIntPtrTy != SrcIntPtrTy) 2852 return 0; 2853 unsigned PtrSize = SrcIntPtrTy->getScalarSizeInBits(); 2854 if (MidSize >= PtrSize) 2855 return Instruction::BitCast; 2856 return 0; 2857 } 2858 case 8: { 2859 // ext, trunc -> bitcast, if the SrcTy and DstTy are same size 2860 // ext, trunc -> ext, if sizeof(SrcTy) < sizeof(DstTy) 2861 // ext, trunc -> trunc, if sizeof(SrcTy) > sizeof(DstTy) 2862 unsigned SrcSize = SrcTy->getScalarSizeInBits(); 2863 unsigned DstSize = DstTy->getScalarSizeInBits(); 2864 if (SrcSize == DstSize) 2865 return Instruction::BitCast; 2866 else if (SrcSize < DstSize) 2867 return firstOp; 2868 return secondOp; 2869 } 2870 case 9: 2871 // zext, sext -> zext, because sext can't sign extend after zext 2872 return Instruction::ZExt; 2873 case 11: { 2874 // inttoptr, ptrtoint -> bitcast if SrcSize<=PtrSize and SrcSize==DstSize 2875 if (!MidIntPtrTy) 2876 return 0; 2877 unsigned PtrSize = MidIntPtrTy->getScalarSizeInBits(); 2878 unsigned SrcSize = SrcTy->getScalarSizeInBits(); 2879 unsigned DstSize = DstTy->getScalarSizeInBits(); 2880 if (SrcSize <= PtrSize && SrcSize == DstSize) 2881 return Instruction::BitCast; 2882 return 0; 2883 } 2884 case 12: 2885 // addrspacecast, addrspacecast -> bitcast, if SrcAS == DstAS 2886 // addrspacecast, addrspacecast -> addrspacecast, if SrcAS != DstAS 2887 if (SrcTy->getPointerAddressSpace() != DstTy->getPointerAddressSpace()) 2888 return Instruction::AddrSpaceCast; 2889 return Instruction::BitCast; 2890 case 13: 2891 // FIXME: this state can be merged with (1), but the following assert 2892 // is useful to check the correcteness of the sequence due to semantic 2893 // change of bitcast. 2894 assert( 2895 SrcTy->isPtrOrPtrVectorTy() && 2896 MidTy->isPtrOrPtrVectorTy() && 2897 DstTy->isPtrOrPtrVectorTy() && 2898 SrcTy->getPointerAddressSpace() != MidTy->getPointerAddressSpace() && 2899 MidTy->getPointerAddressSpace() == DstTy->getPointerAddressSpace() && 2900 "Illegal addrspacecast, bitcast sequence!"); 2901 // Allowed, use first cast's opcode 2902 return firstOp; 2903 case 14: 2904 // bitcast, addrspacecast -> addrspacecast if the element type of 2905 // bitcast's source is the same as that of addrspacecast's destination. 2906 if (SrcTy->getScalarType()->getPointerElementType() == 2907 DstTy->getScalarType()->getPointerElementType()) 2908 return Instruction::AddrSpaceCast; 2909 return 0; 2910 case 15: 2911 // FIXME: this state can be merged with (1), but the following assert 2912 // is useful to check the correcteness of the sequence due to semantic 2913 // change of bitcast. 2914 assert( 2915 SrcTy->isIntOrIntVectorTy() && 2916 MidTy->isPtrOrPtrVectorTy() && 2917 DstTy->isPtrOrPtrVectorTy() && 2918 MidTy->getPointerAddressSpace() == DstTy->getPointerAddressSpace() && 2919 "Illegal inttoptr, bitcast sequence!"); 2920 // Allowed, use first cast's opcode 2921 return firstOp; 2922 case 16: 2923 // FIXME: this state can be merged with (2), but the following assert 2924 // is useful to check the correcteness of the sequence due to semantic 2925 // change of bitcast. 2926 assert( 2927 SrcTy->isPtrOrPtrVectorTy() && 2928 MidTy->isPtrOrPtrVectorTy() && 2929 DstTy->isIntOrIntVectorTy() && 2930 SrcTy->getPointerAddressSpace() == MidTy->getPointerAddressSpace() && 2931 "Illegal bitcast, ptrtoint sequence!"); 2932 // Allowed, use second cast's opcode 2933 return secondOp; 2934 case 17: 2935 // (sitofp (zext x)) -> (uitofp x) 2936 return Instruction::UIToFP; 2937 case 99: 2938 // Cast combination can't happen (error in input). This is for all cases 2939 // where the MidTy is not the same for the two cast instructions. 2940 llvm_unreachable("Invalid Cast Combination"); 2941 default: 2942 llvm_unreachable("Error in CastResults table!!!"); 2943 } 2944} 2945 2946CastInst *CastInst::Create(Instruction::CastOps op, Value *S, Type *Ty, 2947 const Twine &Name, Instruction *InsertBefore) { 2948 assert(castIsValid(op, S, Ty) && "Invalid cast!"); 2949 // Construct and return the appropriate CastInst subclass 2950 switch (op) { 2951 case Trunc: return new TruncInst (S, Ty, Name, InsertBefore); 2952 case ZExt: return new ZExtInst (S, Ty, Name, InsertBefore); 2953 case SExt: return new SExtInst (S, Ty, Name, InsertBefore); 2954 case FPTrunc: return new FPTruncInst (S, Ty, Name, InsertBefore); 2955 case FPExt: return new FPExtInst (S, Ty, Name, InsertBefore); 2956 case UIToFP: return new UIToFPInst (S, Ty, Name, InsertBefore); 2957 case SIToFP: return new SIToFPInst (S, Ty, Name, InsertBefore); 2958 case FPToUI: return new FPToUIInst (S, Ty, Name, InsertBefore); 2959 case FPToSI: return new FPToSIInst (S, Ty, Name, InsertBefore); 2960 case PtrToInt: return new PtrToIntInst (S, Ty, Name, InsertBefore); 2961 case IntToPtr: return new IntToPtrInst (S, Ty, Name, InsertBefore); 2962 case BitCast: return new BitCastInst (S, Ty, Name, InsertBefore); 2963 case AddrSpaceCast: return new AddrSpaceCastInst (S, Ty, Name, InsertBefore); 2964 default: llvm_unreachable("Invalid opcode provided"); 2965 } 2966} 2967 2968CastInst *CastInst::Create(Instruction::CastOps op, Value *S, Type *Ty, 2969 const Twine &Name, BasicBlock *InsertAtEnd) { 2970 assert(castIsValid(op, S, Ty) && "Invalid cast!"); 2971 // Construct and return the appropriate CastInst subclass 2972 switch (op) { 2973 case Trunc: return new TruncInst (S, Ty, Name, InsertAtEnd); 2974 case ZExt: return new ZExtInst (S, Ty, Name, InsertAtEnd); 2975 case SExt: return new SExtInst (S, Ty, Name, InsertAtEnd); 2976 case FPTrunc: return new FPTruncInst (S, Ty, Name, InsertAtEnd); 2977 case FPExt: return new FPExtInst (S, Ty, Name, InsertAtEnd); 2978 case UIToFP: return new UIToFPInst (S, Ty, Name, InsertAtEnd); 2979 case SIToFP: return new SIToFPInst (S, Ty, Name, InsertAtEnd); 2980 case FPToUI: return new FPToUIInst (S, Ty, Name, InsertAtEnd); 2981 case FPToSI: return new FPToSIInst (S, Ty, Name, InsertAtEnd); 2982 case PtrToInt: return new PtrToIntInst (S, Ty, Name, InsertAtEnd); 2983 case IntToPtr: return new IntToPtrInst (S, Ty, Name, InsertAtEnd); 2984 case BitCast: return new BitCastInst (S, Ty, Name, InsertAtEnd); 2985 case AddrSpaceCast: return new AddrSpaceCastInst (S, Ty, Name, InsertAtEnd); 2986 default: llvm_unreachable("Invalid opcode provided"); 2987 } 2988} 2989 2990CastInst *CastInst::CreateZExtOrBitCast(Value *S, Type *Ty, 2991 const Twine &Name, 2992 Instruction *InsertBefore) { 2993 if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) 2994 return Create(Instruction::BitCast, S, Ty, Name, InsertBefore); 2995 return Create(Instruction::ZExt, S, Ty, Name, InsertBefore); 2996} 2997 2998CastInst *CastInst::CreateZExtOrBitCast(Value *S, Type *Ty, 2999 const Twine &Name, 3000 BasicBlock *InsertAtEnd) { 3001 if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) 3002 return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd); 3003 return Create(Instruction::ZExt, S, Ty, Name, InsertAtEnd); 3004} 3005 3006CastInst *CastInst::CreateSExtOrBitCast(Value *S, Type *Ty, 3007 const Twine &Name, 3008 Instruction *InsertBefore) { 3009 if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) 3010 return Create(Instruction::BitCast, S, Ty, Name, InsertBefore); 3011 return Create(Instruction::SExt, S, Ty, Name, InsertBefore); 3012} 3013 3014CastInst *CastInst::CreateSExtOrBitCast(Value *S, Type *Ty, 3015 const Twine &Name, 3016 BasicBlock *InsertAtEnd) { 3017 if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) 3018 return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd); 3019 return Create(Instruction::SExt, S, Ty, Name, InsertAtEnd); 3020} 3021 3022CastInst *CastInst::CreateTruncOrBitCast(Value *S, Type *Ty, 3023 const Twine &Name, 3024 Instruction *InsertBefore) { 3025 if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) 3026 return Create(Instruction::BitCast, S, Ty, Name, InsertBefore); 3027 return Create(Instruction::Trunc, S, Ty, Name, InsertBefore); 3028} 3029 3030CastInst *CastInst::CreateTruncOrBitCast(Value *S, Type *Ty, 3031 const Twine &Name, 3032 BasicBlock *InsertAtEnd) { 3033 if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) 3034 return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd); 3035 return Create(Instruction::Trunc, S, Ty, Name, InsertAtEnd); 3036} 3037 3038CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty, 3039 const Twine &Name, 3040 BasicBlock *InsertAtEnd) { 3041 assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast"); 3042 assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) && 3043 "Invalid cast"); 3044 assert(Ty->isVectorTy() == S->getType()->isVectorTy() && "Invalid cast"); 3045 assert((!Ty->isVectorTy() || 3046 cast<VectorType>(Ty)->getElementCount() == 3047 cast<VectorType>(S->getType())->getElementCount()) && 3048 "Invalid cast"); 3049 3050 if (Ty->isIntOrIntVectorTy()) 3051 return Create(Instruction::PtrToInt, S, Ty, Name, InsertAtEnd); 3052 3053 return CreatePointerBitCastOrAddrSpaceCast(S, Ty, Name, InsertAtEnd); 3054} 3055 3056/// Create a BitCast or a PtrToInt cast instruction 3057CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty, 3058 const Twine &Name, 3059 Instruction *InsertBefore) { 3060 assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast"); 3061 assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) && 3062 "Invalid cast"); 3063 assert(Ty->isVectorTy() == S->getType()->isVectorTy() && "Invalid cast"); 3064 assert((!Ty->isVectorTy() || 3065 cast<VectorType>(Ty)->getElementCount() == 3066 cast<VectorType>(S->getType())->getElementCount()) && 3067 "Invalid cast"); 3068 3069 if (Ty->isIntOrIntVectorTy()) 3070 return Create(Instruction::PtrToInt, S, Ty, Name, InsertBefore); 3071 3072 return CreatePointerBitCastOrAddrSpaceCast(S, Ty, Name, InsertBefore); 3073} 3074 3075CastInst *CastInst::CreatePointerBitCastOrAddrSpaceCast( 3076 Value *S, Type *Ty, 3077 const Twine &Name, 3078 BasicBlock *InsertAtEnd) { 3079 assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast"); 3080 assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast"); 3081 3082 if (S->getType()->getPointerAddressSpace() != Ty->getPointerAddressSpace()) 3083 return Create(Instruction::AddrSpaceCast, S, Ty, Name, InsertAtEnd); 3084 3085 return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd); 3086} 3087 3088CastInst *CastInst::CreatePointerBitCastOrAddrSpaceCast( 3089 Value *S, Type *Ty, 3090 const Twine &Name, 3091 Instruction *InsertBefore) { 3092 assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast"); 3093 assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast"); 3094 3095 if (S->getType()->getPointerAddressSpace() != Ty->getPointerAddressSpace()) 3096 return Create(Instruction::AddrSpaceCast, S, Ty, Name, InsertBefore); 3097 3098 return Create(Instruction::BitCast, S, Ty, Name, InsertBefore); 3099} 3100 3101CastInst *CastInst::CreateBitOrPointerCast(Value *S, Type *Ty, 3102 const Twine &Name, 3103 Instruction *InsertBefore) { 3104 if (S->getType()->isPointerTy() && Ty->isIntegerTy()) 3105 return Create(Instruction::PtrToInt, S, Ty, Name, InsertBefore); 3106 if (S->getType()->isIntegerTy() && Ty->isPointerTy()) 3107 return Create(Instruction::IntToPtr, S, Ty, Name, InsertBefore); 3108 3109 return Create(Instruction::BitCast, S, Ty, Name, InsertBefore); 3110} 3111 3112CastInst *CastInst::CreateIntegerCast(Value *C, Type *Ty, 3113 bool isSigned, const Twine &Name, 3114 Instruction *InsertBefore) { 3115 assert(C->getType()->isIntOrIntVectorTy() && Ty->isIntOrIntVectorTy() && 3116 "Invalid integer cast"); 3117 unsigned SrcBits = C->getType()->getScalarSizeInBits(); 3118 unsigned DstBits = Ty->getScalarSizeInBits(); 3119 Instruction::CastOps opcode = 3120 (SrcBits == DstBits ? Instruction::BitCast : 3121 (SrcBits > DstBits ? Instruction::Trunc : 3122 (isSigned ? Instruction::SExt : Instruction::ZExt))); 3123 return Create(opcode, C, Ty, Name, InsertBefore); 3124} 3125 3126CastInst *CastInst::CreateIntegerCast(Value *C, Type *Ty, 3127 bool isSigned, const Twine &Name, 3128 BasicBlock *InsertAtEnd) { 3129 assert(C->getType()->isIntOrIntVectorTy() && Ty->isIntOrIntVectorTy() && 3130 "Invalid cast"); 3131 unsigned SrcBits = C->getType()->getScalarSizeInBits(); 3132 unsigned DstBits = Ty->getScalarSizeInBits(); 3133 Instruction::CastOps opcode = 3134 (SrcBits == DstBits ? Instruction::BitCast : 3135 (SrcBits > DstBits ? Instruction::Trunc : 3136 (isSigned ? Instruction::SExt : Instruction::ZExt))); 3137 return Create(opcode, C, Ty, Name, InsertAtEnd); 3138} 3139 3140CastInst *CastInst::CreateFPCast(Value *C, Type *Ty, 3141 const Twine &Name, 3142 Instruction *InsertBefore) { 3143 assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() && 3144 "Invalid cast"); 3145 unsigned SrcBits = C->getType()->getScalarSizeInBits(); 3146 unsigned DstBits = Ty->getScalarSizeInBits(); 3147 Instruction::CastOps opcode = 3148 (SrcBits == DstBits ? Instruction::BitCast : 3149 (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt)); 3150 return Create(opcode, C, Ty, Name, InsertBefore); 3151} 3152 3153CastInst *CastInst::CreateFPCast(Value *C, Type *Ty, 3154 const Twine &Name, 3155 BasicBlock *InsertAtEnd) { 3156 assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() && 3157 "Invalid cast"); 3158 unsigned SrcBits = C->getType()->getScalarSizeInBits(); 3159 unsigned DstBits = Ty->getScalarSizeInBits(); 3160 Instruction::CastOps opcode = 3161 (SrcBits == DstBits ? Instruction::BitCast : 3162 (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt)); 3163 return Create(opcode, C, Ty, Name, InsertAtEnd); 3164} 3165 3166bool CastInst::isBitCastable(Type *SrcTy, Type *DestTy) { 3167 if (!SrcTy->isFirstClassType() || !DestTy->isFirstClassType()) 3168 return false; 3169 3170 if (SrcTy == DestTy) 3171 return true; 3172 3173 if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy)) { 3174 if (VectorType *DestVecTy = dyn_cast<VectorType>(DestTy)) { 3175 if (SrcVecTy->getElementCount() == DestVecTy->getElementCount()) { 3176 // An element by element cast. Valid if casting the elements is valid. 3177 SrcTy = SrcVecTy->getElementType(); 3178 DestTy = DestVecTy->getElementType(); 3179 } 3180 } 3181 } 3182 3183 if (PointerType *DestPtrTy = dyn_cast<PointerType>(DestTy)) { 3184 if (PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy)) { 3185 return SrcPtrTy->getAddressSpace() == DestPtrTy->getAddressSpace(); 3186 } 3187 } 3188 3189 TypeSize SrcBits = SrcTy->getPrimitiveSizeInBits(); // 0 for ptr 3190 TypeSize DestBits = DestTy->getPrimitiveSizeInBits(); // 0 for ptr 3191 3192 // Could still have vectors of pointers if the number of elements doesn't 3193 // match 3194 if (SrcBits.getKnownMinSize() == 0 || DestBits.getKnownMinSize() == 0) 3195 return false; 3196 3197 if (SrcBits != DestBits) 3198 return false; 3199 3200 if (DestTy->isX86_MMXTy() || SrcTy->isX86_MMXTy()) 3201 return false; 3202 3203 return true; 3204} 3205 3206bool CastInst::isBitOrNoopPointerCastable(Type *SrcTy, Type *DestTy, 3207 const DataLayout &DL) { 3208 // ptrtoint and inttoptr are not allowed on non-integral pointers 3209 if (auto *PtrTy = dyn_cast<PointerType>(SrcTy)) 3210 if (auto *IntTy = dyn_cast<IntegerType>(DestTy)) 3211 return (IntTy->getBitWidth() == DL.getPointerTypeSizeInBits(PtrTy) && 3212 !DL.isNonIntegralPointerType(PtrTy)); 3213 if (auto *PtrTy = dyn_cast<PointerType>(DestTy)) 3214 if (auto *IntTy = dyn_cast<IntegerType>(SrcTy)) 3215 return (IntTy->getBitWidth() == DL.getPointerTypeSizeInBits(PtrTy) && 3216 !DL.isNonIntegralPointerType(PtrTy)); 3217 3218 return isBitCastable(SrcTy, DestTy); 3219} 3220 3221// Provide a way to get a "cast" where the cast opcode is inferred from the 3222// types and size of the operand. This, basically, is a parallel of the 3223// logic in the castIsValid function below. This axiom should hold: 3224// castIsValid( getCastOpcode(Val, Ty), Val, Ty) 3225// should not assert in castIsValid. In other words, this produces a "correct" 3226// casting opcode for the arguments passed to it. 3227Instruction::CastOps 3228CastInst::getCastOpcode( 3229 const Value *Src, bool SrcIsSigned, Type *DestTy, bool DestIsSigned) { 3230 Type *SrcTy = Src->getType(); 3231 3232 assert(SrcTy->isFirstClassType() && DestTy->isFirstClassType() && 3233 "Only first class types are castable!"); 3234 3235 if (SrcTy == DestTy) 3236 return BitCast; 3237 3238 // FIXME: Check address space sizes here 3239 if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy)) 3240 if (VectorType *DestVecTy = dyn_cast<VectorType>(DestTy)) 3241 if (SrcVecTy->getElementCount() == DestVecTy->getElementCount()) { 3242 // An element by element cast. Find the appropriate opcode based on the 3243 // element types. 3244 SrcTy = SrcVecTy->getElementType(); 3245 DestTy = DestVecTy->getElementType(); 3246 } 3247 3248 // Get the bit sizes, we'll need these 3249 unsigned SrcBits = SrcTy->getPrimitiveSizeInBits(); // 0 for ptr 3250 unsigned DestBits = DestTy->getPrimitiveSizeInBits(); // 0 for ptr 3251 3252 // Run through the possibilities ... 3253 if (DestTy->isIntegerTy()) { // Casting to integral 3254 if (SrcTy->isIntegerTy()) { // Casting from integral 3255 if (DestBits < SrcBits) 3256 return Trunc; // int -> smaller int 3257 else if (DestBits > SrcBits) { // its an extension 3258 if (SrcIsSigned) 3259 return SExt; // signed -> SEXT 3260 else 3261 return ZExt; // unsigned -> ZEXT 3262 } else { 3263 return BitCast; // Same size, No-op cast 3264 } 3265 } else if (SrcTy->isFloatingPointTy()) { // Casting from floating pt 3266 if (DestIsSigned) 3267 return FPToSI; // FP -> sint 3268 else 3269 return FPToUI; // FP -> uint 3270 } else if (SrcTy->isVectorTy()) { 3271 assert(DestBits == SrcBits && 3272 "Casting vector to integer of different width"); 3273 return BitCast; // Same size, no-op cast 3274 } else { 3275 assert(SrcTy->isPointerTy() && 3276 "Casting from a value that is not first-class type"); 3277 return PtrToInt; // ptr -> int 3278 } 3279 } else if (DestTy->isFloatingPointTy()) { // Casting to floating pt 3280 if (SrcTy->isIntegerTy()) { // Casting from integral 3281 if (SrcIsSigned) 3282 return SIToFP; // sint -> FP 3283 else 3284 return UIToFP; // uint -> FP 3285 } else if (SrcTy->isFloatingPointTy()) { // Casting from floating pt 3286 if (DestBits < SrcBits) { 3287 return FPTrunc; // FP -> smaller FP 3288 } else if (DestBits > SrcBits) { 3289 return FPExt; // FP -> larger FP 3290 } else { 3291 return BitCast; // same size, no-op cast 3292 } 3293 } else if (SrcTy->isVectorTy()) { 3294 assert(DestBits == SrcBits && 3295 "Casting vector to floating point of different width"); 3296 return BitCast; // same size, no-op cast 3297 } 3298 llvm_unreachable("Casting pointer or non-first class to float"); 3299 } else if (DestTy->isVectorTy()) { 3300 assert(DestBits == SrcBits && 3301 "Illegal cast to vector (wrong type or size)"); 3302 return BitCast; 3303 } else if (DestTy->isPointerTy()) { 3304 if (SrcTy->isPointerTy()) { 3305 if (DestTy->getPointerAddressSpace() != SrcTy->getPointerAddressSpace()) 3306 return AddrSpaceCast; 3307 return BitCast; // ptr -> ptr 3308 } else if (SrcTy->isIntegerTy()) { 3309 return IntToPtr; // int -> ptr 3310 } 3311 llvm_unreachable("Casting pointer to other than pointer or int"); 3312 } else if (DestTy->isX86_MMXTy()) { 3313 if (SrcTy->isVectorTy()) { 3314 assert(DestBits == SrcBits && "Casting vector of wrong width to X86_MMX"); 3315 return BitCast; // 64-bit vector to MMX 3316 } 3317 llvm_unreachable("Illegal cast to X86_MMX"); 3318 } 3319 llvm_unreachable("Casting to type that is not first-class"); 3320} 3321 3322//===----------------------------------------------------------------------===// 3323// CastInst SubClass Constructors 3324//===----------------------------------------------------------------------===// 3325 3326/// Check that the construction parameters for a CastInst are correct. This 3327/// could be broken out into the separate constructors but it is useful to have 3328/// it in one place and to eliminate the redundant code for getting the sizes 3329/// of the types involved. 3330bool 3331CastInst::castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy) { 3332 if (!SrcTy->isFirstClassType() || !DstTy->isFirstClassType() || 3333 SrcTy->isAggregateType() || DstTy->isAggregateType()) 3334 return false; 3335 3336 // Get the size of the types in bits, and whether we are dealing 3337 // with vector types, we'll need this later. 3338 bool SrcIsVec = isa<VectorType>(SrcTy); 3339 bool DstIsVec = isa<VectorType>(DstTy); 3340 unsigned SrcScalarBitSize = SrcTy->getScalarSizeInBits(); 3341 unsigned DstScalarBitSize = DstTy->getScalarSizeInBits(); 3342 3343 // If these are vector types, get the lengths of the vectors (using zero for 3344 // scalar types means that checking that vector lengths match also checks that 3345 // scalars are not being converted to vectors or vectors to scalars). 3346 ElementCount SrcEC = SrcIsVec ? cast<VectorType>(SrcTy)->getElementCount() 3347 : ElementCount::getFixed(0); 3348 ElementCount DstEC = DstIsVec ? cast<VectorType>(DstTy)->getElementCount() 3349 : ElementCount::getFixed(0); 3350 3351 // Switch on the opcode provided 3352 switch (op) { 3353 default: return false; // This is an input error 3354 case Instruction::Trunc: 3355 return SrcTy->isIntOrIntVectorTy() && DstTy->isIntOrIntVectorTy() && 3356 SrcEC == DstEC && SrcScalarBitSize > DstScalarBitSize; 3357 case Instruction::ZExt: 3358 return SrcTy->isIntOrIntVectorTy() && DstTy->isIntOrIntVectorTy() && 3359 SrcEC == DstEC && SrcScalarBitSize < DstScalarBitSize; 3360 case Instruction::SExt: 3361 return SrcTy->isIntOrIntVectorTy() && DstTy->isIntOrIntVectorTy() && 3362 SrcEC == DstEC && SrcScalarBitSize < DstScalarBitSize; 3363 case Instruction::FPTrunc: 3364 return SrcTy->isFPOrFPVectorTy() && DstTy->isFPOrFPVectorTy() && 3365 SrcEC == DstEC && SrcScalarBitSize > DstScalarBitSize; 3366 case Instruction::FPExt: 3367 return SrcTy->isFPOrFPVectorTy() && DstTy->isFPOrFPVectorTy() && 3368 SrcEC == DstEC && SrcScalarBitSize < DstScalarBitSize; 3369 case Instruction::UIToFP: 3370 case Instruction::SIToFP: 3371 return SrcTy->isIntOrIntVectorTy() && DstTy->isFPOrFPVectorTy() && 3372 SrcEC == DstEC; 3373 case Instruction::FPToUI: 3374 case Instruction::FPToSI: 3375 return SrcTy->isFPOrFPVectorTy() && DstTy->isIntOrIntVectorTy() && 3376 SrcEC == DstEC; 3377 case Instruction::PtrToInt: 3378 if (SrcEC != DstEC) 3379 return false; 3380 return SrcTy->isPtrOrPtrVectorTy() && DstTy->isIntOrIntVectorTy(); 3381 case Instruction::IntToPtr: 3382 if (SrcEC != DstEC) 3383 return false; 3384 return SrcTy->isIntOrIntVectorTy() && DstTy->isPtrOrPtrVectorTy(); 3385 case Instruction::BitCast: { 3386 PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy->getScalarType()); 3387 PointerType *DstPtrTy = dyn_cast<PointerType>(DstTy->getScalarType()); 3388 3389 // BitCast implies a no-op cast of type only. No bits change. 3390 // However, you can't cast pointers to anything but pointers. 3391 if (!SrcPtrTy != !DstPtrTy) 3392 return false; 3393 3394 // For non-pointer cases, the cast is okay if the source and destination bit 3395 // widths are identical. 3396 if (!SrcPtrTy) 3397 return SrcTy->getPrimitiveSizeInBits() == DstTy->getPrimitiveSizeInBits(); 3398 3399 // If both are pointers then the address spaces must match. 3400 if (SrcPtrTy->getAddressSpace() != DstPtrTy->getAddressSpace()) 3401 return false; 3402 3403 // A vector of pointers must have the same number of elements. 3404 if (SrcIsVec && DstIsVec) 3405 return SrcEC == DstEC; 3406 if (SrcIsVec) 3407 return SrcEC == ElementCount::getFixed(1); 3408 if (DstIsVec) 3409 return DstEC == ElementCount::getFixed(1); 3410 3411 return true; 3412 } 3413 case Instruction::AddrSpaceCast: { 3414 PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy->getScalarType()); 3415 if (!SrcPtrTy) 3416 return false; 3417 3418 PointerType *DstPtrTy = dyn_cast<PointerType>(DstTy->getScalarType()); 3419 if (!DstPtrTy) 3420 return false; 3421 3422 if (SrcPtrTy->getAddressSpace() == DstPtrTy->getAddressSpace()) 3423 return false; 3424 3425 return SrcEC == DstEC; 3426 } 3427 } 3428} 3429 3430TruncInst::TruncInst( 3431 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3432) : CastInst(Ty, Trunc, S, Name, InsertBefore) { 3433 assert(castIsValid(getOpcode(), S, Ty) && "Illegal Trunc"); 3434} 3435 3436TruncInst::TruncInst( 3437 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3438) : CastInst(Ty, Trunc, S, Name, InsertAtEnd) { 3439 assert(castIsValid(getOpcode(), S, Ty) && "Illegal Trunc"); 3440} 3441 3442ZExtInst::ZExtInst( 3443 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3444) : CastInst(Ty, ZExt, S, Name, InsertBefore) { 3445 assert(castIsValid(getOpcode(), S, Ty) && "Illegal ZExt"); 3446} 3447 3448ZExtInst::ZExtInst( 3449 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3450) : CastInst(Ty, ZExt, S, Name, InsertAtEnd) { 3451 assert(castIsValid(getOpcode(), S, Ty) && "Illegal ZExt"); 3452} 3453SExtInst::SExtInst( 3454 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3455) : CastInst(Ty, SExt, S, Name, InsertBefore) { 3456 assert(castIsValid(getOpcode(), S, Ty) && "Illegal SExt"); 3457} 3458 3459SExtInst::SExtInst( 3460 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3461) : CastInst(Ty, SExt, S, Name, InsertAtEnd) { 3462 assert(castIsValid(getOpcode(), S, Ty) && "Illegal SExt"); 3463} 3464 3465FPTruncInst::FPTruncInst( 3466 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3467) : CastInst(Ty, FPTrunc, S, Name, InsertBefore) { 3468 assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPTrunc"); 3469} 3470 3471FPTruncInst::FPTruncInst( 3472 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3473) : CastInst(Ty, FPTrunc, S, Name, InsertAtEnd) { 3474 assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPTrunc"); 3475} 3476 3477FPExtInst::FPExtInst( 3478 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3479) : CastInst(Ty, FPExt, S, Name, InsertBefore) { 3480 assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPExt"); 3481} 3482 3483FPExtInst::FPExtInst( 3484 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3485) : CastInst(Ty, FPExt, S, Name, InsertAtEnd) { 3486 assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPExt"); 3487} 3488 3489UIToFPInst::UIToFPInst( 3490 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3491) : CastInst(Ty, UIToFP, S, Name, InsertBefore) { 3492 assert(castIsValid(getOpcode(), S, Ty) && "Illegal UIToFP"); 3493} 3494 3495UIToFPInst::UIToFPInst( 3496 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3497) : CastInst(Ty, UIToFP, S, Name, InsertAtEnd) { 3498 assert(castIsValid(getOpcode(), S, Ty) && "Illegal UIToFP"); 3499} 3500 3501SIToFPInst::SIToFPInst( 3502 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3503) : CastInst(Ty, SIToFP, S, Name, InsertBefore) { 3504 assert(castIsValid(getOpcode(), S, Ty) && "Illegal SIToFP"); 3505} 3506 3507SIToFPInst::SIToFPInst( 3508 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3509) : CastInst(Ty, SIToFP, S, Name, InsertAtEnd) { 3510 assert(castIsValid(getOpcode(), S, Ty) && "Illegal SIToFP"); 3511} 3512 3513FPToUIInst::FPToUIInst( 3514 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3515) : CastInst(Ty, FPToUI, S, Name, InsertBefore) { 3516 assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToUI"); 3517} 3518 3519FPToUIInst::FPToUIInst( 3520 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3521) : CastInst(Ty, FPToUI, S, Name, InsertAtEnd) { 3522 assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToUI"); 3523} 3524 3525FPToSIInst::FPToSIInst( 3526 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3527) : CastInst(Ty, FPToSI, S, Name, InsertBefore) { 3528 assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToSI"); 3529} 3530 3531FPToSIInst::FPToSIInst( 3532 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3533) : CastInst(Ty, FPToSI, S, Name, InsertAtEnd) { 3534 assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToSI"); 3535} 3536 3537PtrToIntInst::PtrToIntInst( 3538 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3539) : CastInst(Ty, PtrToInt, S, Name, InsertBefore) { 3540 assert(castIsValid(getOpcode(), S, Ty) && "Illegal PtrToInt"); 3541} 3542 3543PtrToIntInst::PtrToIntInst( 3544 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3545) : CastInst(Ty, PtrToInt, S, Name, InsertAtEnd) { 3546 assert(castIsValid(getOpcode(), S, Ty) && "Illegal PtrToInt"); 3547} 3548 3549IntToPtrInst::IntToPtrInst( 3550 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3551) : CastInst(Ty, IntToPtr, S, Name, InsertBefore) { 3552 assert(castIsValid(getOpcode(), S, Ty) && "Illegal IntToPtr"); 3553} 3554 3555IntToPtrInst::IntToPtrInst( 3556 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3557) : CastInst(Ty, IntToPtr, S, Name, InsertAtEnd) { 3558 assert(castIsValid(getOpcode(), S, Ty) && "Illegal IntToPtr"); 3559} 3560 3561BitCastInst::BitCastInst( 3562 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3563) : CastInst(Ty, BitCast, S, Name, InsertBefore) { 3564 assert(castIsValid(getOpcode(), S, Ty) && "Illegal BitCast"); 3565} 3566 3567BitCastInst::BitCastInst( 3568 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3569) : CastInst(Ty, BitCast, S, Name, InsertAtEnd) { 3570 assert(castIsValid(getOpcode(), S, Ty) && "Illegal BitCast"); 3571} 3572 3573AddrSpaceCastInst::AddrSpaceCastInst( 3574 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore 3575) : CastInst(Ty, AddrSpaceCast, S, Name, InsertBefore) { 3576 assert(castIsValid(getOpcode(), S, Ty) && "Illegal AddrSpaceCast"); 3577} 3578 3579AddrSpaceCastInst::AddrSpaceCastInst( 3580 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd 3581) : CastInst(Ty, AddrSpaceCast, S, Name, InsertAtEnd) { 3582 assert(castIsValid(getOpcode(), S, Ty) && "Illegal AddrSpaceCast"); 3583} 3584 3585//===----------------------------------------------------------------------===// 3586// CmpInst Classes 3587//===----------------------------------------------------------------------===// 3588 3589CmpInst::CmpInst(Type *ty, OtherOps op, Predicate predicate, Value *LHS, 3590 Value *RHS, const Twine &Name, Instruction *InsertBefore, 3591 Instruction *FlagsSource) 3592 : Instruction(ty, op, 3593 OperandTraits<CmpInst>::op_begin(this), 3594 OperandTraits<CmpInst>::operands(this), 3595 InsertBefore) { 3596 Op<0>() = LHS; 3597 Op<1>() = RHS; 3598 setPredicate((Predicate)predicate); 3599 setName(Name); 3600 if (FlagsSource) 3601 copyIRFlags(FlagsSource); 3602} 3603 3604CmpInst::CmpInst(Type *ty, OtherOps op, Predicate predicate, Value *LHS, 3605 Value *RHS, const Twine &Name, BasicBlock *InsertAtEnd) 3606 : Instruction(ty, op, 3607 OperandTraits<CmpInst>::op_begin(this), 3608 OperandTraits<CmpInst>::operands(this), 3609 InsertAtEnd) { 3610 Op<0>() = LHS; 3611 Op<1>() = RHS; 3612 setPredicate((Predicate)predicate); 3613 setName(Name); 3614} 3615 3616CmpInst * 3617CmpInst::Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2, 3618 const Twine &Name, Instruction *InsertBefore) { 3619 if (Op == Instruction::ICmp) { 3620 if (InsertBefore) 3621 return new ICmpInst(InsertBefore, CmpInst::Predicate(predicate), 3622 S1, S2, Name); 3623 else 3624 return new ICmpInst(CmpInst::Predicate(predicate), 3625 S1, S2, Name); 3626 } 3627 3628 if (InsertBefore) 3629 return new FCmpInst(InsertBefore, CmpInst::Predicate(predicate), 3630 S1, S2, Name); 3631 else 3632 return new FCmpInst(CmpInst::Predicate(predicate), 3633 S1, S2, Name); 3634} 3635 3636CmpInst * 3637CmpInst::Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2, 3638 const Twine &Name, BasicBlock *InsertAtEnd) { 3639 if (Op == Instruction::ICmp) { 3640 return new ICmpInst(*InsertAtEnd, CmpInst::Predicate(predicate), 3641 S1, S2, Name); 3642 } 3643 return new FCmpInst(*InsertAtEnd, CmpInst::Predicate(predicate), 3644 S1, S2, Name); 3645} 3646 3647void CmpInst::swapOperands() { 3648 if (ICmpInst *IC = dyn_cast<ICmpInst>(this)) 3649 IC->swapOperands(); 3650 else 3651 cast<FCmpInst>(this)->swapOperands(); 3652} 3653 3654bool CmpInst::isCommutative() const { 3655 if (const ICmpInst *IC = dyn_cast<ICmpInst>(this)) 3656 return IC->isCommutative(); 3657 return cast<FCmpInst>(this)->isCommutative(); 3658} 3659 3660bool CmpInst::isEquality(Predicate P) { 3661 if (ICmpInst::isIntPredicate(P)) 3662 return ICmpInst::isEquality(P); 3663 if (FCmpInst::isFPPredicate(P)) 3664 return FCmpInst::isEquality(P); 3665 llvm_unreachable("Unsupported predicate kind"); 3666} 3667 3668CmpInst::Predicate CmpInst::getInversePredicate(Predicate pred) { 3669 switch (pred) { 3670 default: llvm_unreachable("Unknown cmp predicate!"); 3671 case ICMP_EQ: return ICMP_NE; 3672 case ICMP_NE: return ICMP_EQ; 3673 case ICMP_UGT: return ICMP_ULE; 3674 case ICMP_ULT: return ICMP_UGE; 3675 case ICMP_UGE: return ICMP_ULT; 3676 case ICMP_ULE: return ICMP_UGT; 3677 case ICMP_SGT: return ICMP_SLE; 3678 case ICMP_SLT: return ICMP_SGE; 3679 case ICMP_SGE: return ICMP_SLT; 3680 case ICMP_SLE: return ICMP_SGT; 3681 3682 case FCMP_OEQ: return FCMP_UNE; 3683 case FCMP_ONE: return FCMP_UEQ; 3684 case FCMP_OGT: return FCMP_ULE; 3685 case FCMP_OLT: return FCMP_UGE; 3686 case FCMP_OGE: return FCMP_ULT; 3687 case FCMP_OLE: return FCMP_UGT; 3688 case FCMP_UEQ: return FCMP_ONE; 3689 case FCMP_UNE: return FCMP_OEQ; 3690 case FCMP_UGT: return FCMP_OLE; 3691 case FCMP_ULT: return FCMP_OGE; 3692 case FCMP_UGE: return FCMP_OLT; 3693 case FCMP_ULE: return FCMP_OGT; 3694 case FCMP_ORD: return FCMP_UNO; 3695 case FCMP_UNO: return FCMP_ORD; 3696 case FCMP_TRUE: return FCMP_FALSE; 3697 case FCMP_FALSE: return FCMP_TRUE; 3698 } 3699} 3700 3701StringRef CmpInst::getPredicateName(Predicate Pred) { 3702 switch (Pred) { 3703 default: return "unknown"; 3704 case FCmpInst::FCMP_FALSE: return "false"; 3705 case FCmpInst::FCMP_OEQ: return "oeq"; 3706 case FCmpInst::FCMP_OGT: return "ogt"; 3707 case FCmpInst::FCMP_OGE: return "oge"; 3708 case FCmpInst::FCMP_OLT: return "olt"; 3709 case FCmpInst::FCMP_OLE: return "ole"; 3710 case FCmpInst::FCMP_ONE: return "one"; 3711 case FCmpInst::FCMP_ORD: return "ord"; 3712 case FCmpInst::FCMP_UNO: return "uno"; 3713 case FCmpInst::FCMP_UEQ: return "ueq"; 3714 case FCmpInst::FCMP_UGT: return "ugt"; 3715 case FCmpInst::FCMP_UGE: return "uge"; 3716 case FCmpInst::FCMP_ULT: return "ult"; 3717 case FCmpInst::FCMP_ULE: return "ule"; 3718 case FCmpInst::FCMP_UNE: return "une"; 3719 case FCmpInst::FCMP_TRUE: return "true"; 3720 case ICmpInst::ICMP_EQ: return "eq"; 3721 case ICmpInst::ICMP_NE: return "ne"; 3722 case ICmpInst::ICMP_SGT: return "sgt"; 3723 case ICmpInst::ICMP_SGE: return "sge"; 3724 case ICmpInst::ICMP_SLT: return "slt"; 3725 case ICmpInst::ICMP_SLE: return "sle"; 3726 case ICmpInst::ICMP_UGT: return "ugt"; 3727 case ICmpInst::ICMP_UGE: return "uge"; 3728 case ICmpInst::ICMP_ULT: return "ult"; 3729 case ICmpInst::ICMP_ULE: return "ule"; 3730 } 3731} 3732 3733ICmpInst::Predicate ICmpInst::getSignedPredicate(Predicate pred) { 3734 switch (pred) { 3735 default: llvm_unreachable("Unknown icmp predicate!"); 3736 case ICMP_EQ: case ICMP_NE: 3737 case ICMP_SGT: case ICMP_SLT: case ICMP_SGE: case ICMP_SLE: 3738 return pred; 3739 case ICMP_UGT: return ICMP_SGT; 3740 case ICMP_ULT: return ICMP_SLT; 3741 case ICMP_UGE: return ICMP_SGE; 3742 case ICMP_ULE: return ICMP_SLE; 3743 } 3744} 3745 3746ICmpInst::Predicate ICmpInst::getUnsignedPredicate(Predicate pred) { 3747 switch (pred) { 3748 default: llvm_unreachable("Unknown icmp predicate!"); 3749 case ICMP_EQ: case ICMP_NE: 3750 case ICMP_UGT: case ICMP_ULT: case ICMP_UGE: case ICMP_ULE: 3751 return pred; 3752 case ICMP_SGT: return ICMP_UGT; 3753 case ICMP_SLT: return ICMP_ULT; 3754 case ICMP_SGE: return ICMP_UGE; 3755 case ICMP_SLE: return ICMP_ULE; 3756 } 3757} 3758 3759CmpInst::Predicate CmpInst::getSwappedPredicate(Predicate pred) { 3760 switch (pred) { 3761 default: llvm_unreachable("Unknown cmp predicate!"); 3762 case ICMP_EQ: case ICMP_NE: 3763 return pred; 3764 case ICMP_SGT: return ICMP_SLT; 3765 case ICMP_SLT: return ICMP_SGT; 3766 case ICMP_SGE: return ICMP_SLE; 3767 case ICMP_SLE: return ICMP_SGE; 3768 case ICMP_UGT: return ICMP_ULT; 3769 case ICMP_ULT: return ICMP_UGT; 3770 case ICMP_UGE: return ICMP_ULE; 3771 case ICMP_ULE: return ICMP_UGE; 3772 3773 case FCMP_FALSE: case FCMP_TRUE: 3774 case FCMP_OEQ: case FCMP_ONE: 3775 case FCMP_UEQ: case FCMP_UNE: 3776 case FCMP_ORD: case FCMP_UNO: 3777 return pred; 3778 case FCMP_OGT: return FCMP_OLT; 3779 case FCMP_OLT: return FCMP_OGT; 3780 case FCMP_OGE: return FCMP_OLE; 3781 case FCMP_OLE: return FCMP_OGE; 3782 case FCMP_UGT: return FCMP_ULT; 3783 case FCMP_ULT: return FCMP_UGT; 3784 case FCMP_UGE: return FCMP_ULE; 3785 case FCMP_ULE: return FCMP_UGE; 3786 } 3787} 3788 3789bool CmpInst::isNonStrictPredicate(Predicate pred) { 3790 switch (pred) { 3791 case ICMP_SGE: 3792 case ICMP_SLE: 3793 case ICMP_UGE: 3794 case ICMP_ULE: 3795 case FCMP_OGE: 3796 case FCMP_OLE: 3797 case FCMP_UGE: 3798 case FCMP_ULE: 3799 return true; 3800 default: 3801 return false; 3802 } 3803} 3804 3805bool CmpInst::isStrictPredicate(Predicate pred) { 3806 switch (pred) { 3807 case ICMP_SGT: 3808 case ICMP_SLT: 3809 case ICMP_UGT: 3810 case ICMP_ULT: 3811 case FCMP_OGT: 3812 case FCMP_OLT: 3813 case FCMP_UGT: 3814 case FCMP_ULT: 3815 return true; 3816 default: 3817 return false; 3818 } 3819} 3820 3821CmpInst::Predicate CmpInst::getStrictPredicate(Predicate pred) { 3822 switch (pred) { 3823 case ICMP_SGE: 3824 return ICMP_SGT; 3825 case ICMP_SLE: 3826 return ICMP_SLT; 3827 case ICMP_UGE: 3828 return ICMP_UGT; 3829 case ICMP_ULE: 3830 return ICMP_ULT; 3831 case FCMP_OGE: 3832 return FCMP_OGT; 3833 case FCMP_OLE: 3834 return FCMP_OLT; 3835 case FCMP_UGE: 3836 return FCMP_UGT; 3837 case FCMP_ULE: 3838 return FCMP_ULT; 3839 default: 3840 return pred; 3841 } 3842} 3843 3844CmpInst::Predicate CmpInst::getNonStrictPredicate(Predicate pred) { 3845 switch (pred) { 3846 case ICMP_SGT: 3847 return ICMP_SGE; 3848 case ICMP_SLT: 3849 return ICMP_SLE; 3850 case ICMP_UGT: 3851 return ICMP_UGE; 3852 case ICMP_ULT: 3853 return ICMP_ULE; 3854 case FCMP_OGT: 3855 return FCMP_OGE; 3856 case FCMP_OLT: 3857 return FCMP_OLE; 3858 case FCMP_UGT: 3859 return FCMP_UGE; 3860 case FCMP_ULT: 3861 return FCMP_ULE; 3862 default: 3863 return pred; 3864 } 3865} 3866 3867CmpInst::Predicate CmpInst::getFlippedStrictnessPredicate(Predicate pred) { 3868 assert(CmpInst::isRelational(pred) && "Call only with relational predicate!"); 3869 3870 if (isStrictPredicate(pred)) 3871 return getNonStrictPredicate(pred); 3872 if (isNonStrictPredicate(pred)) 3873 return getStrictPredicate(pred); 3874 3875 llvm_unreachable("Unknown predicate!"); 3876} 3877 3878CmpInst::Predicate CmpInst::getSignedPredicate(Predicate pred) { 3879 assert(CmpInst::isUnsigned(pred) && "Call only with unsigned predicates!"); 3880 3881 switch (pred) { 3882 default: 3883 llvm_unreachable("Unknown predicate!"); 3884 case CmpInst::ICMP_ULT: 3885 return CmpInst::ICMP_SLT; 3886 case CmpInst::ICMP_ULE: 3887 return CmpInst::ICMP_SLE; 3888 case CmpInst::ICMP_UGT: 3889 return CmpInst::ICMP_SGT; 3890 case CmpInst::ICMP_UGE: 3891 return CmpInst::ICMP_SGE; 3892 } 3893} 3894 3895CmpInst::Predicate CmpInst::getUnsignedPredicate(Predicate pred) { 3896 assert(CmpInst::isSigned(pred) && "Call only with signed predicates!"); 3897 3898 switch (pred) { 3899 default: 3900 llvm_unreachable("Unknown predicate!"); 3901 case CmpInst::ICMP_SLT: 3902 return CmpInst::ICMP_ULT; 3903 case CmpInst::ICMP_SLE: 3904 return CmpInst::ICMP_ULE; 3905 case CmpInst::ICMP_SGT: 3906 return CmpInst::ICMP_UGT; 3907 case CmpInst::ICMP_SGE: 3908 return CmpInst::ICMP_UGE; 3909 } 3910} 3911 3912bool CmpInst::isUnsigned(Predicate predicate) { 3913 switch (predicate) { 3914 default: return false; 3915 case ICmpInst::ICMP_ULT: case ICmpInst::ICMP_ULE: case ICmpInst::ICMP_UGT: 3916 case ICmpInst::ICMP_UGE: return true; 3917 } 3918} 3919 3920bool CmpInst::isSigned(Predicate predicate) { 3921 switch (predicate) { 3922 default: return false; 3923 case ICmpInst::ICMP_SLT: case ICmpInst::ICMP_SLE: case ICmpInst::ICMP_SGT: 3924 case ICmpInst::ICMP_SGE: return true; 3925 } 3926} 3927 3928CmpInst::Predicate CmpInst::getFlippedSignednessPredicate(Predicate pred) { 3929 assert(CmpInst::isRelational(pred) && 3930 "Call only with non-equality predicates!"); 3931 3932 if (isSigned(pred)) 3933 return getUnsignedPredicate(pred); 3934 if (isUnsigned(pred)) 3935 return getSignedPredicate(pred); 3936 3937 llvm_unreachable("Unknown predicate!"); 3938} 3939 3940bool CmpInst::isOrdered(Predicate predicate) { 3941 switch (predicate) { 3942 default: return false; 3943 case FCmpInst::FCMP_OEQ: case FCmpInst::FCMP_ONE: case FCmpInst::FCMP_OGT: 3944 case FCmpInst::FCMP_OLT: case FCmpInst::FCMP_OGE: case FCmpInst::FCMP_OLE: 3945 case FCmpInst::FCMP_ORD: return true; 3946 } 3947} 3948 3949bool CmpInst::isUnordered(Predicate predicate) { 3950 switch (predicate) { 3951 default: return false; 3952 case FCmpInst::FCMP_UEQ: case FCmpInst::FCMP_UNE: case FCmpInst::FCMP_UGT: 3953 case FCmpInst::FCMP_ULT: case FCmpInst::FCMP_UGE: case FCmpInst::FCMP_ULE: 3954 case FCmpInst::FCMP_UNO: return true; 3955 } 3956} 3957 3958bool CmpInst::isTrueWhenEqual(Predicate predicate) { 3959 switch(predicate) { 3960 default: return false; 3961 case ICMP_EQ: case ICMP_UGE: case ICMP_ULE: case ICMP_SGE: case ICMP_SLE: 3962 case FCMP_TRUE: case FCMP_UEQ: case FCMP_UGE: case FCMP_ULE: return true; 3963 } 3964} 3965 3966bool CmpInst::isFalseWhenEqual(Predicate predicate) { 3967 switch(predicate) { 3968 case ICMP_NE: case ICMP_UGT: case ICMP_ULT: case ICMP_SGT: case ICMP_SLT: 3969 case FCMP_FALSE: case FCMP_ONE: case FCMP_OGT: case FCMP_OLT: return true; 3970 default: return false; 3971 } 3972} 3973 3974bool CmpInst::isImpliedTrueByMatchingCmp(Predicate Pred1, Predicate Pred2) { 3975 // If the predicates match, then we know the first condition implies the 3976 // second is true. 3977 if (Pred1 == Pred2) 3978 return true; 3979 3980 switch (Pred1) { 3981 default: 3982 break; 3983 case ICMP_EQ: 3984 // A == B implies A >=u B, A <=u B, A >=s B, and A <=s B are true. 3985 return Pred2 == ICMP_UGE || Pred2 == ICMP_ULE || Pred2 == ICMP_SGE || 3986 Pred2 == ICMP_SLE; 3987 case ICMP_UGT: // A >u B implies A != B and A >=u B are true. 3988 return Pred2 == ICMP_NE || Pred2 == ICMP_UGE; 3989 case ICMP_ULT: // A <u B implies A != B and A <=u B are true. 3990 return Pred2 == ICMP_NE || Pred2 == ICMP_ULE; 3991 case ICMP_SGT: // A >s B implies A != B and A >=s B are true. 3992 return Pred2 == ICMP_NE || Pred2 == ICMP_SGE; 3993 case ICMP_SLT: // A <s B implies A != B and A <=s B are true. 3994 return Pred2 == ICMP_NE || Pred2 == ICMP_SLE; 3995 } 3996 return false; 3997} 3998 3999bool CmpInst::isImpliedFalseByMatchingCmp(Predicate Pred1, Predicate Pred2) { 4000 return isImpliedTrueByMatchingCmp(Pred1, getInversePredicate(Pred2)); 4001} 4002 4003//===----------------------------------------------------------------------===// 4004// SwitchInst Implementation 4005//===----------------------------------------------------------------------===// 4006 4007void SwitchInst::init(Value *Value, BasicBlock *Default, unsigned NumReserved) { 4008 assert(Value && Default && NumReserved); 4009 ReservedSpace = NumReserved; 4010 setNumHungOffUseOperands(2); 4011 allocHungoffUses(ReservedSpace); 4012 4013 Op<0>() = Value; 4014 Op<1>() = Default; 4015} 4016 4017/// SwitchInst ctor - Create a new switch instruction, specifying a value to 4018/// switch on and a default destination. The number of additional cases can 4019/// be specified here to make memory allocation more efficient. This 4020/// constructor can also autoinsert before another instruction. 4021SwitchInst::SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases, 4022 Instruction *InsertBefore) 4023 : Instruction(Type::getVoidTy(Value->getContext()), Instruction::Switch, 4024 nullptr, 0, InsertBefore) { 4025 init(Value, Default, 2+NumCases*2); 4026} 4027 4028/// SwitchInst ctor - Create a new switch instruction, specifying a value to 4029/// switch on and a default destination. The number of additional cases can 4030/// be specified here to make memory allocation more efficient. This 4031/// constructor also autoinserts at the end of the specified BasicBlock. 4032SwitchInst::SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases, 4033 BasicBlock *InsertAtEnd) 4034 : Instruction(Type::getVoidTy(Value->getContext()), Instruction::Switch, 4035 nullptr, 0, InsertAtEnd) { 4036 init(Value, Default, 2+NumCases*2); 4037} 4038 4039SwitchInst::SwitchInst(const SwitchInst &SI) 4040 : Instruction(SI.getType(), Instruction::Switch, nullptr, 0) { 4041 init(SI.getCondition(), SI.getDefaultDest(), SI.getNumOperands()); 4042 setNumHungOffUseOperands(SI.getNumOperands()); 4043 Use *OL = getOperandList(); 4044 const Use *InOL = SI.getOperandList(); 4045 for (unsigned i = 2, E = SI.getNumOperands(); i != E; i += 2) { 4046 OL[i] = InOL[i]; 4047 OL[i+1] = InOL[i+1]; 4048 } 4049 SubclassOptionalData = SI.SubclassOptionalData; 4050} 4051 4052/// addCase - Add an entry to the switch instruction... 4053/// 4054void SwitchInst::addCase(ConstantInt *OnVal, BasicBlock *Dest) { 4055 unsigned NewCaseIdx = getNumCases(); 4056 unsigned OpNo = getNumOperands(); 4057 if (OpNo+2 > ReservedSpace) 4058 growOperands(); // Get more space! 4059 // Initialize some new operands. 4060 assert(OpNo+1 < ReservedSpace && "Growing didn't work!"); 4061 setNumHungOffUseOperands(OpNo+2); 4062 CaseHandle Case(this, NewCaseIdx); 4063 Case.setValue(OnVal); 4064 Case.setSuccessor(Dest); 4065} 4066 4067/// removeCase - This method removes the specified case and its successor 4068/// from the switch instruction. 4069SwitchInst::CaseIt SwitchInst::removeCase(CaseIt I) { 4070 unsigned idx = I->getCaseIndex(); 4071 4072 assert(2 + idx*2 < getNumOperands() && "Case index out of range!!!"); 4073 4074 unsigned NumOps = getNumOperands(); 4075 Use *OL = getOperandList(); 4076 4077 // Overwrite this case with the end of the list. 4078 if (2 + (idx + 1) * 2 != NumOps) { 4079 OL[2 + idx * 2] = OL[NumOps - 2]; 4080 OL[2 + idx * 2 + 1] = OL[NumOps - 1]; 4081 } 4082 4083 // Nuke the last value. 4084 OL[NumOps-2].set(nullptr); 4085 OL[NumOps-2+1].set(nullptr); 4086 setNumHungOffUseOperands(NumOps-2); 4087 4088 return CaseIt(this, idx); 4089} 4090 4091/// growOperands - grow operands - This grows the operand list in response 4092/// to a push_back style of operation. This grows the number of ops by 3 times. 4093/// 4094void SwitchInst::growOperands() { 4095 unsigned e = getNumOperands(); 4096 unsigned NumOps = e*3; 4097 4098 ReservedSpace = NumOps; 4099 growHungoffUses(ReservedSpace); 4100} 4101 4102MDNode * 4103SwitchInstProfUpdateWrapper::getProfBranchWeightsMD(const SwitchInst &SI) { 4104 if (MDNode *ProfileData = SI.getMetadata(LLVMContext::MD_prof)) 4105 if (auto *MDName = dyn_cast<MDString>(ProfileData->getOperand(0))) 4106 if (MDName->getString() == "branch_weights") 4107 return ProfileData; 4108 return nullptr; 4109} 4110 4111MDNode *SwitchInstProfUpdateWrapper::buildProfBranchWeightsMD() { 4112 assert(Changed && "called only if metadata has changed"); 4113 4114 if (!Weights) 4115 return nullptr; 4116 4117 assert(SI.getNumSuccessors() == Weights->size() && 4118 "num of prof branch_weights must accord with num of successors"); 4119 4120 bool AllZeroes = 4121 all_of(Weights.getValue(), [](uint32_t W) { return W == 0; }); 4122 4123 if (AllZeroes || Weights.getValue().size() < 2) 4124 return nullptr; 4125 4126 return MDBuilder(SI.getParent()->getContext()).createBranchWeights(*Weights); 4127} 4128 4129void SwitchInstProfUpdateWrapper::init() { 4130 MDNode *ProfileData = getProfBranchWeightsMD(SI); 4131 if (!ProfileData) 4132 return; 4133 4134 if (ProfileData->getNumOperands() != SI.getNumSuccessors() + 1) { 4135 llvm_unreachable("number of prof branch_weights metadata operands does " 4136 "not correspond to number of succesors"); 4137 } 4138 4139 SmallVector<uint32_t, 8> Weights; 4140 for (unsigned CI = 1, CE = SI.getNumSuccessors(); CI <= CE; ++CI) { 4141 ConstantInt *C = mdconst::extract<ConstantInt>(ProfileData->getOperand(CI)); 4142 uint32_t CW = C->getValue().getZExtValue(); 4143 Weights.push_back(CW); 4144 } 4145 this->Weights = std::move(Weights); 4146} 4147 4148SwitchInst::CaseIt 4149SwitchInstProfUpdateWrapper::removeCase(SwitchInst::CaseIt I) { 4150 if (Weights) { 4151 assert(SI.getNumSuccessors() == Weights->size() && 4152 "num of prof branch_weights must accord with num of successors"); 4153 Changed = true; 4154 // Copy the last case to the place of the removed one and shrink. 4155 // This is tightly coupled with the way SwitchInst::removeCase() removes 4156 // the cases in SwitchInst::removeCase(CaseIt). 4157 Weights.getValue()[I->getCaseIndex() + 1] = Weights.getValue().back(); 4158 Weights.getValue().pop_back(); 4159 } 4160 return SI.removeCase(I); 4161} 4162 4163void SwitchInstProfUpdateWrapper::addCase( 4164 ConstantInt *OnVal, BasicBlock *Dest, 4165 SwitchInstProfUpdateWrapper::CaseWeightOpt W) { 4166 SI.addCase(OnVal, Dest); 4167 4168 if (!Weights && W && *W) { 4169 Changed = true; 4170 Weights = SmallVector<uint32_t, 8>(SI.getNumSuccessors(), 0); 4171 Weights.getValue()[SI.getNumSuccessors() - 1] = *W; 4172 } else if (Weights) { 4173 Changed = true; 4174 Weights.getValue().push_back(W ? *W : 0); 4175 } 4176 if (Weights) 4177 assert(SI.getNumSuccessors() == Weights->size() && 4178 "num of prof branch_weights must accord with num of successors"); 4179} 4180 4181SymbolTableList<Instruction>::iterator 4182SwitchInstProfUpdateWrapper::eraseFromParent() { 4183 // Instruction is erased. Mark as unchanged to not touch it in the destructor. 4184 Changed = false; 4185 if (Weights) 4186 Weights->resize(0); 4187 return SI.eraseFromParent(); 4188} 4189 4190SwitchInstProfUpdateWrapper::CaseWeightOpt 4191SwitchInstProfUpdateWrapper::getSuccessorWeight(unsigned idx) { 4192 if (!Weights) 4193 return None; 4194 return Weights.getValue()[idx]; 4195} 4196 4197void SwitchInstProfUpdateWrapper::setSuccessorWeight( 4198 unsigned idx, SwitchInstProfUpdateWrapper::CaseWeightOpt W) { 4199 if (!W) 4200 return; 4201 4202 if (!Weights && *W) 4203 Weights = SmallVector<uint32_t, 8>(SI.getNumSuccessors(), 0); 4204 4205 if (Weights) { 4206 auto &OldW = Weights.getValue()[idx]; 4207 if (*W != OldW) { 4208 Changed = true; 4209 OldW = *W; 4210 } 4211 } 4212} 4213 4214SwitchInstProfUpdateWrapper::CaseWeightOpt 4215SwitchInstProfUpdateWrapper::getSuccessorWeight(const SwitchInst &SI, 4216 unsigned idx) { 4217 if (MDNode *ProfileData = getProfBranchWeightsMD(SI)) 4218 if (ProfileData->getNumOperands() == SI.getNumSuccessors() + 1) 4219 return mdconst::extract<ConstantInt>(ProfileData->getOperand(idx + 1)) 4220 ->getValue() 4221 .getZExtValue(); 4222 4223 return None; 4224} 4225 4226//===----------------------------------------------------------------------===// 4227// IndirectBrInst Implementation 4228//===----------------------------------------------------------------------===// 4229 4230void IndirectBrInst::init(Value *Address, unsigned NumDests) { 4231 assert(Address && Address->getType()->isPointerTy() && 4232 "Address of indirectbr must be a pointer"); 4233 ReservedSpace = 1+NumDests; 4234 setNumHungOffUseOperands(1); 4235 allocHungoffUses(ReservedSpace); 4236 4237 Op<0>() = Address; 4238} 4239 4240 4241/// growOperands - grow operands - This grows the operand list in response 4242/// to a push_back style of operation. This grows the number of ops by 2 times. 4243/// 4244void IndirectBrInst::growOperands() { 4245 unsigned e = getNumOperands(); 4246 unsigned NumOps = e*2; 4247 4248 ReservedSpace = NumOps; 4249 growHungoffUses(ReservedSpace); 4250} 4251 4252IndirectBrInst::IndirectBrInst(Value *Address, unsigned NumCases, 4253 Instruction *InsertBefore) 4254 : Instruction(Type::getVoidTy(Address->getContext()), 4255 Instruction::IndirectBr, nullptr, 0, InsertBefore) { 4256 init(Address, NumCases); 4257} 4258 4259IndirectBrInst::IndirectBrInst(Value *Address, unsigned NumCases, 4260 BasicBlock *InsertAtEnd) 4261 : Instruction(Type::getVoidTy(Address->getContext()), 4262 Instruction::IndirectBr, nullptr, 0, InsertAtEnd) { 4263 init(Address, NumCases); 4264} 4265 4266IndirectBrInst::IndirectBrInst(const IndirectBrInst &IBI) 4267 : Instruction(Type::getVoidTy(IBI.getContext()), Instruction::IndirectBr, 4268 nullptr, IBI.getNumOperands()) { 4269 allocHungoffUses(IBI.getNumOperands()); 4270 Use *OL = getOperandList(); 4271 const Use *InOL = IBI.getOperandList(); 4272 for (unsigned i = 0, E = IBI.getNumOperands(); i != E; ++i) 4273 OL[i] = InOL[i]; 4274 SubclassOptionalData = IBI.SubclassOptionalData; 4275} 4276 4277/// addDestination - Add a destination. 4278/// 4279void IndirectBrInst::addDestination(BasicBlock *DestBB) { 4280 unsigned OpNo = getNumOperands(); 4281 if (OpNo+1 > ReservedSpace) 4282 growOperands(); // Get more space! 4283 // Initialize some new operands. 4284 assert(OpNo < ReservedSpace && "Growing didn't work!"); 4285 setNumHungOffUseOperands(OpNo+1); 4286 getOperandList()[OpNo] = DestBB; 4287} 4288 4289/// removeDestination - This method removes the specified successor from the 4290/// indirectbr instruction. 4291void IndirectBrInst::removeDestination(unsigned idx) { 4292 assert(idx < getNumOperands()-1 && "Successor index out of range!"); 4293 4294 unsigned NumOps = getNumOperands(); 4295 Use *OL = getOperandList(); 4296 4297 // Replace this value with the last one. 4298 OL[idx+1] = OL[NumOps-1]; 4299 4300 // Nuke the last value. 4301 OL[NumOps-1].set(nullptr); 4302 setNumHungOffUseOperands(NumOps-1); 4303} 4304 4305//===----------------------------------------------------------------------===// 4306// FreezeInst Implementation 4307//===----------------------------------------------------------------------===// 4308 4309FreezeInst::FreezeInst(Value *S, 4310 const Twine &Name, Instruction *InsertBefore) 4311 : UnaryInstruction(S->getType(), Freeze, S, InsertBefore) { 4312 setName(Name); 4313} 4314 4315FreezeInst::FreezeInst(Value *S, 4316 const Twine &Name, BasicBlock *InsertAtEnd) 4317 : UnaryInstruction(S->getType(), Freeze, S, InsertAtEnd) { 4318 setName(Name); 4319} 4320 4321//===----------------------------------------------------------------------===// 4322// cloneImpl() implementations 4323//===----------------------------------------------------------------------===// 4324 4325// Define these methods here so vtables don't get emitted into every translation 4326// unit that uses these classes. 4327 4328GetElementPtrInst *GetElementPtrInst::cloneImpl() const { 4329 return new (getNumOperands()) GetElementPtrInst(*this); 4330} 4331 4332UnaryOperator *UnaryOperator::cloneImpl() const { 4333 return Create(getOpcode(), Op<0>()); 4334} 4335 4336BinaryOperator *BinaryOperator::cloneImpl() const { 4337 return Create(getOpcode(), Op<0>(), Op<1>()); 4338} 4339 4340FCmpInst *FCmpInst::cloneImpl() const { 4341 return new FCmpInst(getPredicate(), Op<0>(), Op<1>()); 4342} 4343 4344ICmpInst *ICmpInst::cloneImpl() const { 4345 return new ICmpInst(getPredicate(), Op<0>(), Op<1>()); 4346} 4347 4348ExtractValueInst *ExtractValueInst::cloneImpl() const { 4349 return new ExtractValueInst(*this); 4350} 4351 4352InsertValueInst *InsertValueInst::cloneImpl() const { 4353 return new InsertValueInst(*this); 4354} 4355 4356AllocaInst *AllocaInst::cloneImpl() const { 4357 AllocaInst *Result = 4358 new AllocaInst(getAllocatedType(), getType()->getAddressSpace(), 4359 getOperand(0), getAlign()); 4360 Result->setUsedWithInAlloca(isUsedWithInAlloca()); 4361 Result->setSwiftError(isSwiftError()); 4362 return Result; 4363} 4364 4365LoadInst *LoadInst::cloneImpl() const { 4366 return new LoadInst(getType(), getOperand(0), Twine(), isVolatile(), 4367 getAlign(), getOrdering(), getSyncScopeID()); 4368} 4369 4370StoreInst *StoreInst::cloneImpl() const { 4371 return new StoreInst(getOperand(0), getOperand(1), isVolatile(), getAlign(), 4372 getOrdering(), getSyncScopeID()); 4373} 4374 4375AtomicCmpXchgInst *AtomicCmpXchgInst::cloneImpl() const { 4376 AtomicCmpXchgInst *Result = new AtomicCmpXchgInst( 4377 getOperand(0), getOperand(1), getOperand(2), getAlign(), 4378 getSuccessOrdering(), getFailureOrdering(), getSyncScopeID()); 4379 Result->setVolatile(isVolatile()); 4380 Result->setWeak(isWeak()); 4381 return Result; 4382} 4383 4384AtomicRMWInst *AtomicRMWInst::cloneImpl() const { 4385 AtomicRMWInst *Result = 4386 new AtomicRMWInst(getOperation(), getOperand(0), getOperand(1), 4387 getAlign(), getOrdering(), getSyncScopeID()); 4388 Result->setVolatile(isVolatile()); 4389 return Result; 4390} 4391 4392FenceInst *FenceInst::cloneImpl() const { 4393 return new FenceInst(getContext(), getOrdering(), getSyncScopeID()); 4394} 4395 4396TruncInst *TruncInst::cloneImpl() const { 4397 return new TruncInst(getOperand(0), getType()); 4398} 4399 4400ZExtInst *ZExtInst::cloneImpl() const { 4401 return new ZExtInst(getOperand(0), getType()); 4402} 4403 4404SExtInst *SExtInst::cloneImpl() const { 4405 return new SExtInst(getOperand(0), getType()); 4406} 4407 4408FPTruncInst *FPTruncInst::cloneImpl() const { 4409 return new FPTruncInst(getOperand(0), getType()); 4410} 4411 4412FPExtInst *FPExtInst::cloneImpl() const { 4413 return new FPExtInst(getOperand(0), getType()); 4414} 4415 4416UIToFPInst *UIToFPInst::cloneImpl() const { 4417 return new UIToFPInst(getOperand(0), getType()); 4418} 4419 4420SIToFPInst *SIToFPInst::cloneImpl() const { 4421 return new SIToFPInst(getOperand(0), getType()); 4422} 4423 4424FPToUIInst *FPToUIInst::cloneImpl() const { 4425 return new FPToUIInst(getOperand(0), getType()); 4426} 4427 4428FPToSIInst *FPToSIInst::cloneImpl() const { 4429 return new FPToSIInst(getOperand(0), getType()); 4430} 4431 4432PtrToIntInst *PtrToIntInst::cloneImpl() const { 4433 return new PtrToIntInst(getOperand(0), getType()); 4434} 4435 4436IntToPtrInst *IntToPtrInst::cloneImpl() const { 4437 return new IntToPtrInst(getOperand(0), getType()); 4438} 4439 4440BitCastInst *BitCastInst::cloneImpl() const { 4441 return new BitCastInst(getOperand(0), getType()); 4442} 4443 4444AddrSpaceCastInst *AddrSpaceCastInst::cloneImpl() const { 4445 return new AddrSpaceCastInst(getOperand(0), getType()); 4446} 4447 4448CallInst *CallInst::cloneImpl() const { 4449 if (hasOperandBundles()) { 4450 unsigned DescriptorBytes = getNumOperandBundles() * sizeof(BundleOpInfo); 4451 return new(getNumOperands(), DescriptorBytes) CallInst(*this); 4452 } 4453 return new(getNumOperands()) CallInst(*this); 4454} 4455 4456SelectInst *SelectInst::cloneImpl() const { 4457 return SelectInst::Create(getOperand(0), getOperand(1), getOperand(2)); 4458} 4459 4460VAArgInst *VAArgInst::cloneImpl() const { 4461 return new VAArgInst(getOperand(0), getType()); 4462} 4463 4464ExtractElementInst *ExtractElementInst::cloneImpl() const { 4465 return ExtractElementInst::Create(getOperand(0), getOperand(1)); 4466} 4467 4468InsertElementInst *InsertElementInst::cloneImpl() const { 4469 return InsertElementInst::Create(getOperand(0), getOperand(1), getOperand(2)); 4470} 4471 4472ShuffleVectorInst *ShuffleVectorInst::cloneImpl() const { 4473 return new ShuffleVectorInst(getOperand(0), getOperand(1), getShuffleMask()); 4474} 4475 4476PHINode *PHINode::cloneImpl() const { return new PHINode(*this); } 4477 4478LandingPadInst *LandingPadInst::cloneImpl() const { 4479 return new LandingPadInst(*this); 4480} 4481 4482ReturnInst *ReturnInst::cloneImpl() const { 4483 return new(getNumOperands()) ReturnInst(*this); 4484} 4485 4486BranchInst *BranchInst::cloneImpl() const { 4487 return new(getNumOperands()) BranchInst(*this); 4488} 4489 4490SwitchInst *SwitchInst::cloneImpl() const { return new SwitchInst(*this); } 4491 4492IndirectBrInst *IndirectBrInst::cloneImpl() const { 4493 return new IndirectBrInst(*this); 4494} 4495 4496InvokeInst *InvokeInst::cloneImpl() const { 4497 if (hasOperandBundles()) { 4498 unsigned DescriptorBytes = getNumOperandBundles() * sizeof(BundleOpInfo); 4499 return new(getNumOperands(), DescriptorBytes) InvokeInst(*this); 4500 } 4501 return new(getNumOperands()) InvokeInst(*this); 4502} 4503 4504CallBrInst *CallBrInst::cloneImpl() const { 4505 if (hasOperandBundles()) { 4506 unsigned DescriptorBytes = getNumOperandBundles() * sizeof(BundleOpInfo); 4507 return new (getNumOperands(), DescriptorBytes) CallBrInst(*this); 4508 } 4509 return new (getNumOperands()) CallBrInst(*this); 4510} 4511 4512ResumeInst *ResumeInst::cloneImpl() const { return new (1) ResumeInst(*this); } 4513 4514CleanupReturnInst *CleanupReturnInst::cloneImpl() const { 4515 return new (getNumOperands()) CleanupReturnInst(*this); 4516} 4517 4518CatchReturnInst *CatchReturnInst::cloneImpl() const { 4519 return new (getNumOperands()) CatchReturnInst(*this); 4520} 4521 4522CatchSwitchInst *CatchSwitchInst::cloneImpl() const { 4523 return new CatchSwitchInst(*this); 4524} 4525 4526FuncletPadInst *FuncletPadInst::cloneImpl() const { 4527 return new (getNumOperands()) FuncletPadInst(*this); 4528} 4529 4530UnreachableInst *UnreachableInst::cloneImpl() const { 4531 LLVMContext &Context = getContext(); 4532 return new UnreachableInst(Context); 4533} 4534 4535FreezeInst *FreezeInst::cloneImpl() const { 4536 return new FreezeInst(getOperand(0)); 4537} 4538