clang/lib/CodeGen/CodeGenTypes.cpp

   1 //===--- CodeGenTypes.cpp - Type translation for LLVM CodeGen -------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This is the code that handles AST -> LLVM type lowering.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "CodeGenTypes.h"
  14 #include "CGCXXABI.h"
  15 #include "CGCall.h"
  16 #include "CGOpenCLRuntime.h"
  17 #include "CGRecordLayout.h"
  18 #include "TargetInfo.h"
  19 #include "clang/AST/ASTContext.h"
  20 #include "clang/AST/DeclCXX.h"
  21 #include "clang/AST/DeclObjC.h"
  22 #include "clang/AST/Expr.h"
  23 #include "clang/AST/RecordLayout.h"
  24 #include "clang/CodeGen/CGFunctionInfo.h"
  25 #include "llvm/IR/DataLayout.h"
  26 #include "llvm/IR/DerivedTypes.h"
  27 #include "llvm/IR/Module.h"
  28
  29 using namespace clang;
  30 using namespace CodeGen;
  31
  32 CodeGenTypes::CodeGenTypes(CodeGenModule &cgm)
  33   : CGM(cgm), Context(cgm.getContext()), TheModule(cgm.getModule()),
  34     Target(cgm.getTarget()), TheCXXABI(cgm.getCXXABI()),
  35     TheABIInfo(cgm.getTargetCodeGenInfo().getABIInfo()) {
  36   SkippedLayout = false;
  37   LongDoubleReferenced = false;
  38 }
  39
  40 CodeGenTypes::~CodeGenTypes() {
  41   for (llvm::FoldingSet<CGFunctionInfo>::iterator
  42        I = FunctionInfos.begin(), E = FunctionInfos.end(); I != E; )
  43     delete &*I++;
  44 }
  45
  46 const CodeGenOptions &CodeGenTypes::getCodeGenOpts() const {
  47   return CGM.getCodeGenOpts();
  48 }
  49
  50 void CodeGenTypes::addRecordTypeName(const RecordDecl *RD,
  51                                      llvm::StructType *Ty,
  52                                      StringRef suffix) {
  53   SmallString<256> TypeName;
  54   llvm::raw_svector_ostream OS(TypeName);
  55   OS << RD->getKindName() << '.';
  56
  57   // FIXME: We probably want to make more tweaks to the printing policy. For
  58   // example, we should probably enable PrintCanonicalTypes and
  59   // FullyQualifiedNames.
  60   PrintingPolicy Policy = RD->getASTContext().getPrintingPolicy();
  61   Policy.SuppressInlineNamespace = false;
  62
  63   // Name the codegen type after the typedef name
  64   // if there is no tag type name available
  65   if (RD->getIdentifier()) {
  66     // FIXME: We should not have to check for a null decl context here.
  67     // Right now we do it because the implicit Obj-C decls don't have one.
  68     if (RD->getDeclContext())
  69       RD->printQualifiedName(OS, Policy);
  70     else
  71       RD->printName(OS, Policy);
  72   } else if (const TypedefNameDecl *TDD = RD->getTypedefNameForAnonDecl()) {
  73     // FIXME: We should not have to check for a null decl context here.
  74     // Right now we do it because the implicit Obj-C decls don't have one.
  75     if (TDD->getDeclContext())
  76       TDD->printQualifiedName(OS, Policy);
  77     else
  78       TDD->printName(OS);
  79   } else
  80     OS << "anon";
  81
  82   if (!suffix.empty())
  83     OS << suffix;
  84
  85   Ty->setName(OS.str());
  86 }
  87
  88 /// ConvertTypeForMem - Convert type T into a llvm::Type.  This differs from
  89 /// ConvertType in that it is used to convert to the memory representation for
  90 /// a type.  For example, the scalar representation for _Bool is i1, but the
  91 /// memory representation is usually i8 or i32, depending on the target.
  92 ///
  93 /// We generally assume that the alloc size of this type under the LLVM
  94 /// data layout is the same as the size of the AST type.  The alignment
  95 /// does not have to match: Clang should always use explicit alignments
  96 /// and packed structs as necessary to produce the layout it needs.
  97 /// But the size does need to be exactly right or else things like struct
  98 /// layout will break.
  99 llvm::Type *CodeGenTypes::ConvertTypeForMem(QualType T) {
 100   if (T->isConstantMatrixType()) {
 101     const Type *Ty = Context.getCanonicalType(T).getTypePtr();
 102     const ConstantMatrixType *MT = cast<ConstantMatrixType>(Ty);
 103     return llvm::ArrayType::get(ConvertType(MT->getElementType()),
 104                                 MT->getNumRows() * MT->getNumColumns());
 105   }
 106
 107   llvm::Type *R = ConvertType(T);
 108
 109   // Check for the boolean vector case.
 110   if (T->isExtVectorBoolType()) {
 111     auto *FixedVT = cast<llvm::FixedVectorType>(R);
 112     // Pad to at least one byte.
 113     uint64_t BytePadded = std::max<uint64_t>(FixedVT->getNumElements(), 8);
 114     return llvm::IntegerType::get(FixedVT->getContext(), BytePadded);
 115   }
 116
 117   // If T is _Bool or a _BitInt type, ConvertType will produce an IR type
 118   // with the exact semantic bit-width of the AST type; for example,
 119   // _BitInt(17) will turn into i17. In memory, however, we need to store
 120   // such values extended to their full storage size as decided by AST
 121   // layout; this is an ABI requirement. Ideally, we would always use an
 122   // integer type that's just the bit-size of the AST type; for example, if
 123   // sizeof(_BitInt(17)) == 4, _BitInt(17) would turn into i32. That is what's
 124   // returned by convertTypeForLoadStore. However, that type does not
 125   // always satisfy the size requirement on memory representation types
 126   // describe above. For example, a 32-bit platform might reasonably set
 127   // sizeof(_BitInt(65)) == 12, but i96 is likely to have to have an alloc size
 128   // of 16 bytes in the LLVM data layout. In these cases, we simply return
 129   // a byte array of the appropriate size.
 130   if (T->isBitIntType()) {
 131     if (typeRequiresSplitIntoByteArray(T, R))
 132       return llvm::ArrayType::get(CGM.Int8Ty,
 133                                   Context.getTypeSizeInChars(T).getQuantity());
 134     return llvm::IntegerType::get(getLLVMContext(),
 135                                   (unsigned)Context.getTypeSize(T));
 136   }
 137
 138   if (R->isIntegerTy(1))
 139     return llvm::IntegerType::get(getLLVMContext(),
 140                                   (unsigned)Context.getTypeSize(T));
 141
 142   // Else, don't map it.
 143   return R;
 144 }
 145
 146 bool CodeGenTypes::typeRequiresSplitIntoByteArray(QualType ASTTy,
 147                                                   llvm::Type *LLVMTy) {
 148   if (!LLVMTy)
 149     LLVMTy = ConvertType(ASTTy);
 150
 151   CharUnits ASTSize = Context.getTypeSizeInChars(ASTTy);
 152   CharUnits LLVMSize =
 153       CharUnits::fromQuantity(getDataLayout().getTypeAllocSize(LLVMTy));
 154   return ASTSize != LLVMSize;
 155 }
 156
 157 llvm::Type *CodeGenTypes::convertTypeForLoadStore(QualType T,
 158                                                   llvm::Type *LLVMTy) {
 159   if (!LLVMTy)
 160     LLVMTy = ConvertType(T);
 161
 162   if (T->isBitIntType())
 163     return llvm::Type::getIntNTy(
 164         getLLVMContext(), Context.getTypeSizeInChars(T).getQuantity() * 8);
 165
 166   if (LLVMTy->isIntegerTy(1))
 167     return llvm::IntegerType::get(getLLVMContext(),
 168                                   (unsigned)Context.getTypeSize(T));
 169
 170   if (T->isExtVectorBoolType())
 171     return ConvertTypeForMem(T);
 172
 173   return LLVMTy;
 174 }
 175
 176 /// isRecordLayoutComplete - Return true if the specified type is already
 177 /// completely laid out.
 178 bool CodeGenTypes::isRecordLayoutComplete(const Type *Ty) const {
 179   llvm::DenseMap<const Type*, llvm::StructType *>::const_iterator I =
 180   RecordDeclTypes.find(Ty);
 181   return I != RecordDeclTypes.end() && !I->second->isOpaque();
 182 }
 183
 184 /// isFuncParamTypeConvertible - Return true if the specified type in a
 185 /// function parameter or result position can be converted to an IR type at this
 186 /// point. This boils down to being whether it is complete.
 187 bool CodeGenTypes::isFuncParamTypeConvertible(QualType Ty) {
 188   // Some ABIs cannot have their member pointers represented in IR unless
 189   // certain circumstances have been reached.
 190   if (const auto *MPT = Ty->getAs<MemberPointerType>())
 191     return getCXXABI().isMemberPointerConvertible(MPT);
 192
 193   // If this isn't a tagged type, we can convert it!
 194   const TagType *TT = Ty->getAs<TagType>();
 195   if (!TT) return true;
 196
 197   // Incomplete types cannot be converted.
 198   return !TT->isIncompleteType();
 199 }
 200
 201
 202 /// Code to verify a given function type is complete, i.e. the return type
 203 /// and all of the parameter types are complete.  Also check to see if we are in
 204 /// a RS_StructPointer context, and if so whether any struct types have been
 205 /// pended.  If so, we don't want to ask the ABI lowering code to handle a type
 206 /// that cannot be converted to an IR type.
 207 bool CodeGenTypes::isFuncTypeConvertible(const FunctionType *FT) {
 208   if (!isFuncParamTypeConvertible(FT->getReturnType()))
 209     return false;
 210
 211   if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FT))
 212     for (unsigned i = 0, e = FPT->getNumParams(); i != e; i++)
 213       if (!isFuncParamTypeConvertible(FPT->getParamType(i)))
 214         return false;
 215
 216   return true;
 217 }
 218
 219 /// UpdateCompletedType - When we find the full definition for a TagDecl,
 220 /// replace the 'opaque' type we previously made for it if applicable.
 221 void CodeGenTypes::UpdateCompletedType(const TagDecl *TD) {
 222   // If this is an enum being completed, then we flush all non-struct types from
 223   // the cache.  This allows function types and other things that may be derived
 224   // from the enum to be recomputed.
 225   if (const EnumDecl *ED = dyn_cast<EnumDecl>(TD)) {
 226     // Only flush the cache if we've actually already converted this type.
 227     if (TypeCache.count(ED->getTypeForDecl())) {
 228       // Okay, we formed some types based on this.  We speculated that the enum
 229       // would be lowered to i32, so we only need to flush the cache if this
 230       // didn't happen.
 231       if (!ConvertType(ED->getIntegerType())->isIntegerTy(32))
 232         TypeCache.clear();
 233     }
 234     // If necessary, provide the full definition of a type only used with a
 235     // declaration so far.
 236     if (CGDebugInfo *DI = CGM.getModuleDebugInfo())
 237       DI->completeType(ED);
 238     return;
 239   }
 240
 241   // If we completed a RecordDecl that we previously used and converted to an
 242   // anonymous type, then go ahead and complete it now.
 243   const RecordDecl *RD = cast<RecordDecl>(TD);
 244   if (RD->isDependentType()) return;
 245
 246   // Only complete it if we converted it already.  If we haven't converted it
 247   // yet, we'll just do it lazily.
 248   if (RecordDeclTypes.count(Context.getTagDeclType(RD).getTypePtr()))
 249     ConvertRecordDeclType(RD);
 250
 251   // If necessary, provide the full definition of a type only used with a
 252   // declaration so far.
 253   if (CGDebugInfo *DI = CGM.getModuleDebugInfo())
 254     DI->completeType(RD);
 255 }
 256
 257 void CodeGenTypes::RefreshTypeCacheForClass(const CXXRecordDecl *RD) {
 258   QualType T = Context.getRecordType(RD);
 259   T = Context.getCanonicalType(T);
 260
 261   const Type *Ty = T.getTypePtr();
 262   if (RecordsWithOpaqueMemberPointers.count(Ty)) {
 263     TypeCache.clear();
 264     RecordsWithOpaqueMemberPointers.clear();
 265   }
 266 }
 267
 268 static llvm::Type *getTypeForFormat(llvm::LLVMContext &VMContext,
 269                                     const llvm::fltSemantics &format,
 270                                     bool UseNativeHalf = false) {
 271   if (&format == &llvm::APFloat::IEEEhalf()) {
 272     if (UseNativeHalf)
 273       return llvm::Type::getHalfTy(VMContext);
 274     else
 275       return llvm::Type::getInt16Ty(VMContext);
 276   }
 277   if (&format == &llvm::APFloat::BFloat())
 278     return llvm::Type::getBFloatTy(VMContext);
 279   if (&format == &llvm::APFloat::IEEEsingle())
 280     return llvm::Type::getFloatTy(VMContext);
 281   if (&format == &llvm::APFloat::IEEEdouble())
 282     return llvm::Type::getDoubleTy(VMContext);
 283   if (&format == &llvm::APFloat::IEEEquad())
 284     return llvm::Type::getFP128Ty(VMContext);
 285   if (&format == &llvm::APFloat::PPCDoubleDouble())
 286     return llvm::Type::getPPC_FP128Ty(VMContext);
 287   if (&format == &llvm::APFloat::x87DoubleExtended())
 288     return llvm::Type::getX86_FP80Ty(VMContext);
 289   llvm_unreachable("Unknown float format!");
 290 }
 291
 292 llvm::Type *CodeGenTypes::ConvertFunctionTypeInternal(QualType QFT) {
 293   assert(QFT.isCanonical());
 294   const FunctionType *FT = cast<FunctionType>(QFT.getTypePtr());
 295   // First, check whether we can build the full function type.  If the
 296   // function type depends on an incomplete type (e.g. a struct or enum), we
 297   // cannot lower the function type.
 298   if (!isFuncTypeConvertible(FT)) {
 299     // This function's type depends on an incomplete tag type.
 300
 301     // Force conversion of all the relevant record types, to make sure
 302     // we re-convert the FunctionType when appropriate.
 303     if (const RecordType *RT = FT->getReturnType()->getAs<RecordType>())
 304       ConvertRecordDeclType(RT->getDecl());
 305     if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FT))
 306       for (unsigned i = 0, e = FPT->getNumParams(); i != e; i++)
 307         if (const RecordType *RT = FPT->getParamType(i)->getAs<RecordType>())
 308           ConvertRecordDeclType(RT->getDecl());
 309
 310     SkippedLayout = true;
 311
 312     // Return a placeholder type.
 313     return llvm::StructType::get(getLLVMContext());
 314   }
 315
 316   // The function type can be built; call the appropriate routines to
 317   // build it.
 318   const CGFunctionInfo *FI;
 319   if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FT)) {
 320     FI = &arrangeFreeFunctionType(
 321         CanQual<FunctionProtoType>::CreateUnsafe(QualType(FPT, 0)));
 322   } else {
 323     const FunctionNoProtoType *FNPT = cast<FunctionNoProtoType>(FT);
 324     FI = &arrangeFreeFunctionType(
 325         CanQual<FunctionNoProtoType>::CreateUnsafe(QualType(FNPT, 0)));
 326   }
 327
 328   llvm::Type *ResultType = nullptr;
 329   // If there is something higher level prodding our CGFunctionInfo, then
 330   // don't recurse into it again.
 331   if (FunctionsBeingProcessed.count(FI)) {
 332
 333     ResultType = llvm::StructType::get(getLLVMContext());
 334     SkippedLayout = true;
 335   } else {
 336
 337     // Otherwise, we're good to go, go ahead and convert it.
 338     ResultType = GetFunctionType(*FI);
 339   }
 340
 341   return ResultType;
 342 }
 343
 344 /// ConvertType - Convert the specified type to its LLVM form.
 345 llvm::Type *CodeGenTypes::ConvertType(QualType T) {
 346   T = Context.getCanonicalType(T);
 347
 348   const Type *Ty = T.getTypePtr();
 349
 350   // For the device-side compilation, CUDA device builtin surface/texture types
 351   // may be represented in different types.
 352   if (Context.getLangOpts().CUDAIsDevice) {
 353     if (T->isCUDADeviceBuiltinSurfaceType()) {
 354       if (auto *Ty = CGM.getTargetCodeGenInfo()
 355                          .getCUDADeviceBuiltinSurfaceDeviceType())
 356         return Ty;
 357     } else if (T->isCUDADeviceBuiltinTextureType()) {
 358       if (auto *Ty = CGM.getTargetCodeGenInfo()
 359                          .getCUDADeviceBuiltinTextureDeviceType())
 360         return Ty;
 361     }
 362   }
 363
 364   // RecordTypes are cached and processed specially.
 365   if (const RecordType *RT = dyn_cast<RecordType>(Ty))
 366     return ConvertRecordDeclType(RT->getDecl());
 367
 368   llvm::Type *CachedType = nullptr;
 369   auto TCI = TypeCache.find(Ty);
 370   if (TCI != TypeCache.end())
 371     CachedType = TCI->second;
 372     // With expensive checks, check that the type we compute matches the
 373     // cached type.
 374 #ifndef EXPENSIVE_CHECKS
 375   if (CachedType)
 376     return CachedType;
 377 #endif
 378
 379   // If we don't have it in the cache, convert it now.
 380   llvm::Type *ResultType = nullptr;
 381   switch (Ty->getTypeClass()) {
 382   case Type::Record: // Handled above.
 383 #define TYPE(Class, Base)
 384 #define ABSTRACT_TYPE(Class, Base)
 385 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
 386 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
 387 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
 388 #include "clang/AST/TypeNodes.inc"
 389     llvm_unreachable("Non-canonical or dependent types aren't possible.");
 390
 391   case Type::Builtin: {
 392     switch (cast<BuiltinType>(Ty)->getKind()) {
 393     case BuiltinType::Void:
 394     case BuiltinType::ObjCId:
 395     case BuiltinType::ObjCClass:
 396     case BuiltinType::ObjCSel:
 397       // LLVM void type can only be used as the result of a function call.  Just
 398       // map to the same as char.
 399       ResultType = llvm::Type::getInt8Ty(getLLVMContext());
 400       break;
 401
 402     case BuiltinType::Bool:
 403       // Note that we always return bool as i1 for use as a scalar type.
 404       ResultType = llvm::Type::getInt1Ty(getLLVMContext());
 405       break;
 406
 407     case BuiltinType::Char_S:
 408     case BuiltinType::Char_U:
 409     case BuiltinType::SChar:
 410     case BuiltinType::UChar:
 411     case BuiltinType::Short:
 412     case BuiltinType::UShort:
 413     case BuiltinType::Int:
 414     case BuiltinType::UInt:
 415     case BuiltinType::Long:
 416     case BuiltinType::ULong:
 417     case BuiltinType::LongLong:
 418     case BuiltinType::ULongLong:
 419     case BuiltinType::WChar_S:
 420     case BuiltinType::WChar_U:
 421     case BuiltinType::Char8:
 422     case BuiltinType::Char16:
 423     case BuiltinType::Char32:
 424     case BuiltinType::ShortAccum:
 425     case BuiltinType::Accum:
 426     case BuiltinType::LongAccum:
 427     case BuiltinType::UShortAccum:
 428     case BuiltinType::UAccum:
 429     case BuiltinType::ULongAccum:
 430     case BuiltinType::ShortFract:
 431     case BuiltinType::Fract:
 432     case BuiltinType::LongFract:
 433     case BuiltinType::UShortFract:
 434     case BuiltinType::UFract:
 435     case BuiltinType::ULongFract:
 436     case BuiltinType::SatShortAccum:
 437     case BuiltinType::SatAccum:
 438     case BuiltinType::SatLongAccum:
 439     case BuiltinType::SatUShortAccum:
 440     case BuiltinType::SatUAccum:
 441     case BuiltinType::SatULongAccum:
 442     case BuiltinType::SatShortFract:
 443     case BuiltinType::SatFract:
 444     case BuiltinType::SatLongFract:
 445     case BuiltinType::SatUShortFract:
 446     case BuiltinType::SatUFract:
 447     case BuiltinType::SatULongFract:
 448       ResultType = llvm::IntegerType::get(getLLVMContext(),
 449                                  static_cast<unsigned>(Context.getTypeSize(T)));
 450       break;
 451
 452     case BuiltinType::Float16:
 453       ResultType =
 454           getTypeForFormat(getLLVMContext(), Context.getFloatTypeSemantics(T),
 455                            /* UseNativeHalf = */ true);
 456       break;
 457
 458     case BuiltinType::Half:
 459       // Half FP can either be storage-only (lowered to i16) or native.
 460       ResultType = getTypeForFormat(
 461           getLLVMContext(), Context.getFloatTypeSemantics(T),
 462           Context.getLangOpts().NativeHalfType ||
 463               !Context.getTargetInfo().useFP16ConversionIntrinsics());
 464       break;
 465     case BuiltinType::LongDouble:
 466       LongDoubleReferenced = true;
 467       [[fallthrough]];
 468     case BuiltinType::BFloat16:
 469     case BuiltinType::Float:
 470     case BuiltinType::Double:
 471     case BuiltinType::Float128:
 472     case BuiltinType::Ibm128:
 473       ResultType = getTypeForFormat(getLLVMContext(),
 474                                     Context.getFloatTypeSemantics(T),
 475                                     /* UseNativeHalf = */ false);
 476       break;
 477
 478     case BuiltinType::NullPtr:
 479       // Model std::nullptr_t as i8*
 480       ResultType = llvm::PointerType::getUnqual(getLLVMContext());
 481       break;
 482
 483     case BuiltinType::UInt128:
 484     case BuiltinType::Int128:
 485       ResultType = llvm::IntegerType::get(getLLVMContext(), 128);
 486       break;
 487
 488 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
 489     case BuiltinType::Id:
 490 #include "clang/Basic/OpenCLImageTypes.def"
 491 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
 492     case BuiltinType::Id:
 493 #include "clang/Basic/OpenCLExtensionTypes.def"
 494     case BuiltinType::OCLSampler:
 495     case BuiltinType::OCLEvent:
 496     case BuiltinType::OCLClkEvent:
 497     case BuiltinType::OCLQueue:
 498     case BuiltinType::OCLReserveID:
 499       ResultType = CGM.getOpenCLRuntime().convertOpenCLSpecificType(Ty);
 500       break;
 501     case BuiltinType::SveInt8:
 502     case BuiltinType::SveUint8:
 503     case BuiltinType::SveInt8x2:
 504     case BuiltinType::SveUint8x2:
 505     case BuiltinType::SveInt8x3:
 506     case BuiltinType::SveUint8x3:
 507     case BuiltinType::SveInt8x4:
 508     case BuiltinType::SveUint8x4:
 509     case BuiltinType::SveInt16:
 510     case BuiltinType::SveUint16:
 511     case BuiltinType::SveInt16x2:
 512     case BuiltinType::SveUint16x2:
 513     case BuiltinType::SveInt16x3:
 514     case BuiltinType::SveUint16x3:
 515     case BuiltinType::SveInt16x4:
 516     case BuiltinType::SveUint16x4:
 517     case BuiltinType::SveInt32:
 518     case BuiltinType::SveUint32:
 519     case BuiltinType::SveInt32x2:
 520     case BuiltinType::SveUint32x2:
 521     case BuiltinType::SveInt32x3:
 522     case BuiltinType::SveUint32x3:
 523     case BuiltinType::SveInt32x4:
 524     case BuiltinType::SveUint32x4:
 525     case BuiltinType::SveInt64:
 526     case BuiltinType::SveUint64:
 527     case BuiltinType::SveInt64x2:
 528     case BuiltinType::SveUint64x2:
 529     case BuiltinType::SveInt64x3:
 530     case BuiltinType::SveUint64x3:
 531     case BuiltinType::SveInt64x4:
 532     case BuiltinType::SveUint64x4:
 533     case BuiltinType::SveBool:
 534     case BuiltinType::SveBoolx2:
 535     case BuiltinType::SveBoolx4:
 536     case BuiltinType::SveFloat16:
 537     case BuiltinType::SveFloat16x2:
 538     case BuiltinType::SveFloat16x3:
 539     case BuiltinType::SveFloat16x4:
 540     case BuiltinType::SveFloat32:
 541     case BuiltinType::SveFloat32x2:
 542     case BuiltinType::SveFloat32x3:
 543     case BuiltinType::SveFloat32x4:
 544     case BuiltinType::SveFloat64:
 545     case BuiltinType::SveFloat64x2:
 546     case BuiltinType::SveFloat64x3:
 547     case BuiltinType::SveFloat64x4:
 548     case BuiltinType::SveBFloat16:
 549     case BuiltinType::SveBFloat16x2:
 550     case BuiltinType::SveBFloat16x3:
 551     case BuiltinType::SveBFloat16x4: {
 552       ASTContext::BuiltinVectorTypeInfo Info =
 553           Context.getBuiltinVectorTypeInfo(cast<BuiltinType>(Ty));
 554       return llvm::ScalableVectorType::get(ConvertType(Info.ElementType),
 555                                            Info.EC.getKnownMinValue() *
 556                                                Info.NumVectors);
 557     }
 558     case BuiltinType::SveCount:
 559       return llvm::TargetExtType::get(getLLVMContext(), "aarch64.svcount");
 560 #define PPC_VECTOR_TYPE(Name, Id, Size) \
 561     case BuiltinType::Id: \
 562       ResultType = \
 563         llvm::FixedVectorType::get(ConvertType(Context.BoolTy), Size); \
 564       break;
 565 #include "clang/Basic/PPCTypes.def"
 566 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 567 #include "clang/Basic/RISCVVTypes.def"
 568       {
 569         ASTContext::BuiltinVectorTypeInfo Info =
 570             Context.getBuiltinVectorTypeInfo(cast<BuiltinType>(Ty));
 571         // Tuple types are expressed as aggregregate types of the same scalable
 572         // vector type (e.g. vint32m1x2_t is two vint32m1_t, which is {<vscale x
 573         // 2 x i32>, <vscale x 2 x i32>}).
 574         if (Info.NumVectors != 1) {
 575           llvm::Type *EltTy = llvm::ScalableVectorType::get(
 576               ConvertType(Info.ElementType), Info.EC.getKnownMinValue());
 577           llvm::SmallVector<llvm::Type *, 4> EltTys(Info.NumVectors, EltTy);
 578           return llvm::StructType::get(getLLVMContext(), EltTys);
 579         }
 580         return llvm::ScalableVectorType::get(ConvertType(Info.ElementType),
 581                                              Info.EC.getKnownMinValue());
 582       }
 583 #define WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS)                  \
 584   case BuiltinType::Id: {                                                      \
 585     if (BuiltinType::Id == BuiltinType::WasmExternRef)                         \
 586       ResultType = CGM.getTargetCodeGenInfo().getWasmExternrefReferenceType(); \
 587     else                                                                       \
 588       llvm_unreachable("Unexpected wasm reference builtin type!");             \
 589   } break;
 590 #include "clang/Basic/WebAssemblyReferenceTypes.def"
 591 #define AMDGPU_OPAQUE_PTR_TYPE(Name, MangledName, AS, Width, Align, Id,        \
 592                                SingletonId)                                    \
 593   case BuiltinType::Id:                                                        \
 594     return llvm::PointerType::get(getLLVMContext(), AS);
 595 #include "clang/Basic/AMDGPUTypes.def"
 596     case BuiltinType::Dependent:
 597 #define BUILTIN_TYPE(Id, SingletonId)
 598 #define PLACEHOLDER_TYPE(Id, SingletonId) \
 599     case BuiltinType::Id:
 600 #include "clang/AST/BuiltinTypes.def"
 601       llvm_unreachable("Unexpected placeholder builtin type!");
 602     }
 603     break;
 604   }
 605   case Type::Auto:
 606   case Type::DeducedTemplateSpecialization:
 607     llvm_unreachable("Unexpected undeduced type!");
 608   case Type::Complex: {
 609     llvm::Type *EltTy = ConvertType(cast<ComplexType>(Ty)->getElementType());
 610     ResultType = llvm::StructType::get(EltTy, EltTy);
 611     break;
 612   }
 613   case Type::LValueReference:
 614   case Type::RValueReference: {
 615     const ReferenceType *RTy = cast<ReferenceType>(Ty);
 616     QualType ETy = RTy->getPointeeType();
 617     unsigned AS = getTargetAddressSpace(ETy);
 618     ResultType = llvm::PointerType::get(getLLVMContext(), AS);
 619     break;
 620   }
 621   case Type::Pointer: {
 622     const PointerType *PTy = cast<PointerType>(Ty);
 623     QualType ETy = PTy->getPointeeType();
 624     unsigned AS = getTargetAddressSpace(ETy);
 625     ResultType = llvm::PointerType::get(getLLVMContext(), AS);
 626     break;
 627   }
 628
 629   case Type::VariableArray: {
 630     const VariableArrayType *A = cast<VariableArrayType>(Ty);
 631     assert(A->getIndexTypeCVRQualifiers() == 0 &&
 632            "FIXME: We only handle trivial array types so far!");
 633     // VLAs resolve to the innermost element type; this matches
 634     // the return of alloca, and there isn't any obviously better choice.
 635     ResultType = ConvertTypeForMem(A->getElementType());
 636     break;
 637   }
 638   case Type::IncompleteArray: {
 639     const IncompleteArrayType *A = cast<IncompleteArrayType>(Ty);
 640     assert(A->getIndexTypeCVRQualifiers() == 0 &&
 641            "FIXME: We only handle trivial array types so far!");
 642     // int X[] -> [0 x int], unless the element type is not sized.  If it is
 643     // unsized (e.g. an incomplete struct) just use [0 x i8].
 644     ResultType = ConvertTypeForMem(A->getElementType());
 645     if (!ResultType->isSized()) {
 646       SkippedLayout = true;
 647       ResultType = llvm::Type::getInt8Ty(getLLVMContext());
 648     }
 649     ResultType = llvm::ArrayType::get(ResultType, 0);
 650     break;
 651   }
 652   case Type::ArrayParameter:
 653   case Type::ConstantArray: {
 654     const ConstantArrayType *A = cast<ConstantArrayType>(Ty);
 655     llvm::Type *EltTy = ConvertTypeForMem(A->getElementType());
 656
 657     // Lower arrays of undefined struct type to arrays of i8 just to have a
 658     // concrete type.
 659     if (!EltTy->isSized()) {
 660       SkippedLayout = true;
 661       EltTy = llvm::Type::getInt8Ty(getLLVMContext());
 662     }
 663
 664     ResultType = llvm::ArrayType::get(EltTy, A->getZExtSize());
 665     break;
 666   }
 667   case Type::ExtVector:
 668   case Type::Vector: {
 669     const auto *VT = cast<VectorType>(Ty);
 670     // An ext_vector_type of Bool is really a vector of bits.
 671     llvm::Type *IRElemTy = VT->isExtVectorBoolType()
 672                                ? llvm::Type::getInt1Ty(getLLVMContext())
 673                                : ConvertType(VT->getElementType());
 674     ResultType = llvm::FixedVectorType::get(IRElemTy, VT->getNumElements());
 675     break;
 676   }
 677   case Type::ConstantMatrix: {
 678     const ConstantMatrixType *MT = cast<ConstantMatrixType>(Ty);
 679     ResultType =
 680         llvm::FixedVectorType::get(ConvertType(MT->getElementType()),
 681                                    MT->getNumRows() * MT->getNumColumns());
 682     break;
 683   }
 684   case Type::FunctionNoProto:
 685   case Type::FunctionProto:
 686     ResultType = ConvertFunctionTypeInternal(T);
 687     break;
 688   case Type::ObjCObject:
 689     ResultType = ConvertType(cast<ObjCObjectType>(Ty)->getBaseType());
 690     break;
 691
 692   case Type::ObjCInterface: {
 693     // Objective-C interfaces are always opaque (outside of the
 694     // runtime, which can do whatever it likes); we never refine
 695     // these.
 696     llvm::Type *&T = InterfaceTypes[cast<ObjCInterfaceType>(Ty)];
 697     if (!T)
 698       T = llvm::StructType::create(getLLVMContext());
 699     ResultType = T;
 700     break;
 701   }
 702
 703   case Type::ObjCObjectPointer:
 704     ResultType = llvm::PointerType::getUnqual(getLLVMContext());
 705     break;
 706
 707   case Type::Enum: {
 708     const EnumDecl *ED = cast<EnumType>(Ty)->getDecl();
 709     if (ED->isCompleteDefinition() || ED->isFixed())
 710       return ConvertType(ED->getIntegerType());
 711     // Return a placeholder 'i32' type.  This can be changed later when the
 712     // type is defined (see UpdateCompletedType), but is likely to be the
 713     // "right" answer.
 714     ResultType = llvm::Type::getInt32Ty(getLLVMContext());
 715     break;
 716   }
 717
 718   case Type::BlockPointer: {
 719     // Block pointers lower to function type. For function type,
 720     // getTargetAddressSpace() returns default address space for
 721     // function pointer i.e. program address space. Therefore, for block
 722     // pointers, it is important to pass the pointee AST address space when
 723     // calling getTargetAddressSpace(), to ensure that we get the LLVM IR
 724     // address space for data pointers and not function pointers.
 725     const QualType FTy = cast<BlockPointerType>(Ty)->getPointeeType();
 726     unsigned AS = Context.getTargetAddressSpace(FTy.getAddressSpace());
 727     ResultType = llvm::PointerType::get(getLLVMContext(), AS);
 728     break;
 729   }
 730
 731   case Type::MemberPointer: {
 732     auto *MPTy = cast<MemberPointerType>(Ty);
 733     if (!getCXXABI().isMemberPointerConvertible(MPTy)) {
 734       auto *C = MPTy->getClass();
 735       auto Insertion = RecordsWithOpaqueMemberPointers.insert({C, nullptr});
 736       if (Insertion.second)
 737         Insertion.first->second = llvm::StructType::create(getLLVMContext());
 738       ResultType = Insertion.first->second;
 739     } else {
 740       ResultType = getCXXABI().ConvertMemberPointerType(MPTy);
 741     }
 742     break;
 743   }
 744
 745   case Type::Atomic: {
 746     QualType valueType = cast<AtomicType>(Ty)->getValueType();
 747     ResultType = ConvertTypeForMem(valueType);
 748
 749     // Pad out to the inflated size if necessary.
 750     uint64_t valueSize = Context.getTypeSize(valueType);
 751     uint64_t atomicSize = Context.getTypeSize(Ty);
 752     if (valueSize != atomicSize) {
 753       assert(valueSize < atomicSize);
 754       llvm::Type *elts[] = {
 755         ResultType,
 756         llvm::ArrayType::get(CGM.Int8Ty, (atomicSize - valueSize) / 8)
 757       };
 758       ResultType =
 759           llvm::StructType::get(getLLVMContext(), llvm::ArrayRef(elts));
 760     }
 761     break;
 762   }
 763   case Type::Pipe: {
 764     ResultType = CGM.getOpenCLRuntime().getPipeType(cast<PipeType>(Ty));
 765     break;
 766   }
 767   case Type::BitInt: {
 768     const auto &EIT = cast<BitIntType>(Ty);
 769     ResultType = llvm::Type::getIntNTy(getLLVMContext(), EIT->getNumBits());
 770     break;
 771   }
 772   }
 773
 774   assert(ResultType && "Didn't convert a type?");
 775   assert((!CachedType || CachedType == ResultType) &&
 776          "Cached type doesn't match computed type");
 777
 778   TypeCache[Ty] = ResultType;
 779   return ResultType;
 780 }
 781
 782 bool CodeGenModule::isPaddedAtomicType(QualType type) {
 783   return isPaddedAtomicType(type->castAs<AtomicType>());
 784 }
 785
 786 bool CodeGenModule::isPaddedAtomicType(const AtomicType *type) {
 787   return Context.getTypeSize(type) != Context.getTypeSize(type->getValueType());
 788 }
 789
 790 /// ConvertRecordDeclType - Lay out a tagged decl type like struct or union.
 791 llvm::StructType *CodeGenTypes::ConvertRecordDeclType(const RecordDecl *RD) {
 792   // TagDecl's are not necessarily unique, instead use the (clang)
 793   // type connected to the decl.
 794   const Type *Key = Context.getTagDeclType(RD).getTypePtr();
 795
 796   llvm::StructType *&Entry = RecordDeclTypes[Key];
 797
 798   // If we don't have a StructType at all yet, create the forward declaration.
 799   if (!Entry) {
 800     Entry = llvm::StructType::create(getLLVMContext());
 801     addRecordTypeName(RD, Entry, "");
 802   }
 803   llvm::StructType *Ty = Entry;
 804
 805   // If this is still a forward declaration, or the LLVM type is already
 806   // complete, there's nothing more to do.
 807   RD = RD->getDefinition();
 808   if (!RD || !RD->isCompleteDefinition() || !Ty->isOpaque())
 809     return Ty;
 810
 811   // Force conversion of non-virtual base classes recursively.
 812   if (const CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) {
 813     for (const auto &I : CRD->bases()) {
 814       if (I.isVirtual()) continue;
 815       ConvertRecordDeclType(I.getType()->castAs<RecordType>()->getDecl());
 816     }
 817   }
 818
 819   // Layout fields.
 820   std::unique_ptr<CGRecordLayout> Layout = ComputeRecordLayout(RD, Ty);
 821   CGRecordLayouts[Key] = std::move(Layout);
 822
 823   // If this struct blocked a FunctionType conversion, then recompute whatever
 824   // was derived from that.
 825   // FIXME: This is hugely overconservative.
 826   if (SkippedLayout)
 827     TypeCache.clear();
 828
 829   return Ty;
 830 }
 831
 832 /// getCGRecordLayout - Return record layout info for the given record decl.
 833 const CGRecordLayout &
 834 CodeGenTypes::getCGRecordLayout(const RecordDecl *RD) {
 835   const Type *Key = Context.getTagDeclType(RD).getTypePtr();
 836
 837   auto I = CGRecordLayouts.find(Key);
 838   if (I != CGRecordLayouts.end())
 839     return *I->second;
 840   // Compute the type information.
 841   ConvertRecordDeclType(RD);
 842
 843   // Now try again.
 844   I = CGRecordLayouts.find(Key);
 845
 846   assert(I != CGRecordLayouts.end() &&
 847          "Unable to find record layout information for type");
 848   return *I->second;
 849 }
 850
 851 bool CodeGenTypes::isPointerZeroInitializable(QualType T) {
 852   assert((T->isAnyPointerType() || T->isBlockPointerType()) && "Invalid type");
 853   return isZeroInitializable(T);
 854 }
 855
 856 bool CodeGenTypes::isZeroInitializable(QualType T) {
 857   if (T->getAs<PointerType>())
 858     return Context.getTargetNullPointerValue(T) == 0;
 859
 860   if (const auto *AT = Context.getAsArrayType(T)) {
 861     if (isa<IncompleteArrayType>(AT))
 862       return true;
 863     if (const auto *CAT = dyn_cast<ConstantArrayType>(AT))
 864       if (Context.getConstantArrayElementCount(CAT) == 0)
 865         return true;
 866     T = Context.getBaseElementType(T);
 867   }
 868
 869   // Records are non-zero-initializable if they contain any
 870   // non-zero-initializable subobjects.
 871   if (const RecordType *RT = T->getAs<RecordType>()) {
 872     const RecordDecl *RD = RT->getDecl();
 873     return isZeroInitializable(RD);
 874   }
 875
 876   // We have to ask the ABI about member pointers.
 877   if (const MemberPointerType *MPT = T->getAs<MemberPointerType>())
 878     return getCXXABI().isZeroInitializable(MPT);
 879
 880   // Everything else is okay.
 881   return true;
 882 }
 883
 884 bool CodeGenTypes::isZeroInitializable(const RecordDecl *RD) {
 885   return getCGRecordLayout(RD).isZeroInitializable();
 886 }
 887
 888 unsigned CodeGenTypes::getTargetAddressSpace(QualType T) const {
 889   // Return the address space for the type. If the type is a
 890   // function type without an address space qualifier, the
 891   // program address space is used. Otherwise, the target picks
 892   // the best address space based on the type information
 893   return T->isFunctionType() && !T.hasAddressSpace()
 894              ? getDataLayout().getProgramAddressSpace()
 895              : getContext().getTargetAddressSpace(T.getAddressSpace());
 896 }