1 //===-- InstrinsicInst.cpp - Intrinsic Instruction Wrappers ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements methods that make it really easy to deal with intrinsic
13 // All intrinsic function calls are instances of the call instruction, so these
14 // are all subclasses of the CallInst class. Note that none of these classes
15 // has state or virtual methods, which is an important part of this gross/neat
18 // In some cases, arguments to intrinsics need to be generic and are defined as
19 // type pointer to empty struct { }*. To access the real item of interest the
20 // cast instruction needs to be stripped away.
22 //===----------------------------------------------------------------------===//
24 #include "llvm/IR/IntrinsicInst.h"
25 #include "llvm/ADT/StringSwitch.h"
26 #include "llvm/IR/Constants.h"
27 #include "llvm/IR/GlobalVariable.h"
28 #include "llvm/IR/Metadata.h"
29 #include "llvm/IR/Module.h"
30 #include "llvm/Support/raw_ostream.h"
33 //===----------------------------------------------------------------------===//
34 /// DbgInfoIntrinsic - This is the common base class for debug info intrinsics
37 Value *DbgInfoIntrinsic::getVariableLocation(bool AllowNullOp) const {
38 Value *Op = getArgOperand(0);
39 if (AllowNullOp && !Op)
42 auto *MD = cast<MetadataAsValue>(Op)->getMetadata();
43 if (auto *V = dyn_cast<ValueAsMetadata>(MD))
46 // When the value goes to null, it gets replaced by an empty MDNode.
47 assert(!cast<MDNode>(MD)->getNumOperands() && "Expected an empty MDNode");
51 int llvm::Intrinsic::lookupLLVMIntrinsicByName(ArrayRef<const char *> NameTable,
53 assert(Name.startswith("llvm."));
55 // Do successive binary searches of the dotted name components. For
56 // "llvm.gc.experimental.statepoint.p1i8.p1i32", we will find the range of
57 // intrinsics starting with "llvm.gc", then "llvm.gc.experimental", then
58 // "llvm.gc.experimental.statepoint", and then we will stop as the range is
59 // size 1. During the search, we can skip the prefix that we already know is
60 // identical. By using strncmp we consider names with differing suffixes to
61 // be part of the equal range.
63 size_t CmpEnd = 4; // Skip the "llvm" component.
64 const char *const *Low = NameTable.begin();
65 const char *const *High = NameTable.end();
66 const char *const *LastLow = Low;
67 while (CmpEnd < Name.size() && High - Low > 0) {
69 CmpEnd = Name.find('.', CmpStart + 1);
70 CmpEnd = CmpEnd == StringRef::npos ? Name.size() : CmpEnd;
71 auto Cmp = [CmpStart, CmpEnd](const char *LHS, const char *RHS) {
72 return strncmp(LHS + CmpStart, RHS + CmpStart, CmpEnd - CmpStart) < 0;
75 std::tie(Low, High) = std::equal_range(Low, High, Name.data(), Cmp);
80 if (LastLow == NameTable.end())
82 StringRef NameFound = *LastLow;
83 if (Name == NameFound ||
84 (Name.startswith(NameFound) && Name[NameFound.size()] == '.'))
85 return LastLow - NameTable.begin();
89 Value *InstrProfIncrementInst::getStep() const {
90 if (InstrProfIncrementInstStep::classof(this)) {
91 return const_cast<Value *>(getArgOperand(4));
93 const Module *M = getModule();
94 LLVMContext &Context = M->getContext();
95 return ConstantInt::get(Type::getInt64Ty(Context), 1);
98 ConstrainedFPIntrinsic::RoundingMode
99 ConstrainedFPIntrinsic::getRoundingMode() const {
100 unsigned NumOperands = getNumArgOperands();
102 dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 2))->getMetadata();
103 if (!MD || !isa<MDString>(MD))
105 StringRef RoundingArg = cast<MDString>(MD)->getString();
107 // For dynamic rounding mode, we use round to nearest but we will set the
108 // 'exact' SDNodeFlag so that the value will not be rounded.
109 return StringSwitch<RoundingMode>(RoundingArg)
110 .Case("round.dynamic", rmDynamic)
111 .Case("round.tonearest", rmToNearest)
112 .Case("round.downward", rmDownward)
113 .Case("round.upward", rmUpward)
114 .Case("round.towardzero", rmTowardZero)
118 ConstrainedFPIntrinsic::ExceptionBehavior
119 ConstrainedFPIntrinsic::getExceptionBehavior() const {
120 unsigned NumOperands = getNumArgOperands();
122 dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 1))->getMetadata();
123 if (!MD || !isa<MDString>(MD))
125 StringRef ExceptionArg = cast<MDString>(MD)->getString();
126 return StringSwitch<ExceptionBehavior>(ExceptionArg)
127 .Case("fpexcept.ignore", ebIgnore)
128 .Case("fpexcept.maytrap", ebMayTrap)
129 .Case("fpexcept.strict", ebStrict)
133 bool ConstrainedFPIntrinsic::isUnaryOp() const {
134 switch (getIntrinsicID()) {
137 case Intrinsic::experimental_constrained_sqrt:
138 case Intrinsic::experimental_constrained_sin:
139 case Intrinsic::experimental_constrained_cos:
140 case Intrinsic::experimental_constrained_exp:
141 case Intrinsic::experimental_constrained_exp2:
142 case Intrinsic::experimental_constrained_log:
143 case Intrinsic::experimental_constrained_log10:
144 case Intrinsic::experimental_constrained_log2:
145 case Intrinsic::experimental_constrained_rint:
146 case Intrinsic::experimental_constrained_nearbyint:
151 bool ConstrainedFPIntrinsic::isTernaryOp() const {
152 switch (getIntrinsicID()) {
155 case Intrinsic::experimental_constrained_fma: