RetroSearch Browse

;

1071 for

(

Module

*&M : Merged)

1072 if

.insert(M).second)

1074

llvm::erase(Merged,

nullptr

);

1081 if

(MergedIt == MergedDefModules.end())

1083 return

MergedIt->second;

1086void

ASTContext::PerModuleInitializers::resolve(

ASTContext

&Ctx) {

1087 if

(LazyInitializers.empty())

1091

assert(Source &&

"lazy initializers but no external source"

);

1093 auto

LazyInits = std::move(LazyInitializers);

1094

LazyInitializers.clear();

1096 for

(

auto

ID : LazyInits)

1097

Initializers.push_back(Source->GetExternalDecl(ID));

1099

assert(LazyInitializers.empty() &&

1100 "GetExternalDecl for lazy module initializer added more inits"

);

1106 if

(

const auto

*ID = dyn_cast<ImportDecl>(

)) {

1107 auto

It = ModuleInitializers.find(ID->getImportedModule());

1110 if

(It == ModuleInitializers.end())

1114 auto

&Imported = *It->second;

1115 if

(Imported.Initializers.size() + Imported.LazyInitializers.size() == 1) {

1116

Imported.resolve(*

this

);

1117 auto

*OnlyDecl = Imported.Initializers.front();

1118 if

(isa<ImportDecl>(OnlyDecl))

1123 auto

*&Inits = ModuleInitializers[M];

1125

Inits =

new

(*this) PerModuleInitializers;

1126

Inits->Initializers.push_back(

);

1131 auto

*&Inits = ModuleInitializers[M];

1133

Inits =

new

(*this) PerModuleInitializers;

1134

Inits->LazyInitializers.insert(Inits->LazyInitializers.end(),

1135

IDs.begin(), IDs.end());

1139 auto

It = ModuleInitializers.find(M);

1140 if

(It == ModuleInitializers.end())

1143 auto

*Inits = It->second;

1144

Inits->resolve(*

this

);

1145 return

Inits->Initializers;

1150

assert(!CurrentCXXNamedModule &&

1151 "We should set named module for ASTContext for only once"

);

1152

CurrentCXXNamedModule = M;

1164 auto

GetRepresentativeModule = [

this

](

const Module

*M) {

1165 auto Iter

= SameModuleLookupSet.find(M);

1166 if

(

Iter

!= SameModuleLookupSet.end())

1167 return Iter

->second;

1169 const Module

*RepresentativeModule =

1170

PrimaryModuleNameMap.try_emplace(M->getPrimaryModuleInterfaceName(), M)

1172

SameModuleLookupSet[M] = RepresentativeModule;

1173 return

RepresentativeModule;

1176

assert(M1 &&

"Shouldn't call `isInSameModule` if both M1 and M2 are none."

);

1177 return

GetRepresentativeModule(M1) == GetRepresentativeModule(M2);

1181 if

(!ExternCContext)

1184 return

ExternCContext;

1190 auto

*BuiltinTemplate =

1192

BuiltinTemplate->setImplicit();

1195 return

BuiltinTemplate;

1200 if

(!MakeIntegerSeqDecl)

1203 return

MakeIntegerSeqDecl;

1208 if

(!TypePackElementDecl)

1211 return

TypePackElementDecl;

1215 if

(!BuiltinCommonTypeDecl)

1218 return

BuiltinCommonTypeDecl;

1232

NewDecl->

addAttr

(TypeVisibilityAttr::CreateImplicit(

1233 const_cast<ASTContext

>

this

), TypeVisibilityAttr::Default));

1238

StringRef Name)

const

{

1262

Types.push_back(Ty);

1267

assert((!this->Target || this->Target == &

) &&

1268 "Incorrect target reinitialization"

);

1269

assert(

VoidTy

() &&

"Context reinitialized?"

);

1271

this->Target = &

;

1272

this->AuxTarget = AuxTarget;

1274

ABI.reset(createCXXABI(

));

1278

InitBuiltinType(

VoidTy

, BuiltinType::Void);

1281

InitBuiltinType(

BoolTy

, BuiltinType::Bool);

1283 if

(LangOpts.CharIsSigned)

1284

InitBuiltinType(

CharTy

, BuiltinType::Char_S);

1286

InitBuiltinType(

CharTy

, BuiltinType::Char_U);

1289

InitBuiltinType(

ShortTy

, BuiltinType::Short);

1290

InitBuiltinType(

, BuiltinType::Int);

1291

InitBuiltinType(

, BuiltinType::Long);

1292

InitBuiltinType(

LongLongTy

, BuiltinType::LongLong);

1302

InitBuiltinType(

FloatTy

, BuiltinType::Float);

1303

InitBuiltinType(

DoubleTy

, BuiltinType::Double);

1304

InitBuiltinType(

LongDoubleTy

, BuiltinType::LongDouble);

1307

InitBuiltinType(

Float128Ty

, BuiltinType::Float128);

1310

InitBuiltinType(

Ibm128Ty

, BuiltinType::Ibm128);

1313

InitBuiltinType(

Float16Ty

, BuiltinType::Float16);

1316

InitBuiltinType(

ShortAccumTy

, BuiltinType::ShortAccum);

1317

InitBuiltinType(

AccumTy

, BuiltinType::Accum);

1318

InitBuiltinType(

LongAccumTy

, BuiltinType::LongAccum);

1322

InitBuiltinType(

ShortFractTy

, BuiltinType::ShortFract);

1323

InitBuiltinType(

FractTy

, BuiltinType::Fract);

1324

InitBuiltinType(

LongFractTy

, BuiltinType::LongFract);

1329

InitBuiltinType(

SatAccumTy

, BuiltinType::SatAccum);

1335

InitBuiltinType(

SatFractTy

, BuiltinType::SatFract);

1342

InitBuiltinType(

Int128Ty

, BuiltinType::Int128);

1347

InitBuiltinType(

WCharTy

, BuiltinType::WChar_S);

1349

InitBuiltinType(

WCharTy

, BuiltinType::WChar_U);

1350 if

(LangOpts.CPlusPlus && LangOpts.WChar)

1360

InitBuiltinType(

Char8Ty

, BuiltinType::Char8);

1362 if

(LangOpts.CPlusPlus)

1363

InitBuiltinType(

Char16Ty

, BuiltinType::Char16);

1367 if

(LangOpts.CPlusPlus)

1368

InitBuiltinType(

Char32Ty

, BuiltinType::Char32);

1377

InitBuiltinType(

DependentTy

, BuiltinType::Dependent);

1380

InitBuiltinType(

OverloadTy

, BuiltinType::Overload);

1392

InitBuiltinType(

UnknownAnyTy

, BuiltinType::UnknownAny);

1398

InitBuiltinType(

BuiltinFnTy

, BuiltinType::BuiltinFn);

1401 if

(LangOpts.OpenMP) {

1408 if

(LangOpts.OpenACC && !LangOpts.OpenMP) {

1411 if

(LangOpts.MatrixTypes)

1419 if

(LangOpts.OpenCL) {

1420#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 1421 InitBuiltinType(SingletonId, BuiltinType::Id); 1422#include "clang/Basic/OpenCLImageTypes.def" 1424

InitBuiltinType(

OCLSamplerTy

, BuiltinType::OCLSampler);

1425

InitBuiltinType(

OCLEventTy

, BuiltinType::OCLEvent);

1427

InitBuiltinType(

OCLQueueTy

, BuiltinType::OCLQueue);

1430#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ 1431 InitBuiltinType(Id##Ty, BuiltinType::Id); 1432#include "clang/Basic/OpenCLExtensionTypes.def" 1435 if

(LangOpts.HLSL) {

1436#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \ 1437 InitBuiltinType(SingletonId, BuiltinType::Id); 1438#include "clang/Basic/HLSLIntangibleTypes.def" 1441 if

(

.hasAArch64SVETypes() ||

1443#define SVE_TYPE(Name, Id, SingletonId) \ 1444 InitBuiltinType(SingletonId, BuiltinType::Id); 1445#include "clang/Basic/AArch64SVEACLETypes.def" 1448 if

(

.getTriple().isPPC64()) {

1449#define PPC_VECTOR_MMA_TYPE(Name, Id, Size) \ 1450 InitBuiltinType(Id##Ty, BuiltinType::Id); 1451#include "clang/Basic/PPCTypes.def" 1452#define PPC_VECTOR_VSX_TYPE(Name, Id, Size) \ 1453 InitBuiltinType(Id##Ty, BuiltinType::Id); 1454#include "clang/Basic/PPCTypes.def" 1457 if

(

.hasRISCVVTypes()) {

1458#define RVV_TYPE(Name, Id, SingletonId) \ 1459 InitBuiltinType(SingletonId, BuiltinType::Id); 1460#include "clang/Basic/RISCVVTypes.def" 1463 if

(

.getTriple().isWasm() &&

.hasFeature(

"reference-types"

)) {

1464#define WASM_TYPE(Name, Id, SingletonId) \ 1465 InitBuiltinType(SingletonId, BuiltinType::Id); 1466#include "clang/Basic/WebAssemblyReferenceTypes.def" 1469 if

(

.getTriple().isAMDGPU() ||

1470

(AuxTarget && AuxTarget->

getTriple

().isAMDGPU())) {

1471#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) \ 1472 InitBuiltinType(SingletonId, BuiltinType::Id); 1473#include "clang/Basic/AMDGPUTypes.def" 1480

ObjCConstantStringType =

();

1485 if

(LangOpts.OpenCLGenericAddressSpace) {

1495

InitBuiltinType(

NullPtrTy

, BuiltinType::NullPtr);

1498

InitBuiltinType(

HalfTy

, BuiltinType::Half);

1500

InitBuiltinType(

BFloat16Ty

, BuiltinType::BFloat16);

1506 if

(LangOpts.MicrosoftExt || LangOpts.Borland) {

1528

llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(

);

1529 if

(Pos != DeclAttrs.end()) {

1530

Pos->second->~AttrVec();

1531

DeclAttrs.erase(Pos);

1545

llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>::iterator Pos =

1546

TemplateOrInstantiation.find(Var);

1547 if

(Pos == TemplateOrInstantiation.end())

1560

Tmpl, TSK, PointOfInstantiation));

1566

assert(!TemplateOrInstantiation[Inst] &&

1567 "Already noted what the variable was instantiated from"

);

1568

TemplateOrInstantiation[Inst] = TSI;

1573 return

InstantiatedFromUsingDecl.lookup(UUD);

1578

assert((isa<UsingDecl>(Pattern) ||

1579

isa<UnresolvedUsingValueDecl>(Pattern) ||

1580

isa<UnresolvedUsingTypenameDecl>(Pattern)) &&

1581 "pattern decl is not a using decl"

);

1582

assert((isa<UsingDecl>(Inst) ||

1583

isa<UnresolvedUsingValueDecl>(Inst) ||

1584

isa<UnresolvedUsingTypenameDecl>(Inst)) &&

1585 "instantiation did not produce a using decl"

);

1586

assert(!InstantiatedFromUsingDecl[Inst] &&

"pattern already exists"

);

1587

InstantiatedFromUsingDecl[Inst] = Pattern;

1592 return

InstantiatedFromUsingEnumDecl.lookup(UUD);

1597

assert(!InstantiatedFromUsingEnumDecl[Inst] &&

"pattern already exists"

);

1598

InstantiatedFromUsingEnumDecl[Inst] = Pattern;

1603 return

InstantiatedFromUsingShadowDecl.lookup(Inst);

1609

assert(!InstantiatedFromUsingShadowDecl[Inst] &&

"pattern already exists"

);

1610

InstantiatedFromUsingShadowDecl[Inst] = Pattern;

1615 return

InstantiatedFromUnnamedFieldDecl.lookup(Field);

1621 "Instantiated field decl is not unnamed"

);

1623 "Template field decl is not unnamed"

);

1624

assert(!InstantiatedFromUnnamedFieldDecl[Inst] &&

1625 "Already noted what unnamed field was instantiated from"

);

1627

InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl;

1648

llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos =

1650 if

(Pos == OverriddenMethods.end())

1658

OverriddenMethods[Method].push_back(Overridden);

1666 if

(

const auto

*CXXMethod = dyn_cast<CXXMethodDecl>(

)) {

1672 const auto

*Method = dyn_cast<ObjCMethodDecl>(

);

1677

Method->getOverriddenMethods(OverDecls);

1678

Overridden.append(OverDecls.begin(), OverDecls.end());

1682

assert(!Import->getNextLocalImport() &&

1683 "Import declaration already in the chain"

);

1684

assert(!Import->isFromASTFile() &&

"Non-local import declaration"

);

1685 if

(!FirstLocalImport) {

1686

FirstLocalImport = Import;

1687

LastLocalImport = Import;

1691

LastLocalImport->setNextLocalImport(Import);

1692

LastLocalImport = Import;

1704

llvm_unreachable(

"Not a floating point type!"

);

1705 case

BuiltinType::BFloat16:

1706 return Target

->getBFloat16Format();

1707 case

BuiltinType::Float16:

1708 return Target

->getHalfFormat();

1709 case

BuiltinType::Half:

1710 return Target

->getHalfFormat();

1711 case

BuiltinType::Float:

return Target

->getFloatFormat();

1712 case

BuiltinType::Double:

return Target

->getDoubleFormat();

1713 case

BuiltinType::Ibm128:

1714 return Target

->getIbm128Format();

1715 case

BuiltinType::LongDouble:

1718 return Target

->getLongDoubleFormat();

1719 case

BuiltinType::Float128:

1722 return Target

->getFloat128Format();

1727 unsigned

Align =

->getCharWidth();

1731

Align = AlignFromAttr;

1739 bool

UseAlignAttrOnly;

1740 if

(

const FieldDecl

*FD = dyn_cast<FieldDecl>(

))

1742

FD->hasAttr<PackedAttr>() || FD->getParent()->hasAttr<PackedAttr>();

1744

UseAlignAttrOnly = AlignFromAttr != 0;

1747 if

(UseAlignAttrOnly) {

1749

}

else if

(

const auto

*VD = dyn_cast<ValueDecl>(

)) {

1759

Align = getTypeInfoImpl(

.getTypePtr()).

;

1764 unsigned

MinWidth =

->getLargeArrayMinWidth();

1765 if

(!ForAlignof && MinWidth) {

1766 if

(isa<VariableArrayType>(

arrayType

))

1767

Align = std::max(Align,

->getLargeArrayAlign());

1768 else if

(isa<ConstantArrayType>(

arrayType

) &&

1770

Align = std::max(Align,

->getLargeArrayAlign());

1775

Align =

->getCharWidth();

1779 if

(

const auto

*VD = dyn_cast<VarDecl>(

))

1780 if

(VD->hasGlobalStorage() && !ForAlignof) {

1791 if

(

const auto

*Field = dyn_cast<FieldDecl>(VD)) {

1794 if

Parent

->isInvalidDecl()) {

1801

uint64_t Offset = Layout.

getFieldOffset

(Field->getFieldIndex());

1805

uint64_t LowBitOfOffset = Offset & (~Offset + 1);

1806 if

(LowBitOfOffset < FieldAlign)

1807

FieldAlign =

static_cast<unsigned>

(LowBitOfOffset);

1810

Align = std::min(Align, FieldAlign);

1818 const auto

*VD = dyn_cast<VarDecl>(

);

1819 if

(MaxAlignedAttr && VD && VD->getStorageClass() ==

SC_Static

)

1820

Align = std::min(Align, MaxAlignedAttr);

1857

assert((Size == 0 ||

static_cast<

uint64_t

>

(EltInfo.

getQuantity

()) <=

1858

(uint64_t)(-1)/Size) &&

1859 "Overflow in array type char size evaluation"

);

1864

Width = llvm::alignTo(Width, Align);

1871 if

(

const auto

*CAT = dyn_cast<ConstantArrayType>(

))

1889 switch

(BT->getKind()) {

1890 case

BuiltinType::Bool:

1891 case

BuiltinType::Char_S:

1892 case

BuiltinType::Char_U:

1893 case

BuiltinType::SChar:

1894 case

BuiltinType::UChar:

1895 case

BuiltinType::Short:

1896 case

BuiltinType::UShort:

1897 case

BuiltinType::WChar_S:

1898 case

BuiltinType::WChar_U:

1899 case

BuiltinType::Char8:

1900 case

BuiltinType::Char16:

1901 case

BuiltinType::Char32:

1910 if

(

isDependentType

() || ET->getDecl()->getPromotionType().isNull() ||

1911

ET->getDecl()->isScoped())

1929 bool

NeedsPreferredAlignment)

const

{

1932 if

(

unsigned

Align = TT->getDecl()->getMaxAlignment())

1943 if

(

unsigned

Align = TT->getDecl()->getMaxAlignment())

1948 return

TT->getDecl()->getMaxAlignment();

1954

TypeInfoMap::iterator I = MemoizedTypeInfo.find(

);

1955 if

(I != MemoizedTypeInfo.end())

1960

MemoizedTypeInfo[

] = TI;

1970TypeInfo

ASTContext::getTypeInfoImpl(

const Type

)

const

{

1976#define TYPE(Class, Base) 1977#define ABSTRACT_TYPE(Class, Base) 1978#define NON_CANONICAL_TYPE(Class, Base) 1979#define DEPENDENT_TYPE(Class, Base) case Type::Class: 1980#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) \ 1982 assert(!T->isDependentType() && "should not see dependent types here"

); \

1983

return getTypeInfo(cast<Class##Type>(T)->desugar().getTypePtr());

1984#include "clang/AST/TypeNodes.inc" 1985

llvm_unreachable(

"Should not see dependent types"

);

1987 case

Type::FunctionNoProto:

1988 case

Type::FunctionProto:

1994 case

Type::IncompleteArray:

1995 case

Type::VariableArray:

1996 case

Type::ConstantArray:

1997 case

Type::ArrayParameter: {

2000 if

(

const auto

*CAT = dyn_cast<ConstantArrayType>(

))

2001

Size = CAT->getZExtSize();

2004

assert((Size == 0 || EltInfo.

<= (uint64_t)(-1) / Size) &&

2005 "Overflow in array type bit size evaluation"

);

2006

Width = EltInfo.

* Size;

2007

Align = EltInfo.

;

2011

Width = llvm::alignTo(Width, Align);

2015 case

Type::ExtVector:

2016 case

Type::Vector: {

2017 const auto

*VT = cast<VectorType>(

);

2019

Width = VT->isExtVectorBoolType() ? VT->getNumElements()

2020

: EltInfo.

* VT->getNumElements();

2022

Width = std::max<unsigned>(8, Width);

2023

Align = std::max<unsigned>(8, Width);

2027 if

(Align & (Align-1)) {

2028

Align = llvm::bit_ceil(Align);

2029

Width = llvm::alignTo(Width, Align);

2033 if

(TargetVectorAlign && TargetVectorAlign < Align)

2034

Align = TargetVectorAlign;

2048

Align = std::min<unsigned>(64, Width);

2052 case

Type::ConstantMatrix: {

2053 const auto

*MT = cast<ConstantMatrixType>(

);

2058

Width = ElementInfo.

* MT->getNumRows() * MT->getNumColumns();

2059

Align = ElementInfo.

;

2064 switch

(cast<BuiltinType>(

)->

()) {

2065 default

: llvm_unreachable(

"Unknown builtin type!"

);

2066 case

BuiltinType::Void:

2071 case

BuiltinType::Bool:

2072

Width =

->getBoolWidth();

2073

Align =

->getBoolAlign();

2075 case

BuiltinType::Char_S:

2076 case

BuiltinType::Char_U:

2077 case

BuiltinType::UChar:

2078 case

BuiltinType::SChar:

2079 case

BuiltinType::Char8:

2080

Width =

->getCharWidth();

2081

Align =

->getCharAlign();

2083 case

BuiltinType::WChar_S:

2084 case

BuiltinType::WChar_U:

2085

Width =

->getWCharWidth();

2086

Align =

->getWCharAlign();

2088 case

BuiltinType::Char16:

2089

Width =

->getChar16Width();

2090

Align =

->getChar16Align();

2092 case

BuiltinType::Char32:

2093

Width =

->getChar32Width();

2094

Align =

->getChar32Align();

2096 case

BuiltinType::UShort:

2097 case

BuiltinType::Short:

2098

Width =

->getShortWidth();

2099

Align =

->getShortAlign();

2101 case

BuiltinType::UInt:

2102 case

BuiltinType::Int:

2103

Width =

->getIntWidth();

2104

Align =

->getIntAlign();

2106 case

BuiltinType::ULong:

2107 case

BuiltinType::Long:

2108

Width =

->getLongWidth();

2109

Align =

->getLongAlign();

2111 case

BuiltinType::ULongLong:

2112 case

BuiltinType::LongLong:

2113

Width =

->getLongLongWidth();

2114

Align =

->getLongLongAlign();

2116 case

BuiltinType::Int128:

2117 case

BuiltinType::UInt128:

2119

Align =

->getInt128Align();

2121 case

BuiltinType::ShortAccum:

2122 case

BuiltinType::UShortAccum:

2123 case

BuiltinType::SatShortAccum:

2124 case

BuiltinType::SatUShortAccum:

2125

Width =

->getShortAccumWidth();

2126

Align =

->getShortAccumAlign();

2128 case

BuiltinType::Accum:

2129 case

BuiltinType::UAccum:

2130 case

BuiltinType::SatAccum:

2131 case

BuiltinType::SatUAccum:

2132

Width =

->getAccumWidth();

2133

Align =

->getAccumAlign();

2135 case

BuiltinType::LongAccum:

2136 case

BuiltinType::ULongAccum:

2137 case

BuiltinType::SatLongAccum:

2138 case

BuiltinType::SatULongAccum:

2139

Width =

->getLongAccumWidth();

2140

Align =

->getLongAccumAlign();

2142 case

BuiltinType::ShortFract:

2143 case

BuiltinType::UShortFract:

2144 case

BuiltinType::SatShortFract:

2145 case

BuiltinType::SatUShortFract:

2146

Width =

->getShortFractWidth();

2147

Align =

->getShortFractAlign();

2149 case

BuiltinType::Fract:

2150 case

BuiltinType::UFract:

2151 case

BuiltinType::SatFract:

2152 case

BuiltinType::SatUFract:

2153

Width =

->getFractWidth();

2154

Align =

->getFractAlign();

2156 case

BuiltinType::LongFract:

2157 case

BuiltinType::ULongFract:

2158 case

BuiltinType::SatLongFract:

2159 case

BuiltinType::SatULongFract:

2160

Width =

->getLongFractWidth();

2161

Align =

->getLongFractAlign();

2163 case

BuiltinType::BFloat16:

2164 if

(

->hasBFloat16Type()) {

2165

Width =

->getBFloat16Width();

2166

Align =

->getBFloat16Align();

2175 case

BuiltinType::Float16:

2176 case

BuiltinType::Half:

2179

Width =

->getHalfWidth();

2180

Align =

->getHalfAlign();

2183 "Expected OpenMP device compilation."

);

2188 case

BuiltinType::Float:

2189

Width =

->getFloatWidth();

2190

Align =

->getFloatAlign();

2192 case

BuiltinType::Double:

2193

Width =

->getDoubleWidth();

2194

Align =

->getDoubleAlign();

2196 case

BuiltinType::Ibm128:

2197

Width =

->getIbm128Width();

2198

Align =

->getIbm128Align();

2200 case

BuiltinType::LongDouble:

2207

Width =

->getLongDoubleWidth();

2208

Align =

->getLongDoubleAlign();

2211 case

BuiltinType::Float128:

2214

Width =

->getFloat128Width();

2215

Align =

->getFloat128Align();

2218 "Expected OpenMP device compilation."

);

2223 case

BuiltinType::NullPtr:

2228 case

BuiltinType::ObjCId:

2229 case

BuiltinType::ObjCClass:

2230 case

BuiltinType::ObjCSel:

2234 case

BuiltinType::OCLSampler:

2235 case

BuiltinType::OCLEvent:

2236 case

BuiltinType::OCLClkEvent:

2237 case

BuiltinType::OCLQueue:

2238 case

BuiltinType::OCLReserveID:

2239#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 2240 case BuiltinType::Id: 2241#include "clang/Basic/OpenCLImageTypes.def" 2242#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ 2243 case BuiltinType::Id: 2244#include "clang/Basic/OpenCLExtensionTypes.def" 2246

Width =

->getPointerWidth(AS);

2247

Align =

->getPointerAlign(AS);

2257#define SVE_VECTOR_TYPE(Name, MangledName, Id, SingletonId) \ 2258 case BuiltinType::Id: \ 2262#define SVE_PREDICATE_TYPE(Name, MangledName, Id, SingletonId) \ 2263 case BuiltinType::Id: \ 2267#define SVE_OPAQUE_TYPE(Name, MangledName, Id, SingletonId) \ 2268 case BuiltinType::Id: \ 2272#define SVE_SCALAR_TYPE(Name, MangledName, Id, SingletonId, Bits) \ 2273 case BuiltinType::Id: \ 2277#include "clang/Basic/AArch64SVEACLETypes.def" 2278#define PPC_VECTOR_TYPE(Name, Id, Size) \ 2279 case BuiltinType::Id: \ 2283#include "clang/Basic/PPCTypes.def" 2284#define RVV_VECTOR_TYPE(Name, Id, SingletonId, ElKind, ElBits, NF, IsSigned, \ 2286 case BuiltinType::Id: \ 2290#define RVV_PREDICATE_TYPE(Name, Id, SingletonId, ElKind) \ 2291 case BuiltinType::Id: \ 2295#include "clang/Basic/RISCVVTypes.def" 2296#define WASM_TYPE(Name, Id, SingletonId) \ 2297 case BuiltinType::Id: \ 2301#include "clang/Basic/WebAssemblyReferenceTypes.def" 2302#define AMDGPU_TYPE(NAME, ID, SINGLETONID, WIDTH, ALIGN) \ 2303 case BuiltinType::ID: \ 2307#include "clang/Basic/AMDGPUTypes.def" 2308#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id: 2309#include "clang/Basic/HLSLIntangibleTypes.def" 2315 case

Type::ObjCObjectPointer:

2319 case

Type::BlockPointer:

2320

AS = cast<BlockPointerType>(

)->getPointeeType().getAddressSpace();

2321

Width =

->getPointerWidth(AS);

2322

Align =

->getPointerAlign(AS);

2324 case

Type::LValueReference:

2325 case

Type::RValueReference:

2328

AS = cast<ReferenceType>(

)->getPointeeType().getAddressSpace();

2329

Width =

->getPointerWidth(AS);

2330

Align =

->getPointerAlign(AS);

2333

AS = cast<PointerType>(

)->getPointeeType().getAddressSpace();

2334

Width =

->getPointerWidth(AS);

2335

Align =

->getPointerAlign(AS);

2337 case

Type::MemberPointer: {

2338 const auto

*MPT = cast<MemberPointerType>(

);

2340

Width = MPI.

;

2341

Align = MPI.

;

2344 case

Type::Complex: {

2348

Width = EltInfo.

* 2;

2349

Align = EltInfo.

;

2352 case

Type::ObjCObject:

2353 return getTypeInfo

(cast<ObjCObjectType>(

)->getBaseType().getTypePtr());

2354 case

Type::Adjusted:

2357 case

Type::ObjCInterface: {

2358 const auto

*ObjCI = cast<ObjCInterfaceType>(

);

2359 if

(ObjCI->getDecl()->isInvalidDecl()) {

2369 case

Type::BitInt: {

2370 const auto

*EIT = cast<BitIntType>(

);

2371

Align =

->getBitIntAlign(EIT->getNumBits());

2372

Width =

->getBitIntWidth(EIT->getNumBits());

2377 const auto

*TT = cast<TagType>(

);

2379 if

(TT->getDecl()->isInvalidDecl()) {

2385 if

(

const auto

*ET = dyn_cast<EnumType>(TT)) {

2386 const EnumDecl

*ED = ET->getDecl();

2390

Info.

= AttrAlign;

2396 const auto

*RT = cast<RecordType>(TT);

2401

AlignRequirement = RD->

<AlignedAttr>()

2407 case

Type::SubstTemplateTypeParm:

2408 return getTypeInfo

(cast<SubstTemplateTypeParmType>(

)->

2409

getReplacementType().getTypePtr());

2412 case

Type::DeducedTemplateSpecialization: {

2413 const auto

*A = cast<DeducedType>(

);

2414

assert(!A->getDeducedType().isNull() &&

2415 "cannot request the size of an undeduced or dependent auto type"

);

2416 return getTypeInfo

(A->getDeducedType().getTypePtr());

2420 return getTypeInfo

(cast<ParenType>(

)->getInnerType().getTypePtr());

2422 case

Type::MacroQualified:

2426 case

Type::ObjCTypeParam:

2427 return getTypeInfo

(cast<ObjCTypeParamType>(

)->desugar().getTypePtr());

2430 return getTypeInfo

(cast<UsingType>(

)->desugar().getTypePtr());

2432 case

Type::Typedef: {

2433 const auto

*TT = cast<TypedefType>(

);

2438 if

(

unsigned

AttrAlign = TT->getDecl()->getMaxAlignment()) {

2442

Align = Info.

;

2445

Width = Info.

;

2449 case

Type::Elaborated:

2450 return getTypeInfo

(cast<ElaboratedType>(

)->getNamedType().getTypePtr());

2452 case

Type::Attributed:

2454

cast<AttributedType>(

)->getEquivalentType().getTypePtr());

2456 case

Type::CountAttributed:

2457 return getTypeInfo

(cast<CountAttributedType>(

)->desugar().getTypePtr());

2459 case

Type::BTFTagAttributed:

2461

cast<BTFTagAttributedType>(

)->getWrappedType().getTypePtr());

2463 case

Type::HLSLAttributedResource:

2465

cast<HLSLAttributedResourceType>(

)->getWrappedType().getTypePtr());

2467 case

Type::Atomic: {

2470

Width = Info.

;

2471

Align = Info.

;

2476

Width =

->getCharWidth();

2478

}

else if

(Width <= Target->getMaxAtomicPromoteWidth()) {

2484

Width = llvm::bit_ceil(Width);

2487

Align =

static_cast<unsigned>

(Width);

2498

assert(llvm::isPowerOf2_32(Align) &&

"Alignment must be power of 2"

);

2499 return TypeInfo

(Width, Align, AlignRequirement);

2503

UnadjustedAlignMap::iterator I = MemoizedUnadjustedAlign.find(

);

2504 if

(I != MemoizedUnadjustedAlign.end())

2507 unsigned

UnadjustedAlign;

2519

MemoizedUnadjustedAlign[

] = UnadjustedAlign;

2520 return

UnadjustedAlign;

2524 unsigned

SimdAlign = llvm::OpenMPIRBuilder::getOpenMPDefaultSimdAlign(

2574 unsigned

ABIAlign = TI.

;

2582 if

->allowsLargerPreferedTypeAlignment())

2596 unsigned

PreferredAlign =

static_cast<unsigned>

(

2598

assert(PreferredAlign >= ABIAlign &&

2599 "PreferredAlign should be at least as large as ABIAlign."

);

2600 return

PreferredAlign;

2607 T

= CT->getElementType().getTypePtr();

2609 T

= ET->getDecl()->getIntegerType().getTypePtr();

2614 Target

->defaultsToAIXPowerAlignment()))

2618 return

std::max(ABIAlign, (

unsigned

)

getTypeSize

(

));

2669 for

(

unsigned

I = 0, N =

Path

.size(); I != N; ++I) {

2673

std::swap(

, Derived);

2693

llvm::append_range(Ivars, OI->

ivars

());

2696 for

(

const ObjCIvarDecl

*Iv = IDecl->all_declared_ivar_begin(); Iv;

2698

Ivars.push_back(Iv);

2706 if

(

const auto

*OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) {

2709 for

(

auto

*Proto : OI->all_referenced_protocols()) {

2714 for

(

const auto

*Cat : OI->visible_categories())

2720

SD = SD->getSuperClass();

2722

}

else if

(

const auto

*OC = dyn_cast<ObjCCategoryDecl>(CDecl)) {

2723 for

(

auto

*Proto : OC->protocols()) {

2726

}

else if

(

const auto

*OP = dyn_cast<ObjCProtocolDecl>(CDecl)) {

2728 if

(!Protocols.insert(

2732 for

(

auto

*Proto : OP->protocols())

2739 bool

CheckIfTriviallyCopyable) {

2740

assert(RD->

() &&

"Must be union type"

);

2743 for

(

const auto

*Field : RD->

()) {

2745

CheckIfTriviallyCopyable))

2748 if

(FieldSize != UnionSize)

2766static

std::optional<int64_t>

2769 bool

CheckIfTriviallyCopyable);

2771static

std::optional<int64_t>

2773 bool

CheckIfTriviallyCopyable) {

2774 if

(Field->getType()->isRecordType()) {

2775 const RecordDecl

*RD = Field->getType()->getAsRecordDecl();

2778

CheckIfTriviallyCopyable);

2783 bool

IsBitIntType = Field->getType()->isBitIntType();

2784 if

(!Field->getType()->isReferenceType() && !IsBitIntType &&

2786

CheckIfTriviallyCopyable))

2787 return

std::nullopt;

2789

int64_t FieldSizeInBits =

2791 if

(Field->isBitField()) {

2794 if

(Field->isUnnamedBitField())

2797

int64_t BitfieldSize = Field->getBitWidthValue();

2799 if

((

unsigned

)BitfieldSize >

2800

cast<BitIntType>(Field->getType())->getNumBits())

2801 return

std::nullopt;

2802

}

else if

(BitfieldSize > FieldSizeInBits) {

2803 return

std::nullopt;

2805

FieldSizeInBits = BitfieldSize;

2807

Field->getType(), CheckIfTriviallyCopyable)) {

2808 return

std::nullopt;

2810 return

FieldSizeInBits;

2813static

std::optional<int64_t>

2815 bool

CheckIfTriviallyCopyable) {

2817

CheckIfTriviallyCopyable);

2820template

typename

RangeT>

2822 const

RangeT &Subobjects, int64_t CurOffsetInBits,

2824 bool

CheckIfTriviallyCopyable) {

2825 for

(

const auto

*Subobject : Subobjects) {

2826

std::optional<int64_t> SizeInBits =

2829 return

std::nullopt;

2830 if

(*SizeInBits != 0) {

2832 if

(Offset != CurOffsetInBits)

2833 return

std::nullopt;

2834

CurOffsetInBits += *SizeInBits;

2837 return

CurOffsetInBits;

2840static

std::optional<int64_t>

2843 bool

CheckIfTriviallyCopyable) {

2844

assert(!RD->

() &&

"Must be struct/class type"

);

2847

int64_t CurOffsetInBits = 0;

2848 if

(

const auto

*ClassDecl = dyn_cast<CXXRecordDecl>(RD)) {

2849 if

(ClassDecl->isDynamicClass())

2850 return

std::nullopt;

2853 for

(

const auto

: ClassDecl->bases()) {

2856

Bases.emplace_back(

.getType()->getAsCXXRecordDecl());

2860 return

Layout.getBaseClassOffset(L) < Layout.getBaseClassOffset(R);

2863

std::optional<int64_t> OffsetAfterBases =

2865

Bases, CurOffsetInBits, Context, Layout, CheckIfTriviallyCopyable);

2866 if

(!OffsetAfterBases)

2867 return

std::nullopt;

2868

CurOffsetInBits = *OffsetAfterBases;

2871

std::optional<int64_t> OffsetAfterFields =

2873

RD->

(), CurOffsetInBits, Context, Layout,

2874

CheckIfTriviallyCopyable);

2875 if

(!OffsetAfterFields)

2876 return

std::nullopt;

2877

CurOffsetInBits = *OffsetAfterFields;

2879 return

CurOffsetInBits;

2883 QualType

Ty,

bool

CheckIfTriviallyCopyable)

const

{

2900

assert(!Ty.

() &&

"Null QualType sent to unique object rep check"

);

2905

CheckIfTriviallyCopyable);

2908 "hasUniqueObjectRepresentations should not be called with an " 2909 "incomplete type"

);

2929 return

!ABI->getMemberPointerInfo(MPT).HasPadding;

2934 if

(

->isInvalidDecl())

2939

CheckIfTriviallyCopyable);

2942

this

, CheckIfTriviallyCopyable);

2944 return

StructSize && *StructSize ==

static_cast<

int64_t

>

(

getTypeSize

(Ty));

2965

count += Ext->ivar_size();

2970

count += ImplDecl->ivar_size();

2988 if

(isa<GNUNullExpr>(

))

return true

;

2996

llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator

2997

I = ObjCImpls.find(

);

2998 if

(I != ObjCImpls.end())

2999 return

cast<ObjCImplementationDecl>(I->second);

3006

llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator

3007

I = ObjCImpls.find(

);

3008 if

(I != ObjCImpls.end())

3009 return

cast<ObjCCategoryImplDecl>(I->second);

3016

assert(IFaceD && ImplD &&

"Passed null params"

);

3017

ObjCImpls[IFaceD] = ImplD;

3023

assert(CatD && ImplD &&

"Passed null params"

);

3024

ObjCImpls[CatD] = ImplD;

3029 return

ObjCMethodRedecls.lookup(MD);

3035

ObjCMethodRedecls[MD] = Redecl;

3040 if

(

const auto

*ID = dyn_cast<ObjCInterfaceDecl>(ND->

getDeclContext

()))

3042 if

(

const auto

*CD = dyn_cast<ObjCCategoryDecl>(ND->

getDeclContext

()))

3043 return

CD->getClassInterface();

3044 if

(

const auto

*IMD = dyn_cast<ObjCImplDecl>(ND->

getDeclContext

()))

3045 return

IMD->getClassInterface();

3053

assert(VD &&

"Passed null params"

);

3054

assert(VD->

<BlocksAttr>() &&

3055 "getBlockVarCopyInits - not __block var"

);

3056 auto

I = BlockVarCopyInits.find(VD);

3057 if

(I != BlockVarCopyInits.end())

3059 return

{

nullptr

false

};

3065

assert(VD && CopyExpr &&

"Passed null params"

);

3066

assert(VD->

<BlocksAttr>() &&

3067 "setBlockVarCopyInits - not __block var"

);

3068

BlockVarCopyInits[VD].setExprAndFlag(CopyExpr,

CanThrow

);

3072 unsigned

DataSize)

const

{

3077 "incorrect data size provided to CreateTypeSourceInfo!"

);

3094 return

getObjCLayout(

nullptr

);

3100 return

getObjCLayout(

->getClassInterface(),

);

3105 bool

&AnyNonCanonArgs) {

3107 for

(

auto

&Arg : CanonArgs) {

3109

Arg =

.getCanonicalTemplateArgument(Arg);

3110

AnyNonCanonArgs |= !Arg.structurallyEquals(OrigArg);

3120

ASTContext::getExtQualType(

const Type

*baseType,

Qualifiers

quals)

const

{

3125

llvm::FoldingSetNodeID

;

3127 void

*insertPos =

nullptr

;

3128 if

(

ExtQuals

*eq = ExtQualNodes.FindNodeOrInsertPos(ID, insertPos)) {

3129

assert(eq->getQualifiers() == quals);

3138

canon = getExtQualType(canonSplit.

, canonSplit.

);

3141

(void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos);

3144 auto

*eq =

new

this

alignof

(

ExtQuals

))

ExtQuals

(baseType, canon, quals);

3145

ExtQualNodes.InsertNode(eq, insertPos);

3150 LangAS

AddressSpace)

const

{

3163 "Type cannot be in multiple addr spaces!"

);

3166 return

getExtQualType(TypeNode, Quals);

3172 if

.hasAddressSpace())

3176 const Type

*TypeNode;

3181

TypeNode =

.getTypePtr();

3185 while

(

.hasAddressSpace()) {

3186

TypeNode = Quals.

strip

(

);

3190 if

(TypeNode, 0).hasAddressSpace())

3194 T

.getSingleStepDesugaredType(*

this

);

3204 return

getExtQualType(TypeNode, Quals);

3212 "Attempted to get vtable pointer discriminator on a monomorphic type"

);

3215

llvm::raw_svector_ostream Out(Str);

3216

MC->mangleCXXVTable(RD, Out);

3217 return

llvm::getPointerAuthStableSipHash(Str);

3246

Ctx, OS, cast<AtomicType>(

)->getValueType());

3248 case

Type::LValueReference:

3253 case

Type::RValueReference:

3267 case

Type::ObjCObjectPointer:

3268 case

Type::BlockPointer:

3275

Ctx, OS, cast<ComplexType>(

)->getElementType());

3277 case

Type::VariableArray:

3278 case

Type::ConstantArray:

3279 case

Type::IncompleteArray:

3280 case

Type::ArrayParameter:

3291

Ctx, OS, cast<ArrayType>(

)->getElementType());

3293 case

Type::ObjCInterface:

3294 case

Type::ObjCObject:

3295

OS <<

"<objc_object>"

;

3304 QualType

UnderlyingType = cast<EnumType>(

)->getDecl()->getIntegerType();

3306

Ctx, OS, UnderlyingType.

() ? Ctx.

: UnderlyingType);

3309 case

Type::FunctionNoProto:

3310 case

Type::FunctionProto: {

3324 const auto

*FuncType = cast<FunctionType>(

);

3326 if

(

const auto

*FPT = dyn_cast<FunctionProtoType>(FuncType)) {

3327 for

(

Param : FPT->param_types()) {

3331 if

(FPT->isVariadic())

3338 case

Type::MemberPointer: {

3345 case

Type::ExtVector:

3353 case

Type::ConstantMatrix:

3357 case

Type::Builtin: {

3359 switch

(BTy->getKind()) {

3360#define SIGNED_TYPE(Id, SingletonId) \ 3361 case BuiltinType::Id: \ 3364#define UNSIGNED_TYPE(Id, SingletonId) \ 3365 case BuiltinType::Id: \ 3368#define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id: 3369#define BUILTIN_TYPE(Id, SingletonId) 3370#include "clang/AST/BuiltinTypes.def" 3371

llvm_unreachable(

"placeholder types should not appear here."

);

3373 case

BuiltinType::Half:

3376 case

BuiltinType::Float:

3379 case

BuiltinType::Double:

3382 case

BuiltinType::LongDouble:

3385 case

BuiltinType::Float16:

3388 case

BuiltinType::Float128:

3392 case

BuiltinType::Void:

3396 case

BuiltinType::ObjCId:

3397 case

BuiltinType::ObjCClass:

3398 case

BuiltinType::ObjCSel:

3399 case

BuiltinType::NullPtr:

3404 case

BuiltinType::OCLSampler:

3405 case

BuiltinType::OCLEvent:

3406 case

BuiltinType::OCLClkEvent:

3407 case

BuiltinType::OCLQueue:

3408 case

BuiltinType::OCLReserveID:

3409 case

BuiltinType::BFloat16:

3410 case

BuiltinType::VectorQuad:

3411 case

BuiltinType::VectorPair:

3416 case

BuiltinType::Ibm128:

3418#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 3419 case BuiltinType::Id: \ 3421#include "clang/Basic/OpenCLImageTypes.def" 3422#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ 3423 case BuiltinType::Id: \ 3425#include "clang/Basic/OpenCLExtensionTypes.def" 3426#define SVE_TYPE(Name, Id, SingletonId) \ 3427 case BuiltinType::Id: \ 3429#include "clang/Basic/AArch64SVEACLETypes.def" 3430#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \ 3431 case BuiltinType::Id: \ 3433#include "clang/Basic/HLSLIntangibleTypes.def" 3434 case

BuiltinType::Dependent:

3435

llvm_unreachable(

"should never get here"

);

3436#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) case BuiltinType::Id: 3437#include "clang/Basic/AMDGPUTypes.def" 3438 case

BuiltinType::WasmExternRef:

3439#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: 3440#include "clang/Basic/RISCVVTypes.def" 3441

llvm_unreachable(

"not yet implemented"

);

3443

llvm_unreachable(

"should never get here"

);

3445 case

Type::Record: {

3466

II = Typedef->getDeclName().getAsIdentifierInfo();

3469

OS <<

"<anonymous_record>"

;

3475 case

Type::HLSLAttributedResource:

3476

llvm_unreachable(

"should never get here"

);

3478 case

Type::DeducedTemplateSpecialization:

3480#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 3481#define DEPENDENT_TYPE(Class, Base) case Type::Class: 3482#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class: 3483#define ABSTRACT_TYPE(Class, Base) 3484#define TYPE(Class, Base) 3485#include "clang/AST/TypeNodes.inc" 3486

llvm_unreachable(

"unexpected non-canonical or dependent type!"

);

3493 "cannot compute type discriminator of a dependent type"

);

3496

llvm::raw_svector_ostream Out(Str);

3504 T

.getUnqualifiedType();

3525 if

(MPT->isMemberFunctionPointer()) {

3534

MC->mangleCanonicalTypeName(

, Out);

3537 return

llvm::getPointerAuthStableSipHash(Str);

3562 "Type cannot have multiple ObjCGCs!"

);

3565 return

getExtQualType(TypeNode, Quals);

3579 QualType

WrappedTy,

Expr

*CountExpr,

bool

CountInBytes,

bool

OrNull,

3583

llvm::FoldingSetNodeID ID;

3586 void

*InsertPos =

nullptr

;

3588

CountAttributedTypes.FindNodeOrInsertPos(ID, InsertPos);

3593 size_t

Size = CountAttributedType::totalSizeToAlloc<TypeCoupledDeclRefInfo>(

3594

DependentDecls.size());

3597

OrNull, DependentDecls);

3598

Types.push_back(CATy);

3599

CountAttributedTypes.InsertNode(CATy, InsertPos);

3608 case

Type::Attributed: {

3609 const auto

*AT = cast<AttributedType>(Orig);

3612 adjustType

(AT->getEquivalentType(), Adjust),

3616 case

Type::BTFTagAttributed: {

3617 const auto

*BTFT = dyn_cast<BTFTagAttributedType>(Orig);

3619 adjustType

(BTFT->getWrappedType(), Adjust));

3622 case

Type::Elaborated: {

3623 const auto

*ET = cast<ElaboratedType>(Orig);

3630 adjustType

(cast<ParenType>(Orig)->getInnerType(), Adjust));

3632 case

Type::Adjusted: {

3633 const auto

*AT = cast<AdjustedType>(Orig);

3638 case

Type::MacroQualified: {

3639 const auto

*MQT = cast<MacroQualifiedType>(Orig);

3641

MQT->getMacroIdentifier());

3645 return

Adjust(Orig);

3655 if

(

const auto

*FNPT = dyn_cast<FunctionNoProtoType>(

)) {

3658 const auto

*FPT = cast<FunctionProtoType>(

);

3664 return

cast<FunctionType>(

Result

.getTypePtr());

3675

FPT->getExtProtoInfo());

3690

L->DeducedReturnType(FD, ResultType);

3701 return getFunctionType

(Proto->getReturnType(), Proto->getParamTypes(),

3702

Proto->getExtProtoInfo().withExceptionSpec(ESI));

3718 for

(

unsigned

i = 0, n = Args.size(); i != n; ++i)

3741 return getFunctionType

(Proto->getReturnType(), Proto->param_types(), EPI);

3767 if

(TSInfo->getType() != FD->

getType

())

3775 "TypeLoc size mismatch from updating exception specification"

);

3776

TSInfo->overrideType(Updated);

3785

llvm::FoldingSetNodeID ID;

3788 void

*InsertPos =

nullptr

;

3789 if

(

ComplexType

*CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos))

3795 if

.isCanonical()) {

3799 ComplexType

*NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos);

3800

assert(!NewIP &&

"Shouldn't be in the map!"

); (void)NewIP;

3803

Types.push_back(New);

3804

ComplexTypes.InsertNode(New, InsertPos);

3813

llvm::FoldingSetNodeID ID;

3816 void

*InsertPos =

nullptr

;

3817 if

(

PointerType

*PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos))

3823 if

.isCanonical()) {

3827 PointerType

*NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos);

3828

assert(!NewIP &&

"Shouldn't be in the map!"

); (void)NewIP;

3831

Types.push_back(New);

3832

PointerTypes.InsertNode(New, InsertPos);

3837

llvm::FoldingSetNodeID ID;

3839 void

*InsertPos =

nullptr

;

3840 AdjustedType

*AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);

3847

AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);

3848

assert(!AT &&

"Shouldn't be in the map!"

);

3852

Types.push_back(AT);

3853

AdjustedTypes.InsertNode(AT, InsertPos);

3858

llvm::FoldingSetNodeID ID;

3860 void

*InsertPos =

nullptr

;

3861 AdjustedType

*AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);

3868

AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);

3869

assert(!AT &&

"Shouldn't be in the map!"

);

3872

Types.push_back(AT);

3873

AdjustedTypes.InsertNode(AT, InsertPos);

3904 const auto

*ATy = cast<ConstantArrayType>(Ty);

3905

llvm::FoldingSetNodeID ID;

3906

ATy->Profile(ID, *

this

, ATy->getElementType(), ATy->getZExtSize(),

3907

ATy->getSizeExpr(), ATy->getSizeModifier(),

3908

ATy->getIndexTypeQualifiers().getAsOpaqueValue());

3909 void

*InsertPos =

nullptr

;

3911

ArrayParameterTypes.FindNodeOrInsertPos(ID, InsertPos);

3920

AT = ArrayParameterTypes.FindNodeOrInsertPos(ID, InsertPos);

3921

assert(!AT &&

"Shouldn't be in the map!"

);

3926

Types.push_back(AT);

3927

ArrayParameterTypes.InsertNode(AT, InsertPos);

3937

llvm::FoldingSetNodeID ID;

3940 void

*InsertPos =

nullptr

;

3942

BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos))

3948 if

.isCanonical()) {

3953

BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos);

3954

assert(!NewIP &&

"Shouldn't be in the map!"

); (void)NewIP;

3958

Types.push_back(New);

3959

BlockPointerTypes.InsertNode(New, InsertPos);

3969 "Unresolved placeholder type"

);

3973

llvm::FoldingSetNodeID ID;

3976 void

*InsertPos =

nullptr

;

3978

LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))

3986 if

(!SpelledAsLValue || InnerRef || !

.isCanonical()) {

3987 QualType

PointeeType = (InnerRef ? InnerRef->getPointeeType() :

);

3992

LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);

3993

assert(!NewIP &&

"Shouldn't be in the map!"

); (void)NewIP;

3998

Types.push_back(New);

3999

LValueReferenceTypes.InsertNode(New, InsertPos);

4009 "Unresolved placeholder type"

);

4013

llvm::FoldingSetNodeID ID;

4016 void

*InsertPos =

nullptr

;

4018

RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))

4026 if

(InnerRef || !

.isCanonical()) {

4027 QualType

PointeeType = (InnerRef ? InnerRef->getPointeeType() :

);

4032

RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);

4033

assert(!NewIP &&

"Shouldn't be in the map!"

); (void)NewIP;

4038

Types.push_back(New);

4039

RValueReferenceTypes.InsertNode(New, InsertPos);

4048

llvm::FoldingSetNodeID ID;

4051 void

*InsertPos =

nullptr

;

4053

MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos))

4064

MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);

4065

assert(!NewIP &&

"Shouldn't be in the map!"

); (void)NewIP;

4069

Types.push_back(New);

4070

MemberPointerTypes.InsertNode(New, InsertPos);

4077 const

llvm::APInt &ArySizeIn,

4078 const Expr

*SizeExpr,

4080 unsigned

IndexTypeQuals)

const

{

4083 "Constant array of VLAs is illegal!"

);

4087

SizeExpr =

nullptr

;

4091

llvm::APInt ArySize(ArySizeIn);

4092

ArySize = ArySize.zextOrTrunc(

->getMaxPointerWidth());

4094

llvm::FoldingSetNodeID ID;

4096

ASM, IndexTypeQuals);

4098 void

*InsertPos =

nullptr

;

4100

ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos))

4111

ASM, IndexTypeQuals);

4116

ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos);

4117

assert(!NewIP &&

"Shouldn't be in the map!"

); (void)NewIP;

4120 auto

*New = ConstantArrayType::Create(*

this

, EltTy, Canon, ArySize, SizeExpr,

4121

ASM, IndexTypeQuals);

4122

ConstantArrayTypes.InsertNode(New, InsertPos);

4123

Types.push_back(New);

4132 if

->isVariablyModifiedType())

return type

;

4137 const Type

*ty = split.

;

4139#define TYPE(Class, Base) 4140#define ABSTRACT_TYPE(Class, Base) 4141#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 4142#include "clang/AST/TypeNodes.inc" 4143

llvm_unreachable(

"didn't desugar past all non-canonical types?"

);

4149 case

Type::DependentVector:

4150 case

Type::ExtVector:

4151 case

Type::DependentSizedExtVector:

4152 case

Type::ConstantMatrix:

4153 case

Type::DependentSizedMatrix:

4154 case

Type::DependentAddressSpace:

4155 case

Type::ObjCObject:

4156 case

Type::ObjCInterface:

4157 case

Type::ObjCObjectPointer:

4160 case

Type::UnresolvedUsing:

4161 case

Type::TypeOfExpr:

4163 case

Type::Decltype:

4164 case

Type::UnaryTransform:

4165 case

Type::DependentName:

4166 case

Type::InjectedClassName:

4167 case

Type::TemplateSpecialization:

4168 case

Type::DependentTemplateSpecialization:

4169 case

Type::TemplateTypeParm:

4170 case

Type::SubstTemplateTypeParmPack:

4172 case

Type::DeducedTemplateSpecialization:

4173 case

Type::PackExpansion:

4174 case

Type::PackIndexing:

4176 case

Type::DependentBitInt:

4177 case

Type::ArrayParameter:

4178 case

Type::HLSLAttributedResource:

4179

llvm_unreachable(

"type should never be variably-modified"

);

4183 case

Type::FunctionNoProto:

4184 case

Type::FunctionProto:

4185 case

Type::BlockPointer:

4186 case

Type::MemberPointer:

4199 case

Type::LValueReference: {

4200 const auto

*lv = cast<LValueReferenceType>(ty);

4203

lv->isSpelledAsLValue());

4207 case

Type::RValueReference: {

4208 const auto

*lv = cast<RValueReferenceType>(ty);

4214 case

Type::Atomic: {

4215 const auto

*at = cast<AtomicType>(ty);

4220 case

Type::ConstantArray: {

4221 const auto

*cat = cast<ConstantArrayType>(ty);

4226

cat->getSizeModifier(),

4227

cat->getIndexTypeCVRQualifiers());

4231 case

Type::DependentSizedArray: {

4232 const auto

*dat = cast<DependentSizedArrayType>(ty);

4236

dat->getSizeModifier(),

4237

dat->getIndexTypeCVRQualifiers(),

4238

dat->getBracketsRange());

4243 case

Type::IncompleteArray: {

4244 const auto

*iat = cast<IncompleteArrayType>(ty);

4248

iat->getIndexTypeCVRQualifiers(),

SourceRange

());

4253 case

Type::VariableArray: {

4254 const auto

*vat = cast<VariableArrayType>(ty);

4258

vat->getIndexTypeCVRQualifiers(), vat->getBracketsRange());

4271 unsigned

IndexTypeQuals,

4282

IndexTypeQuals, Brackets);

4289

VariableArrayTypes.push_back(New);

4290

Types.push_back(New);

4300 unsigned

elementTypeQuals,

4304 "Size must be type- or value-dependent!"

);

4308 void

*insertPos =

nullptr

;

4309

llvm::FoldingSetNodeID ID;

4311

ID, *

this

, numElements ?

(canonElementType.

, 0) : elementType,

4312

ASM, elementTypeQuals, numElements);

4316

DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos);

4327

elementTypeQuals, brackets);

4328

DependentSizedArrayTypes.InsertNode(newType, insertPos);

4329

Types.push_back(newType);

4337

numElements, ASM, elementTypeQuals, brackets);

4338

DependentSizedArrayTypes.InsertNode(canonTy, insertPos);

4339

Types.push_back(canonTy);

4344

canonElementType.

);

