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