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