4348 if

(

(canonElementType.

, 0) == elementType &&

4356

elementTypeQuals, brackets);

4357

Types.push_back(sugaredType);

4363 unsigned

elementTypeQuals)

const

{

4364

llvm::FoldingSetNodeID ID;

4367 void

*insertPos =

nullptr

;

4369

IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos))

4381

ASM, elementTypeQuals);

4386

IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos);

4387

assert(!existing &&

"Shouldn't be in the map!"

); (void) existing;

4393

IncompleteArrayTypes.InsertNode(newType, insertPos);

4394

Types.push_back(newType);

4400#define SVE_INT_ELTTY(BITS, ELTS, SIGNED, NUMVECTORS) \ 4401 {getIntTypeForBitwidth(BITS, SIGNED), llvm::ElementCount::getScalable(ELTS), \ 4404#define SVE_ELTTY(ELTTY, ELTS, NUMVECTORS) \ 4405 {ELTTY, llvm::ElementCount::getScalable(ELTS), NUMVECTORS}; 4409

llvm_unreachable(

"Unsupported builtin vector type"

);

4411#define SVE_VECTOR_TYPE_INT(Name, MangledName, Id, SingletonId, NumEls, \ 4412 ElBits, NF, IsSigned) \ 4413 case BuiltinType::Id: \ 4414 return {getIntTypeForBitwidth(ElBits, IsSigned), \ 4415 llvm::ElementCount::getScalable(NumEls), NF}; 4416#define SVE_VECTOR_TYPE_FLOAT(Name, MangledName, Id, SingletonId, NumEls, \ 4418 case BuiltinType::Id: \ 4419 return {ElBits == 16 ? HalfTy : (ElBits == 32 ? FloatTy : DoubleTy), \ 4420 llvm::ElementCount::getScalable(NumEls), NF}; 4421#define SVE_VECTOR_TYPE_BFLOAT(Name, MangledName, Id, SingletonId, NumEls, \ 4423 case BuiltinType::Id: \ 4424 return {BFloat16Ty, llvm::ElementCount::getScalable(NumEls), NF}; 4425#define SVE_VECTOR_TYPE_MFLOAT(Name, MangledName, Id, SingletonId, NumEls, \ 4427 case BuiltinType::Id: \ 4428 return {MFloat8Ty, llvm::ElementCount::getScalable(NumEls), NF}; 4429#define SVE_PREDICATE_TYPE_ALL(Name, MangledName, Id, SingletonId, NumEls, NF) \ 4430 case BuiltinType::Id: \ 4431 return {BoolTy, llvm::ElementCount::getScalable(NumEls), NF}; 4432#define SVE_TYPE(Name, Id, SingletonId) 4433#include "clang/Basic/AArch64SVEACLETypes.def" 4435#define RVV_VECTOR_TYPE_INT(Name, Id, SingletonId, NumEls, ElBits, NF, \ 4437 case BuiltinType::Id: \ 4438 return {getIntTypeForBitwidth(ElBits, IsSigned), \ 4439 llvm::ElementCount::getScalable(NumEls), NF}; 4440#define RVV_VECTOR_TYPE_FLOAT(Name, Id, SingletonId, NumEls, ElBits, NF) \ 4441 case BuiltinType::Id: \ 4442 return {ElBits == 16 ? Float16Ty : (ElBits == 32 ? FloatTy : DoubleTy), \ 4443 llvm::ElementCount::getScalable(NumEls), NF}; 4444#define RVV_VECTOR_TYPE_BFLOAT(Name, Id, SingletonId, NumEls, ElBits, NF) \ 4445 case BuiltinType::Id: \ 4446 return {BFloat16Ty, llvm::ElementCount::getScalable(NumEls), NF}; 4447#define RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls) \ 4448 case BuiltinType::Id: \ 4449 return {BoolTy, llvm::ElementCount::getScalable(NumEls), 1}; 4450#include "clang/Basic/RISCVVTypes.def" 4457 if

