1 //===-- InstrinsicInst.cpp - Intrinsic Instruction Wrappers ---------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements methods that make it really easy to deal with intrinsic 10 // functions. 11 // 12 // All intrinsic function calls are instances of the call instruction, so these 13 // are all subclasses of the CallInst class. Note that none of these classes 14 // has state or virtual methods, which is an important part of this gross/neat 15 // hack working. 16 // 17 // In some cases, arguments to intrinsics need to be generic and are defined as 18 // type pointer to empty struct { }*. To access the real item of interest the 19 // cast instruction needs to be stripped away. 20 // 21 //===----------------------------------------------------------------------===// 22 23 #include "llvm/IR/IntrinsicInst.h" 24 #include "llvm/IR/Operator.h" 25 #include "llvm/ADT/StringSwitch.h" 26 #include "llvm/IR/Constants.h" 27 #include "llvm/IR/DebugInfoMetadata.h" 28 #include "llvm/IR/GlobalVariable.h" 29 #include "llvm/IR/Metadata.h" 30 #include "llvm/IR/Module.h" 31 #include "llvm/Support/raw_ostream.h" 32 using namespace llvm; 33 34 //===----------------------------------------------------------------------===// 35 /// DbgVariableIntrinsic - This is the common base class for debug info 36 /// intrinsics for variables. 37 /// 38 39 Value *DbgVariableIntrinsic::getVariableLocation(bool AllowNullOp) const { 40 Value *Op = getArgOperand(0); 41 if (AllowNullOp && !Op) 42 return nullptr; 43 44 auto *MD = cast<MetadataAsValue>(Op)->getMetadata(); 45 if (auto *V = dyn_cast<ValueAsMetadata>(MD)) 46 return V->getValue(); 47 48 // When the value goes to null, it gets replaced by an empty MDNode. 49 assert(!cast<MDNode>(MD)->getNumOperands() && "Expected an empty MDNode"); 50 return nullptr; 51 } 52 53 Optional<uint64_t> DbgVariableIntrinsic::getFragmentSizeInBits() const { 54 if (auto Fragment = getExpression()->getFragmentInfo()) 55 return Fragment->SizeInBits; 56 return getVariable()->getSizeInBits(); 57 } 58 59 int llvm::Intrinsic::lookupLLVMIntrinsicByName(ArrayRef<const char *> NameTable, 60 StringRef Name) { 61 assert(Name.startswith("llvm.")); 62 63 // Do successive binary searches of the dotted name components. For 64 // "llvm.gc.experimental.statepoint.p1i8.p1i32", we will find the range of 65 // intrinsics starting with "llvm.gc", then "llvm.gc.experimental", then 66 // "llvm.gc.experimental.statepoint", and then we will stop as the range is 67 // size 1. During the search, we can skip the prefix that we already know is 68 // identical. By using strncmp we consider names with differing suffixes to 69 // be part of the equal range. 70 size_t CmpStart = 0; 71 size_t CmpEnd = 4; // Skip the "llvm" component. 72 const char *const *Low = NameTable.begin(); 73 const char *const *High = NameTable.end(); 74 const char *const *LastLow = Low; 75 while (CmpEnd < Name.size() && High - Low > 0) { 76 CmpStart = CmpEnd; 77 CmpEnd = Name.find('.', CmpStart + 1); 78 CmpEnd = CmpEnd == StringRef::npos ? Name.size() : CmpEnd; 79 auto Cmp = [CmpStart, CmpEnd](const char *LHS, const char *RHS) { 80 return strncmp(LHS + CmpStart, RHS + CmpStart, CmpEnd - CmpStart) < 0; 81 }; 82 LastLow = Low; 83 std::tie(Low, High) = std::equal_range(Low, High, Name.data(), Cmp); 84 } 85 if (High - Low > 0) 86 LastLow = Low; 87 88 if (LastLow == NameTable.end()) 89 return -1; 90 StringRef NameFound = *LastLow; 91 if (Name == NameFound || 92 (Name.startswith(NameFound) && Name[NameFound.size()] == '.')) 93 return LastLow - NameTable.begin(); 94 return -1; 95 } 96 97 Value *InstrProfIncrementInst::getStep() const { 98 if (InstrProfIncrementInstStep::classof(this)) { 99 return const_cast<Value *>(getArgOperand(4)); 100 } 101 const Module *M = getModule(); 102 LLVMContext &Context = M->getContext(); 103 return ConstantInt::get(Type::getInt64Ty(Context), 1); 104 } 105 106 ConstrainedFPIntrinsic::RoundingMode 107 ConstrainedFPIntrinsic::getRoundingMode() const { 108 unsigned NumOperands = getNumArgOperands(); 109 Metadata *MD = 110 dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 2))->getMetadata(); 111 if (!MD || !isa<MDString>(MD)) 112 return rmInvalid; 113 StringRef RoundingArg = cast<MDString>(MD)->getString(); 114 115 // For dynamic rounding mode, we use round to nearest but we will set the 116 // 'exact' SDNodeFlag so that the value will not be rounded. 117 return StringSwitch<RoundingMode>(RoundingArg) 118 .Case("round.dynamic", rmDynamic) 119 .Case("round.tonearest", rmToNearest) 120 .Case("round.downward", rmDownward) 121 .Case("round.upward", rmUpward) 122 .Case("round.towardzero", rmTowardZero) 123 .Default(rmInvalid); 124 } 125 126 ConstrainedFPIntrinsic::ExceptionBehavior 127 ConstrainedFPIntrinsic::getExceptionBehavior() const { 128 unsigned NumOperands = getNumArgOperands(); 129 Metadata *MD = 130 dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 1))->getMetadata(); 131 if (!MD || !isa<MDString>(MD)) 132 return ebInvalid; 133 StringRef ExceptionArg = cast<MDString>(MD)->getString(); 134 return StringSwitch<ExceptionBehavior>(ExceptionArg) 135 .Case("fpexcept.ignore", ebIgnore) 136 .Case("fpexcept.maytrap", ebMayTrap) 137 .Case("fpexcept.strict", ebStrict) 138 .Default(ebInvalid); 139 } 140 141 bool ConstrainedFPIntrinsic::isUnaryOp() const { 142 switch (getIntrinsicID()) { 143 default: 144 return false; 145 case Intrinsic::experimental_constrained_fptrunc: 146 case Intrinsic::experimental_constrained_fpext: 147 case Intrinsic::experimental_constrained_sqrt: 148 case Intrinsic::experimental_constrained_sin: 149 case Intrinsic::experimental_constrained_cos: 150 case Intrinsic::experimental_constrained_exp: 151 case Intrinsic::experimental_constrained_exp2: 152 case Intrinsic::experimental_constrained_log: 153 case Intrinsic::experimental_constrained_log10: 154 case Intrinsic::experimental_constrained_log2: 155 case Intrinsic::experimental_constrained_rint: 156 case Intrinsic::experimental_constrained_nearbyint: 157 case Intrinsic::experimental_constrained_ceil: 158 case Intrinsic::experimental_constrained_floor: 159 case Intrinsic::experimental_constrained_round: 160 case Intrinsic::experimental_constrained_trunc: 161 return true; 162 } 163 } 164 165 bool ConstrainedFPIntrinsic::isTernaryOp() const { 166 switch (getIntrinsicID()) { 167 default: 168 return false; 169 case Intrinsic::experimental_constrained_fma: 170 return true; 171 } 172 } 173 174 Instruction::BinaryOps BinaryOpIntrinsic::getBinaryOp() const { 175 switch (getIntrinsicID()) { 176 case Intrinsic::uadd_with_overflow: 177 case Intrinsic::sadd_with_overflow: 178 case Intrinsic::uadd_sat: 179 case Intrinsic::sadd_sat: 180 return Instruction::Add; 181 case Intrinsic::usub_with_overflow: 182 case Intrinsic::ssub_with_overflow: 183 case Intrinsic::usub_sat: 184 case Intrinsic::ssub_sat: 185 return Instruction::Sub; 186 case Intrinsic::umul_with_overflow: 187 case Intrinsic::smul_with_overflow: 188 return Instruction::Mul; 189 default: 190 llvm_unreachable("Invalid intrinsic"); 191 } 192 } 193 194 bool BinaryOpIntrinsic::isSigned() const { 195 switch (getIntrinsicID()) { 196 case Intrinsic::sadd_with_overflow: 197 case Intrinsic::ssub_with_overflow: 198 case Intrinsic::smul_with_overflow: 199 case Intrinsic::sadd_sat: 200 case Intrinsic::ssub_sat: 201 return true; 202 default: 203 return false; 204 } 205 } 206 207 unsigned BinaryOpIntrinsic::getNoWrapKind() const { 208 if (isSigned()) 209 return OverflowingBinaryOperator::NoSignedWrap; 210 else 211 return OverflowingBinaryOperator::NoUnsignedWrap; 212 } 213