LLVM  15.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/IntrinsicInst.h"
34 #include "llvm/IR/Intrinsics.h"
35 #include "llvm/IR/IntrinsicsAArch64.h"
36 #include "llvm/IR/IntrinsicsAMDGPU.h"
37 #include "llvm/IR/IntrinsicsARM.h"
38 #include "llvm/IR/IntrinsicsBPF.h"
39 #include "llvm/IR/IntrinsicsHexagon.h"
40 #include "llvm/IR/IntrinsicsMips.h"
41 #include "llvm/IR/IntrinsicsNVPTX.h"
42 #include "llvm/IR/IntrinsicsPowerPC.h"
43 #include "llvm/IR/IntrinsicsR600.h"
44 #include "llvm/IR/IntrinsicsRISCV.h"
45 #include "llvm/IR/IntrinsicsS390.h"
46 #include "llvm/IR/IntrinsicsVE.h"
47 #include "llvm/IR/IntrinsicsWebAssembly.h"
48 #include "llvm/IR/IntrinsicsX86.h"
49 #include "llvm/IR/IntrinsicsXCore.h"
50 #include "llvm/IR/LLVMContext.h"
51 #include "llvm/IR/MDBuilder.h"
52 #include "llvm/IR/Metadata.h"
53 #include "llvm/IR/Module.h"
54 #include "llvm/IR/Operator.h"
56 #include "llvm/IR/Type.h"
57 #include "llvm/IR/Use.h"
58 #include "llvm/IR/User.h"
59 #include "llvm/IR/Value.h"
61 #include "llvm/Support/Casting.h"
63 #include "llvm/Support/Compiler.h"
65 #include <cassert>
66 #include <cstddef>
67 #include <cstdint>
68 #include <cstring>
69 #include <string>
70 
71 using namespace llvm;
73 
74 // Explicit instantiations of SymbolTableListTraits since some of the methods
75 // are not in the public header file...
77 
79  "non-global-value-max-name-size", cl::Hidden, cl::init(1024),
80  cl::desc("Maximum size for the name of non-global values."));
81 
82 //===----------------------------------------------------------------------===//
83 // Argument Implementation
84 //===----------------------------------------------------------------------===//
85 
86 Argument::Argument(Type *Ty, const Twine &Name, Function *Par, unsigned ArgNo)
87  : Value(Ty, Value::ArgumentVal), Parent(Par), ArgNo(ArgNo) {
88  setName(Name);
89 }
90 
91 void Argument::setParent(Function *parent) {
92  Parent = parent;
93 }
94 
95 bool Argument::hasNonNullAttr(bool AllowUndefOrPoison) const {
96  if (!getType()->isPointerTy()) return false;
97  if (getParent()->hasParamAttribute(getArgNo(), Attribute::NonNull) &&
98  (AllowUndefOrPoison ||
99  getParent()->hasParamAttribute(getArgNo(), Attribute::NoUndef)))
100  return true;
101  else if (getDereferenceableBytes() > 0 &&
103  getType()->getPointerAddressSpace()))
104  return true;
105  return false;
106 }
107 
109  if (!getType()->isPointerTy()) return false;
110  return hasAttribute(Attribute::ByVal);
111 }
112 
114  if (!getType()->isPointerTy())
115  return false;
116  return hasAttribute(Attribute::ByRef);
117 }
118 
120  return getParent()->hasParamAttribute(getArgNo(), Attribute::SwiftSelf);
121 }
122 
124  return getParent()->hasParamAttribute(getArgNo(), Attribute::SwiftError);
125 }
126 
128  if (!getType()->isPointerTy()) return false;
129  return hasAttribute(Attribute::InAlloca);
130 }
131 
133  if (!getType()->isPointerTy())
134  return false;
135  return hasAttribute(Attribute::Preallocated);
136 }
137 
139  if (!getType()->isPointerTy()) return false;
141  return Attrs.hasParamAttr(getArgNo(), Attribute::ByVal) ||
142  Attrs.hasParamAttr(getArgNo(), Attribute::InAlloca) ||
143  Attrs.hasParamAttr(getArgNo(), Attribute::Preallocated);
144 }
145 
147  if (!getType()->isPointerTy())
148  return false;
150  return Attrs.hasParamAttr(getArgNo(), Attribute::ByVal) ||
151  Attrs.hasParamAttr(getArgNo(), Attribute::StructRet) ||
152  Attrs.hasParamAttr(getArgNo(), Attribute::InAlloca) ||
153  Attrs.hasParamAttr(getArgNo(), Attribute::Preallocated) ||
154  Attrs.hasParamAttr(getArgNo(), Attribute::ByRef);
155 }
156 
157 /// For a byval, sret, inalloca, or preallocated parameter, get the in-memory
158 /// parameter type.
160  // FIXME: All the type carrying attributes are mutually exclusive, so there
161  // should be a single query to get the stored type that handles any of them.
162  if (Type *ByValTy = ParamAttrs.getByValType())
163  return ByValTy;
164  if (Type *ByRefTy = ParamAttrs.getByRefType())
165  return ByRefTy;
166  if (Type *PreAllocTy = ParamAttrs.getPreallocatedType())
167  return PreAllocTy;
168  if (Type *InAllocaTy = ParamAttrs.getInAllocaType())
169  return InAllocaTy;
170  if (Type *SRetTy = ParamAttrs.getStructRetType())
171  return SRetTy;
172 
173  return nullptr;
174 }
175 
177  AttributeSet ParamAttrs =
179  if (Type *MemTy = getMemoryParamAllocType(ParamAttrs))
180  return DL.getTypeAllocSize(MemTy);
181  return 0;
182 }
183 
185  AttributeSet ParamAttrs =
187  return getMemoryParamAllocType(ParamAttrs);
188 }
189 
191  assert(getType()->isPointerTy() && "Only pointers have alignments");
192  return getParent()->getParamAlignment(getArgNo());
193 }
194 
196  assert(getType()->isPointerTy() && "Only pointers have alignments");
197  return getParent()->getParamAlign(getArgNo());
198 }
199 
202 }
203 
205  assert(getType()->isPointerTy() && "Only pointers have byval types");
206  return getParent()->getParamByValType(getArgNo());
207 }
208 
210  assert(getType()->isPointerTy() && "Only pointers have sret types");
212 }
213 
215  assert(getType()->isPointerTy() && "Only pointers have byref types");
216  return getParent()->getParamByRefType(getArgNo());
217 }
218 
220  assert(getType()->isPointerTy() && "Only pointers have inalloca types");
222 }
223 
225  assert(getType()->isPointerTy() &&
226  "Only pointers have dereferenceable bytes");
228 }
229 
231  assert(getType()->isPointerTy() &&
232  "Only pointers have dereferenceable bytes");
234 }
235 
236 bool Argument::hasNestAttr() const {
237  if (!getType()->isPointerTy()) return false;
238  return hasAttribute(Attribute::Nest);
239 }
240 
242  if (!getType()->isPointerTy()) return false;
243  return hasAttribute(Attribute::NoAlias);
244 }
245 
247  if (!getType()->isPointerTy()) return false;
248  return hasAttribute(Attribute::NoCapture);
249 }
250 
252  if (!getType()->isPointerTy()) return false;
253  return hasAttribute(Attribute::NoFree);
254 }
255 
257  if (!getType()->isPointerTy()) return false;
258  return hasAttribute(Attribute::StructRet);
259 }
260 
262  return hasAttribute(Attribute::InReg);
263 }
264 
266  return hasAttribute(Attribute::Returned);
267 }
268 
269 bool Argument::hasZExtAttr() const {
270  return hasAttribute(Attribute::ZExt);
271 }
272 
273 bool Argument::hasSExtAttr() const {
274  return hasAttribute(Attribute::SExt);
275 }
276 
279  return Attrs.hasParamAttr(getArgNo(), Attribute::ReadOnly) ||
280  Attrs.hasParamAttr(getArgNo(), Attribute::ReadNone);
281 }
282 
285  AL = AL.addParamAttributes(Parent->getContext(), getArgNo(), B);
287 }
288 
291 }
292 
294  getParent()->addParamAttr(getArgNo(), Attr);
295 }
296 
299 }
300 
303  AL = AL.removeParamAttributes(Parent->getContext(), getArgNo(), AM);
305 }
306 
309 }
310 
313 }
314 
315 //===----------------------------------------------------------------------===//
316 // Helper Methods in Function
317 //===----------------------------------------------------------------------===//
318 
320  return getType()->getContext();
321 }
322 
324  unsigned NumInstrs = 0;
325  for (const BasicBlock &BB : BasicBlocks)
326  NumInstrs += std::distance(BB.instructionsWithoutDebug().begin(),
327  BB.instructionsWithoutDebug().end());
328  return NumInstrs;
329 }
330 
332  const Twine &N, Module &M) {
333  return Create(Ty, Linkage, M.getDataLayout().getProgramAddressSpace(), N, &M);
334 }
335 
337  LinkageTypes Linkage,
338  unsigned AddrSpace, const Twine &N,
339  Module *M) {
340  auto *F = new Function(Ty, Linkage, AddrSpace, N, M);
341  AttrBuilder B(F->getContext());
342  UWTableKind UWTable = M->getUwtable();
343  if (UWTable != UWTableKind::None)
344  B.addUWTableAttr(UWTable);
345  switch (M->getFramePointer()) {
347  // 0 ("none") is the default.
348  break;
350  B.addAttribute("frame-pointer", "non-leaf");
351  break;
353  B.addAttribute("frame-pointer", "all");
354  break;
355  }
356  F->addFnAttrs(B);
357  return F;
358 }
359 
361  getParent()->getFunctionList().remove(getIterator());
362 }
363 
365  getParent()->getFunctionList().erase(getIterator());
366 }
367 
368 //===----------------------------------------------------------------------===//
369 // Function Implementation
370 //===----------------------------------------------------------------------===//
371 
372 static unsigned computeAddrSpace(unsigned AddrSpace, Module *M) {
373  // If AS == -1 and we are passed a valid module pointer we place the function
374  // in the program address space. Otherwise we default to AS0.
375  if (AddrSpace == static_cast<unsigned>(-1))
376  return M ? M->getDataLayout().getProgramAddressSpace() : 0;
377  return AddrSpace;
378 }
379 
380 Function::Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
381  const Twine &name, Module *ParentModule)
382  : GlobalObject(Ty, Value::FunctionVal,
383  OperandTraits<Function>::op_begin(this), 0, Linkage, name,
384  computeAddrSpace(AddrSpace, ParentModule)),
385  NumArgs(Ty->getNumParams()) {
386  assert(FunctionType::isValidReturnType(getReturnType()) &&
387  "invalid return type");
388  setGlobalObjectSubClassData(0);
389 
390  // We only need a symbol table for a function if the context keeps value names
391  if (!getContext().shouldDiscardValueNames())
392  SymTab = std::make_unique<ValueSymbolTable>(NonGlobalValueMaxNameSize);
393 
394  // If the function has arguments, mark them as lazily built.
395  if (Ty->getNumParams())
396  setValueSubclassData(1); // Set the "has lazy arguments" bit.
397 
398  if (ParentModule)
399  ParentModule->getFunctionList().push_back(this);
400 
401  HasLLVMReservedName = getName().startswith("llvm.");
402  // Ensure intrinsics have the right parameter attributes.
403  // Note, the IntID field will have been set in Value::setName if this function
404  // name is a valid intrinsic ID.
405  if (IntID)
406  setAttributes(Intrinsic::getAttributes(getContext(), IntID));
407 }
408 
409 Function::~Function() {
410  dropAllReferences(); // After this it is safe to delete instructions.
411 
412  // Delete all of the method arguments and unlink from symbol table...
413  if (Arguments)
414  clearArguments();
415 
416  // Remove the function from the on-the-side GC table.
417  clearGC();
418 }
419 
420 void Function::BuildLazyArguments() const {
421  // Create the arguments vector, all arguments start out unnamed.
422  auto *FT = getFunctionType();
423  if (NumArgs > 0) {
424  Arguments = std::allocator<Argument>().allocate(NumArgs);
425  for (unsigned i = 0, e = NumArgs; i != e; ++i) {
426  Type *ArgTy = FT->getParamType(i);
427  assert(!ArgTy->isVoidTy() && "Cannot have void typed arguments!");
428  new (Arguments + i) Argument(ArgTy, "", const_cast<Function *>(this), i);
429  }
430  }
431 
432  // Clear the lazy arguments bit.
433  unsigned SDC = getSubclassDataFromValue();
434  SDC &= ~(1 << 0);
435  const_cast<Function*>(this)->setValueSubclassData(SDC);
437 }
438 
440  return MutableArrayRef<Argument>(Args, Count);
441 }
442 
444  switch (getIntrinsicID()) {
445 #define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
446  case Intrinsic::INTRINSIC:
447 #include "llvm/IR/ConstrainedOps.def"
448  return true;
449 #undef INSTRUCTION
450  default:
451  return false;
452  }
453 }
454 
455 void Function::clearArguments() {
456  for (Argument &A : makeArgArray(Arguments, NumArgs)) {
457  A.setName("");
458  A.~Argument();
459  }
460  std::allocator<Argument>().deallocate(Arguments, NumArgs);
461  Arguments = nullptr;
462 }
463 
465  assert(isDeclaration() && "Expected no references to current arguments");
466 
467  // Drop the current arguments, if any, and set the lazy argument bit.
468  if (!hasLazyArguments()) {
469  assert(llvm::all_of(makeArgArray(Arguments, NumArgs),
470  [](const Argument &A) { return A.use_empty(); }) &&
471  "Expected arguments to be unused in declaration");
472  clearArguments();
473  setValueSubclassData(getSubclassDataFromValue() | (1 << 0));
474  }
475 
476  // Nothing to steal if Src has lazy arguments.
477  if (Src.hasLazyArguments())
478  return;
479 
480  // Steal arguments from Src, and fix the lazy argument bits.
481  assert(arg_size() == Src.arg_size());
482  Arguments = Src.Arguments;
483  Src.Arguments = nullptr;
484  for (Argument &A : makeArgArray(Arguments, NumArgs)) {
485  // FIXME: This does the work of transferNodesFromList inefficiently.
487  if (A.hasName())
488  Name = A.getName();
489  if (!Name.empty())
490  A.setName("");
491  A.setParent(this);
492  if (!Name.empty())
493  A.setName(Name);
494  }
495 
496  setValueSubclassData(getSubclassDataFromValue() & ~(1 << 0));
498  Src.setValueSubclassData(Src.getSubclassDataFromValue() | (1 << 0));
499 }
500 
501 // dropAllReferences() - This function causes all the subinstructions to "let
502 // go" of all references that they are maintaining. This allows one to
503 // 'delete' a whole class at a time, even though there may be circular
504 // references... first all references are dropped, and all use counts go to
505 // zero. Then everything is deleted for real. Note that no operations are
506 // valid on an object that has "dropped all references", except operator
507 // delete.
508 //
510  setIsMaterializable(false);
511 
512  for (BasicBlock &BB : *this)
513  BB.dropAllReferences();
514 
515  // Delete all basic blocks. They are now unused, except possibly by
516  // blockaddresses, but BasicBlock's destructor takes care of those.
517  while (!BasicBlocks.empty())
518  BasicBlocks.begin()->eraseFromParent();
519 
520  // Drop uses of any optional data (real or placeholder).
521  if (getNumOperands()) {
524  setValueSubclassData(getSubclassDataFromValue() & ~0xe);
525  }
526 
527  // Metadata is stored in a side-table.
528  clearMetadata();
529 }
530 
532  AttributeSets = AttributeSets.addAttributeAtIndex(getContext(), i, Attr);
533 }
534 
536  AttributeSets = AttributeSets.addFnAttribute(getContext(), Kind);
537 }
538 
540  AttributeSets = AttributeSets.addFnAttribute(getContext(), Kind, Val);
541 }
542 
544  AttributeSets = AttributeSets.addFnAttribute(getContext(), Attr);
545 }
546 
548  AttributeSets = AttributeSets.addFnAttributes(getContext(), Attrs);
549 }
550 
552  AttributeSets = AttributeSets.addRetAttribute(getContext(), Kind);
553 }
554 
556  AttributeSets = AttributeSets.addRetAttribute(getContext(), Attr);
557 }
558 
560  AttributeSets = AttributeSets.addRetAttributes(getContext(), Attrs);
561 }
562 
564  AttributeSets = AttributeSets.addParamAttribute(getContext(), ArgNo, Kind);
565 }
566 
567 void Function::addParamAttr(unsigned ArgNo, Attribute Attr) {
568  AttributeSets = AttributeSets.addParamAttribute(getContext(), ArgNo, Attr);
569 }
570 
571 void Function::addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) {
572  AttributeSets = AttributeSets.addParamAttributes(getContext(), ArgNo, Attrs);
573 }
574 
576  AttributeSets = AttributeSets.removeAttributeAtIndex(getContext(), i, Kind);
577 }
578 
580  AttributeSets = AttributeSets.removeAttributeAtIndex(getContext(), i, Kind);
581 }
582 
584  AttributeSets = AttributeSets.removeFnAttribute(getContext(), Kind);
585 }
586 
588  AttributeSets = AttributeSets.removeFnAttribute(getContext(), Kind);
589 }
590 
592  AttributeSets = AttributeSets.removeFnAttributes(getContext(), AM);
593 }
594 
596  AttributeSets = AttributeSets.removeRetAttribute(getContext(), Kind);
597 }
598 
600  AttributeSets = AttributeSets.removeRetAttribute(getContext(), Kind);
601 }
602 
604  AttributeSets = AttributeSets.removeRetAttributes(getContext(), Attrs);
605 }
606 
608  AttributeSets = AttributeSets.removeParamAttribute(getContext(), ArgNo, Kind);
609 }
610 
611 void Function::removeParamAttr(unsigned ArgNo, StringRef Kind) {
612  AttributeSets = AttributeSets.removeParamAttribute(getContext(), ArgNo, Kind);
613 }
614 
615 void Function::removeParamAttrs(unsigned ArgNo, const AttributeMask &Attrs) {
616  AttributeSets =
617  AttributeSets.removeParamAttributes(getContext(), ArgNo, Attrs);
618 }
619 
620 void Function::addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes) {
621  AttributeSets =
622  AttributeSets.addDereferenceableParamAttr(getContext(), ArgNo, Bytes);
623 }
624 
626  return AttributeSets.hasFnAttr(Kind);
627 }
628 
630  return AttributeSets.hasFnAttr(Kind);
631 }
632 
634  return AttributeSets.hasRetAttr(Kind);
635 }
636 
637 bool Function::hasParamAttribute(unsigned ArgNo,
638  Attribute::AttrKind Kind) const {
639  return AttributeSets.hasParamAttr(ArgNo, Kind);
640 }
641 
643  Attribute::AttrKind Kind) const {
644  return AttributeSets.getAttributeAtIndex(i, Kind);
645 }
646 
648  return AttributeSets.getAttributeAtIndex(i, Kind);
649 }
650 
652  return AttributeSets.getFnAttr(Kind);
653 }
654 
656  return AttributeSets.getFnAttr(Kind);
657 }
658 
659 /// gets the specified attribute from the list of attributes.
661  Attribute::AttrKind Kind) const {
662  return AttributeSets.getParamAttr(ArgNo, Kind);
663 }
664 
666  uint64_t Bytes) {
667  AttributeSets = AttributeSets.addDereferenceableOrNullParamAttr(getContext(),
668  ArgNo, Bytes);
669 }
670 
672  if (&FPType == &APFloat::IEEEsingle()) {
673  Attribute Attr = getFnAttribute("denormal-fp-math-f32");
674  StringRef Val = Attr.getValueAsString();
675  if (!Val.empty())
676  return parseDenormalFPAttribute(Val);
677 
678  // If the f32 variant of the attribute isn't specified, try to use the
679  // generic one.
680  }
681 
682  Attribute Attr = getFnAttribute("denormal-fp-math");
684 }
685 
686 const std::string &Function::getGC() const {
687  assert(hasGC() && "Function has no collector");
688  return getContext().getGC(*this);
689 }
690 
691 void Function::setGC(std::string Str) {
692  setValueSubclassDataBit(14, !Str.empty());
693  getContext().setGC(*this, std::move(Str));
694 }
695 
697  if (!hasGC())
698  return;
699  getContext().deleteGC(*this);
700  setValueSubclassDataBit(14, false);
701 }
702 
704  return hasFnAttribute(Attribute::StackProtect) ||
705  hasFnAttribute(Attribute::StackProtectStrong) ||
706  hasFnAttribute(Attribute::StackProtectReq);
707 }
708 
709 /// Copy all additional attributes (those not needed to create a Function) from
710 /// the Function Src to this one.
713  setCallingConv(Src->getCallingConv());
714  setAttributes(Src->getAttributes());
715  if (Src->hasGC())
716  setGC(Src->getGC());
717  else
718  clearGC();
719  if (Src->hasPersonalityFn())
720  setPersonalityFn(Src->getPersonalityFn());
721  if (Src->hasPrefixData())
722  setPrefixData(Src->getPrefixData());
723  if (Src->hasPrologueData())
724  setPrologueData(Src->getPrologueData());
725 }
726 
727 /// Table of string intrinsic names indexed by enum value.
728 static const char * const IntrinsicNameTable[] = {
729  "not_intrinsic",
730 #define GET_INTRINSIC_NAME_TABLE
731 #include "llvm/IR/IntrinsicImpl.inc"
732 #undef GET_INTRINSIC_NAME_TABLE
733 };
734 
735 /// Table of per-target intrinsic name tables.
736 #define GET_INTRINSIC_TARGET_DATA
737 #include "llvm/IR/IntrinsicImpl.inc"
738 #undef GET_INTRINSIC_TARGET_DATA
739 
741  return IID > TargetInfos[0].Count;
742 }
743 
745  return isTargetIntrinsic(IntID);
746 }
747 
748 /// Find the segment of \c IntrinsicNameTable for intrinsics with the same
749 /// target as \c Name, or the generic table if \c Name is not target specific.
750 ///
751 /// Returns the relevant slice of \c IntrinsicNameTable
753  assert(Name.startswith("llvm."));
754 
755  ArrayRef<IntrinsicTargetInfo> Targets(TargetInfos);
756  // Drop "llvm." and take the first dotted component. That will be the target
757  // if this is target specific.
758  StringRef Target = Name.drop_front(5).split('.').first;
759  auto It = partition_point(
760  Targets, [=](const IntrinsicTargetInfo &TI) { return TI.Name < Target; });
761  // We've either found the target or just fall back to the generic set, which
762  // is always first.
763  const auto &TI = It != Targets.end() && It->Name == Target ? *It : Targets[0];
764  return makeArrayRef(&IntrinsicNameTable[1] + TI.Offset, TI.Count);
765 }
766 
767 /// This does the actual lookup of an intrinsic ID which
768 /// matches the given function name.
771  int Idx = Intrinsic::lookupLLVMIntrinsicByName(NameTable, Name);
772  if (Idx == -1)
774 
775  // Intrinsic IDs correspond to the location in IntrinsicNameTable, but we have
776  // an index into a sub-table.
777  int Adjust = NameTable.data() - IntrinsicNameTable;
778  Intrinsic::ID ID = static_cast<Intrinsic::ID>(Idx + Adjust);
779 
780  // If the intrinsic is not overloaded, require an exact match. If it is
781  // overloaded, require either exact or prefix match.
782  const auto MatchSize = strlen(NameTable[Idx]);
783  assert(Name.size() >= MatchSize && "Expected either exact or prefix match");
784  bool IsExactMatch = Name.size() == MatchSize;
785  return IsExactMatch || Intrinsic::isOverloaded(ID) ? ID
787 }
788 
790  StringRef Name = getName();
791  if (!Name.startswith("llvm.")) {
792  HasLLVMReservedName = false;
794  return;
795  }
796  HasLLVMReservedName = true;
798 }
799 
800 /// Returns a stable mangling for the type specified for use in the name
801 /// mangling scheme used by 'any' types in intrinsic signatures. The mangling
802 /// of named types is simply their name. Manglings for unnamed types consist
803 /// of a prefix ('p' for pointers, 'a' for arrays, 'f_' for functions)
804 /// combined with the mangling of their component types. A vararg function
805 /// type will have a suffix of 'vararg'. Since function types can contain
806 /// other function types, we close a function type mangling with suffix 'f'
807 /// which can't be confused with it's prefix. This ensures we don't have
808 /// collisions between two unrelated function types. Otherwise, you might
809 /// parse ffXX as f(fXX) or f(fX)X. (X is a placeholder for any other type.)
810 /// The HasUnnamedType boolean is set if an unnamed type was encountered,
811 /// indicating that extra care must be taken to ensure a unique name.
812 static std::string getMangledTypeStr(Type *Ty, bool &HasUnnamedType) {
813  std::string Result;
814  if (PointerType *PTyp = dyn_cast<PointerType>(Ty)) {
815  Result += "p" + utostr(PTyp->getAddressSpace());
816  // Opaque pointer doesn't have pointee type information, so we just mangle
817  // address space for opaque pointer.
818  if (!PTyp->isOpaque())
819  Result += getMangledTypeStr(PTyp->getNonOpaquePointerElementType(),
820  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,
984  IIT_V3 = 53,
988 };
989 
990 static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos,
991  IIT_Info LastInfo,
993  using namespace Intrinsic;
994 
995  bool IsScalableVector = (LastInfo == IIT_SCALABLE_VEC);
996 
997  IIT_Info Info = IIT_Info(Infos[NextElt++]);
998  unsigned StructElts = 2;
999 
1000  switch (Info) {
1001  case IIT_Done:
1002  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0));
1003  return;
1004  case IIT_VARARG:
1005  OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0));
1006  return;
1007  case IIT_MMX:
1008  OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0));
1009  return;
1010  case IIT_AMX:
1011  OutputTable.push_back(IITDescriptor::get(IITDescriptor::AMX, 0));
1012  return;
1013  case IIT_TOKEN:
1014  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Token, 0));
1015  return;
1016  case IIT_METADATA:
1017  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0));
1018  return;
1019  case IIT_F16:
1020  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0));
1021  return;
1022  case IIT_BF16:
1023  OutputTable.push_back(IITDescriptor::get(IITDescriptor::BFloat, 0));
1024  return;
1025  case IIT_F32:
1026  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Float, 0));
1027  return;
1028  case IIT_F64:
1029  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Double, 0));
1030  return;
1031  case IIT_F128:
1032  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Quad, 0));
1033  return;
1034  case IIT_PPCF128:
1035  OutputTable.push_back(IITDescriptor::get(IITDescriptor::PPCQuad, 0));
1036  return;
1037  case IIT_I1:
1038  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 1));
1039  return;
1040  case IIT_I8:
1041  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8));
1042  return;
1043  case IIT_I16:
1044  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer,16));
1045  return;
1046  case IIT_I32:
1047  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32));
1048  return;
1049  case IIT_I64:
1050  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64));
1051  return;
1052  case IIT_I128:
1053  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 128));
1054  return;
1055  case IIT_V1:
1056  OutputTable.push_back(IITDescriptor::getVector(1, IsScalableVector));
1057  DecodeIITType(NextElt, Infos, Info, OutputTable);
1058  return;
1059  case IIT_V2:
1060  OutputTable.push_back(IITDescriptor::getVector(2, IsScalableVector));
1061  DecodeIITType(NextElt, Infos, Info, OutputTable);
1062  return;
1063  case IIT_V3:
1064  OutputTable.push_back(IITDescriptor::getVector(3, IsScalableVector));
1065  DecodeIITType(NextElt, Infos, Info, OutputTable);
1066  return;
1067  case IIT_V4:
1068  OutputTable.push_back(IITDescriptor::getVector(4, IsScalableVector));
1069  DecodeIITType(NextElt, Infos, Info, OutputTable);
1070  return;
1071  case IIT_V8:
1072  OutputTable.push_back(IITDescriptor::getVector(8, IsScalableVector));
1073  DecodeIITType(NextElt, Infos, Info, OutputTable);
1074  return;
1075  case IIT_V16:
1076  OutputTable.push_back(IITDescriptor::getVector(16, IsScalableVector));
1077  DecodeIITType(NextElt, Infos, Info, OutputTable);
1078  return;
1079  case IIT_V32:
1080  OutputTable.push_back(IITDescriptor::getVector(32, IsScalableVector));
1081  DecodeIITType(NextElt, Infos, Info, OutputTable);
1082  return;
1083  case IIT_V64:
1084  OutputTable.push_back(IITDescriptor::getVector(64, IsScalableVector));
1085  DecodeIITType(NextElt, Infos, Info, OutputTable);
1086  return;
1087  case IIT_V128:
1088  OutputTable.push_back(IITDescriptor::getVector(128, IsScalableVector));
1089  DecodeIITType(NextElt, Infos, Info, OutputTable);
1090  return;
1091  case IIT_V256:
1092  OutputTable.push_back(IITDescriptor::getVector(256, IsScalableVector));
1093  DecodeIITType(NextElt, Infos, Info, OutputTable);
1094  return;
1095  case IIT_V512:
1096  OutputTable.push_back(IITDescriptor::getVector(512, IsScalableVector));
1097  DecodeIITType(NextElt, Infos, Info, OutputTable);
1098  return;
1099  case IIT_V1024:
1100  OutputTable.push_back(IITDescriptor::getVector(1024, IsScalableVector));
1101  DecodeIITType(NextElt, Infos, Info, OutputTable);
1102  return;
1103  case IIT_EXTERNREF:
1104  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 10));
1105  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0));
1106  return;
1107  case IIT_FUNCREF:
1108  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 20));
1109  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8));
1110  return;
1111  case IIT_PTR:
1112  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 0));
1113  DecodeIITType(NextElt, Infos, Info, OutputTable);
1114  return;
1115  case IIT_ANYPTR: { // [ANYPTR addrspace, subtype]
1116  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer,
1117  Infos[NextElt++]));
1118  DecodeIITType(NextElt, Infos, Info, OutputTable);
1119  return;
1120  }
1121  case IIT_ARG: {
1122  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1123  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Argument, ArgInfo));
1124  return;
1125  }
1126  case IIT_EXTEND_ARG: {
1127  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1128  OutputTable.push_back(IITDescriptor::get(IITDescriptor::ExtendArgument,
1129  ArgInfo));
1130  return;
1131  }
1132  case IIT_TRUNC_ARG: {
1133  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1134  OutputTable.push_back(IITDescriptor::get(IITDescriptor::TruncArgument,
1135  ArgInfo));
1136  return;
1137  }
1138  case IIT_HALF_VEC_ARG: {
1139  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1140  OutputTable.push_back(IITDescriptor::get(IITDescriptor::HalfVecArgument,
1141  ArgInfo));
1142  return;
1143  }
1144  case IIT_SAME_VEC_WIDTH_ARG: {
1145  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1147  ArgInfo));
1148  return;
1149  }
1150  case IIT_PTR_TO_ARG: {
1151  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1152  OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToArgument,
1153  ArgInfo));
1154  return;
1155  }
1156  case IIT_PTR_TO_ELT: {
1157  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1158  OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToElt, ArgInfo));
1159  return;
1160  }
1161  case IIT_ANYPTR_TO_ELT: {
1162  unsigned short ArgNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1163  unsigned short RefNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1164  OutputTable.push_back(
1166  return;
1167  }
1169  unsigned short ArgNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1170  unsigned short RefNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1171  OutputTable.push_back(
1173  return;
1174  }
1175  case IIT_EMPTYSTRUCT:
1176  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0));
1177  return;
1178  case IIT_STRUCT9: ++StructElts; LLVM_FALLTHROUGH;
1179  case IIT_STRUCT8: ++StructElts; LLVM_FALLTHROUGH;
1180  case IIT_STRUCT7: ++StructElts; LLVM_FALLTHROUGH;
1181  case IIT_STRUCT6: ++StructElts; LLVM_FALLTHROUGH;
1182  case IIT_STRUCT5: ++StructElts; LLVM_FALLTHROUGH;
1183  case IIT_STRUCT4: ++StructElts; LLVM_FALLTHROUGH;
1184  case IIT_STRUCT3: ++StructElts; LLVM_FALLTHROUGH;
1185  case IIT_STRUCT2: {
1186  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts));
1187 
1188  for (unsigned i = 0; i != StructElts; ++i)
1189  DecodeIITType(NextElt, Infos, Info, OutputTable);
1190  return;
1191  }
1192  case IIT_SUBDIVIDE2_ARG: {
1193  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1195  ArgInfo));
1196  return;
1197  }
1198  case IIT_SUBDIVIDE4_ARG: {
1199  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1201  ArgInfo));
1202  return;
1203  }
1204  case IIT_VEC_ELEMENT: {
1205  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1207  ArgInfo));
1208  return;
1209  }
1210  case IIT_SCALABLE_VEC: {
1211  DecodeIITType(NextElt, Infos, Info, OutputTable);
1212  return;
1213  }
1215  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
1217  ArgInfo));
1218  return;
1219  }
1220  }
1221  llvm_unreachable("unhandled");
1222 }
1223 
1224 #define GET_INTRINSIC_GENERATOR_GLOBAL
1225 #include "llvm/IR/IntrinsicImpl.inc"
1226 #undef GET_INTRINSIC_GENERATOR_GLOBAL
1227 
1230  // Check to see if the intrinsic's type was expressible by the table.
1231  unsigned TableVal = IIT_Table[id-1];
1232 
1233  // Decode the TableVal into an array of IITValues.
1235  ArrayRef<unsigned char> IITEntries;
1236  unsigned NextElt = 0;
1237  if ((TableVal >> 31) != 0) {
1238  // This is an offset into the IIT_LongEncodingTable.
1239  IITEntries = IIT_LongEncodingTable;
1240 
1241  // Strip sentinel bit.
1242  NextElt = (TableVal << 1) >> 1;
1243  } else {
1244  // Decode the TableVal into an array of IITValues. If the entry was encoded
1245  // into a single word in the table itself, decode it now.
1246  do {
1247  IITValues.push_back(TableVal & 0xF);
1248  TableVal >>= 4;
1249  } while (TableVal);
1250 
1251  IITEntries = IITValues;
1252  NextElt = 0;
1253  }
1254 
1255  // Okay, decode the table into the output vector of IITDescriptors.
1256  DecodeIITType(NextElt, IITEntries, IIT_Done, T);
1257  while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0)
1258  DecodeIITType(NextElt, IITEntries, IIT_Done, T);
1259 }
1260 
1263  using namespace Intrinsic;
1264 
1265  IITDescriptor D = Infos.front();
1266  Infos = Infos.slice(1);
1267 
1268  switch (D.Kind) {
1281 
1283  return IntegerType::get(Context, D.Integer_Width);
1284  case IITDescriptor::Vector:
1285  return VectorType::get(DecodeFixedType(Infos, Tys, Context),
1286  D.Vector_Width);
1288  return PointerType::get(DecodeFixedType(Infos, Tys, Context),
1289  D.Pointer_AddressSpace);
1290  case IITDescriptor::Struct: {
1292  for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
1293  Elts.push_back(DecodeFixedType(Infos, Tys, Context));
1294  return StructType::get(Context, Elts);
1295  }
1297  return Tys[D.getArgumentNumber()];
1299  Type *Ty = Tys[D.getArgumentNumber()];
1300  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1302 
1303  return IntegerType::get(Context, 2 * cast<IntegerType>(Ty)->getBitWidth());
1304  }
1306  Type *Ty = Tys[D.getArgumentNumber()];
1307  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1309 
1310  IntegerType *ITy = cast<IntegerType>(Ty);
1311  assert(ITy->getBitWidth() % 2 == 0);
1312  return IntegerType::get(Context, ITy->getBitWidth() / 2);
1313  }
1316  Type *Ty = Tys[D.getArgumentNumber()];
1317  VectorType *VTy = dyn_cast<VectorType>(Ty);
1318  assert(VTy && "Expected an argument of Vector Type");
1319  int SubDivs = D.Kind == IITDescriptor::Subdivide2Argument ? 1 : 2;
1320  return VectorType::getSubdividedVectorType(VTy, SubDivs);
1321  }
1323  return VectorType::getHalfElementsVectorType(cast<VectorType>(
1324  Tys[D.getArgumentNumber()]));
1326  Type *EltTy = DecodeFixedType(Infos, Tys, Context);
1327  Type *Ty = Tys[D.getArgumentNumber()];
1328  if (auto *VTy = dyn_cast<VectorType>(Ty))
1329  return VectorType::get(EltTy, VTy->getElementCount());
1330  return EltTy;
1331  }
1333  Type *Ty = Tys[D.getArgumentNumber()];
1334  return PointerType::getUnqual(Ty);
1335  }
1336  case IITDescriptor::PtrToElt: {
1337  Type *Ty = Tys[D.getArgumentNumber()];
1338  VectorType *VTy = dyn_cast<VectorType>(Ty);
1339  if (!VTy)
1340  llvm_unreachable("Expected an argument of Vector Type");
1341  Type *EltTy = VTy->getElementType();
1342  return PointerType::getUnqual(EltTy);
1343  }
1345  Type *Ty = Tys[D.getArgumentNumber()];
1346  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1347  return VTy->getElementType();
1348  llvm_unreachable("Expected an argument of Vector Type");
1349  }
1351  Type *Ty = Tys[D.getArgumentNumber()];
1352  VectorType *VTy = dyn_cast<VectorType>(Ty);
1353  assert(VTy && "Expected an argument of Vector Type");
1354  return VectorType::getInteger(VTy);
1355  }
1357  // Return the overloaded type (which determines the pointers address space)
1358  return Tys[D.getOverloadArgNumber()];
1360  // Return the overloaded type (which determines the pointers address space)
1361  return Tys[D.getOverloadArgNumber()];
1362  }
1363  llvm_unreachable("unhandled");
1364 }
1365 
1367  ID id, ArrayRef<Type*> Tys) {
1369  getIntrinsicInfoTableEntries(id, Table);
1370 
1372  Type *ResultTy = DecodeFixedType(TableRef, Tys, Context);
1373 
1374  SmallVector<Type*, 8> ArgTys;
1375  while (!TableRef.empty())
1376  ArgTys.push_back(DecodeFixedType(TableRef, Tys, Context));
1377 
1378  // DecodeFixedType returns Void for IITDescriptor::Void and IITDescriptor::VarArg
1379  // If we see void type as the type of the last argument, it is vararg intrinsic
1380  if (!ArgTys.empty() && ArgTys.back()->isVoidTy()) {
1381  ArgTys.pop_back();
1382  return FunctionType::get(ResultTy, ArgTys, true);
1383  }
1384  return FunctionType::get(ResultTy, ArgTys, false);
1385 }
1386 
1388 #define GET_INTRINSIC_OVERLOAD_TABLE
1389 #include "llvm/IR/IntrinsicImpl.inc"
1390 #undef GET_INTRINSIC_OVERLOAD_TABLE
1391 }
1392 
1394  switch (id) {
1395  default:
1396  return true;
1397 
1398  case Intrinsic::experimental_gc_statepoint:
1399  case Intrinsic::experimental_patchpoint_void:
1400  case Intrinsic::experimental_patchpoint_i64:
1401  return false;
1402  }
1403 }
1404 
1405 /// This defines the "Intrinsic::getAttributes(ID id)" method.
1406 #define GET_INTRINSIC_ATTRIBUTES
1407 #include "llvm/IR/IntrinsicImpl.inc"
1408 #undef GET_INTRINSIC_ATTRIBUTES
1409 
1411  // There can never be multiple globals with the same name of different types,
1412  // because intrinsics must be a specific type.
1413  auto *FT = getType(M->getContext(), id, Tys);
1414  return cast<Function>(
1415  M->getOrInsertFunction(Tys.empty() ? getName(id)
1416  : getName(id, Tys, M, FT),
1417  getType(M->getContext(), id, Tys))
1418  .getCallee());
1419 }
1420 
1421 // This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method.
1422 #define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
1423 #include "llvm/IR/IntrinsicImpl.inc"
1424 #undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
1425 
1426 // This defines the "Intrinsic::getIntrinsicForMSBuiltin()" method.
1427 #define GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
1428 #include "llvm/IR/IntrinsicImpl.inc"
1429 #undef GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
1430 
1432  std::pair<Type *, ArrayRef<Intrinsic::IITDescriptor>>;
1433 
1436  SmallVectorImpl<Type *> &ArgTys,
1438  bool IsDeferredCheck) {
1439  using namespace Intrinsic;
1440 
1441  // If we ran out of descriptors, there are too many arguments.
1442  if (Infos.empty()) return true;
1443 
1444  // Do this before slicing off the 'front' part
1445  auto InfosRef = Infos;
1446  auto DeferCheck = [&DeferredChecks, &InfosRef](Type *T) {
1447  DeferredChecks.emplace_back(T, InfosRef);
1448  return false;
1449  };
1450 
1451  IITDescriptor D = Infos.front();
1452  Infos = Infos.slice(1);
1453 
1454  switch (D.Kind) {
1455  case IITDescriptor::Void: return !Ty->isVoidTy();
1456  case IITDescriptor::VarArg: return true;
1457  case IITDescriptor::MMX: return !Ty->isX86_MMXTy();
1458  case IITDescriptor::AMX: return !Ty->isX86_AMXTy();
1459  case IITDescriptor::Token: return !Ty->isTokenTy();
1460  case IITDescriptor::Metadata: return !Ty->isMetadataTy();
1461  case IITDescriptor::Half: return !Ty->isHalfTy();
1462  case IITDescriptor::BFloat: return !Ty->isBFloatTy();
1463  case IITDescriptor::Float: return !Ty->isFloatTy();
1464  case IITDescriptor::Double: return !Ty->isDoubleTy();
1465  case IITDescriptor::Quad: return !Ty->isFP128Ty();
1466  case IITDescriptor::PPCQuad: return !Ty->isPPC_FP128Ty();
1467  case IITDescriptor::Integer: return !Ty->isIntegerTy(D.Integer_Width);
1468  case IITDescriptor::Vector: {
1469  VectorType *VT = dyn_cast<VectorType>(Ty);
1470  return !VT || VT->getElementCount() != D.Vector_Width ||
1471  matchIntrinsicType(VT->getElementType(), Infos, ArgTys,
1472  DeferredChecks, IsDeferredCheck);
1473  }
1474  case IITDescriptor::Pointer: {
1475  PointerType *PT = dyn_cast<PointerType>(Ty);
1476  if (!PT || PT->getAddressSpace() != D.Pointer_AddressSpace)
1477  return true;
1478  if (!PT->isOpaque()) {
1479  /* Manually consume a pointer to empty struct descriptor, which is
1480  * used for externref. We don't want to enforce that the struct is
1481  * anonymous in this case. (This renders externref intrinsics
1482  * non-unique, but this will go away with opaque pointers anyway.) */
1483  if (Infos.front().Kind == IITDescriptor::Struct &&
1484  Infos.front().Struct_NumElements == 0) {
1485  Infos = Infos.slice(1);
1486  return false;
1487  }
1489  ArgTys, DeferredChecks, IsDeferredCheck);
1490  }
1491  // Consume IIT descriptors relating to the pointer element type.
1492  // FIXME: Intrinsic type matching of nested single value types or even
1493  // aggregates doesn't work properly with opaque pointers but hopefully
1494  // doesn't happen in practice.
1495  while (Infos.front().Kind == IITDescriptor::Pointer ||
1496  Infos.front().Kind == IITDescriptor::Vector)
1497  Infos = Infos.slice(1);
1498  assert((Infos.front().Kind != IITDescriptor::Argument ||
1500  "Unsupported polymorphic pointer type with opaque pointer");
1501  Infos = Infos.slice(1);
1502  return false;
1503  }
1504 
1505  case IITDescriptor::Struct: {
1506  StructType *ST = dyn_cast<StructType>(Ty);
1507  if (!ST || !ST->isLiteral() || ST->isPacked() ||
1508  ST->getNumElements() != D.Struct_NumElements)
1509  return true;
1510 
1511  for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
1512  if (matchIntrinsicType(ST->getElementType(i), Infos, ArgTys,
1513  DeferredChecks, IsDeferredCheck))
1514  return true;
1515  return false;
1516  }
1517 
1519  // If this is the second occurrence of an argument,
1520  // verify that the later instance matches the previous instance.
1521  if (D.getArgumentNumber() < ArgTys.size())
1522  return Ty != ArgTys[D.getArgumentNumber()];
1523 
1524  if (D.getArgumentNumber() > ArgTys.size() ||
1525  D.getArgumentKind() == IITDescriptor::AK_MatchType)
1526  return IsDeferredCheck || DeferCheck(Ty);
1527 
1528  assert(D.getArgumentNumber() == ArgTys.size() && !IsDeferredCheck &&
1529  "Table consistency error");
1530  ArgTys.push_back(Ty);
1531 
1532  switch (D.getArgumentKind()) {
1533  case IITDescriptor::AK_Any: return false; // Success
1535  case IITDescriptor::AK_AnyFloat: return !Ty->isFPOrFPVectorTy();
1536  case IITDescriptor::AK_AnyVector: return !isa<VectorType>(Ty);
1537  case IITDescriptor::AK_AnyPointer: return !isa<PointerType>(Ty);
1538  default: break;
1539  }
1540  llvm_unreachable("all argument kinds not covered");
1541 
1543  // If this is a forward reference, defer the check for later.
1544  if (D.getArgumentNumber() >= ArgTys.size())
1545  return IsDeferredCheck || DeferCheck(Ty);
1546 
1547  Type *NewTy = ArgTys[D.getArgumentNumber()];
1548  if (VectorType *VTy = dyn_cast<VectorType>(NewTy))
1550  else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy))
1551  NewTy = IntegerType::get(ITy->getContext(), 2 * ITy->getBitWidth());
1552  else
1553  return true;
1554 
1555  return Ty != NewTy;
1556  }
1558  // If this is a forward reference, defer the check for later.
1559  if (D.getArgumentNumber() >= ArgTys.size())
1560  return IsDeferredCheck || DeferCheck(Ty);
1561 
1562  Type *NewTy = ArgTys[D.getArgumentNumber()];
1563  if (VectorType *VTy = dyn_cast<VectorType>(NewTy))
1565  else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy))
1566  NewTy = IntegerType::get(ITy->getContext(), ITy->getBitWidth() / 2);
1567  else
1568  return true;
1569 
1570  return Ty != NewTy;
1571  }
1573  // If this is a forward reference, defer the check for later.
1574  if (D.getArgumentNumber() >= ArgTys.size())
1575  return IsDeferredCheck || DeferCheck(Ty);
1576  return !isa<VectorType>(ArgTys[D.getArgumentNumber()]) ||
1578  cast<VectorType>(ArgTys[D.getArgumentNumber()])) != Ty;
1580  if (D.getArgumentNumber() >= ArgTys.size()) {
1581  // Defer check and subsequent check for the vector element type.
1582  Infos = Infos.slice(1);
1583  return IsDeferredCheck || DeferCheck(Ty);
1584  }
1585  auto *ReferenceType = dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
1586  auto *ThisArgType = dyn_cast<VectorType>(Ty);
1587  // Both must be vectors of the same number of elements or neither.
1588  if ((ReferenceType != nullptr) != (ThisArgType != nullptr))
1589  return true;
1590  Type *EltTy = Ty;
1591  if (ThisArgType) {
1592  if (ReferenceType->getElementCount() !=
1593  ThisArgType->getElementCount())
1594  return true;
1595  EltTy = ThisArgType->getElementType();
1596  }
1597  return matchIntrinsicType(EltTy, Infos, ArgTys, DeferredChecks,
1598  IsDeferredCheck);
1599  }
1601  if (D.getArgumentNumber() >= ArgTys.size())
1602  return IsDeferredCheck || DeferCheck(Ty);
1603  Type * ReferenceType = ArgTys[D.getArgumentNumber()];
1604  PointerType *ThisArgType = dyn_cast<PointerType>(Ty);
1605  return (!ThisArgType ||
1607  }
1608  case IITDescriptor::PtrToElt: {
1609  if (D.getArgumentNumber() >= ArgTys.size())
1610  return IsDeferredCheck || DeferCheck(Ty);
1612  dyn_cast<VectorType> (ArgTys[D.getArgumentNumber()]);
1613  PointerType *ThisArgType = dyn_cast<PointerType>(Ty);
1614 
1615  if (!ThisArgType || !ReferenceType)
1616  return true;
1617  return !ThisArgType->isOpaqueOrPointeeTypeMatches(
1618  ReferenceType->getElementType());
1619  }
1621  unsigned RefArgNumber = D.getRefArgNumber();
1622  if (RefArgNumber >= ArgTys.size()) {
1623  if (IsDeferredCheck)
1624  return true;
1625  // If forward referencing, already add the pointer type and
1626  // defer the checks for later.
1627  ArgTys.push_back(Ty);
1628  return DeferCheck(Ty);
1629  }
1630 
1631  if (!IsDeferredCheck) {
1632  assert(D.getOverloadArgNumber() == ArgTys.size() &&
1633  "Table consistency error");
1634  ArgTys.push_back(Ty);
1635  }
1636 
1637  auto *ReferenceType = dyn_cast<VectorType>(ArgTys[RefArgNumber]);
1638  auto *ThisArgType = dyn_cast<PointerType>(Ty);
1639  if (!ThisArgType || !ReferenceType)
1640  return true;
1641  return !ThisArgType->isOpaqueOrPointeeTypeMatches(
1642  ReferenceType->getElementType());
1643  }
1645  unsigned RefArgNumber = D.getRefArgNumber();
1646  if (RefArgNumber >= ArgTys.size()) {
1647  if (IsDeferredCheck)
1648  return true;
1649  // If forward referencing, already add the pointer-vector type and
1650  // defer the checks for later.
1651  ArgTys.push_back(Ty);
1652  return DeferCheck(Ty);
1653  }
1654 
1655  if (!IsDeferredCheck){
1656  assert(D.getOverloadArgNumber() == ArgTys.size() &&
1657  "Table consistency error");
1658  ArgTys.push_back(Ty);
1659  }
1660 
1661  // Verify the overloaded type "matches" the Ref type.
1662  // i.e. Ty is a vector with the same width as Ref.
1663  // Composed of pointers to the same element type as Ref.
1664  auto *ReferenceType = dyn_cast<VectorType>(ArgTys[RefArgNumber]);
1665  auto *ThisArgVecTy = dyn_cast<VectorType>(Ty);
1666  if (!ThisArgVecTy || !ReferenceType ||
1667  (ReferenceType->getElementCount() != ThisArgVecTy->getElementCount()))
1668  return true;
1669  PointerType *ThisArgEltTy =
1670  dyn_cast<PointerType>(ThisArgVecTy->getElementType());
1671  if (!ThisArgEltTy)
1672  return true;
1673  return !ThisArgEltTy->isOpaqueOrPointeeTypeMatches(
1674  ReferenceType->getElementType());
1675  }
1677  if (D.getArgumentNumber() >= ArgTys.size())
1678  return IsDeferredCheck ? true : DeferCheck(Ty);
1679  auto *ReferenceType = dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
1680  return !ReferenceType || Ty != ReferenceType->getElementType();
1681  }
1684  // If this is a forward reference, defer the check for later.
1685  if (D.getArgumentNumber() >= ArgTys.size())
1686  return IsDeferredCheck || DeferCheck(Ty);
1687 
1688  Type *NewTy = ArgTys[D.getArgumentNumber()];
1689  if (auto *VTy = dyn_cast<VectorType>(NewTy)) {
1690  int SubDivs = D.Kind == IITDescriptor::Subdivide2Argument ? 1 : 2;
1691  NewTy = VectorType::getSubdividedVectorType(VTy, SubDivs);
1692  return Ty != NewTy;
1693  }
1694  return true;
1695  }
1697  if (D.getArgumentNumber() >= ArgTys.size())
1698  return IsDeferredCheck || DeferCheck(Ty);
1699  auto *ReferenceType = dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
1700  auto *ThisArgVecTy = dyn_cast<VectorType>(Ty);
1701  if (!ThisArgVecTy || !ReferenceType)
1702  return true;
1703  return ThisArgVecTy != VectorType::getInteger(ReferenceType);
1704  }
1705  }
1706  llvm_unreachable("unhandled");
1707 }
1708 
1712  SmallVectorImpl<Type *> &ArgTys) {
1714  if (matchIntrinsicType(FTy->getReturnType(), Infos, ArgTys, DeferredChecks,
1715  false))
1717 
1718  unsigned NumDeferredReturnChecks = DeferredChecks.size();
1719 
1720  for (auto Ty : FTy->params())
1721  if (matchIntrinsicType(Ty, Infos, ArgTys, DeferredChecks, false))
1723 
1724  for (unsigned I = 0, E = DeferredChecks.size(); I != E; ++I) {
1725  DeferredIntrinsicMatchPair &Check = DeferredChecks[I];
1726  if (matchIntrinsicType(Check.first, Check.second, ArgTys, DeferredChecks,
1727  true))
1728  return I < NumDeferredReturnChecks ? MatchIntrinsicTypes_NoMatchRet
1730  }
1731 
1733 }
1734 
1735 bool
1738  // If there are no descriptors left, then it can't be a vararg.
1739  if (Infos.empty())
1740  return isVarArg;
1741 
1742  // There should be only one descriptor remaining at this point.
1743  if (Infos.size() != 1)
1744  return true;
1745 
1746  // Check and verify the descriptor.
1747  IITDescriptor D = Infos.front();
1748  Infos = Infos.slice(1);
1749  if (D.Kind == IITDescriptor::VarArg)
1750  return !isVarArg;
1751 
1752  return true;
1753 }
1754 
1756  SmallVectorImpl<Type *> &ArgTys) {
1757  Intrinsic::ID ID = F->getIntrinsicID();
1758  if (!ID)
1759  return false;
1760 
1764 
1765  if (Intrinsic::matchIntrinsicSignature(F->getFunctionType(), TableRef,
1766  ArgTys) !=
1768  return false;
1769  }
1770  if (Intrinsic::matchIntrinsicVarArg(F->getFunctionType()->isVarArg(),
1771  TableRef))
1772  return false;
1773  return true;
1774 }
1775 
1777  SmallVector<Type *, 4> ArgTys;
1778  if (!getIntrinsicSignature(F, ArgTys))
1779  return None;
1780 
1781  Intrinsic::ID ID = F->getIntrinsicID();
1782  StringRef Name = F->getName();
1783  std::string WantedName =
1784  Intrinsic::getName(ID, ArgTys, F->getParent(), F->getFunctionType());
1785  if (Name == WantedName)
1786  return None;
1787 
1788  Function *NewDecl = [&] {
1789  if (auto *ExistingGV = F->getParent()->getNamedValue(WantedName)) {
1790  if (auto *ExistingF = dyn_cast<Function>(ExistingGV))
1791  if (ExistingF->getFunctionType() == F->getFunctionType())
1792  return ExistingF;
1793 
1794  // The name already exists, but is not a function or has the wrong
1795  // prototype. Make place for the new one by renaming the old version.
1796  // Either this old version will be removed later on or the module is
1797  // invalid and we'll get an error.
1798  ExistingGV->setName(WantedName + ".renamed");
1799  }
1800  return Intrinsic::getDeclaration(F->getParent(), ID, ArgTys);
1801  }();
1802 
1803  NewDecl->setCallingConv(F->getCallingConv());
1804  assert(NewDecl->getFunctionType() == F->getFunctionType() &&
1805  "Shouldn't change the signature");
1806  return NewDecl;
1807 }
1808 
1809 /// hasAddressTaken - returns true if there are any uses of this function
1810 /// other than direct calls or invokes to it. Optionally ignores callback
1811 /// uses, assume like pointer annotation calls, and references in llvm.used
1812 /// and llvm.compiler.used variables.
1813 bool Function::hasAddressTaken(const User **PutOffender,
1814  bool IgnoreCallbackUses,
1815  bool IgnoreAssumeLikeCalls, bool IgnoreLLVMUsed,
1816  bool IgnoreARCAttachedCall) const {
1817  for (const Use &U : uses()) {
1818  const User *FU = U.getUser();
1819  if (isa<BlockAddress>(FU))
1820  continue;
1821 
1822  if (IgnoreCallbackUses) {
1823  AbstractCallSite ACS(&U);
1824  if (ACS && ACS.isCallbackCall())
1825  continue;
1826  }
1827 
1828  const auto *Call = dyn_cast<CallBase>(FU);
1829  if (!Call) {
1830  if (IgnoreAssumeLikeCalls) {
1831  if (const auto *FI = dyn_cast<Instruction>(FU)) {
1832  if (FI->isCast() && !FI->user_empty() &&
1833  llvm::all_of(FU->users(), [](const User *U) {
1834  if (const auto *I = dyn_cast<IntrinsicInst>(U))
1835  return I->isAssumeLikeIntrinsic();
1836  return false;
1837  }))
1838  continue;
1839  }
1840  }
1841  if (IgnoreLLVMUsed && !FU->user_empty()) {
1842  const User *FUU = FU;
1843  if (isa<BitCastOperator>(FU) && FU->hasOneUse() &&
1844  !FU->user_begin()->user_empty())
1845  FUU = *FU->user_begin();
1846  if (llvm::all_of(FUU->users(), [](const User *U) {
1847  if (const auto *GV = dyn_cast<GlobalVariable>(U))
1848  return GV->hasName() &&
1849  (GV->getName().equals("llvm.compiler.used") ||
1850  GV->getName().equals("llvm.used"));
1851  return false;
1852  }))
1853  continue;
1854  }
1855  if (PutOffender)
1856  *PutOffender = FU;
1857  return true;
1858  }
1859  if (!Call->isCallee(&U) || Call->getFunctionType() != getFunctionType()) {
1860  if (IgnoreARCAttachedCall &&
1861  Call->isOperandBundleOfType(LLVMContext::OB_clang_arc_attachedcall,
1862  U.getOperandNo()))
1863  continue;
1864 
1865  if (PutOffender)
1866  *PutOffender = FU;
1867  return true;
1868  }
1869  }
1870  return false;
1871 }
1872 
1874  // Check the linkage
1875  if (!hasLinkOnceLinkage() && !hasLocalLinkage() &&
1877  return false;
1878 
1879  // Check if the function is used by anything other than a blockaddress.
1880  for (const User *U : users())
1881  if (!isa<BlockAddress>(U))
1882  return false;
1883 
1884  return true;
1885 }
1886 
1887 /// callsFunctionThatReturnsTwice - Return true if the function has a call to
1888 /// setjmp or other function that gcc recognizes as "returning twice".
1890  for (const Instruction &I : instructions(this))
1891  if (const auto *Call = dyn_cast<CallBase>(&I))
1892  if (Call->hasFnAttr(Attribute::ReturnsTwice))
1893  return true;
1894 
1895  return false;
1896 }
1897 
1900  return cast<Constant>(Op<0>());
1901 }
1902 
1904  setHungoffOperand<0>(Fn);
1905  setValueSubclassDataBit(3, Fn != nullptr);
1906 }
1907 
1910  return cast<Constant>(Op<1>());
1911 }
1912 
1914  setHungoffOperand<1>(PrefixData);
1915  setValueSubclassDataBit(1, PrefixData != nullptr);
1916 }
1917 
1920  return cast<Constant>(Op<2>());
1921 }
1922 
1924  setHungoffOperand<2>(PrologueData);
1925  setValueSubclassDataBit(2, PrologueData != nullptr);
1926 }
1927 
1928 void Function::allocHungoffUselist() {
1929  // If we've already allocated a uselist, stop here.
1930  if (getNumOperands())
1931  return;
1932 
1933  allocHungoffUses(3, /*IsPhi=*/ false);
1935 
1936  // Initialize the uselist with placeholder operands to allow traversal.
1938  Op<0>().set(CPN);
1939  Op<1>().set(CPN);
1940  Op<2>().set(CPN);
1941 }
1942 
1943 template <int Idx>
1944 void Function::setHungoffOperand(Constant *C) {
1945  if (C) {
1946  allocHungoffUselist();
1947  Op<Idx>().set(C);
1948  } else if (getNumOperands()) {
1949  Op<Idx>().set(
1951  }
1952 }
1953 
1954 void Function::setValueSubclassDataBit(unsigned Bit, bool On) {
1955  assert(Bit < 16 && "SubclassData contains only 16 bits");
1956  if (On)
1957  setValueSubclassData(getSubclassDataFromValue() | (1 << Bit));
1958  else
1959  setValueSubclassData(getSubclassDataFromValue() & ~(1 << Bit));
1960 }
1961 
1963  const DenseSet<GlobalValue::GUID> *S) {
1964 #if !defined(NDEBUG)
1965  auto PrevCount = getEntryCount();
1966  assert(!PrevCount.hasValue() || PrevCount->getType() == Count.getType());
1967 #endif
1968 
1969  auto ImportGUIDs = getImportGUIDs();
1970  if (S == nullptr && ImportGUIDs.size())
1971  S = &ImportGUIDs;
1972 
1973  MDBuilder MDB(getContext());
1974  setMetadata(
1975  LLVMContext::MD_prof,
1976  MDB.createFunctionEntryCount(Count.getCount(), Count.isSynthetic(), S));
1977 }
1978 
1980  const DenseSet<GlobalValue::GUID> *Imports) {
1981  setEntryCount(ProfileCount(Count, Type), Imports);
1982 }
1983 
1985  MDNode *MD = getMetadata(LLVMContext::MD_prof);
1986  if (MD && MD->getOperand(0))
1987  if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0))) {
1988  if (MDS->getString().equals("function_entry_count")) {
1989  ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
1990  uint64_t Count = CI->getValue().getZExtValue();
1991  // A value of -1 is used for SamplePGO when there were no samples.
1992  // Treat this the same as unknown.
1993  if (Count == (uint64_t)-1)
1994  return None;
1995  return ProfileCount(Count, PCT_Real);
1996  } else if (AllowSynthetic &&
1997  MDS->getString().equals("synthetic_function_entry_count")) {
1998  ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
1999  uint64_t Count = CI->getValue().getZExtValue();
2000  return ProfileCount(Count, PCT_Synthetic);
2001  }
2002  }
2003  return None;
2004 }
2005 
2008  if (MDNode *MD = getMetadata(LLVMContext::MD_prof))
2009  if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0)))
2010  if (MDS->getString().equals("function_entry_count"))
2011  for (unsigned i = 2; i < MD->getNumOperands(); i++)
2012  R.insert(mdconst::extract<ConstantInt>(MD->getOperand(i))
2013  ->getValue()
2014  .getZExtValue());
2015  return R;
2016 }
2017 
2019  MDBuilder MDB(getContext());
2020  setMetadata(LLVMContext::MD_section_prefix,
2022 }
2023 
2025  if (MDNode *MD = getMetadata(LLVMContext::MD_section_prefix)) {
2026  assert(cast<MDString>(MD->getOperand(0))
2027  ->getString()
2028  .equals("function_section_prefix") &&
2029  "Metadata not match");
2030  return cast<MDString>(MD->getOperand(1))->getString();
2031  }
2032  return None;
2033 }
2034 
2036  return hasFnAttribute(Attribute::NullPointerIsValid);
2037 }
2038 
2039 bool llvm::NullPointerIsDefined(const Function *F, unsigned AS) {
2040  if (F && F->nullPointerIsDefined())
2041  return true;
2042 
2043  if (AS != 0)
2044  return true;
2045 
2046  return false;
2047 }
llvm::Function::getParamAttribute
Attribute getParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const
gets the specified attribute from the list of attributes.
Definition: Function.cpp:660
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:1265
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:626
i
i
Definition: README.txt:29
llvm::Intrinsic::IITDescriptor::AK_AnyVector
@ AK_AnyVector
Definition: Intrinsics.h:161
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:28
IIT_AMX
@ IIT_AMX
Definition: Function.cpp:982
llvm::Intrinsic::remangleIntrinsicFunction
llvm::Optional< Function * > remangleIntrinsicFunction(Function *F)
Definition: Function.cpp:1776
llvm::Argument::hasStructRetAttr
bool hasStructRetAttr() const
Return true if this argument has the sret attribute.
Definition: Function.cpp:256
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:1387
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:127
llvm::Type::DoubleTyID
@ DoubleTyID
64-bit floating point type
Definition: Type.h:59
llvm::AttributeList::removeFnAttributes
LLVM_NODISCARD AttributeList removeFnAttributes(LLVMContext &C, const AttributeMask &AttrsToRemove) const
Remove the specified attribute at the function index from this attribute list.
Definition: Attributes.h:613
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::AttributeList::addRetAttributes
LLVM_NODISCARD AttributeList addRetAttributes(LLVMContext &C, const AttrBuilder &B) const
Add a return value attribute to the list.
Definition: Attributes.h:537
llvm::Argument::hasPassPointeeByValueCopyAttr
bool hasPassPointeeByValueCopyAttr() const
Return true if this argument has the byval, inalloca, or preallocated attribute.
Definition: Function.cpp:138
llvm::Intrinsic::MatchIntrinsicTypes_NoMatchArg
@ MatchIntrinsicTypes_NoMatchArg
Definition: Intrinsics.h:222
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:1324
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::AttributeList::addFnAttribute
LLVM_NODISCARD AttributeList addFnAttribute(LLVMContext &C, Attribute::AttrKind Kind) const
Add a function attribute to the list.
Definition: Attributes.h:495
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:406
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:113
llvm::Value::hasOneUse
bool hasOneUse() const
Return true if there is exactly one use of this value.
Definition: Value.h:434
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:1410
Metadata.h
llvm::Type::isX86_MMXTy
bool isX86_MMXTy() const
Return true if this is X86 MMX.
Definition: Type.h:173
llvm::Function::setSectionPrefix
void setSectionPrefix(StringRef Prefix)
Set the section prefix for this function.
Definition: Function.cpp:2018
llvm::Function::clearGC
void clearGC()
Definition: Function.cpp:696
llvm::Type::getFP128Ty
static Type * getFP128Ty(LLVMContext &C)
Definition: Type.cpp:231
IntrinsicInst.h
llvm::Function::getPrefixData
Constant * getPrefixData() const
Get the prefix data associated with this function.
Definition: Function.cpp:1908
llvm::ElementCount
Definition: TypeSize.h:390
llvm::Intrinsic::IITDescriptor::BFloat
@ BFloat
Definition: Intrinsics.h:123
llvm::APFloatBase::IEEEsingle
static const fltSemantics & IEEEsingle() LLVM_READNONE
Definition: APFloat.cpp:170
llvm::Argument::removeAttrs
void removeAttrs(const AttributeMask &AM)
Definition: Function.cpp:301
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:160
IIT_ANYPTR_TO_ELT
@ IIT_ANYPTR_TO_ELT
Definition: Function.cpp:987
InstIterator.h
ReferenceType
Definition: ItaniumDemangle.h:628
llvm::Function::removeFnAttrs
void removeFnAttrs(const AttributeMask &Attrs)
Definition: Function.cpp:591
T
llvm::Function
Definition: Function.h:60
IIT_EXTERNREF
@ IIT_EXTERNREF
Definition: Function.cpp:985
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:852
DecodeFixedType
static Type * DecodeFixedType(ArrayRef< Intrinsic::IITDescriptor > &Infos, ArrayRef< Type * > Tys, LLVMContext &Context)
Definition: Function.cpp:1261
llvm::Function::getParamDereferenceableBytes
uint64_t getParamDereferenceableBytes(unsigned ArgNo) const
Extract the number of dereferenceable bytes for a parameter.
Definition: Function.h:476
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:727
llvm::Target
Target - Wrapper for Target specific information.
Definition: TargetRegistry.h:140
llvm::Function::eraseFromParent
void eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing module and deletes it.
Definition: Function.cpp:364
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:146
llvm::SmallVector< unsigned char, 8 >
llvm::Intrinsic::IITDescriptor::Quad
@ Quad
Definition: Intrinsics.h:126
llvm::UWTableKind::None
@ None
No unwind table requested.
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:544
llvm::Function::getParamByValType
Type * getParamByValType(unsigned ArgNo) const
Extract the byval type for a parameter.
Definition: Function.h:450
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:637
ErrorHandling.h
makeArgArray
static MutableArrayRef< Argument > makeArgArray(Argument *Args, size_t Count)
Definition: Function.cpp:439
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:682
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:361
llvm::Intrinsic::IITDescriptor::AnyPtrToElt
@ AnyPtrToElt
Definition: Intrinsics.h:145
IIT_I1
@ IIT_I1
Definition: Function.cpp:930
llvm::Type::getTypeID
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:136
llvm::Argument::getParamInAllocaType
Type * getParamInAllocaType() const
If this is an inalloca argument, return its type.
Definition: Function.cpp:219
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:179
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:139
llvm::Intrinsic::IITDescriptor::Metadata
@ Metadata
Definition: Intrinsics.h:121
llvm::Intrinsic::IITDescriptor::PtrToArgument
@ PtrToArgument
Definition: Intrinsics.h:136
true
basic Basic Alias true
Definition: BasicAliasAnalysis.cpp:1909
llvm::Function::getContext
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
Definition: Function.cpp:319
llvm::Function::arg_size
size_t arg_size() const
Definition: Function.h:773
llvm::Argument::getParamAlignment
uint64_t getParamAlignment() const
If this is a byval or inalloca argument, return its alignment.
Definition: Function.cpp:190
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:551
llvm::Intrinsic::lookupLLVMIntrinsicByName
int lookupLLVMIntrinsicByName(ArrayRef< const char * > NameTable, StringRef Name)
Looks up Name in NameTable via binary search.
Definition: IntrinsicInst.cpp:142
Module.h
llvm::AttributeList
Definition: Attributes.h:408
llvm::AttributeMask
Definition: Attributes.h:944
llvm::Type::getTokenTy
static Type * getTokenTy(LLVMContext &C)
Definition: Type.cpp:229
llvm::Argument::getArgNo
unsigned getArgNo() const
Return the index of this formal argument in its containing function.
Definition: Argument.h:46
llvm::Argument::hasInRegAttr
bool hasInRegAttr() const
Return true if this argument has the inreg attribute.
Definition: Function.cpp:261
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:571
llvm::Optional
Definition: APInt.h:33
llvm::Argument::getParent
const Function * getParent() const
Definition: Argument.h:40
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:397
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:98
llvm::Function::hasStackProtectorFnAttr
bool hasStackProtectorFnAttr() const
Returns true if the function has ssp, sspstrong, or sspreq fn attrs.
Definition: Function.cpp:703
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:263
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:633
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:158
llvm::Function::isDefTriviallyDead
bool isDefTriviallyDead() const
isDefTriviallyDead - Return true if it is trivially safe to remove this function definition from the ...
Definition: Function.cpp:1873
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:119
llvm::Intrinsic::IITDescriptor::Void
@ Void
Definition: Intrinsics.h:117
IIT_METADATA
@ IIT_METADATA
Definition: Function.cpp:950
llvm::Type::getNonOpaquePointerElementType
Type * getNonOpaquePointerElementType() const
Only use this method in code that is not reachable with opaque pointers, or part of deprecated method...
Definition: Type.h:382
llvm::Type::isMetadataTy
bool isMetadataTy() const
Return true if this is 'metadata'.
Definition: Type.h:185
Use.h
llvm::Intrinsic::IITDescriptor::AK_MatchType
@ AK_MatchType
Definition: Intrinsics.h:163
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:1755
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:159
llvm::ArrayRef::data
const T * data() const
Definition: ArrayRef.h:161
llvm::Function::addAttributeAtIndex
void addAttributeAtIndex(unsigned i, Attribute Attr)
adds the attribute to the list of attributes.
Definition: Function.cpp:531
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::Intrinsic::IITDescriptor::Float
@ Float
Definition: Intrinsics.h:124
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:55
llvm::Function::addFnAttrs
void addFnAttrs(const AttrBuilder &Attrs)
Add function attributes to this function.
Definition: Function.cpp:547
llvm::Intrinsic::MatchIntrinsicTypes_NoMatchRet
@ MatchIntrinsicTypes_NoMatchRet
Definition: Intrinsics.h:221
llvm::parseDenormalFPAttribute
DenormalMode parseDenormalFPAttribute(StringRef Str)
Returns the denormal mode to use for inputs and outputs.
Definition: FloatingPointMode.h:176
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
llvm::Intrinsic::IITDescriptor::AK_AnyPointer
@ AK_AnyPointer
Definition: Intrinsics.h:162
llvm::Function::setGC
void setGC(std::string Str)
Definition: Function.cpp:691
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:688
llvm::Type::getMetadataTy
static Type * getMetadataTy(LLVMContext &C)
Definition: Type.cpp:228
llvm::Intrinsic::getType
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Return the function type for an intrinsic.
Definition: Function.cpp:1366
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:1607
llvm::UWTableKind
UWTableKind
Definition: CodeGen.h:100
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:234
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:159
llvm::Function::PCT_Synthetic
@ PCT_Synthetic
Definition: Function.h:248
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:241
llvm::MutableArrayRef
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:306
llvm::Argument::hasZExtAttr
bool hasZExtAttr() const
Return true if this argument has the zext attribute.
Definition: Function.cpp:269
llvm::Argument::getParamStackAlign
MaybeAlign getParamStackAlign() const
Definition: Function.cpp:200
Constants.h
llvm::Function::stealArgumentListFrom
void stealArgumentListFrom(Function &Src)
Steal arguments from another function.
Definition: Function.cpp:464
llvm::Intrinsic::IITDescriptor::Struct_NumElements
unsigned Struct_NumElements
Definition: Intrinsics.h:152
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::Type::getPPC_FP128Ty
static Type * getPPC_FP128Ty(LLVMContext &C)
Definition: Type.cpp:232
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::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:990
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:227
llvm::GlobalObject
Definition: GlobalObject.h:27
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:123
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:246
IIT_STRUCT9
@ IIT_STRUCT9
Definition: Function.cpp:980
SymbolTableListTraitsImpl.h
llvm::LLVMContext::OB_clang_arc_attachedcall
@ OB_clang_arc_attachedcall
Definition: LLVMContext.h:96
Check
#define Check(C,...)
Definition: Lint.cpp:170
llvm::Function::removeRetAttrs
void removeRetAttrs(const AttributeMask &Attrs)
removes the attributes from the return value list of attributes.
Definition: Function.cpp:603
llvm::Value::uses
iterator_range< use_iterator > uses()
Definition: Value.h:376
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:595
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:651
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:224
IIT_Done
@ IIT_Done
Definition: Function.cpp:929
llvm::Type::isTokenTy
bool isTokenTy() const
Return true if this is 'token'.
Definition: Type.h:188
llvm::Instruction
Definition: Instruction.h:42
llvm::AttributeList::hasFnAttr
bool hasFnAttr(Attribute::AttrKind Kind) const
Return true if the attribute exists for the function.
Definition: Attributes.cpp:1378
llvm::LLVMContext::getGC
const std::string & getGC(const Function &Fn)
Return the GC for a function.
Definition: LLVMContext.cpp:323
MDBuilder.h
llvm::APInt::getZExtValue
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1478
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:711
llvm::Function::removeParamAttr
void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
removes the attribute from the list of attributes.
Definition: Function.cpp:607
llvm::Value::setName
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:372
llvm::Function::hasPersonalityFn
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:777
llvm::AttributeSet::getInAllocaType
Type * getInAllocaType() const
Definition: Attributes.cpp:713
llvm::FunctionType::params
ArrayRef< Type * > params() const
Definition: DerivedTypes.h:130
llvm::Argument::getAttribute
Attribute getAttribute(Attribute::AttrKind Kind) const
Definition: Function.cpp:311
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:248
Info
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
llvm::Intrinsic::IITDescriptor::PPCQuad
@ PPCQuad
Definition: Intrinsics.h:144
llvm::Argument::hasNestAttr
bool hasNestAttr() const
Return true if this argument has the nest attribute.
Definition: Function.cpp:236
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:646
llvm::AttributeList::removeParamAttributes
LLVM_NODISCARD AttributeList removeParamAttributes(LLVMContext &C, unsigned ArgNo, const AttributeMask &AttrsToRemove) const
Remove the specified attribute at the specified arg index from this attribute list.
Definition: Attributes.h:662
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:1333
llvm::Type::getInt1PtrTy
static PointerType * getInt1PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:287
llvm::Function::getSectionPrefix
Optional< StringRef > getSectionPrefix() const
Get the section prefix for this function.
Definition: Function.cpp:2024
llvm::PointerType::isOpaque
bool isOpaque() const
Definition: DerivedTypes.h:673
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:812
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:194
llvm::Attribute::getValueAsString
StringRef getValueAsString() const
Return the attribute's value as a string.
Definition: Attributes.cpp:305
llvm::None
const NoneType None
Definition: None.h:24
llvm::GlobalValue::IntID
Intrinsic::ID IntID
The intrinsic ID for this subclass (which must be a Function).
Definition: GlobalValue.h:155
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:460
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
llvm::AttributeList::removeRetAttributes
LLVM_NODISCARD AttributeList removeRetAttributes(LLVMContext &C, const AttributeMask &AttrsToRemove) const
Remove the specified attribute at the return value index from this attribute list.
Definition: Attributes.h:639
Type.h
llvm::Argument::hasByRefAttr
bool hasByRefAttr() const
Return true if this argument has the byref attribute.
Definition: Function.cpp:113
IIT_PPCF128
@ IIT_PPCF128
Definition: Function.cpp:983
llvm::Function::hasPrologueData
bool hasPrologueData() const
Check whether this function has prologue data.
Definition: Function.h:795
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:516
llvm::Function::getAttributes
AttributeList getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:314
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:230
llvm::Argument::getParamStructRetType
Type * getParamStructRetType() const
If this is an sret argument, return its type.
Definition: Function.cpp:209
llvm::Function::getGC
const std::string & getGC() const
Definition: Function.cpp:686
llvm::Type::isIntegerTy
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:191
llvm::MDNode::getOperand
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1204
llvm::Intrinsic::MatchIntrinsicTypes_Match
@ MatchIntrinsicTypes_Match
Definition: Intrinsics.h:220
llvm::Argument::hasAttribute
bool hasAttribute(Attribute::AttrKind Kind) const
Check if an argument has a given attribute.
Definition: Function.cpp:307
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
IIT_F128
@ IIT_F128
Definition: Function.cpp:972
llvm::Intrinsic::IITDescriptor::get
static IITDescriptor get(IITDescriptorKind K, unsigned Field)
Definition: Intrinsics.h:196
llvm::Function::hasFnAttribute
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.cpp:625
BasicBlock.h
llvm::cl::opt
Definition: CommandLine.h:1392
llvm::GlobalValue::hasAvailableExternallyLinkage
bool hasAvailableExternallyLinkage() const
Definition: GlobalValue.h:434
llvm::ProfileCount
Function::ProfileCount ProfileCount
Definition: SampleProfileLoaderBaseImpl.h:47
llvm::Function::getEntryCount
Optional< ProfileCount > getEntryCount(bool AllowSynthetic=false) const
Get the entry count for this function.
Definition: Function.cpp:1984
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:642
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::StringRef::empty
constexpr LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
llvm::SymbolTableListTraits
Definition: GlobalAlias.h:26
uint64_t
llvm::Intrinsic::matchIntrinsicVarArg
bool matchIntrinsicVarArg(bool isVarArg, ArrayRef< IITDescriptor > &Infos)
Verify if the intrinsic has variable arguments.
Definition: Function.cpp:1736
llvm::Function::hasPrefixData
bool hasPrefixData() const
Check whether this function has prefix data.
Definition: Function.h:786
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:509
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:50
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:577
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:565
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:306
llvm::ConstantPointerNull::get
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
Definition: Constants.cpp:1755
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:1228
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
IIT_FUNCREF
@ IIT_FUNCREF
Definition: Function.cpp:986
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:72
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:58
llvm::AttrBuilder
Definition: Attributes.h:1005
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:665
llvm::Intrinsic::IITDescriptor::AK_AnyInteger
@ AK_AnyInteger
Definition: Intrinsics.h:159
llvm::DenormalMode
Represent subnormal handling kind for floating point instruction inputs and outputs.
Definition: FloatingPointMode.h:69
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:432
llvm::LLVMContext::setGC
void setGC(const Function &Fn, std::string GCName)
Define the GC for a function.
Definition: LLVMContext.cpp:313
llvm::Argument::hasNoFreeAttr
bool hasNoFreeAttr() const
Return true if this argument has the nofree attribute.
Definition: Function.cpp:251
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:132
llvm::Type::isHalfTy
bool isHalfTy() const
Return true if this is 'half', a 16-bit IEEE fp type.
Definition: Type.h:142
llvm::GlobalValue::Linkage
unsigned Linkage
Definition: GlobalValue.h:93
llvm::Intrinsic::isLeaf
bool isLeaf(ID id)
Returns true if the intrinsic is a leaf, i.e.
Definition: Function.cpp:1393
llvm::Argument::removeAttr
void removeAttr(Attribute::AttrKind Kind)
Remove attributes from an argument.
Definition: Function.cpp:297
llvm::Function::Create
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:137
llvm::Function::ProfileCountType
ProfileCountType
Definition: Function.h:248
llvm::FramePointerKind::All
@ All
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::GlobalValue::hasLocalLinkage
bool hasLocalLinkage() const
Definition: GlobalValue.h:450
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:769
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:86
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:385
llvm::Type::isVoidTy
bool isVoidTy() const
Return true if this is 'void'.
Definition: Type.h:139
llvm::Function::setPersonalityFn
void setPersonalityFn(Constant *Fn)
Definition: Function.cpp:1903
llvm::Intrinsic::IITDescriptor::AMX
@ AMX
Definition: Intrinsics.h:143
DeferredIntrinsicMatchPair
std::pair< Type *, ArrayRef< Intrinsic::IITDescriptor > > DeferredIntrinsicMatchPair
Definition: Function.cpp:1432
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::MDNode
Metadata node.
Definition: Metadata.h:937
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:1323
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:205
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:336
llvm::Function::setEntryCount
void setEntryCount(ProfileCount Count, const DenseSet< GlobalValue::GUID > *Imports=nullptr)
Set the entry count for this function.
Definition: Function.cpp:1962
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:1614
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:242
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::Value::getType
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
llvm::Argument::getParamByRefType
Type * getParamByRefType() const
If this is a byref argument, return its type.
Definition: Function.cpp:214
Compiler.h
llvm::Function::getParamAlign
MaybeAlign getParamAlign(unsigned ArgNo) const
Definition: Function.h:441
llvm::ilist_node_impl< ilist_detail::compute_node_options< Function, Options... >::type >::getIterator
self_iterator getIterator()
Definition: ilist_node.h:82
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:1229
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:176
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:262
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:559
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:1813
llvm::Function::callsFunctionThatReturnsTwice
bool callsFunctionThatReturnsTwice() const
callsFunctionThatReturnsTwice - Return true if the function has a call to setjmp or other function th...
Definition: Function.cpp:1889
llvm::Value::setMetadata
void setMetadata(unsigned KindID, MDNode *Node)
Set a particular kind of metadata attachment.
Definition: Metadata.cpp:1266
LLVM_FALLTHROUGH
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:280
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:305
llvm::Type::getContext
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:128
llvm::ArgInfo
Helper struct shared between Function Specialization and SCCP Solver.
Definition: SCCPSolver.h:47
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:752
IIT_V3
@ IIT_V3
Definition: Function.cpp:984
llvm::Function::setIsMaterializable
void setIsMaterializable(bool V)
Definition: Function.h:193
llvm::ArrayRef::front
const T & front() const
front - Get the first element.
Definition: ArrayRef.h:167
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:671
llvm::Function::ProfileCount::getCount
uint64_t getCount() const
Definition: Function.h:261
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:160
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:283
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:106
name
static const char * name
Definition: SVEIntrinsicOpts.cpp:74
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:1764
llvm::Function::getParamAlignment
uint64_t getParamAlignment(unsigned ArgNo) const
Extract the alignment for a call or parameter (0=unknown).
Definition: Function.h:435
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:563
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:709
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
llvm::Function::removeAttributeAtIndex
void removeAttributeAtIndex(unsigned i, Attribute::AttrKind Kind)
removes the attribute from the list of attributes.
Definition: Function.cpp:575
llvm::Type::isFloatTy
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
Definition: Type.h:148
llvm::AttributeSet::getByRefType
Type * getByRefType() const
Definition: Attributes.cpp:697
llvm::Type::getHalfTy
static Type * getHalfTy(LLVMContext &C)
Definition: Type.cpp:224
IIT_HALF_VEC_ARG
@ IIT_HALF_VEC_ARG
Definition: Function.cpp:961
llvm::AttributeSet::getByValType
Type * getByValType() const
Definition: Attributes.cpp:701
llvm::Type::isIntOrIntVectorTy
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
Definition: Type.h:197
llvm::Function::getParamDereferenceableOrNullBytes
uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const
Extract the number of dereferenceable_or_null bytes for a parameter.
Definition: Function.h:483
llvm::Argument::hasNonNullAttr
bool hasNonNullAttr(bool AllowUndefOrPoison=true) const
Return true if this argument has the nonnull attribute.
Definition: Function.cpp:95
Casting.h
llvm::Argument::hasByValAttr
bool hasByValAttr() const
Return true if this argument has the byval attribute.
Definition: Function.cpp:108
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:204
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:620
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:728
llvm::Type::isDoubleTy
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
Definition: Type.h:151
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:744
IIT_MMX
@ IIT_MMX
Definition: Function.cpp:948
llvm::Type::isPPC_FP128Ty
bool isPPC_FP128Ty() const
Return true if this is powerpc long double.
Definition: Type.h:160
llvm::Function::getFunctionType
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:175
llvm::AttributeList::addRetAttribute
LLVM_NODISCARD AttributeList addRetAttribute(LLVMContext &C, Attribute::AttrKind Kind) const
Add a return value attribute to the list.
Definition: Attributes.h:523
llvm::AttributeList::getAttributeAtIndex
Attribute getAttributeAtIndex(unsigned Index, Attribute::AttrKind Kind) const
Return the attribute object that exists at the given index.
Definition: Attributes.cpp:1391
llvm::Function::addRetAttrs
void addRetAttrs(const AttrBuilder &Attrs)
Add return value attributes to this function.
Definition: Function.cpp:559
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:443
llvm::Type::getBFloatTy
static Type * getBFloatTy(LLVMContext &C)
Definition: Type.cpp:225
llvm::Function::getParamStackAlign
MaybeAlign getParamStackAlign(unsigned ArgNo) const
Definition: Function.h:445
llvm::Function::getPersonalityFn
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1898
llvm::Function::getInstructionCount
unsigned getInstructionCount() const
Returns the number of non-debug IR instructions in this function.
Definition: Function.cpp:323
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:372
llvm::LLVMContext::deleteGC
void deleteGC(const Function &Fn)
Remove the GC for a function.
Definition: LLVMContext.cpp:327
llvm::Function::getParamByRefType
Type * getParamByRefType(unsigned ArgNo) const
Extract the byref type for a parameter.
Definition: Function.h:465
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:475
llvm::MDBuilder
Definition: MDBuilder.h:35
llvm::Function::removeParamAttrs
void removeParamAttrs(unsigned ArgNo, const AttributeMask &Attrs)
removes the attribute from the list of attributes.
Definition: Function.cpp:615
llvm::GlobalValue::HasLLVMReservedName
unsigned HasLLVMReservedName
True if the function's name starts with "llvm.".
Definition: GlobalValue.h:104
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:222
llvm::Function::nullPointerIsDefined
bool nullPointerIsDefined() const
Check if null pointer dereferencing is considered undefined behavior for the function.
Definition: Function.cpp:2035
llvm::User::getNumOperands
unsigned getNumOperands() const
Definition: User.h:191
llvm::AttributeSet
Definition: Attributes.h:274
llvm::Argument::getPointeeInMemoryValueType
Type * getPointeeInMemoryValueType() const
If hasPointeeInMemoryValueAttr returns true, the in-memory ABI type is returned.
Definition: Function.cpp:184
matchIntrinsicType
static bool matchIntrinsicType(Type *Ty, ArrayRef< Intrinsic::IITDescriptor > &Infos, SmallVectorImpl< Type * > &ArgTys, SmallVectorImpl< DeferredIntrinsicMatchPair > &DeferredChecks, bool IsDeferredCheck)
Definition: Function.cpp:1434
SmallVector.h
llvm::Function::setPrefixData
void setPrefixData(Constant *PrefixData)
Definition: Function.cpp:1913
llvm::Intrinsic::IITDescriptor::Token
@ Token
Definition: Intrinsics.h:120
llvm::Type::isBFloatTy
bool isBFloatTy() const
Return true if this is 'bfloat', a 16-bit bfloat type.
Definition: Type.h:145
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:749
llvm::Function::removeFnAttr
void removeFnAttr(Attribute::AttrKind Kind)
Remove function attributes from this function.
Definition: Function.cpp:583
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:599
llvm::Argument::hasNoAliasAttr
bool hasNoAliasAttr() const
Return true if this argument has the noalias attribute.
Definition: Function.cpp:241
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:164
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:1710
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:535
llvm::GlobalObject::copyAttributesFrom
void copyAttributesFrom(const GlobalObject *Src)
Definition: Globals.cpp:132
llvm::Intrinsic::IITDescriptor::getVector
static IITDescriptor getVector(unsigned Width, bool IsScalable)
Definition: Intrinsics.h:208
llvm::Argument::getParamAlign
MaybeAlign getParamAlign() const
If this is a byval or inalloca argument, return its alignment.
Definition: Function.cpp:195
IIT_TOKEN
@ IIT_TOKEN
Definition: Function.cpp:949
llvm::GlobalValue::hasLinkOnceLinkage
bool hasLinkOnceLinkage() const
Definition: GlobalValue.h:437
llvm::Function::removeFromParent
void removeFromParent()
removeFromParent - This method unlinks 'this' from the containing module, but does not delete it.
Definition: Function.cpp:360
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:1193
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
llvm::AttributeSet::getStructRetType
Type * getStructRetType() const
Definition: Attributes.cpp:705
llvm::GlobalValue::getType
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:270
DerivedTypes.h
llvm::Function::setPrologueData
void setPrologueData(Constant *PrologueData)
Definition: Function.cpp:1923
llvm::Function::recalculateIntrinsicID
void recalculateIntrinsicID()
Recalculate the ID for this function if it is an Intrinsic defined in llvm/Intrinsics....
Definition: Function.cpp:789
llvm::IntegerType::get
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:311
llvm::Function::getPrologueData
Constant * getPrologueData() const
Get the prologue data associated with this function.
Definition: Function.cpp:1918
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:394
llvm::FramePointerKind::None
@ None
llvm::Function::ProfileCount
Class to represent profile counts.
Definition: Function.h:253
llvm::cl::desc
Definition: CommandLine.h:405
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:2039
llvm::Type::getX86_MMXTy
static Type * getX86_MMXTy(LLVMContext &C)
Definition: Type.cpp:233
llvm::AMDGPU::VGPRIndexMode::Id
Id
Definition: SIDefines.h:238
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:734
SymbolTableListTraits.h
llvm::Intrinsic::MatchIntrinsicTypesResult
MatchIntrinsicTypesResult
Definition: Intrinsics.h:219
llvm::AttributeList::getParamAttrs
AttributeSet getParamAttrs(unsigned ArgNo) const
The attributes for the argument or parameter at the given index are returned.
Definition: Attributes.cpp:1353
llvm::Argument::onlyReadsMemory
bool onlyReadsMemory() const
Return true if this argument has the readonly or readnone attribute.
Definition: Function.cpp:277
llvm::MDString
A single uniqued string.
Definition: Metadata.h:612
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:793
IIT_STRUCT3
@ IIT_STRUCT3
Definition: Function.cpp:953
Value.h
IIT_V2
@ IIT_V2
Definition: Function.cpp:938
TableRef
Definition: AMDGPULibCalls.cpp:379
llvm::Function::getParamStructRetType
Type * getParamStructRetType(unsigned ArgNo) const
Extract the sret type for a parameter.
Definition: Function.h:455
llvm::Function::setAttributes
void setAttributes(AttributeList Attrs)
Set the attribute list for this Function.
Definition: Function.h:317
llvm::Argument::hasSExtAttr
bool hasSExtAttr() const
Return true if this argument has the sext attribute.
Definition: Function.cpp:273
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:74
llvm::Type::isFP128Ty
bool isFP128Ty() const
Return true if this is 'fp128'.
Definition: Type.h:157
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:668
llvm::Type::HalfTyID
@ HalfTyID
16-bit floating point type
Definition: Type.h:56
llvm::Value::users
iterator_range< user_iterator > users()
Definition: Value.h:421
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:783
llvm::Type::getFloatTy
static Type * getFloatTy(LLVMContext &C)
Definition: Type.cpp:226
llvm::ArrayRef::end
iterator end() const
Definition: ArrayRef.h:153
llvm::Intrinsic::IITDescriptor::getArgumentKind
ArgKind getArgumentKind() const
Definition: Intrinsics.h:175
llvm::Type::isX86_AMXTy
bool isX86_AMXTy() const
Return true if this is X86 AMX.
Definition: Type.h:176
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:265
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:289
llvm::Use
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43
llvm::SmallVectorImpl::emplace_back
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:927
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:2006
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37