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 Optional<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 None; 113 return StrToRoundingMode(cast<MDString>(MD)->getString()); 114 } 115 116 Optional<ConstrainedFPIntrinsic::RoundingMode> 117 ConstrainedFPIntrinsic::StrToRoundingMode(StringRef RoundingArg) { 118 // For dynamic rounding mode, we use round to nearest but we will set the 119 // 'exact' SDNodeFlag so that the value will not be rounded. 120 return StringSwitch<Optional<RoundingMode>>(RoundingArg) 121 .Case("round.dynamic", rmDynamic) 122 .Case("round.tonearest", rmToNearest) 123 .Case("round.downward", rmDownward) 124 .Case("round.upward", rmUpward) 125 .Case("round.towardzero", rmTowardZero) 126 .Default(None); 127 } 128 129 Optional<StringRef> 130 ConstrainedFPIntrinsic::RoundingModeToStr(RoundingMode UseRounding) { 131 Optional<StringRef> RoundingStr = None; 132 switch (UseRounding) { 133 case ConstrainedFPIntrinsic::rmDynamic: 134 RoundingStr = "round.dynamic"; 135 break; 136 case ConstrainedFPIntrinsic::rmToNearest: 137 RoundingStr = "round.tonearest"; 138 break; 139 case ConstrainedFPIntrinsic::rmDownward: 140 RoundingStr = "round.downward"; 141 break; 142 case ConstrainedFPIntrinsic::rmUpward: 143 RoundingStr = "round.upward"; 144 break; 145 case ConstrainedFPIntrinsic::rmTowardZero: 146 RoundingStr = "round.tozero"; 147 break; 148 } 149 return RoundingStr; 150 } 151 152 Optional<ConstrainedFPIntrinsic::ExceptionBehavior> 153 ConstrainedFPIntrinsic::getExceptionBehavior() const { 154 unsigned NumOperands = getNumArgOperands(); 155 Metadata *MD = 156 dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 1))->getMetadata(); 157 if (!MD || !isa<MDString>(MD)) 158 return None; 159 return StrToExceptionBehavior(cast<MDString>(MD)->getString()); 160 } 161 162 Optional<ConstrainedFPIntrinsic::ExceptionBehavior> 163 ConstrainedFPIntrinsic::StrToExceptionBehavior(StringRef ExceptionArg) { 164 return StringSwitch<Optional<ExceptionBehavior>>(ExceptionArg) 165 .Case("fpexcept.ignore", ebIgnore) 166 .Case("fpexcept.maytrap", ebMayTrap) 167 .Case("fpexcept.strict", ebStrict) 168 .Default(None); 169 } 170 171 Optional<StringRef> 172 ConstrainedFPIntrinsic::ExceptionBehaviorToStr(ExceptionBehavior UseExcept) { 173 Optional<StringRef> ExceptStr = None; 174 switch (UseExcept) { 175 case ConstrainedFPIntrinsic::ebStrict: 176 ExceptStr = "fpexcept.strict"; 177 break; 178 case ConstrainedFPIntrinsic::ebIgnore: 179 ExceptStr = "fpexcept.ignore"; 180 break; 181 case ConstrainedFPIntrinsic::ebMayTrap: 182 ExceptStr = "fpexcept.maytrap"; 183 break; 184 } 185 return ExceptStr; 186 } 187 188 bool ConstrainedFPIntrinsic::isUnaryOp() const { 189 switch (getIntrinsicID()) { 190 default: 191 return false; 192 case Intrinsic::experimental_constrained_fptrunc: 193 case Intrinsic::experimental_constrained_fpext: 194 case Intrinsic::experimental_constrained_sqrt: 195 case Intrinsic::experimental_constrained_sin: 196 case Intrinsic::experimental_constrained_cos: 197 case Intrinsic::experimental_constrained_exp: 198 case Intrinsic::experimental_constrained_exp2: 199 case Intrinsic::experimental_constrained_log: 200 case Intrinsic::experimental_constrained_log10: 201 case Intrinsic::experimental_constrained_log2: 202 case Intrinsic::experimental_constrained_rint: 203 case Intrinsic::experimental_constrained_nearbyint: 204 case Intrinsic::experimental_constrained_ceil: 205 case Intrinsic::experimental_constrained_floor: 206 case Intrinsic::experimental_constrained_round: 207 case Intrinsic::experimental_constrained_trunc: 208 return true; 209 } 210 } 211 212 bool ConstrainedFPIntrinsic::isTernaryOp() const { 213 switch (getIntrinsicID()) { 214 default: 215 return false; 216 case Intrinsic::experimental_constrained_fma: 217 return true; 218 } 219 } 220 221 Instruction::BinaryOps BinaryOpIntrinsic::getBinaryOp() const { 222 switch (getIntrinsicID()) { 223 case Intrinsic::uadd_with_overflow: 224 case Intrinsic::sadd_with_overflow: 225 case Intrinsic::uadd_sat: 226 case Intrinsic::sadd_sat: 227 return Instruction::Add; 228 case Intrinsic::usub_with_overflow: 229 case Intrinsic::ssub_with_overflow: 230 case Intrinsic::usub_sat: 231 case Intrinsic::ssub_sat: 232 return Instruction::Sub; 233 case Intrinsic::umul_with_overflow: 234 case Intrinsic::smul_with_overflow: 235 return Instruction::Mul; 236 default: 237 llvm_unreachable("Invalid intrinsic"); 238 } 239 } 240 241 bool BinaryOpIntrinsic::isSigned() const { 242 switch (getIntrinsicID()) { 243 case Intrinsic::sadd_with_overflow: 244 case Intrinsic::ssub_with_overflow: 245 case Intrinsic::smul_with_overflow: 246 case Intrinsic::sadd_sat: 247 case Intrinsic::ssub_sat: 248 return true; 249 default: 250 return false; 251 } 252 } 253 254 unsigned BinaryOpIntrinsic::getNoWrapKind() const { 255 if (isSigned()) 256 return OverflowingBinaryOperator::NoSignedWrap; 257 else 258 return OverflowingBinaryOperator::NoUnsignedWrap; 259 } 260