LLVM  14.0.0git
Function.cpp
Go to the documentation of this file.
1 //===- Function.cpp - Implement the Global object classes -----------------===//
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 the Function class for the IR library.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/IR/Function.h"
15 #include "llvm/ADT/ArrayRef.h"
16 #include "llvm/ADT/DenseSet.h"
17 #include "llvm/ADT/None.h"
18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/ADT/SmallString.h"
20 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/ADT/StringExtras.h"
22 #include "llvm/ADT/StringRef.h"
24 #include "llvm/IR/Argument.h"
25 #include "llvm/IR/Attributes.h"
26 #include "llvm/IR/BasicBlock.h"
27 #include "llvm/IR/Constant.h"
28 #include "llvm/IR/Constants.h"
29 #include "llvm/IR/DerivedTypes.h"
30 #include "llvm/IR/GlobalValue.h"
31 #include "llvm/IR/InstIterator.h"
32 #include "llvm/IR/Instruction.h"
33 #include "llvm/IR/Instructions.h"
34 #include "llvm/IR/IntrinsicInst.h"
35 #include "llvm/IR/Intrinsics.h"
36 #include "llvm/IR/IntrinsicsAArch64.h"
37 #include "llvm/IR/IntrinsicsAMDGPU.h"
38 #include "llvm/IR/IntrinsicsARM.h"
39 #include "llvm/IR/IntrinsicsBPF.h"
40 #include "llvm/IR/IntrinsicsHexagon.h"
41 #include "llvm/IR/IntrinsicsMips.h"
42 #include "llvm/IR/IntrinsicsNVPTX.h"
43 #include "llvm/IR/IntrinsicsPowerPC.h"
44 #include "llvm/IR/IntrinsicsR600.h"
45 #include "llvm/IR/IntrinsicsRISCV.h"
46 #include "llvm/IR/IntrinsicsS390.h"
47 #include "llvm/IR/IntrinsicsVE.h"
48 #include "llvm/IR/IntrinsicsWebAssembly.h"
49 #include "llvm/IR/IntrinsicsX86.h"
50 #include "llvm/IR/IntrinsicsXCore.h"
51 #include "llvm/IR/LLVMContext.h"
52 #include "llvm/IR/MDBuilder.h"
53 #include "llvm/IR/Metadata.h"
54 #include "llvm/IR/Module.h"
55 #include "llvm/IR/Operator.h"
57 #include "llvm/IR/Type.h"
58 #include "llvm/IR/Use.h"
59 #include "llvm/IR/User.h"
60 #include "llvm/IR/Value.h"
62 #include "llvm/Support/Casting.h"
64 #include "llvm/Support/Compiler.h"
66 #include <algorithm>
67 #include <cassert>
68 #include <cstddef>
69 #include <cstdint>
70 #include <cstring>
71 #include <string>
72 
73 using namespace llvm;
75 
76 // Explicit instantiations of SymbolTableListTraits since some of the methods
77 // are not in the public header file...
79 
81  "non-global-value-max-name-size", cl::Hidden, cl::init(1024),
82  cl::desc("Maximum size for the name of non-global values."));
83 
84 //===----------------------------------------------------------------------===//
85 // Argument Implementation
86 //===----------------------------------------------------------------------===//
87 
88 Argument::Argument(Type *Ty, const Twine &Name, Function *Par, unsigned ArgNo)
89  : Value(Ty, Value::ArgumentVal), Parent(Par), ArgNo(ArgNo) {
90  setName(Name);
91 }
92 
93 void Argument::setParent(Function *parent) {
94  Parent = parent;
95 }
96 
97 bool Argument::hasNonNullAttr(bool AllowUndefOrPoison) const {
98  if (!getType()->isPointerTy()) return false;
99  if (getParent()->hasParamAttribute(getArgNo(), Attribute::NonNull) &&
100  (AllowUndefOrPoison ||
101  getParent()->hasParamAttribute(getArgNo(), Attribute::NoUndef)))
102  return true;
103  else if (getDereferenceableBytes() > 0 &&
105  getType()->getPointerAddressSpace()))
106  return true;
107  return false;
108 }
109 
111  if (!getType()->isPointerTy()) return false;
112  return hasAttribute(Attribute::ByVal);
113 }
114 
116  if (!getType()->isPointerTy())
117  return false;
118  return hasAttribute(Attribute::ByRef);
119 }
120 
122  return getParent()->hasParamAttribute(getArgNo(), Attribute::SwiftSelf);
123 }
124 
126  return getParent()->hasParamAttribute(getArgNo(), Attribute::SwiftError);
127 }
128 
130  if (!getType()->isPointerTy()) return false;
131  return hasAttribute(Attribute::InAlloca);
132 }
133 
135  if (!getType()->isPointerTy())
136  return false;
137  return hasAttribute(Attribute::Preallocated);
138 }
139 
141  if (!getType()->isPointerTy()) return false;
143  return Attrs.hasParamAttr(getArgNo(), Attribute::ByVal) ||
144  Attrs.hasParamAttr(getArgNo(), Attribute::InAlloca) ||
145  Attrs.hasParamAttr(getArgNo(), Attribute::Preallocated);
146 }
147 
149  if (!getType()->isPointerTy())
150  return false;
152  return Attrs.hasParamAttr(getArgNo(), Attribute::ByVal) ||
153  Attrs.hasParamAttr(getArgNo(), Attribute::StructRet) ||
154  Attrs.hasParamAttr(getArgNo(), Attribute::InAlloca) ||
155  Attrs.hasParamAttr(getArgNo(), Attribute::Preallocated) ||
156  Attrs.hasParamAttr(getArgNo(), Attribute::ByRef);
157 }
158 
159 /// For a byval, sret, inalloca, or preallocated parameter, get the in-memory
160 /// parameter type.
162  // FIXME: All the type carrying attributes are mutually exclusive, so there
163  // should be a single query to get the stored type that handles any of them.
164  if (Type *ByValTy = ParamAttrs.getByValType())
165  return ByValTy;
166  if (Type *ByRefTy = ParamAttrs.getByRefType())
167  return ByRefTy;
168  if (Type *PreAllocTy = ParamAttrs.getPreallocatedType())
169  return PreAllocTy;
170  if (Type *InAllocaTy = ParamAttrs.getInAllocaType())
171  return InAllocaTy;
172  if (Type *SRetTy = ParamAttrs.getStructRetType())
173  return SRetTy;
174 
175  return nullptr;
176 }
177 
179  AttributeSet ParamAttrs =
181  if (Type *MemTy = getMemoryParamAllocType(ParamAttrs))
182  return DL.getTypeAllocSize(MemTy);
183  return 0;
184 }
185 
187  AttributeSet ParamAttrs =
189  return getMemoryParamAllocType(ParamAttrs);
190 }
191 
192 unsigned Argument::getParamAlignment() const {
193  assert(getType()->isPointerTy() && "Only pointers have alignments");
194  return getParent()->getParamAlignment(getArgNo());
195 }
196 
198  assert(getType()->isPointerTy() && "Only pointers have alignments");
199  return getParent()->getParamAlign(getArgNo());
200 }
201 
204 }
205 
207  assert(getType()->isPointerTy() && "Only pointers have byval types");
208  return getParent()->getParamByValType(getArgNo());
209 }
210 
212  assert(getType()->isPointerTy() && "Only pointers have sret types");
214 }
215 
217  assert(getType()->isPointerTy() && "Only pointers have byref types");
218  return getParent()->getParamByRefType(getArgNo());
219 }
220 
222  assert(getType()->isPointerTy() && "Only pointers have inalloca types");
224 }
225 
227  assert(getType()->isPointerTy() &&
228  "Only pointers have dereferenceable bytes");
230 }
231 
233  assert(getType()->isPointerTy() &&
234  "Only pointers have dereferenceable bytes");
236 }
237 
238 bool Argument::hasNestAttr() const {
239  if (!getType()->isPointerTy()) return false;
240  return hasAttribute(Attribute::Nest);
241 }
242 
244  if (!getType()->isPointerTy()) return false;
245  return hasAttribute(Attribute::NoAlias);
246 }
247 
249  if (!getType()->isPointerTy()) return false;
250  return hasAttribute(Attribute::NoCapture);
251 }
252 
254  if (!getType()->isPointerTy()) return false;
255  return hasAttribute(Attribute::NoFree);
256 }
257 
259  if (!getType()->isPointerTy()) return false;
260  return hasAttribute(Attribute::StructRet);
261 }
262 
264  return hasAttribute(Attribute::InReg);
265 }
266 
268  return hasAttribute(Attribute::Returned);
269 }
270 
271 bool Argument::hasZExtAttr() const {
272  return hasAttribute(Attribute::ZExt);
273 }
274 
275 bool Argument::hasSExtAttr() const {
276  return hasAttribute(Attribute::SExt);
277 }
278 
281  return Attrs.hasParamAttr(getArgNo(), Attribute::ReadOnly) ||
282  Attrs.hasParamAttr(getArgNo(), Attribute::ReadNone);
283 }
284 
287  AL = AL.addParamAttributes(Parent->getContext(), getArgNo(), B);
289 }
290 
293 }
294 
296  getParent()->addParamAttr(getArgNo(), Attr);
297 }
298 
301 }
302 
305  AL = AL.removeParamAttributes(Parent->getContext(), getArgNo(), B);
307 }
308 
311 }
312 
315 }
316 
317 //===----------------------------------------------------------------------===//
318 // Helper Methods in Function
319 //===----------------------------------------------------------------------===//
320 
322  return getType()->getContext();
323 }
324 
326  unsigned NumInstrs = 0;
327  for (const BasicBlock &BB : BasicBlocks)
328  NumInstrs += std::distance(BB.instructionsWithoutDebug().begin(),
329  BB.instructionsWithoutDebug().end());
330  return NumInstrs;
331 }
332 
334  const Twine &N, Module &M) {
335  return Create(Ty, Linkage, M.getDataLayout().getProgramAddressSpace(), N, &M);
336 }
337 
340  unsigned AddrSpace, const Twine &N,
341  Module *M) {
342  auto *F = new Function(Ty, Linkage, AddrSpace, N, M);
343  AttrBuilder B;
344  if (M->getUwtable())
345  B.addAttribute(Attribute::UWTable);
346  switch (M->getFramePointer()) {
348  // 0 ("none") is the default.
349  break;
351  B.addAttribute("frame-pointer", "non-leaf");
352  break;
354  B.addAttribute("frame-pointer", "all");
355  break;
356  }
357  F->addFnAttrs(B);
358  return F;
359 }
360 
362  getParent()->getFunctionList().remove(getIterator());
363 }
364 
366  getParent()->getFunctionList().erase(getIterator());
367 }
368 
369 //===----------------------------------------------------------------------===//
370 // Function Implementation
371 //===----------------------------------------------------------------------===//
372 
373 static unsigned computeAddrSpace(unsigned AddrSpace, Module *M) {
374  // If AS == -1 and we are passed a valid module pointer we place the function
375  // in the program address space. Otherwise we default to AS0.
376  if (AddrSpace == static_cast<unsigned>(-1))
377  return M ? M->getDataLayout().getProgramAddressSpace() : 0;
378  return AddrSpace;
379 }
380 
381 Function::Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
382  const Twine &name, Module *ParentModule)
383  : GlobalObject(Ty, Value::FunctionVal,
384  OperandTraits<Function>::op_begin(this), 0, Linkage, name,
385  computeAddrSpace(AddrSpace, ParentModule)),
386  NumArgs(Ty->getNumParams()) {
387  assert(FunctionType::isValidReturnType(getReturnType()) &&
388  "invalid return type");
389  setGlobalObjectSubClassData(0);
390 
391  // We only need a symbol table for a function if the context keeps value names
392  if (!getContext().shouldDiscardValueNames())
393  SymTab = std::make_unique<ValueSymbolTable>(NonGlobalValueMaxNameSize);
394 
395  // If the function has arguments, mark them as lazily built.
396  if (Ty->getNumParams())
397  setValueSubclassData(1); // Set the "has lazy arguments" bit.
398 
399  if (ParentModule)
400  ParentModule->getFunctionList().push_back(this);
401 
402  HasLLVMReservedName = getName().startswith("llvm.");
403  // Ensure intrinsics have the right parameter attributes.
404  // Note, the IntID field will have been set in Value::setName if this function
405  // name is a valid intrinsic ID.
406  if (IntID)
407  setAttributes(Intrinsic::getAttributes(getContext(), IntID));
408 }
409 
410 Function::~Function() {
411  dropAllReferences(); // After this it is safe to delete instructions.
412 
413  // Delete all of the method arguments and unlink from symbol table...
414  if (Arguments)
415  clearArguments();
416 
417  // Remove the function from the on-the-side GC table.
418  clearGC();
419 }
420 
421 void Function::BuildLazyArguments() const {
422  // Create the arguments vector, all arguments start out unnamed.
423  auto *FT = getFunctionType();
424  if (NumArgs > 0) {
425  Arguments = std::allocator<Argument>().allocate(NumArgs);
426  for (unsigned i = 0, e = NumArgs; i != e; ++i) {
427  Type *ArgTy = FT->getParamType(i);
428  assert(!ArgTy->isVoidTy() && "Cannot have void typed arguments!");
429  new (Arguments + i) Argument(ArgTy, "", const_cast<Function *>(this), i);
430  }
431  }
432 
433  // Clear the lazy arguments bit.
434  unsigned SDC = getSubclassDataFromValue();
435  SDC &= ~(1 << 0);
436  const_cast<Function*>(this)->setValueSubclassData(SDC);
438 }
439 
441  return MutableArrayRef<Argument>(Args, Count);
442 }
443 
445  switch (getIntrinsicID()) {
446 #define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
447  case Intrinsic::INTRINSIC:
448 #include "llvm/IR/ConstrainedOps.def"
449  return true;
450 #undef INSTRUCTION
451  default:
452  return false;
453  }
454 }
455 
456 void Function::clearArguments() {
457  for (Argument &A : makeArgArray(Arguments, NumArgs)) {
458  A.setName("");
459  A.~Argument();
460  }
461  std::allocator<Argument>().deallocate(Arguments, NumArgs);
462  Arguments = nullptr;
463 }
464 
466  assert(isDeclaration() && "Expected no references to current arguments");
467 
468  // Drop the current arguments, if any, and set the lazy argument bit.
469  if (!hasLazyArguments()) {
470  assert(llvm::all_of(makeArgArray(Arguments, NumArgs),
471  [](const Argument &A) { return A.use_empty(); }) &&
472  "Expected arguments to be unused in declaration");
473  clearArguments();
474  setValueSubclassData(getSubclassDataFromValue() | (1 << 0));
475  }
476 
477  // Nothing to steal if Src has lazy arguments.
478  if (Src.hasLazyArguments())
479  return;
480 
481  // Steal arguments from Src, and fix the lazy argument bits.
482  assert(arg_size() == Src.arg_size());
483  Arguments = Src.Arguments;
484  Src.Arguments = nullptr;
485  for (Argument &A : makeArgArray(Arguments, NumArgs)) {
486  // FIXME: This does the work of transferNodesFromList inefficiently.
488  if (A.hasName())
489  Name = A.getName();
490  if (!Name.empty())
491  A.setName("");
492  A.setParent(this);
493  if (!Name.empty())
494  A.setName(Name);
495  }
496 
497  setValueSubclassData(getSubclassDataFromValue() & ~(1 << 0));
499  Src.setValueSubclassData(Src.getSubclassDataFromValue() | (1 << 0));
500 }
501 
502 // dropAllReferences() - This function causes all the subinstructions to "let
503 // go" of all references that they are maintaining. This allows one to
504 // 'delete' a whole class at a time, even though there may be circular
505 // references... first all references are dropped, and all use counts go to
506 // zero. Then everything is deleted for real. Note that no operations are
507 // valid on an object that has "dropped all references", except operator
508 // delete.
509 //
511  setIsMaterializable(false);
512 
513  for (BasicBlock &BB : *this)
514  BB.dropAllReferences();
515 
516  // Delete all basic blocks. They are now unused, except possibly by
517  // blockaddresses, but BasicBlock's destructor takes care of those.
518  while (!BasicBlocks.empty())
519  BasicBlocks.begin()->eraseFromParent();
520 
521  // Drop uses of any optional data (real or placeholder).
522  if (getNumOperands()) {
525  setValueSubclassData(getSubclassDataFromValue() & ~0xe);
526  }
527 
528  // Metadata is stored in a side-table.
529  clearMetadata();
530 }
531 
533  AttributeSets = AttributeSets.addAttributeAtIndex(getContext(), i, Attr);
534 }
535 
537  AttributeSets = AttributeSets.addFnAttribute(getContext(), Kind);
538 }
539 
541  AttributeSets = AttributeSets.addFnAttribute(getContext(), Kind, Val);
542 }
543 
545  AttributeSets = AttributeSets.addFnAttribute(getContext(), Attr);
546 }
547 
549  AttributeSets = AttributeSets.addFnAttributes(getContext(), Attrs);
550 }
551 
553  AttributeSets = AttributeSets.addRetAttribute(getContext(), Kind);
554 }
555 
557  AttributeSets = AttributeSets.addRetAttribute(getContext(), Attr);
558 }
559 
561  AttributeSets = AttributeSets.addRetAttributes(getContext(), Attrs);
562 }
563 
565  AttributeSets = AttributeSets.addParamAttribute(getContext(), ArgNo, Kind);
566 }
567 
568 void Function::addParamAttr(unsigned ArgNo, Attribute Attr) {
569  AttributeSets = AttributeSets.addParamAttribute(getContext(), ArgNo, Attr);
570 }
571 
572 void Function::addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) {
573  AttributeSets = AttributeSets.addParamAttributes(getContext(), ArgNo, Attrs);
574 }
575 
577  AttributeSets = AttributeSets.removeAttributeAtIndex(getContext(), i, Kind);
578 }
579 
581  AttributeSets = AttributeSets.removeAttributeAtIndex(getContext(), i, Kind);
582 }
583 
585  AttributeSets = AttributeSets.removeFnAttribute(getContext(), Kind);
586 }
587 
589  AttributeSets = AttributeSets.removeFnAttribute(getContext(), Kind);
590 }
591 
593  AttributeSets = AttributeSets.removeFnAttributes(getContext(), Attrs);
594 }
595 
597  AttributeSets = AttributeSets.removeRetAttribute(getContext(), Kind);
598 }
599 
601  AttributeSets = AttributeSets.removeRetAttribute(getContext(), Kind);
602 }
603 
605  AttributeSets = AttributeSets.removeRetAttributes(getContext(), Attrs);
606 }
607 
609  AttributeSets = AttributeSets.removeParamAttribute(getContext(), ArgNo, Kind);
610 }
611 
612 void Function::removeParamAttr(unsigned ArgNo, StringRef Kind) {
613  AttributeSets = AttributeSets.removeParamAttribute(getContext(), ArgNo, Kind);
614 }
615 
616 void Function::removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) {
617  AttributeSets =
618  AttributeSets.removeParamAttributes(getContext(), ArgNo, Attrs);
619 }
620 
621 void Function::addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes) {
622  AttributeSets =
623  AttributeSets.addDereferenceableParamAttr(getContext(), ArgNo, Bytes);
624 }
625 
627  return AttributeSets.hasFnAttr(Kind);
628 }
629 
631  return AttributeSets.hasFnAttr(Kind);
632 }
633 
635  return AttributeSets.hasRetAttr(Kind);
636 }
637 
638 bool Function::hasParamAttribute(unsigned ArgNo,
639  Attribute::AttrKind Kind) const {
640  return AttributeSets.hasParamAttr(ArgNo, Kind);
641 }
642 
644  Attribute::AttrKind Kind) const {
645  return AttributeSets.getAttributeAtIndex(i, Kind);
646 }
647 
649  return AttributeSets.getAttributeAtIndex(i, Kind);
650 }
651 
653  return AttributeSets.getFnAttr(Kind);
654 }
655 
657  return AttributeSets.getFnAttr(Kind);
658 }
659 
660 /// gets the specified attribute from the list of attributes.
662  Attribute::AttrKind Kind) const {
663  return AttributeSets.getParamAttr(ArgNo, Kind);
664 }
665 
667  uint64_t Bytes) {
668  AttributeSets = AttributeSets.addDereferenceableOrNullParamAttr(getContext(),
669  ArgNo, Bytes);
670 }
671 
673  if (&FPType == &APFloat::IEEEsingle()) {
674  Attribute Attr = getFnAttribute("denormal-fp-math-f32");
675  StringRef Val = Attr.getValueAsString();
676  if (!Val.empty())
677  return parseDenormalFPAttribute(Val);
678 
679  // If the f32 variant of the attribute isn't specified, try to use the
680  // generic one.
681  }
682 
683  Attribute Attr = getFnAttribute("denormal-fp-math");
685 }
686 
687 const std::string &Function::getGC() const {
688  assert(hasGC() && "Function has no collector");
689  return getContext().getGC(*this);
690 }
691 
692 void Function::setGC(std::string Str) {
693  setValueSubclassDataBit(14, !Str.empty());
694  getContext().setGC(*this, std::move(Str));
695 }
696 
698  if (!hasGC())
699  return;
700  getContext().deleteGC(*this);
701  setValueSubclassDataBit(14, false);
702 }
703 
705  return hasFnAttribute(Attribute::StackProtect) ||
706  hasFnAttribute(Attribute::StackProtectStrong) ||
707  hasFnAttribute(Attribute::StackProtectReq);
708 }
709 
710 /// Copy all additional attributes (those not needed to create a Function) from
711 /// the Function Src to this one.
714  setCallingConv(Src->getCallingConv());
715  setAttributes(Src->getAttributes());
716  if (Src->hasGC())
717  setGC(Src->getGC());
718  else
719  clearGC();
720  if (Src->hasPersonalityFn())
721  setPersonalityFn(Src->getPersonalityFn());
722  if (Src->hasPrefixData())
723  setPrefixData(Src->getPrefixData());
724  if (Src->hasPrologueData())
725  setPrologueData(Src->getPrologueData());
726 }
727 
728 /// Table of string intrinsic names indexed by enum value.
729 static const char * const IntrinsicNameTable[] = {
730  "not_intrinsic",
731 #define GET_INTRINSIC_NAME_TABLE
732 #include "llvm/IR/IntrinsicImpl.inc"
733 #undef GET_INTRINSIC_NAME_TABLE
734 };
735 
736 /// Table of per-target intrinsic name tables.
737 #define GET_INTRINSIC_TARGET_DATA
738 #include "llvm/IR/IntrinsicImpl.inc"
739 #undef GET_INTRINSIC_TARGET_DATA
740 
742  return IID > TargetInfos[0].Count;
743 }
744 
746  return isTargetIntrinsic(IntID);
747 }
748 
749 /// Find the segment of \c IntrinsicNameTable for intrinsics with the same
750 /// target as \c Name, or the generic table if \c Name is not target specific.
751 ///
752 /// Returns the relevant slice of \c IntrinsicNameTable
754  assert(Name.startswith("llvm."));
755 
756  ArrayRef<IntrinsicTargetInfo> Targets(TargetInfos);
757  // Drop "llvm." and take the first dotted component. That will be the target
758  // if this is target specific.
759  StringRef Target = Name.drop_front(5).split('.').first;
760  auto It = partition_point(
761  Targets, [=](const IntrinsicTargetInfo &TI) { return TI.Name < Target; });
762  // We've either found the target or just fall back to the generic set, which
763  // is always first.
764  const auto &TI = It != Targets.end() && It->Name == Target ? *It : Targets[0];
765  return makeArrayRef(&IntrinsicNameTable[1] + TI.Offset, TI.Count);
766 }
767 
768 /// This does the actual lookup of an intrinsic ID which
769 /// matches the given function name.
772  int Idx = Intrinsic::lookupLLVMIntrinsicByName(NameTable, Name);
773  if (Idx == -1)
775 
776  // Intrinsic IDs correspond to the location in IntrinsicNameTable, but we have
777  // an index into a sub-table.
778  int Adjust = NameTable.data() - IntrinsicNameTable;
779  Intrinsic::ID ID = static_cast<Intrinsic::ID>(Idx + Adjust);
780 
781  // If the intrinsic is not overloaded, require an exact match. If it is
782  // overloaded, require either exact or prefix match.
783  const auto MatchSize = strlen(NameTable[Idx]);
784  assert(Name.size() >= MatchSize && "Expected either exact or prefix match");
785  bool IsExactMatch = Name.size() == MatchSize;
786  return IsExactMatch || Intrinsic::isOverloaded(ID) ? ID
788 }
789 
791  StringRef Name = getName();
792  if (!Name.startswith("llvm.")) {
793  HasLLVMReservedName = false;
795  return;
796  }
797  HasLLVMReservedName = true;
799 }
800 
801 /// Returns a stable mangling for the type specified for use in the name
802 /// mangling scheme used by 'any' types in intrinsic signatures. The mangling
803 /// of named types is simply their name. Manglings for unnamed types consist
804 /// of a prefix ('p' for pointers, 'a' for arrays, 'f_' for functions)
805 /// combined with the mangling of their component types. A vararg function
806 /// type will have a suffix of 'vararg'. Since function types can contain
807 /// other function types, we close a function type mangling with suffix 'f'
808 /// which can't be confused with it's prefix. This ensures we don't have
809 /// collisions between two unrelated function types. Otherwise, you might
810 /// parse ffXX as f(fXX) or f(fX)X. (X is a placeholder for any other type.)
811 /// The HasUnnamedType boolean is set if an unnamed type was encountered,
812 /// indicating that extra care must be taken to ensure a unique name.
813 static std::string getMangledTypeStr(Type *Ty, bool &HasUnnamedType) {
814  std::string Result;
815  if (PointerType *PTyp = dyn_cast<PointerType>(Ty)) {
816  Result += "p" + utostr(PTyp->getAddressSpace());
817  // Opaque pointer doesn't have pointee type information, so we just mangle
818  // address space for opaque pointer.
819  if (!PTyp->isOpaque())
820  Result += getMangledTypeStr(PTyp->getElementType(), HasUnnamedType);
821  } else if (ArrayType *ATyp = dyn_cast<ArrayType>(Ty)) {
822  Result += "a" + utostr(ATyp->getNumElements()) +
823  getMangledTypeStr(ATyp->getElementType(), HasUnnamedType);
824  } else if (StructType *STyp = dyn_cast<StructType>(Ty)) {
825  if (!STyp->isLiteral()) {
826  Result += "s_";
827  if (STyp->hasName())
828  Result += STyp->getName();
829  else
830  HasUnnamedType = true;
831  } else {
832  Result += "sl_";
833  for (auto Elem : STyp->elements())
834  Result += getMangledTypeStr(Elem, HasUnnamedType);
835  }
836  // Ensure nested structs are distinguishable.
837  Result += "s";
838  } else if (FunctionType *FT = dyn_cast<FunctionType>(Ty)) {
839  Result += "f_" + getMangledTypeStr(FT->getReturnType(), HasUnnamedType);
840  for (size_t i = 0; i < FT->getNumParams(); i++)
841  Result += getMangledTypeStr(FT->getParamType(i), HasUnnamedType);
842  if (FT->isVarArg())
843  Result += "vararg";
844  // Ensure nested function types are distinguishable.
845  Result += "f";
846  } else if (VectorType *VTy = dyn_cast<VectorType>(Ty)) {
847  ElementCount EC = VTy->getElementCount();
848  if (EC.isScalable())
849  Result += "nx";
850  Result += "v" + utostr(EC.getKnownMinValue()) +
851  getMangledTypeStr(VTy->getElementType(), HasUnnamedType);
852  } else if (Ty) {
853  switch (Ty->getTypeID()) {
854  default: llvm_unreachable("Unhandled type");
855  case Type::VoidTyID: Result += "isVoid"; break;
856  case Type::MetadataTyID: Result += "Metadata"; break;
857  case Type::HalfTyID: Result += "f16"; break;
858  case Type::BFloatTyID: Result += "bf16"; break;
859  case Type::FloatTyID: Result += "f32"; break;
860  case Type::DoubleTyID: Result += "f64"; break;
861  case Type::X86_FP80TyID: Result += "f80"; break;
862  case Type::FP128TyID: Result += "f128"; break;
863  case Type::PPC_FP128TyID: Result += "ppcf128"; break;
864  case Type::X86_MMXTyID: Result += "x86mmx"; break;
865  case Type::X86_AMXTyID: Result += "x86amx"; break;
866  case Type::IntegerTyID:
867  Result += "i" + utostr(cast<IntegerType>(Ty)->getBitWidth());
868  break;
869  }
870  }
871  return Result;
872 }
873 
875  assert(id < num_intrinsics && "Invalid intrinsic ID!");
876  return IntrinsicNameTable[id];
877 }
878 
880  assert(id < num_intrinsics && "Invalid intrinsic ID!");
882  "This version of getName does not support overloading");
883  return getBaseName(id);
884 }
885 
887  Module *M, FunctionType *FT,
888  bool EarlyModuleCheck) {
889 
890  assert(Id < Intrinsic::num_intrinsics && "Invalid intrinsic ID!");
891  assert((Tys.empty() || Intrinsic::isOverloaded(Id)) &&
892  "This version of getName is for overloaded intrinsics only");
893  (void)EarlyModuleCheck;
894  assert((!EarlyModuleCheck || M ||
895  !any_of(Tys, [](Type *T) { return isa<PointerType>(T); })) &&
896  "Intrinsic overloading on pointer types need to provide a Module");
897  bool HasUnnamedType = false;
898  std::string Result(Intrinsic::getBaseName(Id));
899  for (Type *Ty : Tys)
900  Result += "." + getMangledTypeStr(Ty, HasUnnamedType);
901  if (HasUnnamedType) {
902  assert(M && "unnamed types need a module");
903  if (!FT)
904  FT = Intrinsic::getType(M->getContext(), Id, Tys);
905  else
906  assert((FT == Intrinsic::getType(M->getContext(), Id, Tys)) &&
907  "Provided FunctionType must match arguments");
908  return M->getUniqueIntrinsicName(Result, Id, FT);
909  }
910  return Result;
911 }
912 
914  FunctionType *FT) {
915  assert(M && "We need to have a Module");
916  return getIntrinsicNameImpl(Id, Tys, M, FT, true);
917 }
918 
920  return getIntrinsicNameImpl(Id, Tys, nullptr, nullptr, false);
921 }
922 
923 /// IIT_Info - These are enumerators that describe the entries returned by the
924 /// getIntrinsicInfoTableEntries function.
925 ///
926 /// NOTE: This must be kept in synch with the copy in TblGen/IntrinsicEmitter!
927 enum IIT_Info {
928  // Common values should be encoded with 0-15.
929  IIT_Done = 0,
930  IIT_I1 = 1,
931  IIT_I8 = 2,
932  IIT_I16 = 3,
933  IIT_I32 = 4,
934  IIT_I64 = 5,
935  IIT_F16 = 6,
936  IIT_F32 = 7,
937  IIT_F64 = 8,
938  IIT_V2 = 9,
939  IIT_V4 = 10,
940  IIT_V8 = 11,
941  IIT_V16 = 12,
942  IIT_V32 = 13,
943  IIT_PTR = 14,
944  IIT_ARG = 15,
945 
946  // Values from 16+ are only encodable with the inefficient encoding.
947  IIT_V64 = 16,
948  IIT_MMX = 17,
949  IIT_TOKEN = 18,
959  IIT_V1 = 28,
966  IIT_I128 = 35,
967  IIT_V512 = 36,
968  IIT_V1024 = 37,
972  IIT_F128 = 41,
978  IIT_V128 = 47,
979  IIT_BF16 = 48,
981  IIT_V256 = 50,
982  IIT_AMX = 51
983 };
984 
985 static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos,
986  IIT_Info LastInfo,
988  using namespace Intrinsic;
989 
990  bool IsScalableVector = (LastInfo == IIT_SCALABLE_VEC);
991 
992  IIT_Info Info = IIT_Info(Infos[NextElt++]);
993  unsigned StructElts = 2;
994 
995  switch (Info) {
996  case IIT_Done:
997  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0));
998  return;
999  case IIT_VARARG:
1000  OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0));
1001  return;
1002  case IIT_MMX:
1003  OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0));
1004  return;
1005  case IIT_AMX:
1006  OutputTable.push_back(IITDescriptor::get(IITDescriptor::AMX, 0));
1007  return;
1008  case IIT_TOKEN:
1009  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Token, 0));
1010  return;
1011  case IIT_METADATA:
1012  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0));
1013  return;
1014  case IIT_F16:
1015  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0));
1016  return;
1017  case IIT_BF16:
1018  OutputTable.push_back(IITDescriptor::get(IITDescriptor::BFloat, 0));
1019  return;
1020  case IIT_F32:
1021  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Float, 0));
1022  return;
1023  case IIT_F64:
1024  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Double, 0));
1025  return;
1026  case IIT_F128:
1027  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Quad, 0));
1028  return;
1029  case IIT_I1:
1030  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 1));
1031  return;
1032  case IIT_I8:
1033  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8));
1034  return;
1035  case IIT_I16:
1036  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer,16));
1037  return;
1038  case IIT_I32:
1039  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32));
1040  return;
1041  case IIT_I64:
1042  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64));
1043  return;
1044  case IIT_I128:
1045  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 128));
1046  return;
1047  case IIT_V1:
1048  OutputTable.push_back(IITDescriptor::getVector(1, IsScalableVector));
1049  DecodeIITType(NextElt, Infos, Info, OutputTable);
1050  return;
1051  case IIT_V2:
1052  OutputTable.push_back(IITDescriptor::getVector(2, IsScalableVector));
1053  DecodeIITType(NextElt, Infos, Info, OutputTable);
1054  return;
1055  case IIT_V4:
1056  OutputTable.push_back(IITDescriptor::getVector(4, IsScalableVector));
1057  DecodeIITType(NextElt, Infos, Info, OutputTable);
1058  return;
1059  case IIT_V8:
1060  OutputTable.push_back(IITDescriptor::getVector(8, IsScalableVector));
1061  DecodeIITType(NextElt, Infos, Info, OutputTable);
1062  return;
1063  case IIT_V16:
1064  OutputTable.push_back(IITDescriptor::getVector(16, IsScalableVector));
1065  DecodeIITType(NextElt, Infos, Info, OutputTable);
1066  return;
1067  case IIT_V32:
1068  OutputTable.push_back(IITDescriptor::getVector(32, IsScalableVector));
1069  DecodeIITType(NextElt, Infos, Info, OutputTable);
1070  return;
1071  case IIT_V64:
1072  OutputTable.push_back(IITDescriptor::getVector(64, IsScalableVector));
1073  DecodeIITType(NextElt, Infos, Info, OutputTable);
1074  return;
1075  case IIT_V128:
1076  OutputTable.push_back(IITDescriptor::getVector(128, IsScalableVector));
1077  DecodeIITType(NextElt, Infos, Info, OutputTable);
1078  return;
1079  case IIT_V256:
1080  OutputTable.push_back(IITDescriptor::getVector(256, IsScalableVector));
1081  DecodeIITType(NextElt, Infos, Info, OutputTable);
1082  return;
1083  case IIT_V512:
1084  OutputTable.push_back(IITDescriptor::getVector(512, IsScalableVector));
1085  DecodeIITType(NextElt, Infos, Info, OutputTable);
1086  return;
1087  case IIT_V1024:
1088  OutputTable.push_back(IITDescriptor::getVector(1024, IsScalableVector));
1089  DecodeIITType(NextElt, Infos, Info, OutputTable);
1090  return;
1091  case IIT_PTR:
1092  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 0));
1093  DecodeIITType(NextElt, Infos, Info, OutputTable);
1094  return;
1095  case IIT_ANYPTR: { // [ANYPTR addrspace, subtype]
1096  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer,
1097  Infos[NextElt++]));
1098  DecodeIITType(NextElt, Infos, Info, OutputTable);
1099  return;
1100  }
1101  case IIT_ARG: {
1102  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1103  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Argument, ArgInfo));
1104  return;
1105  }
1106  case IIT_EXTEND_ARG: {
1107  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1108  OutputTable.push_back(IITDescriptor::get(IITDescriptor::ExtendArgument,
1109  ArgInfo));
1110  return;
1111  }
1112  case IIT_TRUNC_ARG: {
1113  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1114  OutputTable.push_back(IITDescriptor::get(IITDescriptor::TruncArgument,
1115  ArgInfo));
1116  return;
1117  }
1118  case IIT_HALF_VEC_ARG: {
1119  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1120  OutputTable.push_back(IITDescriptor::get(IITDescriptor::HalfVecArgument,
1121  ArgInfo));
1122  return;
1123  }
1124  case IIT_SAME_VEC_WIDTH_ARG: {
1125  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1127  ArgInfo));
1128  return;
1129  }
1130  case IIT_PTR_TO_ARG: {
1131  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1132  OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToArgument,
1133  ArgInfo));
1134  return;
1135  }
1136  case IIT_PTR_TO_ELT: {
1137  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1138  OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToElt, ArgInfo));
1139  return;
1140  }
1142  unsigned short ArgNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1143  unsigned short RefNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1144  OutputTable.push_back(
1146  return;
1147  }
1148  case IIT_EMPTYSTRUCT:
1149  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0));
1150  return;
1151  case IIT_STRUCT9: ++StructElts; LLVM_FALLTHROUGH;
1152  case IIT_STRUCT8: ++StructElts; LLVM_FALLTHROUGH;
1153  case IIT_STRUCT7: ++StructElts; LLVM_FALLTHROUGH;
1154  case IIT_STRUCT6: ++StructElts; LLVM_FALLTHROUGH;
1155  case IIT_STRUCT5: ++StructElts; LLVM_FALLTHROUGH;
1156  case IIT_STRUCT4: ++StructElts; LLVM_FALLTHROUGH;
1157  case IIT_STRUCT3: ++StructElts; LLVM_FALLTHROUGH;
1158  case IIT_STRUCT2: {
1159  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts));
1160 
1161  for (unsigned i = 0; i != StructElts; ++i)
1162  DecodeIITType(NextElt, Infos, Info, OutputTable);
1163  return;
1164  }
1165  case IIT_SUBDIVIDE2_ARG: {
1166  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1168  ArgInfo));
1169  return;
1170  }
1171  case IIT_SUBDIVIDE4_ARG: {
1172  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1174  ArgInfo));
1175  return;
1176  }
1177  case IIT_VEC_ELEMENT: {
1178  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1180  ArgInfo));
1181  return;
1182  }
1183  case IIT_SCALABLE_VEC: {
1184  DecodeIITType(NextElt, Infos, Info, OutputTable);
1185  return;
1186  }
1188  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1190  ArgInfo));
1191  return;
1192  }
1193  }
1194  llvm_unreachable("unhandled");
1195 }
1196 
1197 #define GET_INTRINSIC_GENERATOR_GLOBAL
1198 #include "llvm/IR/IntrinsicImpl.inc"
1199 #undef GET_INTRINSIC_GENERATOR_GLOBAL
1200 
1203  // Check to see if the intrinsic's type was expressible by the table.
1204  unsigned TableVal = IIT_Table[id-1];
1205 
1206  // Decode the TableVal into an array of IITValues.
1208  ArrayRef<unsigned char> IITEntries;
1209  unsigned NextElt = 0;
1210  if ((TableVal >> 31) != 0) {
1211  // This is an offset into the IIT_LongEncodingTable.
1212  IITEntries = IIT_LongEncodingTable;
1213 
1214  // Strip sentinel bit.
1215  NextElt = (TableVal << 1) >> 1;
1216  } else {
1217  // Decode the TableVal into an array of IITValues. If the entry was encoded
1218  // into a single word in the table itself, decode it now.
1219  do {
1220  IITValues.push_back(TableVal & 0xF);
1221  TableVal >>= 4;
1222  } while (TableVal);
1223 
1224  IITEntries = IITValues;
1225  NextElt = 0;
1226  }
1227 
1228  // Okay, decode the table into the output vector of IITDescriptors.
1229  DecodeIITType(NextElt, IITEntries, IIT_Done, T);
1230  while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0)
1231  DecodeIITType(NextElt, IITEntries, IIT_Done, T);
1232 }
1233 
1236  using namespace Intrinsic;
1237 
1238  IITDescriptor D = Infos.front();
1239  Infos = Infos.slice(1);
1240 
1241  switch (D.Kind) {
1253 
1255  return IntegerType::get(Context, D.Integer_Width);
1256  case IITDescriptor::Vector:
1257  return VectorType::get(DecodeFixedType(Infos, Tys, Context),
1258  D.Vector_Width);
1260  return PointerType::get(DecodeFixedType(Infos, Tys, Context),
1261  D.Pointer_AddressSpace);
1262  case IITDescriptor::Struct: {
1264  for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
1265  Elts.push_back(DecodeFixedType(Infos, Tys, Context));
1266  return StructType::get(Context, Elts);
1267  }
1269  return Tys[D.getArgumentNumber()];
1271  Type *Ty = Tys[D.getArgumentNumber()];
1272  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1274 
1275  return IntegerType::get(Context, 2 * cast<IntegerType>(Ty)->getBitWidth());
1276  }
1278  Type *Ty = Tys[D.getArgumentNumber()];
1279  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1281 
1282  IntegerType *ITy = cast<IntegerType>(Ty);
1283  assert(ITy->getBitWidth() % 2 == 0);
1284  return IntegerType::get(Context, ITy->getBitWidth() / 2);
1285  }
1288  Type *Ty = Tys[D.getArgumentNumber()];
1289  VectorType *VTy = dyn_cast<VectorType>(Ty);
1290  assert(VTy && "Expected an argument of Vector Type");
1291  int SubDivs = D.Kind == IITDescriptor::Subdivide2Argument ? 1 : 2;
1292  return VectorType::getSubdividedVectorType(VTy, SubDivs);
1293  }
1295  return VectorType::getHalfElementsVectorType(cast<VectorType>(
1296  Tys[D.getArgumentNumber()]));
1298  Type *EltTy = DecodeFixedType(Infos, Tys, Context);
1299  Type *Ty = Tys[D.getArgumentNumber()];
1300  if (auto *VTy = dyn_cast<VectorType>(Ty))
1301  return VectorType::get(EltTy, VTy->getElementCount());
1302  return EltTy;
1303  }
1305  Type *Ty = Tys[D.getArgumentNumber()];
1306  return PointerType::getUnqual(Ty);
1307  }
1308  case IITDescriptor::PtrToElt: {
1309  Type *Ty = Tys[D.getArgumentNumber()];
1310  VectorType *VTy = dyn_cast<VectorType>(Ty);
1311  if (!VTy)
1312  llvm_unreachable("Expected an argument of Vector Type");
1313  Type *EltTy = VTy->getElementType();
1314  return PointerType::getUnqual(EltTy);
1315  }
1317  Type *Ty = Tys[D.getArgumentNumber()];
1318  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1319  return VTy->getElementType();
1320  llvm_unreachable("Expected an argument of Vector Type");
1321  }
1323  Type *Ty = Tys[D.getArgumentNumber()];
1324  VectorType *VTy = dyn_cast<VectorType>(Ty);
1325  assert(VTy && "Expected an argument of Vector Type");
1326  return VectorType::getInteger(VTy);
1327  }
1329  // Return the overloaded type (which determines the pointers address space)
1330  return Tys[D.getOverloadArgNumber()];
1331  }
1332  llvm_unreachable("unhandled");
1333 }
1334 
1336  ID id, ArrayRef<Type*> Tys) {
1338  getIntrinsicInfoTableEntries(id, Table);
1339 
1341  Type *ResultTy = DecodeFixedType(TableRef, Tys, Context);
1342 
1343  SmallVector<Type*, 8> ArgTys;
1344  while (!TableRef.empty())
1345  ArgTys.push_back(DecodeFixedType(TableRef, Tys, Context));
1346 
1347  // DecodeFixedType returns Void for IITDescriptor::Void and IITDescriptor::VarArg
1348  // If we see void type as the type of the last argument, it is vararg intrinsic
1349  if (!ArgTys.empty() && ArgTys.back()->isVoidTy()) {
1350  ArgTys.pop_back();
1351  return FunctionType::get(ResultTy, ArgTys, true);
1352  }
1353  return FunctionType::get(ResultTy, ArgTys, false);
1354 }
1355 
1357 #define GET_INTRINSIC_OVERLOAD_TABLE
1358 #include "llvm/IR/IntrinsicImpl.inc"
1359 #undef GET_INTRINSIC_OVERLOAD_TABLE
1360 }
1361 
1363  switch (id) {
1364  default:
1365  return true;
1366 
1367  case Intrinsic::experimental_gc_statepoint:
1368  case Intrinsic::experimental_patchpoint_void:
1369  case Intrinsic::experimental_patchpoint_i64:
1370  return false;
1371  }
1372 }
1373 
1374 /// This defines the "Intrinsic::getAttributes(ID id)" method.
1375 #define GET_INTRINSIC_ATTRIBUTES
1376 #include "llvm/IR/IntrinsicImpl.inc"
1377 #undef GET_INTRINSIC_ATTRIBUTES
1378 
1380  // There can never be multiple globals with the same name of different types,
1381  // because intrinsics must be a specific type.
1382  auto *FT = getType(M->getContext(), id, Tys);
1383  return cast<Function>(
1384  M->getOrInsertFunction(Tys.empty() ? getName(id)
1385  : getName(id, Tys, M, FT),
1386  getType(M->getContext(), id, Tys))
1387  .getCallee());
1388 }
1389 
1390 // This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method.
1391 #define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
1392 #include "llvm/IR/IntrinsicImpl.inc"
1393 #undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
1394 
1395 // This defines the "Intrinsic::getIntrinsicForMSBuiltin()" method.
1396 #define GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
1397 #include "llvm/IR/IntrinsicImpl.inc"
1398 #undef GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
1399 
1401  std::pair<Type *, ArrayRef<Intrinsic::IITDescriptor>>;
1402 
1405  SmallVectorImpl<Type *> &ArgTys,
1407  bool IsDeferredCheck) {
1408  using namespace Intrinsic;
1409 
1410  // If we ran out of descriptors, there are too many arguments.
1411  if (Infos.empty()) return true;
1412 
1413  // Do this before slicing off the 'front' part
1414  auto InfosRef = Infos;
1415  auto DeferCheck = [&DeferredChecks, &InfosRef](Type *T) {
1416  DeferredChecks.emplace_back(T, InfosRef);
1417  return false;
1418  };
1419 
1420  IITDescriptor D = Infos.front();
1421  Infos = Infos.slice(1);
1422 
1423  switch (D.Kind) {
1424  case IITDescriptor::Void: return !Ty->isVoidTy();
1425  case IITDescriptor::VarArg: return true;
1426  case IITDescriptor::MMX: return !Ty->isX86_MMXTy();
1427  case IITDescriptor::AMX: return !Ty->isX86_AMXTy();
1428  case IITDescriptor::Token: return !Ty->isTokenTy();
1429  case IITDescriptor::Metadata: return !Ty->isMetadataTy();
1430  case IITDescriptor::Half: return !Ty->isHalfTy();
1431  case IITDescriptor::BFloat: return !Ty->isBFloatTy();
1432  case IITDescriptor::Float: return !Ty->isFloatTy();
1433  case IITDescriptor::Double: return !Ty->isDoubleTy();
1434  case IITDescriptor::Quad: return !Ty->isFP128Ty();
1435  case IITDescriptor::Integer: return !Ty->isIntegerTy(D.Integer_Width);
1436  case IITDescriptor::Vector: {
1437  VectorType *VT = dyn_cast<VectorType>(Ty);
1438  return !VT || VT->getElementCount() != D.Vector_Width ||
1439  matchIntrinsicType(VT->getElementType(), Infos, ArgTys,
1440  DeferredChecks, IsDeferredCheck);
1441  }
1442  case IITDescriptor::Pointer: {
1443  PointerType *PT = dyn_cast<PointerType>(Ty);
1444  if (!PT || PT->getAddressSpace() != D.Pointer_AddressSpace)
1445  return true;
1446  if (!PT->isOpaque())
1447  return matchIntrinsicType(PT->getElementType(), Infos, ArgTys,
1448  DeferredChecks, IsDeferredCheck);
1449  // Consume IIT descriptors relating to the pointer element type.
1450  while (Infos.front().Kind == IITDescriptor::Pointer)
1451  Infos = Infos.slice(1);
1452  Infos = Infos.slice(1);
1453  return false;
1454  }
1455 
1456  case IITDescriptor::Struct: {
1457  StructType *ST = dyn_cast<StructType>(Ty);
1458  if (!ST || ST->getNumElements() != D.Struct_NumElements)
1459  return true;
1460 
1461  for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
1462  if (matchIntrinsicType(ST->getElementType(i), Infos, ArgTys,
1463  DeferredChecks, IsDeferredCheck))
1464  return true;
1465  return false;
1466  }
1467 
1469  // If this is the second occurrence of an argument,
1470  // verify that the later instance matches the previous instance.
1471  if (D.getArgumentNumber() < ArgTys.size())
1472  return Ty != ArgTys[D.getArgumentNumber()];
1473 
1474  if (D.getArgumentNumber() > ArgTys.size() ||
1475  D.getArgumentKind() == IITDescriptor::AK_MatchType)
1476  return IsDeferredCheck || DeferCheck(Ty);
1477 
1478  assert(D.getArgumentNumber() == ArgTys.size() && !IsDeferredCheck &&
1479  "Table consistency error");
1480  ArgTys.push_back(Ty);
1481 
1482  switch (D.getArgumentKind()) {
1483  case IITDescriptor::AK_Any: return false; // Success
1485  case IITDescriptor::AK_AnyFloat: return !Ty->isFPOrFPVectorTy();
1486  case IITDescriptor::AK_AnyVector: return !isa<VectorType>(Ty);
1487  case IITDescriptor::AK_AnyPointer: return !isa<PointerType>(Ty);
1488  default: break;
1489  }
1490  llvm_unreachable("all argument kinds not covered");
1491 
1493  // If this is a forward reference, defer the check for later.
1494  if (D.getArgumentNumber() >= ArgTys.size())
1495  return IsDeferredCheck || DeferCheck(Ty);
1496 
1497  Type *NewTy = ArgTys[D.getArgumentNumber()];
1498  if (VectorType *VTy = dyn_cast<VectorType>(NewTy))
1500  else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy))
1501  NewTy = IntegerType::get(ITy->getContext(), 2 * ITy->getBitWidth());
1502  else
1503  return true;
1504 
1505  return Ty != NewTy;
1506  }
1508  // If this is a forward reference, defer the check for later.
1509  if (D.getArgumentNumber() >= ArgTys.size())
1510  return IsDeferredCheck || DeferCheck(Ty);
1511 
1512  Type *NewTy = ArgTys[D.getArgumentNumber()];
1513  if (VectorType *VTy = dyn_cast<VectorType>(NewTy))
1515  else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy))
1516  NewTy = IntegerType::get(ITy->getContext(), ITy->getBitWidth() / 2);
1517  else
1518  return true;
1519 
1520  return Ty != NewTy;
1521  }
1523  // If this is a forward reference, defer the check for later.
1524  if (D.getArgumentNumber() >= ArgTys.size())
1525  return IsDeferredCheck || DeferCheck(Ty);
1526  return !isa<VectorType>(ArgTys[D.getArgumentNumber()]) ||
1528  cast<VectorType>(ArgTys[D.getArgumentNumber()])) != Ty;
1530  if (D.getArgumentNumber() >= ArgTys.size()) {
1531  // Defer check and subsequent check for the vector element type.
1532  Infos = Infos.slice(1);
1533  return IsDeferredCheck || DeferCheck(Ty);
1534  }
1535  auto *ReferenceType = dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
1536  auto *ThisArgType = dyn_cast<VectorType>(Ty);
1537  // Both must be vectors of the same number of elements or neither.
1538  if ((ReferenceType != nullptr) != (ThisArgType != nullptr))
1539  return true;
1540  Type *EltTy = Ty;
1541  if (ThisArgType) {
1542  if (ReferenceType->getElementCount() !=
1543  ThisArgType->getElementCount())
1544  return true;
1545  EltTy = ThisArgType->getElementType();
1546  }
1547  return matchIntrinsicType(EltTy, Infos, ArgTys, DeferredChecks,
1548  IsDeferredCheck);
1549  }
1551  if (D.getArgumentNumber() >= ArgTys.size())
1552  return IsDeferredCheck || DeferCheck(Ty);
1553  Type * ReferenceType = ArgTys[D.getArgumentNumber()];
1554  PointerType *ThisArgType = dyn_cast<PointerType>(Ty);
1555  return (!ThisArgType || ThisArgType->getElementType() != ReferenceType);
1556  }
1557  case IITDescriptor::PtrToElt: {
1558  if (D.getArgumentNumber() >= ArgTys.size())
1559  return IsDeferredCheck || DeferCheck(Ty);
1561  dyn_cast<VectorType> (ArgTys[D.getArgumentNumber()]);
1562  PointerType *ThisArgType = dyn_cast<PointerType>(Ty);
1563 
1564  if (!ThisArgType || !ReferenceType)
1565  return true;
1566  return !ThisArgType->isOpaqueOrPointeeTypeMatches(
1567  ReferenceType->getElementType());
1568  }
1570  unsigned RefArgNumber = D.getRefArgNumber();
1571  if (RefArgNumber >= ArgTys.size()) {
1572  if (IsDeferredCheck)
1573  return true;
1574  // If forward referencing, already add the pointer-vector type and
1575  // defer the checks for later.
1576  ArgTys.push_back(Ty);
1577  return DeferCheck(Ty);
1578  }
1579 
1580  if (!IsDeferredCheck){
1581  assert(D.getOverloadArgNumber() == ArgTys.size() &&
1582  "Table consistency error");
1583  ArgTys.push_back(Ty);
1584  }
1585 
1586  // Verify the overloaded type "matches" the Ref type.
1587  // i.e. Ty is a vector with the same width as Ref.
1588  // Composed of pointers to the same element type as Ref.
1589  auto *ReferenceType = dyn_cast<VectorType>(ArgTys[RefArgNumber]);
1590  auto *ThisArgVecTy = dyn_cast<VectorType>(Ty);
1591  if (!ThisArgVecTy || !ReferenceType ||
1592  (ReferenceType->getElementCount() != ThisArgVecTy->getElementCount()))
1593  return true;
1594  PointerType *ThisArgEltTy =
1595  dyn_cast<PointerType>(ThisArgVecTy->getElementType());
1596  if (!ThisArgEltTy)
1597  return true;
1598  return !ThisArgEltTy->isOpaqueOrPointeeTypeMatches(
1599  ReferenceType->getElementType());
1600  }
1602  if (D.getArgumentNumber() >= ArgTys.size())
1603  return IsDeferredCheck ? true : DeferCheck(Ty);
1604  auto *ReferenceType = dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
1605  return !ReferenceType || Ty != ReferenceType->getElementType();
1606  }
1609  // If this is a forward reference, defer the check for later.
1610  if (D.getArgumentNumber() >= ArgTys.size())
1611  return IsDeferredCheck || DeferCheck(Ty);
1612 
1613  Type *NewTy = ArgTys[D.getArgumentNumber()];
1614  if (auto *VTy = dyn_cast<VectorType>(NewTy)) {
1615  int SubDivs = D.Kind == IITDescriptor::Subdivide2Argument ? 1 : 2;
1616  NewTy = VectorType::getSubdividedVectorType(VTy, SubDivs);
1617  return Ty != NewTy;
1618  }
1619  return true;
1620  }
1622  if (D.getArgumentNumber() >= ArgTys.size())
1623  return IsDeferredCheck || DeferCheck(Ty);
1624  auto *ReferenceType = dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
1625  auto *ThisArgVecTy = dyn_cast<VectorType>(Ty);
1626  if (!ThisArgVecTy || !ReferenceType)
1627  return true;
1628  return ThisArgVecTy != VectorType::getInteger(ReferenceType);
1629  }
1630  }
1631  llvm_unreachable("unhandled");
1632 }
1633 
1637  SmallVectorImpl<Type *> &ArgTys) {
1639  if (matchIntrinsicType(FTy->getReturnType(), Infos, ArgTys, DeferredChecks,
1640  false))
1642 
1643  unsigned NumDeferredReturnChecks = DeferredChecks.size();
1644 
1645  for (auto Ty : FTy->params())
1646  if (matchIntrinsicType(Ty, Infos, ArgTys, DeferredChecks, false))
1648 
1649  for (unsigned I = 0, E = DeferredChecks.size(); I != E; ++I) {
1650  DeferredIntrinsicMatchPair &Check = DeferredChecks[I];
1651  if (matchIntrinsicType(Check.first, Check.second, ArgTys, DeferredChecks,
1652  true))
1653  return I < NumDeferredReturnChecks ? MatchIntrinsicTypes_NoMatchRet
1655  }
1656 
1658 }
1659 
1660 bool
1663  // If there are no descriptors left, then it can't be a vararg.
1664  if (Infos.empty())
1665  return isVarArg;
1666 
1667  // There should be only one descriptor remaining at this point.
1668  if (Infos.size() != 1)
1669  return true;
1670 
1671  // Check and verify the descriptor.
1672  IITDescriptor D = Infos.front();
1673  Infos = Infos.slice(1);
1674  if (D.Kind == IITDescriptor::VarArg)
1675  return !isVarArg;
1676 
1677  return true;
1678 }
1679 
1681  SmallVectorImpl<Type *> &ArgTys) {
1682  Intrinsic::ID ID = F->getIntrinsicID();
1683  if (!ID)
1684  return false;
1685 
1689 
1690  if (Intrinsic::matchIntrinsicSignature(F->getFunctionType(), TableRef,
1691  ArgTys) !=
1693  return false;
1694  }
1695  if (Intrinsic::matchIntrinsicVarArg(F->getFunctionType()->isVarArg(),
1696  TableRef))
1697  return false;
1698  return true;
1699 }
1700 
1702  SmallVector<Type *, 4> ArgTys;
1703  if (!getIntrinsicSignature(F, ArgTys))
1704  return None;
1705 
1706  Intrinsic::ID ID = F->getIntrinsicID();
1707  StringRef Name = F->getName();
1708  std::string WantedName =
1709  Intrinsic::getName(ID, ArgTys, F->getParent(), F->getFunctionType());
1710  if (Name == WantedName)
1711  return None;
1712 
1713  Function *NewDecl = [&] {
1714  if (auto *ExistingGV = F->getParent()->getNamedValue(WantedName)) {
1715  if (auto *ExistingF = dyn_cast<Function>(ExistingGV))
1716  if (ExistingF->getFunctionType() == F->getFunctionType())
1717  return ExistingF;
1718 
1719  // The name already exists, but is not a function or has the wrong
1720  // prototype. Make place for the new one by renaming the old version.
1721  // Either this old version will be removed later on or the module is
1722  // invalid and we'll get an error.
1723  ExistingGV->setName(WantedName + ".renamed");
1724  }
1725  return Intrinsic::getDeclaration(F->getParent(), ID, ArgTys);
1726  }();
1727 
1728  NewDecl->setCallingConv(F->getCallingConv());
1729  assert(NewDecl->getFunctionType() == F->getFunctionType() &&
1730  "Shouldn't change the signature");
1731  return NewDecl;
1732 }
1733 
1734 /// hasAddressTaken - returns true if there are any uses of this function
1735 /// other than direct calls or invokes to it. Optionally ignores callback
1736 /// uses, assume like pointer annotation calls, and references in llvm.used
1737 /// and llvm.compiler.used variables.
1738 bool Function::hasAddressTaken(const User **PutOffender,
1739  bool IgnoreCallbackUses,
1740  bool IgnoreAssumeLikeCalls, bool IgnoreLLVMUsed,
1741  bool IgnoreARCAttachedCall) const {
1742  for (const Use &U : uses()) {
1743  const User *FU = U.getUser();
1744  if (isa<BlockAddress>(FU))
1745  continue;
1746 
1747  if (IgnoreCallbackUses) {
1748  AbstractCallSite ACS(&U);
1749  if (ACS && ACS.isCallbackCall())
1750  continue;
1751  }
1752 
1753  const auto *Call = dyn_cast<CallBase>(FU);
1754  if (!Call) {
1755  if (IgnoreAssumeLikeCalls) {
1756  if (const auto *FI = dyn_cast<Instruction>(FU)) {
1757  if (FI->isCast() && !FI->user_empty() &&
1758  llvm::all_of(FU->users(), [](const User *U) {
1759  if (const auto *I = dyn_cast<IntrinsicInst>(U))
1760  return I->isAssumeLikeIntrinsic();
1761  return false;
1762  }))
1763  continue;
1764  }
1765  }
1766  if (IgnoreLLVMUsed && !FU->user_empty()) {
1767  const User *FUU = FU;
1768  if (isa<BitCastOperator>(FU) && FU->hasOneUse() &&
1769  !FU->user_begin()->user_empty())
1770  FUU = *FU->user_begin();
1771  if (llvm::all_of(FUU->users(), [](const User *U) {
1772  if (const auto *GV = dyn_cast<GlobalVariable>(U))
1773  return GV->hasName() &&
1774  (GV->getName().equals("llvm.compiler.used") ||
1775  GV->getName().equals("llvm.used"));
1776  return false;
1777  }))
1778  continue;
1779  }
1780  if (PutOffender)
1781  *PutOffender = FU;
1782  return true;
1783  }
1784  if (!Call->isCallee(&U)) {
1785  if (IgnoreARCAttachedCall &&
1786  Call->isOperandBundleOfType(LLVMContext::OB_clang_arc_attachedcall,
1787  U.getOperandNo()))
1788  continue;
1789 
1790  if (PutOffender)
1791  *PutOffender = FU;
1792  return true;
1793  }
1794  }
1795  return false;
1796 }
1797 
1799  // Check the linkage
1800  if (!hasLinkOnceLinkage() && !hasLocalLinkage() &&
1802  return false;
1803 
1804  // Check if the function is used by anything other than a blockaddress.
1805  for (const User *U : users())
1806  if (!isa<BlockAddress>(U))
1807  return false;
1808 
1809  return true;
1810 }
1811 
1812 /// callsFunctionThatReturnsTwice - Return true if the function has a call to
1813 /// setjmp or other function that gcc recognizes as "returning twice".
1815  for (const Instruction &I : instructions(this))
1816  if (const auto *Call = dyn_cast<CallBase>(&I))
1817  if (Call->hasFnAttr(Attribute::ReturnsTwice))
1818  return true;
1819 
1820  return false;
1821 }
1822 
1825  return cast<Constant>(Op<0>());
1826 }
1827 
1829  setHungoffOperand<0>(Fn);
1830  setValueSubclassDataBit(3, Fn != nullptr);
1831 }
1832 
1835  return cast<Constant>(Op<1>());
1836 }
1837 
1839  setHungoffOperand<1>(PrefixData);
1840  setValueSubclassDataBit(1, PrefixData != nullptr);
1841 }
1842 
1845  return cast<Constant>(Op<2>());
1846 }
1847 
1849  setHungoffOperand<2>(PrologueData);
1850  setValueSubclassDataBit(2, PrologueData != nullptr);
1851 }
1852 
1853 void Function::allocHungoffUselist() {
1854  // If we've already allocated a uselist, stop here.
1855  if (getNumOperands())
1856  return;
1857 
1858  allocHungoffUses(3, /*IsPhi=*/ false);
1860 
1861  // Initialize the uselist with placeholder operands to allow traversal.
1863  Op<0>().set(CPN);
1864  Op<1>().set(CPN);
1865  Op<2>().set(CPN);
1866 }
1867 
1868 template <int Idx>
1869 void Function::setHungoffOperand(Constant *C) {
1870  if (C) {
1871  allocHungoffUselist();
1872  Op<Idx>().set(C);
1873  } else if (getNumOperands()) {
1874  Op<Idx>().set(
1876  }
1877 }
1878 
1879 void Function::setValueSubclassDataBit(unsigned Bit, bool On) {
1880  assert(Bit < 16 && "SubclassData contains only 16 bits");
1881  if (On)
1882  setValueSubclassData(getSubclassDataFromValue() | (1 << Bit));
1883  else
1884  setValueSubclassData(getSubclassDataFromValue() & ~(1 << Bit));
1885 }
1886 
1888  const DenseSet<GlobalValue::GUID> *S) {
1889  assert(Count.hasValue());
1890 #if !defined(NDEBUG)
1891  auto PrevCount = getEntryCount();
1892  assert(!PrevCount.hasValue() || PrevCount.getType() == Count.getType());
1893 #endif
1894 
1895  auto ImportGUIDs = getImportGUIDs();
1896  if (S == nullptr && ImportGUIDs.size())
1897  S = &ImportGUIDs;
1898 
1899  MDBuilder MDB(getContext());
1900  setMetadata(
1901  LLVMContext::MD_prof,
1902  MDB.createFunctionEntryCount(Count.getCount(), Count.isSynthetic(), S));
1903 }
1904 
1906  const DenseSet<GlobalValue::GUID> *Imports) {
1907  setEntryCount(ProfileCount(Count, Type), Imports);
1908 }
1909 
1910 ProfileCount Function::getEntryCount(bool AllowSynthetic) const {
1911  MDNode *MD = getMetadata(LLVMContext::MD_prof);
1912  if (MD && MD->getOperand(0))
1913  if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0))) {
1914  if (MDS->getString().equals("function_entry_count")) {
1915  ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
1916  uint64_t Count = CI->getValue().getZExtValue();
1917  // A value of -1 is used for SamplePGO when there were no samples.
1918  // Treat this the same as unknown.
1919  if (Count == (uint64_t)-1)
1920  return ProfileCount::getInvalid();
1921  return ProfileCount(Count, PCT_Real);
1922  } else if (AllowSynthetic &&
1923  MDS->getString().equals("synthetic_function_entry_count")) {
1924  ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
1925  uint64_t Count = CI->getValue().getZExtValue();
1926  return ProfileCount(Count, PCT_Synthetic);
1927  }
1928  }
1929  return ProfileCount::getInvalid();
1930 }
1931 
1934  if (MDNode *MD = getMetadata(LLVMContext::MD_prof))
1935  if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0)))
1936  if (MDS->getString().equals("function_entry_count"))
1937  for (unsigned i = 2; i < MD->getNumOperands(); i++)
1938  R.insert(mdconst::extract<ConstantInt>(MD->getOperand(i))
1939  ->getValue()
1940  .getZExtValue());
1941  return R;
1942 }
1943 
1945  MDBuilder MDB(getContext());
1946  setMetadata(LLVMContext::MD_section_prefix,
1948 }
1949 
1951  if (MDNode *MD = getMetadata(LLVMContext::MD_section_prefix)) {
1952  assert(cast<MDString>(MD->getOperand(0))
1953  ->getString()
1954  .equals("function_section_prefix") &&
1955  "Metadata not match");
1956  return cast<MDString>(MD->getOperand(1))->getString();
1957  }
1958  return None;
1959 }
1960 
1962  return hasFnAttribute(Attribute::NullPointerIsValid);
1963 }
1964 
1965 bool llvm::NullPointerIsDefined(const Function *F, unsigned AS) {
1966  if (F && F->nullPointerIsDefined())
1967  return true;
1968 
1969  if (AS != 0)
1970  return true;
1971 
1972  return false;
1973 }
llvm::Function::getParamAttribute
Attribute getParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const
gets the specified attribute from the list of attributes.
Definition: Function.cpp:661
llvm::AttributeList::removeAttributeAtIndex
LLVM_NODISCARD AttributeList removeAttributeAtIndex(LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const
Remove the specified attribute at the specified index from this attribute list.
Definition: Attributes.cpp:1294
llvm::Intrinsic::getBaseName
StringRef getBaseName(ID id)
Return the LLVM name for an intrinsic, without encoded types for overloading, such as "llvm....
Definition: Function.cpp:874
llvm::AttributeList::removeRetAttribute
LLVM_NODISCARD AttributeList removeRetAttribute(LLVMContext &C, Attribute::AttrKind Kind) const
Remove the specified attribute at the return value index from this attribute list.
Definition: Attributes.h:614
i
i
Definition: README.txt:29
llvm::Intrinsic::IITDescriptor::AK_AnyVector
@ AK_AnyVector
Definition: Intrinsics.h:159
llvm::Intrinsic::IITDescriptor::Subdivide4Argument
@ Subdivide4Argument
Definition: Intrinsics.h:141
IIT_STRUCT2
@ IIT_STRUCT2
Definition: Function.cpp:952
llvm::Argument
This class represents an incoming formal argument to a Function.
Definition: Argument.h:29
IIT_AMX
@ IIT_AMX
Definition: Function.cpp:982
llvm::Intrinsic::remangleIntrinsicFunction
llvm::Optional< Function * > remangleIntrinsicFunction(Function *F)
Definition: Function.cpp:1701
llvm::Argument::hasStructRetAttr
bool hasStructRetAttr() const
Return true if this argument has the sret attribute.
Definition: Function.cpp:258
llvm::StringRef::startswith
LLVM_NODISCARD bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:286
IIT_SUBDIVIDE4_ARG
@ IIT_SUBDIVIDE4_ARG
Definition: Function.cpp:976
llvm::Type::FloatTyID
@ FloatTyID
32-bit floating point type
Definition: Type.h:58
Attrs
Function Attrs
Definition: README_ALTIVEC.txt:215
IIT_V128
@ IIT_V128
Definition: Function.cpp:978
IIT_F32
@ IIT_F32
Definition: Function.cpp:936
llvm::Intrinsic::isOverloaded
bool isOverloaded(ID id)
Returns true if the intrinsic can be overloaded.
Definition: Function.cpp:1356
getName
static StringRef getName(Value *V)
Definition: ProvenanceAnalysisEvaluator.cpp:42
llvm::VectorType::getSubdividedVectorType
static VectorType * getSubdividedVectorType(VectorType *VTy, int NumSubdivs)
Definition: DerivedTypes.h:483
llvm::Argument::hasInAllocaAttr
bool hasInAllocaAttr() const
Return true if this argument has the inalloca attribute.
Definition: Function.cpp:129
llvm::Type::DoubleTyID
@ DoubleTyID
64-bit floating point type
Definition: Type.h:59
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::AttributeList::addRetAttributes
LLVM_NODISCARD AttributeList addRetAttributes(LLVMContext &C, const AttrBuilder &B) const
Add a return value attribute to the list.
Definition: Attributes.h:525
llvm::Argument::hasPassPointeeByValueCopyAttr
bool hasPassPointeeByValueCopyAttr() const
Return true if this argument has the byval, inalloca, or preallocated attribute.
Definition: Function.cpp:140
llvm::Intrinsic::MatchIntrinsicTypes_NoMatchArg
@ MatchIntrinsicTypes_NoMatchArg
Definition: Intrinsics.h:219
llvm::AttributeList::addDereferenceableParamAttr
LLVM_NODISCARD AttributeList addDereferenceableParamAttr(LLVMContext &C, unsigned ArgNo, uint64_t Bytes) const
Add the dereferenceable attribute to the attribute set at the given arg index.
Definition: Attributes.cpp:1354
llvm::Intrinsic::IITDescriptor::VecOfBitcastsToInt
@ VecOfBitcastsToInt
Definition: Intrinsics.h:142
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::AArch64CC::AL
@ AL
Definition: AArch64BaseInfo.h:269
llvm::StringRef::empty
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
llvm::AttributeList::addFnAttribute
LLVM_NODISCARD AttributeList addFnAttribute(LLVMContext &C, Attribute::AttrKind Kind) const
Add a function attribute to the list.
Definition: Attributes.h:483
IIT_EXTEND_ARG
@ IIT_EXTEND_ARG
Definition: Function.cpp:956
llvm::StructType::get
static StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
Definition: Type.cpp:370
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:112
llvm::Value::hasOneUse
bool hasOneUse() const
Return true if there is exactly one use of this value.
Definition: Value.h:435
llvm::Intrinsic::IITDescriptor::Kind
enum llvm::Intrinsic::IITDescriptor::IITDescriptorKind Kind
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::Type::isX86_MMXTy
bool isX86_MMXTy() const
Return true if this is X86 MMX.
Definition: Type.h:183
llvm::Function::setSectionPrefix
void setSectionPrefix(StringRef Prefix)
Set the section prefix for this function.
Definition: Function.cpp:1944
llvm::Function::clearGC
void clearGC()
Definition: Function.cpp:697
llvm::Type::getFP128Ty
static Type * getFP128Ty(LLVMContext &C)
Definition: Type.cpp:195
IntrinsicInst.h
llvm::Function::getPrefixData
Constant * getPrefixData() const
Get the prefix data associated with this function.
Definition: Function.cpp:1833
llvm::ElementCount
Definition: TypeSize.h:386
llvm::Intrinsic::IITDescriptor::BFloat
@ BFloat
Definition: Intrinsics.h:123
llvm::APFloatBase::IEEEsingle
static const fltSemantics & IEEEsingle() LLVM_READNONE
Definition: APFloat.cpp:170
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:164
InstIterator.h
ReferenceType
Definition: ItaniumDemangle.h:645
llvm::PointerType::getElementType
Type * getElementType() const
Definition: DerivedTypes.h:673
llvm::Function
Definition: Function.h:61
llvm::Attribute
Definition: Attributes.h:52
llvm::Type::VoidTyID
@ VoidTyID
type with no size
Definition: Type.h:63
StringRef.h
llvm::Value::getSubclassDataFromValue
unsigned short getSubclassDataFromValue() const
Definition: Value.h:841
llvm::Argument::getParamAlignment
unsigned getParamAlignment() const
If this is a byval or inalloca argument, return its alignment.
Definition: Function.cpp:192
DecodeFixedType
static Type * DecodeFixedType(ArrayRef< Intrinsic::IITDescriptor > &Infos, ArrayRef< Type * > Tys, LLVMContext &Context)
Definition: Function.cpp:1234
llvm::Function::getParamDereferenceableBytes
uint64_t getParamDereferenceableBytes(unsigned ArgNo) const
Extract the number of dereferenceable bytes for a parameter.
Definition: Function.h:488
llvm::Intrinsic::IITDescriptor::VarArg
@ VarArg
Definition: Intrinsics.h:118
llvm::PointerType::get
static PointerType * get(Type *ElementType, unsigned AddressSpace)
This constructs a pointer to an object of the specified type in a numbered address space.
Definition: Type.cpp:691
llvm::Target
Target - Wrapper for Target specific information.
Definition: TargetRegistry.h:137
llvm::Argument::removeAttrs
void removeAttrs(const AttrBuilder &B)
Definition: Function.cpp:303
llvm::Function::eraseFromParent
void eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing module and deletes it.
Definition: Function.cpp:365
llvm::ConstantInt::getValue
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:133
llvm::Argument::hasPointeeInMemoryValueAttr
bool hasPointeeInMemoryValueAttr() const
Return true if this argument has the byval, sret, inalloca, preallocated, or byref attribute.
Definition: Function.cpp:148
llvm::SmallVector< unsigned char, 8 >
llvm::Intrinsic::IITDescriptor::Quad
@ Quad
Definition: Intrinsics.h:126
llvm::AttributeList::addParamAttribute
LLVM_NODISCARD AttributeList addParamAttribute(LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const
Add an argument attribute to the list.
Definition: Attributes.h:532
llvm::Function::getParamByValType
Type * getParamByValType(unsigned ArgNo) const
Extract the byval type for a parameter.
Definition: Function.h:462
llvm::User::dropAllReferences
void dropAllReferences()
Drop all references to operands.
Definition: User.h:299
llvm::Function::hasParamAttribute
bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const
check if an attributes is in the list of attributes.
Definition: Function.cpp:638
ErrorHandling.h
makeArgArray
static MutableArrayRef< Argument > makeArgArray(Argument *Args, size_t Count)
Definition: Function.cpp:440
llvm::Intrinsic::getName
StringRef getName(ID id)
Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
Definition: Function.cpp:879
llvm::Intrinsic::IITDescriptor::MMX
@ MMX
Definition: Intrinsics.h:119
llvm::PointerType::getAddressSpace
unsigned getAddressSpace() const
Return the address space of the Pointer type.
Definition: DerivedTypes.h:687
llvm::Type::X86_AMXTyID
@ X86_AMXTyID
AMX vectors (8192 bits, X86 specific)
Definition: Type.h:67
llvm::FunctionType::get
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:325
IIT_I1
@ IIT_I1
Definition: Function.cpp:930
llvm::Type::getTypeID
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:135
llvm::Argument::getParamInAllocaType
Type * getParamInAllocaType() const
If this is an inalloca argument, return its type.
Definition: Function.cpp:221
IIT_V8
@ IIT_V8
Definition: Function.cpp:940
llvm::Type::isFPOrFPVectorTy
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
Definition: Type.h:189
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:143
llvm::Intrinsic::IITDescriptor::Metadata
@ Metadata
Definition: Intrinsics.h:121
llvm::Intrinsic::IITDescriptor::PtrToArgument
@ PtrToArgument
Definition: Intrinsics.h:136
llvm::Function::getContext
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
Definition: Function.cpp:321
llvm::Function::arg_size
size_t arg_size() const
Definition: Function.h:781
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::Function::addRetAttr
void addRetAttr(Attribute::AttrKind Kind)
Add return value attributes to this function.
Definition: Function.cpp:552
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::AttributeList
Definition: Attributes.h:398
llvm::Type::getTokenTy
static Type * getTokenTy(LLVMContext &C)
Definition: Type.cpp:193
llvm::Argument::getArgNo
unsigned getArgNo() const
Return the index of this formal argument in its containing function.
Definition: Argument.h:47
llvm::Argument::hasInRegAttr
bool hasInRegAttr() const
Return true if this argument has the inreg attribute.
Definition: Function.cpp:263
llvm::Function::addParamAttrs
void addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs)
adds the attributes to the list of attributes for the given arg.
Definition: Function.cpp:572
llvm::AMDGPU::Exp::Target
Target
Definition: SIDefines.h:739
llvm::Optional
Definition: APInt.h:33
llvm::Argument::getParent
const Function * getParent() const
Definition: Argument.h:41
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::Intrinsic::getAttributes
AttributeList getAttributes(LLVMContext &C, ID id)
Return the attributes for an intrinsic.
Operator.h
llvm::VectorType::getElementType
Type * getElementType() const
Definition: DerivedTypes.h:422
llvm::Value::user_begin
user_iterator user_begin()
Definition: Value.h:398
llvm::Intrinsic::IITDescriptor::ExtendArgument
@ ExtendArgument
Definition: Intrinsics.h:132
getBitWidth
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type.
Definition: ValueTracking.cpp:89
llvm::Function::hasStackProtectorFnAttr
bool hasStackProtectorFnAttr() const
Returns true if the function has ssp, sspstrong, or sspreq fn attrs.
Definition: Function.cpp:704
llvm::FunctionType::getNumParams
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Definition: DerivedTypes.h:139
llvm::Function::ProfileCount::isSynthetic
bool isSynthetic() const
Definition: Function.h:267
llvm::Function::hasRetAttribute
bool hasRetAttribute(Attribute::AttrKind Kind) const
check if an attribute is in the list of attributes for the return value.
Definition: Function.cpp:634
llvm::Intrinsic::not_intrinsic
@ not_intrinsic
Definition: Intrinsics.h:45
llvm::Intrinsic::IITDescriptor::Pointer
@ Pointer
Definition: Intrinsics.h:129
STLExtras.h
llvm::AbstractCallSite
AbstractCallSite.
Definition: AbstractCallSite.h:50
llvm::Intrinsic::IITDescriptor::AK_Any
@ AK_Any
Definition: Intrinsics.h:156
llvm::Function::isDefTriviallyDead
bool isDefTriviallyDead() const
isDefTriviallyDead - Return true if it is trivially safe to remove this function definition from the ...
Definition: Function.cpp:1798
llvm::GlobalValue::LinkageTypes
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:47
llvm::ArrayType
Class to represent array types.
Definition: DerivedTypes.h:357
IIT_V1
@ IIT_V1
Definition: Function.cpp:959
llvm::Argument::hasSwiftSelfAttr
bool hasSwiftSelfAttr() const
Return true if this argument has the swiftself attribute.
Definition: Function.cpp:121
llvm::LLVMContext::OB_clang_arc_attachedcall
@ OB_clang_arc_attachedcall
Definition: LLVMContext.h:96
llvm::Intrinsic::IITDescriptor::Void
@ Void
Definition: Intrinsics.h:117
IIT_METADATA
@ IIT_METADATA
Definition: Function.cpp:950
llvm::Type::isMetadataTy
bool isMetadataTy() const
Return true if this is 'metadata'.
Definition: Type.h:195
Use.h
llvm::Intrinsic::IITDescriptor::AK_MatchType
@ AK_MatchType
Definition: Intrinsics.h:161
llvm::Intrinsic::getIntrinsicSignature
bool getIntrinsicSignature(Function *F, SmallVectorImpl< Type * > &ArgTys)
Gets the type arguments of an intrinsic call by matching type contraints specified by the ....
Definition: Function.cpp:1680
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:160
llvm::ArrayRef::data
const T * data() const
Definition: ArrayRef.h:162
llvm::Function::addAttributeAtIndex
void addAttributeAtIndex(unsigned i, Attribute Attr)
adds the attribute to the list of attributes.
Definition: Function.cpp:532
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::Intrinsic::IITDescriptor::Float
@ Float
Definition: Intrinsics.h:124
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::Function::addFnAttrs
void addFnAttrs(const AttrBuilder &Attrs)
Add function attributes to this function.
Definition: Function.cpp:548
llvm::Intrinsic::MatchIntrinsicTypes_NoMatchRet
@ MatchIntrinsicTypes_NoMatchRet
Definition: Intrinsics.h:218
llvm::parseDenormalFPAttribute
DenormalMode parseDenormalFPAttribute(StringRef Str)
Returns the denormal mode to use for inputs and outputs.
Definition: FloatingPointMode.h:174
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
llvm::Intrinsic::IITDescriptor::AK_AnyPointer
@ AK_AnyPointer
Definition: Intrinsics.h:160
llvm::Function::setGC
void setGC(std::string Str)
Definition: Function.cpp:692
Instruction.h
CommandLine.h
llvm::ConstantInt
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
llvm::PointerType::isOpaqueOrPointeeTypeMatches
bool isOpaqueOrPointeeTypeMatches(Type *Ty)
Return true if either this is an opaque pointer type or if this pointee type matches Ty.
Definition: DerivedTypes.h:693
llvm::Type::getMetadataTy
static Type * getMetadataTy(LLVMContext &C)
Definition: Type.cpp:192
llvm::Intrinsic::getType
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Return the function type for an intrinsic.
Definition: Function.cpp:1335
llvm::all_of
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1547
llvm::Type::MetadataTyID
@ MetadataTyID
Metadata.
Definition: Type.h:65
llvm::VectorType::getTruncatedElementVectorType
static VectorType * getTruncatedElementVectorType(VectorType *VTy)
Definition: DerivedTypes.h:458
llvm::Type::getX86_AMXTy
static Type * getX86_AMXTy(LLVMContext &C)
Definition: Type.cpp:198
GlobalValue.h
llvm::OperandTraits
Compile-time customization of User operands.
Definition: User.h:42
getMemoryParamAllocType
static Type * getMemoryParamAllocType(AttributeSet ParamAttrs)
For a byval, sret, inalloca, or preallocated parameter, get the in-memory parameter type.
Definition: Function.cpp:161
llvm::Function::PCT_Synthetic
@ PCT_Synthetic
Definition: Function.h:249
llvm::GlobalValue::isDeclaration
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:228
llvm::MutableArrayRef
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:307
llvm::Argument::hasZExtAttr
bool hasZExtAttr() const
Return true if this argument has the zext attribute.
Definition: Function.cpp:271
llvm::Argument::getParamStackAlign
MaybeAlign getParamStackAlign() const
Definition: Function.cpp:202
Constants.h
llvm::Function::stealArgumentListFrom
void stealArgumentListFrom(Function &Src)
Steal arguments from another function.
Definition: Function.cpp:465
IIT_BF16
@ IIT_BF16
Definition: Function.cpp:979
IIT_VEC_OF_BITCASTS_TO_INT
@ IIT_VEC_OF_BITCASTS_TO_INT
Definition: Function.cpp:977
SmallString.h
llvm::Intrinsic::IITDescriptor::Double
@ Double
Definition: Intrinsics.h:125
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::User
Definition: User.h:44
llvm::AttributeList::removeParamAttributes
LLVM_NODISCARD AttributeList removeParamAttributes(LLVMContext &C, unsigned ArgNo, const AttrBuilder &AttrsToRemove) const
Remove the specified attribute at the specified arg index from this attribute list.
Definition: Attributes.h:649
llvm::Intrinsic::IITDescriptor::SameVecWidthArgument
@ SameVecWidthArgument
Definition: Intrinsics.h:135
DecodeIITType
static void DecodeIITType(unsigned &NextElt, ArrayRef< unsigned char > Infos, IIT_Info LastInfo, SmallVectorImpl< Intrinsic::IITDescriptor > &OutputTable)
Definition: Function.cpp:985
Intrinsics.h
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::Type::getDoubleTy
static Type * getDoubleTy(LLVMContext &C)
Definition: Type.cpp:191
llvm::AttributeList::removeFnAttributes
LLVM_NODISCARD AttributeList removeFnAttributes(LLVMContext &C, const AttrBuilder &AttrsToRemove) const
Remove the specified attribute at the function index from this attribute list.
Definition: Attributes.h:601
llvm::GlobalObject
Definition: GlobalObject.h:28
llvm::Intrinsic::IITDescriptor::HalfVecArgument
@ HalfVecArgument
Definition: Intrinsics.h:134
llvm::Argument::hasSwiftErrorAttr
bool hasSwiftErrorAttr() const
Return true if this argument has the swifterror attribute.
Definition: Function.cpp:125
IIT_V16
@ IIT_V16
Definition: Function.cpp:941
llvm::VectorType::getInteger
static VectorType * getInteger(VectorType *VTy)
This static method gets a VectorType with the same number of elements as the input type,...
Definition: DerivedTypes.h:440
IIT_Info
IIT_Info
IIT_Info - These are enumerators that describe the entries returned by the getIntrinsicInfoTableEntri...
Definition: Function.cpp:927
llvm::Argument::hasNoCaptureAttr
bool hasNoCaptureAttr() const
Return true if this argument has the nocapture attribute.
Definition: Function.cpp:248
IIT_STRUCT9
@ IIT_STRUCT9
Definition: Function.cpp:980
SymbolTableListTraitsImpl.h
llvm::Value::uses
iterator_range< use_iterator > uses()
Definition: Value.h:377
DenseSet.h
llvm::VectorType::getElementCount
ElementCount getElementCount() const
Return an ElementCount instance to represent the (possibly scalable) number of elements in the vector...
Definition: DerivedTypes.h:627
llvm::Function::removeRetAttr
void removeRetAttr(Attribute::AttrKind Kind)
removes the attribute from the return value list of attributes.
Definition: Function.cpp:596
llvm::MaybeAlign
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:109
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::Function::getFnAttribute
Attribute getFnAttribute(Attribute::AttrKind Kind) const
Return the attribute for the given attribute kind.
Definition: Function.cpp:652
llvm::IntegerType
Class to represent integer types.
Definition: DerivedTypes.h:40
llvm::Argument::getDereferenceableBytes
uint64_t getDereferenceableBytes() const
If this argument has the dereferenceable attribute, return the number of bytes known to be dereferenc...
Definition: Function.cpp:226
IIT_Done
@ IIT_Done
Definition: Function.cpp:929
llvm::Type::isTokenTy
bool isTokenTy() const
Return true if this is 'token'.
Definition: Type.h:198
llvm::Instruction
Definition: Instruction.h:45
llvm::AttributeList::hasFnAttr
bool hasFnAttr(Attribute::AttrKind Kind) const
Return true if the attribute exists for the function.
Definition: Attributes.cpp:1408
llvm::LLVMContext::getGC
const std::string & getGC(const Function &Fn)
Return the GC for a function.
Definition: LLVMContext.cpp:308
MDBuilder.h
llvm::APInt::getZExtValue
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1453
llvm::Function::copyAttributesFrom
void copyAttributesFrom(const Function *Src)
copyAttributesFrom - copy all additional attributes (those not needed to create a Function) from the ...
Definition: Function.cpp:712
llvm::Function::removeParamAttr
void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
removes the attribute from the list of attributes.
Definition: Function.cpp:608
llvm::Value::setName
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:364
llvm::Function::hasPersonalityFn
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:785
llvm::AttributeSet::getInAllocaType
Type * getInAllocaType() const
Definition: Attributes.cpp:707
llvm::FunctionType::params
ArrayRef< Type * > params() const
Definition: DerivedTypes.h:130
llvm::Argument::getAttribute
Attribute getAttribute(Attribute::AttrKind Kind) const
Definition: Function.cpp:313
IIT_V1024
@ IIT_V1024
Definition: Function.cpp:968
IIT_V64
@ IIT_V64
Definition: Function.cpp:947
llvm::Function::PCT_Real
@ PCT_Real
Definition: Function.h:249
Info
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
llvm::Argument::hasNestAttr
bool hasNestAttr() const
Return true if this argument has the nest attribute.
Definition: Function.cpp:238
llvm::AttributeList::removeParamAttribute
LLVM_NODISCARD AttributeList removeParamAttribute(LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const
Remove the specified attribute at the specified arg index from this attribute list.
Definition: Attributes.h:634
llvm::AttributeList::addDereferenceableOrNullParamAttr
LLVM_NODISCARD AttributeList addDereferenceableOrNullParamAttr(LLVMContext &C, unsigned ArgNo, uint64_t Bytes) const
Add the dereferenceable_or_null attribute to the attribute set at the given arg index.
Definition: Attributes.cpp:1363
llvm::Type::getInt1PtrTy
static PointerType * getInt1PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:251
llvm::Function::getSectionPrefix
Optional< StringRef > getSectionPrefix() const
Get the section prefix for this function.
Definition: Function.cpp:1950
llvm::PointerType::isOpaque
bool isOpaque() const
Definition: DerivedTypes.h:678
getMangledTypeStr
static std::string getMangledTypeStr(Type *Ty, bool &HasUnnamedType)
Returns a stable mangling for the type specified for use in the name mangling scheme used by 'any' ty...
Definition: Function.cpp:813
llvm::Type::BFloatTyID
@ BFloatTyID
16-bit floating point type (7-bit significand)
Definition: Type.h:57
llvm::ArrayRef::slice
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array.
Definition: ArrayRef.h:195
llvm::Attribute::getValueAsString
StringRef getValueAsString() const
Return the attribute's value as a string.
Definition: Attributes.cpp:301
llvm::None
const NoneType None
Definition: None.h:23
llvm::GlobalValue::IntID
Intrinsic::ID IntID
The intrinsic ID for this subclass (which must be a Function).
Definition: GlobalValue.h:156
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
llvm::Function::getParamInAllocaType
Type * getParamInAllocaType(unsigned ArgNo) const
Extract the inalloca type for a parameter.
Definition: Function.h:472
Type.h
llvm::Argument::hasByRefAttr
bool hasByRefAttr() const
Return true if this argument has the byref attribute.
Definition: Function.cpp:115
llvm::Function::hasPrologueData
bool hasPrologueData() const
Check whether this function has prologue data.
Definition: Function.h:803
llvm::SmallString< 128 >
llvm::Intrinsic::IITDescriptor::TruncArgument
@ TruncArgument
Definition: Intrinsics.h:133
ValueSymbolTable.h
llvm::AttributeList::addFnAttributes
LLVM_NODISCARD AttributeList addFnAttributes(LLVMContext &C, const AttrBuilder &B) const
Add function attribute to the list.
Definition: Attributes.h:504
llvm::Function::getAttributes
AttributeList getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:326
llvm::Argument::getDereferenceableOrNullBytes
uint64_t getDereferenceableOrNullBytes() const
If this argument has the dereferenceable_or_null attribute, return the number of bytes known to be de...
Definition: Function.cpp:232
llvm::Argument::getParamStructRetType
Type * getParamStructRetType() const
If this is an sret argument, return its type.
Definition: Function.cpp:211
llvm::Function::getGC
const std::string & getGC() const
Definition: Function.cpp:687
llvm::Type::isIntegerTy
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:201
llvm::MDNode::getOperand
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1107
llvm::Intrinsic::MatchIntrinsicTypes_Match
@ MatchIntrinsicTypes_Match
Definition: Intrinsics.h:217
llvm::Argument::hasAttribute
bool hasAttribute(Attribute::AttrKind Kind) const
Check if an argument has a given attribute.
Definition: Function.cpp:309
llvm::VectorType
Base class of all SIMD vector types.
Definition: DerivedTypes.h:389
getIntrinsicNameImpl
static std::string getIntrinsicNameImpl(Intrinsic::ID Id, ArrayRef< Type * > Tys, Module *M, FunctionType *FT, bool EarlyModuleCheck)
Definition: Function.cpp:886
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
Check
static bool Check(DecodeStatus &Out, DecodeStatus In)
Definition: AArch64Disassembler.cpp:242
IIT_F128
@ IIT_F128
Definition: Function.cpp:972
llvm::AttributeList::removeRetAttributes
LLVM_NODISCARD AttributeList removeRetAttributes(LLVMContext &C, const AttrBuilder &AttrsToRemove) const
Remove the specified attribute at the return value index from this attribute list.
Definition: Attributes.h:628
llvm::Intrinsic::IITDescriptor::get
static IITDescriptor get(IITDescriptorKind K, unsigned Field)
Definition: Intrinsics.h:193
llvm::Function::hasFnAttribute
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.cpp:626
BasicBlock.h
llvm::cl::opt
Definition: CommandLine.h:1434
llvm::GlobalValue::hasAvailableExternallyLinkage
bool hasAvailableExternallyLinkage() const
Definition: GlobalValue.h:432
llvm::ProfileCount
Function::ProfileCount ProfileCount
Definition: SampleProfileLoaderBaseImpl.h:46
llvm::instructions
inst_range instructions(Function *F)
Definition: InstIterator.h:133
llvm::Function::getAttributeAtIndex
Attribute getAttributeAtIndex(unsigned i, Attribute::AttrKind Kind) const
gets the attribute from the list of attributes.
Definition: Function.cpp:643
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::PointerType::getUnqual
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the default address space (address sp...
Definition: DerivedTypes.h:651
llvm::SymbolTableListTraits
Definition: GlobalAlias.h:25
uint64_t
llvm::Intrinsic::matchIntrinsicVarArg
bool matchIntrinsicVarArg(bool isVarArg, ArrayRef< IITDescriptor > &Infos)
Verify if the intrinsic has variable arguments.
Definition: Function.cpp:1661
llvm::Function::hasPrefixData
bool hasPrefixData() const
Check whether this function has prefix data.
Definition: Function.h:794
llvm::Intrinsic::IITDescriptor::Half
@ Half
Definition: Intrinsics.h:122
llvm::Function::dropAllReferences
void dropAllReferences()
dropAllReferences() - This method causes all the subinstructions to "let go" of all references that t...
Definition: Function.cpp:510
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
llvm::User::allocHungoffUses
void allocHungoffUses(unsigned N, bool IsPhi=false)
Allocate the array of Uses, followed by a pointer (with bottom bit set) to the User.
Definition: User.cpp:44
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:572
llvm::Type::X86_MMXTyID
@ X86_MMXTyID
MMX vectors (64 bits, X86 specific)
Definition: Type.h:66
llvm::ARM_MB::ST
@ ST
Definition: ARMBaseInfo.h:73
llvm::AttributeList::addParamAttributes
LLVM_NODISCARD AttributeList addParamAttributes(LLVMContext &C, unsigned ArgNo, const AttrBuilder &B) const
Add an argument attribute to the list.
Definition: Attributes.h:553
llvm::Function::hasGC
bool hasGC() const
hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm to use during code generatio...
Definition: Function.h:318
llvm::ConstantPointerNull::get
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
Definition: Constants.cpp:1757
llvm::Intrinsic::getIntrinsicInfoTableEntries
void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl< IITDescriptor > &T)
Return the IIT table descriptor for the specified intrinsic into an array of IITDescriptors.
Definition: Function.cpp:1201
IIT_F16
@ IIT_F16
Definition: Function.cpp:935
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
ProfileCount
Function::ProfileCount ProfileCount
Definition: Function.cpp:74
llvm::Function::removeParamAttrs
void removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs)
removes the attribute from the list of attributes.
Definition: Function.cpp:616
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
IIT_STRUCT4
@ IIT_STRUCT4
Definition: Function.cpp:954
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::AttrBuilder
Definition: Attributes.h:907
StringExtras.h
IIT_I8
@ IIT_I8
Definition: Function.cpp:931
llvm::Function::addDereferenceableOrNullParamAttr
void addDereferenceableOrNullParamAttr(unsigned ArgNo, uint64_t Bytes)
adds the dereferenceable_or_null attribute to the list of attributes for the given arg.
Definition: Function.cpp:666
llvm::Intrinsic::IITDescriptor::AK_AnyInteger
@ AK_AnyInteger
Definition: Intrinsics.h:157
llvm::DenormalMode
Represent subnormal handling kind for floating point instruction inputs and outputs.
Definition: FloatingPointMode.h:67
llvm::Attribute::AttrKind
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results,...
Definition: Attributes.h:71
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:443
llvm::LLVMContext::setGC
void setGC(const Function &Fn, std::string GCName)
Define the GC for a function.
Definition: LLVMContext.cpp:298
llvm::Argument::hasNoFreeAttr
bool hasNoFreeAttr() const
Return true if this argument has the nofree attribute.
Definition: Function.cpp:253
llvm::Intrinsic::IITDescriptor::VecOfAnyPtrsToElt
@ VecOfAnyPtrsToElt
Definition: Intrinsics.h:138
llvm::PointerType
Class to represent pointers.
Definition: DerivedTypes.h:632
ArrayRef.h
llvm::Argument::hasPreallocatedAttr
bool hasPreallocatedAttr() const
Return true if this argument has the preallocated attribute.
Definition: Function.cpp:134
llvm::Type::isHalfTy
bool isHalfTy() const
Return true if this is 'half', a 16-bit IEEE fp type.
Definition: Type.h:141
llvm::GlobalValue::Linkage
unsigned Linkage
Definition: GlobalValue.h:94
llvm::Intrinsic::isLeaf
bool isLeaf(ID id)
Returns true if the intrinsic is a leaf, i.e.
Definition: Function.cpp:1362
llvm::Argument::removeAttr
void removeAttr(Attribute::AttrKind Kind)
Remove attributes from an argument.
Definition: Function.cpp:299
llvm::Function::Create
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:138
llvm::Function::ProfileCountType
ProfileCountType
Definition: Function.h:249
llvm::FramePointerKind::All
@ All
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::GlobalValue::hasLocalLinkage
bool hasLocalLinkage() const
Definition: GlobalValue.h:445
llvm::Function::lookupIntrinsicID
static Intrinsic::ID lookupIntrinsicID(StringRef Name)
This does the actual lookup of an intrinsic ID which matches the given function name.
Definition: Function.cpp:770
IIT_V4
@ IIT_V4
Definition: Function.cpp:939
llvm::Argument::Argument
Argument(Type *Ty, const Twine &Name="", Function *F=nullptr, unsigned ArgNo=0)
Argument constructor.
Definition: Function.cpp:88
NonGlobalValueMaxNameSize
static cl::opt< unsigned > NonGlobalValueMaxNameSize("non-global-value-max-name-size", cl::Hidden, cl::init(1024), cl::desc("Maximum size for the name of non-global values."))
llvm::Value::user_empty
bool user_empty() const
Definition: Value.h:386
llvm::Type::isVoidTy
bool isVoidTy() const
Return true if this is 'void'.
Definition: Type.h:138
llvm::Function::setPersonalityFn
void setPersonalityFn(Constant *Fn)
Definition: Function.cpp:1828
llvm::Intrinsic::IITDescriptor::AMX
@ AMX
Definition: Intrinsics.h:143
DeferredIntrinsicMatchPair
std::pair< Type *, ArrayRef< Intrinsic::IITDescriptor > > DeferredIntrinsicMatchPair
Definition: Function.cpp:1401
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::MDNode
Metadata node.
Definition: Metadata.h:901
IIT_ARG
@ IIT_ARG
Definition: Function.cpp:944
IIT_V256
@ IIT_V256
Definition: Function.cpp:981
llvm::Value::clearMetadata
void clearMetadata()
Erase all metadata attached to this Value.
Definition: Metadata.cpp:1291
IIT_VARARG
@ IIT_VARARG
Definition: Function.cpp:960
IIT_I16
@ IIT_I16
Definition: Function.cpp:932
llvm::AbstractCallSite::isCallbackCall
bool isCallbackCall() const
Return true if this ACS represents a callback call.
Definition: AbstractCallSite.h:125
llvm::Intrinsic::IITDescriptor::Argument
@ Argument
Definition: Intrinsics.h:131
IIT_PTR_TO_ELT
@ IIT_PTR_TO_ELT
Definition: Function.cpp:964
llvm::Intrinsic::IITDescriptor::Subdivide2Argument
@ Subdivide2Argument
Definition: Intrinsics.h:140
llvm::Type::FP128TyID
@ FP128TyID
128-bit floating point type (112-bit significand)
Definition: Type.h:61
llvm::Function::getIntrinsicID
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:206
llvm::Function::createWithDefaultAttr
static Function * createWithDefaultAttr(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Creates a function with some attributes recorded in llvm.module.flags applied.
Definition: Function.cpp:338
llvm::Function::setEntryCount
void setEntryCount(ProfileCount Count, const DenseSet< GlobalValue::GUID > *Imports=nullptr)
Set the entry count for this function.
Definition: Function.cpp:1887
llvm::ArrayRef< const char * >
None.h
llvm::any_of
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1554
llvm::StructType
Class to represent struct types.
Definition: DerivedTypes.h:213
llvm::Type::PPC_FP128TyID
@ PPC_FP128TyID
128-bit floating point type (two 64-bits, PowerPC)
Definition: Type.h:62
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
this
Analysis the ScalarEvolution expression for r is this
Definition: README.txt:8
llvm::Function::setCallingConv
void setCallingConv(CallingConv::ID CC)
Definition: Function.h:243
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::Function::getEntryCount
ProfileCount getEntryCount(bool AllowSynthetic=false) const
Get the entry count for this function.
Definition: Function.cpp:1910
llvm::Argument::getParamByRefType
Type * getParamByRefType() const
If this is a byref argument, return its type.
Definition: Function.cpp:216
Compiler.h
llvm::Function::getParamAlign
MaybeAlign getParamAlign(unsigned ArgNo) const
Definition: Function.h:453
llvm::ilist_node_impl< ilist_detail::compute_node_options< Function, Options... >::type >::getIterator
self_iterator getIterator()
Definition: ilist_node.h:81
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::Value::getMetadata
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
Definition: Metadata.cpp:1197
llvm::Argument::getPassPointeeByValueCopySize
uint64_t getPassPointeeByValueCopySize(const DataLayout &DL) const
If this argument satisfies has hasPassPointeeByValueAttr, return the in-memory ABI size copied to the...
Definition: Function.cpp:178
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::Function::ProfileCount::getType
ProfileCountType getType() const
Definition: Function.h:266
IIT_STRUCT6
@ IIT_STRUCT6
Definition: Function.cpp:969
llvm::Module::getFunctionList
const FunctionListType & getFunctionList() const
Get the Module's list of functions (constant).
Definition: Module.h:556
llvm::VectorType::getHalfElementsVectorType
static VectorType * getHalfElementsVectorType(VectorType *VTy)
This static method returns a VectorType with half as many elements as the input type and the same ele...
Definition: DerivedTypes.h:493
llvm::Function::hasAddressTaken
bool hasAddressTaken(const User **=nullptr, bool IgnoreCallbackUses=false, bool IgnoreAssumeLikeCalls=true, bool IngoreLLVMUsed=false, bool IgnoreARCAttachedCall=false) const
hasAddressTaken - returns true if there are any uses of this function other than direct calls or invo...
Definition: Function.cpp:1738
llvm::Function::callsFunctionThatReturnsTwice
bool callsFunctionThatReturnsTwice() const
callsFunctionThatReturnsTwice - Return true if the function has a call to setjmp or other function th...
Definition: Function.cpp:1814
llvm::Value::setMetadata
void setMetadata(unsigned KindID, MDNode *Node)
Set a particular kind of metadata attachment.
Definition: Metadata.cpp:1234
LLVM_FALLTHROUGH
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:273
llvm::Intrinsic::IITDescriptor::PtrToElt
@ PtrToElt
Definition: Intrinsics.h:137
llvm::Value::getName
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:297
llvm::Type::getContext
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:127
IIT_ANYPTR
@ IIT_ANYPTR
Definition: Function.cpp:958
findTargetSubtable
static ArrayRef< const char * > findTargetSubtable(StringRef Name)
Find the segment of IntrinsicNameTable for intrinsics with the same target as Name,...
Definition: Function.cpp:753
llvm::Function::setIsMaterializable
void setIsMaterializable(bool V)
Definition: Function.h:194
llvm::ArrayRef::front
const T & front() const
front - Get the first element.
Definition: ArrayRef.h:168
llvm::Intrinsic::IITDescriptor::VecElementArgument
@ VecElementArgument
Definition: Intrinsics.h:139
llvm::Function::getDenormalMode
DenormalMode getDenormalMode(const fltSemantics &FPType) const
Returns the denormal handling type for the default rounding mode of the function.
Definition: Function.cpp:672
llvm::Function::ProfileCount::getCount
uint64_t getCount() const
Definition: Function.h:265
IIT_I32
@ IIT_I32
Definition: Function.cpp:933
llvm::MDBuilder::createFunctionSectionPrefix
MDNode * createFunctionSectionPrefix(StringRef Prefix)
Return metadata containing the section prefix for a function.
Definition: MDBuilder.cpp:78
Argument.h
llvm::Intrinsic::IITDescriptor::AK_AnyFloat
@ AK_AnyFloat
Definition: Intrinsics.h:158
llvm::Function::removeFnAttrs
void removeFnAttrs(const AttrBuilder &Attrs)
Definition: Function.cpp:592
IIT_STRUCT7
@ IIT_STRUCT7
Definition: Function.cpp:970
llvm::Type::IntegerTyID
@ IntegerTyID
Arbitrary bit width integers.
Definition: Type.h:71
llvm::Argument::addAttrs
void addAttrs(AttrBuilder &B)
Add attributes to an argument.
Definition: Function.cpp:285
llvm::VectorType::getExtendedElementVectorType
static VectorType * getExtendedElementVectorType(VectorType *VTy)
This static method is like getInteger except that the element types are twice as wide as the elements...
Definition: DerivedTypes.h:449
Attributes.h
llvm::Function::hasLazyArguments
bool hasLazyArguments() const
hasLazyArguments/CheckLazyArguments - The argument list of a function is built on demand,...
Definition: Function.h:107
name
static const char * name
Definition: SVEIntrinsicOpts.cpp:78
llvm::partition_point
auto partition_point(R &&Range, Predicate P)
Binary search for the first iterator in a range where a predicate is false.
Definition: STLExtras.h:1695
IIT_SUBDIVIDE2_ARG
@ IIT_SUBDIVIDE2_ARG
Definition: Function.cpp:975
llvm::Function::addParamAttr
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
adds the attribute to the list of attributes for the given arg.
Definition: Function.cpp:564
Constant.h
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
IIT_VEC_OF_ANYPTRS_TO_ELT
@ IIT_VEC_OF_ANYPTRS_TO_ELT
Definition: Function.cpp:965
llvm::AttributeSet::getPreallocatedType
Type * getPreallocatedType() const
Definition: Attributes.cpp:703
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::Function::removeAttributeAtIndex
void removeAttributeAtIndex(unsigned i, Attribute::AttrKind Kind)
removes the attribute from the list of attributes.
Definition: Function.cpp:576
llvm::Type::isFloatTy
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
Definition: Type.h:147
llvm::AttributeSet::getByRefType
Type * getByRefType() const
Definition: Attributes.cpp:691
llvm::Type::getHalfTy
static Type * getHalfTy(LLVMContext &C)
Definition: Type.cpp:188
IIT_HALF_VEC_ARG
@ IIT_HALF_VEC_ARG
Definition: Function.cpp:961
llvm::AttributeSet::getByValType
Type * getByValType() const
Definition: Attributes.cpp:695
llvm::Type::isIntOrIntVectorTy
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
Definition: Type.h:207
llvm::Function::getParamDereferenceableOrNullBytes
uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const
Extract the number of dereferenceable_or_null bytes for a parameter.
Definition: Function.h:495
llvm::Argument::hasNonNullAttr
bool hasNonNullAttr(bool AllowUndefOrPoison=true) const
Return true if this argument has the nonnull attribute.
Definition: Function.cpp:97
Casting.h
llvm::Argument::hasByValAttr
bool hasByValAttr() const
Return true if this argument has the byval attribute.
Definition: Function.cpp:110
IIT_I64
@ IIT_I64
Definition: Function.cpp:934
llvm::fltSemantics
Definition: APFloat.cpp:54
llvm::Argument::getParamByValType
Type * getParamByValType() const
If this is a byval argument, return its type.
Definition: Function.cpp:206
Function.h
IIT_TRUNC_ARG
@ IIT_TRUNC_ARG
Definition: Function.cpp:957
llvm::FramePointerKind::NonLeaf
@ NonLeaf
IIT_I128
@ IIT_I128
Definition: Function.cpp:966
llvm::Function::addDereferenceableParamAttr
void addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes)
adds the dereferenceable attribute to the list of attributes for the given arg.
Definition: Function.cpp:621
IIT_PTR
@ IIT_PTR
Definition: Function.cpp:943
IntrinsicNameTable
static const char *const IntrinsicNameTable[]
Table of string intrinsic names indexed by enum value.
Definition: Function.cpp:729
llvm::Type::isDoubleTy
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
Definition: Type.h:150
llvm::Function::isTargetIntrinsic
bool isTargetIntrinsic() const
isTargetIntrinsic - Returns true if this function is an intrinsic and the intrinsic is specific to a ...
Definition: Function.cpp:745
IIT_MMX
@ IIT_MMX
Definition: Function.cpp:948
llvm::Function::getFunctionType
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:176
llvm::AttributeList::addRetAttribute
LLVM_NODISCARD AttributeList addRetAttribute(LLVMContext &C, Attribute::AttrKind Kind) const
Add a return value attribute to the list.
Definition: Attributes.h:511
llvm::AttributeList::getAttributeAtIndex
Attribute getAttributeAtIndex(unsigned Index, Attribute::AttrKind Kind) const
Return the attribute object that exists at the given index.
Definition: Attributes.cpp:1421
llvm::orc::ReadOnly
static constexpr sys::Memory::ProtectionFlags ReadOnly
Definition: DebugObjectManagerPlugin.cpp:111
llvm::Function::addRetAttrs
void addRetAttrs(const AttrBuilder &Attrs)
Add return value attributes to this function.
Definition: Function.cpp:560
llvm::Function::ProfileCount::getInvalid
static ProfileCount getInvalid()
Definition: Function.h:275
IIT_V32
@ IIT_V32
Definition: Function.cpp:942
llvm::Function::isConstrainedFPIntrinsic
bool isConstrainedFPIntrinsic() const
Returns true if the function is one of the "Constrained Floating-Point Intrinsics".
Definition: Function.cpp:444
llvm::Type::getBFloatTy
static Type * getBFloatTy(LLVMContext &C)
Definition: Type.cpp:189
llvm::Function::getParamStackAlign
MaybeAlign getParamStackAlign(unsigned ArgNo) const
Definition: Function.h:457
llvm::Function::getPersonalityFn
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1823
llvm::Function::getInstructionCount
unsigned getInstructionCount() const
Returns the number of non-debug IR instructions in this function.
Definition: Function.cpp:325
llvm::Intrinsic::getNameNoUnnamedTypes
std::string getNameNoUnnamedTypes(ID Id, ArrayRef< Type * > Tys)
Return the LLVM name for an intrinsic.
Definition: Function.cpp:919
IIT_PTR_TO_ARG
@ IIT_PTR_TO_ARG
Definition: Function.cpp:963
computeAddrSpace
static unsigned computeAddrSpace(unsigned AddrSpace, Module *M)
Definition: Function.cpp:373
llvm::LLVMContext::deleteGC
void deleteGC(const Function &Fn)
Remove the GC for a function.
Definition: LLVMContext.cpp:312
llvm::Function::getParamByRefType
Type * getParamByRefType(unsigned ArgNo) const
Extract the byref type for a parameter.
Definition: Function.h:477
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:476
llvm::MDBuilder
Definition: MDBuilder.h:35
llvm::GlobalValue::HasLLVMReservedName
unsigned HasLLVMReservedName
True if the function's name starts with "llvm.".
Definition: GlobalValue.h:105
llvm::Intrinsic::IITDescriptor::Struct
@ Struct
Definition: Intrinsics.h:130
IIT_EMPTYSTRUCT
@ IIT_EMPTYSTRUCT
Definition: Function.cpp:951
llvm::Type::getVoidTy
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:186
llvm::Function::getParamAlignment
unsigned getParamAlignment(unsigned ArgNo) const
Extract the alignment for a call or parameter (0=unknown).
Definition: Function.h:447
Instructions.h
llvm::Function::nullPointerIsDefined
bool nullPointerIsDefined() const
Check if null pointer dereferencing is considered undefined behavior for the function.
Definition: Function.cpp:1961
llvm::User::getNumOperands
unsigned getNumOperands() const
Definition: User.h:191
llvm::AttributeSet
Definition: Attributes.h:266
llvm::Argument::getPointeeInMemoryValueType
Type * getPointeeInMemoryValueType() const
If hasPointeeInMemoryValueAttr returns true, the in-memory ABI type is returned.
Definition: Function.cpp:186
matchIntrinsicType
static bool matchIntrinsicType(Type *Ty, ArrayRef< Intrinsic::IITDescriptor > &Infos, SmallVectorImpl< Type * > &ArgTys, SmallVectorImpl< DeferredIntrinsicMatchPair > &DeferredChecks, bool IsDeferredCheck)
Definition: Function.cpp:1403
SmallVector.h
llvm::Function::setPrefixData
void setPrefixData(Constant *PrefixData)
Definition: Function.cpp:1838
llvm::Intrinsic::IITDescriptor::Token
@ Token
Definition: Intrinsics.h:120
llvm::Function::removeRetAttrs
void removeRetAttrs(const AttrBuilder &Attrs)
removes the attributes from the return value list of attributes.
Definition: Function.cpp:604
llvm::Type::isBFloatTy
bool isBFloatTy() const
Return true if this is 'bfloat', a 16-bit bfloat type.
Definition: Type.h:144
User.h
llvm::Intrinsic::IITDescriptor::Vector
@ Vector
Definition: Intrinsics.h:128
N
#define N
llvm::AttributeList::hasRetAttr
bool hasRetAttr(Attribute::AttrKind Kind) const
Return true if the attribute exists for the return value.
Definition: Attributes.h:736
llvm::Function::removeFnAttr
void removeFnAttr(Attribute::AttrKind Kind)
Remove function attributes from this function.
Definition: Function.cpp:584
llvm::AttributeList::removeFnAttribute
LLVM_NODISCARD AttributeList removeFnAttribute(LLVMContext &C, Attribute::AttrKind Kind) const
Remove the specified attribute at the function index from this attribute list.
Definition: Attributes.h:587
llvm::Argument::hasNoAliasAttr
bool hasNoAliasAttr() const
Return true if this argument has the noalias attribute.
Definition: Function.cpp:243
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
llvm::IntegerType::getBitWidth
unsigned getBitWidth() const
Get the number of bits in this IntegerType.
Definition: DerivedTypes.h:72
llvm::Intrinsic::matchIntrinsicSignature
MatchIntrinsicTypesResult matchIntrinsicSignature(FunctionType *FTy, ArrayRef< IITDescriptor > &Infos, SmallVectorImpl< Type * > &ArgTys)
Match the specified function type with the type constraints specified by the .td file.
Definition: Function.cpp:1635
llvm::tgtok::Bit
@ Bit
Definition: TGLexer.h:50
llvm::Function::addFnAttr
void addFnAttr(Attribute::AttrKind Kind)
Add function attributes to this function.
Definition: Function.cpp:536
llvm::GlobalObject::copyAttributesFrom
void copyAttributesFrom(const GlobalObject *Src)
Definition: Globals.cpp:127
llvm::Intrinsic::IITDescriptor::getVector
static IITDescriptor getVector(unsigned Width, bool IsScalable)
Definition: Intrinsics.h:205
llvm::Argument::getParamAlign
MaybeAlign getParamAlign() const
If this is a byval or inalloca argument, return its alignment.
Definition: Function.cpp:197
IIT_TOKEN
@ IIT_TOKEN
Definition: Function.cpp:949
llvm::GlobalValue::hasLinkOnceLinkage
bool hasLinkOnceLinkage() const
Definition: GlobalValue.h:435
llvm::Function::removeFromParent
void removeFromParent()
removeFromParent - This method unlinks 'this' from the containing module, but does not delete it.
Definition: Function.cpp:361
llvm::AttributeList::addAttributeAtIndex
LLVM_NODISCARD AttributeList addAttributeAtIndex(LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const
Add an attribute to the attribute set at the given index.
Definition: Attributes.cpp:1213
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:43
llvm::AttributeSet::getStructRetType
Type * getStructRetType() const
Definition: Attributes.cpp:699
llvm::GlobalValue::getType
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:271
DerivedTypes.h
llvm::Function::setPrologueData
void setPrologueData(Constant *PrologueData)
Definition: Function.cpp:1848
llvm::Function::recalculateIntrinsicID
void recalculateIntrinsicID()
Recalculate the ID for this function if it is an Intrinsic defined in llvm/Intrinsics....
Definition: Function.cpp:790
llvm::IntegerType::get
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:275
llvm::Function::getPrologueData
Constant * getPrologueData() const
Get the prologue data associated with this function.
Definition: Function.cpp:1843
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::Intrinsic::IITDescriptor::Integer
@ Integer
Definition: Intrinsics.h:127
LLVMContext.h
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:389
llvm::FramePointerKind::None
@ None
llvm::Function::ProfileCount
Class to represent profile counts.
Definition: Function.h:254
llvm::cl::desc
Definition: CommandLine.h:414
AbstractCallSite.h
llvm::Intrinsic::IITDescriptor
This is a type descriptor which explains the type requirements of an intrinsic.
Definition: Intrinsics.h:115
IIT_V512
@ IIT_V512
Definition: Function.cpp:967
llvm::NullPointerIsDefined
bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
Definition: Function.cpp:1965
llvm::Function::ProfileCount::hasValue
bool hasValue() const
Definition: Function.h:264
llvm::Type::getX86_MMXTy
static Type * getX86_MMXTy(LLVMContext &C)
Definition: Type.cpp:197
llvm::AMDGPU::VGPRIndexMode::Id
Id
Definition: SIDefines.h:228
IIT_SAME_VEC_WIDTH_ARG
@ IIT_SAME_VEC_WIDTH_ARG
Definition: Function.cpp:962
IIT_STRUCT5
@ IIT_STRUCT5
Definition: Function.cpp:955
llvm::AttributeList::hasParamAttr
bool hasParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Return true if the attribute exists for the given argument.
Definition: Attributes.h:721
SymbolTableListTraits.h
llvm::Intrinsic::MatchIntrinsicTypesResult
MatchIntrinsicTypesResult
Definition: Intrinsics.h:216
llvm::AttributeList::getParamAttrs
AttributeSet getParamAttrs(unsigned ArgNo) const
The attributes for the argument or parameter at the given index are returned.
Definition: Attributes.cpp:1383
llvm::Argument::onlyReadsMemory
bool onlyReadsMemory() const
Return true if this argument has the readonly or readnone attribute.
Definition: Function.cpp:279
llvm::MDString
A single uniqued string.
Definition: Metadata.h:611
true
basic Basic Alias true
Definition: BasicAliasAnalysis.cpp:1815
llvm::MDBuilder::createFunctionEntryCount
MDNode * createFunctionEntryCount(uint64_t Count, bool Synthetic, const DenseSet< GlobalValue::GUID > *Imports)
Return metadata containing the entry Count for a function, a boolean \Synthetic indicating whether th...
Definition: MDBuilder.cpp:59
llvm::AttributeList::getFnAttr
Attribute getFnAttr(Attribute::AttrKind Kind) const
Return the attribute object that exists for the function.
Definition: Attributes.h:780
IIT_STRUCT3
@ IIT_STRUCT3
Definition: Function.cpp:953
Value.h
IIT_V2
@ IIT_V2
Definition: Function.cpp:938
TableRef
Definition: AMDGPULibCalls.cpp:399
llvm::Function::getParamStructRetType
Type * getParamStructRetType(unsigned ArgNo) const
Extract the sret type for a parameter.
Definition: Function.h:467
llvm::Function::setAttributes
void setAttributes(AttributeList Attrs)
Set the attribute list for this Function.
Definition: Function.h:329
llvm::Argument::hasSExtAttr
bool hasSExtAttr() const
Return true if this argument has the sext attribute.
Definition: Function.cpp:275
IIT_STRUCT8
@ IIT_STRUCT8
Definition: Function.cpp:971
llvm::FunctionType::getReturnType
Type * getReturnType() const
Definition: DerivedTypes.h:124
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::Type::isFP128Ty
bool isFP128Ty() const
Return true if this is 'fp128'.
Definition: Type.h:156
llvm::User::setNumHungOffUseOperands
void setNumHungOffUseOperands(unsigned NumOps)
Subclasses with hung off uses need to manage the operand count themselves.
Definition: User.h:215
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::Type::HalfTyID
@ HalfTyID
16-bit floating point type
Definition: Type.h:56
llvm::Value::users
iterator_range< user_iterator > users()
Definition: Value.h:422
llvm::Type::X86_FP80TyID
@ X86_FP80TyID
80-bit floating point type (X87)
Definition: Type.h:60
IIT_VEC_ELEMENT
@ IIT_VEC_ELEMENT
Definition: Function.cpp:973
llvm::AttributeList::getParamAttr
Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Return the attribute object that exists at the arg index.
Definition: Attributes.h:770
llvm::Type::getFloatTy
static Type * getFloatTy(LLVMContext &C)
Definition: Type.cpp:190
llvm::ArrayRef::end
iterator end() const
Definition: ArrayRef.h:154
llvm::Type::isX86_AMXTy
bool isX86_AMXTy() const
Return true if this is X86 AMX.
Definition: Type.h:186
IIT_F64
@ IIT_F64
Definition: Function.cpp:937
llvm::Argument::hasReturnedAttr
bool hasReturnedAttr() const
Return true if this argument has the returned attribute.
Definition: Function.cpp:267
IIT_SCALABLE_VEC
@ IIT_SCALABLE_VEC
Definition: Function.cpp:974
llvm::FunctionType
Class to represent function types.
Definition: DerivedTypes.h:103
llvm::Argument::addAttr
void addAttr(Attribute::AttrKind Kind)
Definition: Function.cpp:291
llvm::Use
A Use represents the edge between a Value definition and its users.
Definition: Use.h:44
llvm::SmallVectorImpl::emplace_back
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:908
llvm::Function::getImportGUIDs
DenseSet< GlobalValue::GUID > getImportGUIDs() const
Returns the set of GUIDs that needs to be imported to the function for sample PGO,...
Definition: Function.cpp:1932
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37