(

->getTriple().isWasm() &&

->hasFeature(

"reference-types"

)) {

4458#define WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS) \ 4459 if (BuiltinType::Id == BuiltinType::WasmExternRef) \ 4461#include "clang/Basic/WebAssemblyReferenceTypes.def" 4464 "shouldn't try to generate type externref outside WebAssembly target"

);

4471 unsigned

NumFields)

const

{

4472 if

(

->hasAArch64SVETypes()) {

4475#define SVE_VECTOR_TYPE_INT(Name, MangledName, Id, SingletonId, NumEls, \ 4476 ElBits, NF, IsSigned) \ 4477 if (EltTy->hasIntegerRepresentation() && !EltTy->isBooleanType() && \ 4478 EltTy->hasSignedIntegerRepresentation() == IsSigned && \ 4479 EltTySize == ElBits && NumElts == (NumEls * NF) && NumFields == 1) { \ 4480 return SingletonId; \ 4482#define SVE_VECTOR_TYPE_FLOAT(Name, MangledName, Id, SingletonId, NumEls, \ 4484 if (EltTy->hasFloatingRepresentation() && !EltTy->isBFloat16Type() && \ 4485 EltTySize == ElBits && NumElts == (NumEls * NF) && NumFields == 1) { \ 4486 return SingletonId; \ 4488#define SVE_VECTOR_TYPE_BFLOAT(Name, MangledName, Id, SingletonId, NumEls, \ 4490 if (EltTy->hasFloatingRepresentation() && EltTy->isBFloat16Type() && \ 4491 EltTySize == ElBits && NumElts == (NumEls * NF) && NumFields == 1) { \ 4492 return SingletonId; \ 4494#define SVE_VECTOR_TYPE_MFLOAT(Name, MangledName, Id, SingletonId, NumEls, \ 4496 if (EltTy->isMFloat8Type() && EltTySize == ElBits && \ 4497 NumElts == (NumEls * NF) && NumFields == 1) { \ 4498 return SingletonId; \ 4500#define SVE_PREDICATE_TYPE_ALL(Name, MangledName, Id, SingletonId, NumEls, NF) \ 4501 if (EltTy->isBooleanType() && NumElts == (NumEls * NF) && NumFields == 1) \ 4503#define SVE_TYPE(Name, Id, SingletonId) 4504#include "clang/Basic/AArch64SVEACLETypes.def" 4505

}

else if

(

->hasRISCVVTypes()) {

4507#define RVV_VECTOR_TYPE(Name, Id, SingletonId, NumEls, ElBits, NF, IsSigned, \ 4509 if (!EltTy->isBooleanType() && \ 4510 ((EltTy->hasIntegerRepresentation() && \ 4511 EltTy->hasSignedIntegerRepresentation() == IsSigned) || \ 4512 (EltTy->hasFloatingRepresentation() && !EltTy->isBFloat16Type() && \ 4514 (EltTy->hasFloatingRepresentation() && EltTy->isBFloat16Type() && \ 4515 IsBF && !IsFP)) && \ 4516 EltTySize == ElBits && NumElts == NumEls && NumFields == NF) \ 4518#define RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls) \ 4519 if (EltTy->isBooleanType() && NumElts == NumEls) \ 4521#include "clang/Basic/RISCVVTypes.def" 4537

llvm::FoldingSetNodeID ID;

4540 void

*InsertPos =

nullptr

;

4541 if

(

VectorType

*VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))

4551 VectorType

*NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);

4552

assert(!NewIP &&

"Shouldn't be in the map!"

); (void)NewIP;

4554 auto

*New =

new

this

alignof

(

VectorType

))

4555 VectorType

(vecType, NumElts, Canonical, VecKind);

4556

VectorTypes.InsertNode(New, InsertPos);

4557

Types.push_back(New);

4564

llvm::FoldingSetNodeID ID;

4567 void

*InsertPos =

nullptr

;

4569

DependentVectorTypes.FindNodeOrInsertPos(ID, InsertPos);

4574

VecType,

(Canon, 0), SizeExpr, AttrLoc, VecKind);

4577 if

(CanonVecTy == VecType) {

4582

DependentVectorTypes.FindNodeOrInsertPos(ID, InsertPos);

4583

assert(!CanonCheck &&

4584 "Dependent-sized vector_size canonical type broken"

);

4586

DependentVectorTypes.InsertNode(New, InsertPos);

4595

Types.push_back(New);

4602 unsigned

NumElts)

const

{

4610

llvm::FoldingSetNodeID ID;

4613 void

*InsertPos =

nullptr

;

4614 if

(

VectorType

*VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))

4624 VectorType

*NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);

4625

assert(!NewIP &&

"Shouldn't be in the map!"

); (void)NewIP;

4629

VectorTypes.InsertNode(New, InsertPos);

4630

Types.push_back(New);

4638

llvm::FoldingSetNodeID ID;

4642 void

*InsertPos =

nullptr

;

4644

= DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);

4654 if

(CanonVecTy == vecType) {

4659

= DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);

4660

assert(!CanonCheck &&

"Dependent-sized ext_vector canonical type broken"

);

4662

DependentSizedExtVectorTypes.InsertNode(New, InsertPos);

4671

Types.push_back(New);

4676 unsigned

NumColumns)

const

{

4677

llvm::FoldingSetNodeID ID;

4679

Type::ConstantMatrix);

4682 "need a valid element type"

);

4685 "need valid matrix dimensions"

);

4686 void

*InsertPos =

nullptr

;

4696

assert(!NewIP &&

"Matrix type shouldn't already exist in the map"

);

4702

MatrixTypes.InsertNode(New, InsertPos);

4703

Types.push_back(New);

4712

llvm::FoldingSetNodeID ID;

4716 void

*InsertPos =

nullptr

;

4718

DependentSizedMatrixTypes.FindNodeOrInsertPos(ID, InsertPos);

4723

ColumnExpr, AttrLoc);

4726

DependentSizedMatrixTypes.FindNodeOrInsertPos(ID, InsertPos);

4727

assert(!CanonCheck &&

"Dependent-sized matrix canonical type broken"

);

4729

DependentSizedMatrixTypes.InsertNode(Canon, InsertPos);

4730

Types.push_back(Canon);

4743

ColumnExpr, AttrLoc);

4744

Types.push_back(New);

4749 Expr

*AddrSpaceExpr,

4755 void

*insertPos =

nullptr

;

4756

llvm::FoldingSetNodeID ID;

4761

DependentAddressSpaceTypes.FindNodeOrInsertPos(ID, insertPos);

4767

DependentAddressSpaceTypes.InsertNode(canonTy, insertPos);

4768

Types.push_back(canonTy);

4771 if

(canonPointeeType == PointeeType &&

4777

AddrSpaceExpr, AttrLoc);

4778

Types.push_back(sugaredType);

4784 return T

.isCanonical() &&

4802

llvm::FoldingSetNodeID ID;

4805 void

*InsertPos =

nullptr

;

4807

FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos))

4817

FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos);

4818

assert(!NewIP &&

"Shouldn't be in the map!"

); (void)NewIP;

4823

Types.push_back(New);

4824

FunctionNoProtoTypes.InsertNode(New, InsertPos);

4840 return

CanResultType;

4847 if

(!NoexceptInType)

4864 bool

AnyPackExpansions =

false

;

4869

AnyPackExpansions =

true

;

4871 return

AnyPackExpansions;

4877QualType

ASTContext::getFunctionTypeInternal(

4880 size_t

NumArgs = ArgArray.size();

4884

llvm::FoldingSetNodeID

;

4889 bool

Unique =

false

;

4891 void

*InsertPos =

nullptr

;

4893

FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) {

4913 bool

IsCanonicalExceptionSpec =

4917 bool

isCanonical = !Unique && IsCanonicalExceptionSpec &&

4919 for

(

unsigned

i = 0; i != NumArgs && isCanonical; ++i)

4920 if

(!ArgArray[i].isCanonicalAsParam())

4921

isCanonical =

false

;

4923 if

(OnlyWantCanonical)

4924

assert(isCanonical &&

4925 "given non-canonical parameters constructing canonical type"

);

4930 if

(!isCanonical && Canonical.

()) {

4932

CanonicalArgs.reserve(NumArgs);

4933 for

(

unsigned

i = 0; i != NumArgs; ++i)

4940 if

(IsCanonicalExceptionSpec) {

4942

}

else if

(NoexceptInType) {

4955 bool

AnyPacks =

false

;

4978

llvm_unreachable(

"dependent noexcept is already canonical"

);

4987

getFunctionTypeInternal(CanResultTy, CanonicalArgs, CanonicalEPI,

true

);

4991

FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos);

4992

assert(!NewIP &&

"Shouldn't be in the map!"

); (void)NewIP;

4997 auto

ESH = FunctionProtoType::getExceptionSpecSize(

4999 size_t Size

= FunctionProtoType::totalSizeToAlloc<

5006

ESH.NumExprPtr, ESH.NumFunctionDeclPtr,

5014

Types.push_back(FTP);

5016

FunctionProtoTypes.InsertNode(FTP, InsertPos);

5018

AnyFunctionEffects =

true

;

5023

llvm::FoldingSetNodeID

;

5026 void

*InsertPos =

nullptr

;

5027 if

(

PipeType

*PT = PipeTypes.FindNodeOrInsertPos(ID, InsertPos))

5033 if

.isCanonical()) {

5037 PipeType

*NewIP = PipeTypes.FindNodeOrInsertPos(ID, InsertPos);

5038

assert(!NewIP &&

"Shouldn't be in the map!"

);

5041 auto

*New =

new

this

alignof

(

PipeType

))

PipeType

(

, Canonical, ReadOnly);

5042

Types.push_back(New);

5043

PipeTypes.InsertNode(New, InsertPos);

5054 return

getPipeType(

true

);

5058 return

getPipeType(

false

);

5062

llvm::FoldingSetNodeID ID;

5065 void

*InsertPos =

nullptr

;

5066 if

(

BitIntType

*EIT = BitIntTypes.FindNodeOrInsertPos(ID, InsertPos))

5070

BitIntTypes.InsertNode(New, InsertPos);

5071

Types.push_back(New);

5076 Expr

*NumBitsExpr)

const

{

5078

llvm::FoldingSetNodeID ID;

5081 void

*InsertPos =

nullptr

;

5083

DependentBitIntTypes.FindNodeOrInsertPos(ID, InsertPos))

5088

DependentBitIntTypes.InsertNode(New, InsertPos);

5090

Types.push_back(New);

5096 if

(!isa<CXXRecordDecl>(

))

return false

;

5097 const auto

*RD = cast<CXXRecordDecl>(

);

5098 if

(isa<ClassTemplatePartialSpecializationDecl>(RD))

5100 if

(RD->getDescribedClassTemplate() &&

5101

!isa<ClassTemplateSpecializationDecl>(RD))

5112 if

(

->TypeForDecl) {

5113

assert(isa<InjectedClassNameType>(

->TypeForDecl));

5115

assert(PrevDecl->TypeForDecl &&

"previous declaration has no type"

);

5116 Decl

->TypeForDecl = PrevDecl->TypeForDecl;

5117

assert(isa<InjectedClassNameType>(

->TypeForDecl));

5121 Decl

->TypeForDecl = newType;

5122

Types.push_back(newType);

5130

assert(

"Passed null for Decl param"

);

5131

assert(!

->TypeForDecl &&

"TypeForDecl present in slow case"

);

5133 if

(

const auto

*Typedef = dyn_cast<TypedefNameDecl>(

))

5136

assert(!isa<TemplateTypeParmDecl>(

) &&

5137 "Template type parameter types are always available."

);

5139 if

(

const auto

= dyn_cast<RecordDecl>(

)) {

5140

assert(

->isFirstDecl() &&

"struct/union has previous declaration"

);

5143

}

else if

(

const auto

= dyn_cast<EnumDecl>(

)) {

5144

assert(

->isFirstDecl() &&

"enum has previous declaration"

);

5146

}

else if

(

const auto

*Using = dyn_cast<UnresolvedUsingTypenameDecl>(

)) {

5149

llvm_unreachable(

"TypeDecl without a type?"

);

5158 if

->TypeForDecl) {

5159 if

(Underlying.

())

5160

Underlying =

->getUnderlyingType();

5163 Decl

->TypeForDecl = NewType;

5164

Types.push_back(NewType);

5167 if

(Underlying.

() ||

->getUnderlyingType() == Underlying)

5171

llvm::FoldingSetNodeID ID;

5174 void

*InsertPos =

nullptr

;

5175 if

(

TypedefType

= TypedefTypes.FindNodeOrInsertPos(ID, InsertPos)) {

5176

assert(!

->typeMatchesDecl() &&

5177 "non-divergent case should be handled with TypeDecl"

);

5181 void

*Mem =

Allocate

(TypedefType::totalSizeToAlloc<QualType>(

true

5183 auto

*NewType =

new

(Mem)

TypedefType

(Type::Typedef,

, Underlying,

5185

TypedefTypes.InsertNode(NewType, InsertPos);

5186

Types.push_back(NewType);

5192

llvm::FoldingSetNodeID ID;

5195 void

*InsertPos =

nullptr

;

5196 if

(

UsingType

= UsingTypes.FindNodeOrInsertPos(ID, InsertPos))

5199 const Type

*TypeForDecl =

5200

cast<TypeDecl>(

->getTargetDecl())->getTypeForDecl();

5206 if

(Underlying.

getTypePtr

() == TypeForDecl)

5209 Allocate

(UsingType::totalSizeToAlloc<QualType>(!Underlying.

()),

5212

Types.push_back(NewType);

5213

UsingTypes.InsertNode(NewType, InsertPos);

5221 if

(PrevDecl->TypeForDecl)

5222 return QualType

(

->TypeForDecl = PrevDecl->TypeForDecl, 0);

5225 Decl

->TypeForDecl = newType;

5226

Types.push_back(newType);

5234 if

(PrevDecl->TypeForDecl)

5235 return QualType

(

->TypeForDecl = PrevDecl->TypeForDecl, 0);

5238 Decl

->TypeForDecl = newType;

5239

Types.push_back(newType);

5244 unsigned

NumPositiveBits,

5247 unsigned

IntWidth =

->getIntWidth();

5248 unsigned

CharWidth =

->getCharWidth();

5249 unsigned

ShortWidth =

->getShortWidth();

5250 bool

EnumTooLarge =

false

;

5252 if

(NumNegativeBits) {

5256 if

(IsPacked && NumNegativeBits <= CharWidth &&

5257

NumPositiveBits < CharWidth) {

5259

BestWidth = CharWidth;

5260

}

else if

(IsPacked && NumNegativeBits <= ShortWidth &&

5261

NumPositiveBits < ShortWidth) {

5263

BestWidth = ShortWidth;

5264

}

else if

(NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {

5266

BestWidth = IntWidth;

5268

BestWidth =

->getLongWidth();

5270 if

(NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {

5273

BestWidth =

->getLongLongWidth();

5275 if

(NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)

5276

EnumTooLarge =

true

;

5280

BestPromotionType = (BestWidth <= IntWidth ?

: BestType);

5285 if

(IsPacked && NumPositiveBits <= CharWidth) {

5287

BestPromotionType =

;

5288

BestWidth = CharWidth;

5289

}

else if

(IsPacked && NumPositiveBits <= ShortWidth) {

5291

BestPromotionType =

;

5292

BestWidth = ShortWidth;

5293

}

else if

(NumPositiveBits <= IntWidth) {

5295

BestWidth = IntWidth;

5296

BestPromotionType = (NumPositiveBits == BestWidth || !LangOpts.CPlusPlus)

5299

}

else if

(NumPositiveBits <= (BestWidth =

->getLongWidth())) {

5301

BestPromotionType = (NumPositiveBits == BestWidth || !LangOpts.CPlusPlus)

5305

BestWidth =

->getLongLongWidth();

5306 if

(NumPositiveBits > BestWidth) {

5311

EnumTooLarge =

true

;

5314

BestPromotionType = (NumPositiveBits == BestWidth || !LangOpts.CPlusPlus)

5319 return

EnumTooLarge;

5324 if

(

->TypeForDecl)

5329 if

(CanonicalDecl->TypeForDecl)

5330 return QualType

(

->TypeForDecl = CanonicalDecl->TypeForDecl, 0);

5334 Decl

->TypeForDecl = newType;

5335

Types.push_back(newType);

5342 const Attr

*attr)

const

{

5343

llvm::FoldingSetNodeID id;

5346 void

*insertPos =

nullptr

;

5350

assert(!

attr

->getKind() == attrKind);

5356

Types.push_back(

);

5357

AttributedTypes.InsertNode(

, insertPos);

5370 switch

(nullability) {

5386

llvm_unreachable(

"Unknown nullability kind"

);

5391

llvm::FoldingSetNodeID ID;

5394 void

*InsertPos =

nullptr

;

5396

BTFTagAttributedTypes.FindNodeOrInsertPos(ID, InsertPos);

5404

Types.push_back(Ty);

5405

BTFTagAttributedTypes.InsertNode(Ty, InsertPos);

5414

llvm::FoldingSetNodeID ID;

5417 void

*InsertPos =

nullptr

;

5419

HLSLAttributedResourceTypes.FindNodeOrInsertPos(ID, InsertPos);

5426

Types.push_back(Ty);

5427

HLSLAttributedResourceTypes.InsertNode(Ty, InsertPos);

5433 QualType

Replacement,

*AssociatedDecl,

unsigned

Index,

5434

std::optional<unsigned> PackIndex,

5436

llvm::FoldingSetNodeID ID;

5439 void

*InsertPos =

nullptr

;

5441

SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);

5444 void

*Mem =

Allocate

(SubstTemplateTypeParmType::totalSizeToAlloc<QualType>(

5445

!Replacement.isCanonical()),

5448

Index, PackIndex, Flag);

5449

Types.push_back(SubstParm);

5450

SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);

5459 unsigned

Index,

bool

Final,

5466

llvm::FoldingSetNodeID ID;

5469 void

*InsertPos =

nullptr

;

5471

SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos))

5481

[[maybe_unused]]

const auto

*Nothing =

5482

SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos);

5490

Types.push_back(SubstParm);

5491

SubstTemplateTypeParmPackTypes.InsertNode(SubstParm, InsertPos);

5501

llvm::FoldingSetNodeID ID;

5503 void

*InsertPos =

nullptr

;

5505

= TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);

5516

= TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);

5517

assert(!TypeCheck &&

"Template type parameter canonical type broken"

);

5521

Depth, Index, ParameterPack,

nullptr

());

5523

Types.push_back(TypeParm);

5524

TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos);

5534

assert(!Name.getAsDependentTemplateName() &&

5535 "No dependent template names here!"

);

5546 for

(

unsigned

i = 0, e = TL.

getNumArgs

(); i != e; ++i)

5556 "No dependent template names here!"

);

5559

ArgVec.reserve(Args.size());

5561

ArgVec.push_back(Arg.getArgument());

5569 if

(Arg.isPackExpansion())

5581 "No dependent template names here!"

);

5586 if

(!Underlying.

())

5592 "Caller must compute aliased type"

);

5593

IsTypeAlias =

false

;

5602

(IsTypeAlias ?

sizeof

(

) : 0),

5606

IsTypeAlias ? Underlying :

());

5608

Types.push_back(Spec);

5615 "No dependent template names here!"

);

5624 bool

AnyNonCanonArgs =

false

;

5630

llvm::FoldingSetNodeID ID;

5632

CanonArgs, *

this

);

5634 void

*InsertPos =

nullptr

;

5636

= TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);

