26#include "llvm/IR/DataLayout.h"
27#include "llvm/IR/DerivedTypes.h"
28#include "llvm/IR/Module.h"
31using namespace CodeGen;
34 : CGM(cgm), Context(cgm.getContext()), TheModule(cgm.getModule()),
36 SkippedLayout =
false;
37 LongDoubleReferenced =
false;
41 for (llvm::FoldingSet<CGFunctionInfo>::iterator
42 I = FunctionInfos.begin(),
E = FunctionInfos.end(); I !=
E; )
56 llvm::raw_svector_ostream OS(
TypeName);
78 if (TDD->getDeclContext())
79 TDD->printQualifiedName(OS, Policy);
88 Ty->setName(OS.str());
114 auto *FixedVT = cast<llvm::FixedVectorType>(R);
116 uint64_t BytePadded = std::max<uint64_t>(FixedVT->getNumElements(), 8);
117 return llvm::IntegerType::get(FixedVT->getContext(), BytePadded);
135 return llvm::ArrayType::get(CGM.
Int8Ty,
141 if (R->isIntegerTy(1))
150 llvm::Type *LLVMTy) {
157 return ASTSize != LLVMSize;
161 llvm::Type *LLVMTy) {
166 return llvm::Type::getIntNTy(
169 if (LLVMTy->isIntegerTy(1))
182 llvm::DenseMap<const Type*, llvm::StructType *>::const_iterator I =
183 RecordDeclTypes.find(Ty);
184 return I != RecordDeclTypes.end() && !I->second->isOpaque();
198 if (!TT)
return true;
215 for (
unsigned i = 0, e = FPT->getNumParams(); i != e; i++)
228 if (
const EnumDecl *ED = dyn_cast<EnumDecl>(TD)) {
230 if (TypeCache.count(ED->getTypeForDecl())) {
234 if (!
ConvertType(ED->getIntegerType())->isIntegerTy(32))
240 DI->completeType(ED);
257 DI->completeType(RD);
264 const Type *Ty =
T.getTypePtr();
265 if (RecordsWithOpaqueMemberPointers.count(Ty)) {
267 RecordsWithOpaqueMemberPointers.clear();
272 const llvm::fltSemantics &format,
273 bool UseNativeHalf =
false) {
274 if (&format == &llvm::APFloat::IEEEhalf()) {
276 return llvm::Type::getHalfTy(VMContext);
278 return llvm::Type::getInt16Ty(VMContext);
280 if (&format == &llvm::APFloat::BFloat())
281 return llvm::Type::getBFloatTy(VMContext);
282 if (&format == &llvm::APFloat::IEEEsingle())
283 return llvm::Type::getFloatTy(VMContext);
284 if (&format == &llvm::APFloat::IEEEdouble())
285 return llvm::Type::getDoubleTy(VMContext);
286 if (&format == &llvm::APFloat::IEEEquad())
287 return llvm::Type::getFP128Ty(VMContext);
288 if (&format == &llvm::APFloat::PPCDoubleDouble())
289 return llvm::Type::getPPC_FP128Ty(VMContext);
290 if (&format == &llvm::APFloat::x87DoubleExtended())
291 return llvm::Type::getX86_FP80Ty(VMContext);
292 llvm_unreachable(
"Unknown float format!");
295llvm::Type *CodeGenTypes::ConvertFunctionTypeInternal(
QualType QFT) {
309 for (
unsigned i = 0, e = FPT->getNumParams(); i != e; i++)
313 SkippedLayout =
true;
331 llvm::Type *ResultType =
nullptr;
334 if (FunctionsBeingProcessed.count(FI)) {
337 SkippedLayout =
true;
351 const Type *Ty =
T.getTypePtr();
368 if (
const RecordType *RT = dyn_cast<RecordType>(Ty))
371 llvm::Type *CachedType =
nullptr;
372 auto TCI = TypeCache.find(Ty);
373 if (TCI != TypeCache.end())
374 CachedType = TCI->second;
377#ifndef EXPENSIVE_CHECKS
383 llvm::Type *ResultType =
nullptr;
386#define TYPE(Class, Base)
387#define ABSTRACT_TYPE(Class, Base)
388#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
389#define DEPENDENT_TYPE(Class, Base) case Type::Class:
390#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
391#include "clang/AST/TypeNodes.inc"
392 llvm_unreachable(
"Non-canonical or dependent types aren't possible.");
394 case Type::Builtin: {
395 switch (cast<BuiltinType>(Ty)->
getKind()) {
396 case BuiltinType::Void:
397 case BuiltinType::ObjCId:
398 case BuiltinType::ObjCClass:
399 case BuiltinType::ObjCSel:
405 case BuiltinType::Bool:
410 case BuiltinType::Char_S:
411 case BuiltinType::Char_U:
412 case BuiltinType::SChar:
413 case BuiltinType::UChar:
414 case BuiltinType::Short:
415 case BuiltinType::UShort:
416 case BuiltinType::Int:
417 case BuiltinType::UInt:
418 case BuiltinType::Long:
419 case BuiltinType::ULong:
420 case BuiltinType::LongLong:
421 case BuiltinType::ULongLong:
422 case BuiltinType::WChar_S:
423 case BuiltinType::WChar_U:
424 case BuiltinType::Char8:
425 case BuiltinType::Char16:
426 case BuiltinType::Char32:
427 case BuiltinType::ShortAccum:
428 case BuiltinType::Accum:
429 case BuiltinType::LongAccum:
430 case BuiltinType::UShortAccum:
431 case BuiltinType::UAccum:
432 case BuiltinType::ULongAccum:
433 case BuiltinType::ShortFract:
434 case BuiltinType::Fract:
435 case BuiltinType::LongFract:
436 case BuiltinType::UShortFract:
437 case BuiltinType::UFract:
438 case BuiltinType::ULongFract:
439 case BuiltinType::SatShortAccum:
440 case BuiltinType::SatAccum:
441 case BuiltinType::SatLongAccum:
442 case BuiltinType::SatUShortAccum:
443 case BuiltinType::SatUAccum:
444 case BuiltinType::SatULongAccum:
445 case BuiltinType::SatShortFract:
446 case BuiltinType::SatFract:
447 case BuiltinType::SatLongFract:
448 case BuiltinType::SatUShortFract:
449 case BuiltinType::SatUFract:
450 case BuiltinType::SatULongFract:
455 case BuiltinType::Float16:
461 case BuiltinType::Half:
468 case BuiltinType::LongDouble:
469 LongDoubleReferenced =
true;
471 case BuiltinType::BFloat16:
472 case BuiltinType::Float:
473 case BuiltinType::Double:
474 case BuiltinType::Float128:
475 case BuiltinType::Ibm128:
481 case BuiltinType::NullPtr:
486 case BuiltinType::UInt128:
487 case BuiltinType::Int128:
491#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
492 case BuiltinType::Id:
493#include "clang/Basic/OpenCLImageTypes.def"
494#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
495 case BuiltinType::Id:
496#include "clang/Basic/OpenCLExtensionTypes.def"
497 case BuiltinType::OCLSampler:
498 case BuiltinType::OCLEvent:
499 case BuiltinType::OCLClkEvent:
500 case BuiltinType::OCLQueue:
501 case BuiltinType::OCLReserveID:
504#define SVE_VECTOR_TYPE(Name, MangledName, Id, SingletonId) \
505 case BuiltinType::Id:
506#define SVE_PREDICATE_TYPE(Name, MangledName, Id, SingletonId) \
507 case BuiltinType::Id:
508#define SVE_TYPE(Name, Id, SingletonId)
509#include "clang/Basic/AArch64SVEACLETypes.def"
519 auto *VTy = llvm::VectorType::get(EltTy, Info.
EC);
522 llvm_unreachable(
"Expected 1, 2, 3 or 4 vectors!");
526 return llvm::StructType::get(VTy, VTy);
528 return llvm::StructType::get(VTy, VTy, VTy);
530 return llvm::StructType::get(VTy, VTy, VTy, VTy);
533 case BuiltinType::SveCount:
534 return llvm::TargetExtType::get(
getLLVMContext(),
"aarch64.svcount");
535 case BuiltinType::MFloat8:
536 return llvm::VectorType::get(llvm::Type::getInt8Ty(
getLLVMContext()), 1,
538#define PPC_VECTOR_TYPE(Name, Id, Size) \
539 case BuiltinType::Id: \
541 llvm::FixedVectorType::get(ConvertType(Context.BoolTy), Size); \
543#include "clang/Basic/PPCTypes.def"
544#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
545#include "clang/Basic/RISCVVTypes.def"
550 unsigned I8EltCount =
551 Info.
EC.getKnownMinValue() *
553 return llvm::TargetExtType::get(
555 llvm::ScalableVectorType::get(
560 Info.
EC.getKnownMinValue());
562#define WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS) \
563 case BuiltinType::Id: { \
564 if (BuiltinType::Id == BuiltinType::WasmExternRef) \
565 ResultType = CGM.getTargetCodeGenInfo().getWasmExternrefReferenceType(); \
567 llvm_unreachable("Unexpected wasm reference builtin type!"); \
569#include "clang/Basic/WebAssemblyReferenceTypes.def"
570#define AMDGPU_OPAQUE_PTR_TYPE(Name, Id, SingletonId, Width, Align, AS) \
571 case BuiltinType::Id: \
572 return llvm::PointerType::get(getLLVMContext(), AS);
573#define AMDGPU_NAMED_BARRIER_TYPE(Name, Id, SingletonId, Width, Align, Scope) \
574 case BuiltinType::Id: \
575 return llvm::TargetExtType::get(getLLVMContext(), "amdgcn.named.barrier", \
577#include "clang/Basic/AMDGPUTypes.def"
578#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
579#include "clang/Basic/HLSLIntangibleTypes.def"
582 case BuiltinType::Dependent:
583#define BUILTIN_TYPE(Id, SingletonId)
584#define PLACEHOLDER_TYPE(Id, SingletonId) \
585 case BuiltinType::Id:
586#include "clang/AST/BuiltinTypes.def"
587 llvm_unreachable(
"Unexpected placeholder builtin type!");
592 case Type::DeducedTemplateSpecialization:
593 llvm_unreachable(
"Unexpected undeduced type!");
594 case Type::Complex: {
595 llvm::Type *EltTy =
ConvertType(cast<ComplexType>(Ty)->getElementType());
596 ResultType = llvm::StructType::get(EltTy, EltTy);
599 case Type::LValueReference:
600 case Type::RValueReference: {
607 case Type::Pointer: {
615 case Type::VariableArray: {
618 "FIXME: We only handle trivial array types so far!");
624 case Type::IncompleteArray: {
627 "FIXME: We only handle trivial array types so far!");
631 if (!ResultType->isSized()) {
632 SkippedLayout =
true;
635 ResultType = llvm::ArrayType::get(ResultType, 0);
638 case Type::ArrayParameter:
639 case Type::ConstantArray: {
645 if (!EltTy->isSized()) {
646 SkippedLayout =
true;
650 ResultType = llvm::ArrayType::get(EltTy, A->
getZExtSize());
653 case Type::ExtVector:
655 const auto *VT = cast<VectorType>(Ty);
657 llvm::Type *IRElemTy = VT->isExtVectorBoolType()
659 : VT->getElementType()->isMFloat8Type()
662 ResultType = llvm::FixedVectorType::get(IRElemTy, VT->getNumElements());
665 case Type::ConstantMatrix: {
672 case Type::FunctionNoProto:
673 case Type::FunctionProto:
674 ResultType = ConvertFunctionTypeInternal(
T);
676 case Type::ObjCObject:
677 ResultType =
ConvertType(cast<ObjCObjectType>(Ty)->getBaseType());
680 case Type::ObjCInterface: {
684 llvm::Type *&
T = InterfaceTypes[cast<ObjCInterfaceType>(Ty)];
691 case Type::ObjCObjectPointer:
696 const EnumDecl *ED = cast<EnumType>(Ty)->getDecl();
706 case Type::BlockPointer: {
719 case Type::MemberPointer: {
720 auto *MPTy = cast<MemberPointerType>(Ty);
721 if (!
getCXXABI().isMemberPointerConvertible(MPTy)) {
722 auto *
C = MPTy->getClass();
723 auto Insertion = RecordsWithOpaqueMemberPointers.insert({
C,
nullptr});
724 if (Insertion.second)
725 Insertion.first->second = llvm::StructType::create(
getLLVMContext());
726 ResultType = Insertion.first->second;
734 QualType valueType = cast<AtomicType>(Ty)->getValueType();
738 uint64_t valueSize = Context.
getTypeSize(valueType);
740 if (valueSize != atomicSize) {
741 assert(valueSize < atomicSize);
742 llvm::Type *elts[] = {
744 llvm::ArrayType::get(CGM.
Int8Ty, (atomicSize - valueSize) / 8)
756 const auto &EIT = cast<BitIntType>(Ty);
757 ResultType = llvm::Type::getIntNTy(
getLLVMContext(), EIT->getNumBits());
760 case Type::HLSLAttributedResource:
765 assert(ResultType &&
"Didn't convert a type?");
766 assert((!CachedType || CachedType == ResultType) &&
767 "Cached type doesn't match computed type");
769 TypeCache[Ty] = ResultType;
787 llvm::StructType *&Entry = RecordDeclTypes[Key];
794 llvm::StructType *Ty = Entry;
803 if (
const CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) {
804 for (
const auto &I : CRD->bases()) {
805 if (I.isVirtual())
continue;
812 CGRecordLayouts[Key] = std::move(Layout);
828 auto I = CGRecordLayouts.find(Key);
829 if (I != CGRecordLayouts.end())
835 I = CGRecordLayouts.find(Key);
837 assert(I != CGRecordLayouts.end() &&
838 "Unable to find record layout information for type");
852 if (isa<IncompleteArrayType>(AT))
854 if (
const auto *CAT = dyn_cast<ConstantArrayType>(AT))
Defines the clang::ASTContext interface.
static llvm::Type * getTypeForFormat(llvm::LLVMContext &VMContext, const llvm::fltSemantics &format, bool UseNativeHalf=false)
static Decl::Kind getKind(const Decl *D)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
llvm::MachO::Target Target
static CharUnits getTypeAllocSize(CodeGenModule &CGM, llvm::Type *type)
BuiltinVectorTypeInfo getBuiltinVectorTypeInfo(const BuiltinType *VecTy) const
Returns the element type, element count and number of vectors (in case of tuple) for a builtin vector...
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat 'semantics' for the specified scalar floating point type.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
QualType getRecordType(const RecordDecl *Decl) const
uint64_t getTargetNullPointerValue(QualType QT) const
Get target-dependent integer value for null pointer which is used for constant folding.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
const LangOptions & getLangOpts() const
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
const clang::PrintingPolicy & getPrintingPolicy() const
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
const TargetInfo & getTargetInfo() const
uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const
Return number of constant array elements.
unsigned getTargetAddressSpace(LangAS AS) const
QualType getElementType() const
unsigned getIndexTypeCVRQualifiers() const
Represents a C++ struct/union/class.
Represents a canonical, potentially-qualified type.
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
CharUnits - This is an opaque type for sizes expressed in character units.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
Implements C++ ABI-specific code generation functions.
virtual bool isMemberPointerConvertible(const MemberPointerType *MPT) const
Return whether or not a member pointers type is convertible to an IR type.
virtual llvm::Type * ConvertMemberPointerType(const MemberPointerType *MPT)
Find the LLVM type used to represent the given member pointer type.
virtual bool isZeroInitializable(const MemberPointerType *MPT)
Return true if the given member pointer can be zero-initialized (in the C++ sense) with an LLVM zeroi...
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
CGFunctionInfo - Class to encapsulate the information about a function definition.
llvm::Type * convertHLSLSpecificType(const Type *T)
virtual llvm::Type * getPipeType(const PipeType *T, StringRef Name, llvm::Type *&PipeTy)
virtual llvm::Type * convertOpenCLSpecificType(const Type *T)
CGRecordLayout - This class handles struct and union layout info while lowering AST types to LLVM typ...
bool isZeroInitializable() const
Check whether this struct can be C++ zero-initialized with a zeroinitializer.
This class organizes the cross-function state that is used while generating LLVM code.
CGHLSLRuntime & getHLSLRuntime()
Return a reference to the configured HLSL runtime.
CGDebugInfo * getModuleDebugInfo()
bool isPaddedAtomicType(QualType type)
CGOpenCLRuntime & getOpenCLRuntime()
Return a reference to the configured OpenCL runtime.
CGCXXABI & getCXXABI() const
const TargetCodeGenInfo & getTargetCodeGenInfo()
const CodeGenOptions & getCodeGenOpts() const
CodeGenTypes(CodeGenModule &cgm)
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
CGCXXABI & getCXXABI() const
bool isPointerZeroInitializable(QualType T)
Check if the pointer type can be zero-initialized (in the C++ sense) with an LLVM zeroinitializer.
const CodeGenOptions & getCodeGenOpts() const
ASTContext & getContext() const
const CGFunctionInfo & arrangeFreeFunctionType(CanQual< FunctionProtoType > Ty)
Arrange the argument and result information for a value of the given freestanding function type.
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
bool isFuncTypeConvertible(const FunctionType *FT)
isFuncTypeConvertible - Utility to check whether a function type can be converted to an LLVM type (i....
std::unique_ptr< CGRecordLayout > ComputeRecordLayout(const RecordDecl *D, llvm::StructType *Ty)
Compute a new LLVM record layout object for the given record.
llvm::Type * convertTypeForLoadStore(QualType T, llvm::Type *LLVMTy=nullptr)
Given that T is a scalar type, return the IR type that should be used for load and store operations.
const CGRecordLayout & getCGRecordLayout(const RecordDecl *)
getCGRecordLayout - Return record layout info for the given record decl.
unsigned getTargetAddressSpace(QualType T) const
llvm::StructType * ConvertRecordDeclType(const RecordDecl *TD)
ConvertRecordDeclType - Lay out a tagged decl type like struct or union.
void RefreshTypeCacheForClass(const CXXRecordDecl *RD)
Remove stale types from the type cache when an inheritance model gets assigned to a class.
bool isRecordLayoutComplete(const Type *Ty) const
isRecordLayoutComplete - Return true if the specified type is already completely laid out.
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
CodeGenModule & getCGM() const
void UpdateCompletedType(const TagDecl *TD)
UpdateCompletedType - When we find the full definition for a TagDecl, replace the 'opaque' type we pr...
llvm::LLVMContext & getLLVMContext()
bool typeRequiresSplitIntoByteArray(QualType ASTTy, llvm::Type *LLVMTy=nullptr)
Check whether the given type needs to be laid out in memory using an opaque byte-array type because i...
const llvm::DataLayout & getDataLayout() const
bool isFuncParamTypeConvertible(QualType Ty)
isFuncParamTypeConvertible - Return true if the specified type in a function parameter or result posi...
bool isZeroInitializable(QualType T)
IsZeroInitializable - Return whether a type can be zero-initialized (in the C++ sense) with an LLVM z...
void addRecordTypeName(const RecordDecl *RD, llvm::StructType *Ty, StringRef suffix)
addRecordTypeName - Compute a name from the given record decl with an optional suffix and name the gi...
virtual llvm::Type * getCUDADeviceBuiltinSurfaceDeviceType() const
Return the device-side type for the CUDA device builtin surface type.
virtual llvm::Type * getCUDADeviceBuiltinTextureDeviceType() const
Return the device-side type for the CUDA device builtin texture type.
Represents the canonical version of C arrays with a specified constant size.
uint64_t getZExtSize() const
Return the size zero-extended as a uint64_t.
Represents a concrete matrix type with constant number of rows and columns.
unsigned getNumColumns() const
Returns the number of columns in the matrix.
unsigned getNumRows() const
Returns the number of rows in the matrix.
ASTContext & getASTContext() const LLVM_READONLY
DeclContext * getDeclContext()
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
Represents a K&R-style 'int foo()' function, which has no information available about its arguments.
Represents a prototype with parameter type info, e.g.
FunctionType - C99 6.7.5.3 - Function Declarators.
QualType getReturnType() const
Represents a C array with an unspecified size.
QualType getElementType() const
Returns type of the elements being stored in the matrix.
A pointer to member type per C++ 8.3.3 - Pointers to members.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
void printQualifiedName(raw_ostream &OS) const
Returns a human-readable qualified name for this declaration, like A::B::i, for i being member of nam...
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
A (possibly-)qualified type.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
Represents a struct/union/class.
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
Base for LValueReferenceType and RValueReferenceType.
QualType getPointeeType() const
Represents the declaration of a struct/union/class/enum.
StringRef getKindName() const
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
TypedefNameDecl * getTypedefNameForAnonDecl() const
void printName(raw_ostream &OS, const PrintingPolicy &Policy) const override
Pretty-print the unqualified name of this declaration.
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
virtual bool useFP16ConversionIntrinsics() const
Check whether llvm intrinsics such as llvm.convert.to.fp16 should be used to convert to and from __fp...
The base class of the type hierarchy.
bool isBlockPointerType() const
bool isMFloat8Type() const
bool isConstantMatrixType() const
bool isCUDADeviceBuiltinSurfaceType() const
Check if the type is the CUDA device builtin surface type.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isExtVectorBoolType() const
bool isBitIntType() const
bool isCUDADeviceBuiltinTextureType() const
Check if the type is the CUDA device builtin texture type.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isAnyPointerType() const
TypeClass getTypeClass() const
const T * getAs() const
Member-template getAs<specific type>'.
Base class for declarations which introduce a typedef-name.
Represents a C array with a specified size that is not an integer-constant-expression.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
The JSON file list parser is used to communicate input to InstallAPI.
const FunctionProtoType * T
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
Describes how types, statements, expressions, and declarations should be printed.
unsigned SuppressInlineNamespace
Suppress printing parts of scope specifiers that correspond to inline namespaces.