llvm/lib/IR/IntrinsicInst.cpp - llvm-project - Git at Google

 //===-- IntrinsicInst.cpp - Intrinsic Instruction Wrappers ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements methods that make it really easy to deal with intrinsic
 // functions.
 //
 // All intrinsic function calls are instances of the call instruction, so these
 // are all subclasses of the CallInst class.  Note that none of these classes
 // has state or virtual methods, which is an important part of this gross/neat
 // hack working.
 //
 // In some cases, arguments to intrinsics need to be generic and are defined as
 // type pointer to empty struct { }*.  To access the real item of interest the
 // cast instruction needs to be stripped away.
 //
 //===----------------------------------------------------------------------===//

 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/PatternMatch.h"
 #include "llvm/IR/Statepoint.h"

 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;

 //===----------------------------------------------------------------------===//
 /// DbgVariableIntrinsic - This is the common base class for debug info
 /// intrinsics for variables.
 ///

 iterator_range<DbgVariableIntrinsic::location_op_iterator>
 DbgVariableIntrinsic::location_ops() const {
   auto *MD = getRawLocation();
   assert(MD && "First operand of DbgVariableIntrinsic should be non-null.");

   // If operand is ValueAsMetadata, return a range over just that operand.
   if (auto *VAM = dyn_cast<ValueAsMetadata>(MD)) {
     return {location_op_iterator(VAM), location_op_iterator(VAM + 1)};
   }
   // If operand is DIArgList, return a range over its args.
   if (auto *AL = dyn_cast<DIArgList>(MD))
     return {location_op_iterator(AL->args_begin()),
             location_op_iterator(AL->args_end())};
   // Operand must be an empty metadata tuple, so return empty iterator.
   return {location_op_iterator(static_cast<ValueAsMetadata *>(nullptr)),
           location_op_iterator(static_cast<ValueAsMetadata *>(nullptr))};
 }

 Value *DbgVariableIntrinsic::getVariableLocationOp(unsigned OpIdx) const {
   auto *MD = getRawLocation();
   assert(MD && "First operand of DbgVariableIntrinsic should be non-null.");
   if (auto *AL = dyn_cast<DIArgList>(MD))
     return AL->getArgs()[OpIdx]->getValue();
   if (isa<MDNode>(MD))
     return nullptr;
   assert(
       isa<ValueAsMetadata>(MD) &&
       "Attempted to get location operand from DbgVariableIntrinsic with none.");
   auto *V = cast<ValueAsMetadata>(MD);
   assert(OpIdx == 0 && "Operand Index must be 0 for a debug intrinsic with a "
                        "single location operand.");
   return V->getValue();
 }

 static ValueAsMetadata *getAsMetadata(Value *V) {
   return isa<MetadataAsValue>(V) ? dyn_cast<ValueAsMetadata>(
                                        cast<MetadataAsValue>(V)->getMetadata())
                                  : ValueAsMetadata::get(V);
 }

 void DbgVariableIntrinsic::replaceVariableLocationOp(Value *OldValue,
                                                      Value *NewValue) {
   assert(NewValue && "Values must be non-null");
   auto Locations = location_ops();
   auto OldIt = find(Locations, OldValue);
   assert(OldIt != Locations.end() && "OldValue must be a current location");
   if (!hasArgList()) {
     Value *NewOperand = isa<MetadataAsValue>(NewValue)
                             ? NewValue
                             : MetadataAsValue::get(
                                   getContext(), ValueAsMetadata::get(NewValue));
     return setArgOperand(0, NewOperand);
   }
   SmallVector<ValueAsMetadata *, 4> MDs;
   ValueAsMetadata *NewOperand = getAsMetadata(NewValue);
   for (auto *VMD : Locations)
     MDs.push_back(VMD == *OldIt ? NewOperand : getAsMetadata(VMD));
   setArgOperand(
       0, MetadataAsValue::get(getContext(), DIArgList::get(getContext(), MDs)));
 }
 void DbgVariableIntrinsic::replaceVariableLocationOp(unsigned OpIdx,
                                                      Value *NewValue) {
   assert(OpIdx < getNumVariableLocationOps() && "Invalid Operand Index");
   if (!hasArgList()) {
     Value *NewOperand = isa<MetadataAsValue>(NewValue)
                             ? NewValue
                             : MetadataAsValue::get(
                                   getContext(), ValueAsMetadata::get(NewValue));
     return setArgOperand(0, NewOperand);
   }
   SmallVector<ValueAsMetadata *, 4> MDs;
   ValueAsMetadata *NewOperand = getAsMetadata(NewValue);
   for (unsigned Idx = 0; Idx < getNumVariableLocationOps(); ++Idx)
     MDs.push_back(Idx == OpIdx ? NewOperand
                                : getAsMetadata(getVariableLocationOp(Idx)));
   setArgOperand(
       0, MetadataAsValue::get(getContext(), DIArgList::get(getContext(), MDs)));
 }

 void DbgVariableIntrinsic::addVariableLocationOps(ArrayRef<Value *> NewValues,
                                                   DIExpression *NewExpr) {
   assert(NewExpr->hasAllLocationOps(getNumVariableLocationOps() +
                                     NewValues.size()) &&
          "NewExpr for debug variable intrinsic does not reference every "
          "location operand.");
   assert(!is_contained(NewValues, nullptr) && "New values must be non-null");
   setArgOperand(2, MetadataAsValue::get(getContext(), NewExpr));
   SmallVector<ValueAsMetadata *, 4> MDs;
   for (auto *VMD : location_ops())
     MDs.push_back(getAsMetadata(VMD));
   for (auto *VMD : NewValues)
     MDs.push_back(getAsMetadata(VMD));
   setArgOperand(
       0, MetadataAsValue::get(getContext(), DIArgList::get(getContext(), MDs)));
 }

 Optional<uint64_t> DbgVariableIntrinsic::getFragmentSizeInBits() const {
   if (auto Fragment = getExpression()->getFragmentInfo())
     return Fragment->SizeInBits;
   return getVariable()->getSizeInBits();
 }

 int llvm::Intrinsic::lookupLLVMIntrinsicByName(ArrayRef<const char *> NameTable,
                                                StringRef Name) {
   assert(Name.startswith("llvm."));

   // Do successive binary searches of the dotted name components. For
   // "llvm.gc.experimental.statepoint.p1i8.p1i32", we will find the range of
   // intrinsics starting with "llvm.gc", then "llvm.gc.experimental", then
   // "llvm.gc.experimental.statepoint", and then we will stop as the range is
   // size 1. During the search, we can skip the prefix that we already know is
   // identical. By using strncmp we consider names with differing suffixes to
   // be part of the equal range.
   size_t CmpEnd = 4; // Skip the "llvm" component.
   const char *const *Low = NameTable.begin();
   const char *const *High = NameTable.end();
   const char *const *LastLow = Low;
   while (CmpEnd < Name.size() && High - Low > 0) {
     size_t CmpStart = CmpEnd;
     CmpEnd = Name.find('.', CmpStart + 1);
     CmpEnd = CmpEnd == StringRef::npos ? Name.size() : CmpEnd;
     auto Cmp = [CmpStart, CmpEnd](const char *LHS, const char *RHS) {
       return strncmp(LHS + CmpStart, RHS + CmpStart, CmpEnd - CmpStart) < 0;
     };
     LastLow = Low;
     std::tie(Low, High) = std::equal_range(Low, High, Name.data(), Cmp);
   }
   if (High - Low > 0)
     LastLow = Low;

   if (LastLow == NameTable.end())
     return -1;
   StringRef NameFound = *LastLow;
   if (Name == NameFound ||
       (Name.startswith(NameFound) && Name[NameFound.size()] == '.'))
     return LastLow - NameTable.begin();
   return -1;
 }

 Value *InstrProfIncrementInst::getStep() const {
   if (InstrProfIncrementInstStep::classof(this)) {
     return const_cast<Value *>(getArgOperand(4));
   }
   const Module *M = getModule();
   LLVMContext &Context = M->getContext();
   return ConstantInt::get(Type::getInt64Ty(Context), 1);
 }

 Optional<RoundingMode> ConstrainedFPIntrinsic::getRoundingMode() const {
   unsigned NumOperands = arg_size();
   Metadata *MD = nullptr;
   auto *MAV = dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 2));
   if (MAV)
     MD = MAV->getMetadata();
   if (!MD || !isa<MDString>(MD))
     return None;
   return convertStrToRoundingMode(cast<MDString>(MD)->getString());
 }

 Optional<fp::ExceptionBehavior>
 ConstrainedFPIntrinsic::getExceptionBehavior() const {
   unsigned NumOperands = arg_size();
   Metadata *MD = nullptr;
   auto *MAV = dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 1));
   if (MAV)
     MD = MAV->getMetadata();
   if (!MD || !isa<MDString>(MD))
     return None;
   return convertStrToExceptionBehavior(cast<MDString>(MD)->getString());
 }

 bool ConstrainedFPIntrinsic::isDefaultFPEnvironment() const {
   Optional<fp::ExceptionBehavior> Except = getExceptionBehavior();
   if (Except) {
     if (Except.getValue() != fp::ebIgnore)
       return false;
   }

   Optional<RoundingMode> Rounding = getRoundingMode();
   if (Rounding) {
     if (Rounding.getValue() != RoundingMode::NearestTiesToEven)
       return false;
   }

   return true;
 }

 FCmpInst::Predicate ConstrainedFPCmpIntrinsic::getPredicate() const {
   Metadata *MD = cast<MetadataAsValue>(getArgOperand(2))->getMetadata();
   if (!MD || !isa<MDString>(MD))
     return FCmpInst::BAD_FCMP_PREDICATE;
   return StringSwitch<FCmpInst::Predicate>(cast<MDString>(MD)->getString())
       .Case("oeq", FCmpInst::FCMP_OEQ)
       .Case("ogt", FCmpInst::FCMP_OGT)
       .Case("oge", FCmpInst::FCMP_OGE)
       .Case("olt", FCmpInst::FCMP_OLT)
       .Case("ole", FCmpInst::FCMP_OLE)
       .Case("one", FCmpInst::FCMP_ONE)
       .Case("ord", FCmpInst::FCMP_ORD)
       .Case("uno", FCmpInst::FCMP_UNO)
       .Case("ueq", FCmpInst::FCMP_UEQ)
       .Case("ugt", FCmpInst::FCMP_UGT)
       .Case("uge", FCmpInst::FCMP_UGE)
       .Case("ult", FCmpInst::FCMP_ULT)
       .Case("ule", FCmpInst::FCMP_ULE)
       .Case("une", FCmpInst::FCMP_UNE)
       .Default(FCmpInst::BAD_FCMP_PREDICATE);
 }

 bool ConstrainedFPIntrinsic::isUnaryOp() const {
   switch (getIntrinsicID()) {
   default:
     return false;
 #define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC)                         \
   case Intrinsic::INTRINSIC:                                                   \
     return NARG == 1;
 #include "llvm/IR/ConstrainedOps.def"
   }
 }

 bool ConstrainedFPIntrinsic::isTernaryOp() const {
   switch (getIntrinsicID()) {
   default:
     return false;
 #define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC)                         \
   case Intrinsic::INTRINSIC:                                                   \
     return NARG == 3;
 #include "llvm/IR/ConstrainedOps.def"
   }
 }

 bool ConstrainedFPIntrinsic::classof(const IntrinsicInst *I) {
   switch (I->getIntrinsicID()) {
 #define INSTRUCTION(NAME, NARGS, ROUND_MODE, INTRINSIC)                        \
   case Intrinsic::INTRINSIC:
 #include "llvm/IR/ConstrainedOps.def"
     return true;
   default:
     return false;
   }
 }

 ElementCount VPIntrinsic::getStaticVectorLength() const {
   auto GetVectorLengthOfType = [](const Type *T) -> ElementCount {
     const auto *VT = cast<VectorType>(T);
     auto ElemCount = VT->getElementCount();
     return ElemCount;
   };

   Value *VPMask = getMaskParam();
   assert(VPMask && "No mask param?");
   return GetVectorLengthOfType(VPMask->getType());
 }

 Value *VPIntrinsic::getMaskParam() const {
   if (auto MaskPos = getMaskParamPos(getIntrinsicID()))
     return getArgOperand(MaskPos.getValue());
   return nullptr;
 }

 void VPIntrinsic::setMaskParam(Value *NewMask) {
   auto MaskPos = getMaskParamPos(getIntrinsicID());
   setArgOperand(*MaskPos, NewMask);
 }

 Value *VPIntrinsic::getVectorLengthParam() const {
   if (auto EVLPos = getVectorLengthParamPos(getIntrinsicID()))
     return getArgOperand(EVLPos.getValue());
   return nullptr;
 }

 void VPIntrinsic::setVectorLengthParam(Value *NewEVL) {
   auto EVLPos = getVectorLengthParamPos(getIntrinsicID());
   setArgOperand(*EVLPos, NewEVL);
 }

 Optional<unsigned> VPIntrinsic::getMaskParamPos(Intrinsic::ID IntrinsicID) {
   switch (IntrinsicID) {
   default:
     return None;

 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS)                    \
   case Intrinsic::VPID:                                                        \
     return MASKPOS;
 #include "llvm/IR/VPIntrinsics.def"
   }
 }

 Optional<unsigned>
 VPIntrinsic::getVectorLengthParamPos(Intrinsic::ID IntrinsicID) {
   switch (IntrinsicID) {
   default:
     return None;

 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS)                    \
   case Intrinsic::VPID:                                                        \
     return VLENPOS;
 #include "llvm/IR/VPIntrinsics.def"
   }
 }

 /// \return the alignment of the pointer used by this load/store/gather or
 /// scatter.
 MaybeAlign VPIntrinsic::getPointerAlignment() const {
   Optional<unsigned> PtrParamOpt = getMemoryPointerParamPos(getIntrinsicID());
   assert(PtrParamOpt.hasValue() && "no pointer argument!");
   return getParamAlign(PtrParamOpt.getValue());
 }

 /// \return The pointer operand of this load,store, gather or scatter.
 Value *VPIntrinsic::getMemoryPointerParam() const {
   if (auto PtrParamOpt = getMemoryPointerParamPos(getIntrinsicID()))
     return getArgOperand(PtrParamOpt.getValue());
   return nullptr;
 }

 Optional<unsigned> VPIntrinsic::getMemoryPointerParamPos(Intrinsic::ID VPID) {
   switch (VPID) {
   default:
     break;
 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
 #define VP_PROPERTY_MEMOP(POINTERPOS, ...) return POINTERPOS;
 #define END_REGISTER_VP_INTRINSIC(VPID) break;
 #include "llvm/IR/VPIntrinsics.def"
   }
   return None;
 }

 /// \return The data (payload) operand of this store or scatter.
 Value *VPIntrinsic::getMemoryDataParam() const {
   auto DataParamOpt = getMemoryDataParamPos(getIntrinsicID());
   if (!DataParamOpt.hasValue())
     return nullptr;
   return getArgOperand(DataParamOpt.getValue());
 }

 Optional<unsigned> VPIntrinsic::getMemoryDataParamPos(Intrinsic::ID VPID) {
   switch (VPID) {
   default:
     break;
 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
 #define VP_PROPERTY_MEMOP(POINTERPOS, DATAPOS) return DATAPOS;
 #define END_REGISTER_VP_INTRINSIC(VPID) break;
 #include "llvm/IR/VPIntrinsics.def"
   }
   return None;
 }

 bool VPIntrinsic::isVPIntrinsic(Intrinsic::ID ID) {
   switch (ID) {
   default:
     break;
 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS)                    \
   case Intrinsic::VPID:                                                        \
     return true;
 #include "llvm/IR/VPIntrinsics.def"
   }
   return false;
 }

 // Equivalent non-predicated opcode
 Optional<unsigned> VPIntrinsic::getFunctionalOpcodeForVP(Intrinsic::ID ID) {
   switch (ID) {
   default:
     break;
 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
 #define VP_PROPERTY_FUNCTIONAL_OPC(OPC) return Instruction::OPC;
 #define END_REGISTER_VP_INTRINSIC(VPID) break;
 #include "llvm/IR/VPIntrinsics.def"
   }
   return None;
 }

 Intrinsic::ID VPIntrinsic::getForOpcode(unsigned IROPC) {
   switch (IROPC) {
   default:
     break;

 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) break;
 #define VP_PROPERTY_FUNCTIONAL_OPC(OPC) case Instruction::OPC:
 #define END_REGISTER_VP_INTRINSIC(VPID) return Intrinsic::VPID;
 #include "llvm/IR/VPIntrinsics.def"
   }
   return Intrinsic::not_intrinsic;
 }

 bool VPIntrinsic::canIgnoreVectorLengthParam() const {
   using namespace PatternMatch;

   ElementCount EC = getStaticVectorLength();

   // No vlen param - no lanes masked-off by it.
   auto *VLParam = getVectorLengthParam();
   if (!VLParam)
     return true;

   // Note that the VP intrinsic causes undefined behavior if the Explicit Vector
   // Length parameter is strictly greater-than the number of vector elements of
   // the operation. This function returns true when this is detected statically
   // in the IR.

   // Check whether "W == vscale * EC.getKnownMinValue()"
   if (EC.isScalable()) {
     // Undig the DL
     const auto *ParMod = this->getModule();
     if (!ParMod)
       return false;
     const auto &DL = ParMod->getDataLayout();

     // Compare vscale patterns
     uint64_t VScaleFactor;
     if (match(VLParam, m_c_Mul(m_ConstantInt(VScaleFactor), m_VScale(DL))))
       return VScaleFactor >= EC.getKnownMinValue();
     return (EC.getKnownMinValue() == 1) && match(VLParam, m_VScale(DL));
   }

   // standard SIMD operation
   const auto *VLConst = dyn_cast<ConstantInt>(VLParam);
   if (!VLConst)
     return false;

   uint64_t VLNum = VLConst->getZExtValue();
   if (VLNum >= EC.getKnownMinValue())
     return true;

   return false;
 }

 Function *VPIntrinsic::getDeclarationForParams(Module *M, Intrinsic::ID VPID,
                                                ArrayRef<Value *> Params) {
   assert(isVPIntrinsic(VPID) && "not a VP intrinsic");
   Function *VPFunc;
   switch (VPID) {
   default: {
     Type *OverloadTy = Params[0]->getType();
     if (VPReductionIntrinsic::isVPReduction(VPID))
       OverloadTy =
           Params[*VPReductionIntrinsic::getVectorParamPos(VPID)]->getType();

     VPFunc = Intrinsic::getDeclaration(M, VPID, OverloadTy);
     break;
   }
   case Intrinsic::vp_select:
     VPFunc = Intrinsic::getDeclaration(M, VPID, {Params[1]->getType()});
     break;
   case Intrinsic::vp_load:
     VPFunc = Intrinsic::getDeclaration(
         M, VPID,
         {Params[0]->getType()->getPointerElementType(), Params[0]->getType()});
     break;
   case Intrinsic::vp_gather:
     VPFunc = Intrinsic::getDeclaration(
         M, VPID,
         {VectorType::get(cast<VectorType>(Params[0]->getType())
                              ->getElementType()
                              ->getPointerElementType(),
                          cast<VectorType>(Params[0]->getType())),
          Params[0]->getType()});
     break;
   case Intrinsic::vp_store:
     VPFunc = Intrinsic::getDeclaration(
         M, VPID,
         {Params[1]->getType()->getPointerElementType(), Params[1]->getType()});
     break;
   case Intrinsic::vp_scatter:
     VPFunc = Intrinsic::getDeclaration(
         M, VPID, {Params[0]->getType(), Params[1]->getType()});
     break;
   }
   assert(VPFunc && "Could not declare VP intrinsic");
   return VPFunc;
 }

 bool VPReductionIntrinsic::isVPReduction(Intrinsic::ID ID) {
   switch (ID) {
   default:
     break;
 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
 #define VP_PROPERTY_REDUCTION(STARTPOS, ...) return true;
 #define END_REGISTER_VP_INTRINSIC(VPID) break;
 #include "llvm/IR/VPIntrinsics.def"
   }
   return false;
 }

 unsigned VPReductionIntrinsic::getVectorParamPos() const {
   return *VPReductionIntrinsic::getVectorParamPos(getIntrinsicID());
 }

 unsigned VPReductionIntrinsic::getStartParamPos() const {
   return *VPReductionIntrinsic::getStartParamPos(getIntrinsicID());
 }

 Optional<unsigned> VPReductionIntrinsic::getVectorParamPos(Intrinsic::ID ID) {
   switch (ID) {
 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
 #define VP_PROPERTY_REDUCTION(STARTPOS, VECTORPOS) return VECTORPOS;
 #define END_REGISTER_VP_INTRINSIC(VPID) break;
 #include "llvm/IR/VPIntrinsics.def"
   default:
     break;
   }
   return None;
 }

 Optional<unsigned> VPReductionIntrinsic::getStartParamPos(Intrinsic::ID ID) {
   switch (ID) {
 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
 #define VP_PROPERTY_REDUCTION(STARTPOS, VECTORPOS) return STARTPOS;
 #define END_REGISTER_VP_INTRINSIC(VPID) break;
 #include "llvm/IR/VPIntrinsics.def"
   default:
     break;
   }
   return None;
 }

 Instruction::BinaryOps BinaryOpIntrinsic::getBinaryOp() const {
   switch (getIntrinsicID()) {
   case Intrinsic::uadd_with_overflow:
   case Intrinsic::sadd_with_overflow:
   case Intrinsic::uadd_sat:
   case Intrinsic::sadd_sat:
     return Instruction::Add;
   case Intrinsic::usub_with_overflow:
   case Intrinsic::ssub_with_overflow:
   case Intrinsic::usub_sat:
   case Intrinsic::ssub_sat:
     return Instruction::Sub;
   case Intrinsic::umul_with_overflow:
   case Intrinsic::smul_with_overflow:
     return Instruction::Mul;
   default:
     llvm_unreachable("Invalid intrinsic");
   }
 }

 bool BinaryOpIntrinsic::isSigned() const {
   switch (getIntrinsicID()) {
   case Intrinsic::sadd_with_overflow:
   case Intrinsic::ssub_with_overflow:
   case Intrinsic::smul_with_overflow:
   case Intrinsic::sadd_sat:
   case Intrinsic::ssub_sat:
     return true;
   default:
     return false;
   }
 }

 unsigned BinaryOpIntrinsic::getNoWrapKind() const {
   if (isSigned())
     return OverflowingBinaryOperator::NoSignedWrap;
   else
     return OverflowingBinaryOperator::NoUnsignedWrap;
 }

 const GCStatepointInst *GCProjectionInst::getStatepoint() const {
   const Value *Token = getArgOperand(0);

   // This takes care both of relocates for call statepoints and relocates
   // on normal path of invoke statepoint.
   if (!isa<LandingPadInst>(Token))
     return cast<GCStatepointInst>(Token);

   // This relocate is on exceptional path of an invoke statepoint
   const BasicBlock *InvokeBB =
     cast<Instruction>(Token)->getParent()->getUniquePredecessor();

   assert(InvokeBB && "safepoints should have unique landingpads");
   assert(InvokeBB->getTerminator() &&
          "safepoint block should be well formed");

   return cast<GCStatepointInst>(InvokeBB->getTerminator());
 }

 Value *GCRelocateInst::getBasePtr() const {
   if (auto Opt = getStatepoint()->getOperandBundle(LLVMContext::OB_gc_live))
     return *(Opt->Inputs.begin() + getBasePtrIndex());
   return *(getStatepoint()->arg_begin() + getBasePtrIndex());
 }

 Value *GCRelocateInst::getDerivedPtr() const {
   if (auto Opt = getStatepoint()->getOperandBundle(LLVMContext::OB_gc_live))
     return *(Opt->Inputs.begin() + getDerivedPtrIndex());
   return *(getStatepoint()->arg_begin() + getDerivedPtrIndex());
 }
	//===-- IntrinsicInst.cpp - Intrinsic Instruction Wrappers ---------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//
	//
	// This file implements methods that make it really easy to deal with intrinsic
	// functions.
	//
	// All intrinsic function calls are instances of the call instruction, so these
	// are all subclasses of the CallInst class. Note that none of these classes
	// has state or virtual methods, which is an important part of this gross/neat
	// hack working.
	//
	// In some cases, arguments to intrinsics need to be generic and are defined as
	// type pointer to empty struct { }*. To access the real item of interest the
	// cast instruction needs to be stripped away.
	//
	//===----------------------------------------------------------------------===//

	#include "llvm/IR/IntrinsicInst.h"
	#include "llvm/ADT/StringSwitch.h"
	#include "llvm/IR/Constants.h"
	#include "llvm/IR/DebugInfoMetadata.h"
	#include "llvm/IR/GlobalVariable.h"
	#include "llvm/IR/Metadata.h"
	#include "llvm/IR/Module.h"
	#include "llvm/IR/Operator.h"
	#include "llvm/IR/PatternMatch.h"
	#include "llvm/IR/Statepoint.h"

	#include "llvm/Support/raw_ostream.h"
	using namespace llvm;

	//===----------------------------------------------------------------------===//
	/// DbgVariableIntrinsic - This is the common base class for debug info
	/// intrinsics for variables.
	///

	iterator_range<DbgVariableIntrinsic::location_op_iterator>
	DbgVariableIntrinsic::location_ops() const {
	auto *MD = getRawLocation();
	assert(MD && "First operand of DbgVariableIntrinsic should be non-null.");

	// If operand is ValueAsMetadata, return a range over just that operand.
	if (auto *VAM = dyn_cast<ValueAsMetadata>(MD)) {
	return {location_op_iterator(VAM), location_op_iterator(VAM + 1)};
	}
	// If operand is DIArgList, return a range over its args.
	if (auto *AL = dyn_cast<DIArgList>(MD))
	return {location_op_iterator(AL->args_begin()),
	location_op_iterator(AL->args_end())};
	// Operand must be an empty metadata tuple, so return empty iterator.
	return {location_op_iterator(static_cast<ValueAsMetadata *>(nullptr)),
	location_op_iterator(static_cast<ValueAsMetadata *>(nullptr))};
	}

	Value *DbgVariableIntrinsic::getVariableLocationOp(unsigned OpIdx) const {
	auto *MD = getRawLocation();
	assert(MD && "First operand of DbgVariableIntrinsic should be non-null.");
	if (auto *AL = dyn_cast<DIArgList>(MD))
	return AL->getArgs()[OpIdx]->getValue();
	if (isa<MDNode>(MD))
	return nullptr;
	assert(
	isa<ValueAsMetadata>(MD) &&
	"Attempted to get location operand from DbgVariableIntrinsic with none.");
	auto *V = cast<ValueAsMetadata>(MD);
	assert(OpIdx == 0 && "Operand Index must be 0 for a debug intrinsic with a "
	"single location operand.");
	return V->getValue();
	}

	static ValueAsMetadata getAsMetadata(Value V) {
	return isa<MetadataAsValue>(V) ? dyn_cast<ValueAsMetadata>(
	cast<MetadataAsValue>(V)->getMetadata())
	: ValueAsMetadata::get(V);
	}

	void DbgVariableIntrinsic::replaceVariableLocationOp(Value *OldValue,
	Value *NewValue) {
	assert(NewValue && "Values must be non-null");
	auto Locations = location_ops();
	auto OldIt = find(Locations, OldValue);
	assert(OldIt != Locations.end() && "OldValue must be a current location");
	if (!hasArgList()) {
	Value *NewOperand = isa<MetadataAsValue>(NewValue)
	? NewValue
	: MetadataAsValue::get(
	getContext(), ValueAsMetadata::get(NewValue));
	return setArgOperand(0, NewOperand);
	}
	SmallVector<ValueAsMetadata *, 4> MDs;
	ValueAsMetadata *NewOperand = getAsMetadata(NewValue);
	for (auto *VMD : Locations)
	MDs.push_back(VMD == *OldIt ? NewOperand : getAsMetadata(VMD));
	setArgOperand(
	0, MetadataAsValue::get(getContext(), DIArgList::get(getContext(), MDs)));
	}
	void DbgVariableIntrinsic::replaceVariableLocationOp(unsigned OpIdx,
	Value *NewValue) {
	assert(OpIdx < getNumVariableLocationOps() && "Invalid Operand Index");
	if (!hasArgList()) {
	Value *NewOperand = isa<MetadataAsValue>(NewValue)
	? NewValue
	: MetadataAsValue::get(
	getContext(), ValueAsMetadata::get(NewValue));
	return setArgOperand(0, NewOperand);
	}
	SmallVector<ValueAsMetadata *, 4> MDs;
	ValueAsMetadata *NewOperand = getAsMetadata(NewValue);
	for (unsigned Idx = 0; Idx < getNumVariableLocationOps(); ++Idx)
	MDs.push_back(Idx == OpIdx ? NewOperand
	: getAsMetadata(getVariableLocationOp(Idx)));
	setArgOperand(
	0, MetadataAsValue::get(getContext(), DIArgList::get(getContext(), MDs)));
	}

	void DbgVariableIntrinsic::addVariableLocationOps(ArrayRef<Value *> NewValues,
	DIExpression *NewExpr) {
	assert(NewExpr->hasAllLocationOps(getNumVariableLocationOps() +
	NewValues.size()) &&
	"NewExpr for debug variable intrinsic does not reference every "
	"location operand.");
	assert(!is_contained(NewValues, nullptr) && "New values must be non-null");
	setArgOperand(2, MetadataAsValue::get(getContext(), NewExpr));
	SmallVector<ValueAsMetadata *, 4> MDs;
	for (auto *VMD : location_ops())
	MDs.push_back(getAsMetadata(VMD));
	for (auto *VMD : NewValues)
	MDs.push_back(getAsMetadata(VMD));
	setArgOperand(
	0, MetadataAsValue::get(getContext(), DIArgList::get(getContext(), MDs)));
	}

	Optional<uint64_t> DbgVariableIntrinsic::getFragmentSizeInBits() const {
	if (auto Fragment = getExpression()->getFragmentInfo())
	return Fragment->SizeInBits;
	return getVariable()->getSizeInBits();
	}

	int llvm::Intrinsic::lookupLLVMIntrinsicByName(ArrayRef<const char *> NameTable,
	StringRef Name) {
	assert(Name.startswith("llvm."));

	// Do successive binary searches of the dotted name components. For
	// "llvm.gc.experimental.statepoint.p1i8.p1i32", we will find the range of
	// intrinsics starting with "llvm.gc", then "llvm.gc.experimental", then
	// "llvm.gc.experimental.statepoint", and then we will stop as the range is
	// size 1. During the search, we can skip the prefix that we already know is
	// identical. By using strncmp we consider names with differing suffixes to
	// be part of the equal range.
	size_t CmpEnd = 4; // Skip the "llvm" component.
	const char const Low = NameTable.begin();
	const char const High = NameTable.end();
	const char const LastLow = Low;
	while (CmpEnd < Name.size() && High - Low > 0) {
	size_t CmpStart = CmpEnd;
	CmpEnd = Name.find('.', CmpStart + 1);
	CmpEnd = CmpEnd == StringRef::npos ? Name.size() : CmpEnd;
	auto Cmp = [CmpStart, CmpEnd](const char LHS, const char RHS) {
	return strncmp(LHS + CmpStart, RHS + CmpStart, CmpEnd - CmpStart) < 0;
	};
	LastLow = Low;
	std::tie(Low, High) = std::equal_range(Low, High, Name.data(), Cmp);
	}
	if (High - Low > 0)
	LastLow = Low;

	if (LastLow == NameTable.end())
	return -1;
	StringRef NameFound = *LastLow;
	if (Name == NameFound \|\|
	(Name.startswith(NameFound) && Name[NameFound.size()] == '.'))
	return LastLow - NameTable.begin();
	return -1;
	}

	Value *InstrProfIncrementInst::getStep() const {
	if (InstrProfIncrementInstStep::classof(this)) {
	return const_cast<Value *>(getArgOperand(4));
	}
	const Module *M = getModule();
	LLVMContext &Context = M->getContext();
	return ConstantInt::get(Type::getInt64Ty(Context), 1);
	}

	Optional<RoundingMode> ConstrainedFPIntrinsic::getRoundingMode() const {
	unsigned NumOperands = arg_size();
	Metadata *MD = nullptr;
	auto *MAV = dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 2));
	if (MAV)
	MD = MAV->getMetadata();
	if (!MD \|\| !isa<MDString>(MD))
	return None;
	return convertStrToRoundingMode(cast<MDString>(MD)->getString());
	}

	Optional<fp::ExceptionBehavior>
	ConstrainedFPIntrinsic::getExceptionBehavior() const {
	unsigned NumOperands = arg_size();
	Metadata *MD = nullptr;
	auto *MAV = dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 1));
	if (MAV)
	MD = MAV->getMetadata();
	if (!MD \|\| !isa<MDString>(MD))
	return None;
	return convertStrToExceptionBehavior(cast<MDString>(MD)->getString());
	}

	bool ConstrainedFPIntrinsic::isDefaultFPEnvironment() const {
	Optional<fp::ExceptionBehavior> Except = getExceptionBehavior();
	if (Except) {
	if (Except.getValue() != fp::ebIgnore)
	return false;
	}

	Optional<RoundingMode> Rounding = getRoundingMode();
	if (Rounding) {
	if (Rounding.getValue() != RoundingMode::NearestTiesToEven)
	return false;
	}

	return true;
	}

	FCmpInst::Predicate ConstrainedFPCmpIntrinsic::getPredicate() const {
	Metadata *MD = cast<MetadataAsValue>(getArgOperand(2))->getMetadata();
	if (!MD \|\| !isa<MDString>(MD))
	return FCmpInst::BAD_FCMP_PREDICATE;
	return StringSwitch<FCmpInst::Predicate>(cast<MDString>(MD)->getString())
	.Case("oeq", FCmpInst::FCMP_OEQ)
	.Case("ogt", FCmpInst::FCMP_OGT)
	.Case("oge", FCmpInst::FCMP_OGE)
	.Case("olt", FCmpInst::FCMP_OLT)
	.Case("ole", FCmpInst::FCMP_OLE)
	.Case("one", FCmpInst::FCMP_ONE)
	.Case("ord", FCmpInst::FCMP_ORD)
	.Case("uno", FCmpInst::FCMP_UNO)
	.Case("ueq", FCmpInst::FCMP_UEQ)
	.Case("ugt", FCmpInst::FCMP_UGT)
	.Case("uge", FCmpInst::FCMP_UGE)
	.Case("ult", FCmpInst::FCMP_ULT)
	.Case("ule", FCmpInst::FCMP_ULE)
	.Case("une", FCmpInst::FCMP_UNE)
	.Default(FCmpInst::BAD_FCMP_PREDICATE);
	}

	bool ConstrainedFPIntrinsic::isUnaryOp() const {
	switch (getIntrinsicID()) {
	default:
	return false;
	#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
	case Intrinsic::INTRINSIC: \
	return NARG == 1;
	#include "llvm/IR/ConstrainedOps.def"
	}
	}

	bool ConstrainedFPIntrinsic::isTernaryOp() const {
	switch (getIntrinsicID()) {
	default:
	return false;
	#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
	case Intrinsic::INTRINSIC: \
	return NARG == 3;
	#include "llvm/IR/ConstrainedOps.def"
	}
	}

	bool ConstrainedFPIntrinsic::classof(const IntrinsicInst *I) {
	switch (I->getIntrinsicID()) {
	#define INSTRUCTION(NAME, NARGS, ROUND_MODE, INTRINSIC) \
	case Intrinsic::INTRINSIC:
	#include "llvm/IR/ConstrainedOps.def"
	return true;
	default:
	return false;
	}
	}

	ElementCount VPIntrinsic::getStaticVectorLength() const {
	auto GetVectorLengthOfType = [](const Type *T) -> ElementCount {
	const auto *VT = cast<VectorType>(T);
	auto ElemCount = VT->getElementCount();
	return ElemCount;
	};

	Value *VPMask = getMaskParam();
	assert(VPMask && "No mask param?");
	return GetVectorLengthOfType(VPMask->getType());
	}

	Value *VPIntrinsic::getMaskParam() const {
	if (auto MaskPos = getMaskParamPos(getIntrinsicID()))
	return getArgOperand(MaskPos.getValue());
	return nullptr;
	}

	void VPIntrinsic::setMaskParam(Value *NewMask) {
	auto MaskPos = getMaskParamPos(getIntrinsicID());
	setArgOperand(*MaskPos, NewMask);
	}

	Value *VPIntrinsic::getVectorLengthParam() const {
	if (auto EVLPos = getVectorLengthParamPos(getIntrinsicID()))
	return getArgOperand(EVLPos.getValue());
	return nullptr;
	}

	void VPIntrinsic::setVectorLengthParam(Value *NewEVL) {
	auto EVLPos = getVectorLengthParamPos(getIntrinsicID());
	setArgOperand(*EVLPos, NewEVL);
	}

	Optional<unsigned> VPIntrinsic::getMaskParamPos(Intrinsic::ID IntrinsicID) {
	switch (IntrinsicID) {
	default:
	return None;

	#define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS) \
	case Intrinsic::VPID: \
	return MASKPOS;
	#include "llvm/IR/VPIntrinsics.def"
	}
	}

	Optional<unsigned>
	VPIntrinsic::getVectorLengthParamPos(Intrinsic::ID IntrinsicID) {
	switch (IntrinsicID) {
	default:
	return None;

	#define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS) \
	case Intrinsic::VPID: \
	return VLENPOS;
	#include "llvm/IR/VPIntrinsics.def"
	}
	}

	/// \return the alignment of the pointer used by this load/store/gather or
	/// scatter.
	MaybeAlign VPIntrinsic::getPointerAlignment() const {
	Optional<unsigned> PtrParamOpt = getMemoryPointerParamPos(getIntrinsicID());
	assert(PtrParamOpt.hasValue() && "no pointer argument!");
	return getParamAlign(PtrParamOpt.getValue());
	}

	/// \return The pointer operand of this load,store, gather or scatter.
	Value *VPIntrinsic::getMemoryPointerParam() const {
	if (auto PtrParamOpt = getMemoryPointerParamPos(getIntrinsicID()))
	return getArgOperand(PtrParamOpt.getValue());
	return nullptr;
	}

	Optional<unsigned> VPIntrinsic::getMemoryPointerParamPos(Intrinsic::ID VPID) {
	switch (VPID) {
	default:
	break;
	#define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
	#define VP_PROPERTY_MEMOP(POINTERPOS, ...) return POINTERPOS;
	#define END_REGISTER_VP_INTRINSIC(VPID) break;
	#include "llvm/IR/VPIntrinsics.def"
	}
	return None;
	}

	/// \return The data (payload) operand of this store or scatter.
	Value *VPIntrinsic::getMemoryDataParam() const {
	auto DataParamOpt = getMemoryDataParamPos(getIntrinsicID());
	if (!DataParamOpt.hasValue())
	return nullptr;
	return getArgOperand(DataParamOpt.getValue());
	}

	Optional<unsigned> VPIntrinsic::getMemoryDataParamPos(Intrinsic::ID VPID) {
	switch (VPID) {
	default:
	break;
	#define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
	#define VP_PROPERTY_MEMOP(POINTERPOS, DATAPOS) return DATAPOS;
	#define END_REGISTER_VP_INTRINSIC(VPID) break;
	#include "llvm/IR/VPIntrinsics.def"
	}
	return None;
	}

	bool VPIntrinsic::isVPIntrinsic(Intrinsic::ID ID) {
	switch (ID) {
	default:
	break;
	#define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS) \
	case Intrinsic::VPID: \
	return true;
	#include "llvm/IR/VPIntrinsics.def"
	}
	return false;
	}

	// Equivalent non-predicated opcode
	Optional<unsigned> VPIntrinsic::getFunctionalOpcodeForVP(Intrinsic::ID ID) {
	switch (ID) {
	default:
	break;
	#define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
	#define VP_PROPERTY_FUNCTIONAL_OPC(OPC) return Instruction::OPC;
	#define END_REGISTER_VP_INTRINSIC(VPID) break;
	#include "llvm/IR/VPIntrinsics.def"
	}
	return None;
	}

	Intrinsic::ID VPIntrinsic::getForOpcode(unsigned IROPC) {
	switch (IROPC) {
	default:
	break;

	#define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) break;
	#define VP_PROPERTY_FUNCTIONAL_OPC(OPC) case Instruction::OPC:
	#define END_REGISTER_VP_INTRINSIC(VPID) return Intrinsic::VPID;
	#include "llvm/IR/VPIntrinsics.def"
	}
	return Intrinsic::not_intrinsic;
	}

	bool VPIntrinsic::canIgnoreVectorLengthParam() const {
	using namespace PatternMatch;

	ElementCount EC = getStaticVectorLength();

	// No vlen param - no lanes masked-off by it.
	auto *VLParam = getVectorLengthParam();
	if (!VLParam)
	return true;

	// Note that the VP intrinsic causes undefined behavior if the Explicit Vector
	// Length parameter is strictly greater-than the number of vector elements of
	// the operation. This function returns true when this is detected statically
	// in the IR.

	// Check whether "W == vscale * EC.getKnownMinValue()"
	if (EC.isScalable()) {
	// Undig the DL
	const auto *ParMod = this->getModule();
	if (!ParMod)
	return false;
	const auto &DL = ParMod->getDataLayout();

	// Compare vscale patterns
	uint64_t VScaleFactor;
	if (match(VLParam, m_c_Mul(m_ConstantInt(VScaleFactor), m_VScale(DL))))
	return VScaleFactor >= EC.getKnownMinValue();
	return (EC.getKnownMinValue() == 1) && match(VLParam, m_VScale(DL));
	}

	// standard SIMD operation
	const auto *VLConst = dyn_cast<ConstantInt>(VLParam);
	if (!VLConst)
	return false;

	uint64_t VLNum = VLConst->getZExtValue();
	if (VLNum >= EC.getKnownMinValue())
	return true;

	return false;
	}

	Function VPIntrinsic::getDeclarationForParams(Module M, Intrinsic::ID VPID,
	ArrayRef<Value *> Params) {
	assert(isVPIntrinsic(VPID) && "not a VP intrinsic");
	Function *VPFunc;
	switch (VPID) {
	default: {
	Type *OverloadTy = Params[0]->getType();
	if (VPReductionIntrinsic::isVPReduction(VPID))
	OverloadTy =
	Params[*VPReductionIntrinsic::getVectorParamPos(VPID)]->getType();

	VPFunc = Intrinsic::getDeclaration(M, VPID, OverloadTy);
	break;
	}
	case Intrinsic::vp_select:
	VPFunc = Intrinsic::getDeclaration(M, VPID, {Params[1]->getType()});
	break;
	case Intrinsic::vp_load:
	VPFunc = Intrinsic::getDeclaration(
	M, VPID,
	{Params[0]->getType()->getPointerElementType(), Params[0]->getType()});
	break;
	case Intrinsic::vp_gather:
	VPFunc = Intrinsic::getDeclaration(
	M, VPID,
	{VectorType::get(cast<VectorType>(Params[0]->getType())
	->getElementType()
	->getPointerElementType(),
	cast<VectorType>(Params[0]->getType())),
	Params[0]->getType()});
	break;
	case Intrinsic::vp_store:
	VPFunc = Intrinsic::getDeclaration(
	M, VPID,
	{Params[1]->getType()->getPointerElementType(), Params[1]->getType()});
	break;
	case Intrinsic::vp_scatter:
	VPFunc = Intrinsic::getDeclaration(
	M, VPID, {Params[0]->getType(), Params[1]->getType()});
	break;
	}
	assert(VPFunc && "Could not declare VP intrinsic");
	return VPFunc;
	}

	bool VPReductionIntrinsic::isVPReduction(Intrinsic::ID ID) {
	switch (ID) {
	default:
	break;
	#define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
	#define VP_PROPERTY_REDUCTION(STARTPOS, ...) return true;
	#define END_REGISTER_VP_INTRINSIC(VPID) break;
	#include "llvm/IR/VPIntrinsics.def"
	}
	return false;
	}

	unsigned VPReductionIntrinsic::getVectorParamPos() const {
	return *VPReductionIntrinsic::getVectorParamPos(getIntrinsicID());
	}

	unsigned VPReductionIntrinsic::getStartParamPos() const {
	return *VPReductionIntrinsic::getStartParamPos(getIntrinsicID());
	}

	Optional<unsigned> VPReductionIntrinsic::getVectorParamPos(Intrinsic::ID ID) {
	switch (ID) {
	#define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
	#define VP_PROPERTY_REDUCTION(STARTPOS, VECTORPOS) return VECTORPOS;
	#define END_REGISTER_VP_INTRINSIC(VPID) break;
	#include "llvm/IR/VPIntrinsics.def"
	default:
	break;
	}
	return None;
	}

	Optional<unsigned> VPReductionIntrinsic::getStartParamPos(Intrinsic::ID ID) {
	switch (ID) {
	#define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
	#define VP_PROPERTY_REDUCTION(STARTPOS, VECTORPOS) return STARTPOS;
	#define END_REGISTER_VP_INTRINSIC(VPID) break;
	#include "llvm/IR/VPIntrinsics.def"
	default:
	break;
	}
	return None;
	}

	Instruction::BinaryOps BinaryOpIntrinsic::getBinaryOp() const {
	switch (getIntrinsicID()) {
	case Intrinsic::uadd_with_overflow:
	case Intrinsic::sadd_with_overflow:
	case Intrinsic::uadd_sat:
	case Intrinsic::sadd_sat:
	return Instruction::Add;
	case Intrinsic::usub_with_overflow:
	case Intrinsic::ssub_with_overflow:
	case Intrinsic::usub_sat:
	case Intrinsic::ssub_sat:
	return Instruction::Sub;
	case Intrinsic::umul_with_overflow:
	case Intrinsic::smul_with_overflow:
	return Instruction::Mul;
	default:
	llvm_unreachable("Invalid intrinsic");
	}
	}

	bool BinaryOpIntrinsic::isSigned() const {
	switch (getIntrinsicID()) {
	case Intrinsic::sadd_with_overflow:
	case Intrinsic::ssub_with_overflow:
	case Intrinsic::smul_with_overflow:
	case Intrinsic::sadd_sat:
	case Intrinsic::ssub_sat:
	return true;
	default:
	return false;
	}
	}

	unsigned BinaryOpIntrinsic::getNoWrapKind() const {
	if (isSigned())
	return OverflowingBinaryOperator::NoSignedWrap;
	else
	return OverflowingBinaryOperator::NoUnsignedWrap;
	}

	const GCStatepointInst *GCProjectionInst::getStatepoint() const {
	const Value *Token = getArgOperand(0);

	// This takes care both of relocates for call statepoints and relocates
	// on normal path of invoke statepoint.
	if (!isa<LandingPadInst>(Token))
	return cast<GCStatepointInst>(Token);

	// This relocate is on exceptional path of an invoke statepoint
	const BasicBlock *InvokeBB =
	cast<Instruction>(Token)->getParent()->getUniquePredecessor();

	assert(InvokeBB && "safepoints should have unique landingpads");
	assert(InvokeBB->getTerminator() &&
	"safepoint block should be well formed");

	return cast<GCStatepointInst>(InvokeBB->getTerminator());
	}

	Value *GCRelocateInst::getBasePtr() const {
	if (auto Opt = getStatepoint()->getOperandBundle(LLVMContext::OB_gc_live))
	return *(Opt->Inputs.begin() + getBasePtrIndex());
	return *(getStatepoint()->arg_begin() + getBasePtrIndex());
	}

	Value *GCRelocateInst::getDerivedPtr() const {
	if (auto Opt = getStatepoint()->getOperandBundle(LLVMContext::OB_gc_live))
	return *(Opt->Inputs.begin() + getDerivedPtrIndex());
	return *(getStatepoint()->arg_begin() + getDerivedPtrIndex());
	}