5646

Types.push_back(Spec);

5647

TemplateSpecializationTypes.InsertNode(Spec, InsertPos);

5651 "Non-dependent template-id type must have a canonical type"

);

5658 TagDecl

*OwnedTagDecl)

const

{

5659

llvm::FoldingSetNodeID ID;

5662 void

*InsertPos =

nullptr

;

5663 ElaboratedType

= ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);

5670 ElaboratedType

*CheckT = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);

5671

assert(!CheckT &&

"Elaborated canonical type broken"

);

5676 Allocate

(ElaboratedType::totalSizeToAlloc<TagDecl *>(!!OwnedTagDecl),

5678 T

new

(Mem)

ElaboratedType

(Keyword, NNS, NamedType, Canon, OwnedTagDecl);

5680

Types.push_back(

);

5681

ElaboratedTypes.InsertNode(

, InsertPos);

5687

llvm::FoldingSetNodeID ID;

5690 void

*InsertPos =

nullptr

;

5691 ParenType

= ParenTypes.FindNodeOrInsertPos(ID, InsertPos);

5698 ParenType

*CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);

5699

assert(!CheckT &&

"Paren canonical type broken"

);

5704

Types.push_back(

);

5705

ParenTypes.InsertNode(

, InsertPos);

5718

Types.push_back(newType);

5728 if

(CanonNNS != NNS)

5732

llvm::FoldingSetNodeID ID;

5735 void

*InsertPos =

nullptr

;

5737

= DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos);

5743

Types.push_back(

);

5744

DependentNameTypes.InsertNode(

, InsertPos);

5753 for

(

unsigned

I = 0,

= Args.size(); I !=

; ++I)

5765 "nested-name-specifier must be dependent"

);

5767

llvm::FoldingSetNodeID ID;

5771 void

*InsertPos =

nullptr

;

5773

= DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);

5783 bool

AnyNonCanonArgs =

false

;

5788 if

(AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) {

5794

[[maybe_unused]]

auto

*Nothing =

5795

DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);

5796

assert(!Nothing &&

"canonical type broken"

);

5804

Types.push_back(

);

5805

DependentTemplateSpecializationTypes.InsertNode(

, InsertPos);

5811 if

(

const auto

*TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {

5817

}

else if

(

auto

*NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {

5819

NTTP->getType().getNonPackExpansionType().getNonLValueExprType(*

this

);

5834 Expr

new

(*this)

5836 T

, VK, NTTP->getLocation());

5838 if

(NTTP->isParameterPack())

5843 auto

*TTP = cast<TemplateTemplateParmDecl>(Param);

5860

std::optional<unsigned> NumExpansions,

5861 bool

ExpectPackInType)

const

{

5863 "Pack expansions must expand one or more parameter packs"

);

5865

llvm::FoldingSetNodeID ID;

5868 void

*InsertPos =

nullptr

;

5880

PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);

5885

Types.push_back(

);

5886

PackExpansionTypes.InsertNode(

, InsertPos);

5898 if

(Protocols.empty())

return true

;

5903 for

(

unsigned

i = 1; i != Protocols.size(); ++i)

5913

llvm::array_pod_sort(Protocols.begin(), Protocols.end(),

CmpProtocolNames

);

5917 P

->getCanonicalDecl();

5920 auto

ProtocolsEnd = std::unique(Protocols.begin(), Protocols.end());

5921

Protocols.erase(ProtocolsEnd, Protocols.end());

5926 unsigned

NumProtocols)

const

{

5936 bool

isKindOf)

const

{

5939 if

(typeArgs.empty() && protocols.empty() && !isKindOf &&

5940

isa<ObjCInterfaceType>(baseType))

5944

llvm::FoldingSetNodeID ID;

5946 void

*InsertPos =

nullptr

;

5947 if

(

ObjCObjectType

*QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos))

5954 if

(effectiveTypeArgs.empty()) {

5956

effectiveTypeArgs = baseObject->getTypeArgs();

5963 bool

typeArgsAreCanonical = llvm::all_of(

5966 if

(!typeArgsAreCanonical || !protocolsSorted || !baseType.

isCanonical

()) {

5970 if

(!typeArgsAreCanonical) {

5971

canonTypeArgsVec.reserve(effectiveTypeArgs.size());

5972 for

(

auto

typeArg : effectiveTypeArgs)

5974

canonTypeArgs = canonTypeArgsVec;

5976

canonTypeArgs = effectiveTypeArgs;

5981 if

(!protocolsSorted) {

5982

canonProtocolsVec.append(protocols.begin(), protocols.end());

5984

canonProtocols = canonProtocolsVec;

5986

canonProtocols = protocols;

5990

canonProtocols, isKindOf);

5993

ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos);

5997

size += typeArgs.size() *

sizeof

(

);

6004

Types.push_back(

);

6005

ObjCObjectTypes.InsertNode(

, InsertPos);

6015 bool

allowOnPointerType)

const

{

6018 if

(

const auto

*objT = dyn_cast<ObjCTypeParamType>(

.getTypePtr())) {

6023 if

(allowOnPointerType) {

6024 if

(

const auto

*objPtr =

6025

dyn_cast<ObjCObjectPointerType>(

.getTypePtr())) {

6031

protocolsVec.append(protocols.begin(), protocols.end());

6043 if

(

const auto

*objT = dyn_cast<ObjCObjectType>(

.getTypePtr())){

6048

objT->getTypeArgsAsWritten(),

6050

objT->isKindOfTypeAsWritten());

6054 if

(

->isObjCObjectType()) {

6064 if

(

->isObjCIdType()) {

6067

objPtr->isKindOfType());

6072 if

(

->isObjCClassType()) {

6075

objPtr->isKindOfType());

6087

llvm::FoldingSetNodeID ID;

6089 void

*InsertPos =

nullptr

;

6091

ObjCTypeParamTypes.FindNodeOrInsertPos(ID, InsertPos))

6096 if

(!protocols.empty()) {

6100

Canonical, protocols, hasError,

true

));

6101

assert(!hasError &&

"Error when apply protocol qualifier to bound type"

);

6109

Types.push_back(newType);

6110

ObjCTypeParamTypes.InsertNode(newType, InsertPos);

6118 auto

NewTypeParamTy = cast<ObjCTypeParamType>(New->

getTypeForDecl

());

6120

protocols.append(NewTypeParamTy->qual_begin(), NewTypeParamTy->qual_end());

6135 for

(

auto

*Proto : OPT->quals()) {

6158 if

(InheritedProtocols.empty())

6162 bool

Conforms =

false

;

6163 for

(

auto

*Proto : OPT->quals()) {

6165 for

(

auto

*PI : InheritedProtocols) {

6177 for

(

auto

*PI : InheritedProtocols) {

6179 bool

Adopts =

false

;

6180 for

(

auto

*Proto : OPT->quals()) {

6194

llvm::FoldingSetNodeID ID;

6197 void

*InsertPos =

nullptr

;

6199

ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos))

6208

ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos);

6217

Types.push_back(QType);

6218

ObjCObjectPointerTypes.InsertNode(QType, InsertPos);

6226 if

(

->TypeForDecl)

6230

assert(PrevDecl->TypeForDecl &&

"previous decl has no TypeForDecl"

);

6231 Decl

->TypeForDecl = PrevDecl->TypeForDecl;

6232 return QualType

(PrevDecl->TypeForDecl, 0);

6241 Decl

->TypeForDecl =

;

6242

Types.push_back(

);

6254

llvm::FoldingSetNodeID ID;

6258 void

*InsertPos =

nullptr

;

6260

DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos);

6270

DependentTypeOfExprTypes.InsertNode(Canon, InsertPos);

6278

Types.push_back(toe);

6289 auto

*tot =

new

this

alignof

(

TypeOfType

))

6290 TypeOfType

this

, tofType, Canonical, Kind);

6291

Types.push_back(tot);

6315

llvm_unreachable(

"Unknown value kind"

);

6330

llvm::FoldingSetNodeID ID;

6333 void

*InsertPos =

nullptr

;

6335

= DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos);

6340

DependentDecltypeTypes.InsertNode(Canon, InsertPos);

6348

Types.push_back(dt);

6353 bool

FullySubstituted,

6357 if

(FullySubstituted && Index != -1) {

6360

llvm::FoldingSetNodeID ID;

6363 void

*InsertPos =

nullptr

;

6365

DependentPackIndexingTypes.FindNodeOrInsertPos(ID, InsertPos);

6368

PackIndexingType::totalSizeToAlloc<QualType>(Expansions.size()),

6372

IndexExpr, FullySubstituted, Expansions);

6373

DependentPackIndexingTypes.InsertNode(Canon, InsertPos);

6379 Allocate

(PackIndexingType::totalSizeToAlloc<QualType>(Expansions.size()),

6382

FullySubstituted, Expansions);

6383

Types.push_back(

);

6397

llvm::FoldingSetNodeID ID;

6400 void

*InsertPos =

nullptr

;

6402

= DependentUnaryTransformTypes.FindNodeOrInsertPos(ID, InsertPos);

6408

DependentUnaryTransformTypes.InsertNode(Canon, InsertPos);

6417

Types.push_back(ut);

6421QualType

ASTContext::getAutoTypeInternal(

6426

!TypeConstraintConcept && !IsDependent)

6430

llvm::FoldingSetNodeID ID;

6431 bool

IsDeducedDependent =

6434

IsDependent || IsDeducedDependent, TypeConstraintConcept,

6435

TypeConstraintArgs);

6436 if

(

auto const

AT_iter = AutoTypes.find(ID); AT_iter != AutoTypes.end())

6437 return QualType

(AT_iter->getSecond(), 0);

6443

}

else if

(TypeConstraintConcept) {

6444 bool

AnyNonCanonArgs =

false

;

6447

this

, TypeConstraintArgs, AnyNonCanonArgs);

6448 if

(CanonicalConcept != TypeConstraintConcept || AnyNonCanonArgs) {

6450

getAutoTypeInternal(

(), Keyword, IsDependent, IsPack,

6451

CanonicalConcept, CanonicalConceptArgs,

true

);

6461

(IsDependent ? TypeDependence::DependentInstantiation

6462

: TypeDependence::None) |

6463

(IsPack ? TypeDependence::UnexpandedPack : TypeDependence::None),

6464

Canon, TypeConstraintConcept, TypeConstraintArgs);

6466

llvm::FoldingSetNodeID InsertedID;

6467

AT->

(InsertedID, *

this

);

6468

assert(InsertedID == ID &&

"ID does not match"

);

6470

Types.push_back(AT);

6471

AutoTypes.try_emplace(ID, AT);

6480 bool

IsDependent,

bool

IsPack,

6483

assert((!IsPack || IsDependent) &&

"only use IsPack for a dependent pack"

);

6485 "A dependent auto should be undeduced"

);

6486 return

getAutoTypeInternal(

DeducedType

, Keyword, IsDependent, IsPack,

6487

TypeConstraintConcept, TypeConstraintArgs);

6491 QualType

CanonT =

.getNonPackExpansionType().getCanonicalType();

6495 if

(!AT->isConstrained())

6499

AT->containsUnexpandedParameterPack()),

6500 T

.getQualifiers());

6511QualType

ASTContext::getDeducedTemplateSpecializationTypeInternal(

6515 void

*InsertPos =

nullptr

;

6516

llvm::FoldingSetNodeID ID;

6520

DeducedTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos))

6526

llvm::FoldingSetNodeID TempID;

6527

DTST->Profile(TempID);

6528

assert(ID == TempID &&

"ID does not match"

);

6529

Types.push_back(DTST);

6530

DeducedTemplateSpecializationTypes.InsertNode(DTST, InsertPos);

6540

? getDeducedTemplateSpecializationTypeInternal(

6544 return

getDeducedTemplateSpecializationTypeInternal(Template,

DeducedType

6545

IsDependent, Canon);

6553

llvm::FoldingSetNodeID ID;

6556 void

*InsertPos =

nullptr

;

6557 if

(

AtomicType

*AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos))

6563 if

.isCanonical()) {

6567 AtomicType

*NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos);

6568

assert(!NewIP &&

"Shouldn't be in the map!"

); (void)NewIP;

6571

Types.push_back(New);

6572

AtomicTypes.InsertNode(New, InsertPos);

6608 return

getFromTargetType(

->getSizeType());

6614 return

getFromTargetType(

->getSignedSizeType());

6619 return

getFromTargetType(

->getIntMaxType());

6624 return

getFromTargetType(

->getUIntMaxType());

6642 return

getFromTargetType(

->getIntPtrType());

6665 return

getFromTargetType(

->getProcessIDType());

6677 const Type

*Ty =

.getTypePtr();

6681

}

else if

(isa<ArrayType>(Ty)) {

6683

}

else if

