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  Type *OverloadTy = Params[0]->getType();
479  OverloadTy =
480  Params[*VPReductionIntrinsic::getVectorParamPos(VPID)]->getType();
481 
482  VPFunc = Intrinsic::getDeclaration(M, VPID, OverloadTy);
483  break;
484  }
485  case Intrinsic::vp_select:
486  VPFunc = Intrinsic::getDeclaration(M, VPID, {Params[1]->getType()});
487  break;
488  case Intrinsic::vp_load:
489  VPFunc = Intrinsic::getDeclaration(
490  M, VPID,
491  {Params[0]->getType()->getPointerElementType(), Params[0]->getType()});
492  break;
493  case Intrinsic::vp_gather:
494  VPFunc = Intrinsic::getDeclaration(
495  M, VPID,
496  {VectorType::get(cast<VectorType>(Params[0]->getType())
497  ->getElementType()
498  ->getPointerElementType(),
499  cast<VectorType>(Params[0]->getType())),
500  Params[0]->getType()});
501  break;
502  case Intrinsic::vp_store:
503  VPFunc = Intrinsic::getDeclaration(
504  M, VPID,
505  {Params[1]->getType()->getPointerElementType(), Params[1]->getType()});
506  break;
507  case Intrinsic::vp_scatter:
508  VPFunc = Intrinsic::getDeclaration(
509  M, VPID, {Params[0]->getType(), Params[1]->getType()});
510  break;
511  }
512  assert(VPFunc && "Could not declare VP intrinsic");
513  return VPFunc;
514 }
515 
517  switch (ID) {
518  default:
519  return false;
520 #define HANDLE_VP_REDUCTION(VPID, STARTPOS, VECTORPOS) \
521  case Intrinsic::VPID: \
522  break;
523 #include "llvm/IR/VPIntrinsics.def"
524  }
525  return true;
526 }
527 
530 }
531 
534 }
535 
537  switch (ID) {
538 #define HANDLE_VP_REDUCTION(VPID, STARTPOS, VECTORPOS) \
539  case Intrinsic::VPID: \
540  return VECTORPOS;
541 #include "llvm/IR/VPIntrinsics.def"
542  default:
543  return None;
544  }
545 }
546 
548  switch (ID) {
549 #define HANDLE_VP_REDUCTION(VPID, STARTPOS, VECTORPOS) \
550  case Intrinsic::VPID: \
551  return STARTPOS;
552 #include "llvm/IR/VPIntrinsics.def"
553  default:
554  return None;
555  }
556 }
557 
559  switch (getIntrinsicID()) {
560  case Intrinsic::uadd_with_overflow:
561  case Intrinsic::sadd_with_overflow:
562  case Intrinsic::uadd_sat:
563  case Intrinsic::sadd_sat:
564  return Instruction::Add;
565  case Intrinsic::usub_with_overflow:
566  case Intrinsic::ssub_with_overflow:
567  case Intrinsic::usub_sat:
568  case Intrinsic::ssub_sat:
569  return Instruction::Sub;
570  case Intrinsic::umul_with_overflow:
571  case Intrinsic::smul_with_overflow:
572  return Instruction::Mul;
573  default:
574  llvm_unreachable("Invalid intrinsic");
575  }
576 }
577 
579  switch (getIntrinsicID()) {
580  case Intrinsic::sadd_with_overflow:
581  case Intrinsic::ssub_with_overflow:
582  case Intrinsic::smul_with_overflow:
583  case Intrinsic::sadd_sat:
584  case Intrinsic::ssub_sat:
585  return true;
586  default:
587  return false;
588  }
589 }
590 
592  if (isSigned())
594  else
596 }
597 
599  const Value *Token = getArgOperand(0);
600 
601  // This takes care both of relocates for call statepoints and relocates
602  // on normal path of invoke statepoint.
603  if (!isa<LandingPadInst>(Token))
604  return cast<GCStatepointInst>(Token);
605 
606  // This relocate is on exceptional path of an invoke statepoint
607  const BasicBlock *InvokeBB =
608  cast<Instruction>(Token)->getParent()->getUniquePredecessor();
609 
610  assert(InvokeBB && "safepoints should have unique landingpads");
611  assert(InvokeBB->getTerminator() &&
612  "safepoint block should be well formed");
613 
614  return cast<GCStatepointInst>(InvokeBB->getTerminator());
615 }
616 
618  if (auto Opt = getStatepoint()->getOperandBundle(LLVMContext::OB_gc_live))
619  return *(Opt->Inputs.begin() + getBasePtrIndex());
620  return *(getStatepoint()->arg_begin() + getBasePtrIndex());
621 }
622 
624  if (auto Opt = getStatepoint()->getOperandBundle(LLVMContext::OB_gc_live))
625  return *(Opt->Inputs.begin() + getDerivedPtrIndex());
626  return *(getStatepoint()->arg_begin() + getDerivedPtrIndex());
627 }
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:558
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:1987
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:1379
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
T
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:1029
llvm::InstrProfIncrementInstStep::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.h:1159
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:1928
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 >
llvm::OverflowingBinaryOperator::NoUnsignedWrap
@ NoUnsignedWrap
Definition: Operator.h:71
Operator.h
llvm::ConstrainedFPIntrinsic::classof
static bool classof(const IntrinsicInst *I)
Definition: IntrinsicInst.cpp:273
llvm::OverflowingBinaryOperator::NoSignedWrap
@ NoSignedWrap
Definition: Operator.h:72
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:2586
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:1208
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::VPReductionIntrinsic::isVPReduction
static bool isVPReduction(Intrinsic::ID ID)
Definition: IntrinsicInst.cpp:516
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::BinaryOpIntrinsic::getNoWrapKind
unsigned getNoWrapKind() const
Returns one of OBO::NoSignedWrap or OBO::NoUnsignedWrap.
Definition: IntrinsicInst.cpp:591
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::LLVMContext::OB_gc_live
@ OB_gc_live
Definition: LLVMContext.h:95
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:900
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::BinaryOpIntrinsic::isSigned
bool isSigned() const
Whether the intrinsic is signed or unsigned.
Definition: IntrinsicInst.cpp:578
uint64_t
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:1571
llvm::VPIntrinsic::getPointerAlignment
MaybeAlign getPointerAlignment() const
Definition: IntrinsicInst.cpp:345
llvm::GCRelocateInst::getDerivedPtr
Value * getDerivedPtr() const
Definition: IntrinsicInst.cpp:623
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:1616
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:1724
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:990
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::VPReductionIntrinsic::getStartParamPos
unsigned getStartParamPos() const
Definition: IntrinsicInst.cpp:532
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:617
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::VPReductionIntrinsic::getVectorParamPos
unsigned getVectorParamPos() const
Definition: IntrinsicInst.cpp:528
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:785
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:9013
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:632
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:598
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:37
llvm::AArch64::Rounding
Rounding
Possible values of current rounding mode, which is specified in bits 23:22 of FPCR.
Definition: AArch64ISelLowering.h:469