LLVM  13.0.0git
IntrinsicInst.cpp
Go to the documentation of this file.
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/ADT/StringSwitch.h"
25 #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/IR/Operator.h"
31 #include "llvm/IR/PatternMatch.h"
32 #include "llvm/IR/Statepoint.h"
33 
35 using namespace llvm;
36 
37 //===----------------------------------------------------------------------===//
38 /// DbgVariableIntrinsic - This is the common base class for debug info
39 /// intrinsics for variables.
40 ///
41 
44  auto *MD = getRawLocation();
45  assert(MD && "First operand of DbgVariableIntrinsic should be non-null.");
46 
47  // If operand is ValueAsMetadata, return a range over just that operand.
48  if (auto *VAM = dyn_cast<ValueAsMetadata>(MD)) {
49  return {location_op_iterator(VAM), location_op_iterator(VAM + 1)};
50  }
51  // If operand is DIArgList, return a range over its args.
52  if (auto *AL = dyn_cast<DIArgList>(MD))
53  return {location_op_iterator(AL->args_begin()),
54  location_op_iterator(AL->args_end())};
55  // Operand must be an empty metadata tuple, so return empty iterator.
56  return {location_op_iterator(static_cast<ValueAsMetadata *>(nullptr)),
57  location_op_iterator(static_cast<ValueAsMetadata *>(nullptr))};
58 }
59 
61  auto *MD = getRawLocation();
62  assert(MD && "First operand of DbgVariableIntrinsic should be non-null.");
63  if (auto *AL = dyn_cast<DIArgList>(MD))
64  return AL->getArgs()[OpIdx]->getValue();
65  if (isa<MDNode>(MD))
66  return nullptr;
67  assert(
68  isa<ValueAsMetadata>(MD) &&
69  "Attempted to get location operand from DbgVariableIntrinsic with none.");
70  auto *V = cast<ValueAsMetadata>(MD);
71  assert(OpIdx == 0 && "Operand Index must be 0 for a debug intrinsic with a "
72  "single location operand.");
73  return V->getValue();
74 }
75 
77  return isa<MetadataAsValue>(V) ? dyn_cast<ValueAsMetadata>(
78  cast<MetadataAsValue>(V)->getMetadata())
80 }
81 
83  Value *NewValue) {
84  assert(NewValue && "Values must be non-null");
85  auto Locations = location_ops();
86  auto OldIt = find(Locations, OldValue);
87  assert(OldIt != Locations.end() && "OldValue must be a current location");
88  if (!hasArgList()) {
89  Value *NewOperand = isa<MetadataAsValue>(NewValue)
90  ? NewValue
92  getContext(), ValueAsMetadata::get(NewValue));
93  return setArgOperand(0, NewOperand);
94  }
96  ValueAsMetadata *NewOperand = getAsMetadata(NewValue);
97  for (auto *VMD : Locations)
98  MDs.push_back(VMD == *OldIt ? NewOperand : getAsMetadata(VMD));
99  setArgOperand(
101 }
103  Value *NewValue) {
104  assert(OpIdx < getNumVariableLocationOps() && "Invalid Operand Index");
105  if (!hasArgList()) {
106  Value *NewOperand = isa<MetadataAsValue>(NewValue)
107  ? NewValue
109  getContext(), ValueAsMetadata::get(NewValue));
110  return setArgOperand(0, NewOperand);
111  }
113  ValueAsMetadata *NewOperand = getAsMetadata(NewValue);
114  for (unsigned Idx = 0; Idx < getNumVariableLocationOps(); ++Idx)
115  MDs.push_back(Idx == OpIdx ? NewOperand
117  setArgOperand(
119 }
120 
122  if (auto Fragment = getExpression()->getFragmentInfo())
123  return Fragment->SizeInBits;
124  return getVariable()->getSizeInBits();
125 }
126 
128  StringRef Name) {
129  assert(Name.startswith("llvm."));
130 
131  // Do successive binary searches of the dotted name components. For
132  // "llvm.gc.experimental.statepoint.p1i8.p1i32", we will find the range of
133  // intrinsics starting with "llvm.gc", then "llvm.gc.experimental", then
134  // "llvm.gc.experimental.statepoint", and then we will stop as the range is
135  // size 1. During the search, we can skip the prefix that we already know is
136  // identical. By using strncmp we consider names with differing suffixes to
137  // be part of the equal range.
138  size_t CmpEnd = 4; // Skip the "llvm" component.
139  const char *const *Low = NameTable.begin();
140  const char *const *High = NameTable.end();
141  const char *const *LastLow = Low;
142  while (CmpEnd < Name.size() && High - Low > 0) {
143  size_t CmpStart = CmpEnd;
144  CmpEnd = Name.find('.', CmpStart + 1);
145  CmpEnd = CmpEnd == StringRef::npos ? Name.size() : CmpEnd;
146  auto Cmp = [CmpStart, CmpEnd](const char *LHS, const char *RHS) {
147  return strncmp(LHS + CmpStart, RHS + CmpStart, CmpEnd - CmpStart) < 0;
148  };
149  LastLow = Low;
150  std::tie(Low, High) = std::equal_range(Low, High, Name.data(), Cmp);
151  }
152  if (High - Low > 0)
153  LastLow = Low;
154 
155  if (LastLow == NameTable.end())
156  return -1;
157  StringRef NameFound = *LastLow;
158  if (Name == NameFound ||
159  (Name.startswith(NameFound) && Name[NameFound.size()] == '.'))
160  return LastLow - NameTable.begin();
161  return -1;
162 }
163 
166  return const_cast<Value *>(getArgOperand(4));
167  }
168  const Module *M = getModule();
169  LLVMContext &Context = M->getContext();
171 }
172 
174  unsigned NumOperands = getNumArgOperands();
175  Metadata *MD =
176  cast<MetadataAsValue>(getArgOperand(NumOperands - 2))->getMetadata();
177  if (!MD || !isa<MDString>(MD))
178  return None;
179  return StrToRoundingMode(cast<MDString>(MD)->getString());
180 }
181 
184  unsigned NumOperands = getNumArgOperands();
185  Metadata *MD =
186  cast<MetadataAsValue>(getArgOperand(NumOperands - 1))->getMetadata();
187  if (!MD || !isa<MDString>(MD))
188  return None;
189  return StrToExceptionBehavior(cast<MDString>(MD)->getString());
190 }
191 
193  Metadata *MD = cast<MetadataAsValue>(getArgOperand(2))->getMetadata();
194  if (!MD || !isa<MDString>(MD))
196  return StringSwitch<FCmpInst::Predicate>(cast<MDString>(MD)->getString())
197  .Case("oeq", FCmpInst::FCMP_OEQ)
198  .Case("ogt", FCmpInst::FCMP_OGT)
199  .Case("oge", FCmpInst::FCMP_OGE)
200  .Case("olt", FCmpInst::FCMP_OLT)
201  .Case("ole", FCmpInst::FCMP_OLE)
202  .Case("one", FCmpInst::FCMP_ONE)
203  .Case("ord", FCmpInst::FCMP_ORD)
204  .Case("uno", FCmpInst::FCMP_UNO)
205  .Case("ueq", FCmpInst::FCMP_UEQ)
206  .Case("ugt", FCmpInst::FCMP_UGT)
207  .Case("uge", FCmpInst::FCMP_UGE)
208  .Case("ult", FCmpInst::FCMP_ULT)
209  .Case("ule", FCmpInst::FCMP_ULE)
210  .Case("une", FCmpInst::FCMP_UNE)
212 }
213 
215  switch (getIntrinsicID()) {
216  default:
217  return false;
218 #define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
219  case Intrinsic::INTRINSIC: \
220  return NARG == 1;
221 #include "llvm/IR/ConstrainedOps.def"
222  }
223 }
224 
226  switch (getIntrinsicID()) {
227  default:
228  return false;
229 #define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
230  case Intrinsic::INTRINSIC: \
231  return NARG == 3;
232 #include "llvm/IR/ConstrainedOps.def"
233  }
234 }
235 
237  switch (I->getIntrinsicID()) {
238 #define INSTRUCTION(NAME, NARGS, ROUND_MODE, INTRINSIC) \
239  case Intrinsic::INTRINSIC:
240 #include "llvm/IR/ConstrainedOps.def"
241  return true;
242  default:
243  return false;
244  }
245 }
246 
248  auto GetVectorLengthOfType = [](const Type *T) -> ElementCount {
249  auto VT = cast<VectorType>(T);
250  auto ElemCount = VT->getElementCount();
251  return ElemCount;
252  };
253 
254  auto VPMask = getMaskParam();
255  return GetVectorLengthOfType(VPMask->getType());
256 }
257 
259  auto maskPos = GetMaskParamPos(getIntrinsicID());
260  if (maskPos)
261  return getArgOperand(maskPos.getValue());
262  return nullptr;
263 }
264 
266  auto vlenPos = GetVectorLengthParamPos(getIntrinsicID());
267  if (vlenPos)
268  return getArgOperand(vlenPos.getValue());
269  return nullptr;
270 }
271 
273  switch (IntrinsicID) {
274  default:
275  return None;
276 
277 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS) \
278  case Intrinsic::VPID: \
279  return MASKPOS;
280 #include "llvm/IR/VPIntrinsics.def"
281  }
282 }
283 
285  switch (IntrinsicID) {
286  default:
287  return None;
288 
289 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS) \
290  case Intrinsic::VPID: \
291  return VLENPOS;
292 #include "llvm/IR/VPIntrinsics.def"
293  }
294 }
295 
297  switch (ID) {
298  default:
299  return false;
300 
301 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS) \
302  case Intrinsic::VPID: \
303  break;
304 #include "llvm/IR/VPIntrinsics.def"
305  }
306  return true;
307 }
308 
309 // Equivalent non-predicated opcode
311  unsigned FunctionalOC = Instruction::Call;
312  switch (ID) {
313  default:
314  break;
315 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
316 #define HANDLE_VP_TO_OPC(OPC) FunctionalOC = Instruction::OPC;
317 #define END_REGISTER_VP_INTRINSIC(...) break;
318 #include "llvm/IR/VPIntrinsics.def"
319  }
320 
321  return FunctionalOC;
322 }
323 
325  switch (IROPC) {
326  default:
328 
329 #define HANDLE_VP_TO_OPC(OPC) case Instruction::OPC:
330 #define END_REGISTER_VP_INTRINSIC(VPID) return Intrinsic::VPID;
331 #include "llvm/IR/VPIntrinsics.def"
332  }
333 }
334 
336  using namespace PatternMatch;
337 
339 
340  // No vlen param - no lanes masked-off by it.
341  auto *VLParam = getVectorLengthParam();
342  if (!VLParam)
343  return true;
344 
345  // Note that the VP intrinsic causes undefined behavior if the Explicit Vector
346  // Length parameter is strictly greater-than the number of vector elements of
347  // the operation. This function returns true when this is detected statically
348  // in the IR.
349 
350  // Check whether "W == vscale * EC.getKnownMinValue()"
351  if (EC.isScalable()) {
352  // Undig the DL
353  auto ParMod = this->getModule();
354  if (!ParMod)
355  return false;
356  const auto &DL = ParMod->getDataLayout();
357 
358  // Compare vscale patterns
359  uint64_t VScaleFactor;
360  if (match(VLParam, m_c_Mul(m_ConstantInt(VScaleFactor), m_VScale(DL))))
361  return VScaleFactor >= EC.getKnownMinValue();
362  return (EC.getKnownMinValue() == 1) && match(VLParam, m_VScale(DL));
363  }
364 
365  // standard SIMD operation
366  auto VLConst = dyn_cast<ConstantInt>(VLParam);
367  if (!VLConst)
368  return false;
369 
370  uint64_t VLNum = VLConst->getZExtValue();
371  if (VLNum >= EC.getKnownMinValue())
372  return true;
373 
374  return false;
375 }
376 
378  switch (getIntrinsicID()) {
379  case Intrinsic::uadd_with_overflow:
380  case Intrinsic::sadd_with_overflow:
381  case Intrinsic::uadd_sat:
382  case Intrinsic::sadd_sat:
383  return Instruction::Add;
384  case Intrinsic::usub_with_overflow:
385  case Intrinsic::ssub_with_overflow:
386  case Intrinsic::usub_sat:
387  case Intrinsic::ssub_sat:
388  return Instruction::Sub;
389  case Intrinsic::umul_with_overflow:
390  case Intrinsic::smul_with_overflow:
391  return Instruction::Mul;
392  default:
393  llvm_unreachable("Invalid intrinsic");
394  }
395 }
396 
398  switch (getIntrinsicID()) {
399  case Intrinsic::sadd_with_overflow:
400  case Intrinsic::ssub_with_overflow:
401  case Intrinsic::smul_with_overflow:
402  case Intrinsic::sadd_sat:
403  case Intrinsic::ssub_sat:
404  return true;
405  default:
406  return false;
407  }
408 }
409 
411  if (isSigned())
413  else
415 }
416 
418  const Value *Token = getArgOperand(0);
419 
420  // This takes care both of relocates for call statepoints and relocates
421  // on normal path of invoke statepoint.
422  if (!isa<LandingPadInst>(Token))
423  return cast<GCStatepointInst>(Token);
424 
425  // This relocate is on exceptional path of an invoke statepoint
426  const BasicBlock *InvokeBB =
427  cast<Instruction>(Token)->getParent()->getUniquePredecessor();
428 
429  assert(InvokeBB && "safepoints should have unique landingpads");
430  assert(InvokeBB->getTerminator() &&
431  "safepoint block should be well formed");
432 
433  return cast<GCStatepointInst>(InvokeBB->getTerminator());
434 }
435 
437  if (auto Opt = getStatepoint()->getOperandBundle(LLVMContext::OB_gc_live))
438  return *(Opt->Inputs.begin() + getBasePtrIndex());
439  return *(getStatepoint()->arg_begin() + getBasePtrIndex());
440 }
441 
443  if (auto Opt = getStatepoint()->getOperandBundle(LLVMContext::OB_gc_live))
444  return *(Opt->Inputs.begin() + getDerivedPtrIndex());
445  return *(getStatepoint()->arg_begin() + getDerivedPtrIndex());
446 }
llvm::StringSwitch::Case
StringSwitch & Case(StringLiteral S, T Value)
Definition: StringSwitch.h:67
llvm::CmpInst::FCMP_ULE
@ FCMP_ULE
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:737
llvm::DbgVariableIntrinsic::getExpression
DIExpression * getExpression() const
Definition: IntrinsicInst.h:252
llvm::BinaryOpIntrinsic::getBinaryOp
Instruction::BinaryOps getBinaryOp() const
Returns the binary operation underlying the intrinsic.
Definition: IntrinsicInst.cpp:377
llvm
Definition: AllocatorList.h:23
llvm::InstrProfIncrementInst::getStep
Value * getStep() const
Definition: IntrinsicInst.cpp:164
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::Instruction::getModule
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:66
llvm::AArch64CC::AL
@ AL
Definition: AArch64BaseInfo.h:250
llvm::CallBase::getOperandBundle
Optional< OperandBundleUse > getOperandBundle(StringRef Name) const
Return an operand bundle by name, if present.
Definition: InstrTypes.h:1982
Metadata.h
llvm::CmpInst::Predicate
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:722
llvm::BasicBlock::getParent
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:107
IntrinsicInst.h
llvm::ElementCount
Definition: TypeSize.h:386
DebugInfoMetadata.h
llvm::StringSwitch::Default
LLVM_NODISCARD R Default(T Value)
Definition: StringSwitch.h:181
llvm::IntrinsicInst::getIntrinsicID
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
Definition: IntrinsicInst.h:52
High
uint64_t High
Definition: NVVMIntrRange.cpp:61
llvm::StringRef::npos
static constexpr size_t npos
Definition: StringRef.h:59
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
llvm::DIVariable::getSizeInBits
Optional< uint64_t > getSizeInBits() const
Determines the size of the variable's type.
Definition: DebugInfoMetadata.cpp:1011
llvm::InstrProfIncrementInstStep::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1110
llvm::CmpInst::FCMP_ONE
@ FCMP_ONE
0 1 1 0 True if ordered and operands are unequal
Definition: InstrTypes.h:730
llvm::DbgVariableIntrinsic::replaceVariableLocationOp
void replaceVariableLocationOp(Value *OldValue, Value *NewValue)
Definition: IntrinsicInst.cpp:82
llvm::VPIntrinsic::canIgnoreVectorLengthParam
bool canIgnoreVectorLengthParam() const
Definition: IntrinsicInst.cpp:335
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:46
llvm::Intrinsic::lookupLLVMIntrinsicByName
int lookupLLVMIntrinsicByName(ArrayRef< const char * > NameTable, StringRef Name)
Looks up Name in NameTable via binary search.
Definition: IntrinsicInst.cpp:127
Module.h
llvm::DbgVariableIntrinsic::getVariable
DILocalVariable * getVariable() const
Definition: IntrinsicInst.h:248
llvm::Optional< uint64_t >
T
#define T
Definition: Mips16ISelLowering.cpp:341
Operator.h
llvm::ConstrainedFPIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.cpp:236
llvm::ValueAsMetadata::get
static ValueAsMetadata * get(Value *V)
Definition: Metadata.cpp:362
llvm::Intrinsic::not_intrinsic
@ not_intrinsic
Definition: Intrinsics.h:45
llvm::CallBase::getNumArgOperands
unsigned getNumArgOperands() const
Definition: InstrTypes.h:1339
llvm::PatternMatch::m_VScale
VScaleVal_match m_VScale(const DataLayout &DL)
Definition: PatternMatch.h:2402
llvm::CmpInst::FCMP_OGT
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:726
llvm::DbgVariableIntrinsic::getVariableLocationOp
Value * getVariableLocationOp(unsigned OpIdx) const
Definition: IntrinsicInst.cpp:60
llvm::MDNode::get
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1198
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::CmpInst::FCMP_ULT
@ FCMP_ULT
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:736
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
llvm::GCStatepointInst
Represents a gc.statepoint intrinsic call.
Definition: Statepoint.h:63
Constants.h
llvm::PatternMatch::match
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:49
llvm::VPIntrinsic::GetVectorLengthParamPos
static Optional< int > GetVectorLengthParamPos(Intrinsic::ID IntrinsicID)
Definition: IntrinsicInst.cpp:284
llvm::CmpInst::FCMP_UGE
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:735
llvm::BinaryOpIntrinsic::getNoWrapKind
unsigned getNoWrapKind() const
Returns one of OBO::NoSignedWrap or OBO::NoUnsignedWrap.
Definition: IntrinsicInst.cpp:410
llvm::PatternMatch::m_ConstantInt
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
Definition: PatternMatch.h:101
llvm::CmpInst::FCMP_UNO
@ FCMP_UNO
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
Definition: InstrTypes.h:732
llvm::ConstantInt::get
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:885
llvm::CmpInst::FCMP_OEQ
@ FCMP_OEQ
0 0 0 1 True if ordered and equal
Definition: InstrTypes.h:725
llvm::DbgVariableIntrinsic::hasArgList
bool hasArgList() const
Definition: IntrinsicInst.h:222
llvm::CmpInst::FCMP_OLT
@ FCMP_OLT
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:728
llvm::VPIntrinsic::GetForOpcode
static Intrinsic::ID GetForOpcode(unsigned OC)
The llvm.vp.* intrinsics for this instruction Opcode.
Definition: IntrinsicInst.cpp:324
PatternMatch.h
llvm::MCID::Call
@ Call
Definition: MCInstrDesc.h:154
llvm::Metadata
Root of the metadata hierarchy.
Definition: Metadata.h:62
llvm::DbgVariableIntrinsic::getNumVariableLocationOps
unsigned getNumVariableLocationOps() const
Definition: IntrinsicInst.h:216
llvm::None
const NoneType None
Definition: None.h:23
Statepoint.h
llvm::VPIntrinsic::getVectorLengthParam
Value * getVectorLengthParam() const
Definition: IntrinsicInst.cpp:265
llvm::VPIntrinsic::GetFunctionalOpcodeForVP
static unsigned GetFunctionalOpcodeForVP(Intrinsic::ID ID)
Definition: IntrinsicInst.cpp:310
llvm::VPIntrinsic::getStaticVectorLength
ElementCount getStaticVectorLength() const
Definition: IntrinsicInst.cpp:247
llvm::VPIntrinsic::GetMaskParamPos
static Optional< int > GetMaskParamPos(Intrinsic::ID IntrinsicID)
Definition: IntrinsicInst.cpp:272
llvm::BinaryOpIntrinsic::isSigned
bool isSigned() const
Whether the intrinsic is signed or unsigned.
Definition: IntrinsicInst.cpp:397
llvm::find
auto find(R &&Range, const T &Val)
Provide wrappers to std::find which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1525
llvm::GCRelocateInst::getDerivedPtr
Value * getDerivedPtr() const
Definition: IntrinsicInst.cpp:442
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
I
#define I(x, y, z)
Definition: MD5.cpp:59
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::CmpInst::FCMP_OGE
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:727
llvm::StrToExceptionBehavior
Optional< fp::ExceptionBehavior > StrToExceptionBehavior(StringRef)
Returns a valid ExceptionBehavior enumerator when given a string valid as input in constrained intrin...
Definition: FPEnv.cpp:60
llvm::VPIntrinsic::IsVPIntrinsic
static bool IsVPIntrinsic(Intrinsic::ID)
Definition: IntrinsicInst.cpp:296
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::ConstrainedFPCmpIntrinsic::getPredicate
FCmpInst::Predicate getPredicate() const
Definition: IntrinsicInst.cpp:192
llvm::ArrayRef< const char * >
llvm::ConstrainedFPIntrinsic::getExceptionBehavior
Optional< fp::ExceptionBehavior > getExceptionBehavior() const
Definition: IntrinsicInst.cpp:183
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
llvm::DbgVariableIntrinsic::getRawLocation
Metadata * getRawLocation() const
Definition: IntrinsicInst.h:256
llvm::Value::getContext
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:940
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::OverflowingBinaryOperator::NoUnsignedWrap
@ NoUnsignedWrap
Definition: Operator.h:70
llvm::DbgVariableIntrinsic::getFragmentSizeInBits
Optional< uint64_t > getFragmentSizeInBits() const
Get the size (in bits) of the variable, or fragment of the variable that is described.
Definition: IntrinsicInst.cpp:121
llvm::BasicBlock::getTerminator
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:148
getAsMetadata
static ValueAsMetadata * getAsMetadata(Value *V)
Definition: IntrinsicInst.cpp:76
llvm::LLVMContext::OB_gc_live
@ OB_gc_live
Definition: LLVMContext.h:95
llvm::CmpInst::FCMP_UGT
@ FCMP_UGT
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:734
llvm::GCRelocateInst::getBasePtr
Value * getBasePtr() const
Definition: IntrinsicInst.cpp:436
llvm::Type::getInt64Ty
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:205
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::ConstrainedFPIntrinsic::isUnaryOp
bool isUnaryOp() const
Definition: IntrinsicInst.cpp:214
llvm::MetadataAsValue::get
static MetadataAsValue * get(LLVMContext &Context, Metadata *MD)
Definition: Metadata.cpp:106
llvm::ArrayRef::begin
iterator begin() const
Definition: ArrayRef.h:151
GlobalVariable.h
llvm::PatternMatch::m_c_Mul
BinaryOp_match< LHS, RHS, Instruction::Mul, true > m_c_Mul(const LHS &L, const RHS &R)
Matches a Mul with LHS and RHS in either order.
Definition: PatternMatch.h:2178
StringSwitch.h
llvm::ConstrainedFPIntrinsic::isTernaryOp
bool isTernaryOp() const
Definition: IntrinsicInst.cpp:225
llvm::MCID::Add
@ Add
Definition: MCInstrDesc.h:184
llvm::IntrinsicInst
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:45
llvm::Instruction::BinaryOps
BinaryOps
Definition: Instruction.h:768
llvm::DbgVariableIntrinsic::location_op_iterator
Definition: IntrinsicInst.h:153
llvm::OverflowingBinaryOperator::NoSignedWrap
@ NoSignedWrap
Definition: Operator.h:71
llvm::CmpInst::FCMP_UNE
@ FCMP_UNE
1 1 1 0 True if unordered or not equal
Definition: InstrTypes.h:738
llvm::CallBase::getArgOperand
Value * getArgOperand(unsigned i) const
Definition: InstrTypes.h:1341
llvm::DbgVariableIntrinsic::location_ops
iterator_range< location_op_iterator > location_ops() const
Get the locations corresponding to the variable referenced by the debug info intrinsic.
Definition: IntrinsicInst.cpp:43
llvm::iterator_range
A range adaptor for a pair of iterators.
Definition: iterator_range.h:30
getBasePtrIndex
static unsigned getBasePtrIndex(const MemSDNode *N)
MemSDNode::getBasePtr() does not work for intrinsics, which needs to offset by the chain and intrinsi...
Definition: SIISelLowering.cpp:8850
llvm::CmpInst::FCMP_OLE
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:729
llvm::ValueAsMetadata
Value wrapper in the Metadata hierarchy.
Definition: Metadata.h:344
llvm::ConstrainedFPIntrinsic::getRoundingMode
Optional< RoundingMode > getRoundingMode() const
Definition: IntrinsicInst.cpp:173
llvm::StringSwitch
A switch()-like statement whose cases are string literals.
Definition: StringSwitch.h:42
llvm::VPIntrinsic::getMaskParam
Value * getMaskParam() const
Definition: IntrinsicInst.cpp:258
raw_ostream.h
llvm::StringRef::size
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:160
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::CmpInst::BAD_FCMP_PREDICATE
@ BAD_FCMP_PREDICATE
Definition: InstrTypes.h:742
llvm::ArrayRef::end
iterator end() const
Definition: ArrayRef.h:152
llvm::CmpInst::FCMP_ORD
@ FCMP_ORD
0 1 1 1 True if ordered (no nans)
Definition: InstrTypes.h:731
llvm::GCProjectionInst::getStatepoint
const GCStatepointInst * getStatepoint() const
The statepoint with which this gc.relocate is associated.
Definition: IntrinsicInst.cpp:417
llvm::CmpInst::FCMP_UEQ
@ FCMP_UEQ
1 0 0 1 True if unordered or equal
Definition: InstrTypes.h:733
llvm::StrToRoundingMode
Optional< RoundingMode > StrToRoundingMode(StringRef)
Returns a valid RoundingMode enumerator when given a string that is valid as input in constrained int...
Definition: FPEnv.cpp:20
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38