(isa<FunctionType>(Ty)) {

6705

quals = splitType.

;

6710 QualType

elementType = AT->getElementType();

6715 if

(elementType == unqualElementType) {

6716

assert(quals.

empty

());

6717

quals = splitType.

;

6725 if

(

const auto

*CAT = dyn_cast<ConstantArrayType>(AT)) {

6727

CAT->getSizeExpr(), CAT->getSizeModifier(), 0);

6730 if

(

const auto

*IAT = dyn_cast<IncompleteArrayType>(AT)) {

6734 if

(

const auto

*VAT = dyn_cast<VariableArrayType>(AT)) {

6737

VAT->getSizeModifier(),

6738

VAT->getIndexTypeCVRQualifiers(),

6739

VAT->getBracketsRange());

6742 const auto

*DSAT = cast<DependentSizedArrayType>(AT);

6744

DSAT->getSizeModifier(), 0,

6755 bool

AllowPiMismatch)

const

{

6770 if

(

auto

*CAT1 = dyn_cast<ConstantArrayType>(AT1)) {

6771 auto

*CAT2 = dyn_cast<ConstantArrayType>(AT2);

6772 if

(!((CAT2 && CAT1->getSize() == CAT2->getSize()) ||

6774

isa<IncompleteArrayType>(AT2))))

6776

}

else if

(isa<IncompleteArrayType>(AT1)) {

6777 if

(!(isa<IncompleteArrayType>(AT2) ||

6779

isa<ConstantArrayType>(AT2))))

6785

T1 = AT1->getElementType();

6786

T2 = AT2->getElementType();

6806 bool

AllowPiMismatch)

const

{

6811 if

(T1PtrType && T2PtrType) {

6819 if

(T1MPType && T2MPType &&

6830 if

(T1OPType && T2OPType) {

6862 if

(Quals1 != Quals2)

6876 switch

(Name.getKind()) {

6911

= Name.getAsSubstTemplateTemplateParm();

6918

= Name.getAsSubstTemplateTemplateParmPack();

6931

llvm_unreachable(

"bad template name kind!"

);

6937 if

(!TP->hasDefaultArgument())

6939 return

&TP->getDefaultArgument().getArgument();

6941 switch

(

->getKind()) {

6942 case

NamedDecl::TemplateTypeParm:

6943 return

handleParam(cast<TemplateTypeParmDecl>(

));

6944 case

NamedDecl::NonTypeTemplateParm:

6945 return

handleParam(cast<NonTypeTemplateParmDecl>(

));

6946 case

NamedDecl::TemplateTemplateParm:

6947 return

handleParam(cast<TemplateTemplateParmDecl>(

));

6949

llvm_unreachable(

"Unexpected template parameter kind"

);

6954 bool

IgnoreDeduced)

const

{

6955 while

(std::optional<TemplateName> UnderlyingOrNone =

6956

Name.desugar(IgnoreDeduced))

6957

Name = *UnderlyingOrNone;

6959 switch

(Name.getKind()) {

6962 if

(

auto

*TTP = dyn_cast<TemplateTemplateParmDecl>(Template))

6963

Template = getCanonicalTemplateTemplateParmDecl(TTP);

6971

llvm_unreachable(

"cannot canonicalize unresolved template"

);

6975

assert(DTN &&

"Non-dependent template names must refer to template decls."

);

6976 return

DTN->CanonicalTemplateName;

6981

Name.getAsSubstTemplateTemplateParmPack();

6989

assert(IgnoreDeduced ==

false

);

6996 bool

NonCanonical = CanonUnderlying != Underlying;

7002

assert(CanonArgs.size() <= Params.size());

7008 for

(

int

I = CanonArgs.size() - 1; I >= 0; --I) {

7017 if

(I ==

int

(CanonArgs.size() - 1))

7018

CanonArgs.pop_back();

7019

NonCanonical =

true

;

7029

llvm_unreachable(

"always sugar node"

);

7032

llvm_unreachable(

"bad template name!"

);

7037 bool

IgnoreDeduced)

const

{

7049

llvm::FoldingSetNodeID XCEID, YCEID;

7050

XCE->

(XCEID, *

this

true

);

7051

YCE->

(YCEID, *

this

true

);

7052 return

XCEID == YCEID;

7098 if

(

->getKind() != Y->

())

7101 if

(

auto

*TX = dyn_cast<TemplateTypeParmDecl>(

)) {

7102 auto

*TY = cast<TemplateTypeParmDecl>(Y);

7103 if

(TX->isParameterPack() != TY->isParameterPack())

7105 if

(TX->hasTypeConstraint() != TY->hasTypeConstraint())

7108

TY->getTypeConstraint());

7111 if

(

auto

*TX = dyn_cast<NonTypeTemplateParmDecl>(

)) {

7112 auto

*TY = cast<NonTypeTemplateParmDecl>(Y);

7113 return

TX->isParameterPack() == TY->isParameterPack() &&

7114

TX->getASTContext().hasSameType(TX->getType(), TY->getType()) &&

7116

TY->getPlaceholderTypeConstraint());

7119 auto

*TX = cast<TemplateTemplateParmDecl>(

);

7120 auto

*TY = cast<TemplateTemplateParmDecl>(Y);

7121 return

TX->isParameterPack() == TY->isParameterPack() &&

7123

TY->getTemplateParameters());

7128 if

(

->size() != Y->

size

())

7131 for

(

unsigned

I = 0, N =

->size(); I != N; ++I)

7145 if

(

auto

*TTPX = dyn_cast<TemplateTypeParmDecl>(

)) {

7146 auto

*TTPY = cast<TemplateTypeParmDecl>(Y);

7147 if

(!TTPX->hasDefaultArgument() || !TTPY->hasDefaultArgument())

7150 return hasSameType

(TTPX->getDefaultArgument().getArgument().getAsType(),

7151

TTPY->getDefaultArgument().getArgument().getAsType());

7154 if

(

auto

*NTTPX = dyn_cast<NonTypeTemplateParmDecl>(

)) {

7155 auto

*NTTPY = cast<NonTypeTemplateParmDecl>(Y);

7156 if

(!NTTPX->hasDefaultArgument() || !NTTPY->hasDefaultArgument())

7159 Expr

*DefaultArgumentX =

7160

NTTPX->getDefaultArgument().getArgument().getAsExpr()->

IgnoreImpCasts

();

7161 Expr

*DefaultArgumentY =

7162

NTTPY->getDefaultArgument().getArgument().getAsExpr()->

IgnoreImpCasts

();

7163

llvm::FoldingSetNodeID XID, YID;

7164

DefaultArgumentX->

(XID, *

this

true

);

7165

DefaultArgumentY->

(YID, *

this

true

);

7169 auto

*TTPX = cast<TemplateTemplateParmDecl>(

);

7170 auto

*TTPY = cast<TemplateTemplateParmDecl>(Y);

7172 if

(!TTPX->hasDefaultArgument() || !TTPY->hasDefaultArgument())

7181 if

(

auto

*NS =

->getAsNamespace())

7183 if

(

auto

*NAS =

->getAsNamespaceAlias())

7184 return

NAS->getNamespace();

7192 if

(!NSY || NSX->getCanonicalDecl() != NSY->getCanonicalDecl())

7194

}

else if

(

->getKind() != Y->

())

7199 switch

(

->getKind()) {

7210 if

(

->getAsType()->getCanonicalTypeInternal() !=

7220 auto

*PX =

->getPrefix();

7234

llvm::FoldingSetNodeID Cand1ID, Cand2ID;

7238 for

(

auto

Pair : zip_longest(AEnableIfAttrs, BEnableIfAttrs)) {

7239

std::optional<EnableIfAttr *> Cand1A = std::get<0>(Pair);

7240

std::optional<EnableIfAttr *> Cand2A = std::get<1>(Pair);

7243 if

(!Cand1A || !Cand2A)

7249

(*Cand1A)->getCond()->Profile(Cand1ID, A->

getASTContext

(),

true

);

7250

(*Cand2A)->getCond()->Profile(Cand2ID, B->

getASTContext

(),

true

);

7254 if

(Cand1ID != Cand2ID)

7282 if

(

const auto

*TypedefX = dyn_cast<TypedefNameDecl>(

))

7283 if

(

const auto

*TypedefY = dyn_cast<TypedefNameDecl>(Y))

7284 return hasSameType

(TypedefX->getUnderlyingType(),

7285

TypedefY->getUnderlyingType());

7288 if

(

->getKind() != Y->

())

7292 if

(isa<ObjCInterfaceDecl>(

) || isa<ObjCProtocolDecl>(

))

7295 if

(isa<ClassTemplateSpecializationDecl>(

)) {

7302 if

(

const auto

*TagX = dyn_cast<TagDecl>(

)) {

7303 const auto

*TagY = cast<TagDecl>(Y);

7304 return

(TagX->getTagKind() == TagY->getTagKind()) ||

7316 if

(

const auto

*FuncX = dyn_cast<FunctionDecl>(

)) {

7317 const auto

*FuncY = cast<FunctionDecl>(Y);

7318 if

(

const auto

*CtorX = dyn_cast<CXXConstructorDecl>(

)) {

7319 const auto

*CtorY = cast<CXXConstructorDecl>(Y);

7320 if

(CtorX->getInheritedConstructor() &&

7321

isSameEntity

(CtorX->getInheritedConstructor().getConstructor(),

7322

CtorY->getInheritedConstructor().getConstructor()))

7326 if

(FuncX->isMultiVersion() != FuncY->isMultiVersion())

7331 if

(FuncX->isMultiVersion()) {

7332 const auto

*TAX = FuncX->getAttr<TargetAttr>();

7333 const auto

*TAY = FuncY->getAttr<TargetAttr>();

7334

assert(TAX && TAY &&

"Multiversion Function without target attribute"

);

7336 if

(TAX->getFeaturesStr() != TAY->getFeaturesStr())

7342 if

((FuncX->isMemberLikeConstrainedFriend() ||

7343

FuncY->isMemberLikeConstrainedFriend()) &&

7344

!FuncX->getLexicalDeclContext()->Equals(

7345

FuncY->getLexicalDeclContext())) {

7350

FuncY->getTrailingRequiresClause()))

7358

FD = FD->getCanonicalDecl();

7359 return

FD->getTypeSourceInfo() ? FD->getTypeSourceInfo()->getType()

7362 QualType

XT = GetTypeAsWritten(FuncX), YT = GetTypeAsWritten(FuncY);

7369 if

(

().CPlusPlus17 && XFPT && YFPT &&

7377 return

FuncX->getLinkageInternal() == FuncY->getLinkageInternal() &&

7382 if

(

const auto

*VarX = dyn_cast<VarDecl>(

)) {

7383 const auto

*VarY = cast<VarDecl>(Y);

7384 if

(VarX->getLinkageInternal() == VarY->getLinkageInternal()) {

7387 if

(VarX->getType().isNull() || VarY->getType().isNull())

7390 if

(

hasSameType

(VarX->getType(), VarY->getType()))

7400 if

(!VarXTy || !VarYTy)

7409 if

(

const auto

*NamespaceX = dyn_cast<NamespaceDecl>(

)) {

7410 const auto

*NamespaceY = cast<NamespaceDecl>(Y);

7411 return

NamespaceX->isInline() == NamespaceY->isInline();

7416 if

(

const auto

*TemplateX = dyn_cast<TemplateDecl>(

)) {

7417 const auto

*TemplateY = cast<TemplateDecl>(Y);

7420 if

(

const auto

*ConceptX = dyn_cast<ConceptDecl>(

)) {

7421 const auto

*ConceptY = cast<ConceptDecl>(Y);

7423

ConceptY->getConstraintExpr()))

7428

TemplateY->getTemplatedDecl()) &&

7430

TemplateY->getTemplateParameters());

7434 if

(

const auto

*FDX = dyn_cast<FieldDecl>(

)) {

7435 const auto

*FDY = cast<FieldDecl>(Y);

7437 return hasSameType

(FDX->getType(), FDY->getType());

7441 if

(

const auto

*IFDX = dyn_cast<IndirectFieldDecl>(

)) {

7442 const auto

*IFDY = cast<IndirectFieldDecl>(Y);

7443 return

IFDX->getAnonField()->getCanonicalDecl() ==

7444

IFDY->getAnonField()->getCanonicalDecl();

7448 if

(isa<EnumConstantDecl>(

))

7453 if

(

const auto

*USX = dyn_cast<UsingShadowDecl>(

)) {

7454 const auto

*USY = cast<UsingShadowDecl>(Y);

7460 if

(

const auto

*UX = dyn_cast<UsingDecl>(

)) {

7461 const auto

*UY = cast<UsingDecl>(Y);

7463

UX->hasTypename() == UY->hasTypename() &&

7464

UX->isAccessDeclaration() == UY->isAccessDeclaration();

7466 if

(

const auto

*UX = dyn_cast<UnresolvedUsingValueDecl>(

)) {

7467 const auto

*UY = cast<UnresolvedUsingValueDecl>(Y);

7469

UX->isAccessDeclaration() == UY->isAccessDeclaration();

7471 if

(

const auto

*UX = dyn_cast<UnresolvedUsingTypenameDecl>(

)) {

7474

cast<UnresolvedUsingTypenameDecl>(Y)->getQualifier());

7479 if

(

const auto

*UX = dyn_cast<UsingPackDecl>(

)) {

7481

UX->getInstantiatedFromUsingDecl(),

7482

cast<UsingPackDecl>(Y)->getInstantiatedFromUsingDecl());

7486 if

(

const auto

*NAX = dyn_cast<NamespaceAliasDecl>(

)) {

7487 const auto

*NAY = cast<NamespaceAliasDecl>(Y);

7488 return

NAX->getNamespace()->Equals(NAY->getNamespace());

7535 bool

AnyNonCanonArgs =

false

;

7538 if

(!AnyNonCanonArgs)

7541 const_cast<ASTContext

>

this

), CanonArgs);

7548

llvm_unreachable(

"Unhandled template argument kind"

);

7591

DNT->getIdentifier());

7605

llvm_unreachable(

"Invalid NestedNameSpecifier::Kind!"

);

7610 if

.hasLocalQualifiers()) {

7612 if

(

const auto

*AT = dyn_cast<ArrayType>(

))

7617 if

(!isa<ArrayType>(

.getCanonicalType()))

7632 const auto

*ATy = dyn_cast<ArrayType>(split.

);

7633 if

(!ATy || qs.

empty

())

7640 if

(

const auto

*CAT = dyn_cast<ConstantArrayType>(ATy))

7643

CAT->getSizeModifier(),

7644

CAT->getIndexTypeCVRQualifiers()));

7645 if

(

const auto

*IAT = dyn_cast<IncompleteArrayType>(ATy))

7647

IAT->getSizeModifier(),

7648

IAT->getIndexTypeCVRQualifiers()));

7650 if

(

const auto

*DSAT = dyn_cast<DependentSizedArrayType>(ATy))

7651 return

cast<ArrayType>(

7653

DSAT->getSizeExpr(),

7654

DSAT->getSizeModifier(),

7655

DSAT->getIndexTypeCVRQualifiers(),

7656

DSAT->getBracketsRange()));

7658 const auto

*VAT = cast<VariableArrayType>(ATy);

7661

VAT->getSizeModifier(),

7662

VAT->getIndexTypeCVRQualifiers(),

7663

VAT->getBracketsRange()));

7677 return T

.getUnqualifiedType();

7690 return T

.getUnqualifiedType();

7705

assert(PrettyArrayType &&

"Not an array type!"

);

7742

uint64_t ElementCount = 1;

7745

CA = dyn_cast_or_null<ConstantArrayType>(

7748 return

ElementCount;

7756

uint64_t ElementCount = 1;

7760

AILE = dyn_cast<ArrayInitLoopExpr>(AILE->

getSubExpr

());

7763 return

ElementCount;

7773 default

: llvm_unreachable(

"getFloatingRank(): not a floating type"

);

7775 case

BuiltinType::Half:

return HalfRank

;

7776 case

BuiltinType::Float:

return FloatRank

;

7777 case

BuiltinType::Double:

return DoubleRank

;

7781 case

BuiltinType::Ibm128:

return Ibm128Rank

;

7809unsigned

ASTContext::getIntegerRank(

const Type

)

const

{

7814 if

(

const auto

*EIT = dyn_cast<BitIntType>(

))

7815 return

0 + (EIT->getNumBits() << 3);

7817 switch

(cast<BuiltinType>(

)->getKind()) {

7818 default

: llvm_unreachable(

"getIntegerRank(): not a built-in integer"

);

7819 case

BuiltinType::Bool:

7821 case

BuiltinType::Char_S:

7822 case

BuiltinType::Char_U:

7823 case

BuiltinType::SChar:

7824 case

BuiltinType::UChar:

7826 case

BuiltinType::Short:

7827 case

BuiltinType::UShort:

7829 case

BuiltinType::Int:

7830 case

BuiltinType::UInt:

7832 case

BuiltinType::Long:

7833 case

BuiltinType::ULong:

7835 case

BuiltinType::LongLong:

7836 case

BuiltinType::ULongLong:

7838 case

BuiltinType::Int128:

7839 case

BuiltinType::UInt128:

7844 case

BuiltinType::Char8:

7846 case

BuiltinType::Char16:

7847 return

getIntegerRank(

7849 case

BuiltinType::Char32:

7850 return

getIntegerRank(

7852 case

BuiltinType::WChar_S:

7853 case

BuiltinType::WChar_U:

7854 return

getIntegerRank(

7884

uint64_t BitWidth = Field->getBitWidthValue();

7907 if

(

QT = Field->getType(); QT->isBitIntType())

7910 if

(BitWidth < IntSize)

7913 if

(BitWidth == IntSize)

7928

assert(!Promotable.

());

7931 return

ET->getDecl()->getPromotionType();

7940 if

(BT->getKind() == BuiltinType::WChar_S ||

7941

BT->getKind() == BuiltinType::WChar_U ||

7942

BT->getKind() == BuiltinType::Char8 ||

7943

BT->getKind() == BuiltinType::Char16 ||

7944

BT->getKind() == BuiltinType::Char32) {

7945 bool

FromIsSigned = BT->getKind() == BuiltinType::WChar_S;

7949 for

(

const auto

&PT : PromoteTypes) {

7951 if

(FromSize < ToSize ||

7952

(FromSize == ToSize && FromIsSigned == PT->isSignedIntegerType()))

7955

llvm_unreachable(

"char type should fit into long long"

);

7962

uint64_t PromotableSize =

getIntWidth

(Promotable);

7971 while

.isNull()) {

7973 return T

.getObjCLifetime();

8003 if

(

const auto

*ET = dyn_cast<EnumType>(LHSC))

8005 if

(

const auto

*ET = dyn_cast<EnumType>(RHSC))

8008 if

(LHSC == RHSC)

return

8013 unsigned

LHSRank = getIntegerRank(LHSC);

8014 unsigned

RHSRank = getIntegerRank(RHSC);

8016 if

(LHSUnsigned == RHSUnsigned) {

8017 if

(LHSRank == RHSRank)

return

8018 return

LHSRank > RHSRank ? 1 : -1;

8024 if

(LHSRank >= RHSRank)

8034 if

(RHSRank >= LHSRank)

8044 if

(CFConstantStringTypeDecl)

8045 return

CFConstantStringTypeDecl;

8047

assert(!CFConstantStringTagDecl &&

8048 "tag and typedef should be initialized together"

);

8088 if

(

static_cast<unsigned>

(CFRuntime) <

8091

Fields[Count++] = {

"flags"

};

8093

Fields[Count++] = {

"length"

};

8097

Fields[Count++] = { getFromTargetType(

->getUInt64Type()),

"_swift_rc"

};

8101

Fields[Count++] = {

"_ptr"

};

8107 for

(

unsigned

i = 0; i < Count; ++i) {

8111

Fields[i].Type,

nullptr

8114

CFConstantStringTagDecl->

(Field);

8121

CFConstantStringTypeDecl =

8124 return

CFConstantStringTypeDecl;

8128 if

(!CFConstantStringTagDecl)

8130 return

CFConstantStringTagDecl;

8139 if

(ObjCSuperType.

()) {

8144 return

ObjCSuperType;

8149

CFConstantStringTypeDecl = cast<TypedefDecl>(TD->getDecl());

8156 if

(BlockDescriptorType)

8169 static const char

const

FieldNames[] = {

8174 for

(

size_t

i = 0; i < 2; ++i) {

8177

(FieldNames[i]), FieldTypes[i],

nullptr

8185

BlockDescriptorType = RD;

8191 if

(BlockDescriptorExtendedType)

8206 static const char

const

FieldNames[] = {

8213 for

(

size_t

i = 0; i < 4; ++i) {

8216

(FieldNames[i]), FieldTypes[i],

nullptr

8225

BlockDescriptorExtendedType = RD;

8230 const auto

*BT = dyn_cast<BuiltinType>(

);

8233 if

(isa<PipeType>(

))

8239 switch

(BT->getKind()) {

8240#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 8241 case BuiltinType::Id: \ 8243#include "clang/Basic/OpenCLImageTypes.def" 8245 case

BuiltinType::OCLClkEvent:

8248 case

BuiltinType::OCLEvent:

8251 case

BuiltinType::OCLQueue:

8254 case

BuiltinType::OCLReserveID:

8257 case

BuiltinType::OCLSampler:

8276 if

(!copyExpr && record->hasTrivialDestructor())

return false

;

8304

llvm_unreachable(

"impossible"

);

8306

llvm_unreachable(

"fell out of lifetime switch!"

);

8314 bool

&HasByrefExtendedLayout)

const

{

8319

HasByrefExtendedLayout =

false

;

8321

HasByrefExtendedLayout =

true

;

8335

assert(

"Expected target to be initialized"

);

8336 const

llvm::Triple &

->getTriple();

8338 if

(

.isOSWindows() &&

.isArch64Bit())

8344

assert(

"Expected target to be initialized"

);

8345 const

llvm::Triple &

->getTriple();

8347 if

(

.isOSWindows() &&

.isArch64Bit())

8353 if

(!ObjCInstanceTypeDecl)

8354

ObjCInstanceTypeDecl =

8356 return

ObjCInstanceTypeDecl;

8362 if

(

const auto

*TT = dyn_cast<TypedefType>(

))

8364 return

II->isStr(

"BOOL"

);

8372 if

->isIncompleteArrayType() &&

->isIncompleteType())

8381 else if

(

->isArrayType())

8400 if

(

First

->isInlineSpecified() || !

First

->isStaticDataMember())

8407

->isInlineSpecified() && (

->isConstexpr() ||

First

->isConstexpr()))

8438 for

(

auto

*PI :

->parameters()) {

8443

assert(sz.

isPositive

() &&

"BlockExpr - Incomplete param type"

);

8452

ParmOffset = PtrSize;

8453 for

(

auto

*PVDecl :

->parameters()) {

8454 QualType

PType = PVDecl->getOriginalType();

8455 if

(

const auto

*AT =

8459 if

(!isa<ConstantArrayType>(AT))

8460

PType = PVDecl->getType();

8462

PType = PVDecl->getType();

8482 for

(

auto

*PI :

->parameters()) {

8489 "getObjCEncodingForFunctionDecl - Incomplete param type"

);

8496 for

(

auto

*PVDecl :

->parameters()) {

8497 QualType

PType = PVDecl->getOriginalType();

8498 if

(

const auto

*AT =

8502 if

(!isa<ConstantArrayType>(AT))

8503

PType = PVDecl->getType();

8505

PType = PVDecl->getType();

8519 bool

Extended)

const

{

8523

ObjCEncOptions Options = ObjCEncOptions()

8524

.setExpandPointedToStructures()

8525

.setExpandStructures()

8526

.setIsOutermostType();

8528

Options.setEncodeBlockParameters().setEncodeClassNames();

8529

getObjCEncodingForTypeImpl(

, S, Options,

nullptr

);

8535 bool

Extended)

const

{

8540 Decl

->getReturnType(), S, Extended);

8549 E

->sel_param_end(); PI !=

; ++PI) {

8556 "getObjCEncodingForMethodDecl - Incomplete param type"

);

8564

ParmOffset = 2 * PtrSize;

8566 E

->sel_param_end(); PI !=

; ++PI) {

8569 if

(

const auto

*AT =

8573 if

(!isa<ConstantArrayType>(AT))

8578

PType, S, Extended);

8589 const Decl

*Container)

const

{

8592 if

(

const auto

*CID = dyn_cast<ObjCCategoryImplDecl>(Container)) {

8593 for

(

auto

*PID : CID->property_impls())

8594 if

(PID->getPropertyDecl() == PD)

8597 const auto

*OID = cast<ObjCImplementationDecl>(Container);

8598 for

(

auto

*PID : OID->property_impls())

8599 if

(PID->getPropertyDecl() == PD)

8633 const Decl

*Container)

const

{

8635 bool

Dynamic =

false

;

8643

SynthesizePID = PropertyImpDecl;

8647

std::string S =

"T"

;

8692 if

(SynthesizePID) {

8709 if

(BT->getKind() == BuiltinType::ULong &&

getIntWidth

(PointeeTy) == 32)

8712 if

(BT->getKind() == BuiltinType::Long &&

getIntWidth

(PointeeTy) == 32)

8725

getObjCEncodingForTypeImpl(

, S,

8727

.setExpandPointedToStructures()

8728

.setExpandStructures()

8729

.setIsOutermostType(),

8730

Field, NotEncodedT);

8734

std::string& S)

const

{

8738

getObjCEncodingForTypeImpl(

, S,

8740

.setExpandPointedToStructures()

8741

.setExpandStructures()

8742

.setIsOutermostType()

8743

.setEncodingProperty(),

8751 case

BuiltinType::Void:

return 'v'

;

8752 case

BuiltinType::Bool:

return 'B'

;

8753 case

BuiltinType::Char8:

8754 case

BuiltinType::Char_U:

8755 case

BuiltinType::UChar:

return 'C'

;

8756 case

BuiltinType::Char16:

8757 case

BuiltinType::UShort:

return 'S'

;

8758 case

BuiltinType::Char32:

8759 case

BuiltinType::UInt:

return 'I'

;

8760 case

BuiltinType::ULong:

8761 return C

->getTargetInfo().getLongWidth() == 32 ?

'L'

'Q'

;

8762 case

BuiltinType::UInt128:

return 'T'

;

8763 case

BuiltinType::ULongLong:

return 'Q'

;

8764 case

BuiltinType::Char_S:

8765 case

BuiltinType::SChar:

return 'c'

;

8766 case

BuiltinType::Short:

return 's'

;

8767 case

BuiltinType::WChar_S:

8768 case

BuiltinType::WChar_U:

8769 case

BuiltinType::Int:

return 'i'

;

8770 case

BuiltinType::Long:

8771 return C

->getTargetInfo().getLongWidth() == 32 ?

'l'

'q'

;

8772 case

BuiltinType::LongLong:

return 'q'

;

8773 case

BuiltinType::Int128:

return 't'

;

8774 case

BuiltinType::Float:

return 'f'

;

8775 case

BuiltinType::Double:

return 'd'

;

8776 case

BuiltinType::LongDouble:

return 'D'

;

8777 case

BuiltinType::NullPtr:

return '*'

;

8779 case

BuiltinType::BFloat16:

8780 case

BuiltinType::Float16:

8781 case

BuiltinType::Float128:

8782 case

BuiltinType::Ibm128:

8783 case

BuiltinType::Half:

8784 case

BuiltinType::ShortAccum:

8785 case

BuiltinType::Accum:

8786 case

BuiltinType::LongAccum:

8787 case

BuiltinType::UShortAccum:

8788 case

BuiltinType::UAccum:

8789 case

BuiltinType::ULongAccum:

8790 case

BuiltinType::ShortFract:

8791 case

BuiltinType::Fract:

8792 case

BuiltinType::LongFract:

8793 case

BuiltinType::UShortFract:

8794 case

BuiltinType::UFract:

8795 case

BuiltinType::ULongFract:

8796 case

BuiltinType::SatShortAccum:

8797 case

BuiltinType::SatAccum:

8798 case

BuiltinType::SatLongAccum:

8799 case

BuiltinType::SatUShortAccum:

8800 case

BuiltinType::SatUAccum:

8801 case

BuiltinType::SatULongAccum:

8802 case

BuiltinType::SatShortFract:

8803 case

BuiltinType::SatFract:

8804 case

BuiltinType::SatLongFract:

8805 case

BuiltinType::SatUShortFract:

8806 case

BuiltinType::SatUFract:

8807 case

BuiltinType::SatULongFract:

8811#define SVE_TYPE(Name, Id, SingletonId) \ 8812 case BuiltinType::Id: 8813#include "clang/Basic/AArch64SVEACLETypes.def" 8814#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: 8815#include "clang/Basic/RISCVVTypes.def" 8816#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id: 8817#include "clang/Basic/WebAssemblyReferenceTypes.def" 8818#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) case BuiltinType::Id: 8819#include "clang/Basic/AMDGPUTypes.def" 8823 "cannot yet @encode type %0"

);

8824

Diags.

Report

(DiagID) << BT->

getName

(

->getPrintingPolicy());

8828 case

BuiltinType::ObjCId:

8829 case

BuiltinType::ObjCClass:

8830 case

BuiltinType::ObjCSel:

8831

llvm_unreachable(

"@encoding ObjC primitive type"

);

8834#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 8835 case BuiltinType::Id: 8836#include "clang/Basic/OpenCLImageTypes.def" 8837#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ 8838 case BuiltinType::Id: 8839#include "clang/Basic/OpenCLExtensionTypes.def" 8840 case

BuiltinType::OCLEvent:

8841 case

BuiltinType::OCLClkEvent:

8842 case

BuiltinType::OCLQueue:

8843 case

BuiltinType::OCLReserveID:

8844 case

BuiltinType::OCLSampler:

8845 case

BuiltinType::Dependent:

8846#define PPC_VECTOR_TYPE(Name, Id, Size) \ 8847 case BuiltinType::Id: 8848#include "clang/Basic/PPCTypes.def" 8849#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id: 8850#include "clang/Basic/HLSLIntangibleTypes.def" 8851#define BUILTIN_TYPE(KIND, ID) 8852#define PLACEHOLDER_TYPE(KIND, ID) \ 8853 case BuiltinType::KIND: 8854#include "clang/AST/BuiltinTypes.def" 8855

llvm_unreachable(

"invalid builtin type for @encode"

);

8857

llvm_unreachable(

"invalid BuiltinType::Kind value"

);

8864 if

->isFixed())

8874

assert(FD->

isBitField

() &&

"not a bitfield - getObjCEncodingForTypeImpl"

);

8894 if

(

const auto

*IVD = dyn_cast<ObjCIvarDecl>(FD)) {

8903

S += llvm::utostr(Offset);

8918 bool

VisitBasesAndFields) {

8923

PT->getPointeeType().getTypePtr(),

false

);

8930 if

(isa<ClassTemplateSpecializationDecl>(CXXRD))

8933 if

(!CXXRD->hasDefinition() || !VisitBasesAndFields)

8936 for

(

const auto

&B : CXXRD->bases())

8941 for

(

auto

*FD : CXXRD->fields())

8950void

ASTContext::getObjCEncodingForTypeImpl(

QualType T

, std::string &S,

8951 const

ObjCEncOptions Options,

8955 switch

(CT->getTypeClass()) {

8960 if

(

const auto

*BT = dyn_cast<BuiltinType>(CT))

8982 case

Type::LValueReference:

8983 case

Type::RValueReference: {

8985 if

(isa<PointerType>(CT)) {

8987 if

(PT->isObjCSelType()) {

8996 bool

isReadOnly =

false

;

9002 if

(Options.IsOutermostType() &&

.isConstQualified()) {

9006

}

else if

(Options.IsOutermostType()) {

9009 P

= PT->getPointeeType();

9010 if

(

.isConstQualified()) {

9019 if

(StringRef(S).ends_with(

"nr"

))

9020

S.replace(S.end()-2, S.end(),

"rn"

);

9032 if

(RTy->getDecl()->getIdentifier() == &

(

"objc_class"

)) {

9037 if

(RTy->getDecl()->getIdentifier() == &

(

"objc_object"

)) {

9046

RTy, Options.ExpandPointedToStructures()))) {

9055

ObjCEncOptions NewOptions;

9056 if

(Options.ExpandPointedToStructures())

9057

NewOptions.setExpandStructures();

9058

getObjCEncodingForTypeImpl(PointeeTy, S, NewOptions,

9059 nullptr

, NotEncodedT);

9063 case

Type::ConstantArray:

9064 case

Type::IncompleteArray:

9065 case

Type::VariableArray: {

9066 const auto

*AT = cast<ArrayType>(CT);

9068 if

(isa<IncompleteArrayType>(AT) && !Options.IsStructField()) {

9072

getObjCEncodingForTypeImpl(

9073

AT->getElementType(), S,

9074

Options.keepingOnly(ObjCEncOptions().setExpandStructures()), FD);

9078 if

(

const auto

*CAT = dyn_cast<ConstantArrayType>(AT))

9079

S += llvm::utostr(CAT->getZExtSize());

9082

assert((isa<VariableArrayType>(AT) || isa<IncompleteArrayType>(AT)) &&

9083 "Unknown array type!"

);

9087

getObjCEncodingForTypeImpl(

9088

AT->getElementType(), S,

9089

Options.keepingOnly(ObjCEncOptions().setExpandStructures()), FD,

9096 case

Type::FunctionNoProto:

9097 case

Type::FunctionProto:

9101 case

Type::Record: {

9102 RecordDecl

*RDecl = cast<RecordType>(CT)->getDecl();

9103

S += RDecl->

() ?

'('

'{'

;

9107 if

(

const auto

*Spec = dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) {

9109

llvm::raw_string_ostream OS(S);

9116 if

(Options.ExpandStructures()) {

9119

getObjCEncodingForStructureImpl(RDecl, S, FD,

true

, NotEncodedT);

9121 for

(

const auto

*Field : RDecl->

()) {

9124

S +=

->getNameAsString();

9129 if

(

->isBitField()) {

9130

getObjCEncodingForTypeImpl(

->getType(), S,

9131

ObjCEncOptions().setExpandStructures(),

9136

getObjCEncodingForTypeImpl(

9138

ObjCEncOptions().setExpandStructures().setIsStructField(), FD,

9144

S += RDecl->

() ?

')'

'}'

;

9148 case

Type::BlockPointer: {

9151 if

(Options.EncodeBlockParameters()) {

9152 const auto

*FT = BT->getPointeeType()->castAs<

FunctionType

>();

9156

getObjCEncodingForTypeImpl(FT->getReturnType(), S,

9157

Options.forComponentType(), FD, NotEncodedT);

9161 if

(

const auto

*FPT = dyn_cast<FunctionProtoType>(FT)) {

9162 for

(

const auto

&I : FPT->param_types())

9163

getObjCEncodingForTypeImpl(I, S, Options.forComponentType(), FD,

9171 case

Type::ObjCObject: {

9175

S +=

"{objc_object=}"

;

9179

S +=

"{objc_class=}"

;

9186 case

Type::ObjCInterface: {

9192 if

(Options.ExpandStructures()) {

9196 for

(

unsigned

i = 0, e = Ivars.size(); i != e; ++i) {

9198 if

(

->isBitField())

9199

getObjCEncodingForTypeImpl(

->getType(), S,

9200

ObjCEncOptions().setExpandStructures(),

9203

getObjCEncodingForTypeImpl(

->getType(), S,

9204

ObjCEncOptions().setExpandStructures(), FD,

9212 case

Type::ObjCObjectPointer: {

9214 if

(OPT->isObjCIdType()) {

9219 if

(OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) {

9227 if

(OPT->isObjCQualifiedIdType()) {

9228

getObjCEncodingForTypeImpl(

9230

Options.keepingOnly(ObjCEncOptions()

9231

.setExpandPointedToStructures()

9232

.setExpandStructures()),

9234 if

(FD || Options.EncodingProperty() || Options.EncodeClassNames()) {

9238 for

(

const auto

*I : OPT->quals()) {

9240

S += I->getObjCRuntimeNameAsString();

9249 if

(OPT->getInterfaceDecl() &&

9250

(FD || Options.EncodingProperty() || Options.EncodeClassNames())) {

9252

S += OPT->getInterfaceDecl()->getObjCRuntimeNameAsString();

9253 for

(

const auto

*I : OPT->quals()) {

9255

S += I->getObjCRuntimeNameAsString();

9265 case

Type::MemberPointer:

9269 case

Type::ExtVector:

9275 case

Type::ConstantMatrix:

9288 case

Type::DeducedTemplateSpecialization:

9291 case

Type::HLSLAttributedResource:

9292

llvm_unreachable(

"unexpected type"

);

9294 case

Type::ArrayParameter:

9296#define ABSTRACT_TYPE(KIND, BASE) 9297#define TYPE(KIND, BASE) 9298#define DEPENDENT_TYPE(KIND, BASE) \ 9300#define NON_CANONICAL_TYPE(KIND, BASE) \ 9302#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(KIND, BASE) \ 9304#include "clang/AST/TypeNodes.inc" 9305

llvm_unreachable(

"@encode for dependent type!"

);

9307

llvm_unreachable(

"bad type kind!"

);

9310void

ASTContext::getObjCEncodingForStructureImpl(

RecordDecl

*RDecl,

9315

assert(RDecl &&

"Expected non-null RecordDecl"

);

9316

assert(!RDecl->

() &&

"Should not be called for unions"

);

9320 const auto

*CXXRec = dyn_cast<CXXRecordDecl>(RDecl);

9321

std::multimap<uint64_t, NamedDecl *> FieldOrBaseOffsets;

9325 for

(

const auto

&BI : CXXRec->bases()) {

9326 if

(!BI.isVirtual()) {

9331

FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),

9332

std::make_pair(offs, base));

9338 if

->isZeroLengthBitField() &&

->isZeroSize(*

this

))

9341

FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),

9342

std::make_pair(offs, Field));

9345 if

(CXXRec && includeVBases) {

9346 for

(

const auto

&BI : CXXRec->vbases()) {

9352

FieldOrBaseOffsets.find(offs) == FieldOrBaseOffsets.end())

9353

FieldOrBaseOffsets.insert(FieldOrBaseOffsets.end(),

9354

std::make_pair(offs, base));

9368

std::multimap<uint64_t, NamedDecl *>::iterator

9369

CurLayObj = FieldOrBaseOffsets.begin();

9371 if

(CXXRec && CXXRec->isDynamicClass() &&

9372

(CurLayObj == FieldOrBaseOffsets.end() || CurLayObj->first != 0)) {

9375

std::string recname = CXXRec->getNameAsString();

9376 if

(recname.empty()) recname =

"?"

;

9389

FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),

9390

std::make_pair(offs,

nullptr

));

9393 for

(; CurLayObj != FieldOrBaseOffsets.end(); ++CurLayObj) {

9395

assert(CurOffs <= CurLayObj->first);

9396 if

(CurOffs < CurLayObj->first) {

9397 uint64_t

padding = CurLayObj->first - CurOffs;

9413 if

(

auto

*base = dyn_cast<CXXRecordDecl>(dcl)) {

9418

getObjCEncodingForStructureImpl(base, S, FD,

false

9425 const auto

*field = cast<FieldDecl>(dcl);

9428

S += field->getNameAsString();

9432 if

(field->isBitField()) {

9435

CurOffs += field->getBitWidthValue();

9440

getObjCEncodingForTypeImpl(

9441

qt, S, ObjCEncOptions().setExpandStructures().setIsStructField(),

9452

std::string& S)

const

{

9485 if

(!ObjCClassDecl) {

9490 return

ObjCClassDecl;

9494 if

(!ObjCProtocolClassDecl) {

9495

ObjCProtocolClassDecl

9504 return

ObjCProtocolClassDecl;

9549 const size_t

NumFields = 5;

9551 const char

*FieldNames[NumFields];

9555

FieldNames[0] =

"__stack"

;

9559

FieldNames[1] =

"__gr_top"

;

9563

FieldNames[2] =

"__vr_top"

;

9566

FieldTypes[3] = Context->

;

9567

FieldNames[3] =

"__gr_offs"

;

9570

FieldTypes[4] = Context->

;

9571

FieldNames[4] =

"__vr_offs"

;

9574 for

(

unsigned

i = 0; i < NumFields; ++i) {

9579

&Context->

(FieldNames[i]),

9580

FieldTypes[i],

nullptr

9585

VaListTagDecl->

(Field);

9602 const size_t

NumFields = 5;

9604 const char

*FieldNames[NumFields];

9608

FieldNames[0] =

"gpr"

;

9612

FieldNames[1] =

"fpr"

;

9616

FieldNames[2] =

"reserved"

;

9620

FieldNames[3] =

"overflow_arg_area"

;

9624

FieldNames[4] =

"reg_save_area"

;

9627 for

(

unsigned

i = 0; i < NumFields; ++i) {

9631

&Context->

(FieldNames[i]),

9632

FieldTypes[i],

nullptr

9637

VaListTagDecl->

(Field);

9664 const size_t

NumFields = 4;

9666 const char

*FieldNames[NumFields];

9670

FieldNames[0] =

"gp_offset"

;

9674

FieldNames[1] =

"fp_offset"

;

9678

FieldNames[2] =

"overflow_arg_area"

;

9682

FieldNames[3] =

"reg_save_area"

;

9685 for

(

unsigned

i = 0; i < NumFields; ++i) {

9690

&Context->

(FieldNames[i]),

9691

FieldTypes[i],

nullptr

9696

VaListTagDecl->

(Field);

9767 const size_t

NumFields = 4;

9769 const char

*FieldNames[NumFields];

9772

FieldTypes[0] = Context->

;

9773

FieldNames[0] =

"__gpr"

;

9776

FieldTypes[1] = Context->

;

9777

FieldNames[1] =

"__fpr"

;

9781

FieldNames[2] =

"__overflow_arg_area"

;

9785

FieldNames[3] =

"__reg_save_area"

;

9788 for

(

unsigned

i = 0; i < NumFields; ++i) {

9793

&Context->

(FieldNames[i]),

9794

FieldTypes[i],

nullptr

9799

VaListTagDecl->

(Field);

9821 const size_t

NumFields = 3;

9823 const char

*FieldNames[NumFields];

9827

FieldNames[0] =

"__current_saved_reg_area_pointer"

;

9831

FieldNames[1] =

"__saved_reg_area_end_pointer"

;

9835

FieldNames[2] =

"__overflow_area_pointer"

;

9838 for

(

unsigned

i = 0; i < NumFields; ++i) {

9846

VaListTagDecl->

(Field);

9876 constexpr size_t

NumFields = 3;

9880 const char

*FieldNames[NumFields] = {

"__va_stk"

"__va_reg"

"__va_ndx"

};

9883 for

(

unsigned

i = 0; i < NumFields; ++i) {

9886

&Context->

(FieldNames[i]), FieldTypes[i],

nullptr

9890

VaListTagDecl->

(Field);

9900 return

VaListTagTypedefDecl;

9928

llvm_unreachable(

"Unhandled __builtin_va_list type kind"

);

9932 if

(!BuiltinVaListDecl) {

9937 return

BuiltinVaListDecl;

9950 if

(!BuiltinMSVaListDecl)

9953 return

BuiltinMSVaListDecl;

9965

assert(ObjCConstantStringType.

() &&

9966 "'NSConstantString' type already set!"

);

9976 unsigned

size = End -

Begin

;

9977

assert(size > 1 &&

"set is not overloaded!"

);

9986

assert(isa<FunctionTemplateDecl>(

) ||

9987

isa<UnresolvedUsingValueDecl>(

) ||

9988

(isa<UsingShadowDecl>(

) &&

9989

isa<FunctionTemplateDecl>(

->getUnderlyingDecl())));

10006 bool

TemplateKeyword,

10012

llvm::FoldingSetNodeID ID;

10015 void

*InsertPos =

nullptr

;

10017

QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos);

10021

QualifiedTemplateNames.InsertNode(QTN, InsertPos);

10033 "Nested name specifier must be dependent"

);

10035

llvm::FoldingSetNodeID ID;

10038 void

*InsertPos =

nullptr

;

10040

DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);

10046 if

(CanonNNS == NNS) {

10054

DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);

10055

assert(!CheckQTN &&

"Dependent type name canonicalization broken"

);

10059

DependentTemplateNames.InsertNode(QTN, InsertPos);

10069 "Nested name specifier must be dependent"

);

10071

llvm::FoldingSetNodeID ID;

10074 void

*InsertPos =

nullptr

;

10076

= DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);

10082 if

(CanonNNS == NNS) {

10091

= DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);

10092

assert(!CheckQTN &&

"Dependent template name canonicalization broken"

);

10096

DependentTemplateNames.InsertNode(QTN, InsertPos);

10102

std::optional<unsigned> PackIndex)

const

{

10103

llvm::FoldingSetNodeID ID;

10107 void

*insertPos =

nullptr

;

10109

= SubstTemplateTemplateParms.FindNodeOrInsertPos(ID, insertPos);

10113

Replacement, AssociatedDecl, Index, PackIndex);

10114

SubstTemplateTemplateParms.InsertNode(subst, insertPos);

10122 Decl

*AssociatedDecl,

10123 unsigned

Index,

bool

Final)

const

{

10125

llvm::FoldingSetNodeID ID;

10127

AssociatedDecl, Index, Final);

10129 void

*InsertPos =

nullptr

;

10131

= SubstTemplateTemplateParmPacks.FindNodeOrInsertPos(ID, InsertPos);

10136

SubstTemplateTemplateParmPacks.InsertNode(Subst, InsertPos);

10150

llvm::FoldingSetNodeID ID;

10153 void

*InsertPos =

nullptr

;

10155

DeducedTemplates.FindNodeOrInsertPos(ID, InsertPos);

10161

DeducedTemplates.InsertNode(DTS, InsertPos);

10184

llvm_unreachable(

"Unhandled TargetInfo::IntType value"

);

10214 while

(

const auto

*AT = dyn_cast<ArrayType>(CT))

10215

CT = AT->getElementType();

10247

assert(FirstVec->

isVectorType

() &&

"FirstVec should be a vector type"

);

10248

assert(SecondVec->

isVectorType

() &&

"SecondVec should be a vector type"

);

10285 if

(Ty->

() == BuiltinType::SveBool ||

10286

Ty->

() == BuiltinType::SveCount)

10299 return

BT->getKind() == BuiltinType::SveBool;

10301 return

VT->getElementType().getCanonicalType() ==

10312 return

IsValidCast(FirstType, SecondType) ||

10313

IsValidCast(SecondType, FirstType);

10318 auto

IsLaxCompatible = [

this

](

FirstType,

SecondType) {

10331 if

(BT->getKind() == BuiltinType::SveBool &&

10352 return

VecTy->getElementType().getCanonicalType()->isIntegerType() &&

10359 return

IsLaxCompatible(FirstType, SecondType) ||

10360

IsLaxCompatible(SecondType, FirstType);

10377

uint64_t MinElts = Info.

.getKnownMinValue();

10378 return

VScale->first * MinElts * EltSize;

10386 "Expected RVV builtin type and vector type!"

);

10426 return

IsValidCast(FirstType, SecondType) ||

10427

IsValidCast(SecondType, FirstType);

10435 "Expected RVV builtin type and vector type!"

);

10437 auto

IsLaxCompatible = [

this

](

FirstType,

SecondType) {

10442 if

(!BT->isRVVVLSBuiltinType())

10462 return

VecTy->getElementType().getCanonicalType()->isIntegerType() &&

10469 return

IsLaxCompatible(FirstType, SecondType) ||

10470

IsLaxCompatible(SecondType, FirstType);

10477 if

(

Attr

->getAttrKind() == attr::ObjCOwnership)

10480

Ty =

Attr

->getModifiedType();

10483

}

else if

(

const ParenType

Paren

= dyn_cast<ParenType>(Ty)) {

10484

Ty =

Paren

->getInnerType();

10506 for

(

auto

*PI : rProto->

protocols

())

10516 for

(

auto

*lhsProto : lhs->

()) {

10517 bool match

false

;

10518 for

(

auto

*rhsProto : rhs->

()) {

10549 for

(

auto

*I : lhs->

()) {

10553 if

(!rhsID->ClassImplementsProtocol(I,

true

))

10561 for

(

auto

*lhsProto : lhs->

()) {

10562 bool match

false

;

10567 for

(

auto

*rhsProto : rhs->

()) {

10577 for

(

auto

*I : lhs->

()) {

10581 if

(rhsID->ClassImplementsProtocol(I,

true

)) {

10598 for

(

auto

*lhsProto : lhs->

()) {

10599 bool match

false

;

10606 for

(

auto

*rhsProto : rhs->

()) {

10625 if

(LHSInheritedProtocols.empty() && lhs->

qual_empty

())

10627 for

(

auto

*lhsProto : LHSInheritedProtocols) {

10628 bool match

false

;

10629 for

(

auto

*rhsProto : rhs->

()) {

10659 auto

finish = [&](

bool

succeeded) ->

bool

{

10704 bool

BlockReturnType) {

10708 auto

finish = [&](

bool

succeeded) ->

bool

{

10733 if

(

().CompatibilityQualifiedIdBlockParamTypeChecking)

10737

(!BlockReturnType &&

10741

(BlockReturnType ? LHSOPT : RHSOPT),

10742

(BlockReturnType ? RHSOPT : LHSOPT),

false

));

10750 return

finish(BlockReturnType);

10752 return

finish(!BlockReturnType);

10764 return

(*lhs)->getName().compare((*rhs)->getName());

10781

assert(LHS->

() &&

"LHS must have an interface base"

);

10782

assert(RHS->

() &&

"RHS must have an interface base"

);

10788 for

(

auto

*proto : LHS->

()) {

10799 for

(

auto

*proto : RHS->

()) {

10807 for

(

auto

*proto : LHSProtocolSet) {

10808 if

(RHSProtocolSet.count(proto))

10809

IntersectionSet.push_back(proto);

10818 if

(!ImpliedProtocols.empty()) {

10820 return

ImpliedProtocols.contains(proto);

10825

llvm::array_pod_sort(IntersectionSet.begin(), IntersectionSet.end(),

10835 if

(lhsOPT && rhsOPT)

10841 if

(lhsBlock && rhsBlock)

10846 if

((lhsOPT && lhsOPT->isObjCIdType() && rhsBlock) ||

10858 bool

stripKindOf) {

10859 if

(lhsArgs.size() != rhsArgs.size())

10866 for

(

unsigned

i = 0, n = lhsArgs.size(); i != n; ++i) {

10872 if

(!stripKindOf ||

10873

!ctx.

hasSameType

(lhsArgs[i].stripObjCKindOfType(ctx),

10874

rhsArgs[i].stripObjCKindOfType(ctx))) {

10902 if

(!LDecl || !RDecl)

10912

llvm::SmallDenseMap<const ObjCInterfaceDecl *, const ObjCObjectType *, 4>

10922 bool

anyChanges =

false

;

10933

anyChanges =

true

;

10940 if

(!Protocols.empty())

10941

anyChanges =

true

;

10946 if

(anyChanges || LHS->

isKindOfType

() != anyKindOf) {

10958 if

(LHSSuperType.

())

10968 if

(KnownLHS != LHSAncestors.end()) {

10969

LHS = KnownLHS->second;

10973 bool

anyChanges =

false

;

10984

anyChanges =

true

;

10991 if

(!Protocols.empty())

10992

anyChanges =

true

;

10996 if

(anyChanges || RHS->

isKindOfType

() != anyKindOf) {

11008 if

(RHSSuperType.

())

11019

assert(LHS->

() &&

"LHS is not an interface type"

);

11020

assert(RHS->

() &&

"RHS is not an interface type"

);

11041 for

(

auto

*RHSPI : RHS->

())

11044 if

(SuperClassInheritedProtocols.empty())

11047 for

(

const auto

*LHSProto : LHS->

()) {

11048 bool

SuperImplementsProtocol =

false

;

11049 for

(

auto

*SuperClassProto : SuperClassInheritedProtocols)

11050 if

(SuperClassProto->lookupProtocolNamed(LHSProto->getIdentifier())) {

11051

SuperImplementsProtocol =

true

;

11054 if

(!SuperImplementsProtocol)

11084 if

(!LHSOPT || !RHSOPT)

11102 bool

CompareUnqualified) {

11121 bool

OfBlockPointer,

11125 if

(UD->

<TransparentUnionAttr>()) {

11126 for

(

const auto

*I : UD->

()) {

11127 QualType

ET = I->getType().getUnqualifiedType();

11141 bool

OfBlockPointer,

11162 bool

IsConditionalOperator) {

11165 const auto

*lproto = dyn_cast<FunctionProtoType>(lbase);

11166 const auto

*rproto = dyn_cast<FunctionProtoType>(rbase);

11167 bool

allLTypes =

true

;

11168 bool

allRTypes =

true

;

11172 if

(OfBlockPointer) {

11174 QualType

LHS = lbase->getReturnType();

11176 if

(!UnqualifiedResult)

11178

retType =

mergeTypes

(LHS, RHS,

true

, UnqualifiedResult,

true

);

11197

allLTypes =

false

;

11199

allRTypes =

false

;

11209 if

(lbaseInfo.

getCC

() != rbaseInfo.

getCC

())

11243 bool

NoReturn = IsConditionalOperator

11247

allLTypes =

false

;

11249

allRTypes =

false

;

11253

std::optional<FunctionEffectSet> MergedFX;

11255 if

(lproto && rproto) {

11256

assert((AllowCXX ||

11257

(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec())) &&

11258 "C++ shouldn't be here"

);

11260 if

(lproto->getNumParams() != rproto->getNumParams())

11264 if

(lproto->isVariadic() != rproto->isVariadic())

11267 if

(lproto->getMethodQuals() != rproto->getMethodQuals())

11273 if

(LHSFX != RHSFX) {

11274 if

(IsConditionalOperator)

11283 if

(*MergedFX != LHSFX)

11284

allLTypes =

false

;

11285 if

(*MergedFX != RHSFX)

11286

allRTypes =

false

;

11290 bool

canUseLeft, canUseRight;

11296

allLTypes =

false

;

11298

allRTypes =

false

;

11302 for

(

unsigned

i = 0, n = lproto->getNumParams(); i < n; i++) {

11303 QualType

lParamType = lproto->getParamType(i).getUnqualifiedType();

11304 QualType

rParamType = rproto->getParamType(i).getUnqualifiedType();

11306

lParamType, rParamType, OfBlockPointer,

Unqualified

);

11307 if

(paramType.

())

11313 types

.push_back(paramType);

11320

allLTypes =

false

;

11322

allRTypes =

false

;

11325 if

(allLTypes)

return

lhs;

11326 if

(allRTypes)

return

rhs;

11331

newParamInfos.empty() ? nullptr : newParamInfos.data();

11337 if

(lproto) allRTypes =

false

;

11338 if

(rproto) allLTypes =

false

;

11342

assert((AllowCXX || !proto->

hasExceptionSpec

()) &&

"C++ shouldn't be here"

);

11350 for

(

unsigned

i = 0, n = proto->

getNumParams

(); i < n; ++i) {

11356

paramTy =

->getDecl()->getIntegerType();

11366 if

(allLTypes)

return

lhs;

11367 if

(allRTypes)

return

rhs;

11376 if

(allLTypes)

return

lhs;

11377 if

(allRTypes)

return

rhs;

11383 QualType

other,

bool

isBlockReturnType) {

11389 if

(underlyingType.

())

11391 if

(Context.

hasSameType

(underlyingType, other))

11405 bool

IsConditionalOperator) {

11416 if

(LangOpts.OpenMP && LHSRefTy && RHSRefTy &&

11420 if

(LHSRefTy || RHSRefTy)

11432 if

(LHSCan == RHSCan)

11437 Qualifiers

RQuals = RHSCan.getLocalQualifiers();

11438 if

(LQuals != RQuals) {

11454

assert((GC_L != GC_R) &&

"unequal qualifier sets had only equal elements"

);

11475 if

(LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto;

11476 if

(RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto;

11479 if

(LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray)

11480

LHSClass = Type::ConstantArray;

11481 if

(RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray)

11482

RHSClass = Type::ConstantArray;

11485 if

(LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject;

11486 if

(RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject;

11489 if

(LHSClass == Type::ExtVector) LHSClass = Type::Vector;

11490 if

(RHSClass == Type::ExtVector) RHSClass = Type::Vector;

11493 if

(LHSClass != RHSClass) {

11503 if

(OfBlockPointer && !BlockReturnType) {

11512 if

(!AT->isDeduced() && AT->isGNUAutoType())

11516 if

(!AT->isDeduced() && AT->isGNUAutoType())

11523 switch

(LHSClass) {

11524#define TYPE(Class, Base) 11525#define ABSTRACT_TYPE(Class, Base) 11526#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class: 11527#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 11528#define DEPENDENT_TYPE(Class, Base) case Type::Class: 11529#include "clang/AST/TypeNodes.inc" 11530

llvm_unreachable(

"Non-canonical and dependent types shouldn't get here"

);

11533 case

Type::DeducedTemplateSpecialization:

11534 case

Type::LValueReference:

11535 case

Type::RValueReference:

11536 case

Type::MemberPointer:

11537

llvm_unreachable(

"C++ should never be in mergeTypes"

);

11539 case

Type::ObjCInterface:

11540 case

Type::IncompleteArray:

11541 case

Type::VariableArray:

11542 case

Type::FunctionProto:

11543 case

Type::ExtVector:

11544

llvm_unreachable(

"Types are eliminated above"

);

11546 case

Type::Pointer:

11557 if

(ResultType.

())

11565 case

Type::BlockPointer:

11590 if

(ResultType.

())

11609 if

(ResultType.

())

11617 case

Type::ConstantArray:

11632 if

(ResultType.

())

11640 if

(LVAT || RVAT) {

11643

-> std::pair<bool,llvm::APInt> {

11645

std::optional<llvm::APSInt> TheInt;

11648 return

std::make_pair(

true

, *TheInt);

11649 return

std::make_pair(

false

, llvm::APSInt());

11652 return

std::make_pair(

true

, CAT->getSize());

11653 return

std::make_pair(

false

, llvm::APInt());

11656 bool

HaveLSize, HaveRSize;

11657

llvm::APInt LSize, RSize;

11658

std::tie(HaveLSize, LSize) = SizeFetch(LVAT, LCAT);

11659

std::tie(HaveRSize, RSize) = SizeFetch(RVAT, RCAT);

11660 if

(HaveLSize && HaveRSize && !llvm::APInt::isSameValue(LSize, RSize))

11694 case

Type::FunctionNoProto:

11696 false

, IsConditionalOperator);

11700 case

Type::Builtin:

11703 case

Type::Complex:

11712 case

Type::ConstantMatrix:

11717 case

Type::ObjCObject: {

11726 case

Type::ObjCObjectPointer:

11727 if

(OfBlockPointer) {

11739

assert(LHS != RHS &&

11740 "Equivalent pipe types should have already been handled!"

);

11742 case

Type::ArrayParameter:

11743

assert(LHS != RHS &&

11744 "Equivalent ArrayParameter types should have already been handled!"

);

11746 case

Type::BitInt: {

11754 if

(LHSUnsigned != RHSUnsigned)

11757 if

(LHSBits != RHSBits)

11761 case

Type::HLSLAttributedResource: {

11768 "HLSLAttributedResourceType should always wrap __hlsl_resource_t"

);

11770 if

(LHSTy->

getAttrs

() == RHSTy->getAttrs() &&

11777

llvm_unreachable(

"Invalid Type::Class!"

);

11782 bool

&CanUseFirst,

bool

&CanUseSecond,

11784

assert(NewParamInfos.empty() &&

"param info list not empty"

);

11785

CanUseFirst = CanUseSecond =

true

;

11791 if

(!FirstHasInfo && !SecondHasInfo)

11794 bool

NeedParamInfo =

false

;

11798 for

(

size_t

I = 0; I <

; ++I) {

11809 bool

FirstNoEscape = FirstParam.

isNoEscape

();

11810 bool

SecondNoEscape = SecondParam.

isNoEscape

();

11811 bool

IsNoEscape = FirstNoEscape && SecondNoEscape;

11812

NewParamInfos.push_back(FirstParam.

withIsNoEscape

(IsNoEscape));

11813 if

(NewParamInfos.back().getOpaqueValue())

11814

NeedParamInfo =

true

;

11815 if

(FirstNoEscape != IsNoEscape)

11816

CanUseFirst =

false

;

11817 if

(SecondNoEscape != IsNoEscape)

11818

CanUseSecond =

false

;

11821 if

(!NeedParamInfo)

11822

NewParamInfos.clear();

11828

ObjCLayouts[CD] =

nullptr

;

11838 if

(LHSCan == RHSCan)

11840 if

(RHSCan->isFunctionType()) {

11844

cast<FunctionType>(RHSCan.getTypePtr())->getReturnType();

11846

cast<FunctionType>(LHSCan.

getTypePtr

())->getReturnType();

11849 if

(ResReturnType.

())

11851 if

(ResReturnType == NewReturnType || ResReturnType == OldReturnType) {

11855 if

(

const auto

*FPT = cast<FunctionProtoType>(F)) {

11868 Qualifiers

RQuals = RHSCan.getLocalQualifiers();

11869 if

(LQuals != RQuals) {

11882

assert((GC_L != GC_R) &&

"unequal qualifier sets had only equal elements"

);

11898 if

(ResQT == LHSBaseQT)

11900 if

(ResQT == RHSBaseQT)

11912 T

= ET->getDecl()->getIntegerType();

11916 return

EIT->getNumBits();

11924 "Unexpected type"

);

11929

VTy->getNumElements(), VTy->getVectorKind());

11938 T

= ETy->getDecl()->getIntegerType();

11941 case

BuiltinType::Char_U:

11943 case

BuiltinType::Char_S:

11944 case

BuiltinType::SChar:

11945 case

BuiltinType::Char8:

11947 case

BuiltinType::Short:

11949 case

BuiltinType::Int:

11951 case

BuiltinType::Long:

11953 case

BuiltinType::LongLong:

11955 case

BuiltinType::Int128:

11960 case

BuiltinType::WChar_S:

11963 case

BuiltinType::ShortAccum:

11965 case

BuiltinType::Accum:

11967 case

BuiltinType::LongAccum:

11969 case

BuiltinType::SatShortAccum:

11971 case

BuiltinType::SatAccum:

11973 case

BuiltinType::SatLongAccum:

11975 case

BuiltinType::ShortFract:

11977 case

BuiltinType::Fract:

11979 case

BuiltinType::LongFract:

11981 case

BuiltinType::SatShortFract:

11983 case

BuiltinType::SatFract:

11985 case

BuiltinType::SatLongFract:

11990 "Unexpected signed integer or fixed point type"

);

11998 "Unexpected type"

);

12003

VTy->getNumElements(), VTy->getVectorKind());

12012 T

= ETy->getDecl()->getIntegerType();

12015 case

BuiltinType::Char_S:

12017 case

BuiltinType::Char_U:

12018 case

BuiltinType::UChar:

12019 case

BuiltinType::Char8:

12021 case

BuiltinType::UShort:

12023 case

BuiltinType::UInt:

12025 case

BuiltinType::ULong:

12027 case

BuiltinType::ULongLong:

12029 case

BuiltinType::UInt128:

12034 case

BuiltinType::WChar_U:

12037 case

BuiltinType::UShortAccum:

12039 case

BuiltinType::UAccum:

12041 case

BuiltinType::ULongAccum:

12043 case

BuiltinType::SatUShortAccum:

12045 case

BuiltinType::SatUAccum:

12047 case

BuiltinType::SatULongAccum:

12049 case

BuiltinType::UShortFract:

12051 case

BuiltinType::UFract:

12053 case

BuiltinType::ULongFract:

12055 case

BuiltinType::SatUShortFract:

12057 case

BuiltinType::SatUFract:

12059 case

BuiltinType::SatULongFract:

12064 "Unexpected signed integer or fixed point type"

);

12089 bool

AllowTypeModifiers) {

12093

RequiresICE =

false

;

12096 bool

Done =

false

;

12098 bool

IsSpecial =

false

;

12102 default

: Done =

true

; --Str;

break

;

12104

RequiresICE =

true

;

12107

assert(!

"Can't use both 'S' and 'U' modifiers!"

);

12108

assert(!

"Can't use 'S' modifier multiple times!"

);

12112

assert(!

"Can't use both 'S' and 'U' modifiers!"

);

12113

assert(!

"Can't use 'U' modifier multiple times!"

);

12117

assert(!IsSpecial &&

"Can't use 'L' with 'W', 'N', 'Z' or 'O' modifiers"

);

12118

assert(HowLong <= 2 &&

"Can't have LLLL modifier"

);

12123

assert(!IsSpecial &&

"Can't use two 'N', 'W', 'Z' or 'O' modifiers!"

);

12124

assert(HowLong == 0 &&

"Can't use both 'L' and 'N' modifiers!"

);

12133

assert(!IsSpecial &&

"Can't use two 'N', 'W', 'Z' or 'O' modifiers!"

);

12134

assert(HowLong == 0 &&

"Can't use both 'L' and 'W' modifiers!"

);

12140

llvm_unreachable(

"Unexpected integer type"

);

12151

assert(!IsSpecial &&

"Can't use two 'N', 'W', 'Z' or 'O' modifiers!"

);

12152

assert(HowLong == 0 &&

"Can't use both 'L' and 'Z' modifiers!"

);

12158

llvm_unreachable(

"Unexpected integer type"

);

12171

assert(!IsSpecial &&

"Can't use two 'N', 'W', 'Z' or 'O' modifiers!"

);

12172

assert(HowLong == 0 &&

"Can't use both 'L' and 'O' modifiers!"

);

12188 default

: llvm_unreachable(

"Unknown builtin type letter!"

);

12191 "Bad modifiers used with 'x'!"

);

12196 "Bad modifiers used with 'y'!"

);

12201 "Bad modifiers used with 'v'!"

);

12206 "Bad modifiers used with 'h'!"

);

12211 "Bad modifiers used with 'f'!"

);

12216 "Bad modifiers used with 'd'!"

);

12219 else if

(HowLong == 2)

12225

assert(HowLong == 0 &&

"Bad modifiers used with 's'!"

);

12234 else if

(HowLong == 2)

12236 else if

(HowLong == 1)

12242

assert(HowLong == 0 &&

"Bad modifiers used with 'c'!"

);

12251

assert(HowLong == 0 && !

&& !

"Bad modifiers for 'b'!"

);

12255

assert(HowLong == 0 && !

&& !

"Bad modifiers for 'z'!"

);

12259

assert(HowLong == 0 && !

&& !

"Bad modifiers for 'w'!"

);

12276

assert(!

.isNull() &&

"builtin va list type not initialized!"

);

12288

assert(!

.isNull() &&

"builtin va list type not initialized!"

);

12296 unsigned

NumElements = strtoul(Str, &End, 10);

12297

assert(End != Str &&

"Missing vector size"

);

12301

RequiresICE,

false

);

12302

assert(!RequiresICE &&

"Can't require vector ICE"

);

12310 Type

= Context.SveCountTy;

12314 Type

= Context.AMDGPUBufferRsrcTy;

12318

llvm_unreachable(

"Unexpected target builtin type"

);

12324 unsigned

NumElements = strtoul(Str, &End, 10);

12325

assert(End != Str &&

"Missing vector size"

);

12329

RequiresICE,

false

);

12330

assert(!RequiresICE &&

"Can't require vector ICE"

);

12339 unsigned

NumElements = strtoul(Str, &End, 10);

12340

assert(End != Str &&

"Missing vector size"

);

12352

assert(!RequiresICE &&

"Can't require complex ICE"

);

12361 if

(

.isNull()) {

12372 if

(

.isNull()) {

12378

assert(HowLong == 0 && !

&& !

"Bad modifiers for 'K'!"

);

12381 if

(

.isNull()) {

12390 Type

= Context.MFloat8Ty;

12395

Done = !AllowTypeModifiers;

12397 switch

(

char c

= *Str++) {

12398 default

: Done =

true

; --Str;

break

;

12404 unsigned

AddrSpace = strtoul(Str, &End, 10);

12432 "Integer constant 'I' type must be an integer"

);

12445 bool

AllowTypeModifiers)

const

{

12446 return DecodeTypeFromStr

(Str, Context, Error, RequireICE, AllowTypeModifiers);

12452 unsigned

*IntegerConstantArgs)

const

{

12454 if

(TypeStr[0] ==

'\0'

) {

12461 bool

RequiresICE =

false

;

12464

RequiresICE,

true

);

12468

assert(!RequiresICE &&

"Result of intrinsic cannot be required to be an ICE"

);

12470 while

(TypeStr[0] && TypeStr[0] !=

'.'

) {

12477 if

(RequiresICE && IntegerConstantArgs)

12478

*IntegerConstantArgs |= 1 << ArgTypes.size();

12484

ArgTypes.push_back(Ty);

12487 if

(

== Builtin::BI__GetExceptionInfo)

12490

assert((TypeStr[0] !=

'.'

|| TypeStr[1] == 0) &&

12491 "'.' should only occur at end of builtin type list!"

);

12493 bool

Variadic = (TypeStr[0] ==

'.'

);

12496

Variadic,

false

true

));

12501 if

(ArgTypes.empty() && Variadic && !

().requiresStrictPrototypes())

12553

!FD->

<DLLExportAttr>()) ||

12554

FD->

<GNUInlineAttr>()) {

12573

isa<CXXConstructorDecl>(FD) &&

12574

cast<CXXConstructorDecl>(FD)->isInheritingConstructor())

12587 if

(

<DLLImportAttr>()) {

12590

}

else if

(

<DLLExportAttr>()) {

12596 if

(

<CUDAGlobalAttr>() &&

12659 while

(LexicalContext && !isa<FunctionDecl>(LexicalContext))

12664 if

(!LexicalContext)

12669 auto

StaticLocalLinkage =

12681 return

StaticLocalLinkage;

12708 return

StrongLinkage;

12726

llvm_unreachable(

"Invalid Linkage!"

);

12736 if

(

const auto

*VD = dyn_cast<VarDecl>(

)) {

12737 if

(!VD->isFileVarDecl())

12742 if

(VD->getDescribedVarTemplate() ||

12743

isa<VarTemplatePartialSpecializationDecl>(VD))

12745

}

else if

(

const auto

*FD = dyn_cast<FunctionDecl>(

)) {

12749

}

else if

(isa<PragmaCommentDecl>(

))

12751 else if

(isa<PragmaDetectMismatchDecl>(

))

12753 else if

(isa<OMPRequiresDecl>(

))

12755 else if

(isa<OMPThreadPrivateDecl>(

))

12757 else if

(isa<OMPAllocateDecl>(

))

12759 else if

(isa<OMPDeclareReductionDecl>(

) || isa<OMPDeclareMapperDecl>(

))

12761 else if

(isa<ImportDecl>(

))

12771 if

(

<WeakRefAttr>())

12778 if

(

const auto

*FD = dyn_cast<FunctionDecl>(

)) {

12780 if

(!FD->doesThisDeclarationHaveABody())

12781 return

FD->doesDeclarationForceExternallyVisibleDefinition();

12784 if

(FD->

<DestructorAttr>())

12789 if

(

getTargetInfo

().getCXXABI().canKeyFunctionBeInline()) {

12790 if

(

const auto

*MD = dyn_cast<CXXMethodDecl>(FD)) {

12808 const auto

*VD = cast<VarDecl>(

);

12809

assert(VD->isFileVarDecl() &&

"Expected file scoped var"

);

12813 if

(LangOpts.OpenMP &&

12814

OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD))

12821 if

(VD->shouldEmitInExternalSource())

12834 if

(VD->needsDestruction(*

this

))

12838 if

(VD->getInit() && VD->getInit()->HasSideEffects(*

this

) &&

12840

(VD->getInit()->isValueDependent() || !VD->evaluateValue()))

12845 if

(

const auto

*DD = dyn_cast<DecompositionDecl>(VD)) {

12846 for

(

const auto

*BD : DD->flat_bindings())

12847 if

(

const auto

*BindingVD = BD->getHoldingVar())

12857

llvm::function_ref<

void

(

FunctionDecl

*)> Pred)

const

{

12858

assert(FD->

isMultiVersion

() &&

"Only valid for multiversioned functions"

);

12859

llvm::SmallDenseSet<const FunctionDecl*, 4> SeenDecls;

12864 for

(

auto

*CurDecl :

12868

SeenDecls.insert(CurFD).second) {

12876 bool

IsBuiltin)

const

{

12879 return

ABI->getDefaultMethodCallConv(IsVariadic);

12884 switch

(LangOpts.getDefaultCallingConv()) {

12913 return Target

->getDefaultCallingConv();

12918 return

ABI->isNearlyEmpty(RD);

12922 if

(!VTContext.get()) {

12923 auto

ABI =

->getCXXABI();

12924 if

(ABI.isMicrosoft())

12927 auto

ComponentLayout =

().RelativeCXXABIVTables

12933 return

VTContext.get();

12939 switch

(

->getCXXABI().getKind()) {

12940 case

TargetCXXABI::AppleARM64:

12941 case

TargetCXXABI::Fuchsia:

12942 case

TargetCXXABI::GenericAArch64:

12943 case

TargetCXXABI::GenericItanium:

12944 case

TargetCXXABI::GenericARM:

12945 case

TargetCXXABI::GenericMIPS:

12946 case

TargetCXXABI::iOS:

12947 case

TargetCXXABI::WebAssembly:

12948 case

TargetCXXABI::WatchOS:

12949 case

TargetCXXABI::XL:

12951 case

TargetCXXABI::Microsoft:

12954

llvm_unreachable(

"Unsupported ABI"

);

12958

assert(

.getCXXABI().getKind() != TargetCXXABI::Microsoft &&

12959 "Device mangle context does not support Microsoft mangling."

);

12960 switch

(

.getCXXABI().getKind()) {

12961 case

TargetCXXABI::AppleARM64:

12962 case

TargetCXXABI::Fuchsia:

12963 case

TargetCXXABI::GenericAArch64:

12964 case

TargetCXXABI::GenericItanium:

12965 case

TargetCXXABI::GenericARM:

12966 case

TargetCXXABI::GenericMIPS:

12967 case

TargetCXXABI::iOS:

12968 case

TargetCXXABI::WebAssembly:

12969 case

TargetCXXABI::WatchOS:

12970 case

TargetCXXABI::XL:

12974 if

(

const auto

*RD = dyn_cast<CXXRecordDecl>(ND))

12975 return

RD->getDeviceLambdaManglingNumber();

12976 return

std::nullopt;

12979 case

TargetCXXABI::Microsoft:

12983

llvm_unreachable(

"Unsupported ABI"

);

12989 return

ASTRecordLayouts.getMemorySize() +

12990

llvm::capacity_in_bytes(ObjCLayouts) +

12991

llvm::capacity_in_bytes(KeyFunctions) +

12992

llvm::capacity_in_bytes(ObjCImpls) +

12993

llvm::capacity_in_bytes(BlockVarCopyInits) +

12994

llvm::capacity_in_bytes(DeclAttrs) +

12995

llvm::capacity_in_bytes(TemplateOrInstantiation) +

12996

llvm::capacity_in_bytes(InstantiatedFromUsingDecl) +

12997

llvm::capacity_in_bytes(InstantiatedFromUsingShadowDecl) +

12998

llvm::capacity_in_bytes(InstantiatedFromUnnamedFieldDecl) +

12999

llvm::capacity_in_bytes(OverriddenMethods) +

13000

llvm::capacity_in_bytes(Types) +

13001

llvm::capacity_in_bytes(VariableArrayTypes);

13009 unsigned Signed

)

const

{

13012 if

(!QualTy && DestWidth == 128)

13041

llvm_unreachable(

"Unhandled TargetInfo::RealType value"

);

13048

MangleNumbers[ND] = Number;

13055 bool

ForAuxTarget)

const

{

13056 auto

I = MangleNumbers.find(ND);

13057 unsigned

Res = I != MangleNumbers.end() ? I->second : 1;

13060 if

(LangOpts.CUDA && !LangOpts.CUDAIsDevice) {

13061

Res = ForAuxTarget ? Res >> 16 : Res & 0xFFFF;

13063

assert(!ForAuxTarget &&

"Only CUDA/HIP host compilation supports mangling " 13064 "number for aux target"

);

13066 return

Res > 1 ? Res : 1;

13073

StaticLocalNumbers[VD] = Number;

13080 auto

I = StaticLocalNumbers.find(VD);

13081 return

I != StaticLocalNumbers.end() ? I->second : 1;

13086

assert(LangOpts.CPlusPlus);

13087

std::unique_ptr<MangleNumberingContext> &MCtx = MangleNumberingContexts[DC];

13095

assert(LangOpts.CPlusPlus);

13096

std::unique_ptr<MangleNumberingContext> &MCtx =

13097

ExtraMangleNumberingContexts[

];

13103

std::unique_ptr<MangleNumberingContext>

13105 return

ABI->createMangleNumberingContext();

13110 return

ABI->getCopyConstructorForExceptionObject(

13116 return

ABI->addCopyConstructorForExceptionObject(

13123 return

ABI->addTypedefNameForUnnamedTagDecl(TD, DD);

13128 return

ABI->getTypedefNameForUnnamedTagDecl(TD);

13133 return

ABI->addDeclaratorForUnnamedTagDecl(TD, DD);

13137 return

ABI->getDeclaratorForUnnamedTagDecl(TD);

13141

ParamIndices[

] = index;

13145

ParameterIndexTable::const_iterator I = ParamIndices.find(

);

13146

assert(I != ParamIndices.end() &&

13147 "ParmIndices lacks entry set by ParmVarDecl"

);

13152 unsigned

Length)

const

{

13178

assert(

MSGuidTagDecl

"building MS GUID without MS extensions?"

);

13180

llvm::FoldingSetNodeID ID;

13184 if

(

MSGuidDecl

*Existing = MSGuidDecls.FindNodeOrInsertPos(ID, InsertPos))

13188 MSGuidDecl

*New = MSGuidDecl::Create(*

this

, GUIDType, Parts);

13189

MSGuidDecls.InsertNode(New, InsertPos);

13195 const APValue

&APVal)

const

{

13196

llvm::FoldingSetNodeID ID;

13201

UnnamedGlobalConstantDecls.FindNodeOrInsertPos(ID, InsertPos))

13205

UnnamedGlobalConstantDecl::Create(*

this

, Ty, APVal);

13206

UnnamedGlobalConstantDecls.InsertNode(New, InsertPos);

13212

assert(

isRecordType

() &&

"template param object of unexpected type"

);

13218

llvm::FoldingSetNodeID ID;

13223

TemplateParamObjectDecls.FindNodeOrInsertPos(ID, InsertPos))

13227

TemplateParamObjectDecls.InsertNode(New, InsertPos);

13233 if

.isOSDarwin())

13236 if

(!(

.isiOS() &&

.isOSVersionLT(7)) &&

13237

.isMacOSX() &&

.isOSVersionLT(10, 9)))

13246 return

(Size != Align ||

toBits

(sizeChars) > MaxInlineWidthInBits);

13253 if

(MethodDecl->

<UnavailableAttr>()

13254

|| MethodDecl->

<DeprecatedAttr>())

13268

IM != EM && IF != EF; ++IM, ++IF) {

13299

llvm::FoldingSetNodeID IDX, IDY;

13300 X

->Profile(IDX, *

this

true

);

13301

Y->

(IDY, *

this

true

);

13315 for

(

const Decl

*DX :

->redecls()) {

13320 if

(DX->isFirstDecl())

13323

llvm_unreachable(

"Corrupt redecls chain"

);

13326template

class

T, std::enable_if_t<std::is_base_of_v<Decl, T>,

bool

> = true>

13328 return

cast_or_null<T>(

13330 const_cast<Decl

>

(cast_or_null<Decl>(Y))));

13333template

class

T, std::enable_if_t<std::is_base_of_v<Decl, T>,

bool

> = true>

13336 const_cast<Decl

>

(cast<Decl>(Y))));

13341 bool

IgnoreDeduced =

false

) {

13356 bool

IgnoreDeduced) {

13364

assert(Xs.size() == Ys.size());

13366 for

(

size_t

I = 0; I < Rs.size(); ++I)

13373 return X

->getAttributeLoc() == Y->getAttributeLoc() ?

->getAttributeLoc()

13380 if

(

.getKind() != Y.

())

13383 switch

(

.getKind()) {

13413 auto

NExpX =

.getNumTemplateExpansions();

13427 if

(Xs.size() != Ys.size())

13429

R.resize(Xs.size());

13430 for

(

size_t

I = 0; I < R.size(); ++I) {

13443

assert(!Different);

13450 return X

->getKeyword() == Y->getKeyword() ?

->getKeyword()

13458 return X

->getQualifier() == Y->getQualifier()

13459

->getQualifier()

13472 QualType

EX =

->getElementType(), EY = Y->getElementType();

13477

QY += EY.getQualifiers() - RQ;

13487

assert(Ctx.

(

->getSizeExpr(), Y->getSizeExpr()));

13488 return X

->getSizeExpr();

13493 return X

->getSizeModifier();

13499 return X

->getIndexTypeCVRQualifiers();

13508

llvm::DenseMap<QualType, unsigned>

;

13509 for

(

auto

Ts : {

, Y}) {

13516

Out.emplace_back(

);

13526 bool

AcceptDependent) {

13552

assert(AcceptDependent &&

13553 "computing composite pointer type of dependent types"

);

13568

llvm_unreachable(

"These ESTs should be handled above"

);

13573

assert(EST2 ==

EST_Dynamic

"other cases should already be handled"

);

13577 Result

.Exceptions = ExceptionTypeStorage;

13584

llvm_unreachable(

"shouldn't see unresolved exception specifications here"

);

13587

llvm_unreachable(

"invalid ExceptionSpecificationType"

);

13596#define UNEXPECTED_TYPE(Class, Kind) \ 13597 case Type::Class: \ 13598 llvm_unreachable("Unexpected "

Kind ": " #Class);

13600#define NON_CANONICAL_TYPE(Class, Base) UNEXPECTED_TYPE(Class, "non-canonical"

)

13601#define TYPE(Class, Base) 13602#include "clang/AST/TypeNodes.inc" 13604#define SUGAR_FREE_TYPE(Class) UNEXPECTED_TYPE(Class, "sugar-free"

)

13615#undef SUGAR_FREE_TYPE 13616#define NON_UNIQUE_TYPE(Class) UNEXPECTED_TYPE(Class, "non-unique"

)

13619#undef NON_UNIQUE_TYPE 13623#undef UNEXPECTED_TYPE 13626 const auto

*AX = cast<AutoType>(

), *AY = cast<AutoType>(Y);

13627

assert(AX->getDeducedType().isNull());

13628

assert(AY->getDeducedType().isNull());

13629

assert(AX->getKeyword() == AY->getKeyword());

13630

assert(AX->isInstantiationDependentType() ==

13631

AY->isInstantiationDependentType());

13633

AY->getTypeConstraintArguments());

13636

AX->containsUnexpandedParameterPack(),

13638

AY->getTypeConstraintConcept()),

13641 case

Type::IncompleteArray: {

13642 const auto

*AX = cast<IncompleteArrayType>(

13643

*AY = cast<IncompleteArrayType>(Y);

13648 case

Type::DependentSizedArray: {

13649 const auto

*AX = cast<DependentSizedArrayType>(

13650

*AY = cast<DependentSizedArrayType>(Y);

13655

AX->getBracketsRange() == AY->getBracketsRange()

13656

? AX->getBracketsRange()

13659 case

Type::ConstantArray: {

13660 const auto

*AX = cast<ConstantArrayType>(

13661

*AY = cast<ConstantArrayType>(Y);

13662

assert(AX->getSize() == AY->getSize());

13663 const Expr

*SizeExpr = Ctx.

(AX->getSizeExpr(), AY->getSizeExpr())

13664

? AX->getSizeExpr()

13670 case

Type::ArrayParameter: {

13671 const auto

*AX = cast<ArrayParameterType>(

13672

*AY = cast<ArrayParameterType>(Y);

13673

assert(AX->getSize() == AY->getSize());

13674 const Expr

*SizeExpr = Ctx.

(AX->getSizeExpr(), AY->getSizeExpr())

13675

? AX->getSizeExpr()

13682 case

Type::Atomic: {

13683 const auto

*AX = cast<AtomicType>(

), *AY = cast<AtomicType>(Y);

13687 case

Type::Complex: {

13688 const auto

*CX = cast<ComplexType>(

), *CY = cast<ComplexType>(Y);

13691 case

Type::Pointer: {

13692 const auto

*PX = cast<PointerType>(

), *PY = cast<PointerType>(Y);

13695 case

Type::BlockPointer: {

13696 const auto

*PX = cast<BlockPointerType>(

), *PY = cast<BlockPointerType>(Y);

13699 case

Type::ObjCObjectPointer: {

13700 const auto

*PX = cast<ObjCObjectPointerType>(

13701

*PY = cast<ObjCObjectPointerType>(Y);

13704 case

Type::MemberPointer: {

13705 const auto

*PX = cast<MemberPointerType>(

13706

*PY = cast<MemberPointerType>(Y);

13713 case

Type::LValueReference: {

13714 const auto

*PX = cast<LValueReferenceType>(

13715

*PY = cast<LValueReferenceType>(Y);

13718

PX->isSpelledAsLValue() ||

13719

PY->isSpelledAsLValue());

13721 case

Type::RValueReference: {

13722 const auto

*PX = cast<RValueReferenceType>(

13723

*PY = cast<RValueReferenceType>(Y);

13727 case

Type::DependentAddressSpace: {

13728 const auto

*PX = cast<DependentAddressSpaceType>(

13729

*PY = cast<DependentAddressSpaceType>(Y);

13730

assert(Ctx.

(PX->getAddrSpaceExpr(), PY->getAddrSpaceExpr()));

13732

PX->getAddrSpaceExpr(),

13735 case

Type::FunctionNoProto: {

13736 const auto

*FX = cast<FunctionNoProtoType>(

13737

*FY = cast<FunctionNoProtoType>(Y);

13738

assert(FX->getExtInfo() == FY->getExtInfo());

13743 case

Type::FunctionProto: {

13744 const auto

*FX = cast<FunctionProtoType>(

13745

*FY = cast<FunctionProtoType>(Y);

13747

EPIY = FY->getExtProtoInfo();

13748

assert(EPIX.

ExtInfo

== EPIY.ExtInfo);

13751

assert(EPIX.

TypeQuals

== EPIY.TypeQuals);

13752

assert(EPIX.

Variadic

== EPIY.Variadic);

13766

EPIX.

ExceptionSpec

, EPIY.ExceptionSpec, Exceptions,

true

);

13769 case

Type::ObjCObject: {

13770 const auto

*OX = cast<ObjCObjectType>(

), *OY = cast<ObjCObjectType>(Y);

13772

std::equal(OX->getProtocols().begin(), OX->getProtocols().end(),

13773

OY->getProtocols().begin(), OY->getProtocols().end(),

13775

return P0->getCanonicalDecl() == P1->getCanonicalDecl();

13777 "protocol lists must be the same"

);

13779

OY->getTypeArgsAsWritten());

13782

OX->getProtocols(),

13783

OX->isKindOfTypeAsWritten() && OY->isKindOfTypeAsWritten());

13785 case

Type::ConstantMatrix: {

13786 const auto

*MX = cast<ConstantMatrixType>(

13787

*MY = cast<ConstantMatrixType>(Y);

13788

assert(MX->getNumRows() == MY->getNumRows());

13789

assert(MX->getNumColumns() == MY->getNumColumns());

13791

MX->getNumRows(), MX->getNumColumns());

13793 case

Type::DependentSizedMatrix: {

13794 const auto

*MX = cast<DependentSizedMatrixType>(

13795

*MY = cast<DependentSizedMatrixType>(Y);

13796

assert(Ctx.

(MX->getRowExpr(), MY->getRowExpr()));

13797

assert(Ctx.

(MX->getColumnExpr(), MY->getColumnExpr()));

13802 case

Type::Vector: {

13803 const auto

*VX = cast<VectorType>(

), *VY = cast<VectorType>(Y);

13804

assert(VX->getNumElements() == VY->getNumElements());

13805

assert(VX->getVectorKind() == VY->getVectorKind());

13807

VX->getNumElements(), VX->getVectorKind());

13809 case

Type::ExtVector: {

13810 const auto

*VX = cast<ExtVectorType>(

), *VY = cast<ExtVectorType>(Y);

13811

assert(VX->getNumElements() == VY->getNumElements());

13813

VX->getNumElements());

13815 case

Type::DependentSizedExtVector: {

13816 const auto

*VX = cast<DependentSizedExtVectorType>(

13817

*VY = cast<DependentSizedExtVectorType>(Y);

13822 case

Type::DependentVector: {

13823 const auto

*VX = cast<DependentVectorType>(

13824

*VY = cast<DependentVectorType>(Y);

13825

assert(VX->getVectorKind() == VY->getVectorKind());

13830 case

Type::InjectedClassName: {

13831 const auto

*IX = cast<InjectedClassNameType>(

13832

*IY = cast<InjectedClassNameType>(Y);

13836

IY->getInjectedSpecializationType()));

13838 case

Type::TemplateSpecialization: {

13839 const auto

*TX = cast<TemplateSpecializationType>(

13840

*TY = cast<TemplateSpecializationType>(Y);

13842

TY->template_arguments());

13845

TY->getTemplateName(),

13847

As,

->getCanonicalTypeInternal());

13849 case

Type::Decltype: {

13850 const auto

*DX = cast<DecltypeType>(

);

13851

[[maybe_unused]]

const auto

*DY = cast<DecltypeType>(Y);

13852

assert(DX->isDependentType());

13853

assert(DY->isDependentType());

13854

assert(Ctx.

(DX->getUnderlyingExpr(), DY->getUnderlyingExpr()));

13858 case

Type::PackIndexing: {

13859 const auto

*DX = cast<PackIndexingType>(

);

13860

[[maybe_unused]]

const auto

*DY = cast<PackIndexingType>(Y);

13861

assert(DX->isDependentType());

13862

assert(DY->isDependentType());

13863

assert(Ctx.

(DX->getIndexExpr(), DY->getIndexExpr()));

13866 case

Type::DependentName: {

13867 const auto

*NX = cast<DependentNameType>(

13868

*NY = cast<DependentNameType>(Y);

13869

assert(NX->getIdentifier() == NY->getIdentifier());

13872

NX->getIdentifier(), NX->getCanonicalTypeInternal());

13874 case

Type::DependentTemplateSpecialization: {

13875 const auto

*TX = cast<DependentTemplateSpecializationType>(

13876

*TY = cast<DependentTemplateSpecializationType>(Y);

13877

assert(TX->getIdentifier() == TY->getIdentifier());

13879

TY->template_arguments());

13882

TX->getIdentifier(), As);

13884 case

Type::UnaryTransform: {

13885 const auto

*TX = cast<UnaryTransformType>(

13886

*TY = cast<UnaryTransformType>(Y);

13887

assert(TX->getUTTKind() == TY->getUTTKind());

13891

TY->getUnderlyingType()),

13894 case

Type::PackExpansion: {

13895 const auto

*PX = cast<PackExpansionType>(

13896

*PY = cast<PackExpansionType>(Y);

13897

assert(PX->getNumExpansions() == PY->getNumExpansions());

13900

PX->getNumExpansions(),

false

);

13903 const auto

*PX = cast<PipeType>(

), *PY = cast<PipeType>(Y);

13904

assert(PX->isReadOnly() == PY->isReadOnly());

13909 case

Type::TemplateTypeParm: {

13910 const auto

*TX = cast<TemplateTypeParmType>(

13911

*TY = cast<TemplateTypeParmType>(Y);

13912

assert(TX->getDepth() == TY->getDepth());

13913

assert(TX->getIndex() == TY->getIndex());

13914

assert(TX->isParameterPack() == TY->isParameterPack());

13916

TX->getDepth(), TX->getIndex(), TX->isParameterPack(),

13920

llvm_unreachable(

"Unknown Type Class"

);

13930#define UNEXPECTED_TYPE(Class, Kind) \ 13931 case Type::Class: \ 13932 llvm_unreachable("Unexpected "

Kind ": " #Class);

13933#define TYPE(Class, Base) 13934#define DEPENDENT_TYPE(Class, Base) UNEXPECTED_TYPE(Class, "dependent"

)

13935#include "clang/AST/TypeNodes.inc" 13937#define CANONICAL_TYPE(Class) UNEXPECTED_TYPE(Class, "canonical"

)

13963#undef CANONICAL_TYPE 13965#undef UNEXPECTED_TYPE 13967 case

Type::Adjusted: {

13968 const auto

*AX = cast<AdjustedType>(

), *AY = cast<AdjustedType>(Y);

13969 QualType

OX = AX->getOriginalType(), OY = AY->getOriginalType();

13976 case

Type::Decayed: {

13977 const auto

*DX = cast<DecayedType>(

), *DY = cast<DecayedType>(Y);

13978 QualType

OX = DX->getOriginalType(), OY = DY->getOriginalType();

13985 case

Type::Attributed: {

13986 const auto

*AX = cast<AttributedType>(

), *AY = cast<AttributedType>(Y);

13988 if

(Kind != AY->getAttrKind())

13990 QualType

MX = AX->getModifiedType(), MY = AY->getModifiedType();

13998 case

Type::BTFTagAttributed: {

13999 const auto

*BX = cast<BTFTagAttributedType>(

);

14000 const

BTFTypeTagAttr *AX = BX->getAttr();

14002 if

(AX->getBTFTypeTag() !=

14003

cast<BTFTagAttributedType>(Y)->getAttr()->getBTFTypeTag())

14008 const auto

*AX = cast<AutoType>(

), *AY = cast<AutoType>(Y);

14011 if

(KW != AY->getKeyword())

14015

AY->getTypeConstraintConcept());

14019

AY->getTypeConstraintArguments())) {

14027 false

false

, CD, As);

14029 case

Type::PackIndexing:

14030 case

Type::Decltype:

14032 case

Type::DeducedTemplateSpecialization:

14036 case

Type::Elaborated: {

14037 const auto

*EX = cast<ElaboratedType>(

), *EY = cast<ElaboratedType>(Y);

14043 case

Type::MacroQualified: {

14044 const auto

*MX = cast<MacroQualifiedType>(

14045

*MY = cast<MacroQualifiedType>(Y);

14047 if

(IX != MY->getMacroIdentifier())

14051 case

Type::SubstTemplateTypeParm: {

14052 const auto

*SX = cast<SubstTemplateTypeParmType>(

14053

*SY = cast<SubstTemplateTypeParmType>(Y);

14058 unsigned

Index = SX->getIndex();

14059 if

(Index != SY->getIndex())

14061 auto

PackIndex = SX->getPackIndex();

14062 if

(PackIndex != SY->getPackIndex())

14065

CD, Index, PackIndex);

14067 case

Type::ObjCTypeParam:

14073 case

Type::TemplateSpecialization: {

14074 const auto

*TX = cast<TemplateSpecializationType>(

14075

*TY = cast<TemplateSpecializationType>(Y);

14078

TY->getTemplateName(),

true

);

14083

TY->template_arguments()))

14088 case

Type::Typedef: {

14089 const auto

*TX = cast<TypedefType>(

), *TY = cast<TypedefType>(Y);

14095 case

Type::TypeOf: {

14101 if

(cast<TypeOfType>(

)->

() == cast<TypeOfType>(Y)->

() &&

14106 case

Type::TypeOfExpr:

14109 case

Type::UnaryTransform: {

14110 const auto

*UX = cast<UnaryTransformType>(

14111

*UY = cast<UnaryTransformType>(Y);

14113 if

(KX != UY->getUTTKind())

14115 QualType

BX = UX->getBaseType(), BY = UY->getBaseType();

14122 case

Type::Using: {

14123 const auto

*UX = cast<UsingType>(

), *UY = cast<UsingType>(Y);

14130 case

Type::CountAttributed: {

14131 const auto

*DX = cast<CountAttributedType>(

14132

*DY = cast<CountAttributedType>(Y);

14133 if

(DX->isCountInBytes() != DY->isCountInBytes())

14135 if

(DX->isOrNull() != DY->isOrNull())

14137 Expr

*CEX = DX->getCountExpr();

14138 Expr

*CEY = DY->getCountExpr();

14142

DX->isCountInBytes(), DX->isOrNull(),

14153

DX->isCountInBytes(), DX->isOrNull(),

14157

llvm_unreachable(

"Unhandled Type Class"

);

14179 if

(

.isCanonical())

14192 if

(SX.

!= SY.Ty) {

14200 while

(!Xs.empty() && !Ys.empty() && Xs.back().Ty == Ys.back().Ty) {

14203

SX = Xs.pop_back_val();

14204

SY = Ys.pop_back_val();

14214 while

(!Xs.empty() && !Ys.empty()) {

14217

SX = Xs.pop_back_val();

14218

SY = Ys.pop_back_val();

14223

SX.

= Underlying.Ty;

14226

QX -= Underlying.Quals;

14244

llvm_unreachable(

"Not a saturated fixed point type!"

);

14245 case

BuiltinType::SatShortAccum:

14247 case

BuiltinType::SatAccum:

14249 case

BuiltinType::SatLongAccum:

14251 case

BuiltinType::SatUShortAccum:

14253 case

BuiltinType::SatUAccum:

14255 case

BuiltinType::SatULongAccum:

14257 case

BuiltinType::SatShortFract:

14259 case

BuiltinType::SatFract:

14261 case

BuiltinType::SatLongFract:

14263 case

BuiltinType::SatUShortFract:

14265 case

BuiltinType::SatUFract:

14267 case

BuiltinType::SatULongFract:

14279

llvm_unreachable(

"Not a fixed point type!"

);

14280 case

BuiltinType::ShortAccum:

14282 case

BuiltinType::Accum:

14284 case

BuiltinType::LongAccum:

14286 case

BuiltinType::UShortAccum:

14288 case

BuiltinType::UAccum:

14290 case

BuiltinType::ULongAccum:

14292 case

BuiltinType::ShortFract:

14294 case

BuiltinType::Fract:

14296 case

BuiltinType::LongFract:

14298 case

BuiltinType::UShortFract:

14300 case

BuiltinType::UFract:

14302 case

BuiltinType::ULongFract:

14308 if

(LangOpts.OpenCL)

14332

llvm_unreachable(

"Not a fixed point type!"

);

14333 case

BuiltinType::ShortAccum:

14334 case

BuiltinType::SatShortAccum:

14335 return Target

.getShortAccumScale();

14336 case

BuiltinType::Accum:

14337 case

BuiltinType::SatAccum:

14338 return Target

.getAccumScale();

14339 case

BuiltinType::LongAccum:

14340 case

BuiltinType::SatLongAccum:

14341 return Target

.getLongAccumScale();

14342 case

BuiltinType::UShortAccum:

14343 case

BuiltinType::SatUShortAccum:

14344 return Target

.getUnsignedShortAccumScale();

14345 case

BuiltinType::UAccum:

14346 case

BuiltinType::SatUAccum:

14347 return Target

.getUnsignedAccumScale();

14348 case

BuiltinType::ULongAccum:

14349 case

BuiltinType::SatULongAccum:

14350 return Target

.getUnsignedLongAccumScale();

14351 case

BuiltinType::ShortFract:

14352 case

BuiltinType::SatShortFract:

14353 return Target

.getShortFractScale();

14354 case

BuiltinType::Fract:

14355 case

BuiltinType::SatFract:

14356 return Target

.getFractScale();

14357 case

BuiltinType::LongFract:

14358 case

BuiltinType::SatLongFract:

14359 return Target

.getLongFractScale();

14360 case

BuiltinType::UShortFract:

14361 case

BuiltinType::SatUShortFract:

14362 return Target

.getUnsignedShortFractScale();

14363 case

BuiltinType::UFract:

14364 case

BuiltinType::SatUFract:

14365 return Target

.getUnsignedFractScale();

14366 case

BuiltinType::ULongFract:

14367 case

BuiltinType::SatULongFract:

14368 return Target

.getUnsignedLongFractScale();

14378

llvm_unreachable(

"Not a fixed point type!"

);

14379 case

BuiltinType::ShortAccum:

14380 case

BuiltinType::SatShortAccum:

14381 return Target

.getShortAccumIBits();

14382 case

BuiltinType::Accum:

14383 case

BuiltinType::SatAccum:

14384 return Target

.getAccumIBits();

14385 case

BuiltinType::LongAccum:

14386 case

BuiltinType::SatLongAccum:

14387 return Target

.getLongAccumIBits();

14388 case

BuiltinType::UShortAccum:

14389 case

BuiltinType::SatUShortAccum:

14390 return Target

.getUnsignedShortAccumIBits();

14391 case

BuiltinType::UAccum:

14392 case

BuiltinType::SatUAccum:

14393 return Target

.getUnsignedAccumIBits();

14394 case

BuiltinType::ULongAccum:

14395 case

BuiltinType::SatULongAccum:

14396 return Target

.getUnsignedLongAccumIBits();

14397 case

BuiltinType::ShortFract:

14398 case

BuiltinType::SatShortFract:

14399 case

BuiltinType::Fract:

14400 case

BuiltinType::SatFract:

14401 case

BuiltinType::LongFract:

14402 case

BuiltinType::SatLongFract:

14403 case

BuiltinType::UShortFract:

14404 case

BuiltinType::SatUShortFract:

14405 case

BuiltinType::UFract:

14406 case

BuiltinType::SatUFract:

14407 case

BuiltinType::ULongFract:

14408 case

BuiltinType::SatULongFract:

14413

llvm::FixedPointSemantics

14416 "Can only get the fixed point semantics for a " 14417 "fixed point or integer type."

);

14419 return

llvm::FixedPointSemantics::GetIntegerSemantics(

14423 return

llvm::FixedPointSemantics(

14426

!isSigned &&

getTargetInfo

().doUnsignedFixedPointTypesHavePadding());

14441 "Expected unsigned fixed point type"

);

14444 case

BuiltinType::UShortAccum:

14446 case

BuiltinType::UAccum:

14448 case

BuiltinType::ULongAccum:

14450 case

BuiltinType::SatUShortAccum:

14452 case

BuiltinType::SatUAccum:

14454 case

BuiltinType::SatULongAccum:

14456 case

BuiltinType::UShortFract:

14458 case

BuiltinType::UFract:

14460 case

BuiltinType::ULongFract:

14462 case

BuiltinType::SatUShortFract:

14464 case

BuiltinType::SatUFract:

14466 case

BuiltinType::SatULongFract:

14469

llvm_unreachable(

"Unexpected unsigned fixed point type"

);

14477

std::vector<std::string> BackendFeats;

14478

llvm::AArch64::ExtensionSet FeatureBits;

14479 for

(StringRef F : FMVFeatStrings)

14480 if

(

auto

FMVExt = llvm::AArch64::parseFMVExtension(F))

14482

FeatureBits.enable(*FMVExt->ID);

14483

FeatureBits.toLLVMFeatureList(BackendFeats);

14484 return

BackendFeats;

14489

assert(TD !=

nullptr

);

14492

llvm::erase_if(

ParsedAttr

.Features, [&](

const

std::string &Feat) {

14493

return !Target->isValidFeatureName(StringRef{Feat}.substr(1));

14504 Target

->getTargetOpts().CPU,

14505 Target

->getTargetOpts().Features);

14512

StringRef TargetCPU =

->getTargetOpts().CPU;

14514 if

(

const auto

*TD = FD->

<TargetAttr>()) {

14520 if

->getTriple().isAArch64())

14523 Target

->getTargetOpts().FeaturesAsWritten.begin(),

14524 Target

->getTargetOpts().FeaturesAsWritten.end());

14535

}

else if

(

const auto

*SD = FD->

<CPUSpecificAttr>()) {

14537 Target

->getCPUSpecificCPUDispatchFeatures(

14539

std::vector<std::string> Features(FeaturesTmp.begin(), FeaturesTmp.end());

14540

Features.insert(Features.begin(),

14541 Target

->getTargetOpts().FeaturesAsWritten.begin(),

14542 Target

->getTargetOpts().FeaturesAsWritten.end());

14544

}

else if

(

const auto

*TC = FD->

<TargetClonesAttr>()) {

14545 if

(

->getTriple().isAArch64()) {

14549

Features.insert(Features.begin(),

14550 Target

->getTargetOpts().FeaturesAsWritten.begin(),

14551 Target

->getTargetOpts().FeaturesAsWritten.end());

14553

}

else if

(

->getTriple().isRISCV()) {

14555

std::vector<std::string> Features;

14556 if

(VersionStr !=

"default"

) {

14558

Features.insert(Features.begin(),

ParsedAttr

.Features.begin(),

14561

Features.insert(Features.begin(),

14562 Target

->getTargetOpts().FeaturesAsWritten.begin(),

14563 Target

->getTargetOpts().FeaturesAsWritten.end());

14566

std::vector<std::string> Features;

14568 if

(VersionStr.starts_with(

"arch="

))

14569

TargetCPU = VersionStr.drop_front(

sizeof

(

"arch="

) - 1);

14570 else if

(VersionStr !=

"default"

)

14571

Features.push_back((StringRef{

"+"

} + VersionStr).str());

14574

}

else if

(

const auto

*TV = FD->

<TargetVersionAttr>()) {

14575

std::vector<std::string> Features;

14576 if

(

->getTriple().isRISCV()) {

14578

Features.insert(Features.begin(),

ParsedAttr

.Features.begin(),

14581

assert(

->getTriple().isAArch64());

14583

TV->getFeatures(Feats);

14586

Features.insert(Features.begin(),

14587 Target

->getTargetOpts().FeaturesAsWritten.begin(),

14588 Target

->getTargetOpts().FeaturesAsWritten.end());

14591

FeatureMap =

->getTargetOpts().FeatureMap;

14597 return

{KernelNameType, FD};

14606 const auto

*SKEPAttr = FD->

<SYCLKernelEntryPointAttr>();

14607

assert(SKEPAttr &&

"Missing sycl_kernel_entry_point attribute"

);

14616 "SYCL kernel name conflict"

);

14631 return

&IT->second;

14636

OMPTraitInfoVector.emplace_back(

new OMPTraitInfo

());

14637 return

*OMPTraitInfoVector.back();

14643 if

(Section.

)

14644 return

DB << Section.

;

14645 return

DB <<

"a prior #pragma section"

;

14649 bool

IsInternalVar =

14650

isa<VarDecl>(

) &&

14652 bool

IsExplicitDeviceVar = (

<CUDADeviceAttr>() &&

14653

<CUDADeviceAttr>()->isImplicit()) ||

14654

(

<CUDAConstantAttr>() &&

14655

<CUDAConstantAttr>()->isImplicit());

14659 return

(IsInternalVar &&

14660

(

<HIPManagedAttr>() || IsExplicitDeviceVar)) ||

14661

(

<CUDAGlobalAttr>() &&

14673 if

(!CUIDHash.empty())

14675 if

(LangOpts.

CUID

.empty())

14676 return

StringRef();

14677

CUIDHash = llvm::utohexstr(llvm::MD5Hash(LangOpts.

CUID

true

);

14687

assert(PrimaryBase);

14690 auto Base

= Layout.getPrimaryBase();

14691 if

== PrimaryBase || !

->isPolymorphic())

14693

PrimaryBase =