LLVM  14.0.0git
Type.cpp
Go to the documentation of this file.
1 //===- Type.cpp - Implement the Type class --------------------------------===//
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 Type class for the IR library.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/IR/Type.h"
14 #include "LLVMContextImpl.h"
15 #include "llvm/ADT/APInt.h"
16 #include "llvm/ADT/None.h"
17 #include "llvm/ADT/SmallString.h"
18 #include "llvm/ADT/StringMap.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/IR/Constant.h"
21 #include "llvm/IR/Constants.h"
22 #include "llvm/IR/DerivedTypes.h"
23 #include "llvm/IR/LLVMContext.h"
24 #include "llvm/IR/Module.h"
25 #include "llvm/IR/Value.h"
26 #include "llvm/Support/Casting.h"
28 #include "llvm/Support/TypeSize.h"
30 #include <cassert>
31 #include <utility>
32 
33 using namespace llvm;
34 
35 //===----------------------------------------------------------------------===//
36 // Type Class Implementation
37 //===----------------------------------------------------------------------===//
38 
40  switch (IDNumber) {
41  case VoidTyID : return getVoidTy(C);
42  case HalfTyID : return getHalfTy(C);
43  case BFloatTyID : return getBFloatTy(C);
44  case FloatTyID : return getFloatTy(C);
45  case DoubleTyID : return getDoubleTy(C);
46  case X86_FP80TyID : return getX86_FP80Ty(C);
47  case FP128TyID : return getFP128Ty(C);
48  case PPC_FP128TyID : return getPPC_FP128Ty(C);
49  case LabelTyID : return getLabelTy(C);
50  case MetadataTyID : return getMetadataTy(C);
51  case X86_MMXTyID : return getX86_MMXTy(C);
52  case X86_AMXTyID : return getX86_AMXTy(C);
53  case TokenTyID : return getTokenTy(C);
54  default:
55  return nullptr;
56  }
57 }
58 
59 bool Type::isIntegerTy(unsigned Bitwidth) const {
60  return isIntegerTy() && cast<IntegerType>(this)->getBitWidth() == Bitwidth;
61 }
62 
64  if (auto *PTy = dyn_cast<PointerType>(this))
65  return PTy->isOpaque();
66  return false;
67 }
68 
70  // Identity cast means no change so return true
71  if (this == Ty)
72  return true;
73 
74  // They are not convertible unless they are at least first class types
75  if (!this->isFirstClassType() || !Ty->isFirstClassType())
76  return false;
77 
78  // Vector -> Vector conversions are always lossless if the two vector types
79  // have the same size, otherwise not.
80  if (isa<VectorType>(this) && isa<VectorType>(Ty))
82 
83  // 64-bit fixed width vector types can be losslessly converted to x86mmx.
84  if (((isa<FixedVectorType>(this)) && Ty->isX86_MMXTy()) &&
85  getPrimitiveSizeInBits().getFixedSize() == 64)
86  return true;
87  if ((isX86_MMXTy() && isa<FixedVectorType>(Ty)) &&
89  return true;
90 
91  // 8192-bit fixed width vector types can be losslessly converted to x86amx.
92  if (((isa<FixedVectorType>(this)) && Ty->isX86_AMXTy()) &&
93  getPrimitiveSizeInBits().getFixedSize() == 8192)
94  return true;
95  if ((isX86_AMXTy() && isa<FixedVectorType>(Ty)) &&
96  Ty->getPrimitiveSizeInBits().getFixedSize() == 8192)
97  return true;
98 
99  // At this point we have only various mismatches of the first class types
100  // remaining and ptr->ptr. Just select the lossless conversions. Everything
101  // else is not lossless. Conservatively assume we can't losslessly convert
102  // between pointers with different address spaces.
103  if (auto *PTy = dyn_cast<PointerType>(this)) {
104  if (auto *OtherPTy = dyn_cast<PointerType>(Ty))
105  return PTy->getAddressSpace() == OtherPTy->getAddressSpace();
106  return false;
107  }
108  return false; // Other types have no identity values
109 }
110 
111 bool Type::isEmptyTy() const {
112  if (auto *ATy = dyn_cast<ArrayType>(this)) {
113  unsigned NumElements = ATy->getNumElements();
114  return NumElements == 0 || ATy->getElementType()->isEmptyTy();
115  }
116 
117  if (auto *STy = dyn_cast<StructType>(this)) {
118  unsigned NumElements = STy->getNumElements();
119  for (unsigned i = 0; i < NumElements; ++i)
120  if (!STy->getElementType(i)->isEmptyTy())
121  return false;
122  return true;
123  }
124 
125  return false;
126 }
127 
129  switch (getTypeID()) {
130  case Type::HalfTyID: return TypeSize::Fixed(16);
131  case Type::BFloatTyID: return TypeSize::Fixed(16);
132  case Type::FloatTyID: return TypeSize::Fixed(32);
133  case Type::DoubleTyID: return TypeSize::Fixed(64);
134  case Type::X86_FP80TyID: return TypeSize::Fixed(80);
135  case Type::FP128TyID: return TypeSize::Fixed(128);
136  case Type::PPC_FP128TyID: return TypeSize::Fixed(128);
137  case Type::X86_MMXTyID: return TypeSize::Fixed(64);
138  case Type::X86_AMXTyID: return TypeSize::Fixed(8192);
139  case Type::IntegerTyID:
140  return TypeSize::Fixed(cast<IntegerType>(this)->getBitWidth());
143  const VectorType *VTy = cast<VectorType>(this);
144  ElementCount EC = VTy->getElementCount();
146  assert(!ETS.isScalable() && "Vector type should have fixed-width elements");
147  return {ETS.getFixedSize() * EC.getKnownMinValue(), EC.isScalable()};
148  }
149  default: return TypeSize::Fixed(0);
150  }
151 }
152 
153 unsigned Type::getScalarSizeInBits() const {
154  // It is safe to assume that the scalar types have a fixed size.
156 }
157 
159  if (auto *VTy = dyn_cast<VectorType>(this))
160  return VTy->getElementType()->getFPMantissaWidth();
161  assert(isFloatingPointTy() && "Not a floating point type!");
162  if (getTypeID() == HalfTyID) return 11;
163  if (getTypeID() == BFloatTyID) return 8;
164  if (getTypeID() == FloatTyID) return 24;
165  if (getTypeID() == DoubleTyID) return 53;
166  if (getTypeID() == X86_FP80TyID) return 64;
167  if (getTypeID() == FP128TyID) return 113;
168  assert(getTypeID() == PPC_FP128TyID && "unknown fp type");
169  return -1;
170 }
171 
172 bool Type::isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited) const {
173  if (auto *ATy = dyn_cast<ArrayType>(this))
174  return ATy->getElementType()->isSized(Visited);
175 
176  if (auto *VTy = dyn_cast<VectorType>(this))
177  return VTy->getElementType()->isSized(Visited);
178 
179  return cast<StructType>(this)->isSized(Visited);
180 }
181 
182 //===----------------------------------------------------------------------===//
183 // Primitive 'Type' data
184 //===----------------------------------------------------------------------===//
185 
186 Type *Type::getVoidTy(LLVMContext &C) { return &C.pImpl->VoidTy; }
187 Type *Type::getLabelTy(LLVMContext &C) { return &C.pImpl->LabelTy; }
188 Type *Type::getHalfTy(LLVMContext &C) { return &C.pImpl->HalfTy; }
189 Type *Type::getBFloatTy(LLVMContext &C) { return &C.pImpl->BFloatTy; }
190 Type *Type::getFloatTy(LLVMContext &C) { return &C.pImpl->FloatTy; }
191 Type *Type::getDoubleTy(LLVMContext &C) { return &C.pImpl->DoubleTy; }
192 Type *Type::getMetadataTy(LLVMContext &C) { return &C.pImpl->MetadataTy; }
193 Type *Type::getTokenTy(LLVMContext &C) { return &C.pImpl->TokenTy; }
194 Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; }
195 Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; }
196 Type *Type::getPPC_FP128Ty(LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; }
197 Type *Type::getX86_MMXTy(LLVMContext &C) { return &C.pImpl->X86_MMXTy; }
198 Type *Type::getX86_AMXTy(LLVMContext &C) { return &C.pImpl->X86_AMXTy; }
199 
200 IntegerType *Type::getInt1Ty(LLVMContext &C) { return &C.pImpl->Int1Ty; }
201 IntegerType *Type::getInt8Ty(LLVMContext &C) { return &C.pImpl->Int8Ty; }
202 IntegerType *Type::getInt16Ty(LLVMContext &C) { return &C.pImpl->Int16Ty; }
203 IntegerType *Type::getInt32Ty(LLVMContext &C) { return &C.pImpl->Int32Ty; }
204 IntegerType *Type::getInt64Ty(LLVMContext &C) { return &C.pImpl->Int64Ty; }
205 IntegerType *Type::getInt128Ty(LLVMContext &C) { return &C.pImpl->Int128Ty; }
206 
208  return IntegerType::get(C, N);
209 }
210 
212  return getHalfTy(C)->getPointerTo(AS);
213 }
214 
216  return getBFloatTy(C)->getPointerTo(AS);
217 }
218 
220  return getFloatTy(C)->getPointerTo(AS);
221 }
222 
224  return getDoubleTy(C)->getPointerTo(AS);
225 }
226 
228  return getX86_FP80Ty(C)->getPointerTo(AS);
229 }
230 
232  return getFP128Ty(C)->getPointerTo(AS);
233 }
234 
236  return getPPC_FP128Ty(C)->getPointerTo(AS);
237 }
238 
240  return getX86_MMXTy(C)->getPointerTo(AS);
241 }
242 
244  return getX86_AMXTy(C)->getPointerTo(AS);
245 }
246 
247 PointerType *Type::getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS) {
248  return getIntNTy(C, N)->getPointerTo(AS);
249 }
250 
252  return getInt1Ty(C)->getPointerTo(AS);
253 }
254 
256  return getInt8Ty(C)->getPointerTo(AS);
257 }
258 
260  return getInt16Ty(C)->getPointerTo(AS);
261 }
262 
264  return getInt32Ty(C)->getPointerTo(AS);
265 }
266 
268  return getInt64Ty(C)->getPointerTo(AS);
269 }
270 
271 //===----------------------------------------------------------------------===//
272 // IntegerType Implementation
273 //===----------------------------------------------------------------------===//
274 
276  assert(NumBits >= MIN_INT_BITS && "bitwidth too small");
277  assert(NumBits <= MAX_INT_BITS && "bitwidth too large");
278 
279  // Check for the built-in integer types
280  switch (NumBits) {
281  case 1: return cast<IntegerType>(Type::getInt1Ty(C));
282  case 8: return cast<IntegerType>(Type::getInt8Ty(C));
283  case 16: return cast<IntegerType>(Type::getInt16Ty(C));
284  case 32: return cast<IntegerType>(Type::getInt32Ty(C));
285  case 64: return cast<IntegerType>(Type::getInt64Ty(C));
286  case 128: return cast<IntegerType>(Type::getInt128Ty(C));
287  default:
288  break;
289  }
290 
291  IntegerType *&Entry = C.pImpl->IntegerTypes[NumBits];
292 
293  if (!Entry)
294  Entry = new (C.pImpl->Alloc) IntegerType(C, NumBits);
295 
296  return Entry;
297 }
298 
301 }
302 
303 //===----------------------------------------------------------------------===//
304 // FunctionType Implementation
305 //===----------------------------------------------------------------------===//
306 
307 FunctionType::FunctionType(Type *Result, ArrayRef<Type*> Params,
308  bool IsVarArgs)
309  : Type(Result->getContext(), FunctionTyID) {
310  Type **SubTys = reinterpret_cast<Type**>(this+1);
311  assert(isValidReturnType(Result) && "invalid return type for function");
312  setSubclassData(IsVarArgs);
313 
314  SubTys[0] = Result;
315 
316  for (unsigned i = 0, e = Params.size(); i != e; ++i) {
317  assert(isValidArgumentType(Params[i]) &&
318  "Not a valid type for function argument!");
319  SubTys[i+1] = Params[i];
320  }
321 
322  ContainedTys = SubTys;
323  NumContainedTys = Params.size() + 1; // + 1 for result type
324 }
325 
326 // This is the factory function for the FunctionType class.
328  ArrayRef<Type*> Params, bool isVarArg) {
329  LLVMContextImpl *pImpl = ReturnType->getContext().pImpl;
331  FunctionType *FT;
332  // Since we only want to allocate a fresh function type in case none is found
333  // and we don't want to perform two lookups (one for checking if existent and
334  // one for inserting the newly allocated one), here we instead lookup based on
335  // Key and update the reference to the function type in-place to a newly
336  // allocated one if not found.
337  auto Insertion = pImpl->FunctionTypes.insert_as(nullptr, Key);
338  if (Insertion.second) {
339  // The function type was not found. Allocate one and update FunctionTypes
340  // in-place.
341  FT = (FunctionType *)pImpl->Alloc.Allocate(
342  sizeof(FunctionType) + sizeof(Type *) * (Params.size() + 1),
343  alignof(FunctionType));
344  new (FT) FunctionType(ReturnType, Params, isVarArg);
345  *Insertion.first = FT;
346  } else {
347  // The function type was found. Just return it.
348  FT = *Insertion.first;
349  }
350  return FT;
351 }
352 
353 FunctionType *FunctionType::get(Type *Result, bool isVarArg) {
354  return get(Result, None, isVarArg);
355 }
356 
358  return !RetTy->isFunctionTy() && !RetTy->isLabelTy() &&
359  !RetTy->isMetadataTy();
360 }
361 
363  return ArgTy->isFirstClassType();
364 }
365 
366 //===----------------------------------------------------------------------===//
367 // StructType Implementation
368 //===----------------------------------------------------------------------===//
369 
370 // Primitive Constructors.
371 
373  bool isPacked) {
374  LLVMContextImpl *pImpl = Context.pImpl;
376 
377  StructType *ST;
378  // Since we only want to allocate a fresh struct type in case none is found
379  // and we don't want to perform two lookups (one for checking if existent and
380  // one for inserting the newly allocated one), here we instead lookup based on
381  // Key and update the reference to the struct type in-place to a newly
382  // allocated one if not found.
383  auto Insertion = pImpl->AnonStructTypes.insert_as(nullptr, Key);
384  if (Insertion.second) {
385  // The struct type was not found. Allocate one and update AnonStructTypes
386  // in-place.
388  ST->setSubclassData(SCDB_IsLiteral); // Literal struct.
389  ST->setBody(ETypes, isPacked);
390  *Insertion.first = ST;
391  } else {
392  // The struct type was found. Just return it.
393  ST = *Insertion.first;
394  }
395 
396  return ST;
397 }
398 
400  for (Type *Ty : elements()) {
401  if (isa<ScalableVectorType>(Ty))
402  return true;
403  if (auto *STy = dyn_cast<StructType>(Ty))
404  if (STy->containsScalableVectorType())
405  return true;
406  }
407 
408  return false;
409 }
410 
411 void StructType::setBody(ArrayRef<Type*> Elements, bool isPacked) {
412  assert(isOpaque() && "Struct body already set!");
413 
414  setSubclassData(getSubclassData() | SCDB_HasBody);
415  if (isPacked)
416  setSubclassData(getSubclassData() | SCDB_Packed);
417 
418  NumContainedTys = Elements.size();
419 
420  if (Elements.empty()) {
421  ContainedTys = nullptr;
422  return;
423  }
424 
425  ContainedTys = Elements.copy(getContext().pImpl->Alloc).data();
426 }
427 
429  if (Name == getName()) return;
430 
432 
433  using EntryTy = StringMap<StructType *>::MapEntryTy;
434 
435  // If this struct already had a name, remove its symbol table entry. Don't
436  // delete the data yet because it may be part of the new name.
437  if (SymbolTableEntry)
438  SymbolTable.remove((EntryTy *)SymbolTableEntry);
439 
440  // If this is just removing the name, we're done.
441  if (Name.empty()) {
442  if (SymbolTableEntry) {
443  // Delete the old string data.
444  ((EntryTy *)SymbolTableEntry)->Destroy(SymbolTable.getAllocator());
445  SymbolTableEntry = nullptr;
446  }
447  return;
448  }
449 
450  // Look up the entry for the name.
451  auto IterBool =
452  getContext().pImpl->NamedStructTypes.insert(std::make_pair(Name, this));
453 
454  // While we have a name collision, try a random rename.
455  if (!IterBool.second) {
456  SmallString<64> TempStr(Name);
457  TempStr.push_back('.');
458  raw_svector_ostream TmpStream(TempStr);
459  unsigned NameSize = Name.size();
460 
461  do {
462  TempStr.resize(NameSize + 1);
463  TmpStream << getContext().pImpl->NamedStructTypesUniqueID++;
464 
465  IterBool = getContext().pImpl->NamedStructTypes.insert(
466  std::make_pair(TmpStream.str(), this));
467  } while (!IterBool.second);
468  }
469 
470  // Delete the old string data.
471  if (SymbolTableEntry)
472  ((EntryTy *)SymbolTableEntry)->Destroy(SymbolTable.getAllocator());
473  SymbolTableEntry = &*IterBool.first;
474 }
475 
476 //===----------------------------------------------------------------------===//
477 // StructType Helper functions.
478 
481  if (!Name.empty())
482  ST->setName(Name);
483  return ST;
484 }
485 
487  return get(Context, None, isPacked);
488 }
489 
491  StringRef Name, bool isPacked) {
493  ST->setBody(Elements, isPacked);
494  return ST;
495 }
496 
498  return create(Context, Elements, StringRef());
499 }
500 
502  return create(Context, StringRef());
503 }
504 
506  bool isPacked) {
507  assert(!Elements.empty() &&
508  "This method may not be invoked with an empty list");
509  return create(Elements[0]->getContext(), Elements, Name, isPacked);
510 }
511 
513  assert(!Elements.empty() &&
514  "This method may not be invoked with an empty list");
515  return create(Elements[0]->getContext(), Elements, StringRef());
516 }
517 
519  if ((getSubclassData() & SCDB_IsSized) != 0)
520  return true;
521  if (isOpaque())
522  return false;
523 
524  if (Visited && !Visited->insert(const_cast<StructType*>(this)).second)
525  return false;
526 
527  // Okay, our struct is sized if all of the elements are, but if one of the
528  // elements is opaque, the struct isn't sized *yet*, but may become sized in
529  // the future, so just bail out without caching.
530  for (Type *Ty : elements()) {
531  // If the struct contains a scalable vector type, don't consider it sized.
532  // This prevents it from being used in loads/stores/allocas/GEPs.
533  if (isa<ScalableVectorType>(Ty))
534  return false;
535  if (!Ty->isSized(Visited))
536  return false;
537  }
538 
539  // Here we cheat a bit and cast away const-ness. The goal is to memoize when
540  // we find a sized type, as types can only move from opaque to sized, not the
541  // other way.
542  const_cast<StructType*>(this)->setSubclassData(
543  getSubclassData() | SCDB_IsSized);
544  return true;
545 }
546 
548  assert(!isLiteral() && "Literal structs never have names");
549  if (!SymbolTableEntry) return StringRef();
550 
551  return ((StringMapEntry<StructType*> *)SymbolTableEntry)->getKey();
552 }
553 
555  return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
556  !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() &&
557  !ElemTy->isTokenTy();
558 }
559 
561  if (this == Other) return true;
562 
563  if (isPacked() != Other->isPacked())
564  return false;
565 
566  return elements() == Other->elements();
567 }
568 
570  unsigned Idx = (unsigned)cast<Constant>(V)->getUniqueInteger().getZExtValue();
571  assert(indexValid(Idx) && "Invalid structure index!");
572  return getElementType(Idx);
573 }
574 
575 bool StructType::indexValid(const Value *V) const {
576  // Structure indexes require (vectors of) 32-bit integer constants. In the
577  // vector case all of the indices must be equal.
578  if (!V->getType()->isIntOrIntVectorTy(32))
579  return false;
580  if (isa<ScalableVectorType>(V->getType()))
581  return false;
582  const Constant *C = dyn_cast<Constant>(V);
583  if (C && V->getType()->isVectorTy())
584  C = C->getSplatValue();
585  const ConstantInt *CU = dyn_cast_or_null<ConstantInt>(C);
586  return CU && CU->getZExtValue() < getNumElements();
587 }
588 
590  return C.pImpl->NamedStructTypes.lookup(Name);
591 }
592 
593 //===----------------------------------------------------------------------===//
594 // ArrayType Implementation
595 //===----------------------------------------------------------------------===//
596 
597 ArrayType::ArrayType(Type *ElType, uint64_t NumEl)
598  : Type(ElType->getContext(), ArrayTyID), ContainedType(ElType),
599  NumElements(NumEl) {
600  ContainedTys = &ContainedType;
601  NumContainedTys = 1;
602 }
603 
604 ArrayType *ArrayType::get(Type *ElementType, uint64_t NumElements) {
605  assert(isValidElementType(ElementType) && "Invalid type for array element!");
606 
607  LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
608  ArrayType *&Entry =
609  pImpl->ArrayTypes[std::make_pair(ElementType, NumElements)];
610 
611  if (!Entry)
612  Entry = new (pImpl->Alloc) ArrayType(ElementType, NumElements);
613  return Entry;
614 }
615 
617  return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
618  !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() &&
619  !ElemTy->isTokenTy() && !ElemTy->isX86_AMXTy() &&
620  !isa<ScalableVectorType>(ElemTy);
621 }
622 
623 //===----------------------------------------------------------------------===//
624 // VectorType Implementation
625 //===----------------------------------------------------------------------===//
626 
628  : Type(ElType->getContext(), TID), ContainedType(ElType),
629  ElementQuantity(EQ) {
630  ContainedTys = &ContainedType;
631  NumContainedTys = 1;
632 }
633 
635  if (EC.isScalable())
636  return ScalableVectorType::get(ElementType, EC.getKnownMinValue());
637  else
638  return FixedVectorType::get(ElementType, EC.getKnownMinValue());
639 }
640 
642  return ElemTy->isIntegerTy() || ElemTy->isFloatingPointTy() ||
643  ElemTy->isPointerTy();
644 }
645 
646 //===----------------------------------------------------------------------===//
647 // FixedVectorType Implementation
648 //===----------------------------------------------------------------------===//
649 
650 FixedVectorType *FixedVectorType::get(Type *ElementType, unsigned NumElts) {
651  assert(NumElts > 0 && "#Elements of a VectorType must be greater than 0");
652  assert(isValidElementType(ElementType) && "Element type of a VectorType must "
653  "be an integer, floating point, or "
654  "pointer type.");
655 
656  auto EC = ElementCount::getFixed(NumElts);
657 
658  LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
659  VectorType *&Entry = ElementType->getContext()
660  .pImpl->VectorTypes[std::make_pair(ElementType, EC)];
661 
662  if (!Entry)
663  Entry = new (pImpl->Alloc) FixedVectorType(ElementType, NumElts);
664  return cast<FixedVectorType>(Entry);
665 }
666 
667 //===----------------------------------------------------------------------===//
668 // ScalableVectorType Implementation
669 //===----------------------------------------------------------------------===//
670 
672  unsigned MinNumElts) {
673  assert(MinNumElts > 0 && "#Elements of a VectorType must be greater than 0");
674  assert(isValidElementType(ElementType) && "Element type of a VectorType must "
675  "be an integer, floating point, or "
676  "pointer type.");
677 
678  auto EC = ElementCount::getScalable(MinNumElts);
679 
680  LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
681  VectorType *&Entry = ElementType->getContext()
682  .pImpl->VectorTypes[std::make_pair(ElementType, EC)];
683 
684  if (!Entry)
685  Entry = new (pImpl->Alloc) ScalableVectorType(ElementType, MinNumElts);
686  return cast<ScalableVectorType>(Entry);
687 }
688 
689 //===----------------------------------------------------------------------===//
690 // PointerType Implementation
691 //===----------------------------------------------------------------------===//
692 
694  assert(EltTy && "Can't get a pointer to <null> type!");
695  assert(isValidElementType(EltTy) && "Invalid type for pointer element!");
696 
697  LLVMContextImpl *CImpl = EltTy->getContext().pImpl;
698 
699  // Create opaque pointer for pointer to opaque pointer.
700  if (CImpl->ForceOpaquePointers || EltTy->isOpaquePointerTy())
701  return get(EltTy->getContext(), AddressSpace);
702 
703  // Since AddressSpace #0 is the common case, we special case it.
704  PointerType *&Entry = AddressSpace == 0 ? CImpl->PointerTypes[EltTy]
705  : CImpl->ASPointerTypes[std::make_pair(EltTy, AddressSpace)];
706 
707  if (!Entry)
708  Entry = new (CImpl->Alloc) PointerType(EltTy, AddressSpace);
709  return Entry;
710 }
711 
713  LLVMContextImpl *CImpl = C.pImpl;
714 
715  // Since AddressSpace #0 is the common case, we special case it.
716  PointerType *&Entry =
717  AddressSpace == 0
718  ? CImpl->PointerTypes[nullptr]
719  : CImpl->ASPointerTypes[std::make_pair(nullptr, AddressSpace)];
720 
721  if (!Entry)
722  Entry = new (CImpl->Alloc) PointerType(C, AddressSpace);
723  return Entry;
724 }
725 
726 PointerType::PointerType(Type *E, unsigned AddrSpace)
727  : Type(E->getContext(), PointerTyID), PointeeTy(E) {
728  ContainedTys = &PointeeTy;
729  NumContainedTys = 1;
730  setSubclassData(AddrSpace);
731 }
732 
733 PointerType::PointerType(LLVMContext &C, unsigned AddrSpace)
734  : Type(C, PointerTyID), PointeeTy(nullptr) {
735  setSubclassData(AddrSpace);
736 }
737 
738 PointerType *Type::getPointerTo(unsigned AddrSpace) const {
739  return PointerType::get(const_cast<Type*>(this), AddrSpace);
740 }
741 
743  return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
744  !ElemTy->isMetadataTy() && !ElemTy->isTokenTy() &&
745  !ElemTy->isX86_AMXTy();
746 }
747 
749  return isValidElementType(ElemTy) && !ElemTy->isFunctionTy();
750 }
i
i
Definition: README.txt:29
llvm::LLVMContextImpl::Alloc
BumpPtrAllocator Alloc
Definition: LLVMContextImpl.h:1434
llvm::LLVMContext::pImpl
LLVMContextImpl *const pImpl
Definition: LLVMContext.h:70
llvm::Type::FloatTyID
@ FloatTyID
32-bit floating point type
Definition: Type.h:58
llvm::ScalableVectorType
Class to represent scalable SIMD vectors.
Definition: DerivedTypes.h:571
MathExtras.h
llvm::Type::DoubleTyID
@ DoubleTyID
64-bit floating point type
Definition: Type.h:59
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::PointerType::isValidElementType
static bool isValidElementType(Type *ElemTy)
Return true if the specified type is valid as a element type.
Definition: Type.cpp:742
llvm::Type::getInt16PtrTy
static PointerType * getInt16PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:259
llvm::Type::getInt1Ty
static IntegerType * getInt1Ty(LLVMContext &C)
Definition: Type.cpp:200
llvm::StringMapEntry
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
Definition: StringMapEntry.h:98
llvm::StructType::getName
StringRef getName() const
Return the name for this struct type if it has an identity.
Definition: Type.cpp:547
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:372
llvm::Type::getInt8PtrTy
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:255
llvm::Type::isX86_MMXTy
bool isX86_MMXTy() const
Return true if this is X86 MMX.
Definition: Type.h:183
llvm::Type::getFP128Ty
static Type * getFP128Ty(LLVMContext &C)
Definition: Type.cpp:195
llvm::Type::isPointerTy
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:228
llvm::ElementCount
Definition: TypeSize.h:386
llvm::TypeSize::getFixedSize
ScalarTy getFixedSize() const
Definition: TypeSize.h:426
llvm::ArrayRef::copy
ArrayRef< T > copy(Allocator &A)
Definition: ArrayRef.h:180
llvm::Type::VoidTyID
@ VoidTyID
type with no size
Definition: Type.h:63
llvm::StringMap::remove
void remove(MapEntryTy *KeyValue)
remove - Remove the specified key/value pair from the map, but do not erase it.
Definition: StringMap.h:353
StringRef.h
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:693
llvm::StructType::setBody
void setBody(ArrayRef< Type * > Elements, bool isPacked=false)
Specify a body for an opaque identified type.
Definition: Type.cpp:411
llvm::Type::getScalarType
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
Definition: Type.h:319
TypeSize.h
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:327
llvm::Type::getSubclassData
unsigned getSubclassData() const
Definition: Type.h:96
llvm::Type::getTypeID
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:135
APInt.h
llvm::COFF::NameSize
@ NameSize
Definition: COFF.h:58
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
Module.h
llvm::StructType::getTypeByName
static StructType * getTypeByName(LLVMContext &C, StringRef Name)
Return the type with the specified name, or null if there is none by that name.
Definition: Type.cpp:589
llvm::Type::getTokenTy
static Type * getTokenTy(LLVMContext &C)
Definition: Type.cpp:193
llvm::Type::getPrimitiveType
static Type * getPrimitiveType(LLVMContext &C, TypeID IDNumber)
Return a type based on an identifier.
Definition: Type.cpp:39
llvm::VectorType::getElementType
Type * getElementType() const
Definition: DerivedTypes.h:421
getBitWidth
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type.
Definition: ValueTracking.cpp:89
llvm::ArrayType
Class to represent array types.
Definition: DerivedTypes.h:356
llvm::StructType::create
static StructType * create(LLVMContext &Context, StringRef Name)
This creates an identified struct.
Definition: Type.cpp:479
llvm::ScalableVectorType::ScalableVectorType
ScalableVectorType(Type *ElTy, unsigned MinNumElts)
Definition: DerivedTypes.h:573
llvm::Type::isFloatingPointTy
bool isFloatingPointTy() const
Return true if this is one of the six floating-point types.
Definition: Type.h:162
llvm::FixedVectorType
Class to represent fixed width SIMD vectors.
Definition: DerivedTypes.h:524
llvm::Type::getInt32PtrTy
static PointerType * getInt32PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:263
llvm::Type::isMetadataTy
bool isMetadataTy() const
Return true if this is 'metadata'.
Definition: Type.h:195
llvm::Type::getInt8Ty
static IntegerType * getInt8Ty(LLVMContext &C)
Definition: Type.cpp:201
llvm::LLVMContextImpl::AnonStructTypes
StructTypeSet AnonStructTypes
Definition: LLVMContextImpl.h:1442
llvm::LinearPolySize::isScalable
bool isScalable() const
Returns whether the size is scaled by a runtime quantity (vscale).
Definition: TypeSize.h:299
llvm::StructType::setName
void setName(StringRef Name)
Change the name of this type to the specified name, or to a name with a suffix if there is a collisio...
Definition: Type.cpp:428
llvm::Type::getInt32Ty
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:203
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:160
llvm::FunctionType::isVarArg
bool isVarArg() const
Definition: DerivedTypes.h:122
llvm::Type::getBFloatPtrTy
static PointerType * getBFloatPtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:215
llvm::IntegerType::getMask
APInt getMask() const
For example, this is 0xFF for an 8 bit integer, 0xFFFF for i16, etc.
Definition: Type.cpp:299
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
llvm::ConstantInt
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
llvm::Type::getMetadataTy
static Type * getMetadataTy(LLVMContext &C)
Definition: Type.cpp:192
llvm::Type::getFP128PtrTy
static PointerType * getFP128PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:231
llvm::Type::MetadataTyID
@ MetadataTyID
Metadata.
Definition: Type.h:65
llvm::Type::getX86_AMXTy
static Type * getX86_AMXTy(LLVMContext &C)
Definition: Type.cpp:198
llvm::LLVMContextImpl::VectorTypes
DenseMap< std::pair< Type *, ElementCount >, VectorType * > VectorTypes
Definition: LLVMContextImpl.h:1447
llvm::LLVMContextImpl::NamedStructTypes
StringMap< StructType * > NamedStructTypes
Definition: LLVMContextImpl.h:1443
Constants.h
llvm::BumpPtrAllocatorImpl::Allocate
LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void * Allocate(size_t Size, Align Alignment)
Allocate space at the specified alignment.
Definition: Allocator.h:145
SmallString.h
llvm::Type::getPPC_FP128Ty
static Type * getPPC_FP128Ty(LLVMContext &C)
Definition: Type.cpp:196
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::FixedVectorType::FixedVectorType
FixedVectorType(Type *ElTy, unsigned NumElts)
Definition: DerivedTypes.h:526
llvm::StructType::isPacked
bool isPacked() const
Definition: DerivedTypes.h:272
llvm::Type::getDoubleTy
static Type * getDoubleTy(LLVMContext &C)
Definition: Type.cpp:191
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::LLVMContextImpl
Definition: LLVMContextImpl.h:1324
llvm::StructType::isSized
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
isSized - Return true if this is a sized type.
Definition: Type.cpp:518
EQ
#define EQ(a, b)
Definition: regexec.c:112
llvm::Type::getPPC_FP128PtrTy
static PointerType * getPPC_FP128PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:235
llvm::AMDGPU::PALMD::Key
Key
PAL metadata keys.
Definition: AMDGPUMetadata.h:481
llvm::FunctionType::isValidReturnType
static bool isValidReturnType(Type *RetTy)
Return true if the specified type is valid as a return type.
Definition: Type.cpp:357
llvm::Type::isVectorTy
bool isVectorTy() const
True if this is an instance of VectorType.
Definition: Type.h:237
llvm::IntegerType::IntegerType
IntegerType(LLVMContext &C, unsigned NumBits)
Definition: DerivedTypes.h:44
llvm::VectorType::getElementCount
ElementCount getElementCount() const
Return an ElementCount instance to represent the (possibly scalable) number of elements in the vector...
Definition: DerivedTypes.h:626
llvm::TypeSize::Fixed
static TypeSize Fixed(ScalarTy MinVal)
Definition: TypeSize.h:423
llvm::IntegerType
Class to represent integer types.
Definition: DerivedTypes.h:40
llvm::Type::isTokenTy
bool isTokenTy() const
Return true if this is 'token'.
Definition: Type.h:198
llvm::Type::getScalarSizeInBits
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
Definition: Type.cpp:153
LLVMContextImpl.h
llvm::SmallVectorImpl::resize
void resize(size_type N)
Definition: SmallVector.h:606
StringMap.h
llvm::FixedVectorType::get
static FixedVectorType * get(Type *ElementType, unsigned NumElts)
Definition: Type.cpp:650
llvm::Type::getInt1PtrTy
static PointerType * getInt1PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:251
llvm::Type::isFunctionTy
bool isFunctionTy() const
True if this is an instance of FunctionType.
Definition: Type.h:219
llvm::AddressSpace
AddressSpace
Definition: NVPTXBaseInfo.h:21
llvm::Type::BFloatTyID
@ BFloatTyID
16-bit floating point type (7-bit significand)
Definition: Type.h:57
llvm::None
const NoneType None
Definition: None.h:23
llvm::LinearPolySize< ElementCount >::getFixed
static ElementCount getFixed(ScalarTy MinVal)
Definition: TypeSize.h:284
Type.h
llvm::StringMap
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:108
llvm::SmallString< 64 >
llvm::Type::isIntegerTy
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:201
llvm::VectorType::isValidElementType
static bool isValidElementType(Type *ElemTy)
Return true if the specified type is valid as a element type.
Definition: Type.cpp:641
llvm::Type::getIntNPtrTy
static PointerType * getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS=0)
Definition: Type.cpp:247
llvm::VectorType
Base class of all SIMD vector types.
Definition: DerivedTypes.h:388
llvm::Type::getFPMantissaWidth
int getFPMantissaWidth() const
Return the width of the mantissa of this type.
Definition: Type.cpp:158
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::LLVMContextImpl::ForceOpaquePointers
bool ForceOpaquePointers
Definition: LLVMContextImpl.h:1450
llvm::detail::DenseSetImpl::insert_as
std::pair< iterator, bool > insert_as(const ValueT &V, const LookupKeyT &LookupKey)
Alternative version of insert that uses a different (and possibly less expensive) key type.
Definition: DenseSet.h:219
llvm::FunctionTypeKeyInfo::KeyTy
Definition: LLVMContextImpl.h:128
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::Type::getHalfPtrTy
static PointerType * getHalfPtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:211
llvm::StructType::isOpaque
bool isOpaque() const
Return true if this is a type with an identity that has no body specified yet.
Definition: DerivedTypes.h:280
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::LLVMContextImpl::NamedStructTypesUniqueID
unsigned NamedStructTypesUniqueID
Definition: LLVMContextImpl.h:1444
llvm::Type::getInt64PtrTy
static PointerType * getInt64PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:267
llvm::LLVMContextImpl::ASPointerTypes
DenseMap< std::pair< Type *, unsigned >, PointerType * > ASPointerTypes
Definition: LLVMContextImpl.h:1452
llvm::FunctionType::isValidArgumentType
static bool isValidArgumentType(Type *ArgTy)
Return true if the specified type is valid as an argument type.
Definition: Type.cpp:362
llvm::PointerType
Class to represent pointers.
Definition: DerivedTypes.h:631
llvm::Type::getX86_MMXPtrTy
static PointerType * getX86_MMXPtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:239
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::LLVMContextImpl::ArrayTypes
DenseMap< std::pair< Type *, uint64_t >, ArrayType * > ArrayTypes
Definition: LLVMContextImpl.h:1446
llvm::Type::isVoidTy
bool isVoidTy() const
Return true if this is 'void'.
Definition: Type.h:138
llvm::StringMap::getAllocator
AllocatorTy & getAllocator()
Definition: StringMap.h:193
llvm::ArrayType::get
static ArrayType * get(Type *ElementType, uint64_t NumElements)
This static method is the primary way to construct an ArrayType.
Definition: Type.cpp:604
llvm::Type::getX86_FP80Ty
static Type * getX86_FP80Ty(LLVMContext &C)
Definition: Type.cpp:194
llvm::Type::getDoublePtrTy
static PointerType * getDoublePtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:223
llvm::ARM::WinEH::ReturnType
ReturnType
Definition: ARMWinEH.h:25
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:70
llvm::Type::FP128TyID
@ FP128TyID
128-bit floating point type (112-bit significand)
Definition: Type.h:61
llvm::Type::setSubclassData
void setSubclassData(unsigned val)
Definition: Type.h:98
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
None.h
llvm::APInt::getAllOnesValue
static APInt getAllOnesValue(unsigned numBits)
Get the all-ones value.
Definition: APInt.h:567
llvm::StructType
Class to represent struct types.
Definition: DerivedTypes.h:212
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
llvm::raw_svector_ostream::str
StringRef str() const
Return a StringRef for the vector contents.
Definition: raw_ostream.h:681
llvm::Value::getType
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:256
llvm::StructType::indexValid
bool indexValid(const Value *V) const
Definition: Type.cpp:575
llvm::Type::isLabelTy
bool isLabelTy() const
Return true if this is 'label'.
Definition: Type.h:192
llvm::VectorType::VectorType
VectorType(Type *ElType, unsigned EQ, Type::TypeID TID)
Definition: Type.cpp:627
llvm::StructType::getTypeAtIndex
Type * getTypeAtIndex(const Value *V) const
Given an index value into the type, return the type of the element.
Definition: Type.cpp:569
llvm::IntegerType::MAX_INT_BITS
@ MAX_INT_BITS
Maximum number of bits that can be specified.
Definition: DerivedTypes.h:52
llvm::Type::getContext
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:127
llvm::Type::getInt128Ty
static IntegerType * getInt128Ty(LLVMContext &C)
Definition: Type.cpp:205
llvm::Type::getFloatPtrTy
static PointerType * getFloatPtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:219
llvm::StructType::getNumElements
unsigned getNumElements() const
Random access to the elements.
Definition: DerivedTypes.h:326
llvm::Type::IntegerTyID
@ IntegerTyID
Arbitrary bit width integers.
Definition: Type.h:71
llvm::SymbolTableEntry
Symbol info for RuntimeDyld.
Definition: RuntimeDyldImpl.h:217
Constant.h
llvm::Type::NumContainedTys
unsigned NumContainedTys
Keeps track of how many Type*'s there are in the ContainedTys list.
Definition: Type.h:105
llvm::IntegerType::MIN_INT_BITS
@ MIN_INT_BITS
Minimum number of bits that can be specified.
Definition: DerivedTypes.h:51
llvm::Type::getInt64Ty
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:204
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::Type::getIntNTy
static IntegerType * getIntNTy(LLVMContext &C, unsigned N)
Definition: Type.cpp:207
llvm::Type::getHalfTy
static Type * getHalfTy(LLVMContext &C)
Definition: Type.cpp:188
llvm::StructType::elements
ArrayRef< Type * > elements() const
Definition: DerivedTypes.h:318
llvm::Type::FixedVectorTyID
@ FixedVectorTyID
Fixed width SIMD vector type.
Definition: Type.h:76
llvm::Type::isEmptyTy
bool isEmptyTy() const
Return true if this type is empty, that is, it has no elements or all of its elements are empty.
Definition: Type.cpp:111
llvm::Type::isIntOrIntVectorTy
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
Definition: Type.h:207
llvm::TypeSize
Definition: TypeSize.h:417
Casting.h
llvm::AnonStructTypeKeyInfo::KeyTy
Definition: LLVMContextImpl.h:76
llvm::LinearPolySize< ElementCount >::getScalable
static ElementCount getScalable(ScalarTy MinVal)
Definition: TypeSize.h:287
llvm::Type::getPointerTo
PointerType * getPointerTo(unsigned AddrSpace=0) const
Return a pointer to the current type.
Definition: Type.cpp:738
llvm::Type::TokenTyID
@ TokenTyID
Tokens.
Definition: Type.h:68
llvm::Type::getBFloatTy
static Type * getBFloatTy(LLVMContext &C)
Definition: Type.cpp:189
llvm::Type::ContainedTys
Type *const * ContainedTys
A pointer to the array of Types contained by this Type.
Definition: Type.h:112
llvm::Type::getX86_FP80PtrTy
static PointerType * getX86_FP80PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:227
llvm::Type::LabelTyID
@ LabelTyID
Labels.
Definition: Type.h:64
llvm::Type::getVoidTy
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:186
llvm::StructType::isValidElementType
static bool isValidElementType(Type *ElemTy)
Return true if the specified type is valid as a element type.
Definition: Type.cpp:554
llvm::Type::isOpaquePointerTy
bool isOpaquePointerTy() const
True if this is an instance of an opaque PointerType.
Definition: Type.cpp:63
llvm::PointerType::isLoadableOrStorableType
static bool isLoadableOrStorableType(Type *ElemTy)
Return true if we can load or store from a pointer to this type.
Definition: Type.cpp:748
llvm::StructType::containsScalableVectorType
bool containsScalableVectorType() const
Returns true if this struct contains a scalable vector.
Definition: Type.cpp:399
N
#define N
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
llvm::IntegerType::getBitWidth
unsigned getBitWidth() const
Get the number of bits in this IntegerType.
Definition: DerivedTypes.h:71
llvm::raw_svector_ostream
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:656
llvm::StructType::getElementType
Type * getElementType(unsigned N) const
Definition: DerivedTypes.h:327
llvm::Type::getInt16Ty
static IntegerType * getInt16Ty(LLVMContext &C)
Definition: Type.cpp:202
llvm::Type::ScalableVectorTyID
@ ScalableVectorTyID
Scalable SIMD vector type.
Definition: Type.h:77
DerivedTypes.h
llvm::SmallPtrSetImpl
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:343
llvm::ArrayType::isValidElementType
static bool isValidElementType(Type *ElemTy)
Return true if the specified type is valid as a element type.
Definition: Type.cpp:616
llvm::LLVMContextImpl::PointerTypes
DenseMap< Type *, PointerType * > PointerTypes
Definition: LLVMContextImpl.h:1451
llvm::IntegerType::get
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:275
llvm::ScalableVectorType::get
static ScalableVectorType * get(Type *ElementType, unsigned MinNumElts)
Definition: Type.cpp:671
llvm::Type::getLabelTy
static Type * getLabelTy(LLVMContext &C)
Definition: Type.cpp:187
LLVMContext.h
llvm::Type::TypeID
TypeID
Definitions of all of the base types for the Type system.
Definition: Type.h:54
raw_ostream.h
llvm::Type::getX86_MMXTy
static Type * getX86_MMXTy(LLVMContext &C)
Definition: Type.cpp:197
llvm::StructType::isLiteral
bool isLiteral() const
Return true if this type is uniqued by structural equivalence, false if it is a struct definition.
Definition: DerivedTypes.h:276
llvm::Type::canLosslesslyBitCastTo
bool canLosslesslyBitCastTo(Type *Ty) const
Return true if this type could be converted with a lossless BitCast to type 'Ty'.
Definition: Type.cpp:69
Value.h
llvm::StructType::isLayoutIdentical
bool isLayoutIdentical(StructType *Other) const
Return true if this is layout identical to the specified struct.
Definition: Type.cpp:560
CU
Definition: AArch64AsmBackend.cpp:499
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::VectorType::get
static VectorType * get(Type *ElementType, ElementCount EC)
This static method is the primary way to construct an VectorType.
Definition: Type.cpp:634
llvm::Type::getX86_AMXPtrTy
static PointerType * getX86_AMXPtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:243
llvm::Type::HalfTyID
@ HalfTyID
16-bit floating point type
Definition: Type.h:56
llvm::Type::X86_FP80TyID
@ X86_FP80TyID
80-bit floating point type (X87)
Definition: Type.h:60
llvm::Type::getFloatTy
static Type * getFloatTy(LLVMContext &C)
Definition: Type.cpp:190
llvm::Type::isX86_AMXTy
bool isX86_AMXTy() const
Return true if this is X86 AMX.
Definition: Type.h:186
llvm::LLVMContextImpl::FunctionTypes
FunctionTypeSet FunctionTypes
Definition: LLVMContextImpl.h:1440
llvm::Type::isFirstClassType
bool isFirstClassType() const
Return true if the type is "first class", meaning it is a valid type for a Value.
Definition: Type.h:253
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1172
llvm::FunctionType
Class to represent function types.
Definition: DerivedTypes.h:102
llvm::Type::getPrimitiveSizeInBits
TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
Definition: Type.cpp:128
llvm::SmallPtrSetImpl::insert
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:364