LLVM  14.0.0git
IntrinsicInst.cpp
Go to the documentation of this file.
1 //===-- IntrinsicInst.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 
123  assert(NewExpr->hasAllLocationOps(getNumVariableLocationOps() +
124  NewValues.size()) &&
125  "NewExpr for debug variable intrinsic does not reference every "
126  "location operand.");
127  assert(!is_contained(NewValues, nullptr) && "New values must be non-null");
128  setArgOperand(2, MetadataAsValue::get(getContext(), NewExpr));
130  for (auto *VMD : location_ops())
131  MDs.push_back(getAsMetadata(VMD));
132  for (auto *VMD : NewValues)
133  MDs.push_back(getAsMetadata(VMD));
134  setArgOperand(
136 }
137 
139  if (auto Fragment = getExpression()->getFragmentInfo())
140  return Fragment->SizeInBits;
141  return getVariable()->getSizeInBits();
142 }
143 
145  StringRef Name) {
146  assert(Name.startswith("llvm."));
147 
148  // Do successive binary searches of the dotted name components. For
149  // "llvm.gc.experimental.statepoint.p1i8.p1i32", we will find the range of
150  // intrinsics starting with "llvm.gc", then "llvm.gc.experimental", then
151  // "llvm.gc.experimental.statepoint", and then we will stop as the range is
152  // size 1. During the search, we can skip the prefix that we already know is
153  // identical. By using strncmp we consider names with differing suffixes to
154  // be part of the equal range.
155  size_t CmpEnd = 4; // Skip the "llvm" component.
156  const char *const *Low = NameTable.begin();
157  const char *const *High = NameTable.end();
158  const char *const *LastLow = Low;
159  while (CmpEnd < Name.size() && High - Low > 0) {
160  size_t CmpStart = CmpEnd;
161  CmpEnd = Name.find('.', CmpStart + 1);
162  CmpEnd = CmpEnd == StringRef::npos ? Name.size() : CmpEnd;
163  auto Cmp = [CmpStart, CmpEnd](const char *LHS, const char *RHS) {
164  return strncmp(LHS + CmpStart, RHS + CmpStart, CmpEnd - CmpStart) < 0;
165  };
166  LastLow = Low;
167  std::tie(Low, High) = std::equal_range(Low, High, Name.data(), Cmp);
168  }
169  if (High - Low > 0)
170  LastLow = Low;
171 
172  if (LastLow == NameTable.end())
173  return -1;
174  StringRef NameFound = *LastLow;
175  if (Name == NameFound ||
176  (Name.startswith(NameFound) && Name[NameFound.size()] == '.'))
177  return LastLow - NameTable.begin();
178  return -1;
179 }
180 
183  return const_cast<Value *>(getArgOperand(4));
184  }
185  const Module *M = getModule();
186  LLVMContext &Context = M->getContext();
188 }
189 
191  unsigned NumOperands = getNumArgOperands();
192  Metadata *MD = nullptr;
193  auto *MAV = dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 2));
194  if (MAV)
195  MD = MAV->getMetadata();
196  if (!MD || !isa<MDString>(MD))
197  return None;
198  return StrToRoundingMode(cast<MDString>(MD)->getString());
199 }
200 
203  unsigned NumOperands = getNumArgOperands();
204  Metadata *MD = nullptr;
205  auto *MAV = dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 1));
206  if (MAV)
207  MD = MAV->getMetadata();
208  if (!MD || !isa<MDString>(MD))
209  return None;
210  return StrToExceptionBehavior(cast<MDString>(MD)->getString());
211 }
212 
215  if (Except) {
216  if (Except.getValue() != fp::ebIgnore)
217  return false;
218  }
219 
221  if (Rounding) {
222  if (Rounding.getValue() != RoundingMode::NearestTiesToEven)
223  return false;
224  }
225 
226  return true;
227 }
228 
230  Metadata *MD = cast<MetadataAsValue>(getArgOperand(2))->getMetadata();
231  if (!MD || !isa<MDString>(MD))
233  return StringSwitch<FCmpInst::Predicate>(cast<MDString>(MD)->getString())
234  .Case("oeq", FCmpInst::FCMP_OEQ)
235  .Case("ogt", FCmpInst::FCMP_OGT)
236  .Case("oge", FCmpInst::FCMP_OGE)
237  .Case("olt", FCmpInst::FCMP_OLT)
238  .Case("ole", FCmpInst::FCMP_OLE)
239  .Case("one", FCmpInst::FCMP_ONE)
240  .Case("ord", FCmpInst::FCMP_ORD)
241  .Case("uno", FCmpInst::FCMP_UNO)
242  .Case("ueq", FCmpInst::FCMP_UEQ)
243  .Case("ugt", FCmpInst::FCMP_UGT)
244  .Case("uge", FCmpInst::FCMP_UGE)
245  .Case("ult", FCmpInst::FCMP_ULT)
246  .Case("ule", FCmpInst::FCMP_ULE)
247  .Case("une", FCmpInst::FCMP_UNE)
249 }
250 
252  switch (getIntrinsicID()) {
253  default:
254  return false;
255 #define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
256  case Intrinsic::INTRINSIC: \
257  return NARG == 1;
258 #include "llvm/IR/ConstrainedOps.def"
259  }
260 }
261 
263  switch (getIntrinsicID()) {
264  default:
265  return false;
266 #define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
267  case Intrinsic::INTRINSIC: \
268  return NARG == 3;
269 #include "llvm/IR/ConstrainedOps.def"
270  }
271 }
272 
274  switch (I->getIntrinsicID()) {
275 #define INSTRUCTION(NAME, NARGS, ROUND_MODE, INTRINSIC) \
276  case Intrinsic::INTRINSIC:
277 #include "llvm/IR/ConstrainedOps.def"
278  return true;
279  default:
280  return false;
281  }
282 }
283 
285  auto GetVectorLengthOfType = [](const Type *T) -> ElementCount {
286  const auto *VT = cast<VectorType>(T);
287  auto ElemCount = VT->getElementCount();
288  return ElemCount;
289  };
290 
291  Value *VPMask = getMaskParam();
292  assert(VPMask && "No mask param?");
293  return GetVectorLengthOfType(VPMask->getType());
294 }
295 
297  if (auto MaskPos = getMaskParamPos(getIntrinsicID()))
298  return getArgOperand(MaskPos.getValue());
299  return nullptr;
300 }
301 
303  auto MaskPos = getMaskParamPos(getIntrinsicID());
304  setArgOperand(*MaskPos, NewMask);
305 }
306 
308  if (auto EVLPos = getVectorLengthParamPos(getIntrinsicID()))
309  return getArgOperand(EVLPos.getValue());
310  return nullptr;
311 }
312 
314  auto EVLPos = getVectorLengthParamPos(getIntrinsicID());
315  setArgOperand(*EVLPos, NewEVL);
316 }
317 
319  switch (IntrinsicID) {
320  default:
321  return None;
322 
323 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS) \
324  case Intrinsic::VPID: \
325  return MASKPOS;
326 #include "llvm/IR/VPIntrinsics.def"
327  }
328 }
329 
332  switch (IntrinsicID) {
333  default:
334  return None;
335 
336 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS) \
337  case Intrinsic::VPID: \
338  return VLENPOS;
339 #include "llvm/IR/VPIntrinsics.def"
340  }
341 }
342 
343 /// \return the alignment of the pointer used by this load/store/gather or
344 /// scatter.
347  assert(PtrParamOpt.hasValue() && "no pointer argument!");
348  return getParamAlign(PtrParamOpt.getValue());
349 }
350 
351 /// \return The pointer operand of this load,store, gather or scatter.
353  if (auto PtrParamOpt = getMemoryPointerParamPos(getIntrinsicID()))
354  return getArgOperand(PtrParamOpt.getValue());
355  return nullptr;
356 }
357 
359  switch (VPID) {
360  default:
361  return None;
362 
363 #define HANDLE_VP_IS_MEMOP(VPID, POINTERPOS, DATAPOS) \
364  case Intrinsic::VPID: \
365  return POINTERPOS;
366 #include "llvm/IR/VPIntrinsics.def"
367  }
368 }
369 
370 /// \return The data (payload) operand of this store or scatter.
372  auto DataParamOpt = getMemoryDataParamPos(getIntrinsicID());
373  if (!DataParamOpt.hasValue())
374  return nullptr;
375  return getArgOperand(DataParamOpt.getValue());
376 }
377 
379  switch (VPID) {
380  default:
381  return None;
382 
383 #define HANDLE_VP_IS_MEMOP(VPID, POINTERPOS, DATAPOS) \
384  case Intrinsic::VPID: \
385  return DATAPOS;
386 #include "llvm/IR/VPIntrinsics.def"
387  }
388 }
389 
391  switch (ID) {
392  default:
393  return false;
394 
395 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS) \
396  case Intrinsic::VPID: \
397  break;
398 #include "llvm/IR/VPIntrinsics.def"
399  }
400  return true;
401 }
402 
403 // Equivalent non-predicated opcode
405  Optional<unsigned> FunctionalOC;
406  switch (ID) {
407  default:
408  break;
409 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
410 #define HANDLE_VP_TO_OPC(OPC) FunctionalOC = Instruction::OPC;
411 #define END_REGISTER_VP_INTRINSIC(...) break;
412 #include "llvm/IR/VPIntrinsics.def"
413  }
414 
415  return FunctionalOC;
416 }
417 
419  switch (IROPC) {
420  default:
422 
423 #define HANDLE_VP_TO_OPC(OPC) case Instruction::OPC:
424 #define END_REGISTER_VP_INTRINSIC(VPID) return Intrinsic::VPID;
425 #include "llvm/IR/VPIntrinsics.def"
426  }
427 }
428 
430  using namespace PatternMatch;
431 
433 
434  // No vlen param - no lanes masked-off by it.
435  auto *VLParam = getVectorLengthParam();
436  if (!VLParam)
437  return true;
438 
439  // Note that the VP intrinsic causes undefined behavior if the Explicit Vector
440  // Length parameter is strictly greater-than the number of vector elements of
441  // the operation. This function returns true when this is detected statically
442  // in the IR.
443 
444  // Check whether "W == vscale * EC.getKnownMinValue()"
445  if (EC.isScalable()) {
446  // Undig the DL
447  const auto *ParMod = this->getModule();
448  if (!ParMod)
449  return false;
450  const auto &DL = ParMod->getDataLayout();
451 
452  // Compare vscale patterns
453  uint64_t VScaleFactor;
454  if (match(VLParam, m_c_Mul(m_ConstantInt(VScaleFactor), m_VScale(DL))))
455  return VScaleFactor >= EC.getKnownMinValue();
456  return (EC.getKnownMinValue() == 1) && match(VLParam, m_VScale(DL));
457  }
458 
459  // standard SIMD operation
460  const auto *VLConst = dyn_cast<ConstantInt>(VLParam);
461  if (!VLConst)
462  return false;
463 
464  uint64_t VLNum = VLConst->getZExtValue();
465  if (VLNum >= EC.getKnownMinValue())
466  return true;
467 
468  return false;
469 }
470 
472  ArrayRef<Value *> Params) {
473  assert(isVPIntrinsic(VPID) && "not a VP intrinsic");
474  Function *VPFunc;
475  switch (VPID) {
476  default:
477  VPFunc = Intrinsic::getDeclaration(M, VPID, Params[0]->getType());
478  break;
479  case Intrinsic::vp_load:
480  VPFunc = Intrinsic::getDeclaration(
481  M, VPID,
482  {Params[0]->getType()->getPointerElementType(), Params[0]->getType()});
483  break;
484  case Intrinsic::vp_gather:
485  VPFunc = Intrinsic::getDeclaration(
486  M, VPID,
487  {VectorType::get(cast<VectorType>(Params[0]->getType())
488  ->getElementType()
489  ->getPointerElementType(),
490  cast<VectorType>(Params[0]->getType())),
491  Params[0]->getType()});
492  break;
493  case Intrinsic::vp_store:
494  VPFunc = Intrinsic::getDeclaration(
495  M, VPID,
496  {Params[1]->getType()->getPointerElementType(), Params[1]->getType()});
497  break;
498  case Intrinsic::vp_scatter:
499  VPFunc = Intrinsic::getDeclaration(
500  M, VPID, {Params[0]->getType(), Params[1]->getType()});
501  break;
502  }
503  assert(VPFunc && "Could not declare VP intrinsic");
504  return VPFunc;
505 }
506 
508  switch (getIntrinsicID()) {
509  case Intrinsic::uadd_with_overflow:
510  case Intrinsic::sadd_with_overflow:
511  case Intrinsic::uadd_sat:
512  case Intrinsic::sadd_sat:
513  return Instruction::Add;
514  case Intrinsic::usub_with_overflow:
515  case Intrinsic::ssub_with_overflow:
516  case Intrinsic::usub_sat:
517  case Intrinsic::ssub_sat:
518  return Instruction::Sub;
519  case Intrinsic::umul_with_overflow:
520  case Intrinsic::smul_with_overflow:
521  return Instruction::Mul;
522  default:
523  llvm_unreachable("Invalid intrinsic");
524  }
525 }
526 
528  switch (getIntrinsicID()) {
529  case Intrinsic::sadd_with_overflow:
530  case Intrinsic::ssub_with_overflow:
531  case Intrinsic::smul_with_overflow:
532  case Intrinsic::sadd_sat:
533  case Intrinsic::ssub_sat:
534  return true;
535  default:
536  return false;
537  }
538 }
539 
541  if (isSigned())
543  else
545 }
546 
548  const Value *Token = getArgOperand(0);
549 
550  // This takes care both of relocates for call statepoints and relocates
551  // on normal path of invoke statepoint.
552  if (!isa<LandingPadInst>(Token))
553  return cast<GCStatepointInst>(Token);
554 
555  // This relocate is on exceptional path of an invoke statepoint
556  const BasicBlock *InvokeBB =
557  cast<Instruction>(Token)->getParent()->getUniquePredecessor();
558 
559  assert(InvokeBB && "safepoints should have unique landingpads");
560  assert(InvokeBB->getTerminator() &&
561  "safepoint block should be well formed");
562 
563  return cast<GCStatepointInst>(InvokeBB->getTerminator());
564 }
565 
567  if (auto Opt = getStatepoint()->getOperandBundle(LLVMContext::OB_gc_live))
568  return *(Opt->Inputs.begin() + getBasePtrIndex());
569  return *(getStatepoint()->arg_begin() + getBasePtrIndex());
570 }
571 
573  if (auto Opt = getStatepoint()->getOperandBundle(LLVMContext::OB_gc_live))
574  return *(Opt->Inputs.begin() + getDerivedPtrIndex());
575  return *(getStatepoint()->arg_begin() + getDerivedPtrIndex());
576 }
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:735
llvm::DbgVariableIntrinsic::getExpression
DIExpression * getExpression() const
Definition: IntrinsicInst.h:257
llvm::BinaryOpIntrinsic::getBinaryOp
Instruction::BinaryOps getBinaryOp() const
Returns the binary operation underlying the intrinsic.
Definition: IntrinsicInst.cpp:507
llvm::VPIntrinsic::getVectorLengthParamPos
static Optional< unsigned > getVectorLengthParamPos(Intrinsic::ID IntrinsicID)
Definition: IntrinsicInst.cpp:331
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::InstrProfIncrementInst::getStep
Value * getStep() const
Definition: IntrinsicInst.cpp:181
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:269
llvm::CallBase::getOperandBundle
Optional< OperandBundleUse > getOperandBundle(StringRef Name) const
Return an operand bundle by name, if present.
Definition: InstrTypes.h:1976
llvm::Intrinsic::getDeclaration
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=None)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
Definition: Function.cpp:1336
Metadata.h
llvm::CmpInst::Predicate
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:720
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::Function
Definition: Function.h:61
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:60
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:1018
llvm::InstrProfIncrementInstStep::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1137
llvm::CmpInst::FCMP_ONE
@ FCMP_ONE
0 1 1 0 True if ordered and operands are unequal
Definition: InstrTypes.h:728
llvm::VPIntrinsic::setVectorLengthParam
void setVectorLengthParam(Value *)
Definition: IntrinsicInst.cpp:313
llvm::DbgVariableIntrinsic::replaceVariableLocationOp
void replaceVariableLocationOp(Value *OldValue, Value *NewValue)
Definition: IntrinsicInst.cpp:82
llvm::VPIntrinsic::canIgnoreVectorLengthParam
bool canIgnoreVectorLengthParam() const
Definition: IntrinsicInst.cpp:429
llvm::ConstrainedFPIntrinsic::isDefaultFPEnvironment
bool isDefaultFPEnvironment() const
Definition: IntrinsicInst.cpp:213
NewExpr
Definition: ItaniumDemangle.h:1773
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::Intrinsic::lookupLLVMIntrinsicByName
int lookupLLVMIntrinsicByName(ArrayRef< const char * > NameTable, StringRef Name)
Looks up Name in NameTable via binary search.
Definition: IntrinsicInst.cpp:144
Module.h
llvm::VPIntrinsic::getMemoryDataParam
Value * getMemoryDataParam() const
Definition: IntrinsicInst.cpp:371
llvm::DbgVariableIntrinsic::getVariable
DILocalVariable * getVariable() const
Definition: IntrinsicInst.h:253
llvm::VPIntrinsic::getFunctionalOpcodeForVP
static Optional< unsigned > getFunctionalOpcodeForVP(Intrinsic::ID ID)
Definition: IntrinsicInst.cpp:404
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:273
llvm::ValueAsMetadata::get
static ValueAsMetadata * get(Value *V)
Definition: Metadata.cpp:368
llvm::Intrinsic::not_intrinsic
@ not_intrinsic
Definition: Intrinsics.h:45
llvm::CallBase::getNumArgOperands
unsigned getNumArgOperands() const
Definition: InstrTypes.h:1336
llvm::DIExpression
DWARF expression.
Definition: DebugInfoMetadata.h:2557
llvm::PatternMatch::m_VScale
VScaleVal_match m_VScale(const DataLayout &DL)
Definition: PatternMatch.h:2455
llvm::CmpInst::FCMP_OGT
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:724
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::VPIntrinsic::setMaskParam
void setMaskParam(Value *)
Definition: IntrinsicInst.cpp:302
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::Optional::hasValue
constexpr bool hasValue() const
Definition: Optional.h:288
llvm::CmpInst::FCMP_ULT
@ FCMP_ULT
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:734
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
llvm::GCStatepointInst
Represents a gc.statepoint intrinsic call.
Definition: Statepoint.h:63
llvm::DbgVariableIntrinsic::addVariableLocationOps
void addVariableLocationOps(ArrayRef< Value * > NewValues, DIExpression *NewExpr)
Adding a new location operand will always result in this intrinsic using an ArgList,...
Definition: IntrinsicInst.cpp:121
Constants.h
llvm::PatternMatch::match
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:49
llvm::CmpInst::FCMP_UGE
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:733
llvm::LLVMContext::OB_gc_live
@ OB_gc_live
Definition: LLVMContext.h:95
llvm::BinaryOpIntrinsic::getNoWrapKind
unsigned getNoWrapKind() const
Returns one of OBO::NoSignedWrap or OBO::NoUnsignedWrap.
Definition: IntrinsicInst.cpp:540
llvm::MaybeAlign
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:109
llvm::PatternMatch::m_ConstantInt
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
Definition: PatternMatch.h:145
llvm::CmpInst::FCMP_UNO
@ FCMP_UNO
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
Definition: InstrTypes.h:730
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:899
llvm::VPIntrinsic::getForOpcode
static Intrinsic::ID getForOpcode(unsigned OC)
The llvm.vp.* intrinsics for this instruction Opcode.
Definition: IntrinsicInst.cpp:418
llvm::CmpInst::FCMP_OEQ
@ FCMP_OEQ
0 0 0 1 True if ordered and equal
Definition: InstrTypes.h:723
llvm::DbgVariableIntrinsic::hasArgList
bool hasArgList() const
Definition: IntrinsicInst.h:227
llvm::CmpInst::FCMP_OLT
@ FCMP_OLT
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:726
llvm::VPIntrinsic::getDeclarationForParams
static Function * getDeclarationForParams(Module *M, Intrinsic::ID, ArrayRef< Value * > Params)
Declares a llvm.vp.
Definition: IntrinsicInst.cpp:471
PatternMatch.h
llvm::Metadata
Root of the metadata hierarchy.
Definition: Metadata.h:62
llvm::DbgVariableIntrinsic::getNumVariableLocationOps
unsigned getNumVariableLocationOps() const
Definition: IntrinsicInst.h:221
llvm::None
const NoneType None
Definition: None.h:23
Statepoint.h
llvm::VPIntrinsic::getMemoryPointerParamPos
static Optional< unsigned > getMemoryPointerParamPos(Intrinsic::ID)
Definition: IntrinsicInst.cpp:358
llvm::VPIntrinsic::getVectorLengthParam
Value * getVectorLengthParam() const
Definition: IntrinsicInst.cpp:307
llvm::VPIntrinsic::getStaticVectorLength
ElementCount getStaticVectorLength() const
Definition: IntrinsicInst.cpp:284
llvm::OverflowingBinaryOperator::NoSignedWrap
@ NoSignedWrap
Definition: Operator.h:72
llvm::BinaryOpIntrinsic::isSigned
bool isSigned() const
Whether the intrinsic is signed or unsigned.
Definition: IntrinsicInst.cpp:527
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:1567
llvm::VPIntrinsic::getPointerAlignment
MaybeAlign getPointerAlignment() const
Definition: IntrinsicInst.cpp:345
llvm::GCRelocateInst::getDerivedPtr
Value * getDerivedPtr() const
Definition: IntrinsicInst.cpp:572
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
llvm::is_contained
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:1612
llvm::OverflowingBinaryOperator::NoUnsignedWrap
@ NoUnsignedWrap
Definition: Operator.h:71
llvm::VPIntrinsic::isVPIntrinsic
static bool isVPIntrinsic(Intrinsic::ID)
Definition: IntrinsicInst.cpp:390
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:725
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::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::VPIntrinsic::getMemoryDataParamPos
static Optional< unsigned > getMemoryDataParamPos(Intrinsic::ID)
Definition: IntrinsicInst.cpp:378
llvm::ConstrainedFPCmpIntrinsic::getPredicate
FCmpInst::Predicate getPredicate() const
Definition: IntrinsicInst.cpp:229
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::ConstrainedFPIntrinsic::getExceptionBehavior
Optional< fp::ExceptionBehavior > getExceptionBehavior() const
Definition: IntrinsicInst.cpp:202
llvm::CallBase::getParamAlign
MaybeAlign getParamAlign(unsigned ArgNo) const
Extract the alignment for a call or parameter (0=unknown).
Definition: InstrTypes.h:1709
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
llvm::Value::getType
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:256
llvm::DbgVariableIntrinsic::getRawLocation
Metadata * getRawLocation() const
Definition: IntrinsicInst.h:261
llvm::Value::getContext
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:979
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
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:138
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
llvm::CallBase::setArgOperand
void setArgOperand(unsigned i, Value *v)
Definition: InstrTypes.h:1343
getAsMetadata
static ValueAsMetadata * getAsMetadata(Value *V)
Definition: IntrinsicInst.cpp:76
llvm::CmpInst::FCMP_UGT
@ FCMP_UGT
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:732
llvm::GCRelocateInst::getBasePtr
Value * getBasePtr() const
Definition: IntrinsicInst.cpp:566
llvm::Type::getInt64Ty
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:204
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::ConstrainedFPIntrinsic::isUnaryOp
bool isUnaryOp() const
Definition: IntrinsicInst.cpp:251
llvm::VPIntrinsic::getMemoryPointerParam
Value * getMemoryPointerParam() const
Definition: IntrinsicInst.cpp:352
llvm::MetadataAsValue::get
static MetadataAsValue * get(LLVMContext &Context, Metadata *MD)
Definition: Metadata.cpp:106
llvm::ArrayRef::begin
iterator begin() const
Definition: ArrayRef.h:153
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:2235
StringSwitch.h
llvm::fp::ebIgnore
@ ebIgnore
This corresponds to "fpexcept.ignore".
Definition: FPEnv.h:32
llvm::ConstrainedFPIntrinsic::isTernaryOp
bool isTernaryOp() const
Definition: IntrinsicInst.cpp:262
llvm::VPIntrinsic::getMaskParamPos
static Optional< unsigned > getMaskParamPos(Intrinsic::ID IntrinsicID)
Definition: IntrinsicInst.cpp:318
llvm::MCID::Add
@ Add
Definition: MCInstrDesc.h:183
llvm::IntrinsicInst
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:45
llvm::Instruction::BinaryOps
BinaryOps
Definition: Instruction.h:787
llvm::DbgVariableIntrinsic::location_op_iterator
Definition: IntrinsicInst.h:153
llvm::CmpInst::FCMP_UNE
@ FCMP_UNE
1 1 1 0 True if unordered or not equal
Definition: InstrTypes.h:736
llvm::CallBase::getArgOperand
Value * getArgOperand(unsigned i) const
Definition: InstrTypes.h:1338
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::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
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:8934
llvm::CmpInst::FCMP_OLE
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:727
llvm::ValueAsMetadata
Value wrapper in the Metadata hierarchy.
Definition: Metadata.h:344
llvm::ConstrainedFPIntrinsic::getRoundingMode
Optional< RoundingMode > getRoundingMode() const
Definition: IntrinsicInst.cpp:190
llvm::StringSwitch
A switch()-like statement whose cases are string literals.
Definition: StringSwitch.h:42
llvm::VPIntrinsic::getMaskParam
Value * getMaskParam() const
Definition: IntrinsicInst.cpp:296
raw_ostream.h
llvm::StringRef::size
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:157
llvm::RoundingMode::NearestTiesToEven
@ NearestTiesToEven
roundTiesToEven.
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::VectorType::get
static VectorType * get(Type *ElementType, ElementCount EC)
This static method is the primary way to construct an VectorType.
Definition: Type.cpp:634
llvm::CmpInst::BAD_FCMP_PREDICATE
@ BAD_FCMP_PREDICATE
Definition: InstrTypes.h:740
llvm::ArrayRef::end
iterator end() const
Definition: ArrayRef.h:154
llvm::Optional::getValue
constexpr const T & getValue() const LLVM_LVALUE_FUNCTION
Definition: Optional.h:282
llvm::CmpInst::FCMP_ORD
@ FCMP_ORD
0 1 1 1 True if ordered (no nans)
Definition: InstrTypes.h:729
llvm::GCProjectionInst::getStatepoint
const GCStatepointInst * getStatepoint() const
The statepoint with which this gc.relocate is associated.
Definition: IntrinsicInst.cpp:547
llvm::CmpInst::FCMP_UEQ
@ FCMP_UEQ
1 0 0 1 True if unordered or equal
Definition: InstrTypes.h:731
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
llvm::AArch64::Rounding
Rounding
Possible values of current rounding mode, which is specified in bits 23:22 of FPCR.
Definition: AArch64ISelLowering.h:469