/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGObjCMac.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGObjCMac.cpp
Warning:	line 2644, column 26 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CGObjCMac.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGObjCMac.cpp

/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGObjCMac.cpp

→

1//===------- CGObjCMac.cpp - Interface to Apple Objective-C Runtime -------===//
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 provides Objective-C code generation targeting the Apple runtime.
10//
11//===----------------------------------------------------------------------===//

13#include "CGBlocks.h"
14#include "CGCleanup.h"
15#include "CGObjCRuntime.h"
16#include "CGRecordLayout.h"
17#include "CodeGenFunction.h"
18#include "CodeGenModule.h"
19#include "clang/AST/ASTContext.h"
20#include "clang/AST/Attr.h"
21#include "clang/AST/Decl.h"
22#include "clang/AST/DeclObjC.h"
23#include "clang/AST/Mangle.h"
24#include "clang/AST/RecordLayout.h"
25#include "clang/AST/StmtObjC.h"
26#include "clang/Basic/CodeGenOptions.h"
27#include "clang/Basic/LangOptions.h"
28#include "clang/CodeGen/CGFunctionInfo.h"
29#include "clang/CodeGen/ConstantInitBuilder.h"
30#include "llvm/ADT/CachedHashString.h"
31#include "llvm/ADT/DenseSet.h"
32#include "llvm/ADT/SetVector.h"
33#include "llvm/ADT/SmallPtrSet.h"
34#include "llvm/ADT/SmallString.h"
35#include "llvm/ADT/UniqueVector.h"
36#include "llvm/IR/DataLayout.h"
37#include "llvm/IR/InlineAsm.h"
38#include "llvm/IR/IntrinsicInst.h"
39#include "llvm/IR/LLVMContext.h"
40#include "llvm/IR/Module.h"
41#include "llvm/Support/ScopedPrinter.h"
42#include "llvm/Support/raw_ostream.h"
43#include <cstdio>

45using namespace clang;
46using namespace CodeGen;

48namespace {

50// FIXME: We should find a nicer way to make the labels for metadata, string
51// concatenation is lame.

53class ObjCCommonTypesHelper {
54protected:
llvm::LLVMContext &VMContext;

57private:
// The types of these functions don't really matter because we
// should always bitcast before calling them.

/// id objc_msgSend (id, SEL, ...)
///
/// The default messenger, used for sends whose ABI is unchanged from
/// the all-integer/pointer case.
llvm::FunctionCallee getMessageSendFn() const {
  // Add the non-lazy-bind attribute, since objc_msgSend is likely to
  // be called a lot.
  llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
  return CGM.CreateRuntimeFunction(
      llvm::FunctionType::get(ObjectPtrTy, params, true), "objc_msgSend",
      llvm::AttributeList::get(CGM.getLLVMContext(),
                               llvm::AttributeList::FunctionIndex,
                               llvm::Attribute::NonLazyBind));
}

/// void objc_msgSend_stret (id, SEL, ...)
///
/// The messenger used when the return value is an aggregate returned
/// by indirect reference in the first argument, and therefore the
/// self and selector parameters are shifted over by one.
llvm::FunctionCallee getMessageSendStretFn() const {
  llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy,
                                                           params, true),
                                   "objc_msgSend_stret");
}

/// [double | long double] objc_msgSend_fpret(id self, SEL op, ...)
///
/// The messenger used when the return value is returned on the x87
/// floating-point stack; without a special entrypoint, the nil case
/// would be unbalanced.
llvm::FunctionCallee getMessageSendFpretFn() const {
  llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.DoubleTy,
                                                           params, true),
                                   "objc_msgSend_fpret");
}

/// _Complex long double objc_msgSend_fp2ret(id self, SEL op, ...)
///
/// The messenger used when the return value is returned in two values on the
/// x87 floating point stack; without a special entrypoint, the nil case
/// would be unbalanced. Only used on 64-bit X86.
llvm::FunctionCallee getMessageSendFp2retFn() const {
  llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
  llvm::Type *longDoubleType = llvm::Type::getX86_FP80Ty(VMContext);
  llvm::Type *resultType =
      llvm::StructType::get(longDoubleType, longDoubleType);

  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(resultType,
                                                           params, true),
                                   "objc_msgSend_fp2ret");
}

/// id objc_msgSendSuper(struct objc_super *super, SEL op, ...)
///
/// The messenger used for super calls, which have different dispatch
/// semantics.  The class passed is the superclass of the current
/// class.
llvm::FunctionCallee getMessageSendSuperFn() const {
  llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
                                                           params, true),
                                   "objc_msgSendSuper");
}

/// id objc_msgSendSuper2(struct objc_super *super, SEL op, ...)
///
/// A slightly different messenger used for super calls.  The class
/// passed is the current class.
llvm::FunctionCallee getMessageSendSuperFn2() const {
  llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
                                                           params, true),
                                   "objc_msgSendSuper2");
}

/// void objc_msgSendSuper_stret(void *stretAddr, struct objc_super *super,
///                              SEL op, ...)
///
/// The messenger used for super calls which return an aggregate indirectly.
llvm::FunctionCallee getMessageSendSuperStretFn() const {
  llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy };
  return CGM.CreateRuntimeFunction(
    llvm::FunctionType::get(CGM.VoidTy, params, true),
    "objc_msgSendSuper_stret");
}

/// void objc_msgSendSuper2_stret(void * stretAddr, struct objc_super *super,
///                               SEL op, ...)
///
/// objc_msgSendSuper_stret with the super2 semantics.
llvm::FunctionCallee getMessageSendSuperStretFn2() const {
  llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy };
  return CGM.CreateRuntimeFunction(
    llvm::FunctionType::get(CGM.VoidTy, params, true),
    "objc_msgSendSuper2_stret");
}

llvm::FunctionCallee getMessageSendSuperFpretFn() const {
  // There is no objc_msgSendSuper_fpret? How can that work?
  return getMessageSendSuperFn();
}

llvm::FunctionCallee getMessageSendSuperFpretFn2() const {
  // There is no objc_msgSendSuper_fpret? How can that work?
  return getMessageSendSuperFn2();
}

171protected:
CodeGen::CodeGenModule &CGM;

174public:
llvm::IntegerType *ShortTy, *IntTy, *LongTy;
llvm::PointerType *Int8PtrTy, *Int8PtrPtrTy;
llvm::Type *IvarOffsetVarTy;

/// ObjectPtrTy - LLVM type for object handles (typeof(id))
llvm::PointerType *ObjectPtrTy;

/// PtrObjectPtrTy - LLVM type for id *
llvm::PointerType *PtrObjectPtrTy;

/// SelectorPtrTy - LLVM type for selector handles (typeof(SEL))
llvm::PointerType *SelectorPtrTy;

188private:
/// ProtocolPtrTy - LLVM type for external protocol handles
/// (typeof(Protocol))
llvm::Type *ExternalProtocolPtrTy;

193public:
llvm::Type *getExternalProtocolPtrTy() {
  if (!ExternalProtocolPtrTy) {
    // FIXME: It would be nice to unify this with the opaque type, so that the
    // IR comes out a bit cleaner.
    CodeGen::CodeGenTypes &Types = CGM.getTypes();
    ASTContext &Ctx = CGM.getContext();
    llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType());
    ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T);
  }

  return ExternalProtocolPtrTy;
}

// SuperCTy - clang type for struct objc_super.
QualType SuperCTy;
// SuperPtrCTy - clang type for struct objc_super *.
QualType SuperPtrCTy;

/// SuperTy - LLVM type for struct objc_super.
llvm::StructType *SuperTy;
/// SuperPtrTy - LLVM type for struct objc_super *.
llvm::PointerType *SuperPtrTy;

/// PropertyTy - LLVM type for struct objc_property (struct _prop_t
/// in GCC parlance).
llvm::StructType *PropertyTy;

/// PropertyListTy - LLVM type for struct objc_property_list
/// (_prop_list_t in GCC parlance).
llvm::StructType *PropertyListTy;
/// PropertyListPtrTy - LLVM type for struct objc_property_list*.
llvm::PointerType *PropertyListPtrTy;

// MethodTy - LLVM type for struct objc_method.
llvm::StructType *MethodTy;

/// CacheTy - LLVM type for struct objc_cache.
llvm::Type *CacheTy;
/// CachePtrTy - LLVM type for struct objc_cache *.
llvm::PointerType *CachePtrTy;

llvm::FunctionCallee getGetPropertyFn() {
  CodeGen::CodeGenTypes &Types = CGM.getTypes();
  ASTContext &Ctx = CGM.getContext();
  // id objc_getProperty (id, SEL, ptrdiff_t, bool)
  CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
  CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
  CanQualType Params[] = {
      IdType, SelType,
      Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(), Ctx.BoolTy};
  llvm::FunctionType *FTy =
      Types.GetFunctionType(
        Types.arrangeBuiltinFunctionDeclaration(IdType, Params));
  return CGM.CreateRuntimeFunction(FTy, "objc_getProperty");
}

llvm::FunctionCallee getSetPropertyFn() {
  CodeGen::CodeGenTypes &Types = CGM.getTypes();
  ASTContext &Ctx = CGM.getContext();
  // void objc_setProperty (id, SEL, ptrdiff_t, id, bool, bool)
  CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
  CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
  CanQualType Params[] = {
      IdType,
      SelType,
      Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(),
      IdType,
      Ctx.BoolTy,
      Ctx.BoolTy};
  llvm::FunctionType *FTy =
      Types.GetFunctionType(
        Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
  return CGM.CreateRuntimeFunction(FTy, "objc_setProperty");
}

llvm::FunctionCallee getOptimizedSetPropertyFn(bool atomic, bool copy) {
  CodeGen::CodeGenTypes &Types = CGM.getTypes();
  ASTContext &Ctx = CGM.getContext();
  // void objc_setProperty_atomic(id self, SEL _cmd,
  //                              id newValue, ptrdiff_t offset);
  // void objc_setProperty_nonatomic(id self, SEL _cmd,
  //                                 id newValue, ptrdiff_t offset);
  // void objc_setProperty_atomic_copy(id self, SEL _cmd,
  //                                   id newValue, ptrdiff_t offset);
  // void objc_setProperty_nonatomic_copy(id self, SEL _cmd,
  //                                      id newValue, ptrdiff_t offset);

  SmallVector<CanQualType,4> Params;
  CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
  CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
  Params.push_back(IdType);
  Params.push_back(SelType);
  Params.push_back(IdType);
  Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified());
  llvm::FunctionType *FTy =
      Types.GetFunctionType(
        Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
  const char *name;
  if (atomic && copy)
    name = "objc_setProperty_atomic_copy";
  else if (atomic && !copy)
    name = "objc_setProperty_atomic";
  else if (!atomic && copy)
    name = "objc_setProperty_nonatomic_copy";
  else
    name = "objc_setProperty_nonatomic";

  return CGM.CreateRuntimeFunction(FTy, name);
}

llvm::FunctionCallee getCopyStructFn() {
  CodeGen::CodeGenTypes &Types = CGM.getTypes();
  ASTContext &Ctx = CGM.getContext();
  // void objc_copyStruct (void *, const void *, size_t, bool, bool)
  SmallVector<CanQualType,5> Params;
  Params.push_back(Ctx.VoidPtrTy);
  Params.push_back(Ctx.VoidPtrTy);
  Params.push_back(Ctx.getSizeType());
  Params.push_back(Ctx.BoolTy);
  Params.push_back(Ctx.BoolTy);
  llvm::FunctionType *FTy =
      Types.GetFunctionType(
        Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
  return CGM.CreateRuntimeFunction(FTy, "objc_copyStruct");
}

/// This routine declares and returns address of:
/// void objc_copyCppObjectAtomic(
///         void *dest, const void *src,
///         void (*copyHelper) (void *dest, const void *source));
llvm::FunctionCallee getCppAtomicObjectFunction() {
  CodeGen::CodeGenTypes &Types = CGM.getTypes();
  ASTContext &Ctx = CGM.getContext();
  /// void objc_copyCppObjectAtomic(void *dest, const void *src, void *helper);
  SmallVector<CanQualType,3> Params;
  Params.push_back(Ctx.VoidPtrTy);
  Params.push_back(Ctx.VoidPtrTy);
  Params.push_back(Ctx.VoidPtrTy);
  llvm::FunctionType *FTy =
      Types.GetFunctionType(
        Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
  return CGM.CreateRuntimeFunction(FTy, "objc_copyCppObjectAtomic");
}

llvm::FunctionCallee getEnumerationMutationFn() {
  CodeGen::CodeGenTypes &Types = CGM.getTypes();
  ASTContext &Ctx = CGM.getContext();
  // void objc_enumerationMutation (id)
  SmallVector<CanQualType,1> Params;
  Params.push_back(Ctx.getCanonicalParamType(Ctx.getObjCIdType()));
  llvm::FunctionType *FTy =
      Types.GetFunctionType(
        Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
  return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation");
}

llvm::FunctionCallee getLookUpClassFn() {
  CodeGen::CodeGenTypes &Types = CGM.getTypes();
  ASTContext &Ctx = CGM.getContext();
  // Class objc_lookUpClass (const char *)
  SmallVector<CanQualType,1> Params;
  Params.push_back(
    Ctx.getCanonicalType(Ctx.getPointerType(Ctx.CharTy.withConst())));
  llvm::FunctionType *FTy =
      Types.GetFunctionType(Types.arrangeBuiltinFunctionDeclaration(
                              Ctx.getCanonicalType(Ctx.getObjCClassType()),
                              Params));
  return CGM.CreateRuntimeFunction(FTy, "objc_lookUpClass");
}

/// GcReadWeakFn -- LLVM objc_read_weak (id *src) function.
llvm::FunctionCallee getGcReadWeakFn() {
  // id objc_read_weak (id *)
  llvm::Type *args[] = { ObjectPtrTy->getPointerTo() };
  llvm::FunctionType *FTy =
    llvm::FunctionType::get(ObjectPtrTy, args, false);
  return CGM.CreateRuntimeFunction(FTy, "objc_read_weak");
}

/// GcAssignWeakFn -- LLVM objc_assign_weak function.
llvm::FunctionCallee getGcAssignWeakFn() {
  // id objc_assign_weak (id, id *)
  llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
  llvm::FunctionType *FTy =
    llvm::FunctionType::get(ObjectPtrTy, args, false);
  return CGM.CreateRuntimeFunction(FTy, "objc_assign_weak");
}

/// GcAssignGlobalFn -- LLVM objc_assign_global function.
llvm::FunctionCallee getGcAssignGlobalFn() {
  // id objc_assign_global(id, id *)
  llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
  llvm::FunctionType *FTy =
    llvm::FunctionType::get(ObjectPtrTy, args, false);
  return CGM.CreateRuntimeFunction(FTy, "objc_assign_global");
}

/// GcAssignThreadLocalFn -- LLVM objc_assign_threadlocal function.
llvm::FunctionCallee getGcAssignThreadLocalFn() {
  // id objc_assign_threadlocal(id src, id * dest)
  llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
  llvm::FunctionType *FTy =
    llvm::FunctionType::get(ObjectPtrTy, args, false);
  return CGM.CreateRuntimeFunction(FTy, "objc_assign_threadlocal");
}

/// GcAssignIvarFn -- LLVM objc_assign_ivar function.
llvm::FunctionCallee getGcAssignIvarFn() {
  // id objc_assign_ivar(id, id *, ptrdiff_t)
  llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo(),
                         CGM.PtrDiffTy };
  llvm::FunctionType *FTy =
    llvm::FunctionType::get(ObjectPtrTy, args, false);
  return CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar");
}

/// GcMemmoveCollectableFn -- LLVM objc_memmove_collectable function.
llvm::FunctionCallee GcMemmoveCollectableFn() {
  // void *objc_memmove_collectable(void *dst, const void *src, size_t size)
  llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, LongTy };
  llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, args, false);
  return CGM.CreateRuntimeFunction(FTy, "objc_memmove_collectable");
}

/// GcAssignStrongCastFn -- LLVM objc_assign_strongCast function.
llvm::FunctionCallee getGcAssignStrongCastFn() {
  // id objc_assign_strongCast(id, id *)
  llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
  llvm::FunctionType *FTy =
    llvm::FunctionType::get(ObjectPtrTy, args, false);
  return CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast");
}

/// ExceptionThrowFn - LLVM objc_exception_throw function.
llvm::FunctionCallee getExceptionThrowFn() {
  // void objc_exception_throw(id)
  llvm::Type *args[] = { ObjectPtrTy };
  llvm::FunctionType *FTy =
    llvm::FunctionType::get(CGM.VoidTy, args, false);
  return CGM.CreateRuntimeFunction(FTy, "objc_exception_throw");
}

/// ExceptionRethrowFn - LLVM objc_exception_rethrow function.
llvm::FunctionCallee getExceptionRethrowFn() {
  // void objc_exception_rethrow(void)
  llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, false);
  return CGM.CreateRuntimeFunction(FTy, "objc_exception_rethrow");
}

/// SyncEnterFn - LLVM object_sync_enter function.
llvm::FunctionCallee getSyncEnterFn() {
  // int objc_sync_enter (id)
  llvm::Type *args[] = { ObjectPtrTy };
  llvm::FunctionType *FTy =
    llvm::FunctionType::get(CGM.IntTy, args, false);
  return CGM.CreateRuntimeFunction(FTy, "objc_sync_enter");
}

/// SyncExitFn - LLVM object_sync_exit function.
llvm::FunctionCallee getSyncExitFn() {
  // int objc_sync_exit (id)
  llvm::Type *args[] = { ObjectPtrTy };
  llvm::FunctionType *FTy =
    llvm::FunctionType::get(CGM.IntTy, args, false);
  return CGM.CreateRuntimeFunction(FTy, "objc_sync_exit");
}

llvm::FunctionCallee getSendFn(bool IsSuper) const {
  return IsSuper ? getMessageSendSuperFn() : getMessageSendFn();
}

llvm::FunctionCallee getSendFn2(bool IsSuper) const {
  return IsSuper ? getMessageSendSuperFn2() : getMessageSendFn();
}

llvm::FunctionCallee getSendStretFn(bool IsSuper) const {
  return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn();
}

llvm::FunctionCallee getSendStretFn2(bool IsSuper) const {
  return IsSuper ? getMessageSendSuperStretFn2() : getMessageSendStretFn();
}

llvm::FunctionCallee getSendFpretFn(bool IsSuper) const {
  return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn();
}

llvm::FunctionCallee getSendFpretFn2(bool IsSuper) const {
  return IsSuper ? getMessageSendSuperFpretFn2() : getMessageSendFpretFn();
}

llvm::FunctionCallee getSendFp2retFn(bool IsSuper) const {
  return IsSuper ? getMessageSendSuperFn() : getMessageSendFp2retFn();
}

llvm::FunctionCallee getSendFp2RetFn2(bool IsSuper) const {
  return IsSuper ? getMessageSendSuperFn2() : getMessageSendFp2retFn();
}

ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm);
494};

496/// ObjCTypesHelper - Helper class that encapsulates lazy
497/// construction of varies types used during ObjC generation.
498class ObjCTypesHelper : public ObjCCommonTypesHelper {
499public:
/// SymtabTy - LLVM type for struct objc_symtab.
llvm::StructType *SymtabTy;
/// SymtabPtrTy - LLVM type for struct objc_symtab *.
llvm::PointerType *SymtabPtrTy;
/// ModuleTy - LLVM type for struct objc_module.
llvm::StructType *ModuleTy;

/// ProtocolTy - LLVM type for struct objc_protocol.
llvm::StructType *ProtocolTy;
/// ProtocolPtrTy - LLVM type for struct objc_protocol *.
llvm::PointerType *ProtocolPtrTy;
/// ProtocolExtensionTy - LLVM type for struct
/// objc_protocol_extension.
llvm::StructType *ProtocolExtensionTy;
/// ProtocolExtensionTy - LLVM type for struct
/// objc_protocol_extension *.
llvm::PointerType *ProtocolExtensionPtrTy;
/// MethodDescriptionTy - LLVM type for struct
/// objc_method_description.
llvm::StructType *MethodDescriptionTy;
/// MethodDescriptionListTy - LLVM type for struct
/// objc_method_description_list.
llvm::StructType *MethodDescriptionListTy;
/// MethodDescriptionListPtrTy - LLVM type for struct
/// objc_method_description_list *.
llvm::PointerType *MethodDescriptionListPtrTy;
/// ProtocolListTy - LLVM type for struct objc_property_list.
llvm::StructType *ProtocolListTy;
/// ProtocolListPtrTy - LLVM type for struct objc_property_list*.
llvm::PointerType *ProtocolListPtrTy;
/// CategoryTy - LLVM type for struct objc_category.
llvm::StructType *CategoryTy;
/// ClassTy - LLVM type for struct objc_class.
llvm::StructType *ClassTy;
/// ClassPtrTy - LLVM type for struct objc_class *.
llvm::PointerType *ClassPtrTy;
/// ClassExtensionTy - LLVM type for struct objc_class_ext.
llvm::StructType *ClassExtensionTy;
/// ClassExtensionPtrTy - LLVM type for struct objc_class_ext *.
llvm::PointerType *ClassExtensionPtrTy;
// IvarTy - LLVM type for struct objc_ivar.
llvm::StructType *IvarTy;
/// IvarListTy - LLVM type for struct objc_ivar_list.
llvm::StructType *IvarListTy;
/// IvarListPtrTy - LLVM type for struct objc_ivar_list *.
llvm::PointerType *IvarListPtrTy;
/// MethodListTy - LLVM type for struct objc_method_list.
llvm::StructType *MethodListTy;
/// MethodListPtrTy - LLVM type for struct objc_method_list *.
llvm::PointerType *MethodListPtrTy;

/// ExceptionDataTy - LLVM type for struct _objc_exception_data.
llvm::StructType *ExceptionDataTy;

/// ExceptionTryEnterFn - LLVM objc_exception_try_enter function.
llvm::FunctionCallee getExceptionTryEnterFn() {
  llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
  return CGM.CreateRuntimeFunction(
    llvm::FunctionType::get(CGM.VoidTy, params, false),
    "objc_exception_try_enter");
}

/// ExceptionTryExitFn - LLVM objc_exception_try_exit function.
llvm::FunctionCallee getExceptionTryExitFn() {
  llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
  return CGM.CreateRuntimeFunction(
    llvm::FunctionType::get(CGM.VoidTy, params, false),
    "objc_exception_try_exit");
}

/// ExceptionExtractFn - LLVM objc_exception_extract function.
llvm::FunctionCallee getExceptionExtractFn() {
  llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
                                                           params, false),
                                   "objc_exception_extract");
}

/// ExceptionMatchFn - LLVM objc_exception_match function.
llvm::FunctionCallee getExceptionMatchFn() {
  llvm::Type *params[] = { ClassPtrTy, ObjectPtrTy };
  return CGM.CreateRuntimeFunction(
    llvm::FunctionType::get(CGM.Int32Ty, params, false),
    "objc_exception_match");
}

/// SetJmpFn - LLVM _setjmp function.
llvm::FunctionCallee getSetJmpFn() {
  // This is specifically the prototype for x86.
  llvm::Type *params[] = { CGM.Int32Ty->getPointerTo() };
  return CGM.CreateRuntimeFunction(
      llvm::FunctionType::get(CGM.Int32Ty, params, false), "_setjmp",
      llvm::AttributeList::get(CGM.getLLVMContext(),
                               llvm::AttributeList::FunctionIndex,
                               llvm::Attribute::NonLazyBind));
}

597public:
ObjCTypesHelper(CodeGen::CodeGenModule &cgm);
599};

601/// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's
602/// modern abi
603class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper {
604public:
// MethodListnfABITy - LLVM for struct _method_list_t
llvm::StructType *MethodListnfABITy;

// MethodListnfABIPtrTy - LLVM for struct _method_list_t*
llvm::PointerType *MethodListnfABIPtrTy;

// ProtocolnfABITy = LLVM for struct _protocol_t
llvm::StructType *ProtocolnfABITy;

// ProtocolnfABIPtrTy = LLVM for struct _protocol_t*
llvm::PointerType *ProtocolnfABIPtrTy;

// ProtocolListnfABITy - LLVM for struct _objc_protocol_list
llvm::StructType *ProtocolListnfABITy;

// ProtocolListnfABIPtrTy - LLVM for struct _objc_protocol_list*
llvm::PointerType *ProtocolListnfABIPtrTy;

// ClassnfABITy - LLVM for struct _class_t
llvm::StructType *ClassnfABITy;

// ClassnfABIPtrTy - LLVM for struct _class_t*
llvm::PointerType *ClassnfABIPtrTy;

// IvarnfABITy - LLVM for struct _ivar_t
llvm::StructType *IvarnfABITy;

// IvarListnfABITy - LLVM for struct _ivar_list_t
llvm::StructType *IvarListnfABITy;

// IvarListnfABIPtrTy = LLVM for struct _ivar_list_t*
llvm::PointerType *IvarListnfABIPtrTy;

// ClassRonfABITy - LLVM for struct _class_ro_t
llvm::StructType *ClassRonfABITy;

// ImpnfABITy - LLVM for id (*)(id, SEL, ...)
llvm::PointerType *ImpnfABITy;

// CategorynfABITy - LLVM for struct _category_t
llvm::StructType *CategorynfABITy;

// New types for nonfragile abi messaging.

// MessageRefTy - LLVM for:
// struct _message_ref_t {
//   IMP messenger;
//   SEL name;
// };
llvm::StructType *MessageRefTy;
// MessageRefCTy - clang type for struct _message_ref_t
QualType MessageRefCTy;

// MessageRefPtrTy - LLVM for struct _message_ref_t*
llvm::Type *MessageRefPtrTy;
// MessageRefCPtrTy - clang type for struct _message_ref_t*
QualType MessageRefCPtrTy;

// SuperMessageRefTy - LLVM for:
// struct _super_message_ref_t {
//   SUPER_IMP messenger;
//   SEL name;
// };
llvm::StructType *SuperMessageRefTy;

// SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
llvm::PointerType *SuperMessageRefPtrTy;

llvm::FunctionCallee getMessageSendFixupFn() {
  // id objc_msgSend_fixup(id, struct message_ref_t*, ...)
  llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
                                                           params, true),
                                   "objc_msgSend_fixup");
}

llvm::FunctionCallee getMessageSendFpretFixupFn() {
  // id objc_msgSend_fpret_fixup(id, struct message_ref_t*, ...)
  llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
                                                           params, true),
                                   "objc_msgSend_fpret_fixup");
}

llvm::FunctionCallee getMessageSendStretFixupFn() {
  // id objc_msgSend_stret_fixup(id, struct message_ref_t*, ...)
  llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
                                                           params, true),
                                   "objc_msgSend_stret_fixup");
}

llvm::FunctionCallee getMessageSendSuper2FixupFn() {
  // id objc_msgSendSuper2_fixup (struct objc_super *,
  //                              struct _super_message_ref_t*, ...)
  llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
  return  CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
                                                            params, true),
                                    "objc_msgSendSuper2_fixup");
}

llvm::FunctionCallee getMessageSendSuper2StretFixupFn() {
  // id objc_msgSendSuper2_stret_fixup(struct objc_super *,
  //                                   struct _super_message_ref_t*, ...)
  llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
  return  CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
                                                            params, true),
                                    "objc_msgSendSuper2_stret_fixup");
}

llvm::FunctionCallee getObjCEndCatchFn() {
  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false),
                                   "objc_end_catch");
}

llvm::FunctionCallee getObjCBeginCatchFn() {
  llvm::Type *params[] = { Int8PtrTy };
  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy,
                                                           params, false),
                                   "objc_begin_catch");
}

/// Class objc_loadClassref (void *)
///
/// Loads from a classref. For Objective-C stub classes, this invokes the
/// initialization callback stored inside the stub. For all other classes
/// this simply dereferences the pointer.
llvm::FunctionCallee getLoadClassrefFn() const {
  // Add the non-lazy-bind attribute, since objc_loadClassref is likely to
  // be called a lot.
  //
  // Also it is safe to make it readnone, since we never load or store the
  // classref except by calling this function.
  llvm::Type *params[] = { Int8PtrPtrTy };
  llvm::FunctionCallee F = CGM.CreateRuntimeFunction(
      llvm::FunctionType::get(ClassnfABIPtrTy, params, false),
      "objc_loadClassref",
      llvm::AttributeList::get(CGM.getLLVMContext(),
                               llvm::AttributeList::FunctionIndex,
                               {llvm::Attribute::NonLazyBind,
                                llvm::Attribute::ReadNone,
                                llvm::Attribute::NoUnwind}));
  if (!CGM.getTriple().isOSBinFormatCOFF())
    cast<llvm::Function>(F.getCallee())->setLinkage(
      llvm::Function::ExternalWeakLinkage);

  return F;
}

llvm::StructType *EHTypeTy;
llvm::Type *EHTypePtrTy;

ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm);
758};

760enum class ObjCLabelType {
ClassName,
MethodVarName,
MethodVarType,
PropertyName,
765};

767class CGObjCCommonMac : public CodeGen::CGObjCRuntime {
768public:
class SKIP_SCAN {
public:
  unsigned skip;
  unsigned scan;
  SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0)
    : skip(_skip), scan(_scan) {}
};

/// opcode for captured block variables layout 'instructions'.
/// In the following descriptions, 'I' is the value of the immediate field.
/// (field following the opcode).
///
enum BLOCK_LAYOUT_OPCODE {
  /// An operator which affects how the following layout should be
  /// interpreted.
  ///   I == 0: Halt interpretation and treat everything else as
  ///           a non-pointer.  Note that this instruction is equal
  ///           to '\0'.
  ///   I != 0: Currently unused.
  BLOCK_LAYOUT_OPERATOR            = 0,

  /// The next I+1 bytes do not contain a value of object pointer type.
  /// Note that this can leave the stream unaligned, meaning that
  /// subsequent word-size instructions do not begin at a multiple of
  /// the pointer size.
  BLOCK_LAYOUT_NON_OBJECT_BYTES    = 1,

  /// The next I+1 words do not contain a value of object pointer type.
  /// This is simply an optimized version of BLOCK_LAYOUT_BYTES for
  /// when the required skip quantity is a multiple of the pointer size.
  BLOCK_LAYOUT_NON_OBJECT_WORDS    = 2,

  /// The next I+1 words are __strong pointers to Objective-C
  /// objects or blocks.
  BLOCK_LAYOUT_STRONG              = 3,

  /// The next I+1 words are pointers to __block variables.
  BLOCK_LAYOUT_BYREF               = 4,

  /// The next I+1 words are __weak pointers to Objective-C
  /// objects or blocks.
  BLOCK_LAYOUT_WEAK                = 5,

  /// The next I+1 words are __unsafe_unretained pointers to
  /// Objective-C objects or blocks.
  BLOCK_LAYOUT_UNRETAINED          = 6

  /// The next I+1 words are block or object pointers with some
  /// as-yet-unspecified ownership semantics.  If we add more
  /// flavors of ownership semantics, values will be taken from
  /// this range.
  ///
  /// This is included so that older tools can at least continue
  /// processing the layout past such things.
  //BLOCK_LAYOUT_OWNERSHIP_UNKNOWN = 7..10,

  /// All other opcodes are reserved.  Halt interpretation and
  /// treat everything else as opaque.
};

class RUN_SKIP {
public:
  enum BLOCK_LAYOUT_OPCODE opcode;
  CharUnits block_var_bytepos;
  CharUnits block_var_size;
  RUN_SKIP(enum BLOCK_LAYOUT_OPCODE Opcode = BLOCK_LAYOUT_OPERATOR,
           CharUnits BytePos = CharUnits::Zero(),
           CharUnits Size = CharUnits::Zero())
  : opcode(Opcode), block_var_bytepos(BytePos),  block_var_size(Size) {}

  // Allow sorting based on byte pos.
  bool operator<(const RUN_SKIP &b) const {
    return block_var_bytepos < b.block_var_bytepos;
  }
};

845protected:
llvm::LLVMContext &VMContext;
// FIXME! May not be needing this after all.
unsigned ObjCABI;

// arc/mrr layout of captured block literal variables.
SmallVector<RUN_SKIP, 16> RunSkipBlockVars;

/// LazySymbols - Symbols to generate a lazy reference for. See
/// DefinedSymbols and FinishModule().
llvm::SetVector<IdentifierInfo*> LazySymbols;

/// DefinedSymbols - External symbols which are defined by this
/// module. The symbols in this list and LazySymbols are used to add
/// special linker symbols which ensure that Objective-C modules are
/// linked properly.
llvm::SetVector<IdentifierInfo*> DefinedSymbols;

/// ClassNames - uniqued class names.
llvm::StringMap<llvm::GlobalVariable*> ClassNames;

/// MethodVarNames - uniqued method variable names.
llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames;

/// DefinedCategoryNames - list of category names in form Class_Category.
llvm::SmallSetVector<llvm::CachedHashString, 16> DefinedCategoryNames;

/// MethodVarTypes - uniqued method type signatures. We have to use
/// a StringMap here because have no other unique reference.
llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes;

/// MethodDefinitions - map of methods which have been defined in
/// this translation unit.
llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;

/// DirectMethodDefinitions - map of direct methods which have been defined in
/// this translation unit.
llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> DirectMethodDefinitions;

/// PropertyNames - uniqued method variable names.
llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames;

/// ClassReferences - uniqued class references.
llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences;

/// SelectorReferences - uniqued selector references.
llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences;

/// Protocols - Protocols for which an objc_protocol structure has
/// been emitted. Forward declarations are handled by creating an
/// empty structure whose initializer is filled in when/if defined.
llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols;

/// DefinedProtocols - Protocols which have actually been
/// defined. We should not need this, see FIXME in GenerateProtocol.
llvm::DenseSet<IdentifierInfo*> DefinedProtocols;

/// DefinedClasses - List of defined classes.
SmallVector<llvm::GlobalValue*, 16> DefinedClasses;

/// ImplementedClasses - List of @implemented classes.
SmallVector<const ObjCInterfaceDecl*, 16> ImplementedClasses;

/// DefinedNonLazyClasses - List of defined "non-lazy" classes.
SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyClasses;

/// DefinedCategories - List of defined categories.
SmallVector<llvm::GlobalValue*, 16> DefinedCategories;

/// DefinedStubCategories - List of defined categories on class stubs.
SmallVector<llvm::GlobalValue*, 16> DefinedStubCategories;

/// DefinedNonLazyCategories - List of defined "non-lazy" categories.
SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyCategories;

/// Cached reference to the class for constant strings. This value has type
/// int * but is actually an Obj-C class pointer.
llvm::WeakTrackingVH ConstantStringClassRef;

/// The LLVM type corresponding to NSConstantString.
llvm::StructType *NSConstantStringType = nullptr;

llvm::StringMap<llvm::GlobalVariable *> NSConstantStringMap;

/// GetMethodVarName - Return a unique constant for the given
/// selector's name. The return value has type char *.
llvm::Constant *GetMethodVarName(Selector Sel);
llvm::Constant *GetMethodVarName(IdentifierInfo *Ident);

/// GetMethodVarType - Return a unique constant for the given
/// method's type encoding string. The return value has type char *.

// FIXME: This is a horrible name.
llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D,
                                 bool Extended = false);
llvm::Constant *GetMethodVarType(const FieldDecl *D);

/// GetPropertyName - Return a unique constant for the given
/// name. The return value has type char *.
llvm::Constant *GetPropertyName(IdentifierInfo *Ident);

// FIXME: This can be dropped once string functions are unified.
llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD,
                                      const Decl *Container);

/// GetClassName - Return a unique constant for the given selector's
/// runtime name (which may change via use of objc_runtime_name attribute on
/// class or protocol definition. The return value has type char *.
llvm::Constant *GetClassName(StringRef RuntimeName);

llvm::Function *GetMethodDefinition(const ObjCMethodDecl *MD);

/// BuildIvarLayout - Builds ivar layout bitmap for the class
/// implementation for the __strong or __weak case.
///
/// \param hasMRCWeakIvars - Whether we are compiling in MRC and there
///   are any weak ivars defined directly in the class.  Meaningless unless
///   building a weak layout.  Does not guarantee that the layout will
///   actually have any entries, because the ivar might be under-aligned.
llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI,
                                CharUnits beginOffset,
                                CharUnits endOffset,
                                bool forStrongLayout,
                                bool hasMRCWeakIvars);

llvm::Constant *BuildStrongIvarLayout(const ObjCImplementationDecl *OI,
                                      CharUnits beginOffset,
                                      CharUnits endOffset) {
  return BuildIvarLayout(OI, beginOffset, endOffset, true, false);
}

llvm::Constant *BuildWeakIvarLayout(const ObjCImplementationDecl *OI,
                                    CharUnits beginOffset,
                                    CharUnits endOffset,
                                    bool hasMRCWeakIvars) {
  return BuildIvarLayout(OI, beginOffset, endOffset, false, hasMRCWeakIvars);
}

Qualifiers::ObjCLifetime getBlockCaptureLifetime(QualType QT, bool ByrefLayout);

void UpdateRunSkipBlockVars(bool IsByref,
                            Qualifiers::ObjCLifetime LifeTime,
                            CharUnits FieldOffset,
                            CharUnits FieldSize);

void BuildRCBlockVarRecordLayout(const RecordType *RT,
                                 CharUnits BytePos, bool &HasUnion,
                                 bool ByrefLayout=false);

void BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
                         const RecordDecl *RD,
                         ArrayRef<const FieldDecl*> RecFields,
                         CharUnits BytePos, bool &HasUnion,
                         bool ByrefLayout);

uint64_t InlineLayoutInstruction(SmallVectorImpl<unsigned char> &Layout);

llvm::Constant *getBitmapBlockLayout(bool ComputeByrefLayout);

/// GetIvarLayoutName - Returns a unique constant for the given
/// ivar layout bitmap.
llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident,
                                  const ObjCCommonTypesHelper &ObjCTypes);

/// EmitPropertyList - Emit the given property list. The return
/// value has type PropertyListPtrTy.
llvm::Constant *EmitPropertyList(Twine Name,
                                 const Decl *Container,
                                 const ObjCContainerDecl *OCD,
                                 const ObjCCommonTypesHelper &ObjCTypes,
                                 bool IsClassProperty);

/// EmitProtocolMethodTypes - Generate the array of extended method type
/// strings. The return value has type Int8PtrPtrTy.
llvm::Constant *EmitProtocolMethodTypes(Twine Name,
                                        ArrayRef<llvm::Constant*> MethodTypes,
                                     const ObjCCommonTypesHelper &ObjCTypes);

/// GetProtocolRef - Return a reference to the internal protocol
/// description, creating an empty one if it has not been
/// defined. The return value has type ProtocolPtrTy.
llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD);

/// Return a reference to the given Class using runtime calls rather than
/// by a symbol reference.
llvm::Value *EmitClassRefViaRuntime(CodeGenFunction &CGF,
                                    const ObjCInterfaceDecl *ID,
                                    ObjCCommonTypesHelper &ObjCTypes);

std::string GetSectionName(StringRef Section, StringRef MachOAttributes);

1036public:
/// CreateMetadataVar - Create a global variable with internal
/// linkage for use by the Objective-C runtime.
///
/// This is a convenience wrapper which not only creates the
/// variable, but also sets the section and alignment and adds the
/// global to the "llvm.used" list.
///
/// \param Name - The variable name.
/// \param Init - The variable initializer; this is also used to
///   define the type of the variable.
/// \param Section - The section the variable should go into, or empty.
/// \param Align - The alignment for the variable, or 0.
/// \param AddToUsed - Whether the variable should be added to
///   "llvm.used".
llvm::GlobalVariable *CreateMetadataVar(Twine Name,
                                        ConstantStructBuilder &Init,
                                        StringRef Section, CharUnits Align,
                                        bool AddToUsed);
llvm::GlobalVariable *CreateMetadataVar(Twine Name,
                                        llvm::Constant *Init,
                                        StringRef Section, CharUnits Align,
                                        bool AddToUsed);

llvm::GlobalVariable *CreateCStringLiteral(StringRef Name,
                                           ObjCLabelType LabelType,
                                           bool ForceNonFragileABI = false,
                                           bool NullTerminate = true);

1065protected:
CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
                                ReturnValueSlot Return,
                                QualType ResultType,
                                Selector Sel,
                                llvm::Value *Arg0,
                                QualType Arg0Ty,
                                bool IsSuper,
                                const CallArgList &CallArgs,
                                const ObjCMethodDecl *OMD,
                                const ObjCInterfaceDecl *ClassReceiver,
                                const ObjCCommonTypesHelper &ObjCTypes);

/// EmitImageInfo - Emit the image info marker used to encode some module
/// level information.
void EmitImageInfo();

1082public:
CGObjCCommonMac(CodeGen::CodeGenModule &cgm)
    : CGObjCRuntime(cgm), VMContext(cgm.getLLVMContext()) {}

bool isNonFragileABI() const {
  return ObjCABI == 2;
}

ConstantAddress GenerateConstantString(const StringLiteral *SL) override;
ConstantAddress GenerateConstantNSString(const StringLiteral *SL);

llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
                               const ObjCContainerDecl *CD=nullptr) override;

llvm::Function *GenerateDirectMethod(const ObjCMethodDecl *OMD,
                                     const ObjCContainerDecl *CD);

void GenerateDirectMethodPrologue(CodeGenFunction &CGF, llvm::Function *Fn,
                                  const ObjCMethodDecl *OMD,
                                  const ObjCContainerDecl *CD) override;

void GenerateProtocol(const ObjCProtocolDecl *PD) override;

/// GetOrEmitProtocolRef - Get a forward reference to the protocol
/// object for the given declaration, emitting it if needed. These
/// forward references will be filled in with empty bodies if no
/// definition is seen. The return value has type ProtocolPtrTy.
virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0;

virtual llvm::Constant *getNSConstantStringClassRef() = 0;

llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM,
                                   const CGBlockInfo &blockInfo) override;
llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM,
                                   const CGBlockInfo &blockInfo) override;
std::string getRCBlockLayoutStr(CodeGen::CodeGenModule &CGM,
                                const CGBlockInfo &blockInfo) override;

llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM,
                                 QualType T) override;

1123private:
void fillRunSkipBlockVars(CodeGenModule &CGM, const CGBlockInfo &blockInfo);
1125};

1127namespace {

1129enum class MethodListType {
CategoryInstanceMethods,
CategoryClassMethods,
InstanceMethods,
ClassMethods,
ProtocolInstanceMethods,
ProtocolClassMethods,
OptionalProtocolInstanceMethods,
OptionalProtocolClassMethods,
1138};

1140/// A convenience class for splitting the methods of a protocol into
1141/// the four interesting groups.
1142class ProtocolMethodLists {
1143public:
enum Kind {
  RequiredInstanceMethods,
  RequiredClassMethods,
  OptionalInstanceMethods,
  OptionalClassMethods
};
enum {
  NumProtocolMethodLists = 4
};

static MethodListType getMethodListKind(Kind kind) {
  switch (kind) {
  case RequiredInstanceMethods:
    return MethodListType::ProtocolInstanceMethods;
  case RequiredClassMethods:
    return MethodListType::ProtocolClassMethods;
  case OptionalInstanceMethods:
    return MethodListType::OptionalProtocolInstanceMethods;
  case OptionalClassMethods:
    return MethodListType::OptionalProtocolClassMethods;
  }
  llvm_unreachable("bad kind")__builtin_unreachable();
}

SmallVector<const ObjCMethodDecl *, 4> Methods[NumProtocolMethodLists];

static ProtocolMethodLists get(const ObjCProtocolDecl *PD) {
  ProtocolMethodLists result;

  for (auto MD : PD->methods()) {
    size_t index = (2 * size_t(MD->isOptional()))
                 + (size_t(MD->isClassMethod()));
    result.Methods[index].push_back(MD);
  }

  return result;
}

template <class Self>
SmallVector<llvm::Constant*, 8> emitExtendedTypesArray(Self *self) const {
  // In both ABIs, the method types list is parallel with the
  // concatenation of the methods arrays in the following order:
  //   instance methods
  //   class methods
  //   optional instance methods
  //   optional class methods
  SmallVector<llvm::Constant*, 8> result;

  // Methods is already in the correct order for both ABIs.
  for (auto &list : Methods) {
    for (auto MD : list) {
      result.push_back(self->GetMethodVarType(MD, true));
    }
  }

  return result;
}

template <class Self>
llvm::Constant *emitMethodList(Self *self, const ObjCProtocolDecl *PD,
                               Kind kind) const {
  return self->emitMethodList(PD->getObjCRuntimeNameAsString(),
                              getMethodListKind(kind), Methods[kind]);
}
1208};

1210} // end anonymous namespace

1212class CGObjCMac : public CGObjCCommonMac {
1213private:
friend ProtocolMethodLists;

ObjCTypesHelper ObjCTypes;

/// EmitModuleInfo - Another marker encoding module level
/// information.
void EmitModuleInfo();

/// EmitModuleSymols - Emit module symbols, the list of defined
/// classes and categories. The result has type SymtabPtrTy.
llvm::Constant *EmitModuleSymbols();

/// FinishModule - Write out global data structures at the end of
/// processing a translation unit.
void FinishModule();

/// EmitClassExtension - Generate the class extension structure used
/// to store the weak ivar layout and properties. The return value
/// has type ClassExtensionPtrTy.
llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID,
                                   CharUnits instanceSize,
                                   bool hasMRCWeakIvars,
                                   bool isMetaclass);

/// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
/// for the given class.
llvm::Value *EmitClassRef(CodeGenFunction &CGF,
                          const ObjCInterfaceDecl *ID);

llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
                                IdentifierInfo *II);

llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;

/// EmitSuperClassRef - Emits reference to class's main metadata class.
llvm::Value *EmitSuperClassRef(const ObjCInterfaceDecl *ID);

/// EmitIvarList - Emit the ivar list for the given
/// implementation. If ForClass is true the list of class ivars
/// (i.e. metaclass ivars) is emitted, otherwise the list of
/// interface ivars will be emitted. The return value has type
/// IvarListPtrTy.
llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID,
                             bool ForClass);

/// EmitMetaClass - Emit a forward reference to the class structure
/// for the metaclass of the given interface. The return value has
/// type ClassPtrTy.
llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID);

/// EmitMetaClass - Emit a class structure for the metaclass of the
/// given implementation. The return value has type ClassPtrTy.
llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID,
                              llvm::Constant *Protocols,
                              ArrayRef<const ObjCMethodDecl *> Methods);

void emitMethodConstant(ConstantArrayBuilder &builder,
                        const ObjCMethodDecl *MD);

void emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
                                   const ObjCMethodDecl *MD);

/// EmitMethodList - Emit the method list for the given
/// implementation. The return value has type MethodListPtrTy.
llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
                               ArrayRef<const ObjCMethodDecl *> Methods);

/// GetOrEmitProtocol - Get the protocol object for the given
/// declaration, emitting it if necessary. The return value has type
/// ProtocolPtrTy.
llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;

/// GetOrEmitProtocolRef - Get a forward reference to the protocol
/// object for the given declaration, emitting it if needed. These
/// forward references will be filled in with empty bodies if no
/// definition is seen. The return value has type ProtocolPtrTy.
llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;

/// EmitProtocolExtension - Generate the protocol extension
/// structure used to store optional instance and class methods, and
/// protocol properties. The return value has type
/// ProtocolExtensionPtrTy.
llvm::Constant *
EmitProtocolExtension(const ObjCProtocolDecl *PD,
                      const ProtocolMethodLists &methodLists);

/// EmitProtocolList - Generate the list of referenced
/// protocols. The return value has type ProtocolListPtrTy.
llvm::Constant *EmitProtocolList(Twine Name,
                                 ObjCProtocolDecl::protocol_iterator begin,
                                 ObjCProtocolDecl::protocol_iterator end);

/// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
/// for the given selector.
llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
Address EmitSelectorAddr(Selector Sel);

1311public:
CGObjCMac(CodeGen::CodeGenModule &cgm);

llvm::Constant *getNSConstantStringClassRef() override;

llvm::Function *ModuleInitFunction() override;

CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
                                    ReturnValueSlot Return,
                                    QualType ResultType,
                                    Selector Sel, llvm::Value *Receiver,
                                    const CallArgList &CallArgs,
                                    const ObjCInterfaceDecl *Class,
                                    const ObjCMethodDecl *Method) override;

CodeGen::RValue
GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
                         ReturnValueSlot Return, QualType ResultType,
                         Selector Sel, const ObjCInterfaceDecl *Class,
                         bool isCategoryImpl, llvm::Value *Receiver,
                         bool IsClassMessage, const CallArgList &CallArgs,
                         const ObjCMethodDecl *Method) override;

llvm::Value *GetClass(CodeGenFunction &CGF,
                      const ObjCInterfaceDecl *ID) override;

llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override;
Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override;

/// The NeXT/Apple runtimes do not support typed selectors; just emit an
/// untyped one.
llvm::Value *GetSelector(CodeGenFunction &CGF,
                         const ObjCMethodDecl *Method) override;

llvm::Constant *GetEHType(QualType T) override;

void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;

void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;

void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}

llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
                                 const ObjCProtocolDecl *PD) override;

llvm::FunctionCallee GetPropertyGetFunction() override;
llvm::FunctionCallee GetPropertySetFunction() override;
llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
                                                     bool copy) override;
llvm::FunctionCallee GetGetStructFunction() override;
llvm::FunctionCallee GetSetStructFunction() override;
llvm::FunctionCallee GetCppAtomicObjectGetFunction() override;
llvm::FunctionCallee GetCppAtomicObjectSetFunction() override;
llvm::FunctionCallee EnumerationMutationFunction() override;

void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
                 const ObjCAtTryStmt &S) override;
void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
                          const ObjCAtSynchronizedStmt &S) override;
void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S);
void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
                   bool ClearInsertionPoint=true) override;
llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
                               Address AddrWeakObj) override;
void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
                        llvm::Value *src, Address dst) override;
void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
                          llvm::Value *src, Address dest,
                          bool threadlocal = false) override;
void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
                        llvm::Value *src, Address dest,
                        llvm::Value *ivarOffset) override;
void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
                              llvm::Value *src, Address dest) override;
void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
                              Address dest, Address src,
                              llvm::Value *size) override;

LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
                            llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
                            unsigned CVRQualifiers) override;
llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
                            const ObjCInterfaceDecl *Interface,
                            const ObjCIvarDecl *Ivar) override;
1395};

1397class CGObjCNonFragileABIMac : public CGObjCCommonMac {
1398private:
friend ProtocolMethodLists;
ObjCNonFragileABITypesHelper ObjCTypes;
llvm::GlobalVariable* ObjCEmptyCacheVar;
llvm::Constant* ObjCEmptyVtableVar;

/// SuperClassReferences - uniqued super class references.
llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences;

/// MetaClassReferences - uniqued meta class references.
llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences;

/// EHTypeReferences - uniqued class ehtype references.
llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences;

/// VTableDispatchMethods - List of methods for which we generate
/// vtable-based message dispatch.
llvm::DenseSet<Selector> VTableDispatchMethods;

/// DefinedMetaClasses - List of defined meta-classes.
std::vector<llvm::GlobalValue*> DefinedMetaClasses;

/// isVTableDispatchedSelector - Returns true if SEL is a
/// vtable-based selector.
bool isVTableDispatchedSelector(Selector Sel);

/// FinishNonFragileABIModule - Write out global data structures at the end of
/// processing a translation unit.
void FinishNonFragileABIModule();

/// AddModuleClassList - Add the given list of class pointers to the
/// module with the provided symbol and section names.
void AddModuleClassList(ArrayRef<llvm::GlobalValue *> Container,
                        StringRef SymbolName, StringRef SectionName);

llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags,
                                            unsigned InstanceStart,
                                            unsigned InstanceSize,
                                            const ObjCImplementationDecl *ID);
llvm::GlobalVariable *BuildClassObject(const ObjCInterfaceDecl *CI,
                                       bool isMetaclass,
                                       llvm::Constant *IsAGV,
                                       llvm::Constant *SuperClassGV,
                                       llvm::Constant *ClassRoGV,
                                       bool HiddenVisibility);

void emitMethodConstant(ConstantArrayBuilder &builder,
                          const ObjCMethodDecl *MD,
                          bool forProtocol);

/// Emit the method list for the given implementation. The return value
/// has type MethodListnfABITy.
llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
                               ArrayRef<const ObjCMethodDecl *> Methods);

/// EmitIvarList - Emit the ivar list for the given
/// implementation. If ForClass is true the list of class ivars
/// (i.e. metaclass ivars) is emitted, otherwise the list of
/// interface ivars will be emitted. The return value has type
/// IvarListnfABIPtrTy.
llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID);

llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
                                  const ObjCIvarDecl *Ivar,
                                  unsigned long int offset);

/// GetOrEmitProtocol - Get the protocol object for the given
/// declaration, emitting it if necessary. The return value has type
/// ProtocolPtrTy.
llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;

/// GetOrEmitProtocolRef - Get a forward reference to the protocol
/// object for the given declaration, emitting it if needed. These
/// forward references will be filled in with empty bodies if no
/// definition is seen. The return value has type ProtocolPtrTy.
llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;

/// EmitProtocolList - Generate the list of referenced
/// protocols. The return value has type ProtocolListPtrTy.
llvm::Constant *EmitProtocolList(Twine Name,
                                 ObjCProtocolDecl::protocol_iterator begin,
                                 ObjCProtocolDecl::protocol_iterator end);

CodeGen::RValue EmitVTableMessageSend(CodeGen::CodeGenFunction &CGF,
                                      ReturnValueSlot Return,
                                      QualType ResultType,
                                      Selector Sel,
                                      llvm::Value *Receiver,
                                      QualType Arg0Ty,
                                      bool IsSuper,
                                      const CallArgList &CallArgs,
                                      const ObjCMethodDecl *Method);

/// GetClassGlobal - Return the global variable for the Objective-C
/// class of the given name.
llvm::Constant *GetClassGlobal(StringRef Name,
                               ForDefinition_t IsForDefinition,
                               bool Weak = false, bool DLLImport = false);
llvm::Constant *GetClassGlobal(const ObjCInterfaceDecl *ID,
                               bool isMetaclass,
                               ForDefinition_t isForDefinition);

llvm::Constant *GetClassGlobalForClassRef(const ObjCInterfaceDecl *ID);

llvm::Value *EmitLoadOfClassRef(CodeGenFunction &CGF,
                                const ObjCInterfaceDecl *ID,
                                llvm::GlobalVariable *Entry);

/// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
/// for the given class reference.
llvm::Value *EmitClassRef(CodeGenFunction &CGF,
                          const ObjCInterfaceDecl *ID);

llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
                                IdentifierInfo *II,
                                const ObjCInterfaceDecl *ID);

llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;

/// EmitSuperClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
/// for the given super class reference.
llvm::Value *EmitSuperClassRef(CodeGenFunction &CGF,
                               const ObjCInterfaceDecl *ID);

/// EmitMetaClassRef - Return a Value * of the address of _class_t
/// meta-data
llvm::Value *EmitMetaClassRef(CodeGenFunction &CGF,
                              const ObjCInterfaceDecl *ID, bool Weak);

/// ObjCIvarOffsetVariable - Returns the ivar offset variable for
/// the given ivar.
///
llvm::GlobalVariable * ObjCIvarOffsetVariable(
  const ObjCInterfaceDecl *ID,
  const ObjCIvarDecl *Ivar);

/// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
/// for the given selector.
llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
Address EmitSelectorAddr(Selector Sel);

/// GetInterfaceEHType - Get the cached ehtype for the given Objective-C
/// interface. The return value has type EHTypePtrTy.
llvm::Constant *GetInterfaceEHType(const ObjCInterfaceDecl *ID,
                                   ForDefinition_t IsForDefinition);

StringRef getMetaclassSymbolPrefix() const { return "OBJC_METACLASS_$_"; }

StringRef getClassSymbolPrefix() const { return "OBJC_CLASS_$_"; }

void GetClassSizeInfo(const ObjCImplementationDecl *OID,
                      uint32_t &InstanceStart,
                      uint32_t &InstanceSize);

// Shamelessly stolen from Analysis/CFRefCount.cpp
Selector GetNullarySelector(const char* name) const {
  IdentifierInfo* II = &CGM.getContext().Idents.get(name);
  return CGM.getContext().Selectors.getSelector(0, &II);
}

Selector GetUnarySelector(const char* name) const {
  IdentifierInfo* II = &CGM.getContext().Idents.get(name);
  return CGM.getContext().Selectors.getSelector(1, &II);
}

/// ImplementationIsNonLazy - Check whether the given category or
/// class implementation is "non-lazy".
bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const;

bool IsIvarOffsetKnownIdempotent(const CodeGen::CodeGenFunction &CGF,
                                 const ObjCIvarDecl *IV) {
  // Annotate the load as an invariant load iff inside an instance method
  // and ivar belongs to instance method's class and one of its super class.
  // This check is needed because the ivar offset is a lazily
  // initialised value that may depend on objc_msgSend to perform a fixup on
  // the first message dispatch.
  //
  // An additional opportunity to mark the load as invariant arises when the
  // base of the ivar access is a parameter to an Objective C method.
  // However, because the parameters are not available in the current
  // interface, we cannot perform this check.
  //
  // Note that for direct methods, because objc_msgSend is skipped,
  // and that the method may be inlined, this optimization actually
  // can't be performed.
  if (const ObjCMethodDecl *MD =
        dyn_cast_or_null<ObjCMethodDecl>(CGF.CurFuncDecl))
    if (MD->isInstanceMethod() && !MD->isDirectMethod())
      if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
        return IV->getContainingInterface()->isSuperClassOf(ID);
  return false;
}

bool isClassLayoutKnownStatically(const ObjCInterfaceDecl *ID) {
  // NSObject is a fixed size. If we can see the @implementation of a class
  // which inherits from NSObject then we know that all it's offsets also must
  // be fixed. FIXME: Can we do this if see a chain of super classes with
  // implementations leading to NSObject?
  return ID->getImplementation() && ID->getSuperClass() &&
         ID->getSuperClass()->getName() == "NSObject";
}

1600public:
CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm);

llvm::Constant *getNSConstantStringClassRef() override;

llvm::Function *ModuleInitFunction() override;

CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
                                    ReturnValueSlot Return,
                                    QualType ResultType, Selector Sel,
                                    llvm::Value *Receiver,
                                    const CallArgList &CallArgs,
                                    const ObjCInterfaceDecl *Class,
                                    const ObjCMethodDecl *Method) override;

CodeGen::RValue
GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
                         ReturnValueSlot Return, QualType ResultType,
                         Selector Sel, const ObjCInterfaceDecl *Class,
                         bool isCategoryImpl, llvm::Value *Receiver,
                         bool IsClassMessage, const CallArgList &CallArgs,
                         const ObjCMethodDecl *Method) override;

llvm::Value *GetClass(CodeGenFunction &CGF,
                      const ObjCInterfaceDecl *ID) override;

llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override
  { return EmitSelector(CGF, Sel); }
Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override
  { return EmitSelectorAddr(Sel); }

/// The NeXT/Apple runtimes do not support typed selectors; just emit an
/// untyped one.
llvm::Value *GetSelector(CodeGenFunction &CGF,
                         const ObjCMethodDecl *Method) override
  { return EmitSelector(CGF, Method->getSelector()); }

void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;

void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;

void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}

llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
                                 const ObjCProtocolDecl *PD) override;

llvm::Constant *GetEHType(QualType T) override;

llvm::FunctionCallee GetPropertyGetFunction() override {
  return ObjCTypes.getGetPropertyFn();
}
llvm::FunctionCallee GetPropertySetFunction() override {
  return ObjCTypes.getSetPropertyFn();
}

llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
                                                     bool copy) override {
  return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
}

llvm::FunctionCallee GetSetStructFunction() override {
  return ObjCTypes.getCopyStructFn();
}

llvm::FunctionCallee GetGetStructFunction() override {
  return ObjCTypes.getCopyStructFn();
}

llvm::FunctionCallee GetCppAtomicObjectSetFunction() override {
  return ObjCTypes.getCppAtomicObjectFunction();
}

llvm::FunctionCallee GetCppAtomicObjectGetFunction() override {
  return ObjCTypes.getCppAtomicObjectFunction();
}

llvm::FunctionCallee EnumerationMutationFunction() override {
  return ObjCTypes.getEnumerationMutationFn();
}

void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
                 const ObjCAtTryStmt &S) override;
void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
                          const ObjCAtSynchronizedStmt &S) override;
void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
                   bool ClearInsertionPoint=true) override;
llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
                               Address AddrWeakObj) override;
void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
                        llvm::Value *src, Address edst) override;
void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
                          llvm::Value *src, Address dest,
                          bool threadlocal = false) override;
void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
                        llvm::Value *src, Address dest,
                        llvm::Value *ivarOffset) override;
void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
                              llvm::Value *src, Address dest) override;
void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
                              Address dest, Address src,
                              llvm::Value *size) override;
LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
                            llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
                            unsigned CVRQualifiers) override;
llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
                            const ObjCInterfaceDecl *Interface,
                            const ObjCIvarDecl *Ivar) override;
1707};

1709/// A helper class for performing the null-initialization of a return
1710/// value.
1711struct NullReturnState {
llvm::BasicBlock *NullBB;
NullReturnState() : NullBB(nullptr) {}

/// Perform a null-check of the given receiver.
void init(CodeGenFunction &CGF, llvm::Value *receiver) {
  // Make blocks for the null-receiver and call edges.
  NullBB = CGF.createBasicBlock("msgSend.null-receiver");
  llvm::BasicBlock *callBB = CGF.createBasicBlock("msgSend.call");

  // Check for a null receiver and, if there is one, jump to the
  // null-receiver block.  There's no point in trying to avoid it:
  // we're always going to put *something* there, because otherwise
  // we shouldn't have done this null-check in the first place.
  llvm::Value *isNull = CGF.Builder.CreateIsNull(receiver);
  CGF.Builder.CreateCondBr(isNull, NullBB, callBB);

  // Otherwise, start performing the call.
  CGF.EmitBlock(callBB);
}

/// Complete the null-return operation.  It is valid to call this
/// regardless of whether 'init' has been called.
RValue complete(CodeGenFunction &CGF,
                ReturnValueSlot returnSlot,
                RValue result,
                QualType resultType,
                const CallArgList &CallArgs,
                const ObjCMethodDecl *Method) {
  // If we never had to do a null-check, just use the raw result.
  if (!NullBB) return result;

  // The continuation block.  This will be left null if we don't have an
  // IP, which can happen if the method we're calling is marked noreturn.
  llvm::BasicBlock *contBB = nullptr;

  // Finish the call path.
  llvm::BasicBlock *callBB = CGF.Builder.GetInsertBlock();
  if (callBB) {
    contBB = CGF.createBasicBlock("msgSend.cont");
    CGF.Builder.CreateBr(contBB);
  }

  // Okay, start emitting the null-receiver block.
  CGF.EmitBlock(NullBB);

  // Release any consumed arguments we've got.
  if (Method) {
    CallArgList::const_iterator I = CallArgs.begin();
    for (ObjCMethodDecl::param_const_iterator i = Method->param_begin(),
         e = Method->param_end(); i != e; ++i, ++I) {
      const ParmVarDecl *ParamDecl = (*i);
      if (ParamDecl->hasAttr<NSConsumedAttr>()) {
        RValue RV = I->getRValue(CGF);
        assert(RV.isScalar() &&((void)0)
               "NullReturnState::complete - arg not on object")((void)0);
        CGF.EmitARCRelease(RV.getScalarVal(), ARCImpreciseLifetime);
      } else {
        QualType QT = ParamDecl->getType();
        auto *RT = QT->getAs<RecordType>();
        if (RT && RT->getDecl()->isParamDestroyedInCallee()) {
          RValue RV = I->getRValue(CGF);
          QualType::DestructionKind DtorKind = QT.isDestructedType();
          switch (DtorKind) {
          case QualType::DK_cxx_destructor:
            CGF.destroyCXXObject(CGF, RV.getAggregateAddress(), QT);
            break;
          case QualType::DK_nontrivial_c_struct:
            CGF.destroyNonTrivialCStruct(CGF, RV.getAggregateAddress(), QT);
            break;
          default:
            llvm_unreachable("unexpected dtor kind")__builtin_unreachable();
            break;
          }
        }
      }
    }
  }

  // The phi code below assumes that we haven't needed any control flow yet.
  assert(CGF.Builder.GetInsertBlock() == NullBB)((void)0);

  // If we've got a void return, just jump to the continuation block.
  if (result.isScalar() && resultType->isVoidType()) {
    // No jumps required if the message-send was noreturn.
    if (contBB) CGF.EmitBlock(contBB);
    return result;
  }

  // If we've got a scalar return, build a phi.
  if (result.isScalar()) {
    // Derive the null-initialization value.
    llvm::Value *null =
        CGF.EmitFromMemory(CGF.CGM.EmitNullConstant(resultType), resultType);

    // If no join is necessary, just flow out.
    if (!contBB) return RValue::get(null);

    // Otherwise, build a phi.
    CGF.EmitBlock(contBB);
    llvm::PHINode *phi = CGF.Builder.CreatePHI(null->getType(), 2);
    phi->addIncoming(result.getScalarVal(), callBB);
    phi->addIncoming(null, NullBB);
    return RValue::get(phi);
  }

  // If we've got an aggregate return, null the buffer out.
  // FIXME: maybe we should be doing things differently for all the
  // cases where the ABI has us returning (1) non-agg values in
  // memory or (2) agg values in registers.
  if (result.isAggregate()) {
    assert(result.isAggregate() && "null init of non-aggregate result?")((void)0);
    if (!returnSlot.isUnused())
      CGF.EmitNullInitialization(result.getAggregateAddress(), resultType);
    if (contBB) CGF.EmitBlock(contBB);
    return result;
  }

  // Complex types.
  CGF.EmitBlock(contBB);
  CodeGenFunction::ComplexPairTy callResult = result.getComplexVal();

  // Find the scalar type and its zero value.
  llvm::Type *scalarTy = callResult.first->getType();
  llvm::Constant *scalarZero = llvm::Constant::getNullValue(scalarTy);

  // Build phis for both coordinates.
  llvm::PHINode *real = CGF.Builder.CreatePHI(scalarTy, 2);
  real->addIncoming(callResult.first, callBB);
  real->addIncoming(scalarZero, NullBB);
  llvm::PHINode *imag = CGF.Builder.CreatePHI(scalarTy, 2);
  imag->addIncoming(callResult.second, callBB);
  imag->addIncoming(scalarZero, NullBB);
  return RValue::getComplex(real, imag);
}
1846};

1848} // end anonymous namespace

1850/* *** Helper Functions *** */

1852/// getConstantGEP() - Help routine to construct simple GEPs.
1853static llvm::Constant *getConstantGEP(llvm::LLVMContext &VMContext,
                                    llvm::GlobalVariable *C, unsigned idx0,
                                    unsigned idx1) {
llvm::Value *Idxs[] = {
  llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0),
  llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1)
};
return llvm::ConstantExpr::getGetElementPtr(C->getValueType(), C, Idxs);
1861}

1863/// hasObjCExceptionAttribute - Return true if this class or any super
1864/// class has the __objc_exception__ attribute.
1865static bool hasObjCExceptionAttribute(ASTContext &Context,
                                    const ObjCInterfaceDecl *OID) {
if (OID->hasAttr<ObjCExceptionAttr>())
  return true;
if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
  return hasObjCExceptionAttribute(Context, Super);
return false;
1872}

1874static llvm::GlobalValue::LinkageTypes
1875getLinkageTypeForObjCMetadata(CodeGenModule &CGM, StringRef Section) {
if (CGM.getTriple().isOSBinFormatMachO() &&
    (Section.empty() || Section.startswith("__DATA")))
  return llvm::GlobalValue::InternalLinkage;
return llvm::GlobalValue::PrivateLinkage;
1880}

1882/// A helper function to create an internal or private global variable.
1883static llvm::GlobalVariable *
1884finishAndCreateGlobal(ConstantInitBuilder::StructBuilder &Builder,
                   const llvm::Twine &Name, CodeGenModule &CGM) {
std::string SectionName;
if (CGM.getTriple().isOSBinFormatMachO())
  SectionName = "__DATA, __objc_const";
auto *GV = Builder.finishAndCreateGlobal(
    Name, CGM.getPointerAlign(), /*constant*/ false,
    getLinkageTypeForObjCMetadata(CGM, SectionName));
GV->setSection(SectionName);
return GV;
1894}

1896/* *** CGObjCMac Public Interface *** */

1898CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm),
                                                  ObjCTypes(cgm) {
ObjCABI = 1;
EmitImageInfo();
1902}

1904/// GetClass - Return a reference to the class for the given interface
1905/// decl.
1906llvm::Value *CGObjCMac::GetClass(CodeGenFunction &CGF,
                               const ObjCInterfaceDecl *ID) {
return EmitClassRef(CGF, ID);
1909}

1911/// GetSelector - Return the pointer to the unique'd string for this selector.
1912llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, Selector Sel) {
return EmitSelector(CGF, Sel);
1914}
1915Address CGObjCMac::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) {
return EmitSelectorAddr(Sel);
1917}
1918llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, const ObjCMethodDecl
                                  *Method) {
return EmitSelector(CGF, Method->getSelector());
1921}

1923llvm::Constant *CGObjCMac::GetEHType(QualType T) {
if (T->isObjCIdType() ||
    T->isObjCQualifiedIdType()) {
  return CGM.GetAddrOfRTTIDescriptor(
            CGM.getContext().getObjCIdRedefinitionType(), /*ForEH=*/true);
}
if (T->isObjCClassType() ||
    T->isObjCQualifiedClassType()) {
  return CGM.GetAddrOfRTTIDescriptor(
           CGM.getContext().getObjCClassRedefinitionType(), /*ForEH=*/true);
}
if (T->isObjCObjectPointerType())
  return CGM.GetAddrOfRTTIDescriptor(T,  /*ForEH=*/true);

llvm_unreachable("asking for catch type for ObjC type in fragile runtime")__builtin_unreachable();
1938}

1940/// Generate a constant CFString object.
1941/*
struct __builtin_CFString {
const int *isa; // point to __CFConstantStringClassReference
int flags;
const char *str;
long length;
};
1948*/

1950/// or Generate a constant NSString object.
1951/*
 struct __builtin_NSString {
   const int *isa; // point to __NSConstantStringClassReference
   const char *str;
   unsigned int length;
 };
1957*/

1959ConstantAddress
1960CGObjCCommonMac::GenerateConstantString(const StringLiteral *SL) {
return (!CGM.getLangOpts().NoConstantCFStrings
          ? CGM.GetAddrOfConstantCFString(SL)
          : GenerateConstantNSString(SL));
1964}

1966static llvm::StringMapEntry<llvm::GlobalVariable *> &
1967GetConstantStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map,
                     const StringLiteral *Literal, unsigned &StringLength) {
StringRef String = Literal->getString();
StringLength = String.size();
return *Map.insert(std::make_pair(String, nullptr)).first;
1972}

1974llvm::Constant *CGObjCMac::getNSConstantStringClassRef() {
if (llvm::Value *V = ConstantStringClassRef)
  return cast<llvm::Constant>(V);

auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
std::string str =
  StringClass.empty() ? "_NSConstantStringClassReference"
                      : "_" + StringClass + "ClassReference";

llvm::Type *PTy = llvm::ArrayType::get(CGM.IntTy, 0);
auto GV = CGM.CreateRuntimeVariable(PTy, str);
auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
ConstantStringClassRef = V;
return V;
1988}

1990llvm::Constant *CGObjCNonFragileABIMac::getNSConstantStringClassRef() {
if (llvm::Value *V = ConstantStringClassRef)
  return cast<llvm::Constant>(V);

auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
std::string str =
  StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
                      : "OBJC_CLASS_$_" + StringClass;
llvm::Constant *GV = GetClassGlobal(str, NotForDefinition);

// Make sure the result is of the correct type.
auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());

ConstantStringClassRef = V;
return V;
2005}

2007ConstantAddress
2008CGObjCCommonMac::GenerateConstantNSString(const StringLiteral *Literal) {
unsigned StringLength = 0;
llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
  GetConstantStringEntry(NSConstantStringMap, Literal, StringLength);

if (auto *C = Entry.second)
  return ConstantAddress(C, CharUnits::fromQuantity(C->getAlignment()));

// If we don't already have it, get _NSConstantStringClassReference.
llvm::Constant *Class = getNSConstantStringClassRef();

// If we don't already have it, construct the type for a constant NSString.
if (!NSConstantStringType) {
  NSConstantStringType =
    llvm::StructType::create({
      CGM.Int32Ty->getPointerTo(),
      CGM.Int8PtrTy,
      CGM.IntTy
    }, "struct.__builtin_NSString");
}

ConstantInitBuilder Builder(CGM);
auto Fields = Builder.beginStruct(NSConstantStringType);

// Class pointer.
Fields.add(Class);

// String pointer.
llvm::Constant *C =
  llvm::ConstantDataArray::getString(VMContext, Entry.first());

llvm::GlobalValue::LinkageTypes Linkage = llvm::GlobalValue::PrivateLinkage;
bool isConstant = !CGM.getLangOpts().WritableStrings;

auto *GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(), isConstant,
                                    Linkage, C, ".str");
GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
// Don't enforce the target's minimum global alignment, since the only use
// of the string is via this class initializer.
GV->setAlignment(llvm::Align(1));
Fields.addBitCast(GV, CGM.Int8PtrTy);

// String length.
Fields.addInt(CGM.IntTy, StringLength);

// The struct.
CharUnits Alignment = CGM.getPointerAlign();
GV = Fields.finishAndCreateGlobal("_unnamed_nsstring_", Alignment,
                                  /*constant*/ true,
                                  llvm::GlobalVariable::PrivateLinkage);
const char *NSStringSection = "__OBJC,__cstring_object,regular,no_dead_strip";
const char *NSStringNonFragileABISection =
    "__DATA,__objc_stringobj,regular,no_dead_strip";
// FIXME. Fix section.
GV->setSection(CGM.getLangOpts().ObjCRuntime.isNonFragile()
                   ? NSStringNonFragileABISection
                   : NSStringSection);
Entry.second = GV;

return ConstantAddress(GV, Alignment);
2068}

2070enum {
kCFTaggedObjectID_Integer = (1 << 1) + 1
2072};

2074/// Generates a message send where the super is the receiver.  This is
2075/// a message send to self with special delivery semantics indicating
2076/// which class's method should be called.
2077CodeGen::RValue
2078CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
                                  ReturnValueSlot Return,
                                  QualType ResultType,
                                  Selector Sel,
                                  const ObjCInterfaceDecl *Class,
                                  bool isCategoryImpl,
                                  llvm::Value *Receiver,
                                  bool IsClassMessage,
                                  const CodeGen::CallArgList &CallArgs,
                                  const ObjCMethodDecl *Method) {
// Create and init a super structure; this is a (receiver, class)
// pair we will pass to objc_msgSendSuper.
Address ObjCSuper =
  CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
                       "objc_super");
llvm::Value *ReceiverAsObject =
  CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
CGF.Builder.CreateStore(ReceiverAsObject,
                        CGF.Builder.CreateStructGEP(ObjCSuper, 0));

// If this is a class message the metaclass is passed as the target.
llvm::Type *ClassTyPtr = llvm::PointerType::getUnqual(ObjCTypes.ClassTy);
llvm::Value *Target;
if (IsClassMessage) {
  if (isCategoryImpl) {
    // Message sent to 'super' in a class method defined in a category
    // implementation requires an odd treatment.
    // If we are in a class method, we must retrieve the
    // _metaclass_ for the current class, pointed at by
    // the class's "isa" pointer.  The following assumes that
    // isa" is the first ivar in a class (which it must be).
    Target = EmitClassRef(CGF, Class->getSuperClass());
    Target = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, Target, 0);
    Target = CGF.Builder.CreateAlignedLoad(ClassTyPtr, Target,
                                           CGF.getPointerAlign());
  } else {
    llvm::Constant *MetaClassPtr = EmitMetaClassRef(Class);
    llvm::Value *SuperPtr =
        CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, MetaClassPtr, 1);
    llvm::Value *Super = CGF.Builder.CreateAlignedLoad(ClassTyPtr, SuperPtr,
                                                       CGF.getPointerAlign());
    Target = Super;
  }
} else if (isCategoryImpl)
  Target = EmitClassRef(CGF, Class->getSuperClass());
else {
  llvm::Value *ClassPtr = EmitSuperClassRef(Class);
  ClassPtr = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, ClassPtr, 1);
  Target = CGF.Builder.CreateAlignedLoad(ClassTyPtr, ClassPtr,
                                         CGF.getPointerAlign());
}
// FIXME: We shouldn't need to do this cast, rectify the ASTContext and
// ObjCTypes types.
llvm::Type *ClassTy =
  CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
Target = CGF.Builder.CreateBitCast(Target, ClassTy);
CGF.Builder.CreateStore(Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1));
return EmitMessageSend(CGF, Return, ResultType, Sel, ObjCSuper.getPointer(),
                       ObjCTypes.SuperPtrCTy, true, CallArgs, Method, Class,
                       ObjCTypes);
2138}

2140/// Generate code for a message send expression.
2141CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
                                             ReturnValueSlot Return,
                                             QualType ResultType,
                                             Selector Sel,
                                             llvm::Value *Receiver,
                                             const CallArgList &CallArgs,
                                             const ObjCInterfaceDecl *Class,
                                             const ObjCMethodDecl *Method) {
return EmitMessageSend(CGF, Return, ResultType, Sel, Receiver,
                       CGF.getContext().getObjCIdType(), false, CallArgs,
                       Method, Class, ObjCTypes);
2152}

2154static bool isWeakLinkedClass(const ObjCInterfaceDecl *ID) {
do {
  if (ID->isWeakImported())
    return true;
} while ((ID = ID->getSuperClass()));

return false;
2161}

2163CodeGen::RValue
2164CGObjCCommonMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF,
                               ReturnValueSlot Return,
                               QualType ResultType,
                               Selector Sel,
                               llvm::Value *Arg0,
                               QualType Arg0Ty,
                               bool IsSuper,
                               const CallArgList &CallArgs,
                               const ObjCMethodDecl *Method,
                               const ObjCInterfaceDecl *ClassReceiver,
                               const ObjCCommonTypesHelper &ObjCTypes) {
CodeGenTypes &Types = CGM.getTypes();
auto selTy = CGF.getContext().getObjCSelType();
llvm::Value *SelValue;

if (Method && Method->isDirectMethod()) {
  // Direct methods will synthesize the proper `_cmd` internally,
  // so just don't bother with setting the `_cmd` argument.
  assert(!IsSuper)((void)0);
  SelValue = llvm::UndefValue::get(Types.ConvertType(selTy));
} else {
  SelValue = GetSelector(CGF, Sel);
}

CallArgList ActualArgs;
if (!IsSuper)
  Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy);
ActualArgs.add(RValue::get(Arg0), Arg0Ty);
ActualArgs.add(RValue::get(SelValue), selTy);
ActualArgs.addFrom(CallArgs);

// If we're calling a method, use the formal signature.
MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);

if (Method)
  assert(CGM.getContext().getCanonicalType(Method->getReturnType()) ==((void)0)
             CGM.getContext().getCanonicalType(ResultType) &&((void)0)
         "Result type mismatch!")((void)0);

bool ReceiverCanBeNull = true;

// Super dispatch assumes that self is non-null; even the messenger
// doesn't have a null check internally.
if (IsSuper) {
  ReceiverCanBeNull = false;

// If this is a direct dispatch of a class method, check whether the class,
// or anything in its hierarchy, was weak-linked.
} else if (ClassReceiver && Method && Method->isClassMethod()) {
  ReceiverCanBeNull = isWeakLinkedClass(ClassReceiver);

// If we're emitting a method, and self is const (meaning just ARC, for now),
// and the receiver is a load of self, then self is a valid object.
} else if (auto CurMethod =
             dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl)) {
  auto Self = CurMethod->getSelfDecl();
  if (Self->getType().isConstQualified()) {
    if (auto LI = dyn_cast<llvm::LoadInst>(Arg0->stripPointerCasts())) {
      llvm::Value *SelfAddr = CGF.GetAddrOfLocalVar(Self).getPointer();
      if (SelfAddr == LI->getPointerOperand()) {
        ReceiverCanBeNull = false;
      }
    }
  }
}

bool RequiresNullCheck = false;

llvm::FunctionCallee Fn = nullptr;
if (Method && Method->isDirectMethod()) {
  Fn = GenerateDirectMethod(Method, Method->getClassInterface());
} else if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
  if (ReceiverCanBeNull) RequiresNullCheck = true;
  Fn = (ObjCABI == 2) ?  ObjCTypes.getSendStretFn2(IsSuper)
    : ObjCTypes.getSendStretFn(IsSuper);
} else if (CGM.ReturnTypeUsesFPRet(ResultType)) {
  Fn = (ObjCABI == 2) ? ObjCTypes.getSendFpretFn2(IsSuper)
    : ObjCTypes.getSendFpretFn(IsSuper);
} else if (CGM.ReturnTypeUsesFP2Ret(ResultType)) {
  Fn = (ObjCABI == 2) ? ObjCTypes.getSendFp2RetFn2(IsSuper)
    : ObjCTypes.getSendFp2retFn(IsSuper);
} else {
  // arm64 uses objc_msgSend for stret methods and yet null receiver check
  // must be made for it.
  if (ReceiverCanBeNull && CGM.ReturnTypeUsesSRet(MSI.CallInfo))
    RequiresNullCheck = true;
  Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper)
    : ObjCTypes.getSendFn(IsSuper);
}

// Cast function to proper signature
llvm::Constant *BitcastFn = cast<llvm::Constant>(
    CGF.Builder.CreateBitCast(Fn.getCallee(), MSI.MessengerType));

// We don't need to emit a null check to zero out an indirect result if the
// result is ignored.
if (Return.isUnused())
  RequiresNullCheck = false;

// Emit a null-check if there's a consumed argument other than the receiver.
if (!RequiresNullCheck && CGM.getLangOpts().ObjCAutoRefCount && Method) {
  for (const auto *ParamDecl : Method->parameters()) {
    if (ParamDecl->isDestroyedInCallee()) {
      RequiresNullCheck = true;
      break;
    }
  }
}

NullReturnState nullReturn;
if (RequiresNullCheck) {
  nullReturn.init(CGF, Arg0);
}

llvm::CallBase *CallSite;
CGCallee Callee = CGCallee::forDirect(BitcastFn);
RValue rvalue = CGF.EmitCall(MSI.CallInfo, Callee, Return, ActualArgs,
                             &CallSite);

// Mark the call as noreturn if the method is marked noreturn and the
// receiver cannot be null.
if (Method && Method->hasAttr<NoReturnAttr>() && !ReceiverCanBeNull) {
  CallSite->setDoesNotReturn();
}

return nullReturn.complete(CGF, Return, rvalue, ResultType, CallArgs,
                           RequiresNullCheck ? Method : nullptr);
2291}

2293static Qualifiers::GC GetGCAttrTypeForType(ASTContext &Ctx, QualType FQT,
                                         bool pointee = false) {
// Note that GC qualification applies recursively to C pointer types
// that aren't otherwise decorated.  This is weird, but it's probably
// an intentional workaround to the unreliable placement of GC qualifiers.
if (FQT.isObjCGCStrong())
  return Qualifiers::Strong;

if (FQT.isObjCGCWeak())
  return Qualifiers::Weak;

if (auto ownership = FQT.getObjCLifetime()) {
  // Ownership does not apply recursively to C pointer types.
  if (pointee) return Qualifiers::GCNone;
  switch (ownership) {
  case Qualifiers::OCL_Weak: return Qualifiers::Weak;
  case Qualifiers::OCL_Strong: return Qualifiers::Strong;
  case Qualifiers::OCL_ExplicitNone: return Qualifiers::GCNone;
  case Qualifiers::OCL_Autoreleasing: llvm_unreachable("autoreleasing ivar?")__builtin_unreachable();
  case Qualifiers::OCL_None: llvm_unreachable("known nonzero")__builtin_unreachable();
  }
  llvm_unreachable("bad objc ownership")__builtin_unreachable();
}

// Treat unqualified retainable pointers as strong.
if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
  return Qualifiers::Strong;

// Walk into C pointer types, but only in GC.
if (Ctx.getLangOpts().getGC() != LangOptions::NonGC) {
  if (const PointerType *PT = FQT->getAs<PointerType>())
    return GetGCAttrTypeForType(Ctx, PT->getPointeeType(), /*pointee*/ true);
}

return Qualifiers::GCNone;
2328}

2330namespace {
struct IvarInfo {
  CharUnits Offset;
  uint64_t SizeInWords;
  IvarInfo(CharUnits offset, uint64_t sizeInWords)
    : Offset(offset), SizeInWords(sizeInWords) {}

  // Allow sorting based on byte pos.
  bool operator<(const IvarInfo &other) const {
    return Offset < other.Offset;
  }
};

/// A helper class for building GC layout strings.
class IvarLayoutBuilder {
  CodeGenModule &CGM;

  /// The start of the layout.  Offsets will be relative to this value,
  /// and entries less than this value will be silently discarded.
  CharUnits InstanceBegin;

  /// The end of the layout.  Offsets will never exceed this value.
  CharUnits InstanceEnd;

  /// Whether we're generating the strong layout or the weak layout.
  bool ForStrongLayout;

  /// Whether the offsets in IvarsInfo might be out-of-order.
  bool IsDisordered = false;

  llvm::SmallVector<IvarInfo, 8> IvarsInfo;

public:
  IvarLayoutBuilder(CodeGenModule &CGM, CharUnits instanceBegin,
                    CharUnits instanceEnd, bool forStrongLayout)
    : CGM(CGM), InstanceBegin(instanceBegin), InstanceEnd(instanceEnd),
      ForStrongLayout(forStrongLayout) {
  }

  void visitRecord(const RecordType *RT, CharUnits offset);

  template <class Iterator, class GetOffsetFn>
  void visitAggregate(Iterator begin, Iterator end,
                      CharUnits aggrOffset,
                      const GetOffsetFn &getOffset);

  void visitField(const FieldDecl *field, CharUnits offset);

  /// Add the layout of a block implementation.
  void visitBlock(const CGBlockInfo &blockInfo);

  /// Is there any information for an interesting bitmap?
  bool hasBitmapData() const { return !IvarsInfo.empty(); }

  llvm::Constant *buildBitmap(CGObjCCommonMac &CGObjC,
                              llvm::SmallVectorImpl<unsigned char> &buffer);

  static void dump(ArrayRef<unsigned char> buffer) {
    const unsigned char *s = buffer.data();
    for (unsigned i = 0, e = buffer.size(); i < e; i++)
      if (!(s[i] & 0xf0))
        printf("0x0%x%s", s[i], s[i] != 0 ? ", " : "");
      else
        printf("0x%x%s",  s[i], s[i] != 0 ? ", " : "");
    printf("\n");
  }
};
2397} // end anonymous namespace

2399llvm::Constant *CGObjCCommonMac::BuildGCBlockLayout(CodeGenModule &CGM,
                                              const CGBlockInfo &blockInfo) {

llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
if (CGM.getLangOpts().getGC() == LangOptions::NonGC)
  return nullPtr;

IvarLayoutBuilder builder(CGM, CharUnits::Zero(), blockInfo.BlockSize,
                          /*for strong layout*/ true);

builder.visitBlock(blockInfo);

if (!builder.hasBitmapData())
  return nullPtr;

llvm::SmallVector<unsigned char, 32> buffer;
llvm::Constant *C = builder.buildBitmap(*this, buffer);
if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
  printf("\n block variable layout for block: ");
  builder.dump(buffer);
}

return C;
2422}

2424void IvarLayoutBuilder::visitBlock(const CGBlockInfo &blockInfo) {
// __isa is the first field in block descriptor and must assume by runtime's
// convention that it is GC'able.
IvarsInfo.push_back(IvarInfo(CharUnits::Zero(), 1));

const BlockDecl *blockDecl = blockInfo.getBlockDecl();

// Ignore the optional 'this' capture: C++ objects are not assumed
// to be GC'ed.

CharUnits lastFieldOffset;

// Walk the captured variables.
for (const auto &CI : blockDecl->captures()) {
  const VarDecl *variable = CI.getVariable();
  QualType type = variable->getType();

  const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);

  // Ignore constant captures.
  if (capture.isConstant()) continue;

  CharUnits fieldOffset = capture.getOffset();

  // Block fields are not necessarily ordered; if we detect that we're
  // adding them out-of-order, make sure we sort later.
  if (fieldOffset < lastFieldOffset)
    IsDisordered = true;
  lastFieldOffset = fieldOffset;

  // __block variables are passed by their descriptor address.
  if (CI.isByRef()) {
    IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
    continue;
  }

  assert(!type->isArrayType() && "array variable should not be caught")((void)0);
  if (const RecordType *record = type->getAs<RecordType>()) {
    visitRecord(record, fieldOffset);
    continue;
  }

  Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), type);

  if (GCAttr == Qualifiers::Strong) {
    assert(CGM.getContext().getTypeSize(type)((void)0)
              == CGM.getTarget().getPointerWidth(0))((void)0);
    IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
  }
}
2474}

2476/// getBlockCaptureLifetime - This routine returns life time of the captured
2477/// block variable for the purpose of block layout meta-data generation. FQT is
2478/// the type of the variable captured in the block.
2479Qualifiers::ObjCLifetime CGObjCCommonMac::getBlockCaptureLifetime(QualType FQT,
                                                                bool ByrefLayout) {
// If it has an ownership qualifier, we're done.
if (auto lifetime = FQT.getObjCLifetime())
  return lifetime;

// If it doesn't, and this is ARC, it has no ownership.
if (CGM.getLangOpts().ObjCAutoRefCount)
  return Qualifiers::OCL_None;

// In MRC, retainable pointers are owned by non-__block variables.
if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
  return ByrefLayout ? Qualifiers::OCL_ExplicitNone : Qualifiers::OCL_Strong;

return Qualifiers::OCL_None;
2494}

2496void CGObjCCommonMac::UpdateRunSkipBlockVars(bool IsByref,
                                           Qualifiers::ObjCLifetime LifeTime,
                                           CharUnits FieldOffset,
                                           CharUnits FieldSize) {
// __block variables are passed by their descriptor address.
if (IsByref)
  RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_BYREF, FieldOffset,
                                      FieldSize));
else if (LifeTime == Qualifiers::OCL_Strong)
  RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_STRONG, FieldOffset,
                                      FieldSize));
else if (LifeTime == Qualifiers::OCL_Weak)
  RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_WEAK, FieldOffset,
                                      FieldSize));
else if (LifeTime == Qualifiers::OCL_ExplicitNone)
  RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_UNRETAINED, FieldOffset,
                                      FieldSize));
else
  RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_NON_OBJECT_BYTES,
                                      FieldOffset,
                                      FieldSize));
2517}

2519void CGObjCCommonMac::BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
                                        const RecordDecl *RD,
                                        ArrayRef<const FieldDecl*> RecFields,
                                        CharUnits BytePos, bool &HasUnion,
                                        bool ByrefLayout) {
bool IsUnion = (RD6.1
'RD' is non-null
1
'RD' is non-null
 && RD->isUnion());
CharUnits MaxUnionSize = CharUnits::Zero();
const FieldDecl *MaxField = nullptr;
const FieldDecl *LastFieldBitfieldOrUnnamed = nullptr;
CharUnits MaxFieldOffset = CharUnits::Zero();
CharUnits LastBitfieldOrUnnamedOffset = CharUnits::Zero();

if (RecFields.empty())
7
←
Assuming the condition is false→
8
←
Taking false branch→
  return;
unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();

for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
9
←
Assuming 'i' is not equal to 'e'→
10
←
Loop condition is true.  Entering loop body→
  const FieldDecl *Field = RecFields[i];
  // Note that 'i' here is actually the field index inside RD of Field,
  // although this dependency is hidden.
  const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
  CharUnits FieldOffset =
    CGM.getContext().toCharUnitsFromBits(RL.getFieldOffset(i));

  // Skip over unnamed or bitfields
  if (!Field->getIdentifier() || Field->isBitField()) {
11
←
Assuming the condition is false→
12
←
Assuming the condition is false→
13
←
Taking false branch→
    LastFieldBitfieldOrUnnamed = Field;
    LastBitfieldOrUnnamedOffset = FieldOffset;
    continue;
  }

  LastFieldBitfieldOrUnnamed = nullptr;
  QualType FQT = Field->getType();
  if (FQT->isRecordType() || FQT->isUnionType()) {
14
←
Calling 'Type::isRecordType'→
17
←
Returning from 'Type::isRecordType'→
    if (FQT->isUnionType())
18
←
Assuming the condition is false→
19
←
Taking false branch→
      HasUnion = true;

    BuildRCBlockVarRecordLayout(FQT->getAs<RecordType>(),
20
←
Assuming the object is not a 'RecordType'→
21
←
Passing null pointer value via 1st parameter 'RT'→
22
←
Calling 'CGObjCCommonMac::BuildRCBlockVarRecordLayout'→
                                BytePos + FieldOffset, HasUnion);
    continue;
  }

  if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
    auto *CArray = cast<ConstantArrayType>(Array);
    uint64_t ElCount = CArray->getSize().getZExtValue();
    assert(CArray && "only array with known element size is supported")((void)0);
    FQT = CArray->getElementType();
    while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
      auto *CArray = cast<ConstantArrayType>(Array);
      ElCount *= CArray->getSize().getZExtValue();
      FQT = CArray->getElementType();
    }
    if (FQT->isRecordType() && ElCount) {
      int OldIndex = RunSkipBlockVars.size() - 1;
      auto *RT = FQT->castAs<RecordType>();
      BuildRCBlockVarRecordLayout(RT, BytePos + FieldOffset, HasUnion);

      // Replicate layout information for each array element. Note that
      // one element is already done.
      uint64_t ElIx = 1;
      for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; ElIx++) {
        CharUnits Size = CGM.getContext().getTypeSizeInChars(RT);
        for (int i = OldIndex+1; i <= FirstIndex; ++i)
          RunSkipBlockVars.push_back(
            RUN_SKIP(RunSkipBlockVars[i].opcode,
            RunSkipBlockVars[i].block_var_bytepos + Size*ElIx,
            RunSkipBlockVars[i].block_var_size));
      }
      continue;
    }
  }
  CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType());
  if (IsUnion) {
    CharUnits UnionIvarSize = FieldSize;
    if (UnionIvarSize > MaxUnionSize) {
      MaxUnionSize = UnionIvarSize;
      MaxField = Field;
      MaxFieldOffset = FieldOffset;
    }
  } else {
    UpdateRunSkipBlockVars(false,
                           getBlockCaptureLifetime(FQT, ByrefLayout),
                           BytePos + FieldOffset,
                           FieldSize);
  }
}

if (LastFieldBitfieldOrUnnamed) {
  if (LastFieldBitfieldOrUnnamed->isBitField()) {
    // Last field was a bitfield. Must update the info.
    uint64_t BitFieldSize
      = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext());
    unsigned UnsSize = (BitFieldSize / ByteSizeInBits) +
                      ((BitFieldSize % ByteSizeInBits) != 0);
    CharUnits Size = CharUnits::fromQuantity(UnsSize);
    Size += LastBitfieldOrUnnamedOffset;
    UpdateRunSkipBlockVars(false,
                           getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
                                                   ByrefLayout),
                           BytePos + LastBitfieldOrUnnamedOffset,
                           Size);
  } else {
    assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed")((void)0);
    // Last field was unnamed. Must update skip info.
    CharUnits FieldSize
      = CGM.getContext().getTypeSizeInChars(LastFieldBitfieldOrUnnamed->getType());
    UpdateRunSkipBlockVars(false,
                           getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
                                                   ByrefLayout),
                           BytePos + LastBitfieldOrUnnamedOffset,
                           FieldSize);
  }
}

if (MaxField)
  UpdateRunSkipBlockVars(false,
                         getBlockCaptureLifetime(MaxField->getType(), ByrefLayout),
                         BytePos + MaxFieldOffset,
                         MaxUnionSize);
2638}

2640void CGObjCCommonMac::BuildRCBlockVarRecordLayout(const RecordType *RT,
                                                CharUnits BytePos,
                                                bool &HasUnion,
                                                bool ByrefLayout) {
const RecordDecl *RD = RT->getDecl();
23
←
Called C++ object pointer is null
SmallVector<const FieldDecl*, 16> Fields(RD->fields());
llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
const llvm::StructLayout *RecLayout =
  CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty));
5
←
'Ty' is a 'StructType'→

BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout);
6
←
Calling 'CGObjCCommonMac::BuildRCRecordLayout'→
2651}

2653/// InlineLayoutInstruction - This routine produce an inline instruction for the
2654/// block variable layout if it can. If not, it returns 0. Rules are as follow:
2655/// If ((uintptr_t) layout) < (1 << 12), the layout is inline. In the 64bit world,
2656/// an inline layout of value 0x0000000000000xyz is interpreted as follows:
2657/// x captured object pointers of BLOCK_LAYOUT_STRONG. Followed by
2658/// y captured object of BLOCK_LAYOUT_BYREF. Followed by
2659/// z captured object of BLOCK_LAYOUT_WEAK. If any of the above is missing, zero
2660/// replaces it. For example, 0x00000x00 means x BLOCK_LAYOUT_STRONG and no
2661/// BLOCK_LAYOUT_BYREF and no BLOCK_LAYOUT_WEAK objects are captured.
2662uint64_t CGObjCCommonMac::InlineLayoutInstruction(
                                  SmallVectorImpl<unsigned char> &Layout) {
uint64_t Result = 0;
if (Layout.size() <= 3) {
  unsigned size = Layout.size();
  unsigned strong_word_count = 0, byref_word_count=0, weak_word_count=0;
  unsigned char inst;
  enum BLOCK_LAYOUT_OPCODE opcode ;
  switch (size) {
    case 3:
      inst = Layout[0];
      opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
      if (opcode == BLOCK_LAYOUT_STRONG)
        strong_word_count = (inst & 0xF)+1;
      else
        return 0;
      inst = Layout[1];
      opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
      if (opcode == BLOCK_LAYOUT_BYREF)
        byref_word_count = (inst & 0xF)+1;
      else
        return 0;
      inst = Layout[2];
      opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
      if (opcode == BLOCK_LAYOUT_WEAK)
        weak_word_count = (inst & 0xF)+1;
      else
        return 0;
      break;

    case 2:
      inst = Layout[0];
      opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
      if (opcode == BLOCK_LAYOUT_STRONG) {
        strong_word_count = (inst & 0xF)+1;
        inst = Layout[1];
        opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
        if (opcode == BLOCK_LAYOUT_BYREF)
          byref_word_count = (inst & 0xF)+1;
        else if (opcode == BLOCK_LAYOUT_WEAK)
          weak_word_count = (inst & 0xF)+1;
        else
          return 0;
      }
      else if (opcode == BLOCK_LAYOUT_BYREF) {
        byref_word_count = (inst & 0xF)+1;
        inst = Layout[1];
        opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
        if (opcode == BLOCK_LAYOUT_WEAK)
          weak_word_count = (inst & 0xF)+1;
        else
          return 0;
      }
      else
        return 0;
      break;

    case 1:
      inst = Layout[0];
      opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
      if (opcode == BLOCK_LAYOUT_STRONG)
        strong_word_count = (inst & 0xF)+1;
      else if (opcode == BLOCK_LAYOUT_BYREF)
        byref_word_count = (inst & 0xF)+1;
      else if (opcode == BLOCK_LAYOUT_WEAK)
        weak_word_count = (inst & 0xF)+1;
      else
        return 0;
      break;

    default:
      return 0;
  }

  // Cannot inline when any of the word counts is 15. Because this is one less
  // than the actual work count (so 15 means 16 actual word counts),
  // and we can only display 0 thru 15 word counts.
  if (strong_word_count == 16 || byref_word_count == 16 || weak_word_count == 16)
    return 0;

  unsigned count =
    (strong_word_count != 0) + (byref_word_count != 0) + (weak_word_count != 0);

  if (size == count) {
    if (strong_word_count)
      Result = strong_word_count;
    Result <<= 4;
    if (byref_word_count)
      Result += byref_word_count;
    Result <<= 4;
    if (weak_word_count)
      Result += weak_word_count;
  }
}
return Result;
2757}

2759llvm::Constant *CGObjCCommonMac::getBitmapBlockLayout(bool ComputeByrefLayout) {
llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
if (RunSkipBlockVars.empty())
  return nullPtr;
unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;

// Sort on byte position; captures might not be allocated in order,
// and unions can do funny things.
llvm::array_pod_sort(RunSkipBlockVars.begin(), RunSkipBlockVars.end());
SmallVector<unsigned char, 16> Layout;

unsigned size = RunSkipBlockVars.size();
for (unsigned i = 0; i < size; i++) {
  enum BLOCK_LAYOUT_OPCODE opcode = RunSkipBlockVars[i].opcode;
  CharUnits start_byte_pos = RunSkipBlockVars[i].block_var_bytepos;
  CharUnits end_byte_pos = start_byte_pos;
  unsigned j = i+1;
  while (j < size) {
    if (opcode == RunSkipBlockVars[j].opcode) {
      end_byte_pos = RunSkipBlockVars[j++].block_var_bytepos;
      i++;
    }
    else
      break;
  }
  CharUnits size_in_bytes =
  end_byte_pos - start_byte_pos + RunSkipBlockVars[j-1].block_var_size;
  if (j < size) {
    CharUnits gap =
    RunSkipBlockVars[j].block_var_bytepos -
    RunSkipBlockVars[j-1].block_var_bytepos - RunSkipBlockVars[j-1].block_var_size;
    size_in_bytes += gap;
  }
  CharUnits residue_in_bytes = CharUnits::Zero();
  if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES) {
    residue_in_bytes = size_in_bytes % WordSizeInBytes;
    size_in_bytes -= residue_in_bytes;
    opcode = BLOCK_LAYOUT_NON_OBJECT_WORDS;
  }

  unsigned size_in_words = size_in_bytes.getQuantity() / WordSizeInBytes;
  while (size_in_words >= 16) {
    // Note that value in imm. is one less that the actual
    // value. So, 0xf means 16 words follow!
    unsigned char inst = (opcode << 4) | 0xf;
    Layout.push_back(inst);
    size_in_words -= 16;
  }
  if (size_in_words > 0) {
    // Note that value in imm. is one less that the actual
    // value. So, we subtract 1 away!
    unsigned char inst = (opcode << 4) | (size_in_words-1);
    Layout.push_back(inst);
  }
  if (residue_in_bytes > CharUnits::Zero()) {
    unsigned char inst =
    (BLOCK_LAYOUT_NON_OBJECT_BYTES << 4) | (residue_in_bytes.getQuantity()-1);
    Layout.push_back(inst);
  }
}

while (!Layout.empty()) {
  unsigned char inst = Layout.back();
  enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
  if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES || opcode == BLOCK_LAYOUT_NON_OBJECT_WORDS)
    Layout.pop_back();
  else
    break;
}

uint64_t Result = InlineLayoutInstruction(Layout);
if (Result != 0) {
  // Block variable layout instruction has been inlined.
  if (CGM.getLangOpts().ObjCGCBitmapPrint) {
    if (ComputeByrefLayout)
      printf("\n Inline BYREF variable layout: ");
    else
      printf("\n Inline block variable layout: ");
    printf("0x0%" PRIx64"llx" "", Result);
    if (auto numStrong = (Result & 0xF00) >> 8)
      printf(", BL_STRONG:%d", (int) numStrong);
    if (auto numByref = (Result & 0x0F0) >> 4)
      printf(", BL_BYREF:%d", (int) numByref);
    if (auto numWeak = (Result & 0x00F) >> 0)
      printf(", BL_WEAK:%d", (int) numWeak);
    printf(", BL_OPERATOR:0\n");
  }
  return llvm::ConstantInt::get(CGM.IntPtrTy, Result);
}

unsigned char inst = (BLOCK_LAYOUT_OPERATOR << 4) | 0;
Layout.push_back(inst);
std::string BitMap;
for (unsigned i = 0, e = Layout.size(); i != e; i++)
  BitMap += Layout[i];

if (CGM.getLangOpts().ObjCGCBitmapPrint) {
  if (ComputeByrefLayout)
    printf("\n Byref variable layout: ");
  else
    printf("\n Block variable layout: ");
  for (unsigned i = 0, e = BitMap.size(); i != e; i++) {
    unsigned char inst = BitMap[i];
    enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
    unsigned delta = 1;
    switch (opcode) {
      case BLOCK_LAYOUT_OPERATOR:
        printf("BL_OPERATOR:");
        delta = 0;
        break;
      case BLOCK_LAYOUT_NON_OBJECT_BYTES:
        printf("BL_NON_OBJECT_BYTES:");
        break;
      case BLOCK_LAYOUT_NON_OBJECT_WORDS:
        printf("BL_NON_OBJECT_WORD:");
        break;
      case BLOCK_LAYOUT_STRONG:
        printf("BL_STRONG:");
        break;
      case BLOCK_LAYOUT_BYREF:
        printf("BL_BYREF:");
        break;
      case BLOCK_LAYOUT_WEAK:
        printf("BL_WEAK:");
        break;
      case BLOCK_LAYOUT_UNRETAINED:
        printf("BL_UNRETAINED:");
        break;
    }
    // Actual value of word count is one more that what is in the imm.
    // field of the instruction
    printf("%d", (inst & 0xf) + delta);
    if (i < e-1)
      printf(", ");
    else
      printf("\n");
  }
}

auto *Entry = CreateCStringLiteral(BitMap, ObjCLabelType::ClassName,
                                   /*ForceNonFragileABI=*/true,
                                   /*NullTerminate=*/false);
return getConstantGEP(VMContext, Entry, 0, 0);
2904}

2906static std::string getBlockLayoutInfoString(
  const SmallVectorImpl<CGObjCCommonMac::RUN_SKIP> &RunSkipBlockVars,
  bool HasCopyDisposeHelpers) {
std::string Str;
for (const CGObjCCommonMac::RUN_SKIP &R : RunSkipBlockVars) {
  if (R.opcode == CGObjCCommonMac::BLOCK_LAYOUT_UNRETAINED) {
    // Copy/dispose helpers don't have any information about
    // __unsafe_unretained captures, so unconditionally concatenate a string.
    Str += "u";
  } else if (HasCopyDisposeHelpers) {
    // Information about __strong, __weak, or byref captures has already been
    // encoded into the names of the copy/dispose helpers. We have to add a
    // string here only when the copy/dispose helpers aren't generated (which
    // happens when the block is non-escaping).
    continue;
  } else {
    switch (R.opcode) {
    case CGObjCCommonMac::BLOCK_LAYOUT_STRONG:
      Str += "s";
      break;
    case CGObjCCommonMac::BLOCK_LAYOUT_BYREF:
      Str += "r";
      break;
    case CGObjCCommonMac::BLOCK_LAYOUT_WEAK:
      Str += "w";
      break;
    default:
      continue;
    }
  }
  Str += llvm::to_string(R.block_var_bytepos.getQuantity());
  Str += "l" + llvm::to_string(R.block_var_size.getQuantity());
}
return Str;
2940}

2942void CGObjCCommonMac::fillRunSkipBlockVars(CodeGenModule &CGM,
                                         const CGBlockInfo &blockInfo) {
assert(CGM.getLangOpts().getGC() == LangOptions::NonGC)((void)0);

RunSkipBlockVars.clear();
bool hasUnion = false;

unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;

const BlockDecl *blockDecl = blockInfo.getBlockDecl();

// Calculate the basic layout of the block structure.
const llvm::StructLayout *layout =
CGM.getDataLayout().getStructLayout(blockInfo.StructureType);

// Ignore the optional 'this' capture: C++ objects are not assumed
// to be GC'ed.
if (blockInfo.BlockHeaderForcedGapSize != CharUnits::Zero())
  UpdateRunSkipBlockVars(false, Qualifiers::OCL_None,
                         blockInfo.BlockHeaderForcedGapOffset,
                         blockInfo.BlockHeaderForcedGapSize);
// Walk the captured variables.
for (const auto &CI : blockDecl->captures()) {
  const VarDecl *variable = CI.getVariable();
  QualType type = variable->getType();

  const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);

  // Ignore constant captures.
  if (capture.isConstant()) continue;

  CharUnits fieldOffset =
     CharUnits::fromQuantity(layout->getElementOffset(capture.getIndex()));

  assert(!type->isArrayType() && "array variable should not be caught")((void)0);
  if (!CI.isByRef())
    if (const RecordType *record = type->getAs<RecordType>()) {
      BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion);
      continue;
    }
  CharUnits fieldSize;
  if (CI.isByRef())
    fieldSize = CharUnits::fromQuantity(WordSizeInBytes);
  else
    fieldSize = CGM.getContext().getTypeSizeInChars(type);
  UpdateRunSkipBlockVars(CI.isByRef(), getBlockCaptureLifetime(type, false),
                         fieldOffset, fieldSize);
}
2992}

2994llvm::Constant *
2995CGObjCCommonMac::BuildRCBlockLayout(CodeGenModule &CGM,
                                  const CGBlockInfo &blockInfo) {
fillRunSkipBlockVars(CGM, blockInfo);
return getBitmapBlockLayout(false);
2999}

3001std::string CGObjCCommonMac::getRCBlockLayoutStr(CodeGenModule &CGM,
                                               const CGBlockInfo &blockInfo) {
fillRunSkipBlockVars(CGM, blockInfo);
return getBlockLayoutInfoString(RunSkipBlockVars,
                                blockInfo.needsCopyDisposeHelpers());
3006}

3008llvm::Constant *CGObjCCommonMac::BuildByrefLayout(CodeGen::CodeGenModule &CGM,
                                                QualType T) {
assert(CGM.getLangOpts().getGC() == LangOptions::NonGC)((void)0);
assert(!T->isArrayType() && "__block array variable should not be caught")((void)0);
CharUnits fieldOffset;
RunSkipBlockVars.clear();
bool hasUnion = false;
if (const RecordType *record = T->getAs<RecordType>()) {
1
Assuming the object is a 'RecordType'→
2
←
Assuming 'record' is non-null→
3
←
Taking true branch→
  BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, true /*ByrefLayout */);
4
←
Calling 'CGObjCCommonMac::BuildRCBlockVarRecordLayout'→
  llvm::Constant *Result = getBitmapBlockLayout(true);
  if (isa<llvm::ConstantInt>(Result))
    Result = llvm::ConstantExpr::getIntToPtr(Result, CGM.Int8PtrTy);
  return Result;
}
llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
return nullPtr;
3024}

3026llvm::Value *CGObjCMac::GenerateProtocolRef(CodeGenFunction &CGF,
                                          const ObjCProtocolDecl *PD) {
// FIXME: I don't understand why gcc generates this, or where it is
// resolved. Investigate. Its also wasteful to look this up over and over.
LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));

return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD),
                                      ObjCTypes.getExternalProtocolPtrTy());
3034}

3036void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) {
// FIXME: We shouldn't need this, the protocol decl should contain enough
// information to tell us whether this was a declaration or a definition.
DefinedProtocols.insert(PD->getIdentifier());

// If we have generated a forward reference to this protocol, emit
// it now. Otherwise do nothing, the protocol objects are lazily
// emitted.
if (Protocols.count(PD->getIdentifier()))
  GetOrEmitProtocol(PD);
3046}

3048llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
if (DefinedProtocols.count(PD->getIdentifier()))
  return GetOrEmitProtocol(PD);

return GetOrEmitProtocolRef(PD);
3053}

3055llvm::Value *CGObjCCommonMac::EmitClassRefViaRuntime(
             CodeGenFunction &CGF,
             const ObjCInterfaceDecl *ID,
             ObjCCommonTypesHelper &ObjCTypes) {
llvm::FunctionCallee lookUpClassFn = ObjCTypes.getLookUpClassFn();

llvm::Value *className = CGF.CGM
                             .GetAddrOfConstantCString(std::string(
                                 ID->getObjCRuntimeNameAsString()))
                             .getPointer();
ASTContext &ctx = CGF.CGM.getContext();
className =
    CGF.Builder.CreateBitCast(className,
                              CGF.ConvertType(
                                ctx.getPointerType(ctx.CharTy.withConst())));
llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className);
call->setDoesNotThrow();
return call;
3073}

3075/*
3076// Objective-C 1.0 extensions
3077struct _objc_protocol {
3078struct _objc_protocol_extension *isa;
3079char *protocol_name;
3080struct _objc_protocol_list *protocol_list;
3081struct _objc__method_prototype_list *instance_methods;
3082struct _objc__method_prototype_list *class_methods
3083};

3085See EmitProtocolExtension().
3086*/
3087llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];

// Early exit if a defining object has already been generated.
if (Entry && Entry->hasInitializer())
  return Entry;

// Use the protocol definition, if there is one.
if (const ObjCProtocolDecl *Def = PD->getDefinition())
  PD = Def;

// FIXME: I don't understand why gcc generates this, or where it is
// resolved. Investigate. Its also wasteful to look this up over and over.
LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));

// Construct method lists.
auto methodLists = ProtocolMethodLists::get(PD);

ConstantInitBuilder builder(CGM);
auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
values.add(EmitProtocolExtension(PD, methodLists));
values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
values.add(EmitProtocolList("OBJC_PROTOCOL_REFS_" + PD->getName(),
                            PD->protocol_begin(), PD->protocol_end()));
values.add(methodLists.emitMethodList(this, PD,
                            ProtocolMethodLists::RequiredInstanceMethods));
values.add(methodLists.emitMethodList(this, PD,
                            ProtocolMethodLists::RequiredClassMethods));

if (Entry) {
  // Already created, update the initializer.
  assert(Entry->hasPrivateLinkage())((void)0);
  values.finishAndSetAsInitializer(Entry);
} else {
  Entry = values.finishAndCreateGlobal("OBJC_PROTOCOL_" + PD->getName(),
                                       CGM.getPointerAlign(),
                                       /*constant*/ false,
                                       llvm::GlobalValue::PrivateLinkage);
  Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");

  Protocols[PD->getIdentifier()] = Entry;
}
CGM.addCompilerUsedGlobal(Entry);

return Entry;
3132}

3134llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) {
llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];

if (!Entry) {
  // We use the initializer as a marker of whether this is a forward
  // reference or not. At module finalization we add the empty
  // contents for protocols which were referenced but never defined.
  Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy,
                                   false, llvm::GlobalValue::PrivateLinkage,
                                   nullptr, "OBJC_PROTOCOL_" + PD->getName());
  Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
  // FIXME: Is this necessary? Why only for protocol?
  Entry->setAlignment(llvm::Align(4));
}

return Entry;
3150}

3152/*
struct _objc_protocol_extension {
uint32_t size;
struct objc_method_description_list *optional_instance_methods;
struct objc_method_description_list *optional_class_methods;
struct objc_property_list *instance_properties;
const char ** extendedMethodTypes;
struct objc_property_list *class_properties;
};
3161*/
3162llvm::Constant *
3163CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
                               const ProtocolMethodLists &methodLists) {
auto optInstanceMethods =
  methodLists.emitMethodList(this, PD,
                             ProtocolMethodLists::OptionalInstanceMethods);
auto optClassMethods =
  methodLists.emitMethodList(this, PD,
                             ProtocolMethodLists::OptionalClassMethods);

auto extendedMethodTypes =
  EmitProtocolMethodTypes("OBJC_PROTOCOL_METHOD_TYPES_" + PD->getName(),
                          methodLists.emitExtendedTypesArray(this),
                          ObjCTypes);

auto instanceProperties =
  EmitPropertyList("OBJC_$_PROP_PROTO_LIST_" + PD->getName(), nullptr, PD,
                   ObjCTypes, false);
auto classProperties =
  EmitPropertyList("OBJC_$_CLASS_PROP_PROTO_LIST_" + PD->getName(), nullptr,
                   PD, ObjCTypes, true);

// Return null if no extension bits are used.
if (optInstanceMethods->isNullValue() &&
    optClassMethods->isNullValue() &&
    extendedMethodTypes->isNullValue() &&
    instanceProperties->isNullValue() &&
    classProperties->isNullValue()) {
  return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
}

uint64_t size =
  CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy);

ConstantInitBuilder builder(CGM);
auto values = builder.beginStruct(ObjCTypes.ProtocolExtensionTy);
values.addInt(ObjCTypes.IntTy, size);
values.add(optInstanceMethods);
values.add(optClassMethods);
values.add(instanceProperties);
values.add(extendedMethodTypes);
values.add(classProperties);

// No special section, but goes in llvm.used
return CreateMetadataVar("_OBJC_PROTOCOLEXT_" + PD->getName(), values,
                         StringRef(), CGM.getPointerAlign(), true);
3208}

3210/*
struct objc_protocol_list {
  struct objc_protocol_list *next;
  long count;
  Protocol *list[];
};
3216*/
3217llvm::Constant *
3218CGObjCMac::EmitProtocolList(Twine name,
                          ObjCProtocolDecl::protocol_iterator begin,
                          ObjCProtocolDecl::protocol_iterator end) {
// Just return null for empty protocol lists
auto PDs = GetRuntimeProtocolList(begin, end);
if (PDs.empty())
  return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);

ConstantInitBuilder builder(CGM);
auto values = builder.beginStruct();

// This field is only used by the runtime.
values.addNullPointer(ObjCTypes.ProtocolListPtrTy);

// Reserve a slot for the count.
auto countSlot = values.addPlaceholder();

auto refsArray = values.beginArray(ObjCTypes.ProtocolPtrTy);
for (const auto *Proto : PDs)
  refsArray.add(GetProtocolRef(Proto));

auto count = refsArray.size();

// This list is null terminated.
refsArray.addNullPointer(ObjCTypes.ProtocolPtrTy);

refsArray.finishAndAddTo(values);
values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);

StringRef section;
if (CGM.getTriple().isOSBinFormatMachO())
  section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";

llvm::GlobalVariable *GV =
    CreateMetadataVar(name, values, section, CGM.getPointerAlign(), false);
return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
3254}

3256static void
3257PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*,16> &PropertySet,
                     SmallVectorImpl<const ObjCPropertyDecl *> &Properties,
                     const ObjCProtocolDecl *Proto,
                     bool IsClassProperty) {
for (const auto *PD : Proto->properties()) {
  if (IsClassProperty != PD->isClassProperty())
    continue;
  if (!PropertySet.insert(PD->getIdentifier()).second)
    continue;
  Properties.push_back(PD);
}

for (const auto *P : Proto->protocols())
  PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3271}

3273/*
struct _objc_property {
  const char * const name;
  const char * const attributes;
};

struct _objc_property_list {
  uint32_t entsize; // sizeof (struct _objc_property)
  uint32_t prop_count;
  struct _objc_property[prop_count];
};
3284*/
3285llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name,
                                     const Decl *Container,
                                     const ObjCContainerDecl *OCD,
                                     const ObjCCommonTypesHelper &ObjCTypes,
                                     bool IsClassProperty) {
if (IsClassProperty) {
  // Make this entry NULL for OS X with deployment target < 10.11, for iOS
  // with deployment target < 9.0.
  const llvm::Triple &Triple = CGM.getTarget().getTriple();
  if ((Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 11)) ||
      (Triple.isiOS() && Triple.isOSVersionLT(9)))
    return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
}

SmallVector<const ObjCPropertyDecl *, 16> Properties;
llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;

if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
  for (const ObjCCategoryDecl *ClassExt : OID->known_extensions())
    for (auto *PD : ClassExt->properties()) {
      if (IsClassProperty != PD->isClassProperty())
        continue;
      if (PD->isDirectProperty())
        continue;
      PropertySet.insert(PD->getIdentifier());
      Properties.push_back(PD);
    }

for (const auto *PD : OCD->properties()) {
  if (IsClassProperty != PD->isClassProperty())
    continue;
  // Don't emit duplicate metadata for properties that were already in a
  // class extension.
  if (!PropertySet.insert(PD->getIdentifier()).second)
    continue;
  if (PD->isDirectProperty())
    continue;
  Properties.push_back(PD);
}

if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) {
  for (const auto *P : OID->all_referenced_protocols())
    PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
}
else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) {
  for (const auto *P : CD->protocols())
    PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
}

// Return null for empty list.
if (Properties.empty())
  return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);

unsigned propertySize =
  CGM.getDataLayout().getTypeAllocSize(ObjCTypes.PropertyTy);

ConstantInitBuilder builder(CGM);
auto values = builder.beginStruct();
values.addInt(ObjCTypes.IntTy, propertySize);
values.addInt(ObjCTypes.IntTy, Properties.size());
auto propertiesArray = values.beginArray(ObjCTypes.PropertyTy);
for (auto PD : Properties) {
  auto property = propertiesArray.beginStruct(ObjCTypes.PropertyTy);
  property.add(GetPropertyName(PD->getIdentifier()));
  property.add(GetPropertyTypeString(PD, Container));
  property.finishAndAddTo(propertiesArray);
}
propertiesArray.finishAndAddTo(values);

StringRef Section;
if (CGM.getTriple().isOSBinFormatMachO())
  Section = (ObjCABI == 2) ? "__DATA, __objc_const"
                           : "__OBJC,__property,regular,no_dead_strip";

llvm::GlobalVariable *GV =
    CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy);
3362}

3364llvm::Constant *
3365CGObjCCommonMac::EmitProtocolMethodTypes(Twine Name,
                                       ArrayRef<llvm::Constant*> MethodTypes,
                                       const ObjCCommonTypesHelper &ObjCTypes) {
// Return null for empty list.
if (MethodTypes.empty())
  return llvm::Constant::getNullValue(ObjCTypes.Int8PtrPtrTy);

llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
                                           MethodTypes.size());
llvm::Constant *Init = llvm::ConstantArray::get(AT, MethodTypes);

StringRef Section;
if (CGM.getTriple().isOSBinFormatMachO() && ObjCABI == 2)
  Section = "__DATA, __objc_const";

llvm::GlobalVariable *GV =
    CreateMetadataVar(Name, Init, Section, CGM.getPointerAlign(), true);
return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.Int8PtrPtrTy);
3383}

3385/*
struct _objc_category {
char *category_name;
char *class_name;
struct _objc_method_list *instance_methods;
struct _objc_method_list *class_methods;
struct _objc_protocol_list *protocols;
uint32_t size; // <rdar://4585769>
struct _objc_property_list *instance_properties;
struct _objc_property_list *class_properties;
};
3396*/
3397void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategoryTy);

// FIXME: This is poor design, the OCD should have a pointer to the category
// decl. Additionally, note that Category can be null for the @implementation
// w/o an @interface case. Sema should just create one for us as it does for
// @implementation so everyone else can live life under a clear blue sky.
const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
const ObjCCategoryDecl *Category =
  Interface->FindCategoryDeclaration(OCD->getIdentifier());

SmallString<256> ExtName;
llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_'
                                   << OCD->getName();

ConstantInitBuilder Builder(CGM);
auto Values = Builder.beginStruct(ObjCTypes.CategoryTy);

enum {
  InstanceMethods,
  ClassMethods,
  NumMethodLists
};
SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
for (const auto *MD : OCD->methods()) {
  if (!MD->isDirectMethod())
    Methods[unsigned(MD->isClassMethod())].push_back(MD);
}

Values.add(GetClassName(OCD->getName()));
Values.add(GetClassName(Interface->getObjCRuntimeNameAsString()));
LazySymbols.insert(Interface->getIdentifier());

Values.add(emitMethodList(ExtName, MethodListType::CategoryInstanceMethods,
                          Methods[InstanceMethods]));
Values.add(emitMethodList(ExtName, MethodListType::CategoryClassMethods,
                          Methods[ClassMethods]));
if (Category) {
  Values.add(
      EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
                       Category->protocol_begin(), Category->protocol_end()));
} else {
  Values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
}
Values.addInt(ObjCTypes.IntTy, Size);

// If there is no category @interface then there can be no properties.
if (Category) {
  Values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(),
                              OCD, Category, ObjCTypes, false));
  Values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
                              OCD, Category, ObjCTypes, true));
} else {
  Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
  Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
}

llvm::GlobalVariable *GV =
    CreateMetadataVar("OBJC_CATEGORY_" + ExtName.str(), Values,
                      "__OBJC,__category,regular,no_dead_strip",
                      CGM.getPointerAlign(), true);
DefinedCategories.push_back(GV);
DefinedCategoryNames.insert(llvm::CachedHashString(ExtName));
// method definition entries must be clear for next implementation.
MethodDefinitions.clear();
3462}

3464enum FragileClassFlags {
/// Apparently: is not a meta-class.
FragileABI_Class_Factory                 = 0x00001,

/// Is a meta-class.
FragileABI_Class_Meta                    = 0x00002,

/// Has a non-trivial constructor or destructor.
FragileABI_Class_HasCXXStructors         = 0x02000,

/// Has hidden visibility.
FragileABI_Class_Hidden                  = 0x20000,

/// Class implementation was compiled under ARC.
FragileABI_Class_CompiledByARC           = 0x04000000,

/// Class implementation was compiled under MRC and has MRC weak ivars.
/// Exclusive with CompiledByARC.
FragileABI_Class_HasMRCWeakIvars         = 0x08000000,
3483};

3485enum NonFragileClassFlags {
/// Is a meta-class.
NonFragileABI_Class_Meta                 = 0x00001,

/// Is a root class.
NonFragileABI_Class_Root                 = 0x00002,

/// Has a non-trivial constructor or destructor.
NonFragileABI_Class_HasCXXStructors      = 0x00004,

/// Has hidden visibility.
NonFragileABI_Class_Hidden               = 0x00010,

/// Has the exception attribute.
NonFragileABI_Class_Exception            = 0x00020,

/// (Obsolete) ARC-specific: this class has a .release_ivars method
NonFragileABI_Class_HasIvarReleaser      = 0x00040,

/// Class implementation was compiled under ARC.
NonFragileABI_Class_CompiledByARC        = 0x00080,

/// Class has non-trivial destructors, but zero-initialization is okay.
NonFragileABI_Class_HasCXXDestructorOnly = 0x00100,

/// Class implementation was compiled under MRC and has MRC weak ivars.
/// Exclusive with CompiledByARC.
NonFragileABI_Class_HasMRCWeakIvars      = 0x00200,
3513};

3515static bool hasWeakMember(QualType type) {
if (type.getObjCLifetime() == Qualifiers::OCL_Weak) {
  return true;
}

if (auto recType = type->getAs<RecordType>()) {
  for (auto field : recType->getDecl()->fields()) {
    if (hasWeakMember(field->getType()))
      return true;
  }
}

return false;
3528}

3530/// For compatibility, we only want to set the "HasMRCWeakIvars" flag
3531/// (and actually fill in a layout string) if we really do have any
3532/// __weak ivars.
3533static bool hasMRCWeakIvars(CodeGenModule &CGM,
                          const ObjCImplementationDecl *ID) {
if (!CGM.getLangOpts().ObjCWeak) return false;
assert(CGM.getLangOpts().getGC() == LangOptions::NonGC)((void)0);

for (const ObjCIvarDecl *ivar =
       ID->getClassInterface()->all_declared_ivar_begin();
     ivar; ivar = ivar->getNextIvar()) {
  if (hasWeakMember(ivar->getType()))
    return true;
}

return false;
3546}

3548/*
struct _objc_class {
Class isa;
Class super_class;
const char *name;
long version;
long info;
long instance_size;
struct _objc_ivar_list *ivars;
struct _objc_method_list *methods;
struct _objc_cache *cache;
struct _objc_protocol_list *protocols;
// Objective-C 1.0 extensions (<rdr://4585769>)
const char *ivar_layout;
struct _objc_class_ext *ext;
};

See EmitClassExtension();
3566*/
3567void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
IdentifierInfo *RuntimeName =
    &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
DefinedSymbols.insert(RuntimeName);

std::string ClassName = ID->getNameAsString();
// FIXME: Gross
ObjCInterfaceDecl *Interface =
  const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
llvm::Constant *Protocols =
    EmitProtocolList("OBJC_CLASS_PROTOCOLS_" + ID->getName(),
                     Interface->all_referenced_protocol_begin(),
                     Interface->all_referenced_protocol_end());
unsigned Flags = FragileABI_Class_Factory;
if (ID->hasNonZeroConstructors() || ID->hasDestructors())
  Flags |= FragileABI_Class_HasCXXStructors;

bool hasMRCWeak = false;

if (CGM.getLangOpts().ObjCAutoRefCount)
  Flags |= FragileABI_Class_CompiledByARC;
else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
  Flags |= FragileABI_Class_HasMRCWeakIvars;

CharUnits Size =
  CGM.getContext().getASTObjCImplementationLayout(ID).getSize();

// FIXME: Set CXX-structors flag.
if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
  Flags |= FragileABI_Class_Hidden;

enum {
  InstanceMethods,
  ClassMethods,
  NumMethodLists
};
SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
for (const auto *MD : ID->methods()) {
  if (!MD->isDirectMethod())
    Methods[unsigned(MD->isClassMethod())].push_back(MD);
}

for (const auto *PID : ID->property_impls()) {
  if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
    if (PID->getPropertyDecl()->isDirectProperty())
      continue;
    if (ObjCMethodDecl *MD = PID->getGetterMethodDecl())
      if (GetMethodDefinition(MD))
        Methods[InstanceMethods].push_back(MD);
    if (ObjCMethodDecl *MD = PID->getSetterMethodDecl())
      if (GetMethodDefinition(MD))
        Methods[InstanceMethods].push_back(MD);
  }
}

ConstantInitBuilder builder(CGM);
auto values = builder.beginStruct(ObjCTypes.ClassTy);
values.add(EmitMetaClass(ID, Protocols, Methods[ClassMethods]));
if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
  // Record a reference to the super class.
  LazySymbols.insert(Super->getIdentifier());

  values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
                    ObjCTypes.ClassPtrTy);
} else {
  values.addNullPointer(ObjCTypes.ClassPtrTy);
}
values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
// Version is always 0.
values.addInt(ObjCTypes.LongTy, 0);
values.addInt(ObjCTypes.LongTy, Flags);
values.addInt(ObjCTypes.LongTy, Size.getQuantity());
values.add(EmitIvarList(ID, false));
values.add(emitMethodList(ID->getName(), MethodListType::InstanceMethods,
                          Methods[InstanceMethods]));
// cache is always NULL.
values.addNullPointer(ObjCTypes.CachePtrTy);
values.add(Protocols);
values.add(BuildStrongIvarLayout(ID, CharUnits::Zero(), Size));
values.add(EmitClassExtension(ID, Size, hasMRCWeak,
                              /*isMetaclass*/ false));

std::string Name("OBJC_CLASS_");
Name += ClassName;
const char *Section = "__OBJC,__class,regular,no_dead_strip";
// Check for a forward reference.
llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
if (GV) {
  assert(GV->getValueType() == ObjCTypes.ClassTy &&((void)0)
         "Forward metaclass reference has incorrect type.")((void)0);
  values.finishAndSetAsInitializer(GV);
  GV->setSection(Section);
  GV->setAlignment(CGM.getPointerAlign().getAsAlign());
  CGM.addCompilerUsedGlobal(GV);
} else
  GV = CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
DefinedClasses.push_back(GV);
ImplementedClasses.push_back(Interface);
// method definition entries must be clear for next implementation.
MethodDefinitions.clear();
3667}

3669llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
                                       llvm::Constant *Protocols,
                              ArrayRef<const ObjCMethodDecl*> Methods) {
unsigned Flags = FragileABI_Class_Meta;
unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassTy);

if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
  Flags |= FragileABI_Class_Hidden;

ConstantInitBuilder builder(CGM);
auto values = builder.beginStruct(ObjCTypes.ClassTy);
// The isa for the metaclass is the root of the hierarchy.
const ObjCInterfaceDecl *Root = ID->getClassInterface();
while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
  Root = Super;
values.addBitCast(GetClassName(Root->getObjCRuntimeNameAsString()),
                  ObjCTypes.ClassPtrTy);
// The super class for the metaclass is emitted as the name of the
// super class. The runtime fixes this up to point to the
// *metaclass* for the super class.
if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
  values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
                    ObjCTypes.ClassPtrTy);
} else {
  values.addNullPointer(ObjCTypes.ClassPtrTy);
}
values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
// Version is always 0.
values.addInt(ObjCTypes.LongTy, 0);
values.addInt(ObjCTypes.LongTy, Flags);
values.addInt(ObjCTypes.LongTy, Size);
values.add(EmitIvarList(ID, true));
values.add(emitMethodList(ID->getName(), MethodListType::ClassMethods,
                          Methods));
// cache is always NULL.
values.addNullPointer(ObjCTypes.CachePtrTy);
values.add(Protocols);
// ivar_layout for metaclass is always NULL.
values.addNullPointer(ObjCTypes.Int8PtrTy);
// The class extension is used to store class properties for metaclasses.
values.add(EmitClassExtension(ID, CharUnits::Zero(), false/*hasMRCWeak*/,
                              /*isMetaclass*/true));

std::string Name("OBJC_METACLASS_");
Name += ID->getName();

// Check for a forward reference.
llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
if (GV) {
  assert(GV->getValueType() == ObjCTypes.ClassTy &&((void)0)
         "Forward metaclass reference has incorrect type.")((void)0);
  values.finishAndSetAsInitializer(GV);
} else {
  GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
                                    /*constant*/ false,
                                    llvm::GlobalValue::PrivateLinkage);
}
GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
CGM.addCompilerUsedGlobal(GV);

return GV;
3730}

3732llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
std::string Name = "OBJC_METACLASS_" + ID->getNameAsString();

// FIXME: Should we look these up somewhere other than the module. Its a bit
// silly since we only generate these while processing an implementation, so
// exactly one pointer would work if know when we entered/exitted an
// implementation block.

// Check for an existing forward reference.
// Previously, metaclass with internal linkage may have been defined.
// pass 'true' as 2nd argument so it is returned.
llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
if (!GV)
  GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
                                llvm::GlobalValue::PrivateLinkage, nullptr,
                                Name);

assert(GV->getValueType() == ObjCTypes.ClassTy &&((void)0)
       "Forward metaclass reference has incorrect type.")((void)0);
return GV;
3752}

3754llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) {
std::string Name = "OBJC_CLASS_" + ID->getNameAsString();
llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);

if (!GV)
  GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
                                llvm::GlobalValue::PrivateLinkage, nullptr,
                                Name);

assert(GV->getValueType() == ObjCTypes.ClassTy &&((void)0)
       "Forward class metadata reference has incorrect type.")((void)0);
return GV;
3766}

3768/*
Emit a "class extension", which in this specific context means extra
data that doesn't fit in the normal fragile-ABI class structure, and
has nothing to do with the language concept of a class extension.

struct objc_class_ext {
uint32_t size;
const char *weak_ivar_layout;
struct _objc_property_list *properties;
};
3778*/
3779llvm::Constant *
3780CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID,
                            CharUnits InstanceSize, bool hasMRCWeakIvars,
                            bool isMetaclass) {
// Weak ivar layout.
llvm::Constant *layout;
if (isMetaclass) {
  layout = llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
} else {
  layout = BuildWeakIvarLayout(ID, CharUnits::Zero(), InstanceSize,
                               hasMRCWeakIvars);
}

// Properties.
llvm::Constant *propertyList =
  EmitPropertyList((isMetaclass ? Twine("_OBJC_$_CLASS_PROP_LIST_")
                                : Twine("_OBJC_$_PROP_LIST_"))
                      + ID->getName(),
                   ID, ID->getClassInterface(), ObjCTypes, isMetaclass);

// Return null if no extension bits are used.
if (layout->isNullValue() && propertyList->isNullValue()) {
  return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
}

uint64_t size =
  CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassExtensionTy);

ConstantInitBuilder builder(CGM);
auto values = builder.beginStruct(ObjCTypes.ClassExtensionTy);
values.addInt(ObjCTypes.IntTy, size);
values.add(layout);
values.add(propertyList);

return CreateMetadataVar("OBJC_CLASSEXT_" + ID->getName(), values,
                         "__OBJC,__class_ext,regular,no_dead_strip",
                         CGM.getPointerAlign(), true);
3816}

3818/*
struct objc_ivar {
  char *ivar_name;
  char *ivar_type;
  int ivar_offset;
};

struct objc_ivar_list {
  int ivar_count;
  struct objc_ivar list[count];
};
3829*/
3830llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
                                      bool ForClass) {
// When emitting the root class GCC emits ivar entries for the
// actual class structure. It is not clear if we need to follow this
// behavior; for now lets try and get away with not doing it. If so,
// the cleanest solution would be to make up an ObjCInterfaceDecl
// for the class.
if (ForClass)
  return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);

const ObjCInterfaceDecl *OID = ID->getClassInterface();

ConstantInitBuilder builder(CGM);
auto ivarList = builder.beginStruct();
auto countSlot = ivarList.addPlaceholder();
auto ivars = ivarList.beginArray(ObjCTypes.IvarTy);

for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
     IVD; IVD = IVD->getNextIvar()) {
  // Ignore unnamed bit-fields.
  if (!IVD->getDeclName())
    continue;

  auto ivar = ivars.beginStruct(ObjCTypes.IvarTy);
  ivar.add(GetMethodVarName(IVD->getIdentifier()));
  ivar.add(GetMethodVarType(IVD));
  ivar.addInt(ObjCTypes.IntTy, ComputeIvarBaseOffset(CGM, OID, IVD));
  ivar.finishAndAddTo(ivars);
}

// Return null for empty list.
auto count = ivars.size();
if (count == 0) {
  ivars.abandon();
  ivarList.abandon();
  return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
}

ivars.finishAndAddTo(ivarList);
ivarList.fillPlaceholderWithInt(countSlot, ObjCTypes.IntTy, count);

llvm::GlobalVariable *GV;
if (ForClass)
  GV =
      CreateMetadataVar("OBJC_CLASS_VARIABLES_" + ID->getName(), ivarList,
                        "__OBJC,__class_vars,regular,no_dead_strip",
                        CGM.getPointerAlign(), true);
else
  GV = CreateMetadataVar("OBJC_INSTANCE_VARIABLES_" + ID->getName(), ivarList,
                         "__OBJC,__instance_vars,regular,no_dead_strip",
                         CGM.getPointerAlign(), true);
return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy);
3882}

3884/// Build a struct objc_method_description constant for the given method.
3885///
3886/// struct objc_method_description {
3887///   SEL method_name;
3888///   char *method_types;
3889/// };
3890void CGObjCMac::emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
                                            const ObjCMethodDecl *MD) {
auto description = builder.beginStruct(ObjCTypes.MethodDescriptionTy);
description.addBitCast(GetMethodVarName(MD->getSelector()),
                       ObjCTypes.SelectorPtrTy);
description.add(GetMethodVarType(MD));
description.finishAndAddTo(builder);
3897}

3899/// Build a struct objc_method constant for the given method.
3900///
3901/// struct objc_method {
3902///   SEL method_name;
3903///   char *method_types;
3904///   void *method;
3905/// };
3906void CGObjCMac::emitMethodConstant(ConstantArrayBuilder &builder,
                                 const ObjCMethodDecl *MD) {
llvm::Function *fn = GetMethodDefinition(MD);
assert(fn && "no definition registered for method")((void)0);

auto method = builder.beginStruct(ObjCTypes.MethodTy);
method.addBitCast(GetMethodVarName(MD->getSelector()),
                  ObjCTypes.SelectorPtrTy);
method.add(GetMethodVarType(MD));
method.addBitCast(fn, ObjCTypes.Int8PtrTy);
method.finishAndAddTo(builder);
3917}

3919/// Build a struct objc_method_list or struct objc_method_description_list,
3920/// as appropriate.
3921///
3922/// struct objc_method_list {
3923///   struct objc_method_list *obsolete;
3924///   int count;
3925///   struct objc_method methods_list[count];
3926/// };
3927///
3928/// struct objc_method_description_list {
3929///   int count;
3930///   struct objc_method_description list[count];
3931/// };
3932llvm::Constant *CGObjCMac::emitMethodList(Twine name, MethodListType MLT,
                               ArrayRef<const ObjCMethodDecl *> methods) {
StringRef prefix;
StringRef section;
bool forProtocol = false;
switch (MLT) {
case MethodListType::CategoryInstanceMethods:
  prefix = "OBJC_CATEGORY_INSTANCE_METHODS_";
  section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
  forProtocol = false;
  break;
case MethodListType::CategoryClassMethods:
  prefix = "OBJC_CATEGORY_CLASS_METHODS_";
  section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
  forProtocol = false;
  break;
case MethodListType::InstanceMethods:
  prefix = "OBJC_INSTANCE_METHODS_";
  section = "__OBJC,__inst_meth,regular,no_dead_strip";
  forProtocol = false;
  break;
case MethodListType::ClassMethods:
  prefix = "OBJC_CLASS_METHODS_";
  section = "__OBJC,__cls_meth,regular,no_dead_strip";
  forProtocol = false;
  break;
case MethodListType::ProtocolInstanceMethods:
  prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_";
  section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
  forProtocol = true;
  break;
case MethodListType::ProtocolClassMethods:
  prefix = "OBJC_PROTOCOL_CLASS_METHODS_";
  section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
  forProtocol = true;
  break;
case MethodListType::OptionalProtocolInstanceMethods:
  prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_OPT_";
  section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
  forProtocol = true;
  break;
case MethodListType::OptionalProtocolClassMethods:
  prefix = "OBJC_PROTOCOL_CLASS_METHODS_OPT_";
  section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
  forProtocol = true;
  break;
}

// Return null for empty list.
if (methods.empty())
  return llvm::Constant::getNullValue(forProtocol
                                      ? ObjCTypes.MethodDescriptionListPtrTy
                                      : ObjCTypes.MethodListPtrTy);

// For protocols, this is an objc_method_description_list, which has
// a slightly different structure.
if (forProtocol) {
  ConstantInitBuilder builder(CGM);
  auto values = builder.beginStruct();
  values.addInt(ObjCTypes.IntTy, methods.size());
  auto methodArray = values.beginArray(ObjCTypes.MethodDescriptionTy);
  for (auto MD : methods) {
    emitMethodDescriptionConstant(methodArray, MD);
  }
  methodArray.finishAndAddTo(values);

  llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
                                               CGM.getPointerAlign(), true);
  return llvm::ConstantExpr::getBitCast(GV,
                                        ObjCTypes.MethodDescriptionListPtrTy);
}

// Otherwise, it's an objc_method_list.
ConstantInitBuilder builder(CGM);
auto values = builder.beginStruct();
values.addNullPointer(ObjCTypes.Int8PtrTy);
values.addInt(ObjCTypes.IntTy, methods.size());
auto methodArray = values.beginArray(ObjCTypes.MethodTy);
for (auto MD : methods) {
  if (!MD->isDirectMethod())
    emitMethodConstant(methodArray, MD);
}
methodArray.finishAndAddTo(values);

llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
                                             CGM.getPointerAlign(), true);
return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListPtrTy);
4019}

4021llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
                                              const ObjCContainerDecl *CD) {
llvm::Function *Method;

if (OMD->isDirectMethod()) {
  Method = GenerateDirectMethod(OMD, CD);
} else {
  auto Name = getSymbolNameForMethod(OMD);

  CodeGenTypes &Types = CGM.getTypes();
  llvm::FunctionType *MethodTy =
      Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
  Method =
      llvm::Function::Create(MethodTy, llvm::GlobalValue::InternalLinkage,
                             Name, &CGM.getModule());
}

MethodDefinitions.insert(std::make_pair(OMD, Method));

return Method;
4041}

4043llvm::Function *
4044CGObjCCommonMac::GenerateDirectMethod(const ObjCMethodDecl *OMD,
                                    const ObjCContainerDecl *CD) {
auto *COMD = OMD->getCanonicalDecl();
auto I = DirectMethodDefinitions.find(COMD);
llvm::Function *OldFn = nullptr, *Fn = nullptr;

if (I != DirectMethodDefinitions.end()) {
  // Objective-C allows for the declaration and implementation types
  // to differ slightly.
  //
  // If we're being asked for the Function associated for a method
  // implementation, a previous value might have been cached
  // based on the type of the canonical declaration.
  //
  // If these do not match, then we'll replace this function with
  // a new one that has the proper type below.
  if (!OMD->getBody() || COMD->getReturnType() == OMD->getReturnType())
    return I->second;
  OldFn = I->second;
}

CodeGenTypes &Types = CGM.getTypes();
llvm::FunctionType *MethodTy =
  Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));

if (OldFn) {
  Fn = llvm::Function::Create(MethodTy, llvm::GlobalValue::ExternalLinkage,
                              "", &CGM.getModule());
  Fn->takeName(OldFn);
  OldFn->replaceAllUsesWith(
      llvm::ConstantExpr::getBitCast(Fn, OldFn->getType()));
  OldFn->eraseFromParent();

  // Replace the cached function in the map.
  I->second = Fn;
} else {
  auto Name = getSymbolNameForMethod(OMD, /*include category*/ false);

  Fn = llvm::Function::Create(MethodTy, llvm::GlobalValue::ExternalLinkage,
                              Name, &CGM.getModule());
  DirectMethodDefinitions.insert(std::make_pair(COMD, Fn));
}

return Fn;
4088}

4090void CGObjCCommonMac::GenerateDirectMethodPrologue(
  CodeGenFunction &CGF, llvm::Function *Fn, const ObjCMethodDecl *OMD,
  const ObjCContainerDecl *CD) {
auto &Builder = CGF.Builder;
bool ReceiverCanBeNull = true;
auto selfAddr = CGF.GetAddrOfLocalVar(OMD->getSelfDecl());
auto selfValue = Builder.CreateLoad(selfAddr);

// Generate:
//
// /* for class methods only to force class lazy initialization */
// self = [self self];
//
// /* unless the receiver is never NULL */
// if (self == nil) {
//     return (ReturnType){ };
// }
//
// _cmd = @selector(...)
// ...

if (OMD->isClassMethod()) {
  const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(CD);
  assert(OID &&((void)0)
         "GenerateDirectMethod() should be called with the Class Interface")((void)0);
  Selector SelfSel = GetNullarySelector("self", CGM.getContext());
  auto ResultType = CGF.getContext().getObjCIdType();
  RValue result;
  CallArgList Args;

  // TODO: If this method is inlined, the caller might know that `self` is
  // already initialized; for example, it might be an ordinary Objective-C
  // method which always receives an initialized `self`, or it might have just
  // forced initialization on its own.
  //
  // We should find a way to eliminate this unnecessary initialization in such
  // cases in LLVM.
  result = GeneratePossiblySpecializedMessageSend(
      CGF, ReturnValueSlot(), ResultType, SelfSel, selfValue, Args, OID,
      nullptr, true);
  Builder.CreateStore(result.getScalarVal(), selfAddr);

  // Nullable `Class` expressions cannot be messaged with a direct method
  // so the only reason why the receive can be null would be because
  // of weak linking.
  ReceiverCanBeNull = isWeakLinkedClass(OID);
}

if (ReceiverCanBeNull) {
  llvm::BasicBlock *SelfIsNilBlock =
      CGF.createBasicBlock("objc_direct_method.self_is_nil");
  llvm::BasicBlock *ContBlock =
      CGF.createBasicBlock("objc_direct_method.cont");

  // if (self == nil) {
  auto selfTy = cast<llvm::PointerType>(selfValue->getType());
  auto Zero = llvm::ConstantPointerNull::get(selfTy);

  llvm::MDBuilder MDHelper(CGM.getLLVMContext());
  Builder.CreateCondBr(Builder.CreateICmpEQ(selfValue, Zero), SelfIsNilBlock,
                       ContBlock, MDHelper.createBranchWeights(1, 1 << 20));

  CGF.EmitBlock(SelfIsNilBlock);

  //   return (ReturnType){ };
  auto retTy = OMD->getReturnType();
  Builder.SetInsertPoint(SelfIsNilBlock);
  if (!retTy->isVoidType()) {
    CGF.EmitNullInitialization(CGF.ReturnValue, retTy);
  }
  CGF.EmitBranchThroughCleanup(CGF.ReturnBlock);
  // }

  // rest of the body
  CGF.EmitBlock(ContBlock);
  Builder.SetInsertPoint(ContBlock);
}

// only synthesize _cmd if it's referenced
if (OMD->getCmdDecl()->isUsed()) {
  Builder.CreateStore(GetSelector(CGF, OMD),
                      CGF.GetAddrOfLocalVar(OMD->getCmdDecl()));
}
4173}

4175llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
                                             ConstantStructBuilder &Init,
                                                       StringRef Section,
                                                       CharUnits Align,
                                                       bool AddToUsed) {
llvm::GlobalValue::LinkageTypes LT =
    getLinkageTypeForObjCMetadata(CGM, Section);
llvm::GlobalVariable *GV =
    Init.finishAndCreateGlobal(Name, Align, /*constant*/ false, LT);
if (!Section.empty())
  GV->setSection(Section);
if (AddToUsed)
  CGM.addCompilerUsedGlobal(GV);
return GV;
4189}

4191llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
                                                       llvm::Constant *Init,
                                                       StringRef Section,
                                                       CharUnits Align,
                                                       bool AddToUsed) {
llvm::Type *Ty = Init->getType();
llvm::GlobalValue::LinkageTypes LT =
    getLinkageTypeForObjCMetadata(CGM, Section);
llvm::GlobalVariable *GV =
    new llvm::GlobalVariable(CGM.getModule(), Ty, false, LT, Init, Name);
if (!Section.empty())
  GV->setSection(Section);
GV->setAlignment(Align.getAsAlign());
if (AddToUsed)
  CGM.addCompilerUsedGlobal(GV);
return GV;
4207}

4209llvm::GlobalVariable *
4210CGObjCCommonMac::CreateCStringLiteral(StringRef Name, ObjCLabelType Type,
                                    bool ForceNonFragileABI,
                                    bool NullTerminate) {
StringRef Label;
switch (Type) {
case ObjCLabelType::ClassName:     Label = "OBJC_CLASS_NAME_"; break;
case ObjCLabelType::MethodVarName: Label = "OBJC_METH_VAR_NAME_"; break;
case ObjCLabelType::MethodVarType: Label = "OBJC_METH_VAR_TYPE_"; break;
case ObjCLabelType::PropertyName:  Label = "OBJC_PROP_NAME_ATTR_"; break;
}

bool NonFragile = ForceNonFragileABI || isNonFragileABI();

StringRef Section;
switch (Type) {
case ObjCLabelType::ClassName:
  Section = NonFragile ? "__TEXT,__objc_classname,cstring_literals"
                       : "__TEXT,__cstring,cstring_literals";
  break;
case ObjCLabelType::MethodVarName:
  Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals"
                       : "__TEXT,__cstring,cstring_literals";
  break;
case ObjCLabelType::MethodVarType:
  Section = NonFragile ? "__TEXT,__objc_methtype,cstring_literals"
                       : "__TEXT,__cstring,cstring_literals";
  break;
case ObjCLabelType::PropertyName:
  Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals"
                       : "__TEXT,__cstring,cstring_literals";
  break;
}

llvm::Constant *Value =
    llvm::ConstantDataArray::getString(VMContext, Name, NullTerminate);
llvm::GlobalVariable *GV =
    new llvm::GlobalVariable(CGM.getModule(), Value->getType(),
                             /*isConstant=*/true,
                             llvm::GlobalValue::PrivateLinkage, Value, Label);
if (CGM.getTriple().isOSBinFormatMachO())
  GV->setSection(Section);
GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
GV->setAlignment(CharUnits::One().getAsAlign());
CGM.addCompilerUsedGlobal(GV);

return GV;
4256}

4258llvm::Function *CGObjCMac::ModuleInitFunction() {
// Abuse this interface function as a place to finalize.
FinishModule();
return nullptr;
4262}

4264llvm::FunctionCallee CGObjCMac::GetPropertyGetFunction() {
return ObjCTypes.getGetPropertyFn();
4266}

4268llvm::FunctionCallee CGObjCMac::GetPropertySetFunction() {
return ObjCTypes.getSetPropertyFn();
4270}

4272llvm::FunctionCallee CGObjCMac::GetOptimizedPropertySetFunction(bool atomic,
                                                              bool copy) {
return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
4275}

4277llvm::FunctionCallee CGObjCMac::GetGetStructFunction() {
return ObjCTypes.getCopyStructFn();
4279}

4281llvm::FunctionCallee CGObjCMac::GetSetStructFunction() {
return ObjCTypes.getCopyStructFn();
4283}

4285llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectGetFunction() {
return ObjCTypes.getCppAtomicObjectFunction();
4287}

4289llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectSetFunction() {
return ObjCTypes.getCppAtomicObjectFunction();
4291}

4293llvm::FunctionCallee CGObjCMac::EnumerationMutationFunction() {
return ObjCTypes.getEnumerationMutationFn();
4295}

4297void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) {
return EmitTryOrSynchronizedStmt(CGF, S);
4299}

4301void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF,
                                   const ObjCAtSynchronizedStmt &S) {
return EmitTryOrSynchronizedStmt(CGF, S);
4304}

4306namespace {
struct PerformFragileFinally final : EHScopeStack::Cleanup {
  const Stmt &S;
  Address SyncArgSlot;
  Address CallTryExitVar;
  Address ExceptionData;
  ObjCTypesHelper &ObjCTypes;
  PerformFragileFinally(const Stmt *S,
                        Address SyncArgSlot,
                        Address CallTryExitVar,
                        Address ExceptionData,
                        ObjCTypesHelper *ObjCTypes)
    : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar),
      ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {}

  void Emit(CodeGenFunction &CGF, Flags flags) override {
    // Check whether we need to call objc_exception_try_exit.
    // In optimized code, this branch will always be folded.
    llvm::BasicBlock *FinallyCallExit =
      CGF.createBasicBlock("finally.call_exit");
    llvm::BasicBlock *FinallyNoCallExit =
      CGF.createBasicBlock("finally.no_call_exit");
    CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
                             FinallyCallExit, FinallyNoCallExit);

    CGF.EmitBlock(FinallyCallExit);
    CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryExitFn(),
                                ExceptionData.getPointer());

    CGF.EmitBlock(FinallyNoCallExit);

    if (isa<ObjCAtTryStmt>(S)) {
      if (const ObjCAtFinallyStmt* FinallyStmt =
            cast<ObjCAtTryStmt>(S).getFinallyStmt()) {
        // Don't try to do the @finally if this is an EH cleanup.
        if (flags.isForEHCleanup()) return;

        // Save the current cleanup destination in case there's
        // control flow inside the finally statement.
        llvm::Value *CurCleanupDest =
          CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot());

        CGF.EmitStmt(FinallyStmt->getFinallyBody());

        if (CGF.HaveInsertPoint()) {
          CGF.Builder.CreateStore(CurCleanupDest,
                                  CGF.getNormalCleanupDestSlot());
        } else {
          // Currently, the end of the cleanup must always exist.
          CGF.EnsureInsertPoint();
        }
      }
    } else {
      // Emit objc_sync_exit(expr); as finally's sole statement for
      // @synchronized.
      llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot);
      CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncExitFn(), SyncArg);
    }
  }
};

class FragileHazards {
  CodeGenFunction &CGF;
  SmallVector<llvm::Value*, 20> Locals;
  llvm::DenseSet<llvm::BasicBlock*> BlocksBeforeTry;

  llvm::InlineAsm *ReadHazard;
  llvm::InlineAsm *WriteHazard;

  llvm::FunctionType *GetAsmFnType();

  void collectLocals();
  void emitReadHazard(CGBuilderTy &Builder);

public:
  FragileHazards(CodeGenFunction &CGF);

  void emitWriteHazard();
  void emitHazardsInNewBlocks();
};
4386} // end anonymous namespace

4388/// Create the fragile-ABI read and write hazards based on the current
4389/// state of the function, which is presumed to be immediately prior
4390/// to a @try block.  These hazards are used to maintain correct
4391/// semantics in the face of optimization and the fragile ABI's
4392/// cavalier use of setjmp/longjmp.
4393FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) {
collectLocals();

if (Locals.empty()) return;

// Collect all the blocks in the function.
for (llvm::Function::iterator
       I = CGF.CurFn->begin(), E = CGF.CurFn->end(); I != E; ++I)
  BlocksBeforeTry.insert(&*I);

llvm::FunctionType *AsmFnTy = GetAsmFnType();

// Create a read hazard for the allocas.  This inhibits dead-store
// optimizations and forces the values to memory.  This hazard is
// inserted before any 'throwing' calls in the protected scope to
// reflect the possibility that the variables might be read from the
// catch block if the call throws.
{
  std::string Constraint;
  for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
    if (I) Constraint += ',';
    Constraint += "*m";
  }

  ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
}

// Create a write hazard for the allocas.  This inhibits folding
// loads across the hazard.  This hazard is inserted at the
// beginning of the catch path to reflect the possibility that the
// variables might have been written within the protected scope.
{
  std::string Constraint;
  for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
    if (I) Constraint += ',';
    Constraint += "=*m";
  }

  WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
}
4433}

4435/// Emit a write hazard at the current location.
4436void FragileHazards::emitWriteHazard() {
if (Locals.empty()) return;

CGF.EmitNounwindRuntimeCall(WriteHazard, Locals);
4440}

4442void FragileHazards::emitReadHazard(CGBuilderTy &Builder) {
assert(!Locals.empty())((void)0);
llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals);
call->setDoesNotThrow();
call->setCallingConv(CGF.getRuntimeCC());
4447}

4449/// Emit read hazards in all the protected blocks, i.e. all the blocks
4450/// which have been inserted since the beginning of the try.
4451void FragileHazards::emitHazardsInNewBlocks() {
if (Locals.empty()) return;

CGBuilderTy Builder(CGF, CGF.getLLVMContext());

// Iterate through all blocks, skipping those prior to the try.
for (llvm::Function::iterator
       FI = CGF.CurFn->begin(), FE = CGF.CurFn->end(); FI != FE; ++FI) {
  llvm::BasicBlock &BB = *FI;
  if (BlocksBeforeTry.count(&BB)) continue;

  // Walk through all the calls in the block.
  for (llvm::BasicBlock::iterator
         BI = BB.begin(), BE = BB.end(); BI != BE; ++BI) {
    llvm::Instruction &I = *BI;

    // Ignore instructions that aren't non-intrinsic calls.
    // These are the only calls that can possibly call longjmp.
    if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I))
      continue;
    if (isa<llvm::IntrinsicInst>(I))
      continue;

    // Ignore call sites marked nounwind.  This may be questionable,
    // since 'nounwind' doesn't necessarily mean 'does not call longjmp'.
    if (cast<llvm::CallBase>(I).doesNotThrow())
      continue;

    // Insert a read hazard before the call.  This will ensure that
    // any writes to the locals are performed before making the
    // call.  If the call throws, then this is sufficient to
    // guarantee correctness as long as it doesn't also write to any
    // locals.
    Builder.SetInsertPoint(&BB, BI);
    emitReadHazard(Builder);
  }
}
4488}

4490static void addIfPresent(llvm::DenseSet<llvm::Value*> &S, Address V) {
if (V.isValid()) S.insert(V.getPointer());
4492}

4494void FragileHazards::collectLocals() {
// Compute a set of allocas to ignore.
llvm::DenseSet<llvm::Value*> AllocasToIgnore;
addIfPresent(AllocasToIgnore, CGF.ReturnValue);
addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest);

// Collect all the allocas currently in the function.  This is
// probably way too aggressive.
llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock();
for (llvm::BasicBlock::iterator
       I = Entry.begin(), E = Entry.end(); I != E; ++I)
  if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I))
    Locals.push_back(&*I);
4507}

4509llvm::FunctionType *FragileHazards::GetAsmFnType() {
SmallVector<llvm::Type *, 16> tys(Locals.size());
for (unsigned i = 0, e = Locals.size(); i != e; ++i)
  tys[i] = Locals[i]->getType();
return llvm::FunctionType::get(CGF.VoidTy, tys, false);
4514}

4516/*

Objective-C setjmp-longjmp (sjlj) Exception Handling
--

A catch buffer is a setjmp buffer plus:
  - a pointer to the exception that was caught
  - a pointer to the previous exception data buffer
  - two pointers of reserved storage
Therefore catch buffers form a stack, with a pointer to the top
of the stack kept in thread-local storage.

objc_exception_try_enter pushes a catch buffer onto the EH stack.
objc_exception_try_exit pops the given catch buffer, which is
  required to be the top of the EH stack.
objc_exception_throw pops the top of the EH stack, writes the
  thrown exception into the appropriate field, and longjmps
  to the setjmp buffer.  It crashes the process (with a printf
  and an abort()) if there are no catch buffers on the stack.
objc_exception_extract just reads the exception pointer out of the
  catch buffer.

There's no reason an implementation couldn't use a light-weight
setjmp here --- something like __builtin_setjmp, but API-compatible
with the heavyweight setjmp.  This will be more important if we ever
want to implement correct ObjC/C++ exception interactions for the
fragile ABI.

Note that for this use of setjmp/longjmp to be correct, we may need
to mark some local variables volatile: if a non-volatile local
variable is modified between the setjmp and the longjmp, it has
indeterminate value.  For the purposes of LLVM IR, it may be
sufficient to make loads and stores within the @try (to variables
declared outside the @try) volatile.  This is necessary for
optimized correctness, but is not currently being done; this is
being tracked as rdar://problem/8160285

The basic framework for a @try-catch-finally is as follows:
{
objc_exception_data d;
id _rethrow = null;
bool _call_try_exit = true;

objc_exception_try_enter(&d);
if (!setjmp(d.jmp_buf)) {
... try body ...
} else {
// exception path
id _caught = objc_exception_extract(&d);

// enter new try scope for handlers
if (!setjmp(d.jmp_buf)) {
... match exception and execute catch blocks ...

// fell off end, rethrow.
_rethrow = _caught;
... jump-through-finally to finally_rethrow ...
} else {
// exception in catch block
_rethrow = objc_exception_extract(&d);
_call_try_exit = false;
... jump-through-finally to finally_rethrow ...
}
}
... jump-through-finally to finally_end ...

finally:
if (_call_try_exit)
objc_exception_try_exit(&d);

... finally block ....
... dispatch to finally destination ...

finally_rethrow:
objc_exception_throw(_rethrow);

finally_end:
}

This framework differs slightly from the one gcc uses, in that gcc
uses _rethrow to determine if objc_exception_try_exit should be called
and if the object should be rethrown. This breaks in the face of
throwing nil and introduces unnecessary branches.

We specialize this framework for a few particular circumstances:

- If there are no catch blocks, then we avoid emitting the second
exception handling context.

- If there is a catch-all catch block (i.e. @catch(...) or @catch(id
e)) we avoid emitting the code to rethrow an uncaught exception.

- FIXME: If there is no @finally block we can do a few more
simplifications.

Rethrows and Jumps-Through-Finally
--

'@throw;' is supported by pushing the currently-caught exception
onto ObjCEHStack while the @catch blocks are emitted.

Branches through the @finally block are handled with an ordinary
normal cleanup.  We do not register an EH cleanup; fragile-ABI ObjC
exceptions are not compatible with C++ exceptions, and this is
hardly the only place where this will go wrong.

@synchronized(expr) { stmt; } is emitted as if it were:
  id synch_value = expr;
  objc_sync_enter(synch_value);
  @try { stmt; } @finally { objc_sync_exit(synch_value); }
4626*/

4628void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
                                        const Stmt &S) {
bool isTry = isa<ObjCAtTryStmt>(S);

// A destination for the fall-through edges of the catch handlers to
// jump to.
CodeGenFunction::JumpDest FinallyEnd =
  CGF.getJumpDestInCurrentScope("finally.end");

// A destination for the rethrow edge of the catch handlers to jump
// to.
CodeGenFunction::JumpDest FinallyRethrow =
  CGF.getJumpDestInCurrentScope("finally.rethrow");

// For @synchronized, call objc_sync_enter(sync.expr). The
// evaluation of the expression must occur before we enter the
// @synchronized.  We can't avoid a temp here because we need the
// value to be preserved.  If the backend ever does liveness
// correctly after setjmp, this will be unnecessary.
Address SyncArgSlot = Address::invalid();
if (!isTry) {
  llvm::Value *SyncArg =
    CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
  SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
  CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncEnterFn(), SyncArg);

  SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(),
                                     CGF.getPointerAlign(), "sync.arg");
  CGF.Builder.CreateStore(SyncArg, SyncArgSlot);
}

// Allocate memory for the setjmp buffer.  This needs to be kept
// live throughout the try and catch blocks.
Address ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
                                             CGF.getPointerAlign(),
                                             "exceptiondata.ptr");

// Create the fragile hazards.  Note that this will not capture any
// of the allocas required for exception processing, but will
// capture the current basic block (which extends all the way to the
// setjmp call) as "before the @try".
FragileHazards Hazards(CGF);

// Create a flag indicating whether the cleanup needs to call
// objc_exception_try_exit.  This is true except when
//   - no catches match and we're branching through the cleanup
//     just to rethrow the exception, or
//   - a catch matched and we're falling out of the catch handler.
// The setjmp-safety rule here is that we should always store to this
// variable in a place that dominates the branch through the cleanup
// without passing through any setjmps.
Address CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
                                              CharUnits::One(),
                                              "_call_try_exit");

// A slot containing the exception to rethrow.  Only needed when we
// have both a @catch and a @finally.
Address PropagatingExnVar = Address::invalid();

// Push a normal cleanup to leave the try scope.
CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalAndEHCleanup, &S,
                                               SyncArgSlot,
                                               CallTryExitVar,
                                               ExceptionData,
                                               &ObjCTypes);

// Enter a try block:
//  - Call objc_exception_try_enter to push ExceptionData on top of
//    the EH stack.
CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
                            ExceptionData.getPointer());

//  - Call setjmp on the exception data buffer.
llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
llvm::Value *GEPIndexes[] = { Zero, Zero, Zero };
llvm::Value *SetJmpBuffer = CGF.Builder.CreateGEP(
    ObjCTypes.ExceptionDataTy, ExceptionData.getPointer(), GEPIndexes,
    "setjmp_buffer");
llvm::CallInst *SetJmpResult = CGF.EmitNounwindRuntimeCall(
    ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result");
SetJmpResult->setCanReturnTwice();

// If setjmp returned 0, enter the protected block; otherwise,
// branch to the handler.
llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
llvm::Value *DidCatch =
  CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock);

// Emit the protected block.
CGF.EmitBlock(TryBlock);
CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
                   : cast<ObjCAtSynchronizedStmt>(S).getSynchBody());

CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP();

// Emit the exception handler block.
CGF.EmitBlock(TryHandler);

// Don't optimize loads of the in-scope locals across this point.
Hazards.emitWriteHazard();

// For a @synchronized (or a @try with no catches), just branch
// through the cleanup to the rethrow block.
if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) {
  // Tell the cleanup not to re-pop the exit.
  CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
  CGF.EmitBranchThroughCleanup(FinallyRethrow);

// Otherwise, we have to match against the caught exceptions.
} else {
  // Retrieve the exception object.  We may emit multiple blocks but
  // nothing can cross this so the value is already in SSA form.
  llvm::CallInst *Caught =
    CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
                                ExceptionData.getPointer(), "caught");

  // Push the exception to rethrow onto the EH value stack for the
  // benefit of any @throws in the handlers.
  CGF.ObjCEHValueStack.push_back(Caught);

  const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S);

  bool HasFinally = (AtTryStmt->getFinallyStmt() != nullptr);

  llvm::BasicBlock *CatchBlock = nullptr;
  llvm::BasicBlock *CatchHandler = nullptr;
  if (HasFinally) {
    // Save the currently-propagating exception before
    // objc_exception_try_enter clears the exception slot.
    PropagatingExnVar = CGF.CreateTempAlloca(Caught->getType(),
                                             CGF.getPointerAlign(),
                                             "propagating_exception");
    CGF.Builder.CreateStore(Caught, PropagatingExnVar);

    // Enter a new exception try block (in case a @catch block
    // throws an exception).
    CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
                                ExceptionData.getPointer());

    llvm::CallInst *SetJmpResult =
      CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(),
                                  SetJmpBuffer, "setjmp.result");
    SetJmpResult->setCanReturnTwice();

    llvm::Value *Threw =
      CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");

    CatchBlock = CGF.createBasicBlock("catch");
    CatchHandler = CGF.createBasicBlock("catch_for_catch");
    CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);

    CGF.EmitBlock(CatchBlock);
  }

  CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar);

  // Handle catch list. As a special case we check if everything is
  // matched and avoid generating code for falling off the end if
  // so.
  bool AllMatched = false;
  for (unsigned I = 0, N = AtTryStmt->getNumCatchStmts(); I != N; ++I) {
    const ObjCAtCatchStmt *CatchStmt = AtTryStmt->getCatchStmt(I);

    const VarDecl *CatchParam = CatchStmt->getCatchParamDecl();
    const ObjCObjectPointerType *OPT = nullptr;

    // catch(...) always matches.
    if (!CatchParam) {
      AllMatched = true;
    } else {
      OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>();

      // catch(id e) always matches under this ABI, since only
      // ObjC exceptions end up here in the first place.
      // FIXME: For the time being we also match id<X>; this should
      // be rejected by Sema instead.
      if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType()))
        AllMatched = true;
    }

    // If this is a catch-all, we don't need to test anything.
    if (AllMatched) {
      CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);

      if (CatchParam) {
        CGF.EmitAutoVarDecl(*CatchParam);
        assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?")((void)0);

        // These types work out because ConvertType(id) == i8*.
        EmitInitOfCatchParam(CGF, Caught, CatchParam);
      }

      CGF.EmitStmt(CatchStmt->getCatchBody());

      // The scope of the catch variable ends right here.
      CatchVarCleanups.ForceCleanup();

      CGF.EmitBranchThroughCleanup(FinallyEnd);
      break;
    }

    assert(OPT && "Unexpected non-object pointer type in @catch")((void)0);
    const ObjCObjectType *ObjTy = OPT->getObjectType();

    // FIXME: @catch (Class c) ?
    ObjCInterfaceDecl *IDecl = ObjTy->getInterface();
    assert(IDecl && "Catch parameter must have Objective-C type!")((void)0);

    // Check if the @catch block matches the exception object.
    llvm::Value *Class = EmitClassRef(CGF, IDecl);

    llvm::Value *matchArgs[] = { Class, Caught };
    llvm::CallInst *Match =
      CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionMatchFn(),
                                  matchArgs, "match");

    llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match");
    llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next");

    CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
                             MatchedBlock, NextCatchBlock);

    // Emit the @catch block.
    CGF.EmitBlock(MatchedBlock);

    // Collect any cleanups for the catch variable.  The scope lasts until
    // the end of the catch body.
    CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);

    CGF.EmitAutoVarDecl(*CatchParam);
    assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?")((void)0);

    // Initialize the catch variable.
    llvm::Value *Tmp =
      CGF.Builder.CreateBitCast(Caught,
                                CGF.ConvertType(CatchParam->getType()));
    EmitInitOfCatchParam(CGF, Tmp, CatchParam);

    CGF.EmitStmt(CatchStmt->getCatchBody());

    // We're done with the catch variable.
    CatchVarCleanups.ForceCleanup();

    CGF.EmitBranchThroughCleanup(FinallyEnd);

    CGF.EmitBlock(NextCatchBlock);
  }

  CGF.ObjCEHValueStack.pop_back();

  // If nothing wanted anything to do with the caught exception,
  // kill the extract call.
  if (Caught->use_empty())
    Caught->eraseFromParent();

  if (!AllMatched)
    CGF.EmitBranchThroughCleanup(FinallyRethrow);

  if (HasFinally) {
    // Emit the exception handler for the @catch blocks.
    CGF.EmitBlock(CatchHandler);

    // In theory we might now need a write hazard, but actually it's
    // unnecessary because there's no local-accessing code between
    // the try's write hazard and here.
    //Hazards.emitWriteHazard();

    // Extract the new exception and save it to the
    // propagating-exception slot.
    assert(PropagatingExnVar.isValid())((void)0);
    llvm::CallInst *NewCaught =
      CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
                                  ExceptionData.getPointer(), "caught");
    CGF.Builder.CreateStore(NewCaught, PropagatingExnVar);

    // Don't pop the catch handler; the throw already did.
    CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
    CGF.EmitBranchThroughCleanup(FinallyRethrow);
  }
}

// Insert read hazards as required in the new blocks.
Hazards.emitHazardsInNewBlocks();

// Pop the cleanup.
CGF.Builder.restoreIP(TryFallthroughIP);
if (CGF.HaveInsertPoint())
  CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
CGF.PopCleanupBlock();
CGF.EmitBlock(FinallyEnd.getBlock(), true);

// Emit the rethrow block.
CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
CGF.EmitBlock(FinallyRethrow.getBlock(), true);
if (CGF.HaveInsertPoint()) {
  // If we have a propagating-exception variable, check it.
  llvm::Value *PropagatingExn;
  if (PropagatingExnVar.isValid()) {
    PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar);

  // Otherwise, just look in the buffer for the exception to throw.
  } else {
    llvm::CallInst *Caught =
      CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
                                  ExceptionData.getPointer());
    PropagatingExn = Caught;
  }

  CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionThrowFn(),
                              PropagatingExn);
  CGF.Builder.CreateUnreachable();
}

CGF.Builder.restoreIP(SavedIP);
4945}

4947void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
                            const ObjCAtThrowStmt &S,
                            bool ClearInsertionPoint) {
llvm::Value *ExceptionAsObject;

if (const Expr *ThrowExpr = S.getThrowExpr()) {
  llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
  ExceptionAsObject =
    CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
} else {
  assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&((void)0)
         "Unexpected rethrow outside @catch block.")((void)0);
  ExceptionAsObject = CGF.ObjCEHValueStack.back();
}

CGF.EmitRuntimeCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject)
  ->setDoesNotReturn();
CGF.Builder.CreateUnreachable();

// Clear the insertion point to indicate we are in unreachable code.
if (ClearInsertionPoint)
  CGF.Builder.ClearInsertionPoint();
4969}

4971/// EmitObjCWeakRead - Code gen for loading value of a __weak
4972/// object: objc_read_weak (id *src)
4973///
4974llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
                                        Address AddrWeakObj) {
llvm::Type* DestTy = AddrWeakObj.getElementType();
AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj,
                                        ObjCTypes.PtrObjectPtrTy);
llvm::Value *read_weak =
  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
                              AddrWeakObj.getPointer(), "weakread");
read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
return read_weak;
4984}

4986/// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
4987/// objc_assign_weak (id src, id *dst)
4988///
4989void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
                                 llvm::Value *src, Address dst) {
llvm::Type * SrcTy = src->getType();
if (!isa<llvm::PointerType>(SrcTy)) {
  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
  assert(Size <= 8 && "does not support size > 8")((void)0);
  src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
                    : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
}
src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
llvm::Value *args[] = { src, dst.getPointer() };
CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
                            args, "weakassign");
5004}

5006/// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
5007/// objc_assign_global (id src, id *dst)
5008///
5009void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
                                   llvm::Value *src, Address dst,
                                   bool threadlocal) {
llvm::Type * SrcTy = src->getType();
if (!isa<llvm::PointerType>(SrcTy)) {
  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
  assert(Size <= 8 && "does not support size > 8")((void)0);
  src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
                    : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
}
src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
llvm::Value *args[] = { src, dst.getPointer() };
if (!threadlocal)
  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
                              args, "globalassign");
else
  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
                              args, "threadlocalassign");
5029}

5031/// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
5032/// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset)
5033///
5034void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
                                 llvm::Value *src, Address dst,
                                 llvm::Value *ivarOffset) {
assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL")((void)0);
llvm::Type * SrcTy = src->getType();
if (!isa<llvm::PointerType>(SrcTy)) {
  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
  assert(Size <= 8 && "does not support size > 8")((void)0);
  src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
                    : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
}
src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
5050}

5052/// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
5053/// objc_assign_strongCast (id src, id *dst)
5054///
5055void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
                                       llvm::Value *src, Address dst) {
llvm::Type * SrcTy = src->getType();
if (!isa<llvm::PointerType>(SrcTy)) {
  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
  assert(Size <= 8 && "does not support size > 8")((void)0);
  src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
                    : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
}
src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
llvm::Value *args[] = { src, dst.getPointer() };
CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
                            args, "strongassign");
5070}

5072void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
                                       Address DestPtr,
                                       Address SrcPtr,
                                       llvm::Value *size) {
SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), size };
CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
5080}

5082/// EmitObjCValueForIvar - Code Gen for ivar reference.
5083///
5084LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
                                     QualType ObjectTy,
                                     llvm::Value *BaseValue,
                                     const ObjCIvarDecl *Ivar,
                                     unsigned CVRQualifiers) {
const ObjCInterfaceDecl *ID =
  ObjectTy->castAs<ObjCObjectType>()->getInterface();
return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
                                EmitIvarOffset(CGF, ID, Ivar));
5093}

5095llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
                                     const ObjCInterfaceDecl *Interface,
                                     const ObjCIvarDecl *Ivar) {
uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar);
return llvm::ConstantInt::get(
  CGM.getTypes().ConvertType(CGM.getContext().LongTy),
  Offset);
5102}

5104/* *** Private Interface *** */

5106std::string CGObjCCommonMac::GetSectionName(StringRef Section,
                                          StringRef MachOAttributes) {
switch (CGM.getTriple().getObjectFormat()) {
case llvm::Triple::UnknownObjectFormat:
  llvm_unreachable("unexpected object file format")__builtin_unreachable();
case llvm::Triple::MachO: {
  if (MachOAttributes.empty())
    return ("__DATA," + Section).str();
  return ("__DATA," + Section + "," + MachOAttributes).str();
}
case llvm::Triple::ELF:
  assert(Section.substr(0, 2) == "__" &&((void)0)
         "expected the name to begin with __")((void)0);
  return Section.substr(2).str();
case llvm::Triple::COFF:
  assert(Section.substr(0, 2) == "__" &&((void)0)
         "expected the name to begin with __")((void)0);
  return ("." + Section.substr(2) + "$B").str();
case llvm::Triple::Wasm:
case llvm::Triple::GOFF:
case llvm::Triple::XCOFF:
  llvm::report_fatal_error(
      "Objective-C support is unimplemented for object file format");
}

llvm_unreachable("Unhandled llvm::Triple::ObjectFormatType enum")__builtin_unreachable();
5132}

5134/// EmitImageInfo - Emit the image info marker used to encode some module
5135/// level information.
5136///
5137/// See: <rdr://4810609&4810587&4810587>
5138/// struct IMAGE_INFO {
5139///   unsigned version;
5140///   unsigned flags;
5141/// };
5142enum ImageInfoFlags {
eImageInfo_FixAndContinue      = (1 << 0), // This flag is no longer set by clang.
eImageInfo_GarbageCollected    = (1 << 1),
eImageInfo_GCOnly              = (1 << 2),
eImageInfo_OptimizedByDyld     = (1 << 3), // This flag is set by the dyld shared cache.

// A flag indicating that the module has no instances of a @synthesize of a
// superclass variable. <rdar://problem/6803242>
eImageInfo_CorrectedSynthesize = (1 << 4), // This flag is no longer set by clang.
eImageInfo_ImageIsSimulated    = (1 << 5),
eImageInfo_ClassProperties     = (1 << 6)
5153};

5155void CGObjCCommonMac::EmitImageInfo() {
unsigned version = 0; // Version is unused?
std::string Section =
    (ObjCABI == 1)
        ? "__OBJC,__image_info,regular"
        : GetSectionName("__objc_imageinfo", "regular,no_dead_strip");

// Generate module-level named metadata to convey this information to the
// linker and code-gen.
llvm::Module &Mod = CGM.getModule();

// Add the ObjC ABI version to the module flags.
Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI);
Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version",
                  version);
Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section",
                  llvm::MDString::get(VMContext, Section));

auto Int8Ty = llvm::Type::getInt8Ty(VMContext);
if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
  // Non-GC overrides those files which specify GC.
  Mod.addModuleFlag(llvm::Module::Error,
                    "Objective-C Garbage Collection",
                    llvm::ConstantInt::get(Int8Ty,0));
} else {
  // Add the ObjC garbage collection value.
  Mod.addModuleFlag(llvm::Module::Error,
                    "Objective-C Garbage Collection",
                    llvm::ConstantInt::get(Int8Ty,
                      (uint8_t)eImageInfo_GarbageCollected));

  if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
    // Add the ObjC GC Only value.
    Mod.addModuleFlag(llvm::Module::Error, "Objective-C GC Only",
                      eImageInfo_GCOnly);

    // Require that GC be specified and set to eImageInfo_GarbageCollected.
    llvm::Metadata *Ops[2] = {
        llvm::MDString::get(VMContext, "Objective-C Garbage Collection"),
        llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
            Int8Ty, eImageInfo_GarbageCollected))};
    Mod.addModuleFlag(llvm::Module::Require, "Objective-C GC Only",
                      llvm::MDNode::get(VMContext, Ops));
  }
}

// Indicate whether we're compiling this to run on a simulator.
if (CGM.getTarget().getTriple().isSimulatorEnvironment())
  Mod.addModuleFlag(llvm::Module::Error, "Objective-C Is Simulated",
                    eImageInfo_ImageIsSimulated);

// Indicate whether we are generating class properties.
Mod.addModuleFlag(llvm::Module::Error, "Objective-C Class Properties",
                  eImageInfo_ClassProperties);
5209}

5211// struct objc_module {
5212//   unsigned long version;
5213//   unsigned long size;
5214//   const char *name;
5215//   Symtab symtab;
5216// };

5218// FIXME: Get from somewhere
5219static const int ModuleVersion = 7;

5221void CGObjCMac::EmitModuleInfo() {
uint64_t Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ModuleTy);

ConstantInitBuilder builder(CGM);
auto values = builder.beginStruct(ObjCTypes.ModuleTy);
values.addInt(ObjCTypes.LongTy, ModuleVersion);
values.addInt(ObjCTypes.LongTy, Size);
// This used to be the filename, now it is unused. <rdr://4327263>
values.add(GetClassName(StringRef("")));
values.add(EmitModuleSymbols());
CreateMetadataVar("OBJC_MODULES", values,
                  "__OBJC,__module_info,regular,no_dead_strip",
                  CGM.getPointerAlign(), true);
5234}

5236llvm::Constant *CGObjCMac::EmitModuleSymbols() {
unsigned NumClasses = DefinedClasses.size();
unsigned NumCategories = DefinedCategories.size();

// Return null if no symbols were defined.
if (!NumClasses && !NumCategories)
  return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy);

ConstantInitBuilder builder(CGM);
auto values = builder.beginStruct();
values.addInt(ObjCTypes.LongTy, 0);
values.addNullPointer(ObjCTypes.SelectorPtrTy);
values.addInt(ObjCTypes.ShortTy, NumClasses);
values.addInt(ObjCTypes.ShortTy, NumCategories);

// The runtime expects exactly the list of defined classes followed
// by the list of defined categories, in a single array.
auto array = values.beginArray(ObjCTypes.Int8PtrTy);
for (unsigned i=0; i<NumClasses; i++) {
  const ObjCInterfaceDecl *ID = ImplementedClasses[i];
  assert(ID)((void)0);
  if (ObjCImplementationDecl *IMP = ID->getImplementation())
    // We are implementing a weak imported interface. Give it external linkage
    if (ID->isWeakImported() && !IMP->isWeakImported())
      DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);

  array.addBitCast(DefinedClasses[i], ObjCTypes.Int8PtrTy);
}
for (unsigned i=0; i<NumCategories; i++)
  array.addBitCast(DefinedCategories[i], ObjCTypes.Int8PtrTy);

array.finishAndAddTo(values);

llvm::GlobalVariable *GV = CreateMetadataVar(
    "OBJC_SYMBOLS", values, "__OBJC,__symbols,regular,no_dead_strip",
    CGM.getPointerAlign(), true);
return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy);
5273}

5275llvm::Value *CGObjCMac::EmitClassRefFromId(CodeGenFunction &CGF,
                                         IdentifierInfo *II) {
LazySymbols.insert(II);

llvm::GlobalVariable *&Entry = ClassReferences[II];

if (!Entry) {
  llvm::Constant *Casted =
  llvm::ConstantExpr::getBitCast(GetClassName(II->getName()),
                                 ObjCTypes.ClassPtrTy);
  Entry = CreateMetadataVar(
      "OBJC_CLASS_REFERENCES_", Casted,
      "__OBJC,__cls_refs,literal_pointers,no_dead_strip",
      CGM.getPointerAlign(), true);
}

return CGF.Builder.CreateAlignedLoad(Entry->getValueType(), Entry,
                                     CGF.getPointerAlign());
5293}

5295llvm::Value *CGObjCMac::EmitClassRef(CodeGenFunction &CGF,
                                   const ObjCInterfaceDecl *ID) {
// If the class has the objc_runtime_visible attribute, we need to
// use the Objective-C runtime to get the class.
if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
  return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);

IdentifierInfo *RuntimeName =
    &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
return EmitClassRefFromId(CGF, RuntimeName);
5305}

5307llvm::Value *CGObjCMac::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
return EmitClassRefFromId(CGF, II);
5310}

5312llvm::Value *CGObjCMac::EmitSelector(CodeGenFunction &CGF, Selector Sel) {
return CGF.Builder.CreateLoad(EmitSelectorAddr(Sel));
5314}

5316Address CGObjCMac::EmitSelectorAddr(Selector Sel) {
CharUnits Align = CGM.getPointerAlign();

llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
if (!Entry) {
  llvm::Constant *Casted =
    llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
                                   ObjCTypes.SelectorPtrTy);
  Entry = CreateMetadataVar(
      "OBJC_SELECTOR_REFERENCES_", Casted,
      "__OBJC,__message_refs,literal_pointers,no_dead_strip", Align, true);
  Entry->setExternallyInitialized(true);
}

return Address(Entry, Align);
5331}

5333llvm::Constant *CGObjCCommonMac::GetClassName(StringRef RuntimeName) {
  llvm::GlobalVariable *&Entry = ClassNames[RuntimeName];
  if (!Entry)
    Entry = CreateCStringLiteral(RuntimeName, ObjCLabelType::ClassName);
  return getConstantGEP(VMContext, Entry, 0, 0);
5338}

5340llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) {
llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator
    I = MethodDefinitions.find(MD);
if (I != MethodDefinitions.end())
  return I->second;

return nullptr;
5347}

5349/// GetIvarLayoutName - Returns a unique constant for the given
5350/// ivar layout bitmap.
5351llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident,
                                     const ObjCCommonTypesHelper &ObjCTypes) {
return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
5354}

5356void IvarLayoutBuilder::visitRecord(const RecordType *RT,
                                  CharUnits offset) {
const RecordDecl *RD = RT->getDecl();

// If this is a union, remember that we had one, because it might mess
// up the ordering of layout entries.
if (RD->isUnion())
  IsDisordered = true;

const ASTRecordLayout *recLayout = nullptr;
visitAggregate(RD->field_begin(), RD->field_end(), offset,
               [&](const FieldDecl *field) -> CharUnits {
  if (!recLayout)
    recLayout = &CGM.getContext().getASTRecordLayout(RD);
  auto offsetInBits = recLayout->getFieldOffset(field->getFieldIndex());
  return CGM.getContext().toCharUnitsFromBits(offsetInBits);
});
5373}

5375template <class Iterator, class GetOffsetFn>
5376void IvarLayoutBuilder::visitAggregate(Iterator begin, Iterator end,
                                     CharUnits aggregateOffset,
                                     const GetOffsetFn &getOffset) {
for (; begin != end; ++begin) {
  auto field = *begin;

  // Skip over bitfields.
  if (field->isBitField()) {
    continue;
  }

  // Compute the offset of the field within the aggregate.
  CharUnits fieldOffset = aggregateOffset + getOffset(field);

  visitField(field, fieldOffset);
}
5392}

5394/// Collect layout information for the given fields into IvarsInfo.
5395void IvarLayoutBuilder::visitField(const FieldDecl *field,
                                 CharUnits fieldOffset) {
QualType fieldType = field->getType();

// Drill down into arrays.
uint64_t numElts = 1;
if (auto arrayType = CGM.getContext().getAsIncompleteArrayType(fieldType)) {
  numElts = 0;
  fieldType = arrayType->getElementType();
}
// Unlike incomplete arrays, constant arrays can be nested.
while (auto arrayType = CGM.getContext().getAsConstantArrayType(fieldType)) {
  numElts *= arrayType->getSize().getZExtValue();
  fieldType = arrayType->getElementType();
}

assert(!fieldType->isArrayType() && "ivar of non-constant array type?")((void)0);

// If we ended up with a zero-sized array, we've done what we can do within
// the limits of this layout encoding.
if (numElts == 0) return;

// Recurse if the base element type is a record type.
if (auto recType = fieldType->getAs<RecordType>()) {
  size_t oldEnd = IvarsInfo.size();

  visitRecord(recType, fieldOffset);

  // If we have an array, replicate the first entry's layout information.
  auto numEltEntries = IvarsInfo.size() - oldEnd;
  if (numElts != 1 && numEltEntries != 0) {
    CharUnits eltSize = CGM.getContext().getTypeSizeInChars(recType);
    for (uint64_t eltIndex = 1; eltIndex != numElts; ++eltIndex) {
      // Copy the last numEltEntries onto the end of the array, adjusting
      // each for the element size.
      for (size_t i = 0; i != numEltEntries; ++i) {
        auto firstEntry = IvarsInfo[oldEnd + i];
        IvarsInfo.push_back(IvarInfo(firstEntry.Offset + eltIndex * eltSize,
                                     firstEntry.SizeInWords));
      }
    }
  }

  return;
}

// Classify the element type.
Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), fieldType);

// If it matches what we're looking for, add an entry.
if ((ForStrongLayout && GCAttr == Qualifiers::Strong)
    || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) {
  assert(CGM.getContext().getTypeSizeInChars(fieldType)((void)0)
           == CGM.getPointerSize())((void)0);
  IvarsInfo.push_back(IvarInfo(fieldOffset, numElts));
}
5451}

5453/// buildBitmap - This routine does the horsework of taking the offsets of
5454/// strong/weak references and creating a bitmap.  The bitmap is also
5455/// returned in the given buffer, suitable for being passed to \c dump().
5456llvm::Constant *IvarLayoutBuilder::buildBitmap(CGObjCCommonMac &CGObjC,
                              llvm::SmallVectorImpl<unsigned char> &buffer) {
// The bitmap is a series of skip/scan instructions, aligned to word
// boundaries.  The skip is performed first.
const unsigned char MaxNibble = 0xF;
const unsigned char SkipMask = 0xF0, SkipShift = 4;
const unsigned char ScanMask = 0x0F, ScanShift = 0;

assert(!IvarsInfo.empty() && "generating bitmap for no data")((void)0);

// Sort the ivar info on byte position in case we encounterred a
// union nested in the ivar list.
if (IsDisordered) {
  // This isn't a stable sort, but our algorithm should handle it fine.
  llvm::array_pod_sort(IvarsInfo.begin(), IvarsInfo.end());
} else {
  assert(llvm::is_sorted(IvarsInfo))((void)0);
}
assert(IvarsInfo.back().Offset < InstanceEnd)((void)0);

assert(buffer.empty())((void)0);

// Skip the next N words.
auto skip = [&](unsigned numWords) {
  assert(numWords > 0)((void)0);

  // Try to merge into the previous byte.  Since scans happen second, we
  // can't do this if it includes a scan.
  if (!buffer.empty() && !(buffer.back() & ScanMask)) {
    unsigned lastSkip = buffer.back() >> SkipShift;
    if (lastSkip < MaxNibble) {
      unsigned claimed = std::min(MaxNibble - lastSkip, numWords);
      numWords -= claimed;
      lastSkip += claimed;
      buffer.back() = (lastSkip << SkipShift);
    }
  }

  while (numWords >= MaxNibble) {
    buffer.push_back(MaxNibble << SkipShift);
    numWords -= MaxNibble;
  }
  if (numWords) {
    buffer.push_back(numWords << SkipShift);
  }
};

// Scan the next N words.
auto scan = [&](unsigned numWords) {
  assert(numWords > 0)((void)0);

  // Try to merge into the previous byte.  Since scans happen second, we can
  // do this even if it includes a skip.
  if (!buffer.empty()) {
    unsigned lastScan = (buffer.back() & ScanMask) >> ScanShift;
    if (lastScan < MaxNibble) {
      unsigned claimed = std::min(MaxNibble - lastScan, numWords);
      numWords -= claimed;
      lastScan += claimed;
      buffer.back() = (buffer.back() & SkipMask) | (lastScan << ScanShift);
    }
  }

  while (numWords >= MaxNibble) {
    buffer.push_back(MaxNibble << ScanShift);
    numWords -= MaxNibble;
  }
  if (numWords) {
    buffer.push_back(numWords << ScanShift);
  }
};

// One past the end of the last scan.
unsigned endOfLastScanInWords = 0;
const CharUnits WordSize = CGM.getPointerSize();

// Consider all the scan requests.
for (auto &request : IvarsInfo) {
  CharUnits beginOfScan = request.Offset - InstanceBegin;

  // Ignore scan requests that don't start at an even multiple of the
  // word size.  We can't encode them.
  if ((beginOfScan % WordSize) != 0) continue;

  // Ignore scan requests that start before the instance start.
  // This assumes that scans never span that boundary.  The boundary
  // isn't the true start of the ivars, because in the fragile-ARC case
  // it's rounded up to word alignment, but the test above should leave
  // us ignoring that possibility.
  if (beginOfScan.isNegative()) {
    assert(request.Offset + request.SizeInWords * WordSize <= InstanceBegin)((void)0);
    continue;
  }

  unsigned beginOfScanInWords = beginOfScan / WordSize;
  unsigned endOfScanInWords = beginOfScanInWords + request.SizeInWords;

  // If the scan starts some number of words after the last one ended,
  // skip forward.
  if (beginOfScanInWords > endOfLastScanInWords) {
    skip(beginOfScanInWords - endOfLastScanInWords);

  // Otherwise, start scanning where the last left off.
  } else {
    beginOfScanInWords = endOfLastScanInWords;

    // If that leaves us with nothing to scan, ignore this request.
    if (beginOfScanInWords >= endOfScanInWords) continue;
  }

  // Scan to the end of the request.
  assert(beginOfScanInWords < endOfScanInWords)((void)0);
  scan(endOfScanInWords - beginOfScanInWords);
  endOfLastScanInWords = endOfScanInWords;
}

if (buffer.empty())
  return llvm::ConstantPointerNull::get(CGM.Int8PtrTy);

// For GC layouts, emit a skip to the end of the allocation so that we
// have precise information about the entire thing.  This isn't useful
// or necessary for the ARC-style layout strings.
if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
  unsigned lastOffsetInWords =
    (InstanceEnd - InstanceBegin + WordSize - CharUnits::One()) / WordSize;
  if (lastOffsetInWords > endOfLastScanInWords) {
    skip(lastOffsetInWords - endOfLastScanInWords);
  }
}

// Null terminate the string.
buffer.push_back(0);

auto *Entry = CGObjC.CreateCStringLiteral(
    reinterpret_cast<char *>(buffer.data()), ObjCLabelType::ClassName);
return getConstantGEP(CGM.getLLVMContext(), Entry, 0, 0);
5592}

5594/// BuildIvarLayout - Builds ivar layout bitmap for the class
5595/// implementation for the __strong or __weak case.
5596/// The layout map displays which words in ivar list must be skipped
5597/// and which must be scanned by GC (see below). String is built of bytes.
5598/// Each byte is divided up in two nibbles (4-bit each). Left nibble is count
5599/// of words to skip and right nibble is count of words to scan. So, each
5600/// nibble represents up to 15 workds to skip or scan. Skipping the rest is
5601/// represented by a 0x00 byte which also ends the string.
5602/// 1. when ForStrongLayout is true, following ivars are scanned:
5603/// - id, Class
5604/// - object *
5605/// - __strong anything
5606///
5607/// 2. When ForStrongLayout is false, following ivars are scanned:
5608/// - __weak anything
5609///
5610llvm::Constant *
5611CGObjCCommonMac::BuildIvarLayout(const ObjCImplementationDecl *OMD,
                               CharUnits beginOffset, CharUnits endOffset,
                               bool ForStrongLayout, bool HasMRCWeakIvars) {
// If this is MRC, and we're either building a strong layout or there
// are no weak ivars, bail out early.
llvm::Type *PtrTy = CGM.Int8PtrTy;
if (CGM.getLangOpts().getGC() == LangOptions::NonGC &&
    !CGM.getLangOpts().ObjCAutoRefCount &&
    (ForStrongLayout || !HasMRCWeakIvars))
  return llvm::Constant::getNullValue(PtrTy);

const ObjCInterfaceDecl *OI = OMD->getClassInterface();
SmallVector<const ObjCIvarDecl*, 32> ivars;

// GC layout strings include the complete object layout, possibly
// inaccurately in the non-fragile ABI; the runtime knows how to fix this
// up.
//
// ARC layout strings only include the class's ivars.  In non-fragile
// runtimes, that means starting at InstanceStart, rounded up to word
// alignment.  In fragile runtimes, there's no InstanceStart, so it means
// starting at the offset of the first ivar, rounded up to word alignment.
//
// MRC weak layout strings follow the ARC style.
CharUnits baseOffset;
if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
  for (const ObjCIvarDecl *IVD = OI->all_declared_ivar_begin();
       IVD; IVD = IVD->getNextIvar())
    ivars.push_back(IVD);

  if (isNonFragileABI()) {
    baseOffset = beginOffset; // InstanceStart
  } else if (!ivars.empty()) {
    baseOffset =
      CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivars[0]));
  } else {
    baseOffset = CharUnits::Zero();
  }

  baseOffset = baseOffset.alignTo(CGM.getPointerAlign());
}
else {
  CGM.getContext().DeepCollectObjCIvars(OI, true, ivars);

  baseOffset = CharUnits::Zero();
}

if (ivars.empty())
  return llvm::Constant::getNullValue(PtrTy);

IvarLayoutBuilder builder(CGM, baseOffset, endOffset, ForStrongLayout);

builder.visitAggregate(ivars.begin(), ivars.end(), CharUnits::Zero(),
                       [&](const ObjCIvarDecl *ivar) -> CharUnits {
    return CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivar));
});

if (!builder.hasBitmapData())
  return llvm::Constant::getNullValue(PtrTy);

llvm::SmallVector<unsigned char, 4> buffer;
llvm::Constant *C = builder.buildBitmap(*this, buffer);

 if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
  printf("\n%s ivar layout for class '%s': ",
         ForStrongLayout ? "strong" : "weak",
         OMD->getClassInterface()->getName().str().c_str());
  builder.dump(buffer);
}
return C;
5681}

5683llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) {
llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
// FIXME: Avoid std::string in "Sel.getAsString()"
if (!Entry)
  Entry = CreateCStringLiteral(Sel.getAsString(), ObjCLabelType::MethodVarName);
return getConstantGEP(VMContext, Entry, 0, 0);
5689}

5691// FIXME: Merge into a single cstring creation function.
5692llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) {
return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
5694}

5696llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) {
std::string TypeStr;
CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field);

llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
if (!Entry)
  Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
return getConstantGEP(VMContext, Entry, 0, 0);
5704}

5706llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D,
                                                bool Extended) {
std::string TypeStr =
  CGM.getContext().getObjCEncodingForMethodDecl(D, Extended);

llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
if (!Entry)
  Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
return getConstantGEP(VMContext, Entry, 0, 0);
5715}

5717// FIXME: Merge into a single cstring creation function.
5718llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) {
llvm::GlobalVariable *&Entry = PropertyNames[Ident];
if (!Entry)
  Entry = CreateCStringLiteral(Ident->getName(), ObjCLabelType::PropertyName);
return getConstantGEP(VMContext, Entry, 0, 0);
5723}

5725// FIXME: Merge into a single cstring creation function.
5726// FIXME: This Decl should be more precise.
5727llvm::Constant *
5728CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
                                     const Decl *Container) {
std::string TypeStr =
  CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container);
return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
5733}

5735void CGObjCMac::FinishModule() {
EmitModuleInfo();

// Emit the dummy bodies for any protocols which were referenced but
// never defined.
for (auto &entry : Protocols) {
  llvm::GlobalVariable *global = entry.second;
  if (global->hasInitializer())
    continue;

  ConstantInitBuilder builder(CGM);
  auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
  values.addNullPointer(ObjCTypes.ProtocolExtensionPtrTy);
  values.add(GetClassName(entry.first->getName()));
  values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
  values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
  values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
  values.finishAndSetAsInitializer(global);
  CGM.addCompilerUsedGlobal(global);
}

// Add assembler directives to add lazy undefined symbol references
// for classes which are referenced but not defined. This is
// important for correct linker interaction.
//
// FIXME: It would be nice if we had an LLVM construct for this.
if ((!LazySymbols.empty() || !DefinedSymbols.empty()) &&
    CGM.getTriple().isOSBinFormatMachO()) {
  SmallString<256> Asm;
  Asm += CGM.getModule().getModuleInlineAsm();
  if (!Asm.empty() && Asm.back() != '\n')
    Asm += '\n';

  llvm::raw_svector_ostream OS(Asm);
  for (const auto *Sym : DefinedSymbols)
    OS << "\t.objc_class_name_" << Sym->getName() << "=0\n"
       << "\t.globl .objc_class_name_" << Sym->getName() << "\n";
  for (const auto *Sym : LazySymbols)
    OS << "\t.lazy_reference .objc_class_name_" << Sym->getName() << "\n";
  for (const auto &Category : DefinedCategoryNames)
    OS << "\t.objc_category_name_" << Category << "=0\n"
       << "\t.globl .objc_category_name_" << Category << "\n";

  CGM.getModule().setModuleInlineAsm(OS.str());
}
5780}

5782CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm)
  : CGObjCCommonMac(cgm), ObjCTypes(cgm), ObjCEmptyCacheVar(nullptr),
    ObjCEmptyVtableVar(nullptr) {
ObjCABI = 2;
5786}

5788/* *** */

5790ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
: VMContext(cgm.getLLVMContext()), CGM(cgm), ExternalProtocolPtrTy(nullptr)
5792{
CodeGen::CodeGenTypes &Types = CGM.getTypes();
ASTContext &Ctx = CGM.getContext();

ShortTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.ShortTy));
IntTy = CGM.IntTy;
LongTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.LongTy));
Int8PtrTy = CGM.Int8PtrTy;
Int8PtrPtrTy = CGM.Int8PtrPtrTy;

// arm64 targets use "int" ivar offset variables. All others,
// including OS X x86_64 and Windows x86_64, use "long" ivar offsets.
if (CGM.getTarget().getTriple().getArch() == llvm::Triple::aarch64)
  IvarOffsetVarTy = IntTy;
else
  IvarOffsetVarTy = LongTy;

ObjectPtrTy =
  cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCIdType()));
PtrObjectPtrTy =
  llvm::PointerType::getUnqual(ObjectPtrTy);
SelectorPtrTy =
  cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCSelType()));

// I'm not sure I like this. The implicit coordination is a bit
// gross. We should solve this in a reasonable fashion because this
// is a pretty common task (match some runtime data structure with
// an LLVM data structure).

// FIXME: This is leaked.
// FIXME: Merge with rewriter code?

// struct _objc_super {
//   id self;
//   Class cls;
// }
RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
                                    Ctx.getTranslationUnitDecl(),
                                    SourceLocation(), SourceLocation(),
                                    &Ctx.Idents.get("_objc_super"));
RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
                              nullptr, Ctx.getObjCIdType(), nullptr, nullptr,
                              false, ICIS_NoInit));
RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
                              nullptr, Ctx.getObjCClassType(), nullptr,
                              nullptr, false, ICIS_NoInit));
RD->completeDefinition();

SuperCTy = Ctx.getTagDeclType(RD);
SuperPtrCTy = Ctx.getPointerType(SuperCTy);

SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy));
SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);

// struct _prop_t {
//   char *name;
//   char *attributes;
// }
PropertyTy = llvm::StructType::create("struct._prop_t", Int8PtrTy, Int8PtrTy);

// struct _prop_list_t {
//   uint32_t entsize;      // sizeof(struct _prop_t)
//   uint32_t count_of_properties;
//   struct _prop_t prop_list[count_of_properties];
// }
PropertyListTy = llvm::StructType::create(
    "struct._prop_list_t", IntTy, IntTy, llvm::ArrayType::get(PropertyTy, 0));
// struct _prop_list_t *
PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);

// struct _objc_method {
//   SEL _cmd;
//   char *method_type;
//   char *_imp;
// }
MethodTy = llvm::StructType::create("struct._objc_method", SelectorPtrTy,
                                    Int8PtrTy, Int8PtrTy);

// struct _objc_cache *
CacheTy = llvm::StructType::create(VMContext, "struct._objc_cache");
CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
5873}

5875ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
: ObjCCommonTypesHelper(cgm) {
// struct _objc_method_description {
//   SEL name;
//   char *types;
// }
MethodDescriptionTy = llvm::StructType::create(
    "struct._objc_method_description", SelectorPtrTy, Int8PtrTy);

// struct _objc_method_description_list {
//   int count;
//   struct _objc_method_description[1];
// }
MethodDescriptionListTy =
    llvm::StructType::create("struct._objc_method_description_list", IntTy,
                             llvm::ArrayType::get(MethodDescriptionTy, 0));

// struct _objc_method_description_list *
MethodDescriptionListPtrTy =
  llvm::PointerType::getUnqual(MethodDescriptionListTy);

// Protocol description structures

// struct _objc_protocol_extension {
//   uint32_t size;  // sizeof(struct _objc_protocol_extension)
//   struct _objc_method_description_list *optional_instance_methods;
//   struct _objc_method_description_list *optional_class_methods;
//   struct _objc_property_list *instance_properties;
//   const char ** extendedMethodTypes;
//   struct _objc_property_list *class_properties;
// }
ProtocolExtensionTy = llvm::StructType::create(
    "struct._objc_protocol_extension", IntTy, MethodDescriptionListPtrTy,
    MethodDescriptionListPtrTy, PropertyListPtrTy, Int8PtrPtrTy,
    PropertyListPtrTy);

// struct _objc_protocol_extension *
ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);

// Handle recursive construction of Protocol and ProtocolList types

ProtocolTy =
  llvm::StructType::create(VMContext, "struct._objc_protocol");

ProtocolListTy =
  llvm::StructType::create(VMContext, "struct._objc_protocol_list");
ProtocolListTy->setBody(llvm::PointerType::getUnqual(ProtocolListTy), LongTy,
                        llvm::ArrayType::get(ProtocolTy, 0));

// struct _objc_protocol {
//   struct _objc_protocol_extension *isa;
//   char *protocol_name;
//   struct _objc_protocol **_objc_protocol_list;
//   struct _objc_method_description_list *instance_methods;
//   struct _objc_method_description_list *class_methods;
// }
ProtocolTy->setBody(ProtocolExtensionPtrTy, Int8PtrTy,
                    llvm::PointerType::getUnqual(ProtocolListTy),
                    MethodDescriptionListPtrTy, MethodDescriptionListPtrTy);

// struct _objc_protocol_list *
ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);

ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);

// Class description structures

// struct _objc_ivar {
//   char *ivar_name;
//   char *ivar_type;
//   int  ivar_offset;
// }
IvarTy = llvm::StructType::create("struct._objc_ivar", Int8PtrTy, Int8PtrTy,
                                  IntTy);

// struct _objc_ivar_list *
IvarListTy =
  llvm::StructType::create(VMContext, "struct._objc_ivar_list");
IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);

// struct _objc_method_list *
MethodListTy =
  llvm::StructType::create(VMContext, "struct._objc_method_list");
MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);

// struct _objc_class_extension *
ClassExtensionTy = llvm::StructType::create(
    "struct._objc_class_extension", IntTy, Int8PtrTy, PropertyListPtrTy);
ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);

ClassTy = llvm::StructType::create(VMContext, "struct._objc_class");

// struct _objc_class {
//   Class isa;
//   Class super_class;
//   char *name;
//   long version;
//   long info;
//   long instance_size;
//   struct _objc_ivar_list *ivars;
//   struct _objc_method_list *methods;
//   struct _objc_cache *cache;
//   struct _objc_protocol_list *protocols;
//   char *ivar_layout;
//   struct _objc_class_ext *ext;
// };
ClassTy->setBody(llvm::PointerType::getUnqual(ClassTy),
                 llvm::PointerType::getUnqual(ClassTy), Int8PtrTy, LongTy,
                 LongTy, LongTy, IvarListPtrTy, MethodListPtrTy, CachePtrTy,
                 ProtocolListPtrTy, Int8PtrTy, ClassExtensionPtrTy);

ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);

// struct _objc_category {
//   char *category_name;
//   char *class_name;
//   struct _objc_method_list *instance_method;
//   struct _objc_method_list *class_method;
//   struct _objc_protocol_list *protocols;
//   uint32_t size;  // sizeof(struct _objc_category)
//   struct _objc_property_list *instance_properties;// category's @property
//   struct _objc_property_list *class_properties;
// }
CategoryTy = llvm::StructType::create(
    "struct._objc_category", Int8PtrTy, Int8PtrTy, MethodListPtrTy,
    MethodListPtrTy, ProtocolListPtrTy, IntTy, PropertyListPtrTy,
    PropertyListPtrTy);

// Global metadata structures

// struct _objc_symtab {
//   long sel_ref_cnt;
//   SEL *refs;
//   short cls_def_cnt;
//   short cat_def_cnt;
//   char *defs[cls_def_cnt + cat_def_cnt];
// }
SymtabTy = llvm::StructType::create("struct._objc_symtab", LongTy,
                                    SelectorPtrTy, ShortTy, ShortTy,
                                    llvm::ArrayType::get(Int8PtrTy, 0));
SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);

// struct _objc_module {
//   long version;
//   long size;   // sizeof(struct _objc_module)
//   char *name;
//   struct _objc_symtab* symtab;
//  }
ModuleTy = llvm::StructType::create("struct._objc_module", LongTy, LongTy,
                                    Int8PtrTy, SymtabPtrTy);

// FIXME: This is the size of the setjmp buffer and should be target
// specific. 18 is what's used on 32-bit X86.
uint64_t SetJmpBufferSize = 18;

// Exceptions
llvm::Type *StackPtrTy = llvm::ArrayType::get(CGM.Int8PtrTy, 4);

ExceptionDataTy = llvm::StructType::create(
    "struct._objc_exception_data",
    llvm::ArrayType::get(CGM.Int32Ty, SetJmpBufferSize), StackPtrTy);
6036}

6038ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm)
: ObjCCommonTypesHelper(cgm) {
// struct _method_list_t {
//   uint32_t entsize;  // sizeof(struct _objc_method)
//   uint32_t method_count;
//   struct _objc_method method_list[method_count];
// }
MethodListnfABITy =
    llvm::StructType::create("struct.__method_list_t", IntTy, IntTy,
                             llvm::ArrayType::get(MethodTy, 0));
// struct method_list_t *
MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy);

// struct _protocol_t {
//   id isa;  // NULL
//   const char * const protocol_name;
//   const struct _protocol_list_t * protocol_list; // super protocols
//   const struct method_list_t * const instance_methods;
//   const struct method_list_t * const class_methods;
//   const struct method_list_t *optionalInstanceMethods;
//   const struct method_list_t *optionalClassMethods;
//   const struct _prop_list_t * properties;
//   const uint32_t size;  // sizeof(struct _protocol_t)
//   const uint32_t flags;  // = 0
//   const char ** extendedMethodTypes;
//   const char *demangledName;
//   const struct _prop_list_t * class_properties;
// }

// Holder for struct _protocol_list_t *
ProtocolListnfABITy =
  llvm::StructType::create(VMContext, "struct._objc_protocol_list");

ProtocolnfABITy = llvm::StructType::create(
    "struct._protocol_t", ObjectPtrTy, Int8PtrTy,
    llvm::PointerType::getUnqual(ProtocolListnfABITy), MethodListnfABIPtrTy,
    MethodListnfABIPtrTy, MethodListnfABIPtrTy, MethodListnfABIPtrTy,
    PropertyListPtrTy, IntTy, IntTy, Int8PtrPtrTy, Int8PtrTy,
    PropertyListPtrTy);

// struct _protocol_t*
ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy);

// struct _protocol_list_t {
//   long protocol_count;   // Note, this is 32/64 bit
//   struct _protocol_t *[protocol_count];
// }
ProtocolListnfABITy->setBody(LongTy,
                             llvm::ArrayType::get(ProtocolnfABIPtrTy, 0));

// struct _objc_protocol_list*
ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy);

// struct _ivar_t {
//   unsigned [long] int *offset;  // pointer to ivar offset location
//   char *name;
//   char *type;
//   uint32_t alignment;
//   uint32_t size;
// }
IvarnfABITy = llvm::StructType::create(
    "struct._ivar_t", llvm::PointerType::getUnqual(IvarOffsetVarTy),
    Int8PtrTy, Int8PtrTy, IntTy, IntTy);

// struct _ivar_list_t {
//   uint32 entsize;  // sizeof(struct _ivar_t)
//   uint32 count;
//   struct _iver_t list[count];
// }
IvarListnfABITy =
    llvm::StructType::create("struct._ivar_list_t", IntTy, IntTy,
                             llvm::ArrayType::get(IvarnfABITy, 0));

IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy);

// struct _class_ro_t {
//   uint32_t const flags;
//   uint32_t const instanceStart;
//   uint32_t const instanceSize;
//   uint32_t const reserved;  // only when building for 64bit targets
//   const uint8_t * const ivarLayout;
//   const char *const name;
//   const struct _method_list_t * const baseMethods;
//   const struct _objc_protocol_list *const baseProtocols;
//   const struct _ivar_list_t *const ivars;
//   const uint8_t * const weakIvarLayout;
//   const struct _prop_list_t * const properties;
// }

// FIXME. Add 'reserved' field in 64bit abi mode!
ClassRonfABITy = llvm::StructType::create(
    "struct._class_ro_t", IntTy, IntTy, IntTy, Int8PtrTy, Int8PtrTy,
    MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, IvarListnfABIPtrTy,
    Int8PtrTy, PropertyListPtrTy);

// ImpnfABITy - LLVM for id (*)(id, SEL, ...)
llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
ImpnfABITy = llvm::FunctionType::get(ObjectPtrTy, params, false)
               ->getPointerTo();

// struct _class_t {
//   struct _class_t *isa;
//   struct _class_t * const superclass;
//   void *cache;
//   IMP *vtable;
//   struct class_ro_t *ro;
// }

ClassnfABITy = llvm::StructType::create(VMContext, "struct._class_t");
ClassnfABITy->setBody(llvm::PointerType::getUnqual(ClassnfABITy),
                      llvm::PointerType::getUnqual(ClassnfABITy), CachePtrTy,
                      llvm::PointerType::getUnqual(ImpnfABITy),
                      llvm::PointerType::getUnqual(ClassRonfABITy));

// LLVM for struct _class_t *
ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy);

// struct _category_t {
//   const char * const name;
//   struct _class_t *const cls;
//   const struct _method_list_t * const instance_methods;
//   const struct _method_list_t * const class_methods;
//   const struct _protocol_list_t * const protocols;
//   const struct _prop_list_t * const properties;
//   const struct _prop_list_t * const class_properties;
//   const uint32_t size;
// }
CategorynfABITy = llvm::StructType::create(
    "struct._category_t", Int8PtrTy, ClassnfABIPtrTy, MethodListnfABIPtrTy,
    MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, PropertyListPtrTy,
    PropertyListPtrTy, IntTy);

// New types for nonfragile abi messaging.
CodeGen::CodeGenTypes &Types = CGM.getTypes();
ASTContext &Ctx = CGM.getContext();

// MessageRefTy - LLVM for:
// struct _message_ref_t {
//   IMP messenger;
//   SEL name;
// };

// First the clang type for struct _message_ref_t
RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
                                    Ctx.getTranslationUnitDecl(),
                                    SourceLocation(), SourceLocation(),
                                    &Ctx.Idents.get("_message_ref_t"));
RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
                              nullptr, Ctx.VoidPtrTy, nullptr, nullptr, false,
                              ICIS_NoInit));
RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
                              nullptr, Ctx.getObjCSelType(), nullptr, nullptr,
                              false, ICIS_NoInit));
RD->completeDefinition();

MessageRefCTy = Ctx.getTagDeclType(RD);
MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy);
MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy));

// MessageRefPtrTy - LLVM for struct _message_ref_t*
MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy);

// SuperMessageRefTy - LLVM for:
// struct _super_message_ref_t {
//   SUPER_IMP messenger;
//   SEL name;
// };
SuperMessageRefTy = llvm::StructType::create("struct._super_message_ref_t",
                                             ImpnfABITy, SelectorPtrTy);

// SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy);


// struct objc_typeinfo {
//   const void** vtable; // objc_ehtype_vtable + 2
//   const char*  name;    // c++ typeinfo string
//   Class        cls;
// };
EHTypeTy = llvm::StructType::create("struct._objc_typeinfo",
                                    llvm::PointerType::getUnqual(Int8PtrTy),
                                    Int8PtrTy, ClassnfABIPtrTy);
EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy);
6221}

6223llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() {
FinishNonFragileABIModule();

return nullptr;
6227}

6229void CGObjCNonFragileABIMac::AddModuleClassList(
  ArrayRef<llvm::GlobalValue *> Container, StringRef SymbolName,
  StringRef SectionName) {
unsigned NumClasses = Container.size();

if (!NumClasses)
  return;

SmallVector<llvm::Constant*, 8> Symbols(NumClasses);
for (unsigned i=0; i<NumClasses; i++)
  Symbols[i] = llvm::ConstantExpr::getBitCast(Container[i],
                                              ObjCTypes.Int8PtrTy);
llvm::Constant *Init =
  llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
                                                Symbols.size()),
                           Symbols);

// Section name is obtained by calling GetSectionName, which returns
// sections in the __DATA segment on MachO.
assert((!CGM.getTriple().isOSBinFormatMachO() ||((void)0)
        SectionName.startswith("__DATA")) &&((void)0)
       "SectionName expected to start with __DATA on MachO")((void)0);
llvm::GlobalVariable *GV = new llvm::GlobalVariable(
    CGM.getModule(), Init->getType(), false,
    llvm::GlobalValue::PrivateLinkage, Init, SymbolName);
GV->setAlignment(
    llvm::Align(CGM.getDataLayout().getABITypeAlignment(Init->getType())));
GV->setSection(SectionName);
CGM.addCompilerUsedGlobal(GV);
6258}

6260void CGObjCNonFragileABIMac::FinishNonFragileABIModule() {
// nonfragile abi has no module definition.

// Build list of all implemented class addresses in array
// L_OBJC_LABEL_CLASS_$.

for (unsigned i=0, NumClasses=ImplementedClasses.size(); i<NumClasses; i++) {
  const ObjCInterfaceDecl *ID = ImplementedClasses[i];
  assert(ID)((void)0);
  if (ObjCImplementationDecl *IMP = ID->getImplementation())
    // We are implementing a weak imported interface. Give it external linkage
    if (ID->isWeakImported() && !IMP->isWeakImported()) {
      DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
      DefinedMetaClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
    }
}

AddModuleClassList(DefinedClasses, "OBJC_LABEL_CLASS_$",
                   GetSectionName("__objc_classlist",
                                  "regular,no_dead_strip"));

AddModuleClassList(DefinedNonLazyClasses, "OBJC_LABEL_NONLAZY_CLASS_$",
                   GetSectionName("__objc_nlclslist",
                                  "regular,no_dead_strip"));

// Build list of all implemented category addresses in array
// L_OBJC_LABEL_CATEGORY_$.
AddModuleClassList(DefinedCategories, "OBJC_LABEL_CATEGORY_$",
                   GetSectionName("__objc_catlist",
                                  "regular,no_dead_strip"));
AddModuleClassList(DefinedStubCategories, "OBJC_LABEL_STUB_CATEGORY_$",
                   GetSectionName("__objc_catlist2",
                                  "regular,no_dead_strip"));
AddModuleClassList(DefinedNonLazyCategories, "OBJC_LABEL_NONLAZY_CATEGORY_$",
                   GetSectionName("__objc_nlcatlist",
                                  "regular,no_dead_strip"));

EmitImageInfo();
6298}

6300/// isVTableDispatchedSelector - Returns true if SEL is not in the list of
6301/// VTableDispatchMethods; false otherwise. What this means is that
6302/// except for the 19 selectors in the list, we generate 32bit-style
6303/// message dispatch call for all the rest.
6304bool CGObjCNonFragileABIMac::isVTableDispatchedSelector(Selector Sel) {
// At various points we've experimented with using vtable-based
// dispatch for all methods.
switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
case CodeGenOptions::Legacy:
  return false;
case CodeGenOptions::NonLegacy:
  return true;
case CodeGenOptions::Mixed:
  break;
}

// If so, see whether this selector is in the white-list of things which must
// use the new dispatch convention. We lazily build a dense set for this.
if (VTableDispatchMethods.empty()) {
  VTableDispatchMethods.insert(GetNullarySelector("alloc"));
  VTableDispatchMethods.insert(GetNullarySelector("class"));
  VTableDispatchMethods.insert(GetNullarySelector("self"));
  VTableDispatchMethods.insert(GetNullarySelector("isFlipped"));
  VTableDispatchMethods.insert(GetNullarySelector("length"));
  VTableDispatchMethods.insert(GetNullarySelector("count"));

  // These are vtable-based if GC is disabled.
  // Optimistically use vtable dispatch for hybrid compiles.
  if (CGM.getLangOpts().getGC() != LangOptions::GCOnly) {
    VTableDispatchMethods.insert(GetNullarySelector("retain"));
    VTableDispatchMethods.insert(GetNullarySelector("release"));
    VTableDispatchMethods.insert(GetNullarySelector("autorelease"));
  }

  VTableDispatchMethods.insert(GetUnarySelector("allocWithZone"));
  VTableDispatchMethods.insert(GetUnarySelector("isKindOfClass"));
  VTableDispatchMethods.insert(GetUnarySelector("respondsToSelector"));
  VTableDispatchMethods.insert(GetUnarySelector("objectForKey"));
  VTableDispatchMethods.insert(GetUnarySelector("objectAtIndex"));
  VTableDispatchMethods.insert(GetUnarySelector("isEqualToString"));
  VTableDispatchMethods.insert(GetUnarySelector("isEqual"));

  // These are vtable-based if GC is enabled.
  // Optimistically use vtable dispatch for hybrid compiles.
  if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
    VTableDispatchMethods.insert(GetNullarySelector("hash"));
    VTableDispatchMethods.insert(GetUnarySelector("addObject"));

    // "countByEnumeratingWithState:objects:count"
    IdentifierInfo *KeyIdents[] = {
      &CGM.getContext().Idents.get("countByEnumeratingWithState"),
      &CGM.getContext().Idents.get("objects"),
      &CGM.getContext().Idents.get("count")
    };
    VTableDispatchMethods.insert(
      CGM.getContext().Selectors.getSelector(3, KeyIdents));
  }
}

return VTableDispatchMethods.count(Sel);
6360}

6362/// BuildClassRoTInitializer - generate meta-data for:
6363/// struct _class_ro_t {
6364///   uint32_t const flags;
6365///   uint32_t const instanceStart;
6366///   uint32_t const instanceSize;
6367///   uint32_t const reserved;  // only when building for 64bit targets
6368///   const uint8_t * const ivarLayout;
6369///   const char *const name;
6370///   const struct _method_list_t * const baseMethods;
6371///   const struct _protocol_list_t *const baseProtocols;
6372///   const struct _ivar_list_t *const ivars;
6373///   const uint8_t * const weakIvarLayout;
6374///   const struct _prop_list_t * const properties;
6375/// }
6376///
6377llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer(
unsigned flags,
unsigned InstanceStart,
unsigned InstanceSize,
const ObjCImplementationDecl *ID) {
std::string ClassName = std::string(ID->getObjCRuntimeNameAsString());

CharUnits beginInstance = CharUnits::fromQuantity(InstanceStart);
CharUnits endInstance = CharUnits::fromQuantity(InstanceSize);

bool hasMRCWeak = false;
if (CGM.getLangOpts().ObjCAutoRefCount)
  flags |= NonFragileABI_Class_CompiledByARC;
else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
  flags |= NonFragileABI_Class_HasMRCWeakIvars;

ConstantInitBuilder builder(CGM);
auto values = builder.beginStruct(ObjCTypes.ClassRonfABITy);

values.addInt(ObjCTypes.IntTy, flags);
values.addInt(ObjCTypes.IntTy, InstanceStart);
values.addInt(ObjCTypes.IntTy, InstanceSize);
values.add((flags & NonFragileABI_Class_Meta)
              ? GetIvarLayoutName(nullptr, ObjCTypes)
              : BuildStrongIvarLayout(ID, beginInstance, endInstance));
values.add(GetClassName(ID->getObjCRuntimeNameAsString()));

// const struct _method_list_t * const baseMethods;
SmallVector<const ObjCMethodDecl*, 16> methods;
if (flags & NonFragileABI_Class_Meta) {
  for (const auto *MD : ID->class_methods())
    if (!MD->isDirectMethod())
      methods.push_back(MD);
} else {
  for (const auto *MD : ID->instance_methods())
    if (!MD->isDirectMethod())
      methods.push_back(MD);
}

values.add(emitMethodList(ID->getObjCRuntimeNameAsString(),
                          (flags & NonFragileABI_Class_Meta)
                             ? MethodListType::ClassMethods
                             : MethodListType::InstanceMethods,
                          methods));

const ObjCInterfaceDecl *OID = ID->getClassInterface();
assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer")((void)0);
values.add(EmitProtocolList("_OBJC_CLASS_PROTOCOLS_$_"
                              + OID->getObjCRuntimeNameAsString(),
                            OID->all_referenced_protocol_begin(),
                            OID->all_referenced_protocol_end()));

if (flags & NonFragileABI_Class_Meta) {
  values.addNullPointer(ObjCTypes.IvarListnfABIPtrTy);
  values.add(GetIvarLayoutName(nullptr, ObjCTypes));
  values.add(EmitPropertyList(
      "_OBJC_$_CLASS_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
      ID, ID->getClassInterface(), ObjCTypes, true));
} else {
  values.add(EmitIvarList(ID));
  values.add(BuildWeakIvarLayout(ID, beginInstance, endInstance, hasMRCWeak));
  values.add(EmitPropertyList(
      "_OBJC_$_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
      ID, ID->getClassInterface(), ObjCTypes, false));
}

llvm::SmallString<64> roLabel;
llvm::raw_svector_ostream(roLabel)
    << ((flags & NonFragileABI_Class_Meta) ? "_OBJC_METACLASS_RO_$_"
                                           : "_OBJC_CLASS_RO_$_")
    << ClassName;

return finishAndCreateGlobal(values, roLabel, CGM);
6450}

6452/// Build the metaclass object for a class.
6453///
6454/// struct _class_t {
6455///   struct _class_t *isa;
6456///   struct _class_t * const superclass;
6457///   void *cache;
6458///   IMP *vtable;
6459///   struct class_ro_t *ro;
6460/// }
6461///
6462llvm::GlobalVariable *
6463CGObjCNonFragileABIMac::BuildClassObject(const ObjCInterfaceDecl *CI,
                                       bool isMetaclass,
                                       llvm::Constant *IsAGV,
                                       llvm::Constant *SuperClassGV,
                                       llvm::Constant *ClassRoGV,
                                       bool HiddenVisibility) {
ConstantInitBuilder builder(CGM);
auto values = builder.beginStruct(ObjCTypes.ClassnfABITy);
values.add(IsAGV);
if (SuperClassGV) {
  values.add(SuperClassGV);
} else {
  values.addNullPointer(ObjCTypes.ClassnfABIPtrTy);
}
values.add(ObjCEmptyCacheVar);
values.add(ObjCEmptyVtableVar);
values.add(ClassRoGV);

llvm::GlobalVariable *GV =
  cast<llvm::GlobalVariable>(GetClassGlobal(CI, isMetaclass, ForDefinition));
values.finishAndSetAsInitializer(GV);

if (CGM.getTriple().isOSBinFormatMachO())
  GV->setSection("__DATA, __objc_data");
GV->setAlignment(llvm::Align(
    CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassnfABITy)));
if (!CGM.getTriple().isOSBinFormatCOFF())
  if (HiddenVisibility)
    GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
return GV;
6493}

6495bool CGObjCNonFragileABIMac::ImplementationIsNonLazy(
  const ObjCImplDecl *OD) const {
return OD->getClassMethod(GetNullarySelector("load")) != nullptr ||
       OD->getClassInterface()->hasAttr<ObjCNonLazyClassAttr>() ||
       OD->hasAttr<ObjCNonLazyClassAttr>();
6500}

6502void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID,
                                            uint32_t &InstanceStart,
                                            uint32_t &InstanceSize) {
const ASTRecordLayout &RL =
  CGM.getContext().getASTObjCImplementationLayout(OID);

// InstanceSize is really instance end.
InstanceSize = RL.getDataSize().getQuantity();

// If there are no fields, the start is the same as the end.
if (!RL.getFieldCount())
  InstanceStart = InstanceSize;
else
  InstanceStart = RL.getFieldOffset(0) / CGM.getContext().getCharWidth();
6516}

6518static llvm::GlobalValue::DLLStorageClassTypes getStorage(CodeGenModule &CGM,
                                                        StringRef Name) {
IdentifierInfo &II = CGM.getContext().Idents.get(Name);
TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl();
DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);

const VarDecl *VD = nullptr;
for (const auto *Result : DC->lookup(&II))
  if ((VD = dyn_cast<VarDecl>(Result)))
    break;

if (!VD)
  return llvm::GlobalValue::DLLImportStorageClass;
if (VD->hasAttr<DLLExportAttr>())
  return llvm::GlobalValue::DLLExportStorageClass;
if (VD->hasAttr<DLLImportAttr>())
  return llvm::GlobalValue::DLLImportStorageClass;
return llvm::GlobalValue::DefaultStorageClass;
6536}

6538void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
if (!ObjCEmptyCacheVar) {
  ObjCEmptyCacheVar =
      new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.CacheTy, false,
                               llvm::GlobalValue::ExternalLinkage, nullptr,
                               "_objc_empty_cache");
  if (CGM.getTriple().isOSBinFormatCOFF())
    ObjCEmptyCacheVar->setDLLStorageClass(getStorage(CGM, "_objc_empty_cache"));

  // Only OS X with deployment version <10.9 use the empty vtable symbol
  const llvm::Triple &Triple = CGM.getTarget().getTriple();
  if (Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 9))
    ObjCEmptyVtableVar =
        new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ImpnfABITy, false,
                                 llvm::GlobalValue::ExternalLinkage, nullptr,
                                 "_objc_empty_vtable");
  else
    ObjCEmptyVtableVar =
      llvm::ConstantPointerNull::get(ObjCTypes.ImpnfABITy->getPointerTo());
}

// FIXME: Is this correct (that meta class size is never computed)?
uint32_t InstanceStart =
  CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassnfABITy);
uint32_t InstanceSize = InstanceStart;
uint32_t flags = NonFragileABI_Class_Meta;

llvm::Constant *SuperClassGV, *IsAGV;

const auto *CI = ID->getClassInterface();
assert(CI && "CGObjCNonFragileABIMac::GenerateClass - class is 0")((void)0);

// Build the flags for the metaclass.
bool classIsHidden = (CGM.getTriple().isOSBinFormatCOFF())
                         ? !CI->hasAttr<DLLExportAttr>()
                         : CI->getVisibility() == HiddenVisibility;
if (classIsHidden)
  flags |= NonFragileABI_Class_Hidden;

// FIXME: why is this flag set on the metaclass?
// ObjC metaclasses have no fields and don't really get constructed.
if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
  flags |= NonFragileABI_Class_HasCXXStructors;
  if (!ID->hasNonZeroConstructors())
    flags |= NonFragileABI_Class_HasCXXDestructorOnly;
}

if (!CI->getSuperClass()) {
  // class is root
  flags |= NonFragileABI_Class_Root;

  SuperClassGV = GetClassGlobal(CI, /*metaclass*/ false, NotForDefinition);
  IsAGV = GetClassGlobal(CI, /*metaclass*/ true, NotForDefinition);
} else {
  // Has a root. Current class is not a root.
  const ObjCInterfaceDecl *Root = ID->getClassInterface();
  while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
    Root = Super;

  const auto *Super = CI->getSuperClass();
  IsAGV = GetClassGlobal(Root, /*metaclass*/ true, NotForDefinition);
  SuperClassGV = GetClassGlobal(Super, /*metaclass*/ true, NotForDefinition);
}

llvm::GlobalVariable *CLASS_RO_GV =
    BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);

llvm::GlobalVariable *MetaTClass =
  BuildClassObject(CI, /*metaclass*/ true,
                   IsAGV, SuperClassGV, CLASS_RO_GV, classIsHidden);
CGM.setGVProperties(MetaTClass, CI);
DefinedMetaClasses.push_back(MetaTClass);

// Metadata for the class
flags = 0;
if (classIsHidden)
  flags |= NonFragileABI_Class_Hidden;

if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
  flags |= NonFragileABI_Class_HasCXXStructors;

  // Set a flag to enable a runtime optimization when a class has
  // fields that require destruction but which don't require
  // anything except zero-initialization during construction.  This
  // is most notably true of __strong and __weak types, but you can
  // also imagine there being C++ types with non-trivial default
  // constructors that merely set all fields to null.
  if (!ID->hasNonZeroConstructors())
    flags |= NonFragileABI_Class_HasCXXDestructorOnly;
}

if (hasObjCExceptionAttribute(CGM.getContext(), CI))
  flags |= NonFragileABI_Class_Exception;

if (!CI->getSuperClass()) {
  flags |= NonFragileABI_Class_Root;
  SuperClassGV = nullptr;
} else {
  // Has a root. Current class is not a root.
  const auto *Super = CI->getSuperClass();
  SuperClassGV = GetClassGlobal(Super, /*metaclass*/ false, NotForDefinition);
}

GetClassSizeInfo(ID, InstanceStart, InstanceSize);
CLASS_RO_GV =
    BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);

llvm::GlobalVariable *ClassMD =
  BuildClassObject(CI, /*metaclass*/ false,
                   MetaTClass, SuperClassGV, CLASS_RO_GV, classIsHidden);
CGM.setGVProperties(ClassMD, CI);
DefinedClasses.push_back(ClassMD);
ImplementedClasses.push_back(CI);

// Determine if this class is also "non-lazy".
if (ImplementationIsNonLazy(ID))
  DefinedNonLazyClasses.push_back(ClassMD);

// Force the definition of the EHType if necessary.
if (flags & NonFragileABI_Class_Exception)
  (void) GetInterfaceEHType(CI, ForDefinition);
// Make sure method definition entries are all clear for next implementation.
MethodDefinitions.clear();
6661}

6663/// GenerateProtocolRef - This routine is called to generate code for
6664/// a protocol reference expression; as in:
6665/// @code
6666///   @protocol(Proto1);
6667/// @endcode
6668/// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1
6669/// which will hold address of the protocol meta-data.
6670///
6671llvm::Value *CGObjCNonFragileABIMac::GenerateProtocolRef(CodeGenFunction &CGF,
                                                       const ObjCProtocolDecl *PD) {

// This routine is called for @protocol only. So, we must build definition
// of protocol's meta-data (not a reference to it!)
assert(!PD->isNonRuntimeProtocol() &&((void)0)
       "attempting to get a protocol ref to a static protocol.")((void)0);
llvm::Constant *Init =
  llvm::ConstantExpr::getBitCast(GetOrEmitProtocol(PD),
                                 ObjCTypes.getExternalProtocolPtrTy());

std::string ProtocolName("_OBJC_PROTOCOL_REFERENCE_$_");
ProtocolName += PD->getObjCRuntimeNameAsString();

CharUnits Align = CGF.getPointerAlign();

llvm::GlobalVariable *PTGV = CGM.getModule().getGlobalVariable(ProtocolName);
if (PTGV)
  return CGF.Builder.CreateAlignedLoad(PTGV->getValueType(), PTGV, Align);
PTGV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
                                llvm::GlobalValue::WeakAnyLinkage, Init,
                                ProtocolName);
PTGV->setSection(GetSectionName("__objc_protorefs",
                                "coalesced,no_dead_strip"));
PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
PTGV->setAlignment(Align.getAsAlign());
if (!CGM.getTriple().isOSBinFormatMachO())
  PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolName));
CGM.addUsedGlobal(PTGV);
return CGF.Builder.CreateAlignedLoad(PTGV->getValueType(), PTGV, Align);
6701}

6703/// GenerateCategory - Build metadata for a category implementation.
6704/// struct _category_t {
6705///   const char * const name;
6706///   struct _class_t *const cls;
6707///   const struct _method_list_t * const instance_methods;
6708///   const struct _method_list_t * const class_methods;
6709///   const struct _protocol_list_t * const protocols;
6710///   const struct _prop_list_t * const properties;
6711///   const struct _prop_list_t * const class_properties;
6712///   const uint32_t size;
6713/// }
6714///
6715void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
const char *Prefix = "_OBJC_$_CATEGORY_";

llvm::SmallString<64> ExtCatName(Prefix);
ExtCatName += Interface->getObjCRuntimeNameAsString();
ExtCatName += "_$_";
ExtCatName += OCD->getNameAsString();

ConstantInitBuilder builder(CGM);
auto values = builder.beginStruct(ObjCTypes.CategorynfABITy);
values.add(GetClassName(OCD->getIdentifier()->getName()));
// meta-class entry symbol
values.add(GetClassGlobal(Interface, /*metaclass*/ false, NotForDefinition));
std::string listName =
    (Interface->getObjCRuntimeNameAsString() + "_$_" + OCD->getName()).str();

SmallVector<const ObjCMethodDecl *, 16> instanceMethods;
SmallVector<const ObjCMethodDecl *, 8> classMethods;
for (const auto *MD : OCD->methods()) {
  if (MD->isDirectMethod())
    continue;
  if (MD->isInstanceMethod()) {
    instanceMethods.push_back(MD);
  } else {
    classMethods.push_back(MD);
  }
}

values.add(emitMethodList(listName, MethodListType::CategoryInstanceMethods,
                          instanceMethods));
values.add(emitMethodList(listName, MethodListType::CategoryClassMethods,
                          classMethods));

const ObjCCategoryDecl *Category =
  Interface->FindCategoryDeclaration(OCD->getIdentifier());
if (Category) {
  SmallString<256> ExtName;
  llvm::raw_svector_ostream(ExtName) << Interface->getObjCRuntimeNameAsString() << "_$_"
                                     << OCD->getName();
  values.add(EmitProtocolList("_OBJC_CATEGORY_PROTOCOLS_$_"
                                 + Interface->getObjCRuntimeNameAsString() + "_$_"
                                 + Category->getName(),
                              Category->protocol_begin(),
                              Category->protocol_end()));
  values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(),
                              OCD, Category, ObjCTypes, false));
  values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
                              OCD, Category, ObjCTypes, true));
} else {
  values.addNullPointer(ObjCTypes.ProtocolListnfABIPtrTy);
  values.addNullPointer(ObjCTypes.PropertyListPtrTy);
  values.addNullPointer(ObjCTypes.PropertyListPtrTy);
}

unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategorynfABITy);
values.addInt(ObjCTypes.IntTy, Size);

llvm::GlobalVariable *GCATV =
    finishAndCreateGlobal(values, ExtCatName.str(), CGM);
CGM.addCompilerUsedGlobal(GCATV);
if (Interface->hasAttr<ObjCClassStubAttr>())
  DefinedStubCategories.push_back(GCATV);
else
  DefinedCategories.push_back(GCATV);

// Determine if this category is also "non-lazy".
if (ImplementationIsNonLazy(OCD))
  DefinedNonLazyCategories.push_back(GCATV);
// method definition entries must be clear for next implementation.
MethodDefinitions.clear();
6786}

6788/// emitMethodConstant - Return a struct objc_method constant.  If
6789/// forProtocol is true, the implementation will be null; otherwise,
6790/// the method must have a definition registered with the runtime.
6791///
6792/// struct _objc_method {
6793///   SEL _cmd;
6794///   char *method_type;
6795///   char *_imp;
6796/// }
6797void CGObjCNonFragileABIMac::emitMethodConstant(ConstantArrayBuilder &builder,
                                              const ObjCMethodDecl *MD,
                                              bool forProtocol) {
auto method = builder.beginStruct(ObjCTypes.MethodTy);
method.addBitCast(GetMethodVarName(MD->getSelector()),
                  ObjCTypes.SelectorPtrTy);
method.add(GetMethodVarType(MD));

if (forProtocol) {
  // Protocol methods have no implementation. So, this entry is always NULL.
  method.addNullPointer(ObjCTypes.Int8PtrTy);
} else {
  llvm::Function *fn = GetMethodDefinition(MD);
  assert(fn && "no definition for method?")((void)0);
  method.addBitCast(fn, ObjCTypes.Int8PtrTy);
}

method.finishAndAddTo(builder);
6815}

6817/// Build meta-data for method declarations.
6818///
6819/// struct _method_list_t {
6820///   uint32_t entsize;  // sizeof(struct _objc_method)
6821///   uint32_t method_count;
6822///   struct _objc_method method_list[method_count];
6823/// }
6824///
6825llvm::Constant *
6826CGObjCNonFragileABIMac::emitMethodList(Twine name, MethodListType kind,
                            ArrayRef<const ObjCMethodDecl *> methods) {
// Return null for empty list.
if (methods.empty())
  return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy);

StringRef prefix;
bool forProtocol;
switch (kind) {
case MethodListType::CategoryInstanceMethods:
  prefix = "_OBJC_$_CATEGORY_INSTANCE_METHODS_";
  forProtocol = false;
  break;
case MethodListType::CategoryClassMethods:
  prefix = "_OBJC_$_CATEGORY_CLASS_METHODS_";
  forProtocol = false;
  break;
case MethodListType::InstanceMethods:
  prefix = "_OBJC_$_INSTANCE_METHODS_";
  forProtocol = false;
  break;
case MethodListType::ClassMethods:
  prefix = "_OBJC_$_CLASS_METHODS_";
  forProtocol = false;
  break;

case MethodListType::ProtocolInstanceMethods:
  prefix = "_OBJC_$_PROTOCOL_INSTANCE_METHODS_";
  forProtocol = true;
  break;
case MethodListType::ProtocolClassMethods:
  prefix = "_OBJC_$_PROTOCOL_CLASS_METHODS_";
  forProtocol = true;
  break;
case MethodListType::OptionalProtocolInstanceMethods:
  prefix = "_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_";
  forProtocol = true;
  break;
case MethodListType::OptionalProtocolClassMethods:
  prefix = "_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_";
  forProtocol = true;
  break;
}

ConstantInitBuilder builder(CGM);
auto values = builder.beginStruct();

// sizeof(struct _objc_method)
unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.MethodTy);
values.addInt(ObjCTypes.IntTy, Size);
// method_count
values.addInt(ObjCTypes.IntTy, methods.size());
auto methodArray = values.beginArray(ObjCTypes.MethodTy);
for (auto MD : methods)
  emitMethodConstant(methodArray, MD, forProtocol);
methodArray.finishAndAddTo(values);

llvm::GlobalVariable *GV = finishAndCreateGlobal(values, prefix + name, CGM);
CGM.addCompilerUsedGlobal(GV);
return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListnfABIPtrTy);
6886}

6888/// ObjCIvarOffsetVariable - Returns the ivar offset variable for
6889/// the given ivar.
6890llvm::GlobalVariable *
6891CGObjCNonFragileABIMac::ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
                                             const ObjCIvarDecl *Ivar) {
const ObjCInterfaceDecl *Container = Ivar->getContainingInterface();
llvm::SmallString<64> Name("OBJC_IVAR_$_");
Name += Container->getObjCRuntimeNameAsString();
Name += ".";
Name += Ivar->getName();
llvm::GlobalVariable *IvarOffsetGV = CGM.getModule().getGlobalVariable(Name);
if (!IvarOffsetGV) {
  IvarOffsetGV =
      new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.IvarOffsetVarTy,
                               false, llvm::GlobalValue::ExternalLinkage,
                               nullptr, Name.str());
  if (CGM.getTriple().isOSBinFormatCOFF()) {
    bool IsPrivateOrPackage =
        Ivar->getAccessControl() == ObjCIvarDecl::Private ||
        Ivar->getAccessControl() == ObjCIvarDecl::Package;

    const ObjCInterfaceDecl *ContainingID = Ivar->getContainingInterface();

    if (ContainingID->hasAttr<DLLImportAttr>())
      IvarOffsetGV
          ->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
    else if (ContainingID->hasAttr<DLLExportAttr>() && !IsPrivateOrPackage)
      IvarOffsetGV
          ->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
  }
}
return IvarOffsetGV;
6920}

6922llvm::Constant *
6923CGObjCNonFragileABIMac::EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
                                        const ObjCIvarDecl *Ivar,
                                        unsigned long int Offset) {
llvm::GlobalVariable *IvarOffsetGV = ObjCIvarOffsetVariable(ID, Ivar);
IvarOffsetGV->setInitializer(
    llvm::ConstantInt::get(ObjCTypes.IvarOffsetVarTy, Offset));
IvarOffsetGV->setAlignment(llvm::Align(
    CGM.getDataLayout().getABITypeAlignment(ObjCTypes.IvarOffsetVarTy)));

if (!CGM.getTriple().isOSBinFormatCOFF()) {
  // FIXME: This matches gcc, but shouldn't the visibility be set on the use
  // as well (i.e., in ObjCIvarOffsetVariable).
  if (Ivar->getAccessControl() == ObjCIvarDecl::Private ||
      Ivar->getAccessControl() == ObjCIvarDecl::Package ||
      ID->getVisibility() == HiddenVisibility)
    IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
  else
    IvarOffsetGV->setVisibility(llvm::GlobalValue::DefaultVisibility);
}

// If ID's layout is known, then make the global constant. This serves as a
// useful assertion: we'll never use this variable to calculate ivar offsets,
// so if the runtime tries to patch it then we should crash.
if (isClassLayoutKnownStatically(ID))
  IvarOffsetGV->setConstant(true);

if (CGM.getTriple().isOSBinFormatMachO())
  IvarOffsetGV->setSection("__DATA, __objc_ivar");
return IvarOffsetGV;
6952}

6954/// EmitIvarList - Emit the ivar list for the given
6955/// implementation. The return value has type
6956/// IvarListnfABIPtrTy.
6957///  struct _ivar_t {
6958///   unsigned [long] int *offset;  // pointer to ivar offset location
6959///   char *name;
6960///   char *type;
6961///   uint32_t alignment;
6962///   uint32_t size;
6963/// }
6964/// struct _ivar_list_t {
6965///   uint32 entsize;  // sizeof(struct _ivar_t)
6966///   uint32 count;
6967///   struct _iver_t list[count];
6968/// }
6969///

6971llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList(
const ObjCImplementationDecl *ID) {

ConstantInitBuilder builder(CGM);
auto ivarList = builder.beginStruct();
ivarList.addInt(ObjCTypes.IntTy,
                CGM.getDataLayout().getTypeAllocSize(ObjCTypes.IvarnfABITy));
auto ivarCountSlot = ivarList.addPlaceholder();
auto ivars = ivarList.beginArray(ObjCTypes.IvarnfABITy);

const ObjCInterfaceDecl *OID = ID->getClassInterface();
assert(OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface")((void)0);

// FIXME. Consolidate this with similar code in GenerateClass.

for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
     IVD; IVD = IVD->getNextIvar()) {
  // Ignore unnamed bit-fields.
  if (!IVD->getDeclName())
    continue;

  auto ivar = ivars.beginStruct(ObjCTypes.IvarnfABITy);
  ivar.add(EmitIvarOffsetVar(ID->getClassInterface(), IVD,
                             ComputeIvarBaseOffset(CGM, ID, IVD)));
  ivar.add(GetMethodVarName(IVD->getIdentifier()));
  ivar.add(GetMethodVarType(IVD));
  llvm::Type *FieldTy =
    CGM.getTypes().ConvertTypeForMem(IVD->getType());
  unsigned Size = CGM.getDataLayout().getTypeAllocSize(FieldTy);
  unsigned Align = CGM.getContext().getPreferredTypeAlign(
    IVD->getType().getTypePtr()) >> 3;
  Align = llvm::Log2_32(Align);
  ivar.addInt(ObjCTypes.IntTy, Align);
  // NOTE. Size of a bitfield does not match gcc's, because of the
  // way bitfields are treated special in each. But I am told that
  // 'size' for bitfield ivars is ignored by the runtime so it does
  // not matter.  If it matters, there is enough info to get the
  // bitfield right!
  ivar.addInt(ObjCTypes.IntTy, Size);
  ivar.finishAndAddTo(ivars);
}
// Return null for empty list.
if (ivars.empty()) {
  ivars.abandon();
  ivarList.abandon();
  return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
}

auto ivarCount = ivars.size();
ivars.finishAndAddTo(ivarList);
ivarList.fillPlaceholderWithInt(ivarCountSlot, ObjCTypes.IntTy, ivarCount);

const char *Prefix = "_OBJC_$_INSTANCE_VARIABLES_";
llvm::GlobalVariable *GV = finishAndCreateGlobal(
    ivarList, Prefix + OID->getObjCRuntimeNameAsString(), CGM);
CGM.addCompilerUsedGlobal(GV);
return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListnfABIPtrTy);
7028}

7030llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocolRef(
const ObjCProtocolDecl *PD) {
llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];

assert(!PD->isNonRuntimeProtocol() &&((void)0)
       "attempting to GetOrEmit a non-runtime protocol")((void)0);
if (!Entry) {
  // We use the initializer as a marker of whether this is a forward
  // reference or not. At module finalization we add the empty
  // contents for protocols which were referenced but never defined.
  llvm::SmallString<64> Protocol;
  llvm::raw_svector_ostream(Protocol) << "_OBJC_PROTOCOL_$_"
                                      << PD->getObjCRuntimeNameAsString();

  Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy,
                                   false, llvm::GlobalValue::ExternalLinkage,
                                   nullptr, Protocol);
  if (!CGM.getTriple().isOSBinFormatMachO())
    Entry->setComdat(CGM.getModule().getOrInsertComdat(Protocol));
}

return Entry;
7052}

7054/// GetOrEmitProtocol - Generate the protocol meta-data:
7055/// @code
7056/// struct _protocol_t {
7057///   id isa;  // NULL
7058///   const char * const protocol_name;
7059///   const struct _protocol_list_t * protocol_list; // super protocols
7060///   const struct method_list_t * const instance_methods;
7061///   const struct method_list_t * const class_methods;
7062///   const struct method_list_t *optionalInstanceMethods;
7063///   const struct method_list_t *optionalClassMethods;
7064///   const struct _prop_list_t * properties;
7065///   const uint32_t size;  // sizeof(struct _protocol_t)
7066///   const uint32_t flags;  // = 0
7067///   const char ** extendedMethodTypes;
7068///   const char *demangledName;
7069///   const struct _prop_list_t * class_properties;
7070/// }
7071/// @endcode
7072///

7074llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol(
const ObjCProtocolDecl *PD) {
llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];

// Early exit if a defining object has already been generated.
if (Entry && Entry->hasInitializer())
  return Entry;

// Use the protocol definition, if there is one.
assert(PD->hasDefinition() &&((void)0)
       "emitting protocol metadata without definition")((void)0);
PD = PD->getDefinition();

auto methodLists = ProtocolMethodLists::get(PD);

ConstantInitBuilder builder(CGM);
auto values = builder.beginStruct(ObjCTypes.ProtocolnfABITy);

// isa is NULL
values.addNullPointer(ObjCTypes.ObjectPtrTy);
values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
values.add(EmitProtocolList("_OBJC_$_PROTOCOL_REFS_"
                              + PD->getObjCRuntimeNameAsString(),
                             PD->protocol_begin(),
                             PD->protocol_end()));
values.add(methodLists.emitMethodList(this, PD,
                               ProtocolMethodLists::RequiredInstanceMethods));
values.add(methodLists.emitMethodList(this, PD,
                               ProtocolMethodLists::RequiredClassMethods));
values.add(methodLists.emitMethodList(this, PD,
                               ProtocolMethodLists::OptionalInstanceMethods));
values.add(methodLists.emitMethodList(this, PD,
                               ProtocolMethodLists::OptionalClassMethods));
values.add(EmitPropertyList(
             "_OBJC_$_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
             nullptr, PD, ObjCTypes, false));
uint32_t Size =
  CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolnfABITy);
values.addInt(ObjCTypes.IntTy, Size);
values.addInt(ObjCTypes.IntTy, 0);
values.add(EmitProtocolMethodTypes("_OBJC_$_PROTOCOL_METHOD_TYPES_"
                                     + PD->getObjCRuntimeNameAsString(),
                                   methodLists.emitExtendedTypesArray(this),
                                   ObjCTypes));

// const char *demangledName;
values.addNullPointer(ObjCTypes.Int8PtrTy);

values.add(EmitPropertyList(
    "_OBJC_$_CLASS_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
    nullptr, PD, ObjCTypes, true));

if (Entry) {
  // Already created, fix the linkage and update the initializer.
  Entry->setLinkage(llvm::GlobalValue::WeakAnyLinkage);
  values.finishAndSetAsInitializer(Entry);
} else {
  llvm::SmallString<64> symbolName;
  llvm::raw_svector_ostream(symbolName)
    << "_OBJC_PROTOCOL_$_" << PD->getObjCRuntimeNameAsString();

  Entry = values.finishAndCreateGlobal(symbolName, CGM.getPointerAlign(),
                                       /*constant*/ false,
                                       llvm::GlobalValue::WeakAnyLinkage);
  if (!CGM.getTriple().isOSBinFormatMachO())
    Entry->setComdat(CGM.getModule().getOrInsertComdat(symbolName));

  Protocols[PD->getIdentifier()] = Entry;
}
Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
CGM.addUsedGlobal(Entry);

// Use this protocol meta-data to build protocol list table in section
// __DATA, __objc_protolist
llvm::SmallString<64> ProtocolRef;
llvm::raw_svector_ostream(ProtocolRef) << "_OBJC_LABEL_PROTOCOL_$_"
                                       << PD->getObjCRuntimeNameAsString();

llvm::GlobalVariable *PTGV =
  new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABIPtrTy,
                           false, llvm::GlobalValue::WeakAnyLinkage, Entry,
                           ProtocolRef);
if (!CGM.getTriple().isOSBinFormatMachO())
  PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolRef));
PTGV->setAlignment(llvm::Align(
    CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ProtocolnfABIPtrTy)));
PTGV->setSection(GetSectionName("__objc_protolist",
                                "coalesced,no_dead_strip"));
PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
CGM.addUsedGlobal(PTGV);
return Entry;
7165}

7167/// EmitProtocolList - Generate protocol list meta-data:
7168/// @code
7169/// struct _protocol_list_t {
7170///   long protocol_count;   // Note, this is 32/64 bit
7171///   struct _protocol_t[protocol_count];
7172/// }
7173/// @endcode
7174///
7175llvm::Constant *
7176CGObjCNonFragileABIMac::EmitProtocolList(Twine Name,
                                    ObjCProtocolDecl::protocol_iterator begin,
                                    ObjCProtocolDecl::protocol_iterator end) {
// Just return null for empty protocol lists
auto Protocols = GetRuntimeProtocolList(begin, end);
if (Protocols.empty())
  return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);

SmallVector<llvm::Constant *, 16> ProtocolRefs;
ProtocolRefs.reserve(Protocols.size());

for (const auto *PD : Protocols)
  ProtocolRefs.push_back(GetProtocolRef(PD));

// If all of the protocols in the protocol list are objc_non_runtime_protocol
// just return null
if (ProtocolRefs.size() == 0)
  return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);

// FIXME: We shouldn't need to do this lookup here, should we?
SmallString<256> TmpName;
Name.toVector(TmpName);
llvm::GlobalVariable *GV =
  CGM.getModule().getGlobalVariable(TmpName.str(), true);
if (GV)
  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListnfABIPtrTy);

ConstantInitBuilder builder(CGM);
auto values = builder.beginStruct();
auto countSlot = values.addPlaceholder();

// A null-terminated array of protocols.
auto array = values.beginArray(ObjCTypes.ProtocolnfABIPtrTy);
for (auto const &proto : ProtocolRefs)
  array.add(proto);
auto count = array.size();
array.addNullPointer(ObjCTypes.ProtocolnfABIPtrTy);

array.finishAndAddTo(values);
values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);

GV = finishAndCreateGlobal(values, Name, CGM);
CGM.addCompilerUsedGlobal(GV);
return llvm::ConstantExpr::getBitCast(GV,
                                      ObjCTypes.ProtocolListnfABIPtrTy);
7221}

7223/// EmitObjCValueForIvar - Code Gen for nonfragile ivar reference.
7224/// This code gen. amounts to generating code for:
7225/// @code
7226/// (type *)((char *)base + _OBJC_IVAR_$_.ivar;
7227/// @encode
7228///
7229LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar(
                                             CodeGen::CodeGenFunction &CGF,
                                             QualType ObjectTy,
                                             llvm::Value *BaseValue,
                                             const ObjCIvarDecl *Ivar,
                                             unsigned CVRQualifiers) {
ObjCInterfaceDecl *ID = ObjectTy->castAs<ObjCObjectType>()->getInterface();
llvm::Value *Offset = EmitIvarOffset(CGF, ID, Ivar);
return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
                                Offset);
7239}

7241llvm::Value *
7242CGObjCNonFragileABIMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
                                     const ObjCInterfaceDecl *Interface,
                                     const ObjCIvarDecl *Ivar) {
llvm::Value *IvarOffsetValue;
if (isClassLayoutKnownStatically(Interface)) {
  IvarOffsetValue = llvm::ConstantInt::get(
      ObjCTypes.IvarOffsetVarTy,
      ComputeIvarBaseOffset(CGM, Interface->getImplementation(), Ivar));
} else {
  llvm::GlobalVariable *GV = ObjCIvarOffsetVariable(Interface, Ivar);
  IvarOffsetValue =
      CGF.Builder.CreateAlignedLoad(GV->getValueType(), GV,
                                    CGF.getSizeAlign(), "ivar");
  if (IsIvarOffsetKnownIdempotent(CGF, Ivar))
    cast<llvm::LoadInst>(IvarOffsetValue)
        ->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
                      llvm::MDNode::get(VMContext, None));
}

// This could be 32bit int or 64bit integer depending on the architecture.
// Cast it to 64bit integer value, if it is a 32bit integer ivar offset value
//  as this is what caller always expects.
if (ObjCTypes.IvarOffsetVarTy == ObjCTypes.IntTy)
  IvarOffsetValue = CGF.Builder.CreateIntCast(
      IvarOffsetValue, ObjCTypes.LongTy, true, "ivar.conv");
return IvarOffsetValue;
7268}

7270static void appendSelectorForMessageRefTable(std::string &buffer,
                                           Selector selector) {
if (selector.isUnarySelector()) {
  buffer += selector.getNameForSlot(0);
  return;
}

for (unsigned i = 0, e = selector.getNumArgs(); i != e; ++i) {
  buffer += selector.getNameForSlot(i);
  buffer += '_';
}
7281}

7283/// Emit a "vtable" message send.  We emit a weak hidden-visibility
7284/// struct, initially containing the selector pointer and a pointer to
7285/// a "fixup" variant of the appropriate objc_msgSend.  To call, we
7286/// load and call the function pointer, passing the address of the
7287/// struct as the second parameter.  The runtime determines whether
7288/// the selector is currently emitted using vtable dispatch; if so, it
7289/// substitutes a stub function which simply tail-calls through the
7290/// appropriate vtable slot, and if not, it substitues a stub function
7291/// which tail-calls objc_msgSend.  Both stubs adjust the selector
7292/// argument to correctly point to the selector.
7293RValue
7294CGObjCNonFragileABIMac::EmitVTableMessageSend(CodeGenFunction &CGF,
                                            ReturnValueSlot returnSlot,
                                            QualType resultType,
                                            Selector selector,
                                            llvm::Value *arg0,
                                            QualType arg0Type,
                                            bool isSuper,
                                            const CallArgList &formalArgs,
                                            const ObjCMethodDecl *method) {
// Compute the actual arguments.
CallArgList args;

// First argument: the receiver / super-call structure.
if (!isSuper)
  arg0 = CGF.Builder.CreateBitCast(arg0, ObjCTypes.ObjectPtrTy);
args.add(RValue::get(arg0), arg0Type);

// Second argument: a pointer to the message ref structure.  Leave
// the actual argument value blank for now.
args.add(RValue::get(nullptr), ObjCTypes.MessageRefCPtrTy);

args.insert(args.end(), formalArgs.begin(), formalArgs.end());

MessageSendInfo MSI = getMessageSendInfo(method, resultType, args);

NullReturnState nullReturn;

// Find the function to call and the mangled name for the message
// ref structure.  Using a different mangled name wouldn't actually
// be a problem; it would just be a waste.
//
// The runtime currently never uses vtable dispatch for anything
// except normal, non-super message-sends.
// FIXME: don't use this for that.
llvm::FunctionCallee fn = nullptr;
std::string messageRefName("_");
if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
  if (isSuper) {
    fn = ObjCTypes.getMessageSendSuper2StretFixupFn();
    messageRefName += "objc_msgSendSuper2_stret_fixup";
  } else {
    nullReturn.init(CGF, arg0);
    fn = ObjCTypes.getMessageSendStretFixupFn();
    messageRefName += "objc_msgSend_stret_fixup";
  }
} else if (!isSuper && CGM.ReturnTypeUsesFPRet(resultType)) {
  fn = ObjCTypes.getMessageSendFpretFixupFn();
  messageRefName += "objc_msgSend_fpret_fixup";
} else {
  if (isSuper) {
    fn = ObjCTypes.getMessageSendSuper2FixupFn();
    messageRefName += "objc_msgSendSuper2_fixup";
  } else {
    fn = ObjCTypes.getMessageSendFixupFn();
    messageRefName += "objc_msgSend_fixup";
  }
}
assert(fn && "CGObjCNonFragileABIMac::EmitMessageSend")((void)0);
messageRefName += '_';

// Append the selector name, except use underscores anywhere we
// would have used colons.
appendSelectorForMessageRefTable(messageRefName, selector);

llvm::GlobalVariable *messageRef
  = CGM.getModule().getGlobalVariable(messageRefName);
if (!messageRef) {
  // Build the message ref structure.
  ConstantInitBuilder builder(CGM);
  auto values = builder.beginStruct();
  values.add(cast<llvm::Constant>(fn.getCallee()));
  values.add(GetMethodVarName(selector));
  messageRef = values.finishAndCreateGlobal(messageRefName,
                                            CharUnits::fromQuantity(16),
                                            /*constant*/ false,
                                      llvm::GlobalValue::WeakAnyLinkage);
  messageRef->setVisibility(llvm::GlobalValue::HiddenVisibility);
  messageRef->setSection(GetSectionName("__objc_msgrefs", "coalesced"));
}

bool requiresnullCheck = false;
if (CGM.getLangOpts().ObjCAutoRefCount && method)
  for (const auto *ParamDecl : method->parameters()) {
    if (ParamDecl->isDestroyedInCallee()) {
      if (!nullReturn.NullBB)
        nullReturn.init(CGF, arg0);
      requiresnullCheck = true;
      break;
    }
  }

Address mref =
  Address(CGF.Builder.CreateBitCast(messageRef, ObjCTypes.MessageRefPtrTy),
          CGF.getPointerAlign());

// Update the message ref argument.
args[1].setRValue(RValue::get(mref.getPointer()));

// Load the function to call from the message ref table.
Address calleeAddr = CGF.Builder.CreateStructGEP(mref, 0);
llvm::Value *calleePtr = CGF.Builder.CreateLoad(calleeAddr, "msgSend_fn");

calleePtr = CGF.Builder.CreateBitCast(calleePtr, MSI.MessengerType);
CGCallee callee(CGCalleeInfo(), calleePtr);

RValue result = CGF.EmitCall(MSI.CallInfo, callee, returnSlot, args);
return nullReturn.complete(CGF, returnSlot, result, resultType, formalArgs,
                           requiresnullCheck ? method : nullptr);
7402}

7404/// Generate code for a message send expression in the nonfragile abi.
7405CodeGen::RValue
7406CGObjCNonFragileABIMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
                                          ReturnValueSlot Return,
                                          QualType ResultType,
                                          Selector Sel,
                                          llvm::Value *Receiver,
                                          const CallArgList &CallArgs,
                                          const ObjCInterfaceDecl *Class,
                                          const ObjCMethodDecl *Method) {
return isVTableDispatchedSelector(Sel)
  ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
                          Receiver, CGF.getContext().getObjCIdType(),
                          false, CallArgs, Method)
  : EmitMessageSend(CGF, Return, ResultType, Sel,
                    Receiver, CGF.getContext().getObjCIdType(),
                    false, CallArgs, Method, Class, ObjCTypes);
7421}

7423llvm::Constant *
7424CGObjCNonFragileABIMac::GetClassGlobal(const ObjCInterfaceDecl *ID,
                                     bool metaclass,
                                     ForDefinition_t isForDefinition) {
auto prefix =
  (metaclass ? getMetaclassSymbolPrefix() : getClassSymbolPrefix());
return GetClassGlobal((prefix + ID->getObjCRuntimeNameAsString()).str(),
                      isForDefinition,
                      ID->isWeakImported(),
                      !isForDefinition
                        && CGM.getTriple().isOSBinFormatCOFF()
                        && ID->hasAttr<DLLImportAttr>());
7435}

7437llvm::Constant *
7438CGObjCNonFragileABIMac::GetClassGlobal(StringRef Name,
                                     ForDefinition_t IsForDefinition,
                                     bool Weak, bool DLLImport) {
llvm::GlobalValue::LinkageTypes L =
    Weak ? llvm::GlobalValue::ExternalWeakLinkage
         : llvm::GlobalValue::ExternalLinkage;

llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
if (!GV || GV->getType() != ObjCTypes.ClassnfABITy->getPointerTo()) {
  auto *NewGV = new llvm::GlobalVariable(ObjCTypes.ClassnfABITy, false, L,
                                         nullptr, Name);

  if (DLLImport)
    NewGV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);

  if (GV) {
    GV->replaceAllUsesWith(
        llvm::ConstantExpr::getBitCast(NewGV, GV->getType()));
    GV->eraseFromParent();
  }
  GV = NewGV;
  CGM.getModule().getGlobalList().push_back(GV);
}

assert(GV->getLinkage() == L)((void)0);
return GV;
7464}

7466llvm::Constant *
7467CGObjCNonFragileABIMac::GetClassGlobalForClassRef(const ObjCInterfaceDecl *ID) {
llvm::Constant *ClassGV = GetClassGlobal(ID, /*metaclass*/ false,
                                         NotForDefinition);

if (!ID->hasAttr<ObjCClassStubAttr>())
  return ClassGV;

ClassGV = llvm::ConstantExpr::getPointerCast(ClassGV, ObjCTypes.Int8PtrTy);

// Stub classes are pointer-aligned. Classrefs pointing at stub classes
// must set the least significant bit set to 1.
auto *Idx = llvm::ConstantInt::get(CGM.Int32Ty, 1);
return llvm::ConstantExpr::getGetElementPtr(CGM.Int8Ty, ClassGV, Idx);
7480}

7482llvm::Value *
7483CGObjCNonFragileABIMac::EmitLoadOfClassRef(CodeGenFunction &CGF,
                                         const ObjCInterfaceDecl *ID,
                                         llvm::GlobalVariable *Entry) {
if (ID && ID->hasAttr<ObjCClassStubAttr>()) {
  // Classrefs pointing at Objective-C stub classes must be loaded by calling
  // a special runtime function.
  return CGF.EmitRuntimeCall(
    ObjCTypes.getLoadClassrefFn(), Entry, "load_classref_result");
}

CharUnits Align = CGF.getPointerAlign();
return CGF.Builder.CreateAlignedLoad(Entry->getValueType(), Entry, Align);
7495}

7497llvm::Value *
7498CGObjCNonFragileABIMac::EmitClassRefFromId(CodeGenFunction &CGF,
                                         IdentifierInfo *II,
                                         const ObjCInterfaceDecl *ID) {
llvm::GlobalVariable *&Entry = ClassReferences[II];

if (!Entry) {
  llvm::Constant *ClassGV;
  if (ID) {
    ClassGV = GetClassGlobalForClassRef(ID);
  } else {
    ClassGV = GetClassGlobal((getClassSymbolPrefix() + II->getName()).str(),
                             NotForDefinition);
    assert(ClassGV->getType() == ObjCTypes.ClassnfABIPtrTy &&((void)0)
           "classref was emitted with the wrong type?")((void)0);
  }

  std::string SectionName =
      GetSectionName("__objc_classrefs", "regular,no_dead_strip");
  Entry = new llvm::GlobalVariable(
      CGM.getModule(), ClassGV->getType(), false,
      getLinkageTypeForObjCMetadata(CGM, SectionName), ClassGV,
      "OBJC_CLASSLIST_REFERENCES_$_");
  Entry->setAlignment(CGF.getPointerAlign().getAsAlign());
  if (!ID || !ID->hasAttr<ObjCClassStubAttr>())
    Entry->setSection(SectionName);

  CGM.addCompilerUsedGlobal(Entry);
}

return EmitLoadOfClassRef(CGF, ID, Entry);
7528}

7530llvm::Value *CGObjCNonFragileABIMac::EmitClassRef(CodeGenFunction &CGF,
                                                const ObjCInterfaceDecl *ID) {
// If the class has the objc_runtime_visible attribute, we need to
// use the Objective-C runtime to get the class.
if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
  return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);

return EmitClassRefFromId(CGF, ID->getIdentifier(), ID);
7538}

7540llvm::Value *CGObjCNonFragileABIMac::EmitNSAutoreleasePoolClassRef(
                                                  CodeGenFunction &CGF) {
IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
return EmitClassRefFromId(CGF, II, nullptr);
7544}

7546llvm::Value *
7547CGObjCNonFragileABIMac::EmitSuperClassRef(CodeGenFunction &CGF,
                                        const ObjCInterfaceDecl *ID) {
llvm::GlobalVariable *&Entry = SuperClassReferences[ID->getIdentifier()];

if (!Entry) {
  llvm::Constant *ClassGV = GetClassGlobalForClassRef(ID);
  std::string SectionName =
      GetSectionName("__objc_superrefs", "regular,no_dead_strip");
  Entry = new llvm::GlobalVariable(CGM.getModule(), ClassGV->getType(), false,
                                   llvm::GlobalValue::PrivateLinkage, ClassGV,
                                   "OBJC_CLASSLIST_SUP_REFS_$_");
  Entry->setAlignment(CGF.getPointerAlign().getAsAlign());
  Entry->setSection(SectionName);
  CGM.addCompilerUsedGlobal(Entry);
}

return EmitLoadOfClassRef(CGF, ID, Entry);
7564}

7566/// EmitMetaClassRef - Return a Value * of the address of _class_t
7567/// meta-data
7568///
7569llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef(CodeGenFunction &CGF,
                                                    const ObjCInterfaceDecl *ID,
                                                    bool Weak) {
CharUnits Align = CGF.getPointerAlign();
llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()];
if (!Entry) {
  auto MetaClassGV = GetClassGlobal(ID, /*metaclass*/ true, NotForDefinition);
  std::string SectionName =
      GetSectionName("__objc_superrefs", "regular,no_dead_strip");
  Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
                                   false, llvm::GlobalValue::PrivateLinkage,
                                   MetaClassGV, "OBJC_CLASSLIST_SUP_REFS_$_");
  Entry->setAlignment(Align.getAsAlign());
  Entry->setSection(SectionName);
  CGM.addCompilerUsedGlobal(Entry);
}

return CGF.Builder.CreateAlignedLoad(ObjCTypes.ClassnfABIPtrTy, Entry, Align);
7587}

7589/// GetClass - Return a reference to the class for the given interface
7590/// decl.
7591llvm::Value *CGObjCNonFragileABIMac::GetClass(CodeGenFunction &CGF,
                                            const ObjCInterfaceDecl *ID) {
if (ID->isWeakImported()) {
  auto ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition);
  (void)ClassGV;
  assert(!isa<llvm::GlobalVariable>(ClassGV) ||((void)0)
         cast<llvm::GlobalVariable>(ClassGV)->hasExternalWeakLinkage())((void)0);
}

return EmitClassRef(CGF, ID);
7601}

7603/// Generates a message send where the super is the receiver.  This is
7604/// a message send to self with special delivery semantics indicating
7605/// which class's method should be called.
7606CodeGen::RValue
7607CGObjCNonFragileABIMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
                                               ReturnValueSlot Return,
                                               QualType ResultType,
                                               Selector Sel,
                                               const ObjCInterfaceDecl *Class,
                                               bool isCategoryImpl,
                                               llvm::Value *Receiver,
                                               bool IsClassMessage,
                                               const CodeGen::CallArgList &CallArgs,
                                               const ObjCMethodDecl *Method) {
// ...
// Create and init a super structure; this is a (receiver, class)
// pair we will pass to objc_msgSendSuper.
Address ObjCSuper =
  CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
                       "objc_super");

llvm::Value *ReceiverAsObject =
  CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
CGF.Builder.CreateStore(ReceiverAsObject,
                        CGF.Builder.CreateStructGEP(ObjCSuper, 0));

// If this is a class message the metaclass is passed as the target.
llvm::Value *Target;
if (IsClassMessage)
    Target = EmitMetaClassRef(CGF, Class, Class->isWeakImported());
else
  Target = EmitSuperClassRef(CGF, Class);

// FIXME: We shouldn't need to do this cast, rectify the ASTContext and
// ObjCTypes types.
llvm::Type *ClassTy =
  CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
Target = CGF.Builder.CreateBitCast(Target, ClassTy);
CGF.Builder.CreateStore(Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1));

return (isVTableDispatchedSelector(Sel))
  ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
                          ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
                          true, CallArgs, Method)
  : EmitMessageSend(CGF, Return, ResultType, Sel,
                    ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
                    true, CallArgs, Method, Class, ObjCTypes);
7650}

7652llvm::Value *CGObjCNonFragileABIMac::EmitSelector(CodeGenFunction &CGF,
                                                Selector Sel) {
Address Addr = EmitSelectorAddr(Sel);

llvm::LoadInst* LI = CGF.Builder.CreateLoad(Addr);
LI->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
                llvm::MDNode::get(VMContext, None));
return LI;
7660}

7662Address CGObjCNonFragileABIMac::EmitSelectorAddr(Selector Sel) {
llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
CharUnits Align = CGM.getPointerAlign();
if (!Entry) {
  llvm::Constant *Casted =
    llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
                                   ObjCTypes.SelectorPtrTy);
  std::string SectionName =
      GetSectionName("__objc_selrefs", "literal_pointers,no_dead_strip");
  Entry = new llvm::GlobalVariable(
      CGM.getModule(), ObjCTypes.SelectorPtrTy, false,
      getLinkageTypeForObjCMetadata(CGM, SectionName), Casted,
      "OBJC_SELECTOR_REFERENCES_");
  Entry->setExternallyInitialized(true);
  Entry->setSection(SectionName);
  Entry->setAlignment(Align.getAsAlign());
  CGM.addCompilerUsedGlobal(Entry);
}

return Address(Entry, Align);
7682}

7684/// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
7685/// objc_assign_ivar (id src, id *dst, ptrdiff_t)
7686///
7687void CGObjCNonFragileABIMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
                                              llvm::Value *src,
                                              Address dst,
                                              llvm::Value *ivarOffset) {
llvm::Type * SrcTy = src->getType();
if (!isa<llvm::PointerType>(SrcTy)) {
  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
  assert(Size <= 8 && "does not support size > 8")((void)0);
  src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
         : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
}
src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
7703}

7705/// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
7706/// objc_assign_strongCast (id src, id *dst)
7707///
7708void CGObjCNonFragileABIMac::EmitObjCStrongCastAssign(
CodeGen::CodeGenFunction &CGF,
llvm::Value *src, Address dst) {
llvm::Type * SrcTy = src->getType();
if (!isa<llvm::PointerType>(SrcTy)) {
  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
  assert(Size <= 8 && "does not support size > 8")((void)0);
  src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
         : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
}
src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
llvm::Value *args[] = { src, dst.getPointer() };
CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
                            args, "weakassign");
7724}

7726void CGObjCNonFragileABIMac::EmitGCMemmoveCollectable(
CodeGen::CodeGenFunction &CGF,
Address DestPtr,
Address SrcPtr,
llvm::Value *Size) {
SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), Size };
CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
7735}

7737/// EmitObjCWeakRead - Code gen for loading value of a __weak
7738/// object: objc_read_weak (id *src)
7739///
7740llvm::Value * CGObjCNonFragileABIMac::EmitObjCWeakRead(
CodeGen::CodeGenFunction &CGF,
Address AddrWeakObj) {
llvm::Type *DestTy = AddrWeakObj.getElementType();
AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy);
llvm::Value *read_weak =
  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
                              AddrWeakObj.getPointer(), "weakread");
read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
return read_weak;
7750}

7752/// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
7753/// objc_assign_weak (id src, id *dst)
7754///
7755void CGObjCNonFragileABIMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
                                              llvm::Value *src, Address dst) {
llvm::Type * SrcTy = src->getType();
if (!isa<llvm::PointerType>(SrcTy)) {
  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
  assert(Size <= 8 && "does not support size > 8")((void)0);
  src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
         : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
}
src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
llvm::Value *args[] = { src, dst.getPointer() };
CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
                            args, "weakassign");
7770}

7772/// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
7773/// objc_assign_global (id src, id *dst)
7774///
7775void CGObjCNonFragileABIMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
                                        llvm::Value *src, Address dst,
                                        bool threadlocal) {
llvm::Type * SrcTy = src->getType();
if (!isa<llvm::PointerType>(SrcTy)) {
  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
  assert(Size <= 8 && "does not support size > 8")((void)0);
  src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
         : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
}
src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
llvm::Value *args[] = { src, dst.getPointer() };
if (!threadlocal)
  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
                              args, "globalassign");
else
  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
                              args, "threadlocalassign");
7795}

7797void
7798CGObjCNonFragileABIMac::EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
                                           const ObjCAtSynchronizedStmt &S) {
EmitAtSynchronizedStmt(CGF, S, ObjCTypes.getSyncEnterFn(),
                       ObjCTypes.getSyncExitFn());
7802}

7804llvm::Constant *
7805CGObjCNonFragileABIMac::GetEHType(QualType T) {
// There's a particular fixed type info for 'id'.
if (T->isObjCIdType() || T->isObjCQualifiedIdType()) {
  auto *IDEHType = CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id");
  if (!IDEHType) {
    IDEHType =
        new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
                                 llvm::GlobalValue::ExternalLinkage, nullptr,
                                 "OBJC_EHTYPE_id");
    if (CGM.getTriple().isOSBinFormatCOFF())
      IDEHType->setDLLStorageClass(getStorage(CGM, "OBJC_EHTYPE_id"));
  }
  return IDEHType;
}

// All other types should be Objective-C interface pointer types.
const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>();
assert(PT && "Invalid @catch type.")((void)0);

const ObjCInterfaceType *IT = PT->getInterfaceType();
assert(IT && "Invalid @catch type.")((void)0);

return GetInterfaceEHType(IT->getDecl(), NotForDefinition);
7828}

7830void CGObjCNonFragileABIMac::EmitTryStmt(CodeGen::CodeGenFunction &CGF,
                                       const ObjCAtTryStmt &S) {
EmitTryCatchStmt(CGF, S, ObjCTypes.getObjCBeginCatchFn(),
                 ObjCTypes.getObjCEndCatchFn(),
                 ObjCTypes.getExceptionRethrowFn());
7835}

7837/// EmitThrowStmt - Generate code for a throw statement.
7838void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
                                         const ObjCAtThrowStmt &S,
                                         bool ClearInsertionPoint) {
if (const Expr *ThrowExpr = S.getThrowExpr()) {
  llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
  Exception = CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
  llvm::CallBase *Call =
      CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionThrowFn(), Exception);
  Call->setDoesNotReturn();
} else {
  llvm::CallBase *Call =
      CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionRethrowFn());
  Call->setDoesNotReturn();
}

CGF.Builder.CreateUnreachable();
if (ClearInsertionPoint)
  CGF.Builder.ClearInsertionPoint();
7856}

7858llvm::Constant *
7859CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceDecl *ID,
                                         ForDefinition_t IsForDefinition) {
llvm::GlobalVariable * &Entry = EHTypeReferences[ID->getIdentifier()];
StringRef ClassName = ID->getObjCRuntimeNameAsString();

// If we don't need a definition, return the entry if found or check
// if we use an external reference.
if (!IsForDefinition) {
  if (Entry)
    return Entry;

  // If this type (or a super class) has the __objc_exception__
  // attribute, emit an external reference.
  if (hasObjCExceptionAttribute(CGM.getContext(), ID)) {
    std::string EHTypeName = ("OBJC_EHTYPE_$_" + ClassName).str();
    Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy,
                                     false, llvm::GlobalValue::ExternalLinkage,
                                     nullptr, EHTypeName);
    CGM.setGVProperties(Entry, ID);
    return Entry;
  }
}

// Otherwise we need to either make a new entry or fill in the initializer.
assert((!Entry || !Entry->hasInitializer()) && "Duplicate EHType definition")((void)0);

std::string VTableName = "objc_ehtype_vtable";
auto *VTableGV = CGM.getModule().getGlobalVariable(VTableName);
if (!VTableGV) {
  VTableGV =
      new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.Int8PtrTy, false,
                               llvm::GlobalValue::ExternalLinkage, nullptr,
                               VTableName);
  if (CGM.getTriple().isOSBinFormatCOFF())
    VTableGV->setDLLStorageClass(getStorage(CGM, VTableName));
}

llvm::Value *VTableIdx = llvm::ConstantInt::get(CGM.Int32Ty, 2);
ConstantInitBuilder builder(CGM);
auto values = builder.beginStruct(ObjCTypes.EHTypeTy);
values.add(
  llvm::ConstantExpr::getInBoundsGetElementPtr(VTableGV->getValueType(),
                                               VTableGV, VTableIdx));
values.add(GetClassName(ClassName));
values.add(GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition));

llvm::GlobalValue::LinkageTypes L = IsForDefinition
                                        ? llvm::GlobalValue::ExternalLinkage
                                        : llvm::GlobalValue::WeakAnyLinkage;
if (Entry) {
  values.finishAndSetAsInitializer(Entry);
  Entry->setAlignment(CGM.getPointerAlign().getAsAlign());
} else {
  Entry = values.finishAndCreateGlobal("OBJC_EHTYPE_$_" + ClassName,
                                       CGM.getPointerAlign(),
                                       /*constant*/ false,
                                       L);
  if (hasObjCExceptionAttribute(CGM.getContext(), ID))
    CGM.setGVProperties(Entry, ID);
}
assert(Entry->getLinkage() == L)((void)0);

if (!CGM.getTriple().isOSBinFormatCOFF())
  if (ID->getVisibility() == HiddenVisibility)
    Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);

if (IsForDefinition)
  if (CGM.getTriple().isOSBinFormatMachO())
    Entry->setSection("__DATA,__objc_const");

return Entry;
7930}

7932/* *** */

7934CodeGen::CGObjCRuntime *
7935CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) {
switch (CGM.getLangOpts().ObjCRuntime.getKind()) {
case ObjCRuntime::FragileMacOSX:
return new CGObjCMac(CGM);

case ObjCRuntime::MacOSX:
case ObjCRuntime::iOS:
case ObjCRuntime::WatchOS:
  return new CGObjCNonFragileABIMac(CGM);

case ObjCRuntime::GNUstep:
case ObjCRuntime::GCC:
case ObjCRuntime::ObjFW:
  llvm_unreachable("these runtimes are not Mac runtimes")__builtin_unreachable();
}
llvm_unreachable("bad runtime")__builtin_unreachable();
7951}

←

/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/include/clang/AST/Type.h

1//===- Type.h - C Language Family Type Representation -----------*- C++ -*-===//
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/// \file
10/// C Language Family Type Representation
11///
12/// This file defines the clang::Type interface and subclasses, used to
13/// represent types for languages in the C family.
14//
15//===----------------------------------------------------------------------===//

17#ifndef LLVM_CLANG_AST_TYPE_H
18#define LLVM_CLANG_AST_TYPE_H

20#include "clang/AST/DependenceFlags.h"
21#include "clang/AST/NestedNameSpecifier.h"
22#include "clang/AST/TemplateName.h"
23#include "clang/Basic/AddressSpaces.h"
24#include "clang/Basic/AttrKinds.h"
25#include "clang/Basic/Diagnostic.h"
26#include "clang/Basic/ExceptionSpecificationType.h"
27#include "clang/Basic/LLVM.h"
28#include "clang/Basic/Linkage.h"
29#include "clang/Basic/PartialDiagnostic.h"
30#include "clang/Basic/SourceLocation.h"
31#include "clang/Basic/Specifiers.h"
32#include "clang/Basic/Visibility.h"
33#include "llvm/ADT/APInt.h"
34#include "llvm/ADT/APSInt.h"
35#include "llvm/ADT/ArrayRef.h"
36#include "llvm/ADT/FoldingSet.h"
37#include "llvm/ADT/None.h"
38#include "llvm/ADT/Optional.h"
39#include "llvm/ADT/PointerIntPair.h"
40#include "llvm/ADT/PointerUnion.h"
41#include "llvm/ADT/StringRef.h"
42#include "llvm/ADT/Twine.h"
43#include "llvm/ADT/iterator_range.h"
44#include "llvm/Support/Casting.h"
45#include "llvm/Support/Compiler.h"
46#include "llvm/Support/ErrorHandling.h"
47#include "llvm/Support/PointerLikeTypeTraits.h"
48#include "llvm/Support/TrailingObjects.h"
49#include "llvm/Support/type_traits.h"
50#include <cassert>
51#include <cstddef>
52#include <cstdint>
53#include <cstring>
54#include <string>
55#include <type_traits>
56#include <utility>

58namespace clang {

60class ExtQuals;
61class QualType;
62class ConceptDecl;
63class TagDecl;
64class TemplateParameterList;
65class Type;

67enum {
TypeAlignmentInBits = 4,
TypeAlignment = 1 << TypeAlignmentInBits
70};

72namespace serialization {
template <class T> class AbstractTypeReader;
template <class T> class AbstractTypeWriter;
75}

77} // namespace clang

79namespace llvm {

template <typename T>
struct PointerLikeTypeTraits;
template<>
struct PointerLikeTypeTraits< ::clang::Type*> {
  static inline void *getAsVoidPointer(::clang::Type *P) { return P; }

  static inline ::clang::Type *getFromVoidPointer(void *P) {
    return static_cast< ::clang::Type*>(P);
  }

  static constexpr int NumLowBitsAvailable = clang::TypeAlignmentInBits;
};

template<>
struct PointerLikeTypeTraits< ::clang::ExtQuals*> {
  static inline void *getAsVoidPointer(::clang::ExtQuals *P) { return P; }

  static inline ::clang::ExtQuals *getFromVoidPointer(void *P) {
    return static_cast< ::clang::ExtQuals*>(P);
  }

  static constexpr int NumLowBitsAvailable = clang::TypeAlignmentInBits;
};

105} // namespace llvm

107namespace clang {

109class ASTContext;
110template <typename> class CanQual;
111class CXXRecordDecl;
112class DeclContext;
113class EnumDecl;
114class Expr;
115class ExtQualsTypeCommonBase;
116class FunctionDecl;
117class IdentifierInfo;
118class NamedDecl;
119class ObjCInterfaceDecl;
120class ObjCProtocolDecl;
121class ObjCTypeParamDecl;
122struct PrintingPolicy;
123class RecordDecl;
124class Stmt;
125class TagDecl;
126class TemplateArgument;
127class TemplateArgumentListInfo;
128class TemplateArgumentLoc;
129class TemplateTypeParmDecl;
130class TypedefNameDecl;
131class UnresolvedUsingTypenameDecl;

133using CanQualType = CanQual<Type>;

135// Provide forward declarations for all of the *Type classes.
136#define TYPE(Class, Base) class Class##Type;
137#include "clang/AST/TypeNodes.inc"

139/// The collection of all-type qualifiers we support.
140/// Clang supports five independent qualifiers:
141/// * C99: const, volatile, and restrict
142/// * MS: __unaligned
143/// * Embedded C (TR18037): address spaces
144/// * Objective C: the GC attributes (none, weak, or strong)
145class Qualifiers {
146public:
enum TQ { // NOTE: These flags must be kept in sync with DeclSpec::TQ.
  Const    = 0x1,
  Restrict = 0x2,
  Volatile = 0x4,
  CVRMask = Const | Volatile | Restrict
};

enum GC {
  GCNone = 0,
  Weak,
  Strong
};

enum ObjCLifetime {
  /// There is no lifetime qualification on this type.
  OCL_None,

  /// This object can be modified without requiring retains or
  /// releases.
  OCL_ExplicitNone,

  /// Assigning into this object requires the old value to be
  /// released and the new value to be retained.  The timing of the
  /// release of the old value is inexact: it may be moved to
  /// immediately after the last known point where the value is
  /// live.
  OCL_Strong,

  /// Reading or writing from this object requires a barrier call.
  OCL_Weak,

  /// Assigning into this object requires a lifetime extension.
  OCL_Autoreleasing
};

enum {
  /// The maximum supported address space number.
  /// 23 bits should be enough for anyone.
  MaxAddressSpace = 0x7fffffu,

  /// The width of the "fast" qualifier mask.
  FastWidth = 3,

  /// The fast qualifier mask.
  FastMask = (1 << FastWidth) - 1
};

/// Returns the common set of qualifiers while removing them from
/// the given sets.
static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R) {
  // If both are only CVR-qualified, bit operations are sufficient.
  if (!(L.Mask & ~CVRMask) && !(R.Mask & ~CVRMask)) {
    Qualifiers Q;
    Q.Mask = L.Mask & R.Mask;
    L.Mask &= ~Q.Mask;
    R.Mask &= ~Q.Mask;
    return Q;
  }

  Qualifiers Q;
  unsigned CommonCRV = L.getCVRQualifiers() & R.getCVRQualifiers();
  Q.addCVRQualifiers(CommonCRV);
  L.removeCVRQualifiers(CommonCRV);
  R.removeCVRQualifiers(CommonCRV);

  if (L.getObjCGCAttr() == R.getObjCGCAttr()) {
    Q.setObjCGCAttr(L.getObjCGCAttr());
    L.removeObjCGCAttr();
    R.removeObjCGCAttr();
  }

  if (L.getObjCLifetime() == R.getObjCLifetime()) {
    Q.setObjCLifetime(L.getObjCLifetime());
    L.removeObjCLifetime();
    R.removeObjCLifetime();
  }

  if (L.getAddressSpace() == R.getAddressSpace()) {
    Q.setAddressSpace(L.getAddressSpace());
    L.removeAddressSpace();
    R.removeAddressSpace();
  }
  return Q;
}

static Qualifiers fromFastMask(unsigned Mask) {
  Qualifiers Qs;
  Qs.addFastQualifiers(Mask);
  return Qs;
}

static Qualifiers fromCVRMask(unsigned CVR) {
  Qualifiers Qs;
  Qs.addCVRQualifiers(CVR);
  return Qs;
}

static Qualifiers fromCVRUMask(unsigned CVRU) {
  Qualifiers Qs;
  Qs.addCVRUQualifiers(CVRU);
  return Qs;
}

// Deserialize qualifiers from an opaque representation.
static Qualifiers fromOpaqueValue(unsigned opaque) {
  Qualifiers Qs;
  Qs.Mask = opaque;
  return Qs;
}

// Serialize these qualifiers into an opaque representation.
unsigned getAsOpaqueValue() const {
  return Mask;
}

bool hasConst() const { return Mask & Const; }
bool hasOnlyConst() const { return Mask == Const; }
void removeConst() { Mask &= ~Const; }
void addConst() { Mask |= Const; }

bool hasVolatile() const { return Mask & Volatile; }
bool hasOnlyVolatile() const { return Mask == Volatile; }
void removeVolatile() { Mask &= ~Volatile; }
void addVolatile() { Mask |= Volatile; }

bool hasRestrict() const { return Mask & Restrict; }
bool hasOnlyRestrict() const { return Mask == Restrict; }
void removeRestrict() { Mask &= ~Restrict; }
void addRestrict() { Mask |= Restrict; }

bool hasCVRQualifiers() const { return getCVRQualifiers(); }
unsigned getCVRQualifiers() const { return Mask & CVRMask; }
unsigned getCVRUQualifiers() const { return Mask & (CVRMask | UMask); }

void setCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((void)0);
  Mask = (Mask & ~CVRMask) | mask;
}
void removeCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((void)0);
  Mask &= ~mask;
}
void removeCVRQualifiers() {
  removeCVRQualifiers(CVRMask);
}
void addCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((void)0);
  Mask |= mask;
}
void addCVRUQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits")((void)0);
  Mask |= mask;
}

bool hasUnaligned() const { return Mask & UMask; }
void setUnaligned(bool flag) {
  Mask = (Mask & ~UMask) | (flag ? UMask : 0);
}
void removeUnaligned() { Mask &= ~UMask; }
void addUnaligned() { Mask |= UMask; }

bool hasObjCGCAttr() const { return Mask & GCAttrMask; }
GC getObjCGCAttr() const { return GC((Mask & GCAttrMask) >> GCAttrShift); }
void setObjCGCAttr(GC type) {
  Mask = (Mask & ~GCAttrMask) | (type << GCAttrShift);
}
void removeObjCGCAttr() { setObjCGCAttr(GCNone); }
void addObjCGCAttr(GC type) {
  assert(type)((void)0);
  setObjCGCAttr(type);
}
Qualifiers withoutObjCGCAttr() const {
  Qualifiers qs = *this;
  qs.removeObjCGCAttr();
  return qs;
}
Qualifiers withoutObjCLifetime() const {
  Qualifiers qs = *this;
  qs.removeObjCLifetime();
  return qs;
}
Qualifiers withoutAddressSpace() const {
  Qualifiers qs = *this;
  qs.removeAddressSpace();
  return qs;
}

bool hasObjCLifetime() const { return Mask & LifetimeMask; }
ObjCLifetime getObjCLifetime() const {
  return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
}
void setObjCLifetime(ObjCLifetime type) {
  Mask = (Mask & ~LifetimeMask) | (type << LifetimeShift);
}
void removeObjCLifetime() { setObjCLifetime(OCL_None); }
void addObjCLifetime(ObjCLifetime type) {
  assert(type)((void)0);
  assert(!hasObjCLifetime())((void)0);
  Mask |= (type << LifetimeShift);
}

/// True if the lifetime is neither None or ExplicitNone.
bool hasNonTrivialObjCLifetime() const {
  ObjCLifetime lifetime = getObjCLifetime();
  return (lifetime > OCL_ExplicitNone);
}

/// True if the lifetime is either strong or weak.
bool hasStrongOrWeakObjCLifetime() const {
  ObjCLifetime lifetime = getObjCLifetime();
  return (lifetime == OCL_Strong || lifetime == OCL_Weak);
}

bool hasAddressSpace() const { return Mask & AddressSpaceMask; }
LangAS getAddressSpace() const {
  return static_cast<LangAS>(Mask >> AddressSpaceShift);
}
bool hasTargetSpecificAddressSpace() const {
  return isTargetAddressSpace(getAddressSpace());
}
/// Get the address space attribute value to be printed by diagnostics.
unsigned getAddressSpaceAttributePrintValue() const {
  auto Addr = getAddressSpace();
  // This function is not supposed to be used with language specific
  // address spaces. If that happens, the diagnostic message should consider
  // printing the QualType instead of the address space value.
  assert(Addr == LangAS::Default || hasTargetSpecificAddressSpace())((void)0);
  if (Addr != LangAS::Default)
    return toTargetAddressSpace(Addr);
  // TODO: The diagnostic messages where Addr may be 0 should be fixed
  // since it cannot differentiate the situation where 0 denotes the default
  // address space or user specified __attribute__((address_space(0))).
  return 0;
}
void setAddressSpace(LangAS space) {
  assert((unsigned)space <= MaxAddressSpace)((void)0);
  Mask = (Mask & ~AddressSpaceMask)
       | (((uint32_t) space) << AddressSpaceShift);
}
void removeAddressSpace() { setAddressSpace(LangAS::Default); }
void addAddressSpace(LangAS space) {
  assert(space != LangAS::Default)((void)0);
  setAddressSpace(space);
}

// Fast qualifiers are those that can be allocated directly
// on a QualType object.
bool hasFastQualifiers() const { return getFastQualifiers(); }
unsigned getFastQualifiers() const { return Mask & FastMask; }
void setFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((void)0);
  Mask = (Mask & ~FastMask) | mask;
}
void removeFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((void)0);
  Mask &= ~mask;
}
void removeFastQualifiers() {
  removeFastQualifiers(FastMask);
}
void addFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((void)0);
  Mask |= mask;
}

/// Return true if the set contains any qualifiers which require an ExtQuals
/// node to be allocated.
bool hasNonFastQualifiers() const { return Mask & ~FastMask; }
Qualifiers getNonFastQualifiers() const {
  Qualifiers Quals = *this;
  Quals.setFastQualifiers(0);
  return Quals;
}

/// Return true if the set contains any qualifiers.
bool hasQualifiers() const { return Mask; }
bool empty() const { return !Mask; }

/// Add the qualifiers from the given set to this set.
void addQualifiers(Qualifiers Q) {
  // If the other set doesn't have any non-boolean qualifiers, just
  // bit-or it in.
  if (!(Q.Mask & ~CVRMask))
    Mask |= Q.Mask;
  else {
    Mask |= (Q.Mask & CVRMask);
    if (Q.hasAddressSpace())
      addAddressSpace(Q.getAddressSpace());
    if (Q.hasObjCGCAttr())
      addObjCGCAttr(Q.getObjCGCAttr());
    if (Q.hasObjCLifetime())
      addObjCLifetime(Q.getObjCLifetime());
  }
}

/// Remove the qualifiers from the given set from this set.
void removeQualifiers(Qualifiers Q) {
  // If the other set doesn't have any non-boolean qualifiers, just
  // bit-and the inverse in.
  if (!(Q.Mask & ~CVRMask))
    Mask &= ~Q.Mask;
  else {
    Mask &= ~(Q.Mask & CVRMask);
    if (getObjCGCAttr() == Q.getObjCGCAttr())
      removeObjCGCAttr();
    if (getObjCLifetime() == Q.getObjCLifetime())
      removeObjCLifetime();
    if (getAddressSpace() == Q.getAddressSpace())
      removeAddressSpace();
  }
}

/// Add the qualifiers from the given set to this set, given that
/// they don't conflict.
void addConsistentQualifiers(Qualifiers qs) {
  assert(getAddressSpace() == qs.getAddressSpace() ||((void)0)
         !hasAddressSpace() || !qs.hasAddressSpace())((void)0);
  assert(getObjCGCAttr() == qs.getObjCGCAttr() ||((void)0)
         !hasObjCGCAttr() || !qs.hasObjCGCAttr())((void)0);
  assert(getObjCLifetime() == qs.getObjCLifetime() ||((void)0)
         !hasObjCLifetime() || !qs.hasObjCLifetime())((void)0);
  Mask |= qs.Mask;
}

/// Returns true if address space A is equal to or a superset of B.
/// OpenCL v2.0 defines conversion rules (OpenCLC v2.0 s6.5.5) and notion of
/// overlapping address spaces.
/// CL1.1 or CL1.2:
///   every address space is a superset of itself.
/// CL2.0 adds:
///   __generic is a superset of any address space except for __constant.
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B) {
  // Address spaces must match exactly.
  return A == B ||
         // Otherwise in OpenCLC v2.0 s6.5.5: every address space except
         // for __constant can be used as __generic.
         (A == LangAS::opencl_generic && B != LangAS::opencl_constant) ||
         // We also define global_device and global_host address spaces,
         // to distinguish global pointers allocated on host from pointers
         // allocated on device, which are a subset of __global.
         (A == LangAS::opencl_global && (B == LangAS::opencl_global_device ||
                                         B == LangAS::opencl_global_host)) ||
         (A == LangAS::sycl_global && (B == LangAS::sycl_global_device ||
                                       B == LangAS::sycl_global_host)) ||
         // Consider pointer size address spaces to be equivalent to default.
         ((isPtrSizeAddressSpace(A) || A == LangAS::Default) &&
          (isPtrSizeAddressSpace(B) || B == LangAS::Default)) ||
         // Default is a superset of SYCL address spaces.
         (A == LangAS::Default &&
          (B == LangAS::sycl_private || B == LangAS::sycl_local ||
           B == LangAS::sycl_global || B == LangAS::sycl_global_device ||
           B == LangAS::sycl_global_host));
}

/// Returns true if the address space in these qualifiers is equal to or
/// a superset of the address space in the argument qualifiers.
bool isAddressSpaceSupersetOf(Qualifiers other) const {
  return isAddressSpaceSupersetOf(getAddressSpace(), other.getAddressSpace());
}

/// Determines if these qualifiers compatibly include another set.
/// Generally this answers the question of whether an object with the other
/// qualifiers can be safely used as an object with these qualifiers.
bool compatiblyIncludes(Qualifiers other) const {
  return isAddressSpaceSupersetOf(other) &&
         // ObjC GC qualifiers can match, be added, or be removed, but can't
         // be changed.
         (getObjCGCAttr() == other.getObjCGCAttr() || !hasObjCGCAttr() ||
          !other.hasObjCGCAttr()) &&
         // ObjC lifetime qualifiers must match exactly.
         getObjCLifetime() == other.getObjCLifetime() &&
         // CVR qualifiers may subset.
         (((Mask & CVRMask) | (other.Mask & CVRMask)) == (Mask & CVRMask)) &&
         // U qualifier may superset.
         (!other.hasUnaligned() || hasUnaligned());
}

/// Determines if these qualifiers compatibly include another set of
/// qualifiers from the narrow perspective of Objective-C ARC lifetime.
///
/// One set of Objective-C lifetime qualifiers compatibly includes the other
/// if the lifetime qualifiers match, or if both are non-__weak and the
/// including set also contains the 'const' qualifier, or both are non-__weak
/// and one is None (which can only happen in non-ARC modes).
bool compatiblyIncludesObjCLifetime(Qualifiers other) const {
  if (getObjCLifetime() == other.getObjCLifetime())
    return true;

  if (getObjCLifetime() == OCL_Weak || other.getObjCLifetime() == OCL_Weak)
    return false;

  if (getObjCLifetime() == OCL_None || other.getObjCLifetime() == OCL_None)
    return true;

  return hasConst();
}

/// Determine whether this set of qualifiers is a strict superset of
/// another set of qualifiers, not considering qualifier compatibility.
bool isStrictSupersetOf(Qualifiers Other) const;

bool operator==(Qualifiers Other) const { return Mask == Other.Mask; }
bool operator!=(Qualifiers Other) const { return Mask != Other.Mask; }

explicit operator bool() const { return hasQualifiers(); }

Qualifiers &operator+=(Qualifiers R) {
  addQualifiers(R);
  return *this;
}

// Union two qualifier sets.  If an enumerated qualifier appears
// in both sets, use the one from the right.
friend Qualifiers operator+(Qualifiers L, Qualifiers R) {
  L += R;
  return L;
}

Qualifiers &operator-=(Qualifiers R) {
  removeQualifiers(R);
  return *this;
}

/// Compute the difference between two qualifier sets.
friend Qualifiers operator-(Qualifiers L, Qualifiers R) {
  L -= R;
  return L;
}

std::string getAsString() const;
std::string getAsString(const PrintingPolicy &Policy) const;

static std::string getAddrSpaceAsString(LangAS AS);

bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const;
void print(raw_ostream &OS, const PrintingPolicy &Policy,
           bool appendSpaceIfNonEmpty = false) const;

void Profile(llvm::FoldingSetNodeID &ID) const {
  ID.AddInteger(Mask);
}

589private:
// bits:     |0 1 2|3|4 .. 5|6  ..  8|9   ...   31|
//           |C R V|U|GCAttr|Lifetime|AddressSpace|
uint32_t Mask = 0;

static const uint32_t UMask = 0x8;
static const uint32_t UShift = 3;
static const uint32_t GCAttrMask = 0x30;
static const uint32_t GCAttrShift = 4;
static const uint32_t LifetimeMask = 0x1C0;
static const uint32_t LifetimeShift = 6;
static const uint32_t AddressSpaceMask =
    ~(CVRMask | UMask | GCAttrMask | LifetimeMask);
static const uint32_t AddressSpaceShift = 9;
603};

605/// A std::pair-like structure for storing a qualified type split
606/// into its local qualifiers and its locally-unqualified type.
607struct SplitQualType {
/// The locally-unqualified type.
const Type *Ty = nullptr;

/// The local qualifiers.
Qualifiers Quals;

SplitQualType() = default;
SplitQualType(const Type *ty, Qualifiers qs) : Ty(ty), Quals(qs) {}

SplitQualType getSingleStepDesugaredType() const; // end of this file

// Make std::tie work.
std::pair<const Type *,Qualifiers> asPair() const {
  return std::pair<const Type *, Qualifiers>(Ty, Quals);
}

friend bool operator==(SplitQualType a, SplitQualType b) {
  return a.Ty == b.Ty && a.Quals == b.Quals;
}
friend bool operator!=(SplitQualType a, SplitQualType b) {
  return a.Ty != b.Ty || a.Quals != b.Quals;
}
630};

632/// The kind of type we are substituting Objective-C type arguments into.
633///
634/// The kind of substitution affects the replacement of type parameters when
635/// no concrete type information is provided, e.g., when dealing with an
636/// unspecialized type.
637enum class ObjCSubstitutionContext {
/// An ordinary type.
Ordinary,

/// The result type of a method or function.
Result,

/// The parameter type of a method or function.
Parameter,

/// The type of a property.
Property,

/// The superclass of a type.
Superclass,
652};

654/// A (possibly-)qualified type.
655///
656/// For efficiency, we don't store CV-qualified types as nodes on their
657/// own: instead each reference to a type stores the qualifiers.  This
658/// greatly reduces the number of nodes we need to allocate for types (for
659/// example we only need one for 'int', 'const int', 'volatile int',
660/// 'const volatile int', etc).
661///
662/// As an added efficiency bonus, instead of making this a pair, we
663/// just store the two bits we care about in the low bits of the
664/// pointer.  To handle the packing/unpacking, we make QualType be a
665/// simple wrapper class that acts like a smart pointer.  A third bit
666/// indicates whether there are extended qualifiers present, in which
667/// case the pointer points to a special structure.
668class QualType {
friend class QualifierCollector;

// Thankfully, these are efficiently composable.
llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
                     Qualifiers::FastWidth> Value;

const ExtQuals *getExtQualsUnsafe() const {
  return Value.getPointer().get<const ExtQuals*>();
}

const Type *getTypePtrUnsafe() const {
  return Value.getPointer().get<const Type*>();
}

const ExtQualsTypeCommonBase *getCommonPtr() const {
  assert(!isNull() && "Cannot retrieve a NULL type pointer")((void)0);
  auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
  CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
  return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal);
}

690public:
QualType() = default;
QualType(const Type *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
QualType(const ExtQuals *Ptr, unsigned Quals) : Value(Ptr, Quals) {}

unsigned getLocalFastQualifiers() const { return Value.getInt(); }
void setLocalFastQualifiers(unsigned Quals) { Value.setInt(Quals); }

/// Retrieves a pointer to the underlying (unqualified) type.
///
/// This function requires that the type not be NULL. If the type might be
/// NULL, use the (slightly less efficient) \c getTypePtrOrNull().
const Type *getTypePtr() const;

const Type *getTypePtrOrNull() const;

/// Retrieves a pointer to the name of the base type.
const IdentifierInfo *getBaseTypeIdentifier() const;

/// Divides a QualType into its unqualified type and a set of local
/// qualifiers.
SplitQualType split() const;

void *getAsOpaquePtr() const { return Value.getOpaqueValue(); }

static QualType getFromOpaquePtr(const void *Ptr) {
  QualType T;
  T.Value.setFromOpaqueValue(const_cast<void*>(Ptr));
  return T;
}

const Type &operator*() const {
  return *getTypePtr();
}

const Type *operator->() const {
  return getTypePtr();
}

bool isCanonical() const;
bool isCanonicalAsParam() const;

/// Return true if this QualType doesn't point to a type yet.
bool isNull() const {
  return Value.getPointer().isNull();
}

/// Determine whether this particular QualType instance has the
/// "const" qualifier set, without looking through typedefs that may have
/// added "const" at a different level.
bool isLocalConstQualified() const {
  return (getLocalFastQualifiers() & Qualifiers::Const);
}

/// Determine whether this type is const-qualified.
bool isConstQualified() const;

/// Determine whether this particular QualType instance has the
/// "restrict" qualifier set, without looking through typedefs that may have
/// added "restrict" at a different level.
bool isLocalRestrictQualified() const {
  return (getLocalFastQualifiers() & Qualifiers::Restrict);
}

/// Determine whether this type is restrict-qualified.
bool isRestrictQualified() const;

/// Determine whether this particular QualType instance has the
/// "volatile" qualifier set, without looking through typedefs that may have
/// added "volatile" at a different level.
bool isLocalVolatileQualified() const {
  return (getLocalFastQualifiers() & Qualifiers::Volatile);
}

/// Determine whether this type is volatile-qualified.
bool isVolatileQualified() const;

/// Determine whether this particular QualType instance has any
/// qualifiers, without looking through any typedefs that might add
/// qualifiers at a different level.
bool hasLocalQualifiers() const {
  return getLocalFastQualifiers() || hasLocalNonFastQualifiers();
}

/// Determine whether this type has any qualifiers.
bool hasQualifiers() const;

/// Determine whether this particular QualType instance has any
/// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType
/// instance.
bool hasLocalNonFastQualifiers() const {
  return Value.getPointer().is<const ExtQuals*>();
}

/// Retrieve the set of qualifiers local to this particular QualType
/// instance, not including any qualifiers acquired through typedefs or
/// other sugar.
Qualifiers getLocalQualifiers() const;

/// Retrieve the set of qualifiers applied to this type.
Qualifiers getQualifiers() const;

/// Retrieve the set of CVR (const-volatile-restrict) qualifiers
/// local to this particular QualType instance, not including any qualifiers
/// acquired through typedefs or other sugar.
unsigned getLocalCVRQualifiers() const {
  return getLocalFastQualifiers();
}

/// Retrieve the set of CVR (const-volatile-restrict) qualifiers
/// applied to this type.
unsigned getCVRQualifiers() const;

bool isConstant(const ASTContext& Ctx) const {
  return QualType::isConstant(*this, Ctx);
}

/// Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
bool isPODType(const ASTContext &Context) const;

/// Return true if this is a POD type according to the rules of the C++98
/// standard, regardless of the current compilation's language.
bool isCXX98PODType(const ASTContext &Context) const;

/// Return true if this is a POD type according to the more relaxed rules
/// of the C++11 standard, regardless of the current compilation's language.
/// (C++0x [basic.types]p9). Note that, unlike
/// CXXRecordDecl::isCXX11StandardLayout, this takes DRs into account.
bool isCXX11PODType(const ASTContext &Context) const;

/// Return true if this is a trivial type per (C++0x [basic.types]p9)
bool isTrivialType(const ASTContext &Context) const;

/// Return true if this is a trivially copyable type (C++0x [basic.types]p9)
bool isTriviallyCopyableType(const ASTContext &Context) const;


/// Returns true if it is a class and it might be dynamic.
bool mayBeDynamicClass() const;

/// Returns true if it is not a class or if the class might not be dynamic.
bool mayBeNotDynamicClass() const;

// Don't promise in the API that anything besides 'const' can be
// easily added.

/// Add the `const` type qualifier to this QualType.
void addConst() {
  addFastQualifiers(Qualifiers::Const);
}
QualType withConst() const {
  return withFastQualifiers(Qualifiers::Const);
}

/// Add the `volatile` type qualifier to this QualType.
void addVolatile() {
  addFastQualifiers(Qualifiers::Volatile);
}
QualType withVolatile() const {
  return withFastQualifiers(Qualifiers::Volatile);
}

/// Add the `restrict` qualifier to this QualType.
void addRestrict() {
  addFastQualifiers(Qualifiers::Restrict);
}
QualType withRestrict() const {
  return withFastQualifiers(Qualifiers::Restrict);
}

QualType withCVRQualifiers(unsigned CVR) const {
  return withFastQualifiers(CVR);
}

void addFastQualifiers(unsigned TQs) {
  assert(!(TQs & ~Qualifiers::FastMask)((void)0)
         && "non-fast qualifier bits set in mask!")((void)0);
  Value.setInt(Value.getInt() | TQs);
}

void removeLocalConst();
void removeLocalVolatile();
void removeLocalRestrict();
void removeLocalCVRQualifiers(unsigned Mask);

void removeLocalFastQualifiers() { Value.setInt(0); }
void removeLocalFastQualifiers(unsigned Mask) {
  assert(!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers")((void)0);
  Value.setInt(Value.getInt() & ~Mask);
}

// Creates a type with the given qualifiers in addition to any
// qualifiers already on this type.
QualType withFastQualifiers(unsigned TQs) const {
  QualType T = *this;
  T.addFastQualifiers(TQs);
  return T;
}

// Creates a type with exactly the given fast qualifiers, removing
// any existing fast qualifiers.
QualType withExactLocalFastQualifiers(unsigned TQs) const {
  return withoutLocalFastQualifiers().withFastQualifiers(TQs);
}

// Removes fast qualifiers, but leaves any extended qualifiers in place.
QualType withoutLocalFastQualifiers() const {
  QualType T = *this;
  T.removeLocalFastQualifiers();
  return T;
}

QualType getCanonicalType() const;

/// Return this type with all of the instance-specific qualifiers
/// removed, but without removing any qualifiers that may have been applied
/// through typedefs.
QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); }

/// Retrieve the unqualified variant of the given type,
/// removing as little sugar as possible.
///
/// This routine looks through various kinds of sugar to find the
/// least-desugared type that is unqualified. For example, given:
///
/// \code
/// typedef int Integer;
/// typedef const Integer CInteger;
/// typedef CInteger DifferenceType;
/// \endcode
///
/// Executing \c getUnqualifiedType() on the type \c DifferenceType will
/// desugar until we hit the type \c Integer, which has no qualifiers on it.
///
/// The resulting type might still be qualified if it's sugar for an array
/// type.  To strip qualifiers even from within a sugared array type, use
/// ASTContext::getUnqualifiedArrayType.
inline QualType getUnqualifiedType() const;

/// Retrieve the unqualified variant of the given type, removing as little
/// sugar as possible.
///
/// Like getUnqualifiedType(), but also returns the set of
/// qualifiers that were built up.
///
/// The resulting type might still be qualified if it's sugar for an array
/// type.  To strip qualifiers even from within a sugared array type, use
/// ASTContext::getUnqualifiedArrayType.
inline SplitQualType getSplitUnqualifiedType() const;

/// Determine whether this type is more qualified than the other
/// given type, requiring exact equality for non-CVR qualifiers.
bool isMoreQualifiedThan(QualType Other) const;

/// Determine whether this type is at least as qualified as the other
/// given type, requiring exact equality for non-CVR qualifiers.
bool isAtLeastAsQualifiedAs(QualType Other) const;

QualType getNonReferenceType() const;

/// Determine the type of a (typically non-lvalue) expression with the
/// specified result type.
///
/// This routine should be used for expressions for which the return type is
/// explicitly specified (e.g., in a cast or call) and isn't necessarily
/// an lvalue. It removes a top-level reference (since there are no
/// expressions of reference type) and deletes top-level cvr-qualifiers
/// from non-class types (in C++) or all types (in C).
QualType getNonLValueExprType(const ASTContext &Context) const;

/// Remove an outer pack expansion type (if any) from this type. Used as part
/// of converting the type of a declaration to the type of an expression that
/// references that expression. It's meaningless for an expression to have a
/// pack expansion type.
QualType getNonPackExpansionType() const;

/// Return the specified type with any "sugar" removed from
/// the type.  This takes off typedefs, typeof's etc.  If the outer level of
/// the type is already concrete, it returns it unmodified.  This is similar
/// to getting the canonical type, but it doesn't remove *all* typedefs.  For
/// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
/// concrete.
///
/// Qualifiers are left in place.
QualType getDesugaredType(const ASTContext &Context) const {
  return getDesugaredType(*this, Context);
}

SplitQualType getSplitDesugaredType() const {
  return getSplitDesugaredType(*this);
}

/// Return the specified type with one level of "sugar" removed from
/// the type.
///
/// This routine takes off the first typedef, typeof, etc. If the outer level
/// of the type is already concrete, it returns it unmodified.
QualType getSingleStepDesugaredType(const ASTContext &Context) const {
  return getSingleStepDesugaredTypeImpl(*this, Context);
}

/// Returns the specified type after dropping any
/// outer-level parentheses.
QualType IgnoreParens() const {
  if (isa<ParenType>(*this))
    return QualType::IgnoreParens(*this);
  return *this;
}

/// Indicate whether the specified types and qualifiers are identical.
friend bool operator==(const QualType &LHS, const QualType &RHS) {
  return LHS.Value == RHS.Value;
}
friend bool operator!=(const QualType &LHS, const QualType &RHS) {
  return LHS.Value != RHS.Value;
}
friend bool operator<(const QualType &LHS, const QualType &RHS) {
  return LHS.Value < RHS.Value;
}

static std::string getAsString(SplitQualType split,
                               const PrintingPolicy &Policy) {
  return getAsString(split.Ty, split.Quals, Policy);
}
static std::string getAsString(const Type *ty, Qualifiers qs,
                               const PrintingPolicy &Policy);

std::string getAsString() const;
std::string getAsString(const PrintingPolicy &Policy) const;

void print(raw_ostream &OS, const PrintingPolicy &Policy,
           const Twine &PlaceHolder = Twine(),
           unsigned Indentation = 0) const;

static void print(SplitQualType split, raw_ostream &OS,
                  const PrintingPolicy &policy, const Twine &PlaceHolder,
                  unsigned Indentation = 0) {
  return print(split.Ty, split.Quals, OS, policy, PlaceHolder, Indentation);
}

static void print(const Type *ty, Qualifiers qs,
                  raw_ostream &OS, const PrintingPolicy &policy,
                  const Twine &PlaceHolder,
                  unsigned Indentation = 0);

void getAsStringInternal(std::string &Str,
                         const PrintingPolicy &Policy) const;

static void getAsStringInternal(SplitQualType split, std::string &out,
                                const PrintingPolicy &policy) {
  return getAsStringInternal(split.Ty, split.Quals, out, policy);
}

static void getAsStringInternal(const Type *ty, Qualifiers qs,
                                std::string &out,
                                const PrintingPolicy &policy);

class StreamedQualTypeHelper {
  const QualType &T;
  const PrintingPolicy &Policy;
  const Twine &PlaceHolder;
  unsigned Indentation;

public:
  StreamedQualTypeHelper(const QualType &T, const PrintingPolicy &Policy,
                         const Twine &PlaceHolder, unsigned Indentation)
      : T(T), Policy(Policy), PlaceHolder(PlaceHolder),
        Indentation(Indentation) {}

  friend raw_ostream &operator<<(raw_ostream &OS,
                                 const StreamedQualTypeHelper &SQT) {
    SQT.T.print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation);
    return OS;
  }
};

StreamedQualTypeHelper stream(const PrintingPolicy &Policy,
                              const Twine &PlaceHolder = Twine(),
                              unsigned Indentation = 0) const {
  return StreamedQualTypeHelper(*this, Policy, PlaceHolder, Indentation);
}

void dump(const char *s) const;
void dump() const;
void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;

void Profile(llvm::FoldingSetNodeID &ID) const {
  ID.AddPointer(getAsOpaquePtr());
}

/// Check if this type has any address space qualifier.
inline bool hasAddressSpace() const;

/// Return the address space of this type.
inline LangAS getAddressSpace() const;

/// Returns true if address space qualifiers overlap with T address space
/// qualifiers.
/// OpenCL C defines conversion rules for pointers to different address spaces
/// and notion of overlapping address spaces.
/// CL1.1 or CL1.2:
///   address spaces overlap iff they are they same.
/// OpenCL C v2.0 s6.5.5 adds:
///   __generic overlaps with any address space except for __constant.
bool isAddressSpaceOverlapping(QualType T) const {
  Qualifiers Q = getQualifiers();
  Qualifiers TQ = T.getQualifiers();
  // Address spaces overlap if at least one of them is a superset of another
  return Q.isAddressSpaceSupersetOf(TQ) || TQ.isAddressSpaceSupersetOf(Q);
}

/// Returns gc attribute of this type.
inline Qualifiers::GC getObjCGCAttr() const;

/// true when Type is objc's weak.
bool isObjCGCWeak() const {
  return getObjCGCAttr() == Qualifiers::Weak;
}

/// true when Type is objc's strong.
bool isObjCGCStrong() const {
  return getObjCGCAttr() == Qualifiers::Strong;
}

/// Returns lifetime attribute of this type.
Qualifiers::ObjCLifetime getObjCLifetime() const {
  return getQualifiers().getObjCLifetime();
}

bool hasNonTrivialObjCLifetime() const {
  return getQualifiers().hasNonTrivialObjCLifetime();
}

bool hasStrongOrWeakObjCLifetime() const {
  return getQualifiers().hasStrongOrWeakObjCLifetime();
}

// true when Type is objc's weak and weak is enabled but ARC isn't.
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const;

enum PrimitiveDefaultInitializeKind {
  /// The type does not fall into any of the following categories. Note that
  /// this case is zero-valued so that values of this enum can be used as a
  /// boolean condition for non-triviality.
  PDIK_Trivial,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __strong qualifier.
  PDIK_ARCStrong,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __weak qualifier.
  PDIK_ARCWeak,

  /// The type is a struct containing a field whose type is not PCK_Trivial.
  PDIK_Struct
};

/// Functions to query basic properties of non-trivial C struct types.

/// Check if this is a non-trivial type that would cause a C struct
/// transitively containing this type to be non-trivial to default initialize
/// and return the kind.
PrimitiveDefaultInitializeKind
isNonTrivialToPrimitiveDefaultInitialize() const;

enum PrimitiveCopyKind {
  /// The type does not fall into any of the following categories. Note that
  /// this case is zero-valued so that values of this enum can be used as a
  /// boolean condition for non-triviality.
  PCK_Trivial,

  /// The type would be trivial except that it is volatile-qualified. Types
  /// that fall into one of the other non-trivial cases may additionally be
  /// volatile-qualified.
  PCK_VolatileTrivial,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __strong qualifier.
  PCK_ARCStrong,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __weak qualifier.
  PCK_ARCWeak,

  /// The type is a struct containing a field whose type is neither
  /// PCK_Trivial nor PCK_VolatileTrivial.
  /// Note that a C++ struct type does not necessarily match this; C++ copying
  /// semantics are too complex to express here, in part because they depend
  /// on the exact constructor or assignment operator that is chosen by
  /// overload resolution to do the copy.
  PCK_Struct
};

/// Check if this is a non-trivial type that would cause a C struct
/// transitively containing this type to be non-trivial to copy and return the
/// kind.
PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const;

/// Check if this is a non-trivial type that would cause a C struct
/// transitively containing this type to be non-trivial to destructively
/// move and return the kind. Destructive move in this context is a C++-style
/// move in which the source object is placed in a valid but unspecified state
/// after it is moved, as opposed to a truly destructive move in which the
/// source object is placed in an uninitialized state.
PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const;

enum DestructionKind {
  DK_none,
  DK_cxx_destructor,
  DK_objc_strong_lifetime,
  DK_objc_weak_lifetime,
  DK_nontrivial_c_struct
};

/// Returns a nonzero value if objects of this type require
/// non-trivial work to clean up after.  Non-zero because it's
/// conceivable that qualifiers (objc_gc(weak)?) could make
/// something require destruction.
DestructionKind isDestructedType() const {
  return isDestructedTypeImpl(*this);
}

/// Check if this is or contains a C union that is non-trivial to
/// default-initialize, which is a union that has a member that is non-trivial
/// to default-initialize. If this returns true,
/// isNonTrivialToPrimitiveDefaultInitialize returns PDIK_Struct.
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const;

/// Check if this is or contains a C union that is non-trivial to destruct,
/// which is a union that has a member that is non-trivial to destruct. If
/// this returns true, isDestructedType returns DK_nontrivial_c_struct.
bool hasNonTrivialToPrimitiveDestructCUnion() const;

/// Check if this is or contains a C union that is non-trivial to copy, which
/// is a union that has a member that is non-trivial to copy. If this returns
/// true, isNonTrivialToPrimitiveCopy returns PCK_Struct.
bool hasNonTrivialToPrimitiveCopyCUnion() const;

/// Determine whether expressions of the given type are forbidden
/// from being lvalues in C.
///
/// The expression types that are forbidden to be lvalues are:
///   - 'void', but not qualified void
///   - function types
///
/// The exact rule here is C99 6.3.2.1:
///   An lvalue is an expression with an object type or an incomplete
///   type other than void.
bool isCForbiddenLValueType() const;

/// Substitute type arguments for the Objective-C type parameters used in the
/// subject type.
///
/// \param ctx ASTContext in which the type exists.
///
/// \param typeArgs The type arguments that will be substituted for the
/// Objective-C type parameters in the subject type, which are generally
/// computed via \c Type::getObjCSubstitutions. If empty, the type
/// parameters will be replaced with their bounds or id/Class, as appropriate
/// for the context.
///
/// \param context The context in which the subject type was written.
///
/// \returns the resulting type.
QualType substObjCTypeArgs(ASTContext &ctx,
                           ArrayRef<QualType> typeArgs,
                           ObjCSubstitutionContext context) const;

/// Substitute type arguments from an object type for the Objective-C type
/// parameters used in the subject type.
///
/// This operation combines the computation of type arguments for
/// substitution (\c Type::getObjCSubstitutions) with the actual process of
/// substitution (\c QualType::substObjCTypeArgs) for the convenience of
/// callers that need to perform a single substitution in isolation.
///
/// \param objectType The type of the object whose member type we're
/// substituting into. For example, this might be the receiver of a message
/// or the base of a property access.
///
/// \param dc The declaration context from which the subject type was
/// retrieved, which indicates (for example) which type parameters should
/// be substituted.
///
/// \param context The context in which the subject type was written.
///
/// \returns the subject type after replacing all of the Objective-C type
/// parameters with their corresponding arguments.
QualType substObjCMemberType(QualType objectType,
                             const DeclContext *dc,
                             ObjCSubstitutionContext context) const;

/// Strip Objective-C "__kindof" types from the given type.
QualType stripObjCKindOfType(const ASTContext &ctx) const;

/// Remove all qualifiers including _Atomic.
QualType getAtomicUnqualifiedType() const;

1289private:
// These methods are implemented in a separate translation unit;
// "static"-ize them to avoid creating temporary QualTypes in the
// caller.
static bool isConstant(QualType T, const ASTContext& Ctx);
static QualType getDesugaredType(QualType T, const ASTContext &Context);
static SplitQualType getSplitDesugaredType(QualType T);
static SplitQualType getSplitUnqualifiedTypeImpl(QualType type);
static QualType getSingleStepDesugaredTypeImpl(QualType type,
                                               const ASTContext &C);
static QualType IgnoreParens(QualType T);
static DestructionKind isDestructedTypeImpl(QualType type);

/// Check if \param RD is or contains a non-trivial C union.
static bool hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD);
static bool hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl *RD);
static bool hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD);
1306};

1308} // namespace clang

1310namespace llvm {

1312/// Implement simplify_type for QualType, so that we can dyn_cast from QualType
1313/// to a specific Type class.
1314template<> struct simplify_type< ::clang::QualType> {
using SimpleType = const ::clang::Type *;

static SimpleType getSimplifiedValue(::clang::QualType Val) {
  return Val.getTypePtr();
}
1320};

1322// Teach SmallPtrSet that QualType is "basically a pointer".
1323template<>
1324struct PointerLikeTypeTraits<clang::QualType> {
static inline void *getAsVoidPointer(clang::QualType P) {
  return P.getAsOpaquePtr();
}

static inline clang::QualType getFromVoidPointer(void *P) {
  return clang::QualType::getFromOpaquePtr(P);
}

// Various qualifiers go in low bits.
static constexpr int NumLowBitsAvailable = 0;
1335};

1337} // namespace llvm

1339namespace clang {

1341/// Base class that is common to both the \c ExtQuals and \c Type
1342/// classes, which allows \c QualType to access the common fields between the
1343/// two.
1344class ExtQualsTypeCommonBase {
friend class ExtQuals;
friend class QualType;
friend class Type;

/// The "base" type of an extended qualifiers type (\c ExtQuals) or
/// a self-referential pointer (for \c Type).
///
/// This pointer allows an efficient mapping from a QualType to its
/// underlying type pointer.
const Type *const BaseType;

/// The canonical type of this type.  A QualType.
QualType CanonicalType;

ExtQualsTypeCommonBase(const Type *baseType, QualType canon)
    : BaseType(baseType), CanonicalType(canon) {}
1361};

1363/// We can encode up to four bits in the low bits of a
1364/// type pointer, but there are many more type qualifiers that we want
1365/// to be able to apply to an arbitrary type.  Therefore we have this
1366/// struct, intended to be heap-allocated and used by QualType to
1367/// store qualifiers.
1368///
1369/// The current design tags the 'const', 'restrict', and 'volatile' qualifiers
1370/// in three low bits on the QualType pointer; a fourth bit records whether
1371/// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
1372/// Objective-C GC attributes) are much more rare.
1373class ExtQuals : public ExtQualsTypeCommonBase, public llvm::FoldingSetNode {
// NOTE: changing the fast qualifiers should be straightforward as
// long as you don't make 'const' non-fast.
// 1. Qualifiers:
//    a) Modify the bitmasks (Qualifiers::TQ and DeclSpec::TQ).
//       Fast qualifiers must occupy the low-order bits.
//    b) Update Qualifiers::FastWidth and FastMask.
// 2. QualType:
//    a) Update is{Volatile,Restrict}Qualified(), defined inline.
//    b) Update remove{Volatile,Restrict}, defined near the end of
//       this header.
// 3. ASTContext:
//    a) Update get{Volatile,Restrict}Type.

/// The immutable set of qualifiers applied by this node. Always contains
/// extended qualifiers.
Qualifiers Quals;

ExtQuals *this_() { return this; }

1393public:
ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
    : ExtQualsTypeCommonBase(baseType,
                             canon.isNull() ? QualType(this_(), 0) : canon),
      Quals(quals) {
  assert(Quals.hasNonFastQualifiers()((void)0)
         && "ExtQuals created with no fast qualifiers")((void)0);
  assert(!Quals.hasFastQualifiers()((void)0)
         && "ExtQuals created with fast qualifiers")((void)0);
}

Qualifiers getQualifiers() const { return Quals; }

bool hasObjCGCAttr() const { return Quals.hasObjCGCAttr(); }
Qualifiers::GC getObjCGCAttr() const { return Quals.getObjCGCAttr(); }

bool hasObjCLifetime() const { return Quals.hasObjCLifetime(); }
Qualifiers::ObjCLifetime getObjCLifetime() const {
  return Quals.getObjCLifetime();
}

bool hasAddressSpace() const { return Quals.hasAddressSpace(); }
LangAS getAddressSpace() const { return Quals.getAddressSpace(); }

const Type *getBaseType() const { return BaseType; }

1419public:
void Profile(llvm::FoldingSetNodeID &ID) const {
  Profile(ID, getBaseType(), Quals);
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    const Type *BaseType,
                    Qualifiers Quals) {
  assert(!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!")((void)0);
  ID.AddPointer(BaseType);
  Quals.Profile(ID);
}
1431};

1433/// The kind of C++11 ref-qualifier associated with a function type.
1434/// This determines whether a member function's "this" object can be an
1435/// lvalue, rvalue, or neither.
1436enum RefQualifierKind {
/// No ref-qualifier was provided.
RQ_None = 0,

/// An lvalue ref-qualifier was provided (\c &).
RQ_LValue,

/// An rvalue ref-qualifier was provided (\c &&).
RQ_RValue
1445};

1447/// Which keyword(s) were used to create an AutoType.
1448enum class AutoTypeKeyword {
/// auto
Auto,

/// decltype(auto)
DecltypeAuto,

/// __auto_type (GNU extension)
GNUAutoType
1457};

1459/// The base class of the type hierarchy.
1460///
1461/// A central concept with types is that each type always has a canonical
1462/// type.  A canonical type is the type with any typedef names stripped out
1463/// of it or the types it references.  For example, consider:
1464///
1465///  typedef int  foo;
1466///  typedef foo* bar;
1467///    'int *'    'foo *'    'bar'
1468///
1469/// There will be a Type object created for 'int'.  Since int is canonical, its
1470/// CanonicalType pointer points to itself.  There is also a Type for 'foo' (a
1471/// TypedefType).  Its CanonicalType pointer points to the 'int' Type.  Next
1472/// there is a PointerType that represents 'int*', which, like 'int', is
1473/// canonical.  Finally, there is a PointerType type for 'foo*' whose canonical
1474/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
1475/// is also 'int*'.
1476///
1477/// Non-canonical types are useful for emitting diagnostics, without losing
1478/// information about typedefs being used.  Canonical types are useful for type
1479/// comparisons (they allow by-pointer equality tests) and useful for reasoning
1480/// about whether something has a particular form (e.g. is a function type),
1481/// because they implicitly, recursively, strip all typedefs out of a type.
1482///
1483/// Types, once created, are immutable.
1484///
1485class alignas(8) Type : public ExtQualsTypeCommonBase {
1486public:
enum TypeClass {
1488#define TYPE(Class, Base) Class,
1489#define LAST_TYPE(Class) TypeLast = Class
1490#define ABSTRACT_TYPE(Class, Base)
1491#include "clang/AST/TypeNodes.inc"
};

1494private:
/// Bitfields required by the Type class.
class TypeBitfields {
  friend class Type;
  template <class T> friend class TypePropertyCache;

  /// TypeClass bitfield - Enum that specifies what subclass this belongs to.
  unsigned TC : 8;

  /// Store information on the type dependency.
  unsigned Dependence : llvm::BitWidth<TypeDependence>;

  /// True if the cache (i.e. the bitfields here starting with
  /// 'Cache') is valid.
  mutable unsigned CacheValid : 1;

  /// Linkage of this type.
  mutable unsigned CachedLinkage : 3;

  /// Whether this type involves and local or unnamed types.
  mutable unsigned CachedLocalOrUnnamed : 1;

  /// Whether this type comes from an AST file.
  mutable unsigned FromAST : 1;

  bool isCacheValid() const {
    return CacheValid;
  }

  Linkage getLinkage() const {
    assert(isCacheValid() && "getting linkage from invalid cache")((void)0);
    return static_cast<Linkage>(CachedLinkage);
  }

  bool hasLocalOrUnnamedType() const {
    assert(isCacheValid() && "getting linkage from invalid cache")((void)0);
    return CachedLocalOrUnnamed;
  }
};
enum { NumTypeBits = 8 + llvm::BitWidth<TypeDependence> + 6 };

1535protected:
// These classes allow subclasses to somewhat cleanly pack bitfields
// into Type.

class ArrayTypeBitfields {
  friend class ArrayType;

  unsigned : NumTypeBits;

  /// CVR qualifiers from declarations like
  /// 'int X[static restrict 4]'. For function parameters only.
  unsigned IndexTypeQuals : 3;

  /// Storage class qualifiers from declarations like
  /// 'int X[static restrict 4]'. For function parameters only.
  /// Actually an ArrayType::ArraySizeModifier.
  unsigned SizeModifier : 3;
};

class ConstantArrayTypeBitfields {
  friend class ConstantArrayType;

  unsigned : NumTypeBits + 3 + 3;

  /// Whether we have a stored size expression.
  unsigned HasStoredSizeExpr : 1;
};

class BuiltinTypeBitfields {
  friend class BuiltinType;

  unsigned : NumTypeBits;

  /// The kind (BuiltinType::Kind) of builtin type this is.
  unsigned Kind : 8;
};

/// FunctionTypeBitfields store various bits belonging to FunctionProtoType.
/// Only common bits are stored here. Additional uncommon bits are stored
/// in a trailing object after FunctionProtoType.
class FunctionTypeBitfields {
  friend class FunctionProtoType;
  friend class FunctionType;

  unsigned : NumTypeBits;

  /// Extra information which affects how the function is called, like
  /// regparm and the calling convention.
  unsigned ExtInfo : 13;

  /// The ref-qualifier associated with a \c FunctionProtoType.
  ///
  /// This is a value of type \c RefQualifierKind.
  unsigned RefQualifier : 2;

  /// Used only by FunctionProtoType, put here to pack with the
  /// other bitfields.
  /// The qualifiers are part of FunctionProtoType because...
  ///
  /// C++ 8.3.5p4: The return type, the parameter type list and the
  /// cv-qualifier-seq, [...], are part of the function type.
  unsigned FastTypeQuals : Qualifiers::FastWidth;
  /// Whether this function has extended Qualifiers.
  unsigned HasExtQuals : 1;

  /// The number of parameters this function has, not counting '...'.
  /// According to [implimits] 8 bits should be enough here but this is
  /// somewhat easy to exceed with metaprogramming and so we would like to
  /// keep NumParams as wide as reasonably possible.
  unsigned NumParams : 16;

  /// The type of exception specification this function has.
  unsigned ExceptionSpecType : 4;

  /// Whether this function has extended parameter information.
  unsigned HasExtParameterInfos : 1;

  /// Whether the function is variadic.
  unsigned Variadic : 1;

  /// Whether this function has a trailing return type.
  unsigned HasTrailingReturn : 1;
};

class ObjCObjectTypeBitfields {
  friend class ObjCObjectType;

  unsigned : NumTypeBits;

  /// The number of type arguments stored directly on this object type.
  unsigned NumTypeArgs : 7;

  /// The number of protocols stored directly on this object type.
  unsigned NumProtocols : 6;

  /// Whether this is a "kindof" type.
  unsigned IsKindOf : 1;
};

class ReferenceTypeBitfields {
  friend class ReferenceType;

  unsigned : NumTypeBits;

  /// True if the type was originally spelled with an lvalue sigil.
  /// This is never true of rvalue references but can also be false
  /// on lvalue references because of C++0x [dcl.typedef]p9,
  /// as follows:
  ///
  ///   typedef int &ref;    // lvalue, spelled lvalue
  ///   typedef int &&rvref; // rvalue
  ///   ref &a;              // lvalue, inner ref, spelled lvalue
  ///   ref &&a;             // lvalue, inner ref
  ///   rvref &a;            // lvalue, inner ref, spelled lvalue
  ///   rvref &&a;           // rvalue, inner ref
  unsigned SpelledAsLValue : 1;

  /// True if the inner type is a reference type.  This only happens
  /// in non-canonical forms.
  unsigned InnerRef : 1;
};

class TypeWithKeywordBitfields {
  friend class TypeWithKeyword;

  unsigned : NumTypeBits;

  /// An ElaboratedTypeKeyword.  8 bits for efficient access.
  unsigned Keyword : 8;
};

enum { NumTypeWithKeywordBits = 8 };

class ElaboratedTypeBitfields {
  friend class ElaboratedType;

  unsigned : NumTypeBits;
  unsigned : NumTypeWithKeywordBits;

  /// Whether the ElaboratedType has a trailing OwnedTagDecl.
  unsigned HasOwnedTagDecl : 1;
};

class VectorTypeBitfields {
  friend class VectorType;
  friend class DependentVectorType;

  unsigned : NumTypeBits;

  /// The kind of vector, either a generic vector type or some
  /// target-specific vector type such as for AltiVec or Neon.
  unsigned VecKind : 3;
  /// The number of elements in the vector.
  uint32_t NumElements;
};

class AttributedTypeBitfields {
  friend class AttributedType;

  unsigned : NumTypeBits;

  /// An AttributedType::Kind
  unsigned AttrKind : 32 - NumTypeBits;
};

class AutoTypeBitfields {
  friend class AutoType;

  unsigned : NumTypeBits;

  /// Was this placeholder type spelled as 'auto', 'decltype(auto)',
  /// or '__auto_type'?  AutoTypeKeyword value.
  unsigned Keyword : 2;

  /// The number of template arguments in the type-constraints, which is
  /// expected to be able to hold at least 1024 according to [implimits].
  /// However as this limit is somewhat easy to hit with template
  /// metaprogramming we'd prefer to keep it as large as possible.
  /// At the moment it has been left as a non-bitfield since this type
  /// safely fits in 64 bits as an unsigned, so there is no reason to
  /// introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class SubstTemplateTypeParmPackTypeBitfields {
  friend class SubstTemplateTypeParmPackType;

  unsigned : NumTypeBits;

  /// The number of template arguments in \c Arguments, which is
  /// expected to be able to hold at least 1024 according to [implimits].
  /// However as this limit is somewhat easy to hit with template
  /// metaprogramming we'd prefer to keep it as large as possible.
  /// At the moment it has been left as a non-bitfield since this type
  /// safely fits in 64 bits as an unsigned, so there is no reason to
  /// introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class TemplateSpecializationTypeBitfields {
  friend class TemplateSpecializationType;

  unsigned : NumTypeBits;

  /// Whether this template specialization type is a substituted type alias.
  unsigned TypeAlias : 1;

  /// The number of template arguments named in this class template
  /// specialization, which is expected to be able to hold at least 1024
  /// according to [implimits]. However, as this limit is somewhat easy to
  /// hit with template metaprogramming we'd prefer to keep it as large
  /// as possible. At the moment it has been left as a non-bitfield since
  /// this type safely fits in 64 bits as an unsigned, so there is no reason
  /// to introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class DependentTemplateSpecializationTypeBitfields {
  friend class DependentTemplateSpecializationType;

  unsigned : NumTypeBits;
  unsigned : NumTypeWithKeywordBits;

  /// The number of template arguments named in this class template
  /// specialization, which is expected to be able to hold at least 1024
  /// according to [implimits]. However, as this limit is somewhat easy to
  /// hit with template metaprogramming we'd prefer to keep it as large
  /// as possible. At the moment it has been left as a non-bitfield since
  /// this type safely fits in 64 bits as an unsigned, so there is no reason
  /// to introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class PackExpansionTypeBitfields {
  friend class PackExpansionType;

  unsigned : NumTypeBits;

  /// The number of expansions that this pack expansion will
  /// generate when substituted (+1), which is expected to be able to
  /// hold at least 1024 according to [implimits]. However, as this limit
  /// is somewhat easy to hit with template metaprogramming we'd prefer to
  /// keep it as large as possible. At the moment it has been left as a
  /// non-bitfield since this type safely fits in 64 bits as an unsigned, so
  /// there is no reason to introduce the performance impact of a bitfield.
  ///
  /// This field will only have a non-zero value when some of the parameter
  /// packs that occur within the pattern have been substituted but others
  /// have not.
  unsigned NumExpansions;
};

union {
  TypeBitfields TypeBits;
  ArrayTypeBitfields ArrayTypeBits;
  ConstantArrayTypeBitfields ConstantArrayTypeBits;
  AttributedTypeBitfields AttributedTypeBits;
  AutoTypeBitfields AutoTypeBits;
  BuiltinTypeBitfields BuiltinTypeBits;
  FunctionTypeBitfields FunctionTypeBits;
  ObjCObjectTypeBitfields ObjCObjectTypeBits;
  ReferenceTypeBitfields ReferenceTypeBits;
  TypeWithKeywordBitfields TypeWithKeywordBits;
  ElaboratedTypeBitfields ElaboratedTypeBits;
  VectorTypeBitfields VectorTypeBits;
  SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits;
  TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits;
  DependentTemplateSpecializationTypeBitfields
    DependentTemplateSpecializationTypeBits;
  PackExpansionTypeBitfields PackExpansionTypeBits;
};

1807private:
template <class T> friend class TypePropertyCache;

/// Set whether this type comes from an AST file.
void setFromAST(bool V = true) const {
  TypeBits.FromAST = V;
}

1815protected:
friend class ASTContext;

Type(TypeClass tc, QualType canon, TypeDependence Dependence)
    : ExtQualsTypeCommonBase(this,
                             canon.isNull() ? QualType(this_(), 0) : canon) {
  static_assert(sizeof(*this) <= 8 + sizeof(ExtQualsTypeCommonBase),
                "changing bitfields changed sizeof(Type)!");
  static_assert(alignof(decltype(*this)) % sizeof(void *) == 0,
                "Insufficient alignment!");
  TypeBits.TC = tc;
  TypeBits.Dependence = static_cast<unsigned>(Dependence);
  TypeBits.CacheValid = false;
  TypeBits.CachedLocalOrUnnamed = false;
  TypeBits.CachedLinkage = NoLinkage;
  TypeBits.FromAST = false;
}

// silence VC++ warning C4355: 'this' : used in base member initializer list
Type *this_() { return this; }

void setDependence(TypeDependence D) {
  TypeBits.Dependence = static_cast<unsigned>(D);
}

void addDependence(TypeDependence D) { setDependence(getDependence() | D); }

1842public:
friend class ASTReader;
friend class ASTWriter;
template <class T> friend class serialization::AbstractTypeReader;
template <class T> friend class serialization::AbstractTypeWriter;

Type(const Type &) = delete;
Type(Type &&) = delete;
Type &operator=(const Type &) = delete;
Type &operator=(Type &&) = delete;

TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); }

/// Whether this type comes from an AST file.
bool isFromAST() const { return TypeBits.FromAST; }

/// Whether this type is or contains an unexpanded parameter
/// pack, used to support C++0x variadic templates.
///
/// A type that contains a parameter pack shall be expanded by the
/// ellipsis operator at some point. For example, the typedef in the
/// following example contains an unexpanded parameter pack 'T':
///
/// \code
/// template<typename ...T>
/// struct X {
///   typedef T* pointer_types; // ill-formed; T is a parameter pack.
/// };
/// \endcode
///
/// Note that this routine does not specify which
bool containsUnexpandedParameterPack() const {
  return getDependence() & TypeDependence::UnexpandedPack;
}

/// Determines if this type would be canonical if it had no further
/// qualification.
bool isCanonicalUnqualified() const {
  return CanonicalType == QualType(this, 0);
}

/// Pull a single level of sugar off of this locally-unqualified type.
/// Users should generally prefer SplitQualType::getSingleStepDesugaredType()
/// or QualType::getSingleStepDesugaredType(const ASTContext&).
QualType getLocallyUnqualifiedSingleStepDesugaredType() const;

/// As an extension, we classify types as one of "sized" or "sizeless";
/// every type is one or the other.  Standard types are all sized;
/// sizeless types are purely an extension.
///
/// Sizeless types contain data with no specified size, alignment,
/// or layout.
bool isSizelessType() const;
bool isSizelessBuiltinType() const;

/// Determines if this is a sizeless type supported by the
/// 'arm_sve_vector_bits' type attribute, which can be applied to a single
/// SVE vector or predicate, excluding tuple types such as svint32x4_t.
bool isVLSTBuiltinType() const;

/// Returns the representative type for the element of an SVE builtin type.
/// This is used to represent fixed-length SVE vectors created with the
/// 'arm_sve_vector_bits' type attribute as VectorType.
QualType getSveEltType(const ASTContext &Ctx) const;

/// Types are partitioned into 3 broad categories (C99 6.2.5p1):
/// object types, function types, and incomplete types.

/// Return true if this is an incomplete type.
/// A type that can describe objects, but which lacks information needed to
/// determine its size (e.g. void, or a fwd declared struct). Clients of this
/// routine will need to determine if the size is actually required.
///
/// Def If non-null, and the type refers to some kind of declaration
/// that can be completed (such as a C struct, C++ class, or Objective-C
/// class), will be set to the declaration.
bool isIncompleteType(NamedDecl **Def = nullptr) const;

/// Return true if this is an incomplete or object
/// type, in other words, not a function type.
bool isIncompleteOrObjectType() const {
  return !isFunctionType();
}

/// Determine whether this type is an object type.
bool isObjectType() const {
  // C++ [basic.types]p8:
  //   An object type is a (possibly cv-qualified) type that is not a
  //   function type, not a reference type, and not a void type.
  return !isReferenceType() && !isFunctionType() && !isVoidType();
}

/// Return true if this is a literal type
/// (C++11 [basic.types]p10)
bool isLiteralType(const ASTContext &Ctx) const;

/// Determine if this type is a structural type, per C++20 [temp.param]p7.
bool isStructuralType() const;

/// Test if this type is a standard-layout type.
/// (C++0x [basic.type]p9)
bool isStandardLayoutType() const;

/// Helper methods to distinguish type categories. All type predicates
/// operate on the canonical type, ignoring typedefs and qualifiers.

/// Returns true if the type is a builtin type.
bool isBuiltinType() const;

/// Test for a particular builtin type.
bool isSpecificBuiltinType(unsigned K) const;

/// Test for a type which does not represent an actual type-system type but
/// is instead used as a placeholder for various convenient purposes within
/// Clang.  All such types are BuiltinTypes.
bool isPlaceholderType() const;
const BuiltinType *getAsPlaceholderType() const;

/// Test for a specific placeholder type.
bool isSpecificPlaceholderType(unsigned K) const;

/// Test for a placeholder type other than Overload; see
/// BuiltinType::isNonOverloadPlaceholderType.
bool isNonOverloadPlaceholderType() const;

/// isIntegerType() does *not* include complex integers (a GCC extension).
/// isComplexIntegerType() can be used to test for complex integers.
bool isIntegerType() const;     // C99 6.2.5p17 (int, char, bool, enum)
bool isEnumeralType() const;

/// Determine whether this type is a scoped enumeration type.
bool isScopedEnumeralType() const;
bool isBooleanType() const;
bool isCharType() const;
bool isWideCharType() const;
bool isChar8Type() const;
bool isChar16Type() const;
bool isChar32Type() const;
bool isAnyCharacterType() const;
bool isIntegralType(const ASTContext &Ctx) const;

/// Determine whether this type is an integral or enumeration type.
bool isIntegralOrEnumerationType() const;

/// Determine whether this type is an integral or unscoped enumeration type.
bool isIntegralOrUnscopedEnumerationType() const;
bool isUnscopedEnumerationType() const;

/// Floating point categories.
bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double)
/// isComplexType() does *not* include complex integers (a GCC extension).
/// isComplexIntegerType() can be used to test for complex integers.
bool isComplexType() const;      // C99 6.2.5p11 (complex)
bool isAnyComplexType() const;   // C99 6.2.5p11 (complex) + Complex Int.
bool isFloatingType() const;     // C99 6.2.5p11 (real floating + complex)
bool isHalfType() const;         // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
bool isFloat16Type() const;      // C11 extension ISO/IEC TS 18661
bool isBFloat16Type() const;
bool isFloat128Type() const;
bool isRealType() const;         // C99 6.2.5p17 (real floating + integer)
bool isArithmeticType() const;   // C99 6.2.5p18 (integer + floating)
bool isVoidType() const;         // C99 6.2.5p19
bool isScalarType() const;       // C99 6.2.5p21 (arithmetic + pointers)
bool isAggregateType() const;
bool isFundamentalType() const;
bool isCompoundType() const;

// Type Predicates: Check to see if this type is structurally the specified
// type, ignoring typedefs and qualifiers.
bool isFunctionType() const;
bool isFunctionNoProtoType() const { return getAs<FunctionNoProtoType>(); }
bool isFunctionProtoType() const { return getAs<FunctionProtoType>(); }
bool isPointerType() const;
bool isAnyPointerType() const;   // Any C pointer or ObjC object pointer
bool isBlockPointerType() const;
bool isVoidPointerType() const;
bool isReferenceType() const;
bool isLValueReferenceType() const;
bool isRValueReferenceType() const;
bool isObjectPointerType() const;
bool isFunctionPointerType() const;
bool isFunctionReferenceType() const;
bool isMemberPointerType() const;
bool isMemberFunctionPointerType() const;
bool isMemberDataPointerType() const;
bool isArrayType() const;
bool isConstantArrayType() const;
bool isIncompleteArrayType() const;
bool isVariableArrayType() const;
bool isDependentSizedArrayType() const;
bool isRecordType() const;
bool isClassType() const;
bool isStructureType() const;
bool isObjCBoxableRecordType() const;
bool isInterfaceType() const;
bool isStructureOrClassType() const;
bool isUnionType() const;
bool isComplexIntegerType() const;            // GCC _Complex integer type.
bool isVectorType() const;                    // GCC vector type.
bool isExtVectorType() const;                 // Extended vector type.
bool isMatrixType() const;                    // Matrix type.
bool isConstantMatrixType() const;            // Constant matrix type.
bool isDependentAddressSpaceType() const;     // value-dependent address space qualifier
bool isObjCObjectPointerType() const;         // pointer to ObjC object
bool isObjCRetainableType() const;            // ObjC object or block pointer
bool isObjCLifetimeType() const;              // (array of)* retainable type
bool isObjCIndirectLifetimeType() const;      // (pointer to)* lifetime type
bool isObjCNSObjectType() const;              // __attribute__((NSObject))
bool isObjCIndependentClassType() const;      // __attribute__((objc_independent_class))
// FIXME: change this to 'raw' interface type, so we can used 'interface' type
// for the common case.
bool isObjCObjectType() const;                // NSString or typeof(*(id)0)
bool isObjCQualifiedInterfaceType() const;    // NSString<foo>
bool isObjCQualifiedIdType() const;           // id<foo>
bool isObjCQualifiedClassType() const;        // Class<foo>
bool isObjCObjectOrInterfaceType() const;
bool isObjCIdType() const;                    // id
bool isDecltypeType() const;
/// Was this type written with the special inert-in-ARC __unsafe_unretained
/// qualifier?
///
/// This approximates the answer to the following question: if this
/// translation unit were compiled in ARC, would this type be qualified
/// with __unsafe_unretained?
bool isObjCInertUnsafeUnretainedType() const {
  return hasAttr(attr::ObjCInertUnsafeUnretained);
}

/// Whether the type is Objective-C 'id' or a __kindof type of an
/// object type, e.g., __kindof NSView * or __kindof id
/// <NSCopying>.
///
/// \param bound Will be set to the bound on non-id subtype types,
/// which will be (possibly specialized) Objective-C class type, or
/// null for 'id.
bool isObjCIdOrObjectKindOfType(const ASTContext &ctx,
                                const ObjCObjectType *&bound) const;

bool isObjCClassType() const;                 // Class

/// Whether the type is Objective-C 'Class' or a __kindof type of an
/// Class type, e.g., __kindof Class <NSCopying>.
///
/// Unlike \c isObjCIdOrObjectKindOfType, there is no relevant bound
/// here because Objective-C's type system cannot express "a class
/// object for a subclass of NSFoo".
bool isObjCClassOrClassKindOfType() const;

bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const;
bool isObjCSelType() const;                 // Class
bool isObjCBuiltinType() const;               // 'id' or 'Class'
bool isObjCARCBridgableType() const;
bool isCARCBridgableType() const;
bool isTemplateTypeParmType() const;          // C++ template type parameter
bool isNullPtrType() const;                   // C++11 std::nullptr_t
bool isNothrowT() const;                      // C++   std::nothrow_t
bool isAlignValT() const;                     // C++17 std::align_val_t
bool isStdByteType() const;                   // C++17 std::byte
bool isAtomicType() const;                    // C11 _Atomic()
bool isUndeducedAutoType() const;             // C++11 auto or
                                              // C++14 decltype(auto)
bool isTypedefNameType() const;               // typedef or alias template

2105#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
bool is##Id##Type() const;
2107#include "clang/Basic/OpenCLImageTypes.def"

bool isImageType() const;                     // Any OpenCL image type

bool isSamplerT() const;                      // OpenCL sampler_t
bool isEventT() const;                        // OpenCL event_t
bool isClkEventT() const;                     // OpenCL clk_event_t
bool isQueueT() const;                        // OpenCL queue_t
bool isReserveIDT() const;                    // OpenCL reserve_id_t

2117#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
bool is##Id##Type() const;
2119#include "clang/Basic/OpenCLExtensionTypes.def"
// Type defined in cl_intel_device_side_avc_motion_estimation OpenCL extension
bool isOCLIntelSubgroupAVCType() const;
bool isOCLExtOpaqueType() const;              // Any OpenCL extension type

bool isPipeType() const;                      // OpenCL pipe type
bool isExtIntType() const;                    // Extended Int Type
bool isOpenCLSpecificType() const;            // Any OpenCL specific type

/// Determines if this type, which must satisfy
/// isObjCLifetimeType(), is implicitly __unsafe_unretained rather
/// than implicitly __strong.
bool isObjCARCImplicitlyUnretainedType() const;

/// Check if the type is the CUDA device builtin surface type.
bool isCUDADeviceBuiltinSurfaceType() const;
/// Check if the type is the CUDA device builtin texture type.
bool isCUDADeviceBuiltinTextureType() const;

/// Return the implicit lifetime for this type, which must not be dependent.
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const;

enum ScalarTypeKind {
  STK_CPointer,
  STK_BlockPointer,
  STK_ObjCObjectPointer,
  STK_MemberPointer,
  STK_Bool,
  STK_Integral,
  STK_Floating,
  STK_IntegralComplex,
  STK_FloatingComplex,
  STK_FixedPoint
};

/// Given that this is a scalar type, classify it.
ScalarTypeKind getScalarTypeKind() const;

TypeDependence getDependence() const {
  return static_cast<TypeDependence>(TypeBits.Dependence);
}

/// Whether this type is an error type.
bool containsErrors() const {
  return getDependence() & TypeDependence::Error;
}

/// Whether this type is a dependent type, meaning that its definition
/// somehow depends on a template parameter (C++ [temp.dep.type]).
bool isDependentType() const {
  return getDependence() & TypeDependence::Dependent;
}

/// Determine whether this type is an instantiation-dependent type,
/// meaning that the type involves a template parameter (even if the
/// definition does not actually depend on the type substituted for that
/// template parameter).
bool isInstantiationDependentType() const {
  return getDependence() & TypeDependence::Instantiation;
}

/// Determine whether this type is an undeduced type, meaning that
/// it somehow involves a C++11 'auto' type or similar which has not yet been
/// deduced.
bool isUndeducedType() const;

/// Whether this type is a variably-modified type (C99 6.7.5).
bool isVariablyModifiedType() const {
  return getDependence() & TypeDependence::VariablyModified;
}

/// Whether this type involves a variable-length array type
/// with a definite size.
bool hasSizedVLAType() const;

/// Whether this type is or contains a local or unnamed type.
bool hasUnnamedOrLocalType() const;

bool isOverloadableType() const;

/// Determine wither this type is a C++ elaborated-type-specifier.
bool isElaboratedTypeSpecifier() const;

bool canDecayToPointerType() const;

/// Whether this type is represented natively as a pointer.  This includes
/// pointers, references, block pointers, and Objective-C interface,
/// qualified id, and qualified interface types, as well as nullptr_t.
bool hasPointerRepresentation() const;

/// Whether this type can represent an objective pointer type for the
/// purpose of GC'ability
bool hasObjCPointerRepresentation() const;

/// Determine whether this type has an integer representation
/// of some sort, e.g., it is an integer type or a vector.
bool hasIntegerRepresentation() const;

/// Determine whether this type has an signed integer representation
/// of some sort, e.g., it is an signed integer type or a vector.
bool hasSignedIntegerRepresentation() const;

/// Determine whether this type has an unsigned integer representation
/// of some sort, e.g., it is an unsigned integer type or a vector.
bool hasUnsignedIntegerRepresentation() const;

/// Determine whether this type has a floating-point representation
/// of some sort, e.g., it is a floating-point type or a vector thereof.
bool hasFloatingRepresentation() const;

// Type Checking Functions: Check to see if this type is structurally the
// specified type, ignoring typedefs and qualifiers, and return a pointer to
// the best type we can.
const RecordType *getAsStructureType() const;
/// NOTE: getAs*ArrayType are methods on ASTContext.
const RecordType *getAsUnionType() const;
const ComplexType *getAsComplexIntegerType() const; // GCC complex int type.
const ObjCObjectType *getAsObjCInterfaceType() const;

// The following is a convenience method that returns an ObjCObjectPointerType
// for object declared using an interface.
const ObjCObjectPointerType *getAsObjCInterfacePointerType() const;
const ObjCObjectPointerType *getAsObjCQualifiedIdType() const;
const ObjCObjectPointerType *getAsObjCQualifiedClassType() const;
const ObjCObjectType *getAsObjCQualifiedInterfaceType() const;

/// Retrieves the CXXRecordDecl that this type refers to, either
/// because the type is a RecordType or because it is the injected-class-name
/// type of a class template or class template partial specialization.
CXXRecordDecl *getAsCXXRecordDecl() const;

/// Retrieves the RecordDecl this type refers to.
RecordDecl *getAsRecordDecl() const;

/// Retrieves the TagDecl that this type refers to, either
/// because the type is a TagType or because it is the injected-class-name
/// type of a class template or class template partial specialization.
TagDecl *getAsTagDecl() const;

/// If this is a pointer or reference to a RecordType, return the
/// CXXRecordDecl that the type refers to.
///
/// If this is not a pointer or reference, or the type being pointed to does
/// not refer to a CXXRecordDecl, returns NULL.
const CXXRecordDecl *getPointeeCXXRecordDecl() const;

/// Get the DeducedType whose type will be deduced for a variable with
/// an initializer of this type. This looks through declarators like pointer
/// types, but not through decltype or typedefs.
DeducedType *getContainedDeducedType() const;

/// Get the AutoType whose type will be deduced for a variable with
/// an initializer of this type. This looks through declarators like pointer
/// types, but not through decltype or typedefs.
AutoType *getContainedAutoType() const {
  return dyn_cast_or_null<AutoType>(getContainedDeducedType());
}

/// Determine whether this type was written with a leading 'auto'
/// corresponding to a trailing return type (possibly for a nested
/// function type within a pointer to function type or similar).
bool hasAutoForTrailingReturnType() const;

/// Member-template getAs<specific type>'.  Look through sugar for
/// an instance of \<specific type>.   This scheme will eventually
/// replace the specific getAsXXXX methods above.
///
/// There are some specializations of this member template listed
/// immediately following this class.
template <typename T> const T *getAs() const;

/// Member-template getAsAdjusted<specific type>. Look through specific kinds
/// of sugar (parens, attributes, etc) for an instance of \<specific type>.
/// This is used when you need to walk over sugar nodes that represent some
/// kind of type adjustment from a type that was written as a \<specific type>
/// to another type that is still canonically a \<specific type>.
template <typename T> const T *getAsAdjusted() const;

/// A variant of getAs<> for array types which silently discards
/// qualifiers from the outermost type.
const ArrayType *getAsArrayTypeUnsafe() const;

/// Member-template castAs<specific type>.  Look through sugar for
/// the underlying instance of \<specific type>.
///
/// This method has the same relationship to getAs<T> as cast<T> has
/// to dyn_cast<T>; which is to say, the underlying type *must*
/// have the intended type, and this method will never return null.
template <typename T> const T *castAs() const;

/// A variant of castAs<> for array type which silently discards
/// qualifiers from the outermost type.
const ArrayType *castAsArrayTypeUnsafe() const;

/// Determine whether this type had the specified attribute applied to it
/// (looking through top-level type sugar).
bool hasAttr(attr::Kind AK) const;

/// Get the base element type of this type, potentially discarding type
/// qualifiers.  This should never be used when type qualifiers
/// are meaningful.
const Type *getBaseElementTypeUnsafe() const;

/// If this is an array type, return the element type of the array,
/// potentially with type qualifiers missing.
/// This should never be used when type qualifiers are meaningful.
const Type *getArrayElementTypeNoTypeQual() const;

/// If this is a pointer type, return the pointee type.
/// If this is an array type, return the array element type.
/// This should never be used when type qualifiers are meaningful.
const Type *getPointeeOrArrayElementType() const;

/// If this is a pointer, ObjC object pointer, or block
/// pointer, this returns the respective pointee.
QualType getPointeeType() const;

/// Return the specified type with any "sugar" removed from the type,
/// removing any typedefs, typeofs, etc., as well as any qualifiers.
const Type *getUnqualifiedDesugaredType() const;

/// More type predicates useful for type checking/promotion
bool isPromotableIntegerType() const; // C99 6.3.1.1p2

/// Return true if this is an integer type that is
/// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
/// or an enum decl which has a signed representation.
bool isSignedIntegerType() const;

/// Return true if this is an integer type that is
/// unsigned, according to C99 6.2.5p6 [which returns true for _Bool],
/// or an enum decl which has an unsigned representation.
bool isUnsignedIntegerType() const;

/// Determines whether this is an integer type that is signed or an
/// enumeration types whose underlying type is a signed integer type.
bool isSignedIntegerOrEnumerationType() const;

/// Determines whether this is an integer type that is unsigned or an
/// enumeration types whose underlying type is a unsigned integer type.
bool isUnsignedIntegerOrEnumerationType() const;

/// Return true if this is a fixed point type according to
/// ISO/IEC JTC1 SC22 WG14 N1169.
bool isFixedPointType() const;

/// Return true if this is a fixed point or integer type.
bool isFixedPointOrIntegerType() const;

/// Return true if this is a saturated fixed point type according to
/// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
bool isSaturatedFixedPointType() const;

/// Return true if this is a saturated fixed point type according to
/// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
bool isUnsaturatedFixedPointType() const;

/// Return true if this is a fixed point type that is signed according
/// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
bool isSignedFixedPointType() const;

/// Return true if this is a fixed point type that is unsigned according
/// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
bool isUnsignedFixedPointType() const;

/// Return true if this is not a variable sized type,
/// according to the rules of C99 6.7.5p3.  It is not legal to call this on
/// incomplete types.
bool isConstantSizeType() const;

/// Returns true if this type can be represented by some
/// set of type specifiers.
bool isSpecifierType() const;

/// Determine the linkage of this type.
Linkage getLinkage() const;

/// Determine the visibility of this type.
Visibility getVisibility() const {
  return getLinkageAndVisibility().getVisibility();
}

/// Return true if the visibility was explicitly set is the code.
bool isVisibilityExplicit() const {
  return getLinkageAndVisibility().isVisibilityExplicit();
}

/// Determine the linkage and visibility of this type.
LinkageInfo getLinkageAndVisibility() const;

/// True if the computed linkage is valid. Used for consistency
/// checking. Should always return true.
bool isLinkageValid() const;

/// Determine the nullability of the given type.
///
/// Note that nullability is only captured as sugar within the type
/// system, not as part of the canonical type, so nullability will
/// be lost by canonicalization and desugaring.
Optional<NullabilityKind> getNullability(const ASTContext &context) const;

/// Determine whether the given type can have a nullability
/// specifier applied to it, i.e., if it is any kind of pointer type.
///
/// \param ResultIfUnknown The value to return if we don't yet know whether
///        this type can have nullability because it is dependent.
bool canHaveNullability(bool ResultIfUnknown = true) const;

/// Retrieve the set of substitutions required when accessing a member
/// of the Objective-C receiver type that is declared in the given context.
///
/// \c *this is the type of the object we're operating on, e.g., the
/// receiver for a message send or the base of a property access, and is
/// expected to be of some object or object pointer type.
///
/// \param dc The declaration context for which we are building up a
/// substitution mapping, which should be an Objective-C class, extension,
/// category, or method within.
///
/// \returns an array of type arguments that can be substituted for
/// the type parameters of the given declaration context in any type described
/// within that context, or an empty optional to indicate that no
/// substitution is required.
Optional<ArrayRef<QualType>>
getObjCSubstitutions(const DeclContext *dc) const;

/// Determines if this is an ObjC interface type that may accept type
/// parameters.
bool acceptsObjCTypeParams() const;

const char *getTypeClassName() const;

QualType getCanonicalTypeInternal() const {
  return CanonicalType;
}

CanQualType getCanonicalTypeUnqualified() const; // in CanonicalType.h
void dump() const;
void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;
2458};

2460/// This will check for a TypedefType by removing any existing sugar
2461/// until it reaches a TypedefType or a non-sugared type.
2462template <> const TypedefType *Type::getAs() const;

2464/// This will check for a TemplateSpecializationType by removing any
2465/// existing sugar until it reaches a TemplateSpecializationType or a
2466/// non-sugared type.
2467template <> const TemplateSpecializationType *Type::getAs() const;

2469/// This will check for an AttributedType by removing any existing sugar
2470/// until it reaches an AttributedType or a non-sugared type.
2471template <> const AttributedType *Type::getAs() const;

2473// We can do canonical leaf types faster, because we don't have to
2474// worry about preserving child type decoration.
2475#define TYPE(Class, Base)
2476#define LEAF_TYPE(Class) \
2477template <> inline const Class##Type *Type::getAs() const { \
return dyn_cast<Class##Type>(CanonicalType); \
2479} \
2480template <> inline const Class##Type *Type::castAs() const { \
return cast<Class##Type>(CanonicalType); \
2482}
2483#include "clang/AST/TypeNodes.inc"

2485/// This class is used for builtin types like 'int'.  Builtin
2486/// types are always canonical and have a literal name field.
2487class BuiltinType : public Type {
2488public:
enum Kind {
2490// OpenCL image types
2491#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
2492#include "clang/Basic/OpenCLImageTypes.def"
2493// OpenCL extension types
2494#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
2495#include "clang/Basic/OpenCLExtensionTypes.def"
2496// SVE Types
2497#define SVE_TYPE(Name, Id, SingletonId) Id,
2498#include "clang/Basic/AArch64SVEACLETypes.def"
2499// PPC MMA Types
2500#define PPC_VECTOR_TYPE(Name, Id, Size) Id,
2501#include "clang/Basic/PPCTypes.def"
2502// RVV Types
2503#define RVV_TYPE(Name, Id, SingletonId) Id,
2504#include "clang/Basic/RISCVVTypes.def"
2505// All other builtin types
2506#define BUILTIN_TYPE(Id, SingletonId) Id,
2507#define LAST_BUILTIN_TYPE(Id) LastKind = Id
2508#include "clang/AST/BuiltinTypes.def"
};

2511private:
friend class ASTContext; // ASTContext creates these.

BuiltinType(Kind K)
    : Type(Builtin, QualType(),
           K == Dependent ? TypeDependence::DependentInstantiation
                          : TypeDependence::None) {
  BuiltinTypeBits.Kind = K;
}

2521public:
Kind getKind() const { return static_cast<Kind>(BuiltinTypeBits.Kind); }
StringRef getName(const PrintingPolicy &Policy) const;

const char *getNameAsCString(const PrintingPolicy &Policy) const {
  // The StringRef is null-terminated.
  StringRef str = getName(Policy);
  assert(!str.empty() && str.data()[str.size()] == '\0')((void)0);
  return str.data();
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

bool isInteger() const {
  return getKind() >= Bool && getKind() <= Int128;
}

bool isSignedInteger() const {
  return getKind() >= Char_S && getKind() <= Int128;
}

bool isUnsignedInteger() const {
  return getKind() >= Bool && getKind() <= UInt128;
}

bool isFloatingPoint() const {
  return getKind() >= Half && getKind() <= Float128;
}

/// Determines whether the given kind corresponds to a placeholder type.
static bool isPlaceholderTypeKind(Kind K) {
  return K >= Overload;
}

/// Determines whether this type is a placeholder type, i.e. a type
/// which cannot appear in arbitrary positions in a fully-formed
/// expression.
bool isPlaceholderType() const {
  return isPlaceholderTypeKind(getKind());
}

/// Determines whether this type is a placeholder type other than
/// Overload.  Most placeholder types require only syntactic
/// information about their context in order to be resolved (e.g.
/// whether it is a call expression), which means they can (and
/// should) be resolved in an earlier "phase" of analysis.
/// Overload expressions sometimes pick up further information
/// from their context, like whether the context expects a
/// specific function-pointer type, and so frequently need
/// special treatment.
bool isNonOverloadPlaceholderType() const {
  return getKind() > Overload;
}

static bool classof(const Type *T) { return T->getTypeClass() == Builtin; }
2577};

2579/// Complex values, per C99 6.2.5p11.  This supports the C99 complex
2580/// types (_Complex float etc) as well as the GCC integer complex extensions.
2581class ComplexType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ElementType;

ComplexType(QualType Element, QualType CanonicalPtr)
    : Type(Complex, CanonicalPtr, Element->getDependence()),
      ElementType(Element) {}

2590public:
QualType getElementType() const { return ElementType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Element) {
  ID.AddPointer(Element.getAsOpaquePtr());
}

static bool classof(const Type *T) { return T->getTypeClass() == Complex; }
2605};

2607/// Sugar for parentheses used when specifying types.
2608class ParenType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType Inner;

ParenType(QualType InnerType, QualType CanonType)
    : Type(Paren, CanonType, InnerType->getDependence()), Inner(InnerType) {}

2616public:
QualType getInnerType() const { return Inner; }

bool isSugared() const { return true; }
QualType desugar() const { return getInnerType(); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getInnerType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Inner) {
  Inner.Profile(ID);
}

static bool classof(const Type *T) { return T->getTypeClass() == Paren; }
2631};

2633/// PointerType - C99 6.7.5.1 - Pointer Declarators.
2634class PointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

PointerType(QualType Pointee, QualType CanonicalPtr)
    : Type(Pointer, CanonicalPtr, Pointee->getDependence()),
      PointeeType(Pointee) {}

2643public:
QualType getPointeeType() const { return PointeeType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPointeeType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
  ID.AddPointer(Pointee.getAsOpaquePtr());
}

static bool classof(const Type *T) { return T->getTypeClass() == Pointer; }
2658};

2660/// Represents a type which was implicitly adjusted by the semantic
2661/// engine for arbitrary reasons.  For example, array and function types can
2662/// decay, and function types can have their calling conventions adjusted.
2663class AdjustedType : public Type, public llvm::FoldingSetNode {
QualType OriginalTy;
QualType AdjustedTy;

2667protected:
friend class ASTContext; // ASTContext creates these.

AdjustedType(TypeClass TC, QualType OriginalTy, QualType AdjustedTy,
             QualType CanonicalPtr)
    : Type(TC, CanonicalPtr, OriginalTy->getDependence()),
      OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}

2675public:
QualType getOriginalType() const { return OriginalTy; }
QualType getAdjustedType() const { return AdjustedTy; }

bool isSugared() const { return true; }
QualType desugar() const { return AdjustedTy; }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, OriginalTy, AdjustedTy);
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Orig, QualType New) {
  ID.AddPointer(Orig.getAsOpaquePtr());
  ID.AddPointer(New.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Adjusted || T->getTypeClass() == Decayed;
}
2694};

2696/// Represents a pointer type decayed from an array or function type.
2697class DecayedType : public AdjustedType {
friend class ASTContext; // ASTContext creates these.

inline
DecayedType(QualType OriginalType, QualType Decayed, QualType Canonical);

2703public:
QualType getDecayedType() const { return getAdjustedType(); }

inline QualType getPointeeType() const;

static bool classof(const Type *T) { return T->getTypeClass() == Decayed; }
2709};

2711/// Pointer to a block type.
2712/// This type is to represent types syntactically represented as
2713/// "void (^)(int)", etc. Pointee is required to always be a function type.
2714class BlockPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

// Block is some kind of pointer type
QualType PointeeType;

BlockPointerType(QualType Pointee, QualType CanonicalCls)
    : Type(BlockPointer, CanonicalCls, Pointee->getDependence()),
      PointeeType(Pointee) {}

2724public:
// Get the pointee type. Pointee is required to always be a function type.
QualType getPointeeType() const { return PointeeType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
    Profile(ID, getPointeeType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
    ID.AddPointer(Pointee.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == BlockPointer;
}
2742};

2744/// Base for LValueReferenceType and RValueReferenceType
2745class ReferenceType : public Type, public llvm::FoldingSetNode {
QualType PointeeType;

2748protected:
ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef,
              bool SpelledAsLValue)
    : Type(tc, CanonicalRef, Referencee->getDependence()),
      PointeeType(Referencee) {
  ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
  ReferenceTypeBits.InnerRef = Referencee->isReferenceType();
}

2757public:
bool isSpelledAsLValue() const { return ReferenceTypeBits.SpelledAsLValue; }
bool isInnerRef() const { return ReferenceTypeBits.InnerRef; }

QualType getPointeeTypeAsWritten() const { return PointeeType; }

QualType getPointeeType() const {
  // FIXME: this might strip inner qualifiers; okay?
  const ReferenceType *T = this;
  while (T->isInnerRef())
    T = T->PointeeType->castAs<ReferenceType>();
  return T->PointeeType;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, PointeeType, isSpelledAsLValue());
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    QualType Referencee,
                    bool SpelledAsLValue) {
  ID.AddPointer(Referencee.getAsOpaquePtr());
  ID.AddBoolean(SpelledAsLValue);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == LValueReference ||
         T->getTypeClass() == RValueReference;
}
2786};

2788/// An lvalue reference type, per C++11 [dcl.ref].
2789class LValueReferenceType : public ReferenceType {
friend class ASTContext; // ASTContext creates these

LValueReferenceType(QualType Referencee, QualType CanonicalRef,
                    bool SpelledAsLValue)
    : ReferenceType(LValueReference, Referencee, CanonicalRef,
                    SpelledAsLValue) {}

2797public:
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == LValueReference;
}
2804};

2806/// An rvalue reference type, per C++11 [dcl.ref].
2807class RValueReferenceType : public ReferenceType {
friend class ASTContext; // ASTContext creates these

RValueReferenceType(QualType Referencee, QualType CanonicalRef)
     : ReferenceType(RValueReference, Referencee, CanonicalRef, false) {}

2813public:
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == RValueReference;
}
2820};

2822/// A pointer to member type per C++ 8.3.3 - Pointers to members.
2823///
2824/// This includes both pointers to data members and pointer to member functions.
2825class MemberPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

/// The class of which the pointee is a member. Must ultimately be a
/// RecordType, but could be a typedef or a template parameter too.
const Type *Class;

MemberPointerType(QualType Pointee, const Type *Cls, QualType CanonicalPtr)
    : Type(MemberPointer, CanonicalPtr,
           (Cls->getDependence() & ~TypeDependence::VariablyModified) |
               Pointee->getDependence()),
      PointeeType(Pointee), Class(Cls) {}

2840public:
QualType getPointeeType() const { return PointeeType; }

/// Returns true if the member type (i.e. the pointee type) is a
/// function type rather than a data-member type.
bool isMemberFunctionPointer() const {
  return PointeeType->isFunctionProtoType();
}

/// Returns true if the member type (i.e. the pointee type) is a
/// data type rather than a function type.
bool isMemberDataPointer() const {
  return !PointeeType->isFunctionProtoType();
}

const Type *getClass() const { return Class; }
CXXRecordDecl *getMostRecentCXXRecordDecl() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPointeeType(), getClass());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee,
                    const Type *Class) {
  ID.AddPointer(Pointee.getAsOpaquePtr());
  ID.AddPointer(Class);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == MemberPointer;
}
2874};

2876/// Represents an array type, per C99 6.7.5.2 - Array Declarators.
2877class ArrayType : public Type, public llvm::FoldingSetNode {
2878public:
/// Capture whether this is a normal array (e.g. int X[4])
/// an array with a static size (e.g. int X[static 4]), or an array
/// with a star size (e.g. int X[*]).
/// 'static' is only allowed on function parameters.
enum ArraySizeModifier {
  Normal, Static, Star
};

2887private:
/// The element type of the array.
QualType ElementType;

2891protected:
friend class ASTContext; // ASTContext creates these.

ArrayType(TypeClass tc, QualType et, QualType can, ArraySizeModifier sm,
          unsigned tq, const Expr *sz = nullptr);

2897public:
QualType getElementType() const { return ElementType; }

ArraySizeModifier getSizeModifier() const {
  return ArraySizeModifier(ArrayTypeBits.SizeModifier);
}

Qualifiers getIndexTypeQualifiers() const {
  return Qualifiers::fromCVRMask(getIndexTypeCVRQualifiers());
}

unsigned getIndexTypeCVRQualifiers() const {
  return ArrayTypeBits.IndexTypeQuals;
}

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantArray ||
         T->getTypeClass() == VariableArray ||
         T->getTypeClass() == IncompleteArray ||
         T->getTypeClass() == DependentSizedArray;
}
2918};

2920/// Represents the canonical version of C arrays with a specified constant size.
2921/// For example, the canonical type for 'int A[4 + 4*100]' is a
2922/// ConstantArrayType where the element type is 'int' and the size is 404.
2923class ConstantArrayType final
  : public ArrayType,
    private llvm::TrailingObjects<ConstantArrayType, const Expr *> {
friend class ASTContext; // ASTContext creates these.
friend TrailingObjects;

llvm::APInt Size; // Allows us to unique the type.

ConstantArrayType(QualType et, QualType can, const llvm::APInt &size,
                  const Expr *sz, ArraySizeModifier sm, unsigned tq)
    : ArrayType(ConstantArray, et, can, sm, tq, sz), Size(size) {
  ConstantArrayTypeBits.HasStoredSizeExpr = sz != nullptr;
  if (ConstantArrayTypeBits.HasStoredSizeExpr) {
    assert(!can.isNull() && "canonical constant array should not have size")((void)0);
    *getTrailingObjects<const Expr*>() = sz;
  }
}

unsigned numTrailingObjects(OverloadToken<const Expr*>) const {
  return ConstantArrayTypeBits.HasStoredSizeExpr;
}

2945public:
const llvm::APInt &getSize() const { return Size; }
const Expr *getSizeExpr() const {
  return ConstantArrayTypeBits.HasStoredSizeExpr
             ? *getTrailingObjects<const Expr *>()
             : nullptr;
}
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

/// Determine the number of bits required to address a member of
// an array with the given element type and number of elements.
static unsigned getNumAddressingBits(const ASTContext &Context,
                                     QualType ElementType,
                                     const llvm::APInt &NumElements);

/// Determine the maximum number of active bits that an array's size
/// can require, which limits the maximum size of the array.
static unsigned getMaxSizeBits(const ASTContext &Context);

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
  Profile(ID, Ctx, getElementType(), getSize(), getSizeExpr(),
          getSizeModifier(), getIndexTypeCVRQualifiers());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx,
                    QualType ET, const llvm::APInt &ArraySize,
                    const Expr *SizeExpr, ArraySizeModifier SizeMod,
                    unsigned TypeQuals);

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantArray;
}
2978};

2980/// Represents a C array with an unspecified size.  For example 'int A[]' has
2981/// an IncompleteArrayType where the element type is 'int' and the size is
2982/// unspecified.
2983class IncompleteArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

IncompleteArrayType(QualType et, QualType can,
                    ArraySizeModifier sm, unsigned tq)
    : ArrayType(IncompleteArray, et, can, sm, tq) {}

2990public:
friend class StmtIteratorBase;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == IncompleteArray;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), getSizeModifier(),
          getIndexTypeCVRQualifiers());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ET,
                    ArraySizeModifier SizeMod, unsigned TypeQuals) {
  ID.AddPointer(ET.getAsOpaquePtr());
  ID.AddInteger(SizeMod);
  ID.AddInteger(TypeQuals);
}
3011};

3013/// Represents a C array with a specified size that is not an
3014/// integer-constant-expression.  For example, 'int s[x+foo()]'.
3015/// Since the size expression is an arbitrary expression, we store it as such.
3016///
3017/// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and
3018/// should not be: two lexically equivalent variable array types could mean
3019/// different things, for example, these variables do not have the same type
3020/// dynamically:
3021///
3022/// void foo(int x) {
3023///   int Y[x];
3024///   ++x;
3025///   int Z[x];
3026/// }
3027class VariableArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

/// An assignment-expression. VLA's are only permitted within
/// a function block.
Stmt *SizeExpr;

/// The range spanned by the left and right array brackets.
SourceRange Brackets;

VariableArrayType(QualType et, QualType can, Expr *e,
                  ArraySizeModifier sm, unsigned tq,
                  SourceRange brackets)
    : ArrayType(VariableArray, et, can, sm, tq, e),
      SizeExpr((Stmt*) e), Brackets(brackets) {}

3043public:
friend class StmtIteratorBase;

Expr *getSizeExpr() const {
  // We use C-style casts instead of cast<> here because we do not wish
  // to have a dependency of Type.h on Stmt.h/Expr.h.
  return (Expr*) SizeExpr;
}

SourceRange getBracketsRange() const { return Brackets; }
SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == VariableArray;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  llvm_unreachable("Cannot unique VariableArrayTypes.")__builtin_unreachable();
}
3066};

3068/// Represents an array type in C++ whose size is a value-dependent expression.
3069///
3070/// For example:
3071/// \code
3072/// template<typename T, int Size>
3073/// class array {
3074///   T data[Size];
3075/// };
3076/// \endcode
3077///
3078/// For these types, we won't actually know what the array bound is
3079/// until template instantiation occurs, at which point this will
3080/// become either a ConstantArrayType or a VariableArrayType.
3081class DependentSizedArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

const ASTContext &Context;

/// An assignment expression that will instantiate to the
/// size of the array.
///
/// The expression itself might be null, in which case the array
/// type will have its size deduced from an initializer.
Stmt *SizeExpr;

/// The range spanned by the left and right array brackets.
SourceRange Brackets;

DependentSizedArrayType(const ASTContext &Context, QualType et, QualType can,
                        Expr *e, ArraySizeModifier sm, unsigned tq,
                        SourceRange brackets);

3100public:
friend class StmtIteratorBase;

Expr *getSizeExpr() const {
  // We use C-style casts instead of cast<> here because we do not wish
  // to have a dependency of Type.h on Stmt.h/Expr.h.
  return (Expr*) SizeExpr;
}

SourceRange getBracketsRange() const { return Brackets; }
SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentSizedArray;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(),
          getSizeModifier(), getIndexTypeCVRQualifiers(), getSizeExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ET, ArraySizeModifier SizeMod,
                    unsigned TypeQuals, Expr *E);
3128};

3130/// Represents an extended address space qualifier where the input address space
3131/// value is dependent. Non-dependent address spaces are not represented with a
3132/// special Type subclass; they are stored on an ExtQuals node as part of a QualType.
3133///
3134/// For example:
3135/// \code
3136/// template<typename T, int AddrSpace>
3137/// class AddressSpace {
3138///   typedef T __attribute__((address_space(AddrSpace))) type;
3139/// }
3140/// \endcode
3141class DependentAddressSpaceType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

const ASTContext &Context;
Expr *AddrSpaceExpr;
QualType PointeeType;
SourceLocation loc;

DependentAddressSpaceType(const ASTContext &Context, QualType PointeeType,
                          QualType can, Expr *AddrSpaceExpr,
                          SourceLocation loc);

3153public:
Expr *getAddrSpaceExpr() const { return AddrSpaceExpr; }
QualType getPointeeType() const { return PointeeType; }
SourceLocation getAttributeLoc() const { return loc; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentAddressSpace;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getPointeeType(), getAddrSpaceExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType PointeeType, Expr *AddrSpaceExpr);
3171};

3173/// Represents an extended vector type where either the type or size is
3174/// dependent.
3175///
3176/// For example:
3177/// \code
3178/// template<typename T, int Size>
3179/// class vector {
3180///   typedef T __attribute__((ext_vector_type(Size))) type;
3181/// }
3182/// \endcode
3183class DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

const ASTContext &Context;
Expr *SizeExpr;

/// The element type of the array.
QualType ElementType;

SourceLocation loc;

DependentSizedExtVectorType(const ASTContext &Context, QualType ElementType,
                            QualType can, Expr *SizeExpr, SourceLocation loc);

3197public:
Expr *getSizeExpr() const { return SizeExpr; }
QualType getElementType() const { return ElementType; }
SourceLocation getAttributeLoc() const { return loc; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentSizedExtVector;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(), getSizeExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ElementType, Expr *SizeExpr);
3215};


3218/// Represents a GCC generic vector type. This type is created using
3219/// __attribute__((vector_size(n)), where "n" specifies the vector size in
3220/// bytes; or from an Altivec __vector or vector declaration.
3221/// Since the constructor takes the number of vector elements, the
3222/// client is responsible for converting the size into the number of elements.
3223class VectorType : public Type, public llvm::FoldingSetNode {
3224public:
enum VectorKind {
  /// not a target-specific vector type
  GenericVector,

  /// is AltiVec vector
  AltiVecVector,

  /// is AltiVec 'vector Pixel'
  AltiVecPixel,

  /// is AltiVec 'vector bool ...'
  AltiVecBool,

  /// is ARM Neon vector
  NeonVector,

  /// is ARM Neon polynomial vector
  NeonPolyVector,

  /// is AArch64 SVE fixed-length data vector
  SveFixedLengthDataVector,

  /// is AArch64 SVE fixed-length predicate vector
  SveFixedLengthPredicateVector
};

3251protected:
friend class ASTContext; // ASTContext creates these.

/// The element type of the vector.
QualType ElementType;

VectorType(QualType vecType, unsigned nElements, QualType canonType,
           VectorKind vecKind);

VectorType(TypeClass tc, QualType vecType, unsigned nElements,
           QualType canonType, VectorKind vecKind);

3263public:
QualType getElementType() const { return ElementType; }
unsigned getNumElements() const { return VectorTypeBits.NumElements; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

VectorKind getVectorKind() const {
  return VectorKind(VectorTypeBits.VecKind);
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), getNumElements(),
          getTypeClass(), getVectorKind());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
                    unsigned NumElements, TypeClass TypeClass,
                    VectorKind VecKind) {
  ID.AddPointer(ElementType.getAsOpaquePtr());
  ID.AddInteger(NumElements);
  ID.AddInteger(TypeClass);
  ID.AddInteger(VecKind);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Vector || T->getTypeClass() == ExtVector;
}
3291};

3293/// Represents a vector type where either the type or size is dependent.
3294////
3295/// For example:
3296/// \code
3297/// template<typename T, int Size>
3298/// class vector {
3299///   typedef T __attribute__((vector_size(Size))) type;
3300/// }
3301/// \endcode
3302class DependentVectorType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

const ASTContext &Context;
QualType ElementType;
Expr *SizeExpr;
SourceLocation Loc;

DependentVectorType(const ASTContext &Context, QualType ElementType,
                         QualType CanonType, Expr *SizeExpr,
                         SourceLocation Loc, VectorType::VectorKind vecKind);

3314public:
Expr *getSizeExpr() const { return SizeExpr; }
QualType getElementType() const { return ElementType; }
SourceLocation getAttributeLoc() const { return Loc; }
VectorType::VectorKind getVectorKind() const {
  return VectorType::VectorKind(VectorTypeBits.VecKind);
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentVector;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(), getSizeExpr(), getVectorKind());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ElementType, const Expr *SizeExpr,
                    VectorType::VectorKind VecKind);
3336};

3338/// ExtVectorType - Extended vector type. This type is created using
3339/// __attribute__((ext_vector_type(n)), where "n" is the number of elements.
3340/// Unlike vector_size, ext_vector_type is only allowed on typedef's. This
3341/// class enables syntactic extensions, like Vector Components for accessing
3342/// points (as .xyzw), colors (as .rgba), and textures (modeled after OpenGL
3343/// Shading Language).
3344class ExtVectorType : public VectorType {
friend class ASTContext; // ASTContext creates these.

ExtVectorType(QualType vecType, unsigned nElements, QualType canonType)
    : VectorType(ExtVector, vecType, nElements, canonType, GenericVector) {}

3350public:
static int getPointAccessorIdx(char c) {
  switch (c) {
  default: return -1;
  case 'x': case 'r': return 0;
  case 'y': case 'g': return 1;
  case 'z': case 'b': return 2;
  case 'w': case 'a': return 3;
  }
}

static int getNumericAccessorIdx(char c) {
  switch (c) {
    default: return -1;
    case '0': return 0;
    case '1': return 1;
    case '2': return 2;
    case '3': return 3;
    case '4': return 4;
    case '5': return 5;
    case '6': return 6;
    case '7': return 7;
    case '8': return 8;
    case '9': return 9;
    case 'A':
    case 'a': return 10;
    case 'B':
    case 'b': return 11;
    case 'C':
    case 'c': return 12;
    case 'D':
    case 'd': return 13;
    case 'E':
    case 'e': return 14;
    case 'F':
    case 'f': return 15;
  }
}

static int getAccessorIdx(char c, bool isNumericAccessor) {
  if (isNumericAccessor)
    return getNumericAccessorIdx(c);
  else
    return getPointAccessorIdx(c);
}

bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const {
  if (int idx = getAccessorIdx(c, isNumericAccessor)+1)
    return unsigned(idx-1) < getNumElements();
  return false;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ExtVector;
}
3408};

3410/// Represents a matrix type, as defined in the Matrix Types clang extensions.
3411/// __attribute__((matrix_type(rows, columns))), where "rows" specifies
3412/// number of rows and "columns" specifies the number of columns.
3413class MatrixType : public Type, public llvm::FoldingSetNode {
3414protected:
friend class ASTContext;

/// The element type of the matrix.
QualType ElementType;

MatrixType(QualType ElementTy, QualType CanonElementTy);

MatrixType(TypeClass TypeClass, QualType ElementTy, QualType CanonElementTy,
           const Expr *RowExpr = nullptr, const Expr *ColumnExpr = nullptr);

3425public:
/// Returns type of the elements being stored in the matrix
QualType getElementType() const { return ElementType; }

/// Valid elements types are the following:
/// * an integer type (as in C2x 6.2.5p19), but excluding enumerated types
///   and _Bool
/// * the standard floating types float or double
/// * a half-precision floating point type, if one is supported on the target
static bool isValidElementType(QualType T) {
  return T->isDependentType() ||
         (T->isRealType() && !T->isBooleanType() && !T->isEnumeralType());
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantMatrix ||
         T->getTypeClass() == DependentSizedMatrix;
}
3446};

3448/// Represents a concrete matrix type with constant number of rows and columns
3449class ConstantMatrixType final : public MatrixType {
3450protected:
friend class ASTContext;

/// The element type of the matrix.
// FIXME: Appears to be unused? There is also MatrixType::ElementType...
QualType ElementType;

/// Number of rows and columns.
unsigned NumRows;
unsigned NumColumns;

static constexpr unsigned MaxElementsPerDimension = (1 << 20) - 1;

ConstantMatrixType(QualType MatrixElementType, unsigned NRows,
                   unsigned NColumns, QualType CanonElementType);

ConstantMatrixType(TypeClass typeClass, QualType MatrixType, unsigned NRows,
                   unsigned NColumns, QualType CanonElementType);

3469public:
/// Returns the number of rows in the matrix.
unsigned getNumRows() const { return NumRows; }

/// Returns the number of columns in the matrix.
unsigned getNumColumns() const { return NumColumns; }

/// Returns the number of elements required to embed the matrix into a vector.
unsigned getNumElementsFlattened() const {
  return getNumRows() * getNumColumns();
}

/// Returns true if \p NumElements is a valid matrix dimension.
static constexpr bool isDimensionValid(size_t NumElements) {
  return NumElements > 0 && NumElements <= MaxElementsPerDimension;
}

/// Returns the maximum number of elements per dimension.
static constexpr unsigned getMaxElementsPerDimension() {
  return MaxElementsPerDimension;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), getNumRows(), getNumColumns(),
          getTypeClass());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
                    unsigned NumRows, unsigned NumColumns,
                    TypeClass TypeClass) {
  ID.AddPointer(ElementType.getAsOpaquePtr());
  ID.AddInteger(NumRows);
  ID.AddInteger(NumColumns);
  ID.AddInteger(TypeClass);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantMatrix;
}
3508};

3510/// Represents a matrix type where the type and the number of rows and columns
3511/// is dependent on a template.
3512class DependentSizedMatrixType final : public MatrixType {
friend class ASTContext;

const ASTContext &Context;
Expr *RowExpr;
Expr *ColumnExpr;

SourceLocation loc;

DependentSizedMatrixType(const ASTContext &Context, QualType ElementType,
                         QualType CanonicalType, Expr *RowExpr,
                         Expr *ColumnExpr, SourceLocation loc);

3525public:
QualType getElementType() const { return ElementType; }
Expr *getRowExpr() const { return RowExpr; }
Expr *getColumnExpr() const { return ColumnExpr; }
SourceLocation getAttributeLoc() const { return loc; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentSizedMatrix;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(), getRowExpr(), getColumnExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ElementType, Expr *RowExpr, Expr *ColumnExpr);
3544};

3546/// FunctionType - C99 6.7.5.3 - Function Declarators.  This is the common base
3547/// class of FunctionNoProtoType and FunctionProtoType.
3548class FunctionType : public Type {
// The type returned by the function.
QualType ResultType;

3552public:
/// Interesting information about a specific parameter that can't simply
/// be reflected in parameter's type. This is only used by FunctionProtoType
/// but is in FunctionType to make this class available during the
/// specification of the bases of FunctionProtoType.
///
/// It makes sense to model language features this way when there's some
/// sort of parameter-specific override (such as an attribute) that
/// affects how the function is called.  For example, the ARC ns_consumed
/// attribute changes whether a parameter is passed at +0 (the default)
/// or +1 (ns_consumed).  This must be reflected in the function type,
/// but isn't really a change to the parameter type.
///
/// One serious disadvantage of modelling language features this way is
/// that they generally do not work with language features that attempt
/// to destructure types.  For example, template argument deduction will
/// not be able to match a parameter declared as
///   T (*)(U)
/// against an argument of type
///   void (*)(__attribute__((ns_consumed)) id)
/// because the substitution of T=void, U=id into the former will
/// not produce the latter.
class ExtParameterInfo {
  enum {
    ABIMask = 0x0F,
    IsConsumed = 0x10,
    HasPassObjSize = 0x20,
    IsNoEscape = 0x40,
  };
  unsigned char Data = 0;

public:
  ExtParameterInfo() = default;

  /// Return the ABI treatment of this parameter.
  ParameterABI getABI() const { return ParameterABI(Data & ABIMask); }
  ExtParameterInfo withABI(ParameterABI kind) const {
    ExtParameterInfo copy = *this;
    copy.Data = (copy.Data & ~ABIMask) | unsigned(kind);
    return copy;
  }

  /// Is this parameter considered "consumed" by Objective-C ARC?
  /// Consumed parameters must have retainable object type.
  bool isConsumed() const { return (Data & IsConsumed); }
  ExtParameterInfo withIsConsumed(bool consumed) const {
    ExtParameterInfo copy = *this;
    if (consumed)
      copy.Data |= IsConsumed;
    else
      copy.Data &= ~IsConsumed;
    return copy;
  }

  bool hasPassObjectSize() const { return Data & HasPassObjSize; }
  ExtParameterInfo withHasPassObjectSize() const {
    ExtParameterInfo Copy = *this;
    Copy.Data |= HasPassObjSize;
    return Copy;
  }

  bool isNoEscape() const { return Data & IsNoEscape; }
  ExtParameterInfo withIsNoEscape(bool NoEscape) const {
    ExtParameterInfo Copy = *this;
    if (NoEscape)
      Copy.Data |= IsNoEscape;
    else
      Copy.Data &= ~IsNoEscape;
    return Copy;
  }

  unsigned char getOpaqueValue() const { return Data; }
  static ExtParameterInfo getFromOpaqueValue(unsigned char data) {
    ExtParameterInfo result;
    result.Data = data;
    return result;
  }

  friend bool operator==(ExtParameterInfo lhs, ExtParameterInfo rhs) {
    return lhs.Data == rhs.Data;
  }

  friend bool operator!=(ExtParameterInfo lhs, ExtParameterInfo rhs) {
    return lhs.Data != rhs.Data;
  }
};

/// A class which abstracts out some details necessary for
/// making a call.
///
/// It is not actually used directly for storing this information in
/// a FunctionType, although FunctionType does currently use the
/// same bit-pattern.
///
// If you add a field (say Foo), other than the obvious places (both,
// constructors, compile failures), what you need to update is
// * Operator==
// * getFoo
// * withFoo
// * functionType. Add Foo, getFoo.
// * ASTContext::getFooType
// * ASTContext::mergeFunctionTypes
// * FunctionNoProtoType::Profile
// * FunctionProtoType::Profile
// * TypePrinter::PrintFunctionProto
// * AST read and write
// * Codegen
class ExtInfo {
  friend class FunctionType;

  // Feel free to rearrange or add bits, but if you go over 16, you'll need to
  // adjust the Bits field below, and if you add bits, you'll need to adjust
  // Type::FunctionTypeBitfields::ExtInfo as well.

  // |  CC  |noreturn|produces|nocallersavedregs|regparm|nocfcheck|cmsenscall|
  // |0 .. 4|   5    |    6   |       7         |8 .. 10|    11   |    12    |
  //
  // regparm is either 0 (no regparm attribute) or the regparm value+1.
  enum { CallConvMask = 0x1F };
  enum { NoReturnMask = 0x20 };
  enum { ProducesResultMask = 0x40 };
  enum { NoCallerSavedRegsMask = 0x80 };
  enum {
    RegParmMask =  0x700,
    RegParmOffset = 8
  };
  enum { NoCfCheckMask = 0x800 };
  enum { CmseNSCallMask = 0x1000 };
  uint16_t Bits = CC_C;

  ExtInfo(unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}

public:
  // Constructor with no defaults. Use this when you know that you
  // have all the elements (when reading an AST file for example).
  ExtInfo(bool noReturn, bool hasRegParm, unsigned regParm, CallingConv cc,
          bool producesResult, bool noCallerSavedRegs, bool NoCfCheck,
          bool cmseNSCall) {
    assert((!hasRegParm || regParm < 7) && "Invalid regparm value")((void)0);
    Bits = ((unsigned)cc) | (noReturn ? NoReturnMask : 0) |
           (producesResult ? ProducesResultMask : 0) |
           (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
           (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
           (NoCfCheck ? NoCfCheckMask : 0) |
           (cmseNSCall ? CmseNSCallMask : 0);
  }

  // Constructor with all defaults. Use when for example creating a
  // function known to use defaults.
  ExtInfo() = default;

  // Constructor with just the calling convention, which is an important part
  // of the canonical type.
  ExtInfo(CallingConv CC) : Bits(CC) {}

  bool getNoReturn() const { return Bits & NoReturnMask; }
  bool getProducesResult() const { return Bits & ProducesResultMask; }
  bool getCmseNSCall() const { return Bits & CmseNSCallMask; }
  bool getNoCallerSavedRegs() const { return Bits & NoCallerSavedRegsMask; }
  bool getNoCfCheck() const { return Bits & NoCfCheckMask; }
  bool getHasRegParm() const { return ((Bits & RegParmMask) >> RegParmOffset) != 0; }

  unsigned getRegParm() const {
    unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
    if (RegParm > 0)
      --RegParm;
    return RegParm;
  }

  CallingConv getCC() const { return CallingConv(Bits & CallConvMask); }

  bool operator==(ExtInfo Other) const {
    return Bits == Other.Bits;
  }
  bool operator!=(ExtInfo Other) const {
    return Bits != Other.Bits;
  }

  // Note that we don't have setters. That is by design, use
  // the following with methods instead of mutating these objects.

  ExtInfo withNoReturn(bool noReturn) const {
    if (noReturn)
      return ExtInfo(Bits | NoReturnMask);
    else
      return ExtInfo(Bits & ~NoReturnMask);
  }

  ExtInfo withProducesResult(bool producesResult) const {
    if (producesResult)
      return ExtInfo(Bits | ProducesResultMask);
    else
      return ExtInfo(Bits & ~ProducesResultMask);
  }

  ExtInfo withCmseNSCall(bool cmseNSCall) const {
    if (cmseNSCall)
      return ExtInfo(Bits | CmseNSCallMask);
    else
      return ExtInfo(Bits & ~CmseNSCallMask);
  }

  ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const {
    if (noCallerSavedRegs)
      return ExtInfo(Bits | NoCallerSavedRegsMask);
    else
      return ExtInfo(Bits & ~NoCallerSavedRegsMask);
  }

  ExtInfo withNoCfCheck(bool noCfCheck) const {
    if (noCfCheck)
      return ExtInfo(Bits | NoCfCheckMask);
    else
      return ExtInfo(Bits & ~NoCfCheckMask);
  }

  ExtInfo withRegParm(unsigned RegParm) const {
    assert(RegParm < 7 && "Invalid regparm value")((void)0);
    return ExtInfo((Bits & ~RegParmMask) |
                   ((RegParm + 1) << RegParmOffset));
  }

  ExtInfo withCallingConv(CallingConv cc) const {
    return ExtInfo((Bits & ~CallConvMask) | (unsigned) cc);
  }

  void Profile(llvm::FoldingSetNodeID &ID) const {
    ID.AddInteger(Bits);
  }
};

/// A simple holder for a QualType representing a type in an
/// exception specification. Unfortunately needed by FunctionProtoType
/// because TrailingObjects cannot handle repeated types.
struct ExceptionType { QualType Type; };

/// A simple holder for various uncommon bits which do not fit in
/// FunctionTypeBitfields. Aligned to alignof(void *) to maintain the
/// alignment of subsequent objects in TrailingObjects. You must update
/// hasExtraBitfields in FunctionProtoType after adding extra data here.
struct alignas(void *) FunctionTypeExtraBitfields {
  /// The number of types in the exception specification.
  /// A whole unsigned is not needed here and according to
  /// [implimits] 8 bits would be enough here.
  unsigned NumExceptionType;
};

3799protected:
FunctionType(TypeClass tc, QualType res, QualType Canonical,
             TypeDependence Dependence, ExtInfo Info)
    : Type(tc, Canonical, Dependence), ResultType(res) {
  FunctionTypeBits.ExtInfo = Info.Bits;
}

Qualifiers getFastTypeQuals() const {
  return Qualifiers::fromFastMask(FunctionTypeBits.FastTypeQuals);
}

3810public:
QualType getReturnType() const { return ResultType; }

bool getHasRegParm() const { return getExtInfo().getHasRegParm(); }
unsigned getRegParmType() const { return getExtInfo().getRegParm(); }

/// Determine whether this function type includes the GNU noreturn
/// attribute. The C++11 [[noreturn]] attribute does not affect the function
/// type.
bool getNoReturnAttr() const { return getExtInfo().getNoReturn(); }

bool getCmseNSCallAttr() const { return getExtInfo().getCmseNSCall(); }
CallingConv getCallConv() const { return getExtInfo().getCC(); }
ExtInfo getExtInfo() const { return ExtInfo(FunctionTypeBits.ExtInfo); }

static_assert((~Qualifiers::FastMask & Qualifiers::CVRMask) == 0,
              "Const, volatile and restrict are assumed to be a subset of "
              "the fast qualifiers.");

bool isConst() const { return getFastTypeQuals().hasConst(); }
bool isVolatile() const { return getFastTypeQuals().hasVolatile(); }
bool isRestrict() const { return getFastTypeQuals().hasRestrict(); }

/// Determine the type of an expression that calls a function of
/// this type.
QualType getCallResultType(const ASTContext &Context) const {
  return getReturnType().getNonLValueExprType(Context);
}

static StringRef getNameForCallConv(CallingConv CC);

static bool classof(const Type *T) {
  return T->getTypeClass() == FunctionNoProto ||
         T->getTypeClass() == FunctionProto;
}
3845};

3847/// Represents a K&R-style 'int foo()' function, which has
3848/// no information available about its arguments.
3849class FunctionNoProtoType : public FunctionType, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

FunctionNoProtoType(QualType Result, QualType Canonical, ExtInfo Info)
    : FunctionType(FunctionNoProto, Result, Canonical,
                   Result->getDependence() &
                       ~(TypeDependence::DependentInstantiation |
                         TypeDependence::UnexpandedPack),
                   Info) {}

3859public:
// No additional state past what FunctionType provides.

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getReturnType(), getExtInfo());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ResultType,
                    ExtInfo Info) {
  Info.Profile(ID);
  ID.AddPointer(ResultType.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == FunctionNoProto;
}
3878};

3880/// Represents a prototype with parameter type info, e.g.
3881/// 'int foo(int)' or 'int foo(void)'.  'void' is represented as having no
3882/// parameters, not as having a single void parameter. Such a type can have
3883/// an exception specification, but this specification is not part of the
3884/// canonical type. FunctionProtoType has several trailing objects, some of
3885/// which optional. For more information about the trailing objects see
3886/// the first comment inside FunctionProtoType.
3887class FunctionProtoType final
  : public FunctionType,
    public llvm::FoldingSetNode,
    private llvm::TrailingObjects<
        FunctionProtoType, QualType, SourceLocation,
        FunctionType::FunctionTypeExtraBitfields, FunctionType::ExceptionType,
        Expr *, FunctionDecl *, FunctionType::ExtParameterInfo, Qualifiers> {
friend class ASTContext; // ASTContext creates these.
friend TrailingObjects;

// FunctionProtoType is followed by several trailing objects, some of
// which optional. They are in order:
//
// * An array of getNumParams() QualType holding the parameter types.
//   Always present. Note that for the vast majority of FunctionProtoType,
//   these will be the only trailing objects.
//
// * Optionally if the function is variadic, the SourceLocation of the
//   ellipsis.
//
// * Optionally if some extra data is stored in FunctionTypeExtraBitfields
//   (see FunctionTypeExtraBitfields and FunctionTypeBitfields):
//   a single FunctionTypeExtraBitfields. Present if and only if
//   hasExtraBitfields() is true.
//
// * Optionally exactly one of:
//   * an array of getNumExceptions() ExceptionType,
//   * a single Expr *,
//   * a pair of FunctionDecl *,
//   * a single FunctionDecl *
//   used to store information about the various types of exception
//   specification. See getExceptionSpecSize for the details.
//
// * Optionally an array of getNumParams() ExtParameterInfo holding
//   an ExtParameterInfo for each of the parameters. Present if and
//   only if hasExtParameterInfos() is true.
//
// * Optionally a Qualifiers object to represent extra qualifiers that can't
//   be represented by FunctionTypeBitfields.FastTypeQuals. Present if and only
//   if hasExtQualifiers() is true.
//
// The optional FunctionTypeExtraBitfields has to be before the data
// related to the exception specification since it contains the number
// of exception types.
//
// We put the ExtParameterInfos last.  If all were equal, it would make
// more sense to put these before the exception specification, because
// it's much easier to skip past them compared to the elaborate switch
// required to skip the exception specification.  However, all is not
// equal; ExtParameterInfos are used to model very uncommon features,
// and it's better not to burden the more common paths.

3939public:
/// Holds information about the various types of exception specification.
/// ExceptionSpecInfo is not stored as such in FunctionProtoType but is
/// used to group together the various bits of information about the
/// exception specification.
struct ExceptionSpecInfo {
  /// The kind of exception specification this is.
  ExceptionSpecificationType Type = EST_None;

  /// Explicitly-specified list of exception types.
  ArrayRef<QualType> Exceptions;

  /// Noexcept expression, if this is a computed noexcept specification.
  Expr *NoexceptExpr = nullptr;

  /// The function whose exception specification this is, for
  /// EST_Unevaluated and EST_Uninstantiated.
  FunctionDecl *SourceDecl = nullptr;

  /// The function template whose exception specification this is instantiated
  /// from, for EST_Uninstantiated.
  FunctionDecl *SourceTemplate = nullptr;

  ExceptionSpecInfo() = default;

  ExceptionSpecInfo(ExceptionSpecificationType EST) : Type(EST) {}
};

/// Extra information about a function prototype. ExtProtoInfo is not
/// stored as such in FunctionProtoType but is used to group together
/// the various bits of extra information about a function prototype.
struct ExtProtoInfo {
  FunctionType::ExtInfo ExtInfo;
  bool Variadic : 1;
  bool HasTrailingReturn : 1;
  Qualifiers TypeQuals;
  RefQualifierKind RefQualifier = RQ_None;
  ExceptionSpecInfo ExceptionSpec;
  const ExtParameterInfo *ExtParameterInfos = nullptr;
  SourceLocation EllipsisLoc;

  ExtProtoInfo() : Variadic(false), HasTrailingReturn(false) {}

  ExtProtoInfo(CallingConv CC)
      : ExtInfo(CC), Variadic(false), HasTrailingReturn(false) {}

  ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI) {
    ExtProtoInfo Result(*this);
    Result.ExceptionSpec = ESI;
    return Result;
  }
};

3992private:
unsigned numTrailingObjects(OverloadToken<QualType>) const {
  return getNumParams();
}

unsigned numTrailingObjects(OverloadToken<SourceLocation>) const {
  return isVariadic();
}

unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>) const {
  return hasExtraBitfields();
}

unsigned numTrailingObjects(OverloadToken<ExceptionType>) const {
  return getExceptionSpecSize().NumExceptionType;
}

unsigned numTrailingObjects(OverloadToken<Expr *>) const {
  return getExceptionSpecSize().NumExprPtr;
}

unsigned numTrailingObjects(OverloadToken<FunctionDecl *>) const {
  return getExceptionSpecSize().NumFunctionDeclPtr;
}

unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>) const {
  return hasExtParameterInfos() ? getNumParams() : 0;
}

/// Determine whether there are any argument types that
/// contain an unexpanded parameter pack.
static bool containsAnyUnexpandedParameterPack(const QualType *ArgArray,
                                               unsigned numArgs) {
  for (unsigned Idx = 0; Idx < numArgs; ++Idx)
    if (ArgArray[Idx]->containsUnexpandedParameterPack())
      return true;

  return false;
}

FunctionProtoType(QualType result, ArrayRef<QualType> params,
                  QualType canonical, const ExtProtoInfo &epi);

/// This struct is returned by getExceptionSpecSize and is used to
/// translate an ExceptionSpecificationType to the number and kind
/// of trailing objects related to the exception specification.
struct ExceptionSpecSizeHolder {
  unsigned NumExceptionType;
  unsigned NumExprPtr;
  unsigned NumFunctionDeclPtr;
};

/// Return the number and kind of trailing objects
/// related to the exception specification.
static ExceptionSpecSizeHolder
getExceptionSpecSize(ExceptionSpecificationType EST, unsigned NumExceptions) {
  switch (EST) {
  case EST_None:
  case EST_DynamicNone:
  case EST_MSAny:
  case EST_BasicNoexcept:
  case EST_Unparsed:
  case EST_NoThrow:
    return {0, 0, 0};

  case EST_Dynamic:
    return {NumExceptions, 0, 0};

  case EST_DependentNoexcept:
  case EST_NoexceptFalse:
  case EST_NoexceptTrue:
    return {0, 1, 0};

  case EST_Uninstantiated:
    return {0, 0, 2};

  case EST_Unevaluated:
    return {0, 0, 1};
  }
  llvm_unreachable("bad exception specification kind")__builtin_unreachable();
}

/// Return the number and kind of trailing objects
/// related to the exception specification.
ExceptionSpecSizeHolder getExceptionSpecSize() const {
  return getExceptionSpecSize(getExceptionSpecType(), getNumExceptions());
}

/// Whether the trailing FunctionTypeExtraBitfields is present.
static bool hasExtraBitfields(ExceptionSpecificationType EST) {
  // If the exception spec type is EST_Dynamic then we have > 0 exception
  // types and the exact number is stored in FunctionTypeExtraBitfields.
  return EST == EST_Dynamic;
}

/// Whether the trailing FunctionTypeExtraBitfields is present.
bool hasExtraBitfields() const {
  return hasExtraBitfields(getExceptionSpecType());
}

bool hasExtQualifiers() const {
  return FunctionTypeBits.HasExtQuals;
}

4096public:
unsigned getNumParams() const { return FunctionTypeBits.NumParams; }

QualType getParamType(unsigned i) const {
  assert(i < getNumParams() && "invalid parameter index")((void)0);
  return param_type_begin()[i];
}

ArrayRef<QualType> getParamTypes() const {
  return llvm::makeArrayRef(param_type_begin(), param_type_end());
}

ExtProtoInfo getExtProtoInfo() const {
  ExtProtoInfo EPI;
  EPI.ExtInfo = getExtInfo();
  EPI.Variadic = isVariadic();
  EPI.EllipsisLoc = getEllipsisLoc();
  EPI.HasTrailingReturn = hasTrailingReturn();
  EPI.ExceptionSpec = getExceptionSpecInfo();
  EPI.TypeQuals = getMethodQuals();
  EPI.RefQualifier = getRefQualifier();
  EPI.ExtParameterInfos = getExtParameterInfosOrNull();
  return EPI;
}

/// Get the kind of exception specification on this function.
ExceptionSpecificationType getExceptionSpecType() const {
  return static_cast<ExceptionSpecificationType>(
      FunctionTypeBits.ExceptionSpecType);
}

/// Return whether this function has any kind of exception spec.
bool hasExceptionSpec() const { return getExceptionSpecType() != EST_None; }

/// Return whether this function has a dynamic (throw) exception spec.
bool hasDynamicExceptionSpec() const {
  return isDynamicExceptionSpec(getExceptionSpecType());
}

/// Return whether this function has a noexcept exception spec.
bool hasNoexceptExceptionSpec() const {
  return isNoexceptExceptionSpec(getExceptionSpecType());
}

/// Return whether this function has a dependent exception spec.
bool hasDependentExceptionSpec() const;

/// Return whether this function has an instantiation-dependent exception
/// spec.
bool hasInstantiationDependentExceptionSpec() const;

/// Return all the available information about this type's exception spec.
ExceptionSpecInfo getExceptionSpecInfo() const {
  ExceptionSpecInfo Result;
  Result.Type = getExceptionSpecType();
  if (Result.Type == EST_Dynamic) {
    Result.Exceptions = exceptions();
  } else if (isComputedNoexcept(Result.Type)) {
    Result.NoexceptExpr = getNoexceptExpr();
  } else if (Result.Type == EST_Uninstantiated) {
    Result.SourceDecl = getExceptionSpecDecl();
    Result.SourceTemplate = getExceptionSpecTemplate();
  } else if (Result.Type == EST_Unevaluated) {
    Result.SourceDecl = getExceptionSpecDecl();
  }
  return Result;
}

/// Return the number of types in the exception specification.
unsigned getNumExceptions() const {
  return getExceptionSpecType() == EST_Dynamic
             ? getTrailingObjects<FunctionTypeExtraBitfields>()
                   ->NumExceptionType
             : 0;
}

/// Return the ith exception type, where 0 <= i < getNumExceptions().
QualType getExceptionType(unsigned i) const {
  assert(i < getNumExceptions() && "Invalid exception number!")((void)0);
  return exception_begin()[i];
}

/// Return the expression inside noexcept(expression), or a null pointer
/// if there is none (because the exception spec is not of this form).
Expr *getNoexceptExpr() const {
  if (!isComputedNoexcept(getExceptionSpecType()))
    return nullptr;
  return *getTrailingObjects<Expr *>();
}

/// If this function type has an exception specification which hasn't
/// been determined yet (either because it has not been evaluated or because
/// it has not been instantiated), this is the function whose exception
/// specification is represented by this type.
FunctionDecl *getExceptionSpecDecl() const {
  if (getExceptionSpecType() != EST_Uninstantiated &&
      getExceptionSpecType() != EST_Unevaluated)
    return nullptr;
  return getTrailingObjects<FunctionDecl *>()[0];
}

/// If this function type has an uninstantiated exception
/// specification, this is the function whose exception specification
/// should be instantiated to find the exception specification for
/// this type.
FunctionDecl *getExceptionSpecTemplate() const {
  if (getExceptionSpecType() != EST_Uninstantiated)
    return nullptr;
  return getTrailingObjects<FunctionDecl *>()[1];
}

/// Determine whether this function type has a non-throwing exception
/// specification.
CanThrowResult canThrow() const;

/// Determine whether this function type has a non-throwing exception
/// specification. If this depends on template arguments, returns
/// \c ResultIfDependent.
bool isNothrow(bool ResultIfDependent = false) const {
  return ResultIfDependent ? canThrow() != CT_Can : canThrow() == CT_Cannot;
}

/// Whether this function prototype is variadic.
bool isVariadic() const { return FunctionTypeBits.Variadic; }

SourceLocation getEllipsisLoc() const {
  return isVariadic() ? *getTrailingObjects<SourceLocation>()
                      : SourceLocation();
}

/// Determines whether this function prototype contains a
/// parameter pack at the end.
///
/// A function template whose last parameter is a parameter pack can be
/// called with an arbitrary number of arguments, much like a variadic
/// function.
bool isTemplateVariadic() const;

/// Whether this function prototype has a trailing return type.
bool hasTrailingReturn() const { return FunctionTypeBits.HasTrailingReturn; }

Qualifiers getMethodQuals() const {
  if (hasExtQualifiers())
    return *getTrailingObjects<Qualifiers>();
  else
    return getFastTypeQuals();
}

/// Retrieve the ref-qualifier associated with this function type.
RefQualifierKind getRefQualifier() const {
  return static_cast<RefQualifierKind>(FunctionTypeBits.RefQualifier);
}

using param_type_iterator = const QualType *;
using param_type_range = llvm::iterator_range<param_type_iterator>;

param_type_range param_types() const {
  return param_type_range(param_type_begin(), param_type_end());
}

param_type_iterator param_type_begin() const {
  return getTrailingObjects<QualType>();
}

param_type_iterator param_type_end() const {
  return param_type_begin() + getNumParams();
}

using exception_iterator = const QualType *;

ArrayRef<QualType> exceptions() const {
  return llvm::makeArrayRef(exception_begin(), exception_end());
}

exception_iterator exception_begin() const {
  return reinterpret_cast<exception_iterator>(
      getTrailingObjects<ExceptionType>());
}

exception_iterator exception_end() const {
  return exception_begin() + getNumExceptions();
}

/// Is there any interesting extra information for any of the parameters
/// of this function type?
bool hasExtParameterInfos() const {
  return FunctionTypeBits.HasExtParameterInfos;
}

ArrayRef<ExtParameterInfo> getExtParameterInfos() const {
  assert(hasExtParameterInfos())((void)0);
  return ArrayRef<ExtParameterInfo>(getTrailingObjects<ExtParameterInfo>(),
                                    getNumParams());
}

/// Return a pointer to the beginning of the array of extra parameter
/// information, if present, or else null if none of the parameters
/// carry it.  This is equivalent to getExtProtoInfo().ExtParameterInfos.
const ExtParameterInfo *getExtParameterInfosOrNull() const {
  if (!hasExtParameterInfos())
    return nullptr;
  return getTrailingObjects<ExtParameterInfo>();
}

ExtParameterInfo getExtParameterInfo(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")((void)0);
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I];
  return ExtParameterInfo();
}

ParameterABI getParameterABI(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")((void)0);
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I].getABI();
  return ParameterABI::Ordinary;
}

bool isParamConsumed(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")((void)0);
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
  return false;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void printExceptionSpecification(raw_ostream &OS,
                                 const PrintingPolicy &Policy) const;

static bool classof(const Type *T) {
  return T->getTypeClass() == FunctionProto;
}

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx);
static void Profile(llvm::FoldingSetNodeID &ID, QualType Result,
                    param_type_iterator ArgTys, unsigned NumArgs,
                    const ExtProtoInfo &EPI, const ASTContext &Context,
                    bool Canonical);
4336};

4338/// Represents the dependent type named by a dependently-scoped
4339/// typename using declaration, e.g.
4340///   using typename Base<T>::foo;
4341///
4342/// Template instantiation turns these into the underlying type.
4343class UnresolvedUsingType : public Type {
friend class ASTContext; // ASTContext creates these.

UnresolvedUsingTypenameDecl *Decl;

UnresolvedUsingType(const UnresolvedUsingTypenameDecl *D)
    : Type(UnresolvedUsing, QualType(),
           TypeDependence::DependentInstantiation),
      Decl(const_cast<UnresolvedUsingTypenameDecl *>(D)) {}

4353public:
UnresolvedUsingTypenameDecl *getDecl() const { return Decl; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == UnresolvedUsing;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  return Profile(ID, Decl);
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    UnresolvedUsingTypenameDecl *D) {
  ID.AddPointer(D);
}
4371};

4373class TypedefType : public Type {
TypedefNameDecl *Decl;

4376private:
friend class ASTContext; // ASTContext creates these.

TypedefType(TypeClass tc, const TypedefNameDecl *D, QualType underlying,
            QualType can);

4382public:
TypedefNameDecl *getDecl() const { return Decl; }

bool isSugared() const { return true; }
QualType desugar() const;

static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
4389};

4391/// Sugar type that represents a type that was qualified by a qualifier written
4392/// as a macro invocation.
4393class MacroQualifiedType : public Type {
friend class ASTContext; // ASTContext creates these.

QualType UnderlyingTy;
const IdentifierInfo *MacroII;

MacroQualifiedType(QualType UnderlyingTy, QualType CanonTy,
                   const IdentifierInfo *MacroII)
    : Type(MacroQualified, CanonTy, UnderlyingTy->getDependence()),
      UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
  assert(isa<AttributedType>(UnderlyingTy) &&((void)0)
         "Expected a macro qualified type to only wrap attributed types.")((void)0);
}

4407public:
const IdentifierInfo *getMacroIdentifier() const { return MacroII; }
QualType getUnderlyingType() const { return UnderlyingTy; }

/// Return this attributed type's modified type with no qualifiers attached to
/// it.
QualType getModifiedType() const;

bool isSugared() const { return true; }
QualType desugar() const;

static bool classof(const Type *T) {
  return T->getTypeClass() == MacroQualified;
}
4421};

4423/// Represents a `typeof` (or __typeof__) expression (a GCC extension).
4424class TypeOfExprType : public Type {
Expr *TOExpr;

4427protected:
friend class ASTContext; // ASTContext creates these.

TypeOfExprType(Expr *E, QualType can = QualType());

4432public:
Expr *getUnderlyingExpr() const { return TOExpr; }

/// Remove a single level of sugar.
QualType desugar() const;

/// Returns whether this type directly provides sugar.
bool isSugared() const;

static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExpr; }
4442};

4444/// Internal representation of canonical, dependent
4445/// `typeof(expr)` types.
4446///
4447/// This class is used internally by the ASTContext to manage
4448/// canonical, dependent types, only. Clients will only see instances
4449/// of this class via TypeOfExprType nodes.
4450class DependentTypeOfExprType
: public TypeOfExprType, public llvm::FoldingSetNode {
const ASTContext &Context;

4454public:
DependentTypeOfExprType(const ASTContext &Context, Expr *E)
    : TypeOfExprType(E), Context(Context) {}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getUnderlyingExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    Expr *E);
4464};

4466/// Represents `typeof(type)`, a GCC extension.
4467class TypeOfType : public Type {
friend class ASTContext; // ASTContext creates these.

QualType TOType;

TypeOfType(QualType T, QualType can)
    : Type(TypeOf, can, T->getDependence()), TOType(T) {
  assert(!isa<TypedefType>(can) && "Invalid canonical type")((void)0);
}

4477public:
QualType getUnderlyingType() const { return TOType; }

/// Remove a single level of sugar.
QualType desugar() const { return getUnderlyingType(); }

/// Returns whether this type directly provides sugar.
bool isSugared() const { return true; }

static bool classof(const Type *T) { return T->getTypeClass() == TypeOf; }
4487};

4489/// Represents the type `decltype(expr)` (C++11).
4490class DecltypeType : public Type {
Expr *E;
QualType UnderlyingType;

4494protected:
friend class ASTContext; // ASTContext creates these.

DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());

4499public:
Expr *getUnderlyingExpr() const { return E; }
QualType getUnderlyingType() const { return UnderlyingType; }

/// Remove a single level of sugar.
QualType desugar() const;

/// Returns whether this type directly provides sugar.
bool isSugared() const;

static bool classof(const Type *T) { return T->getTypeClass() == Decltype; }
4510};

4512/// Internal representation of canonical, dependent
4513/// decltype(expr) types.
4514///
4515/// This class is used internally by the ASTContext to manage
4516/// canonical, dependent types, only. Clients will only see instances
4517/// of this class via DecltypeType nodes.
4518class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
const ASTContext &Context;

4521public:
DependentDecltypeType(const ASTContext &Context, Expr *E);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getUnderlyingExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    Expr *E);
4530};

4532/// A unary type transform, which is a type constructed from another.
4533class UnaryTransformType : public Type {
4534public:
enum UTTKind {
  EnumUnderlyingType
};

4539private:
/// The untransformed type.
QualType BaseType;

/// The transformed type if not dependent, otherwise the same as BaseType.
QualType UnderlyingType;

UTTKind UKind;

4548protected:
friend class ASTContext;

UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind,
                   QualType CanonicalTy);

4554public:
bool isSugared() const { return !isDependentType(); }
QualType desugar() const { return UnderlyingType; }

QualType getUnderlyingType() const { return UnderlyingType; }
QualType getBaseType() const { return BaseType; }

UTTKind getUTTKind() const { return UKind; }

static bool classof(const Type *T) {
  return T->getTypeClass() == UnaryTransform;
}
4566};

4568/// Internal representation of canonical, dependent
4569/// __underlying_type(type) types.
4570///
4571/// This class is used internally by the ASTContext to manage
4572/// canonical, dependent types, only. Clients will only see instances
4573/// of this class via UnaryTransformType nodes.
4574class DependentUnaryTransformType : public UnaryTransformType,
                                  public llvm::FoldingSetNode {
4576public:
DependentUnaryTransformType(const ASTContext &C, QualType BaseType,
                            UTTKind UKind);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getBaseType(), getUTTKind());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType BaseType,
                    UTTKind UKind) {
  ID.AddPointer(BaseType.getAsOpaquePtr());
  ID.AddInteger((unsigned)UKind);
}
4589};

4591class TagType : public Type {
friend class ASTReader;
template <class T> friend class serialization::AbstractTypeReader;

/// Stores the TagDecl associated with this type. The decl may point to any
/// TagDecl that declares the entity.
TagDecl *decl;

4599protected:
TagType(TypeClass TC, const TagDecl *D, QualType can);

4602public:
TagDecl *getDecl() const;

/// Determines whether this type is in the process of being defined.
bool isBeingDefined() const;

static bool classof(const Type *T) {
  return T->getTypeClass() == Enum || T->getTypeClass() == Record;
}
4611};

4613/// A helper class that allows the use of isa/cast/dyncast
4614/// to detect TagType objects of structs/unions/classes.
4615class RecordType : public TagType {
4616protected:
friend class ASTContext; // ASTContext creates these.

explicit RecordType(const RecordDecl *D)
    : TagType(Record, reinterpret_cast<const TagDecl*>(D), QualType()) {}
explicit RecordType(TypeClass TC, RecordDecl *D)
    : TagType(TC, reinterpret_cast<const TagDecl*>(D), QualType()) {}

4624public:
RecordDecl *getDecl() const {
  return reinterpret_cast<RecordDecl*>(TagType::getDecl());
}

/// Recursively check all fields in the record for const-ness. If any field
/// is declared const, return true. Otherwise, return false.
bool hasConstFields() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) { return T->getTypeClass() == Record; }
4637};

4639/// A helper class that allows the use of isa/cast/dyncast
4640/// to detect TagType objects of enums.
4641class EnumType : public TagType {
friend class ASTContext; // ASTContext creates these.

explicit EnumType(const EnumDecl *D)
    : TagType(Enum, reinterpret_cast<const TagDecl*>(D), QualType()) {}

4647public:
EnumDecl *getDecl() const {
  return reinterpret_cast<EnumDecl*>(TagType::getDecl());
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) { return T->getTypeClass() == Enum; }
4656};

4658/// An attributed type is a type to which a type attribute has been applied.
4659///
4660/// The "modified type" is the fully-sugared type to which the attributed
4661/// type was applied; generally it is not canonically equivalent to the
4662/// attributed type. The "equivalent type" is the minimally-desugared type
4663/// which the type is canonically equivalent to.
4664///
4665/// For example, in the following attributed type:
4666///     int32_t __attribute__((vector_size(16)))
4667///   - the modified type is the TypedefType for int32_t
4668///   - the equivalent type is VectorType(16, int32_t)
4669///   - the canonical type is VectorType(16, int)
4670class AttributedType : public Type, public llvm::FoldingSetNode {
4671public:
using Kind = attr::Kind;

4674private:
friend class ASTContext; // ASTContext creates these

QualType ModifiedType;
QualType EquivalentType;

AttributedType(QualType canon, attr::Kind attrKind, QualType modified,
               QualType equivalent)
    : Type(Attributed, canon, equivalent->getDependence()),
      ModifiedType(modified), EquivalentType(equivalent) {
  AttributedTypeBits.AttrKind = attrKind;
}

4687public:
Kind getAttrKind() const {
  return static_cast<Kind>(AttributedTypeBits.AttrKind);
}

QualType getModifiedType() const { return ModifiedType; }
QualType getEquivalentType() const { return EquivalentType; }

bool isSugared() const { return true; }
QualType desugar() const { return getEquivalentType(); }

/// Does this attribute behave like a type qualifier?
///
/// A type qualifier adjusts a type to provide specialized rules for
/// a specific object, like the standard const and volatile qualifiers.
/// This includes attributes controlling things like nullability,
/// address spaces, and ARC ownership.  The value of the object is still
/// largely described by the modified type.
///
/// In contrast, many type attributes "rewrite" their modified type to
/// produce a fundamentally different type, not necessarily related in any
/// formalizable way to the original type.  For example, calling convention
/// and vector attributes are not simple type qualifiers.
///
/// Type qualifiers are often, but not always, reflected in the canonical
/// type.
bool isQualifier() const;

bool isMSTypeSpec() const;

bool isCallingConv() const;

llvm::Optional<NullabilityKind> getImmediateNullability() const;

/// Retrieve the attribute kind corresponding to the given
/// nullability kind.
static Kind getNullabilityAttrKind(NullabilityKind kind) {
  switch (kind) {
  case NullabilityKind::NonNull:
    return attr::TypeNonNull;

  case NullabilityKind::Nullable:
    return attr::TypeNullable;

  case NullabilityKind::NullableResult:
    return attr::TypeNullableResult;

  case NullabilityKind::Unspecified:
    return attr::TypeNullUnspecified;
  }
  llvm_unreachable("Unknown nullability kind.")__builtin_unreachable();
}

/// Strip off the top-level nullability annotation on the given
/// type, if it's there.
///
/// \param T The type to strip. If the type is exactly an
/// AttributedType specifying nullability (without looking through
/// type sugar), the nullability is returned and this type changed
/// to the underlying modified type.
///
/// \returns the top-level nullability, if present.
static Optional<NullabilityKind> stripOuterNullability(QualType &T);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getAttrKind(), ModifiedType, EquivalentType);
}

static void Profile(llvm::FoldingSetNodeID &ID, Kind attrKind,
                    QualType modified, QualType equivalent) {
  ID.AddInteger(attrKind);
  ID.AddPointer(modified.getAsOpaquePtr());
  ID.AddPointer(equivalent.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Attributed;
}
4765};

4767class TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

// Helper data collector for canonical types.
struct CanonicalTTPTInfo {
  unsigned Depth : 15;
  unsigned ParameterPack : 1;
  unsigned Index : 16;
};

union {
  // Info for the canonical type.
  CanonicalTTPTInfo CanTTPTInfo;

  // Info for the non-canonical type.
  TemplateTypeParmDecl *TTPDecl;
};

/// Build a non-canonical type.
TemplateTypeParmType(TemplateTypeParmDecl *TTPDecl, QualType Canon)
    : Type(TemplateTypeParm, Canon,
           TypeDependence::DependentInstantiation |
               (Canon->getDependence() & TypeDependence::UnexpandedPack)),
      TTPDecl(TTPDecl) {}

/// Build the canonical type.
TemplateTypeParmType(unsigned D, unsigned I, bool PP)
    : Type(TemplateTypeParm, QualType(this, 0),
           TypeDependence::DependentInstantiation |
               (PP ? TypeDependence::UnexpandedPack : TypeDependence::None)) {
  CanTTPTInfo.Depth = D;
  CanTTPTInfo.Index = I;
  CanTTPTInfo.ParameterPack = PP;
}

const CanonicalTTPTInfo& getCanTTPTInfo() const {
  QualType Can = getCanonicalTypeInternal();
  return Can->castAs<TemplateTypeParmType>()->CanTTPTInfo;
}

4807public:
unsigned getDepth() const { return getCanTTPTInfo().Depth; }
unsigned getIndex() const { return getCanTTPTInfo().Index; }
bool isParameterPack() const { return getCanTTPTInfo().ParameterPack; }

TemplateTypeParmDecl *getDecl() const {
  return isCanonicalUnqualified() ? nullptr : TTPDecl;
}

IdentifierInfo *getIdentifier() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getDepth(), getIndex(), isParameterPack(), getDecl());
}

static void Profile(llvm::FoldingSetNodeID &ID, unsigned Depth,
                    unsigned Index, bool ParameterPack,
                    TemplateTypeParmDecl *TTPDecl) {
  ID.AddInteger(Depth);
  ID.AddInteger(Index);
  ID.AddBoolean(ParameterPack);
  ID.AddPointer(TTPDecl);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == TemplateTypeParm;
}
4837};

4839/// Represents the result of substituting a type for a template
4840/// type parameter.
4841///
4842/// Within an instantiated template, all template type parameters have
4843/// been replaced with these.  They are used solely to record that a
4844/// type was originally written as a template type parameter;
4845/// therefore they are never canonical.
4846class SubstTemplateTypeParmType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

// The original type parameter.
const TemplateTypeParmType *Replaced;

SubstTemplateTypeParmType(const TemplateTypeParmType *Param, QualType Canon)
    : Type(SubstTemplateTypeParm, Canon, Canon->getDependence()),
      Replaced(Param) {}

4856public:
/// Gets the template parameter that was substituted for.
const TemplateTypeParmType *getReplacedParameter() const {
  return Replaced;
}

/// Gets the type that was substituted for the template
/// parameter.
QualType getReplacementType() const {
  return getCanonicalTypeInternal();
}

bool isSugared() const { return true; }
QualType desugar() const { return getReplacementType(); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getReplacedParameter(), getReplacementType());
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    const TemplateTypeParmType *Replaced,
                    QualType Replacement) {
  ID.AddPointer(Replaced);
  ID.AddPointer(Replacement.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == SubstTemplateTypeParm;
}
4885};

4887/// Represents the result of substituting a set of types for a template
4888/// type parameter pack.
4889///
4890/// When a pack expansion in the source code contains multiple parameter packs
4891/// and those parameter packs correspond to different levels of template
4892/// parameter lists, this type node is used to represent a template type
4893/// parameter pack from an outer level, which has already had its argument pack
4894/// substituted but that still lives within a pack expansion that itself
4895/// could not be instantiated. When actually performing a substitution into
4896/// that pack expansion (e.g., when all template parameters have corresponding
4897/// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
4898/// at the current pack substitution index.
4899class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

/// The original type parameter.
const TemplateTypeParmType *Replaced;

/// A pointer to the set of template arguments that this
/// parameter pack is instantiated with.
const TemplateArgument *Arguments;

SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
                              QualType Canon,
                              const TemplateArgument &ArgPack);

4913public:
IdentifierInfo *getIdentifier() const { return Replaced->getIdentifier(); }

/// Gets the template parameter that was substituted for.
const TemplateTypeParmType *getReplacedParameter() const {
  return Replaced;
}

unsigned getNumArgs() const {
  return SubstTemplateTypeParmPackTypeBits.NumArgs;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

TemplateArgument getArgumentPack() const;

void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    const TemplateTypeParmType *Replaced,
                    const TemplateArgument &ArgPack);

static bool classof(const Type *T) {
  return T->getTypeClass() == SubstTemplateTypeParmPack;
}
4938};

4940/// Common base class for placeholders for types that get replaced by
4941/// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced
4942/// class template types, and constrained type names.
4943///
4944/// These types are usually a placeholder for a deduced type. However, before
4945/// the initializer is attached, or (usually) if the initializer is
4946/// type-dependent, there is no deduced type and the type is canonical. In
4947/// the latter case, it is also a dependent type.
4948class DeducedType : public Type {
4949protected:
DeducedType(TypeClass TC, QualType DeducedAsType,
            TypeDependence ExtraDependence)
    : Type(TC,
           // FIXME: Retain the sugared deduced type?
           DeducedAsType.isNull() ? QualType(this, 0)
                                  : DeducedAsType.getCanonicalType(),
           ExtraDependence | (DeducedAsType.isNull()
                                  ? TypeDependence::None
                                  : DeducedAsType->getDependence() &
                                        ~TypeDependence::VariablyModified)) {}

4961public:
bool isSugared() const { return !isCanonicalUnqualified(); }
QualType desugar() const { return getCanonicalTypeInternal(); }

/// Get the type deduced for this placeholder type, or null if it's
/// either not been deduced or was deduced to a dependent type.
QualType getDeducedType() const {
  return !isCanonicalUnqualified() ? getCanonicalTypeInternal() : QualType();
}
bool isDeduced() const {
  return !isCanonicalUnqualified() || isDependentType();
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Auto ||
         T->getTypeClass() == DeducedTemplateSpecialization;
}
4978};

4980/// Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained
4981/// by a type-constraint.
4982class alignas(8) AutoType : public DeducedType, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

ConceptDecl *TypeConstraintConcept;

AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
         TypeDependence ExtraDependence, ConceptDecl *CD,
         ArrayRef<TemplateArgument> TypeConstraintArgs);

const TemplateArgument *getArgBuffer() const {
  return reinterpret_cast<const TemplateArgument*>(this+1);
}

TemplateArgument *getArgBuffer() {
  return reinterpret_cast<TemplateArgument*>(this+1);
}

4999public:
/// Retrieve the template arguments.
const TemplateArgument *getArgs() const {
  return getArgBuffer();
}

/// Retrieve the number of template arguments.
unsigned getNumArgs() const {
  return AutoTypeBits.NumArgs;
}

const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h

ArrayRef<TemplateArgument> getTypeConstraintArguments() const {
  return {getArgs(), getNumArgs()};
}

ConceptDecl *getTypeConstraintConcept() const {
  return TypeConstraintConcept;
}

bool isConstrained() const {
  return TypeConstraintConcept != nullptr;
}

bool isDecltypeAuto() const {
  return getKeyword() == AutoTypeKeyword::DecltypeAuto;
}

AutoTypeKeyword getKeyword() const {
  return (AutoTypeKeyword)AutoTypeBits.Keyword;
}

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
  Profile(ID, Context, getDeducedType(), getKeyword(), isDependentType(),
          getTypeConstraintConcept(), getTypeConstraintArguments());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType Deduced, AutoTypeKeyword Keyword,
                    bool IsDependent, ConceptDecl *CD,
                    ArrayRef<TemplateArgument> Arguments);

static bool classof(const Type *T) {
  return T->getTypeClass() == Auto;
}
5045};

5047/// Represents a C++17 deduced template specialization type.
5048class DeducedTemplateSpecializationType : public DeducedType,
                                        public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The name of the template whose arguments will be deduced.
TemplateName Template;

DeducedTemplateSpecializationType(TemplateName Template,
                                  QualType DeducedAsType,
                                  bool IsDeducedAsDependent)
    : DeducedType(DeducedTemplateSpecialization, DeducedAsType,
                  toTypeDependence(Template.getDependence()) |
                      (IsDeducedAsDependent
                           ? TypeDependence::DependentInstantiation
                           : TypeDependence::None)),
      Template(Template) {}

5065public:
/// Retrieve the name of the template that we are deducing.
TemplateName getTemplateName() const { return Template;}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getTemplateName(), getDeducedType(), isDependentType());
}

static void Profile(llvm::FoldingSetNodeID &ID, TemplateName Template,
                    QualType Deduced, bool IsDependent) {
  Template.Profile(ID);
  ID.AddPointer(Deduced.getAsOpaquePtr());
  ID.AddBoolean(IsDependent);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == DeducedTemplateSpecialization;
}
5083};

5085/// Represents a type template specialization; the template
5086/// must be a class template, a type alias template, or a template
5087/// template parameter.  A template which cannot be resolved to one of
5088/// these, e.g. because it is written with a dependent scope
5089/// specifier, is instead represented as a
5090/// @c DependentTemplateSpecializationType.
5091///
5092/// A non-dependent template specialization type is always "sugar",
5093/// typically for a \c RecordType.  For example, a class template
5094/// specialization type of \c vector<int> will refer to a tag type for
5095/// the instantiation \c std::vector<int, std::allocator<int>>
5096///
5097/// Template specializations are dependent if either the template or
5098/// any of the template arguments are dependent, in which case the
5099/// type may also be canonical.
5100///
5101/// Instances of this type are allocated with a trailing array of
5102/// TemplateArguments, followed by a QualType representing the
5103/// non-canonical aliased type when the template is a type alias
5104/// template.
5105class alignas(8) TemplateSpecializationType
  : public Type,
    public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The name of the template being specialized.  This is
/// either a TemplateName::Template (in which case it is a
/// ClassTemplateDecl*, a TemplateTemplateParmDecl*, or a
/// TypeAliasTemplateDecl*), a
/// TemplateName::SubstTemplateTemplateParmPack, or a
/// TemplateName::SubstTemplateTemplateParm (in which case the
/// replacement must, recursively, be one of these).
TemplateName Template;

TemplateSpecializationType(TemplateName T,
                           ArrayRef<TemplateArgument> Args,
                           QualType Canon,
                           QualType Aliased);

5124public:
/// Determine whether any of the given template arguments are dependent.
///
/// The converted arguments should be supplied when known; whether an
/// argument is dependent can depend on the conversions performed on it
/// (for example, a 'const int' passed as a template argument might be
/// dependent if the parameter is a reference but non-dependent if the
/// parameter is an int).
///
/// Note that the \p Args parameter is unused: this is intentional, to remind
/// the caller that they need to pass in the converted arguments, not the
/// specified arguments.
static bool
anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
                              ArrayRef<TemplateArgument> Converted);
static bool
anyDependentTemplateArguments(const TemplateArgumentListInfo &,
                              ArrayRef<TemplateArgument> Converted);
static bool anyInstantiationDependentTemplateArguments(
    ArrayRef<TemplateArgumentLoc> Args);

/// True if this template specialization type matches a current
/// instantiation in the context in which it is found.
bool isCurrentInstantiation() const {
  return isa<InjectedClassNameType>(getCanonicalTypeInternal());
}

/// Determine if this template specialization type is for a type alias
/// template that has been substituted.
///
/// Nearly every template specialization type whose template is an alias
/// template will be substituted. However, this is not the case when
/// the specialization contains a pack expansion but the template alias
/// does not have a corresponding parameter pack, e.g.,
///
/// \code
/// template<typename T, typename U, typename V> struct S;
/// template<typename T, typename U> using A = S<T, int, U>;
/// template<typename... Ts> struct X {
///   typedef A<Ts...> type; // not a type alias
/// };
/// \endcode
bool isTypeAlias() const { return TemplateSpecializationTypeBits.TypeAlias; }

/// Get the aliased type, if this is a specialization of a type alias
/// template.
QualType getAliasedType() const {
  assert(isTypeAlias() && "not a type alias template specialization")((void)0);
  return *reinterpret_cast<const QualType*>(end());
}

using iterator = const TemplateArgument *;

iterator begin() const { return getArgs(); }
iterator end() const; // defined inline in TemplateBase.h

/// Retrieve the name of the template that we are specializing.
TemplateName getTemplateName() const { return Template; }

/// Retrieve the template arguments.
const TemplateArgument *getArgs() const {
  return reinterpret_cast<const TemplateArgument *>(this + 1);
}

/// Retrieve the number of template arguments.
unsigned getNumArgs() const {
  return TemplateSpecializationTypeBits.NumArgs;
}

/// Retrieve a specific template argument as a type.
/// \pre \c isArgType(Arg)
const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h

ArrayRef<TemplateArgument> template_arguments() const {
  return {getArgs(), getNumArgs()};
}

bool isSugared() const {
  return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
}

QualType desugar() const {
  return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
}

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
  Profile(ID, Template, template_arguments(), Ctx);
  if (isTypeAlias())
    getAliasedType().Profile(ID);
}

static void Profile(llvm::FoldingSetNodeID &ID, TemplateName T,
                    ArrayRef<TemplateArgument> Args,
                    const ASTContext &Context);

static bool classof(const Type *T) {
  return T->getTypeClass() == TemplateSpecialization;
}
5222};

5224/// Print a template argument list, including the '<' and '>'
5225/// enclosing the template arguments.
5226void printTemplateArgumentList(raw_ostream &OS,
                             ArrayRef<TemplateArgument> Args,
                             const PrintingPolicy &Policy,
                             const TemplateParameterList *TPL = nullptr);

5231void printTemplateArgumentList(raw_ostream &OS,
                             ArrayRef<TemplateArgumentLoc> Args,
                             const PrintingPolicy &Policy,
                             const TemplateParameterList *TPL = nullptr);

5236void printTemplateArgumentList(raw_ostream &OS,
                             const TemplateArgumentListInfo &Args,
                             const PrintingPolicy &Policy,
                             const TemplateParameterList *TPL = nullptr);

5241/// The injected class name of a C++ class template or class
5242/// template partial specialization.  Used to record that a type was
5243/// spelled with a bare identifier rather than as a template-id; the
5244/// equivalent for non-templated classes is just RecordType.
5245///
5246/// Injected class name types are always dependent.  Template
5247/// instantiation turns these into RecordTypes.
5248///
5249/// Injected class name types are always canonical.  This works
5250/// because it is impossible to compare an injected class name type
5251/// with the corresponding non-injected template type, for the same
5252/// reason that it is impossible to directly compare template
5253/// parameters from different dependent contexts: injected class name
5254/// types can only occur within the scope of a particular templated
5255/// declaration, and within that scope every template specialization
5256/// will canonicalize to the injected class name (when appropriate
5257/// according to the rules of the language).
5258class InjectedClassNameType : public Type {
friend class ASTContext; // ASTContext creates these.
friend class ASTNodeImporter;
friend class ASTReader; // FIXME: ASTContext::getInjectedClassNameType is not
                        // currently suitable for AST reading, too much
                        // interdependencies.
template <class T> friend class serialization::AbstractTypeReader;

CXXRecordDecl *Decl;

/// The template specialization which this type represents.
/// For example, in
///   template <class T> class A { ... };
/// this is A<T>, whereas in
///   template <class X, class Y> class A<B<X,Y> > { ... };
/// this is A<B<X,Y> >.
///
/// It is always unqualified, always a template specialization type,
/// and always dependent.
QualType InjectedType;

InjectedClassNameType(CXXRecordDecl *D, QualType TST)
    : Type(InjectedClassName, QualType(),
           TypeDependence::DependentInstantiation),
      Decl(D), InjectedType(TST) {
  assert(isa<TemplateSpecializationType>(TST))((void)0);
  assert(!TST.hasQualifiers())((void)0);
  assert(TST->isDependentType())((void)0);
}

5288public:
QualType getInjectedSpecializationType() const { return InjectedType; }

const TemplateSpecializationType *getInjectedTST() const {
  return cast<TemplateSpecializationType>(InjectedType.getTypePtr());
}

TemplateName getTemplateName() const {
  return getInjectedTST()->getTemplateName();
}

CXXRecordDecl *getDecl() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == InjectedClassName;
}
5307};

5309/// The kind of a tag type.
5310enum TagTypeKind {
/// The "struct" keyword.
TTK_Struct,

/// The "__interface" keyword.
TTK_Interface,

/// The "union" keyword.
TTK_Union,

/// The "class" keyword.
TTK_Class,

/// The "enum" keyword.
TTK_Enum
5325};

5327/// The elaboration keyword that precedes a qualified type name or
5328/// introduces an elaborated-type-specifier.
5329enum ElaboratedTypeKeyword {
/// The "struct" keyword introduces the elaborated-type-specifier.
ETK_Struct,

/// The "__interface" keyword introduces the elaborated-type-specifier.
ETK_Interface,

/// The "union" keyword introduces the elaborated-type-specifier.
ETK_Union,

/// The "class" keyword introduces the elaborated-type-specifier.
ETK_Class,

/// The "enum" keyword introduces the elaborated-type-specifier.
ETK_Enum,

/// The "typename" keyword precedes the qualified type name, e.g.,
/// \c typename T::type.
ETK_Typename,

/// No keyword precedes the qualified type name.
ETK_None
5351};

5353/// A helper class for Type nodes having an ElaboratedTypeKeyword.
5354/// The keyword in stored in the free bits of the base class.
5355/// Also provides a few static helpers for converting and printing
5356/// elaborated type keyword and tag type kind enumerations.
5357class TypeWithKeyword : public Type {
5358protected:
TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc,
                QualType Canonical, TypeDependence Dependence)
    : Type(tc, Canonical, Dependence) {
  TypeWithKeywordBits.Keyword = Keyword;
}

5365public:
ElaboratedTypeKeyword getKeyword() const {
  return static_cast<ElaboratedTypeKeyword>(TypeWithKeywordBits.Keyword);
}

/// Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec);

/// Converts a type specifier (DeclSpec::TST) into a tag type kind.
/// It is an error to provide a type specifier which *isn't* a tag kind here.
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec);

/// Converts a TagTypeKind into an elaborated type keyword.
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag);

/// Converts an elaborated type keyword into a TagTypeKind.
/// It is an error to provide an elaborated type keyword
/// which *isn't* a tag kind here.
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword);

static bool KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword);

static StringRef getKeywordName(ElaboratedTypeKeyword Keyword);

static StringRef getTagTypeKindName(TagTypeKind Kind) {
  return getKeywordName(getKeywordForTagTypeKind(Kind));
}

class CannotCastToThisType {};
static CannotCastToThisType classof(const Type *);
5395};

5397/// Represents a type that was referred to using an elaborated type
5398/// keyword, e.g., struct S, or via a qualified name, e.g., N::M::type,
5399/// or both.
5400///
5401/// This type is used to keep track of a type name as written in the
5402/// source code, including tag keywords and any nested-name-specifiers.
5403/// The type itself is always "sugar", used to express what was written
5404/// in the source code but containing no additional semantic information.
5405class ElaboratedType final
  : public TypeWithKeyword,
    public llvm::FoldingSetNode,
    private llvm::TrailingObjects<ElaboratedType, TagDecl *> {
friend class ASTContext; // ASTContext creates these
friend TrailingObjects;

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The type that this qualified name refers to.
QualType NamedType;

/// The (re)declaration of this tag type owned by this occurrence is stored
/// as a trailing object if there is one. Use getOwnedTagDecl to obtain
/// it, or obtain a null pointer if there is none.

ElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
               QualType NamedType, QualType CanonType, TagDecl *OwnedTagDecl)
    : TypeWithKeyword(Keyword, Elaborated, CanonType,
                      // Any semantic dependence on the qualifier will have
                      // been incorporated into NamedType. We still need to
                      // track syntactic (instantiation / error / pack)
                      // dependence on the qualifier.
                      NamedType->getDependence() |
                          (NNS ? toSyntacticDependence(
                                     toTypeDependence(NNS->getDependence()))
                               : TypeDependence::None)),
      NNS(NNS), NamedType(NamedType) {
  ElaboratedTypeBits.HasOwnedTagDecl = false;
  if (OwnedTagDecl) {
    ElaboratedTypeBits.HasOwnedTagDecl = true;
    *getTrailingObjects<TagDecl *>() = OwnedTagDecl;
  }
  assert(!(Keyword == ETK_None && NNS == nullptr) &&((void)0)
         "ElaboratedType cannot have elaborated type keyword "((void)0)
         "and name qualifier both null.")((void)0);
}

5444public:
/// Retrieve the qualification on this type.
NestedNameSpecifier *getQualifier() const { return NNS; }

/// Retrieve the type named by the qualified-id.
QualType getNamedType() const { return NamedType; }

/// Remove a single level of sugar.
QualType desugar() const { return getNamedType(); }

/// Returns whether this type directly provides sugar.
bool isSugared() const { return true; }

/// Return the (re)declaration of this type owned by this occurrence of this
/// type, or nullptr if there is none.
TagDecl *getOwnedTagDecl() const {
  return ElaboratedTypeBits.HasOwnedTagDecl ? *getTrailingObjects<TagDecl *>()
                                            : nullptr;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getKeyword(), NNS, NamedType, getOwnedTagDecl());
}

static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *NNS, QualType NamedType,
                    TagDecl *OwnedTagDecl) {
  ID.AddInteger(Keyword);
  ID.AddPointer(NNS);
  NamedType.Profile(ID);
  ID.AddPointer(OwnedTagDecl);
}

static bool classof(const Type *T) { return T->getTypeClass() == Elaborated; }
5478};

5480/// Represents a qualified type name for which the type name is
5481/// dependent.
5482///
5483/// DependentNameType represents a class of dependent types that involve a
5484/// possibly dependent nested-name-specifier (e.g., "T::") followed by a
5485/// name of a type. The DependentNameType may start with a "typename" (for a
5486/// typename-specifier), "class", "struct", "union", or "enum" (for a
5487/// dependent elaborated-type-specifier), or nothing (in contexts where we
5488/// know that we must be referring to a type, e.g., in a base class specifier).
5489/// Typically the nested-name-specifier is dependent, but in MSVC compatibility
5490/// mode, this type is used with non-dependent names to delay name lookup until
5491/// instantiation.
5492class DependentNameType : public TypeWithKeyword, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The type that this typename specifier refers to.
const IdentifierInfo *Name;

DependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
                  const IdentifierInfo *Name, QualType CanonType)
    : TypeWithKeyword(Keyword, DependentName, CanonType,
                      TypeDependence::DependentInstantiation |
                          toTypeDependence(NNS->getDependence())),
      NNS(NNS), Name(Name) {}

5508public:
/// Retrieve the qualification on this type.
NestedNameSpecifier *getQualifier() const { return NNS; }

/// Retrieve the type named by the typename specifier as an identifier.
///
/// This routine will return a non-NULL identifier pointer when the
/// form of the original typename was terminated by an identifier,
/// e.g., "typename T::type".
const IdentifierInfo *getIdentifier() const {
  return Name;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getKeyword(), NNS, Name);
}

static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *NNS, const IdentifierInfo *Name) {
  ID.AddInteger(Keyword);
  ID.AddPointer(NNS);
  ID.AddPointer(Name);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentName;
}
5538};

5540/// Represents a template specialization type whose template cannot be
5541/// resolved, e.g.
5542///   A<T>::template B<T>
5543class alignas(8) DependentTemplateSpecializationType
  : public TypeWithKeyword,
    public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The identifier of the template.
const IdentifierInfo *Name;

DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
                                    NestedNameSpecifier *NNS,
                                    const IdentifierInfo *Name,
                                    ArrayRef<TemplateArgument> Args,
                                    QualType Canon);

const TemplateArgument *getArgBuffer() const {
  return reinterpret_cast<const TemplateArgument*>(this+1);
}

TemplateArgument *getArgBuffer() {
  return reinterpret_cast<TemplateArgument*>(this+1);
}

5568public:
NestedNameSpecifier *getQualifier() const { return NNS; }
const IdentifierInfo *getIdentifier() const { return Name; }

/// Retrieve the template arguments.
const TemplateArgument *getArgs() const {
  return getArgBuffer();
}

/// Retrieve the number of template arguments.
unsigned getNumArgs() const {
  return DependentTemplateSpecializationTypeBits.NumArgs;
}

const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h

ArrayRef<TemplateArgument> template_arguments() const {
  return {getArgs(), getNumArgs()};
}

using iterator = const TemplateArgument *;

iterator begin() const { return getArgs(); }
iterator end() const; // inline in TemplateBase.h

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
  Profile(ID, Context, getKeyword(), NNS, Name, {getArgs(), getNumArgs()});
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    const ASTContext &Context,
                    ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *Qualifier,
                    const IdentifierInfo *Name,
                    ArrayRef<TemplateArgument> Args);

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentTemplateSpecialization;
}
5610};

5612/// Represents a pack expansion of types.
5613///
5614/// Pack expansions are part of C++11 variadic templates. A pack
5615/// expansion contains a pattern, which itself contains one or more
5616/// "unexpanded" parameter packs. When instantiated, a pack expansion
5617/// produces a series of types, each instantiated from the pattern of
5618/// the expansion, where the Ith instantiation of the pattern uses the
5619/// Ith arguments bound to each of the unexpanded parameter packs. The
5620/// pack expansion is considered to "expand" these unexpanded
5621/// parameter packs.
5622///
5623/// \code
5624/// template<typename ...Types> struct tuple;
5625///
5626/// template<typename ...Types>
5627/// struct tuple_of_references {
5628///   typedef tuple<Types&...> type;
5629/// };
5630/// \endcode
5631///
5632/// Here, the pack expansion \c Types&... is represented via a
5633/// PackExpansionType whose pattern is Types&.
5634class PackExpansionType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The pattern of the pack expansion.
QualType Pattern;

PackExpansionType(QualType Pattern, QualType Canon,
                  Optional<unsigned> NumExpansions)
    : Type(PackExpansion, Canon,
           (Pattern->getDependence() | TypeDependence::Dependent |
            TypeDependence::Instantiation) &
               ~TypeDependence::UnexpandedPack),
      Pattern(Pattern) {
  PackExpansionTypeBits.NumExpansions =
      NumExpansions ? *NumExpansions + 1 : 0;
}

5651public:
/// Retrieve the pattern of this pack expansion, which is the
/// type that will be repeatedly instantiated when instantiating the
/// pack expansion itself.
QualType getPattern() const { return Pattern; }

/// Retrieve the number of expansions that this pack expansion will
/// generate, if known.
Optional<unsigned> getNumExpansions() const {
  if (PackExpansionTypeBits.NumExpansions)
    return PackExpansionTypeBits.NumExpansions - 1;
  return None;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPattern(), getNumExpansions());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern,
                    Optional<unsigned> NumExpansions) {
  ID.AddPointer(Pattern.getAsOpaquePtr());
  ID.AddBoolean(NumExpansions.hasValue());
  if (NumExpansions)
    ID.AddInteger(*NumExpansions);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == PackExpansion;
}
5683};

5685/// This class wraps the list of protocol qualifiers. For types that can
5686/// take ObjC protocol qualifers, they can subclass this class.
5687template <class T>
5688class ObjCProtocolQualifiers {
5689protected:
ObjCProtocolQualifiers() = default;

ObjCProtocolDecl * const *getProtocolStorage() const {
  return const_cast<ObjCProtocolQualifiers*>(this)->getProtocolStorage();
}

ObjCProtocolDecl **getProtocolStorage() {
  return static_cast<T*>(this)->getProtocolStorageImpl();
}

void setNumProtocols(unsigned N) {
  static_cast<T*>(this)->setNumProtocolsImpl(N);
}

void initialize(ArrayRef<ObjCProtocolDecl *> protocols) {
  setNumProtocols(protocols.size());
  assert(getNumProtocols() == protocols.size() &&((void)0)
         "bitfield overflow in protocol count")((void)0);
  if (!protocols.empty())
    memcpy(getProtocolStorage(), protocols.data(),
           protocols.size() * sizeof(ObjCProtocolDecl*));
}

5713public:
using qual_iterator = ObjCProtocolDecl * const *;
using qual_range = llvm::iterator_range<qual_iterator>;

qual_range quals() const { return qual_range(qual_begin(), qual_end()); }
qual_iterator qual_begin() const { return getProtocolStorage(); }
qual_iterator qual_end() const { return qual_begin() + getNumProtocols(); }

bool qual_empty() const { return getNumProtocols() == 0; }

/// Return the number of qualifying protocols in this type, or 0 if
/// there are none.
unsigned getNumProtocols() const {
  return static_cast<const T*>(this)->getNumProtocolsImpl();
}

/// Fetch a protocol by index.
ObjCProtocolDecl *getProtocol(unsigned I) const {
  assert(I < getNumProtocols() && "Out-of-range protocol access")((void)0);
  return qual_begin()[I];
}

/// Retrieve all of the protocol qualifiers.
ArrayRef<ObjCProtocolDecl *> getProtocols() const {
  return ArrayRef<ObjCProtocolDecl *>(qual_begin(), getNumProtocols());
}
5739};

5741/// Represents a type parameter type in Objective C. It can take
5742/// a list of protocols.
5743class ObjCTypeParamType : public Type,
                        public ObjCProtocolQualifiers<ObjCTypeParamType>,
                        public llvm::FoldingSetNode {
friend class ASTContext;
friend class ObjCProtocolQualifiers<ObjCTypeParamType>;

/// The number of protocols stored on this type.
unsigned NumProtocols : 6;

ObjCTypeParamDecl *OTPDecl;

/// The protocols are stored after the ObjCTypeParamType node. In the
/// canonical type, the list of protocols are sorted alphabetically
/// and uniqued.
ObjCProtocolDecl **getProtocolStorageImpl();

/// Return the number of qualifying protocols in this interface type,
/// or 0 if there are none.
unsigned getNumProtocolsImpl() const {
  return NumProtocols;
}

void setNumProtocolsImpl(unsigned N) {
  NumProtocols = N;
}

ObjCTypeParamType(const ObjCTypeParamDecl *D,
                  QualType can,
                  ArrayRef<ObjCProtocolDecl *> protocols);

5773public:
bool isSugared() const { return true; }
QualType desugar() const { return getCanonicalTypeInternal(); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCTypeParam;
}

void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    const ObjCTypeParamDecl *OTPDecl,
                    QualType CanonicalType,
                    ArrayRef<ObjCProtocolDecl *> protocols);

ObjCTypeParamDecl *getDecl() const { return OTPDecl; }
5788};

5790/// Represents a class type in Objective C.
5791///
5792/// Every Objective C type is a combination of a base type, a set of
5793/// type arguments (optional, for parameterized classes) and a list of
5794/// protocols.
5795///
5796/// Given the following declarations:
5797/// \code
5798///   \@class C<T>;
5799///   \@protocol P;
5800/// \endcode
5801///
5802/// 'C' is an ObjCInterfaceType C.  It is sugar for an ObjCObjectType
5803/// with base C and no protocols.
5804///
5805/// 'C<P>' is an unspecialized ObjCObjectType with base C and protocol list [P].
5806/// 'C<C*>' is a specialized ObjCObjectType with type arguments 'C*' and no
5807/// protocol list.
5808/// 'C<C*><P>' is a specialized ObjCObjectType with base C, type arguments 'C*',
5809/// and protocol list [P].
5810///
5811/// 'id' is a TypedefType which is sugar for an ObjCObjectPointerType whose
5812/// pointee is an ObjCObjectType with base BuiltinType::ObjCIdType
5813/// and no protocols.
5814///
5815/// 'id<P>' is an ObjCObjectPointerType whose pointee is an ObjCObjectType
5816/// with base BuiltinType::ObjCIdType and protocol list [P].  Eventually
5817/// this should get its own sugar class to better represent the source.
5818class ObjCObjectType : public Type,
                     public ObjCProtocolQualifiers<ObjCObjectType> {
friend class ObjCProtocolQualifiers<ObjCObjectType>;

// ObjCObjectType.NumTypeArgs - the number of type arguments stored
// after the ObjCObjectPointerType node.
// ObjCObjectType.NumProtocols - the number of protocols stored
// after the type arguments of ObjCObjectPointerType node.
//
// These protocols are those written directly on the type.  If
// protocol qualifiers ever become additive, the iterators will need
// to get kindof complicated.
//
// In the canonical object type, these are sorted alphabetically
// and uniqued.

/// Either a BuiltinType or an InterfaceType or sugar for either.
QualType BaseType;

/// Cached superclass type.
mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool>
  CachedSuperClassType;

QualType *getTypeArgStorage();
const QualType *getTypeArgStorage() const {
  return const_cast<ObjCObjectType *>(this)->getTypeArgStorage();
}

ObjCProtocolDecl **getProtocolStorageImpl();
/// Return the number of qualifying protocols in this interface type,
/// or 0 if there are none.
unsigned getNumProtocolsImpl() const {
  return ObjCObjectTypeBits.NumProtocols;
}
void setNumProtocolsImpl(unsigned N) {
  ObjCObjectTypeBits.NumProtocols = N;
}

5856protected:
enum Nonce_ObjCInterface { Nonce_ObjCInterface };

ObjCObjectType(QualType Canonical, QualType Base,
               ArrayRef<QualType> typeArgs,
               ArrayRef<ObjCProtocolDecl *> protocols,
               bool isKindOf);

ObjCObjectType(enum Nonce_ObjCInterface)
    : Type(ObjCInterface, QualType(), TypeDependence::None),
      BaseType(QualType(this_(), 0)) {
  ObjCObjectTypeBits.NumProtocols = 0;
  ObjCObjectTypeBits.NumTypeArgs = 0;
  ObjCObjectTypeBits.IsKindOf = 0;
}

void computeSuperClassTypeSlow() const;

5874public:
/// Gets the base type of this object type.  This is always (possibly
/// sugar for) one of:
///  - the 'id' builtin type (as opposed to the 'id' type visible to the
///    user, which is a typedef for an ObjCObjectPointerType)
///  - the 'Class' builtin type (same caveat)
///  - an ObjCObjectType (currently always an ObjCInterfaceType)
QualType getBaseType() const { return BaseType; }

bool isObjCId() const {
  return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId);
}

bool isObjCClass() const {
  return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass);
}

bool isObjCUnqualifiedId() const { return qual_empty() && isObjCId(); }
bool isObjCUnqualifiedClass() const { return qual_empty() && isObjCClass(); }
bool isObjCUnqualifiedIdOrClass() const {
  if (!qual_empty()) return false;
  if (const BuiltinType *T = getBaseType()->getAs<BuiltinType>())
    return T->getKind() == BuiltinType::ObjCId ||
           T->getKind() == BuiltinType::ObjCClass;
  return false;
}
bool isObjCQualifiedId() const { return !qual_empty() && isObjCId(); }
bool isObjCQualifiedClass() const { return !qual_empty() && isObjCClass(); }

/// Gets the interface declaration for this object type, if the base type
/// really is an interface.
ObjCInterfaceDecl *getInterface() const;

/// Determine whether this object type is "specialized", meaning
/// that it has type arguments.
bool isSpecialized() const;

/// Determine whether this object type was written with type arguments.
bool isSpecializedAsWritten() const {
  return ObjCObjectTypeBits.NumTypeArgs > 0;
}

/// Determine whether this object type is "unspecialized", meaning
/// that it has no type arguments.
bool isUnspecialized() const { return !isSpecialized(); }

/// Determine whether this object type is "unspecialized" as
/// written, meaning that it has no type arguments.
bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }

/// Retrieve the type arguments of this object type (semantically).
ArrayRef<QualType> getTypeArgs() const;

/// Retrieve the type arguments of this object type as they were
/// written.
ArrayRef<QualType> getTypeArgsAsWritten() const {
  return llvm::makeArrayRef(getTypeArgStorage(),
                            ObjCObjectTypeBits.NumTypeArgs);
}

/// Whether this is a "__kindof" type as written.
bool isKindOfTypeAsWritten() const { return ObjCObjectTypeBits.IsKindOf; }

/// Whether this ia a "__kindof" type (semantically).
bool isKindOfType() const;

/// Retrieve the type of the superclass of this object type.
///
/// This operation substitutes any type arguments into the
/// superclass of the current class type, potentially producing a
/// specialization of the superclass type. Produces a null type if
/// there is no superclass.
QualType getSuperClassType() const {
  if (!CachedSuperClassType.getInt())
    computeSuperClassTypeSlow();

  assert(CachedSuperClassType.getInt() && "Superclass not set?")((void)0);
  return QualType(CachedSuperClassType.getPointer(), 0);
}

/// Strip off the Objective-C "kindof" type and (with it) any
/// protocol qualifiers.
QualType stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCObject ||
         T->getTypeClass() == ObjCInterface;
}
5965};

5967/// A class providing a concrete implementation
5968/// of ObjCObjectType, so as to not increase the footprint of
5969/// ObjCInterfaceType.  Code outside of ASTContext and the core type
5970/// system should not reference this type.
5971class ObjCObjectTypeImpl : public ObjCObjectType, public llvm::FoldingSetNode {
friend class ASTContext;

// If anyone adds fields here, ObjCObjectType::getProtocolStorage()
// will need to be modified.

ObjCObjectTypeImpl(QualType Canonical, QualType Base,
                   ArrayRef<QualType> typeArgs,
                   ArrayRef<ObjCProtocolDecl *> protocols,
                   bool isKindOf)
    : ObjCObjectType(Canonical, Base, typeArgs, protocols, isKindOf) {}

5983public:
void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    QualType Base,
                    ArrayRef<QualType> typeArgs,
                    ArrayRef<ObjCProtocolDecl *> protocols,
                    bool isKindOf);
5990};

5992inline QualType *ObjCObjectType::getTypeArgStorage() {
return reinterpret_cast<QualType *>(static_cast<ObjCObjectTypeImpl*>(this)+1);
5994}

5996inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
  return reinterpret_cast<ObjCProtocolDecl**>(
           getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
5999}

6001inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
  return reinterpret_cast<ObjCProtocolDecl**>(
           static_cast<ObjCTypeParamType*>(this)+1);
6004}

6006/// Interfaces are the core concept in Objective-C for object oriented design.
6007/// They basically correspond to C++ classes.  There are two kinds of interface
6008/// types: normal interfaces like `NSString`, and qualified interfaces, which
6009/// are qualified with a protocol list like `NSString<NSCopyable, NSAmazing>`.
6010///
6011/// ObjCInterfaceType guarantees the following properties when considered
6012/// as a subtype of its superclass, ObjCObjectType:
6013///   - There are no protocol qualifiers.  To reinforce this, code which
6014///     tries to invoke the protocol methods via an ObjCInterfaceType will
6015///     fail to compile.
6016///   - It is its own base type.  That is, if T is an ObjCInterfaceType*,
6017///     T->getBaseType() == QualType(T, 0).
6018class ObjCInterfaceType : public ObjCObjectType {
friend class ASTContext; // ASTContext creates these.
friend class ASTReader;
friend class ObjCInterfaceDecl;
template <class T> friend class serialization::AbstractTypeReader;

mutable ObjCInterfaceDecl *Decl;

ObjCInterfaceType(const ObjCInterfaceDecl *D)
    : ObjCObjectType(Nonce_ObjCInterface),
      Decl(const_cast<ObjCInterfaceDecl*>(D)) {}

6030public:
/// Get the declaration of this interface.
ObjCInterfaceDecl *getDecl() const { return Decl; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCInterface;
}

// Nonsense to "hide" certain members of ObjCObjectType within this
// class.  People asking for protocols on an ObjCInterfaceType are
// not going to get what they want: ObjCInterfaceTypes are
// guaranteed to have no protocols.
enum {
  qual_iterator,
  qual_begin,
  qual_end,
  getNumProtocols,
  getProtocol
};
6052};

6054inline ObjCInterfaceDecl *ObjCObjectType::getInterface() const {
QualType baseType = getBaseType();
while (const auto *ObjT = baseType->getAs<ObjCObjectType>()) {
  if (const auto *T = dyn_cast<ObjCInterfaceType>(ObjT))
    return T->getDecl();

  baseType = ObjT->getBaseType();
}

return nullptr;
6064}

6066/// Represents a pointer to an Objective C object.
6067///
6068/// These are constructed from pointer declarators when the pointee type is
6069/// an ObjCObjectType (or sugar for one).  In addition, the 'id' and 'Class'
6070/// types are typedefs for these, and the protocol-qualified types 'id<P>'
6071/// and 'Class<P>' are translated into these.
6072///
6073/// Pointers to pointers to Objective C objects are still PointerTypes;
6074/// only the first level of pointer gets it own type implementation.
6075class ObjCObjectPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

ObjCObjectPointerType(QualType Canonical, QualType Pointee)
    : Type(ObjCObjectPointer, Canonical, Pointee->getDependence()),
      PointeeType(Pointee) {}

6084public:
/// Gets the type pointed to by this ObjC pointer.
/// The result will always be an ObjCObjectType or sugar thereof.
QualType getPointeeType() const { return PointeeType; }

/// Gets the type pointed to by this ObjC pointer.  Always returns non-null.
///
/// This method is equivalent to getPointeeType() except that
/// it discards any typedefs (or other sugar) between this
/// type and the "outermost" object type.  So for:
/// \code
///   \@class A; \@protocol P; \@protocol Q;
///   typedef A<P> AP;
///   typedef A A1;
///   typedef A1<P> A1P;
///   typedef A1P<Q> A1PQ;
/// \endcode
/// For 'A*', getObjectType() will return 'A'.
/// For 'A<P>*', getObjectType() will return 'A<P>'.
/// For 'AP*', getObjectType() will return 'A<P>'.
/// For 'A1*', getObjectType() will return 'A'.
/// For 'A1<P>*', getObjectType() will return 'A1<P>'.
/// For 'A1P*', getObjectType() will return 'A1<P>'.
/// For 'A1PQ*', getObjectType() will return 'A1<Q>', because
///   adding protocols to a protocol-qualified base discards the
///   old qualifiers (for now).  But if it didn't, getObjectType()
///   would return 'A1P<Q>' (and we'd have to make iterating over
///   qualifiers more complicated).
const ObjCObjectType *getObjectType() const {
  return PointeeType->castAs<ObjCObjectType>();
}

/// If this pointer points to an Objective C
/// \@interface type, gets the type for that interface.  Any protocol
/// qualifiers on the interface are ignored.
///
/// \return null if the base type for this pointer is 'id' or 'Class'
const ObjCInterfaceType *getInterfaceType() const;

/// If this pointer points to an Objective \@interface
/// type, gets the declaration for that interface.
///
/// \return null if the base type for this pointer is 'id' or 'Class'
ObjCInterfaceDecl *getInterfaceDecl() const {
  return getObjectType()->getInterface();
}

/// True if this is equivalent to the 'id' type, i.e. if
/// its object type is the primitive 'id' type with no protocols.
bool isObjCIdType() const {
  return getObjectType()->isObjCUnqualifiedId();
}

/// True if this is equivalent to the 'Class' type,
/// i.e. if its object tive is the primitive 'Class' type with no protocols.
bool isObjCClassType() const {
  return getObjectType()->isObjCUnqualifiedClass();
}

/// True if this is equivalent to the 'id' or 'Class' type,
bool isObjCIdOrClassType() const {
  return getObjectType()->isObjCUnqualifiedIdOrClass();
}

/// True if this is equivalent to 'id<P>' for some non-empty set of
/// protocols.
bool isObjCQualifiedIdType() const {
  return getObjectType()->isObjCQualifiedId();
}

/// True if this is equivalent to 'Class<P>' for some non-empty set of
/// protocols.
bool isObjCQualifiedClassType() const {
  return getObjectType()->isObjCQualifiedClass();
}

/// Whether this is a "__kindof" type.
bool isKindOfType() const { return getObjectType()->isKindOfType(); }

/// Whether this type is specialized, meaning that it has type arguments.
bool isSpecialized() const { return getObjectType()->isSpecialized(); }

/// Whether this type is specialized, meaning that it has type arguments.
bool isSpecializedAsWritten() const {
  return getObjectType()->isSpecializedAsWritten();
}

/// Whether this type is unspecialized, meaning that is has no type arguments.
bool isUnspecialized() const { return getObjectType()->isUnspecialized(); }

/// Determine whether this object type is "unspecialized" as
/// written, meaning that it has no type arguments.
bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }

/// Retrieve the type arguments for this type.
ArrayRef<QualType> getTypeArgs() const {
  return getObjectType()->getTypeArgs();
}

/// Retrieve the type arguments for this type.
ArrayRef<QualType> getTypeArgsAsWritten() const {
  return getObjectType()->getTypeArgsAsWritten();
}

/// An iterator over the qualifiers on the object type.  Provided
/// for convenience.  This will always iterate over the full set of
/// protocols on a type, not just those provided directly.
using qual_iterator = ObjCObjectType::qual_iterator;
using qual_range = llvm::iterator_range<qual_iterator>;

qual_range quals() const { return qual_range(qual_begin(), qual_end()); }

qual_iterator qual_begin() const {
  return getObjectType()->qual_begin();
}

qual_iterator qual_end() const {
  return getObjectType()->qual_end();
}

bool qual_empty() const { return getObjectType()->qual_empty(); }

/// Return the number of qualifying protocols on the object type.
unsigned getNumProtocols() const {
  return getObjectType()->getNumProtocols();
}

/// Retrieve a qualifying protocol by index on the object type.
ObjCProtocolDecl *getProtocol(unsigned I) const {
  return getObjectType()->getProtocol(I);
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

/// Retrieve the type of the superclass of this object pointer type.
///
/// This operation substitutes any type arguments into the
/// superclass of the current class type, potentially producing a
/// pointer to a specialization of the superclass type. Produces a
/// null type if there is no superclass.
QualType getSuperClassType() const;

/// Strip off the Objective-C "kindof" type and (with it) any
/// protocol qualifiers.
const ObjCObjectPointerType *stripObjCKindOfTypeAndQuals(
                               const ASTContext &ctx) const;

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPointeeType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
  ID.AddPointer(T.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCObjectPointer;
}
6243};

6245class AtomicType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ValueType;

AtomicType(QualType ValTy, QualType Canonical)
    : Type(Atomic, Canonical, ValTy->getDependence()), ValueType(ValTy) {}

6253public:
/// Gets the type contained by this atomic type, i.e.
/// the type returned by performing an atomic load of this atomic type.
QualType getValueType() const { return ValueType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getValueType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
  ID.AddPointer(T.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Atomic;
}
6272};

6274/// PipeType - OpenCL20.
6275class PipeType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ElementType;
bool isRead;

PipeType(QualType elemType, QualType CanonicalPtr, bool isRead)
    : Type(Pipe, CanonicalPtr, elemType->getDependence()),
      ElementType(elemType), isRead(isRead) {}

6285public:
QualType getElementType() const { return ElementType; }

bool isSugared() const { return false; }

QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), isReadOnly());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType T, bool isRead) {
  ID.AddPointer(T.getAsOpaquePtr());
  ID.AddBoolean(isRead);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Pipe;
}

bool isReadOnly() const { return isRead; }
6306};

6308/// A fixed int type of a specified bitwidth.
6309class ExtIntType final : public Type, public llvm::FoldingSetNode {
friend class ASTContext;
unsigned IsUnsigned : 1;
unsigned NumBits : 24;

6314protected:
ExtIntType(bool isUnsigned, unsigned NumBits);

6317public:
bool isUnsigned() const { return IsUnsigned; }
bool isSigned() const { return !IsUnsigned; }
unsigned getNumBits() const { return NumBits; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, isUnsigned(), getNumBits());
}

static void Profile(llvm::FoldingSetNodeID &ID, bool IsUnsigned,
                    unsigned NumBits) {
  ID.AddBoolean(IsUnsigned);
  ID.AddInteger(NumBits);
}

static bool classof(const Type *T) { return T->getTypeClass() == ExtInt; }
6336};

6338class DependentExtIntType final : public Type, public llvm::FoldingSetNode {
friend class ASTContext;
const ASTContext &Context;
llvm::PointerIntPair<Expr*, 1, bool> ExprAndUnsigned;

6343protected:
DependentExtIntType(const ASTContext &Context, bool IsUnsigned,
                    Expr *NumBits);

6347public:
bool isUnsigned() const;
bool isSigned() const { return !isUnsigned(); }
Expr *getNumBitsExpr() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, isUnsigned(), getNumBitsExpr());
}
static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    bool IsUnsigned, Expr *NumBitsExpr);

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentExtInt;
}
6364};

6366/// A qualifier set is used to build a set of qualifiers.
6367class QualifierCollector : public Qualifiers {
6368public:
QualifierCollector(Qualifiers Qs = Qualifiers()) : Qualifiers(Qs) {}

/// Collect any qualifiers on the given type and return an
/// unqualified type.  The qualifiers are assumed to be consistent
/// with those already in the type.
const Type *strip(QualType type) {
  addFastQualifiers(type.getLocalFastQualifiers());
  if (!type.hasLocalNonFastQualifiers())
    return type.getTypePtrUnsafe();

  const ExtQuals *extQuals = type.getExtQualsUnsafe();
  addConsistentQualifiers(extQuals->getQualifiers());
  return extQuals->getBaseType();
}

/// Apply the collected qualifiers to the given type.
QualType apply(const ASTContext &Context, QualType QT) const;

/// Apply the collected qualifiers to the given type.
QualType apply(const ASTContext &Context, const Type* T) const;
6389};

6391/// A container of type source information.
6392///
6393/// A client can read the relevant info using TypeLoc wrappers, e.g:
6394/// @code
6395/// TypeLoc TL = TypeSourceInfo->getTypeLoc();
6396/// TL.getBeginLoc().print(OS, SrcMgr);
6397/// @endcode
6398class alignas(8) TypeSourceInfo {
// Contains a memory block after the class, used for type source information,
// allocated by ASTContext.
friend class ASTContext;

QualType Ty;

TypeSourceInfo(QualType ty) : Ty(ty) {}

6407public:
/// Return the type wrapped by this type source info.
QualType getType() const { return Ty; }

/// Return the TypeLoc wrapper for the type source info.
TypeLoc getTypeLoc() const; // implemented in TypeLoc.h

/// Override the type stored in this TypeSourceInfo. Use with caution!
void overrideType(QualType T) { Ty = T; }
6416};

6418// Inline function definitions.

6420inline SplitQualType SplitQualType::getSingleStepDesugaredType() const {
SplitQualType desugar =
  Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
desugar.Quals.addConsistentQualifiers(Quals);
return desugar;
6425}

6427inline const Type *QualType::getTypePtr() const {
return getCommonPtr()->BaseType;
6429}

6431inline const Type *QualType::getTypePtrOrNull() const {
return (isNull() ? nullptr : getCommonPtr()->BaseType);
6433}

6435inline SplitQualType QualType::split() const {
if (!hasLocalNonFastQualifiers())
  return SplitQualType(getTypePtrUnsafe(),
                       Qualifiers::fromFastMask(getLocalFastQualifiers()));

const ExtQuals *eq = getExtQualsUnsafe();
Qualifiers qs = eq->getQualifiers();
qs.addFastQualifiers(getLocalFastQualifiers());
return SplitQualType(eq->getBaseType(), qs);
6444}

6446inline Qualifiers QualType::getLocalQualifiers() const {
Qualifiers Quals;
if (hasLocalNonFastQualifiers())
  Quals = getExtQualsUnsafe()->getQualifiers();
Quals.addFastQualifiers(getLocalFastQualifiers());
return Quals;
6452}

6454inline Qualifiers QualType::getQualifiers() const {
Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
quals.addFastQualifiers(getLocalFastQualifiers());
return quals;
6458}

6460inline unsigned QualType::getCVRQualifiers() const {
unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
cvr |= getLocalCVRQualifiers();
return cvr;
6464}

6466inline QualType QualType::getCanonicalType() const {
QualType canon = getCommonPtr()->CanonicalType;
return canon.withFastQualifiers(getLocalFastQualifiers());
6469}

6471inline bool QualType::isCanonical() const {
return getTypePtr()->isCanonicalUnqualified();
6473}

6475inline bool QualType::isCanonicalAsParam() const {
if (!isCanonical()) return false;
if (hasLocalQualifiers()) return false;

const Type *T = getTypePtr();
if (T->isVariablyModifiedType() && T->hasSizedVLAType())
  return false;

return !isa<FunctionType>(T) && !isa<ArrayType>(T);
6484}

6486inline bool QualType::isConstQualified() const {
return isLocalConstQualified() ||
       getCommonPtr()->CanonicalType.isLocalConstQualified();
6489}

6491inline bool QualType::isRestrictQualified() const {
return isLocalRestrictQualified() ||
       getCommonPtr()->CanonicalType.isLocalRestrictQualified();
6494}


6497inline bool QualType::isVolatileQualified() const {
return isLocalVolatileQualified() ||
       getCommonPtr()->CanonicalType.isLocalVolatileQualified();
6500}

6502inline bool QualType::hasQualifiers() const {
return hasLocalQualifiers() ||
       getCommonPtr()->CanonicalType.hasLocalQualifiers();
6505}

6507inline QualType QualType::getUnqualifiedType() const {
if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
  return QualType(getTypePtr(), 0);

return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
6512}

6514inline SplitQualType QualType::getSplitUnqualifiedType() const {
if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
  return split();

return getSplitUnqualifiedTypeImpl(*this);
6519}

6521inline void QualType::removeLocalConst() {
removeLocalFastQualifiers(Qualifiers::Const);
6523}

6525inline void QualType::removeLocalRestrict() {
removeLocalFastQualifiers(Qualifiers::Restrict);
6527}

6529inline void QualType::removeLocalVolatile() {
removeLocalFastQualifiers(Qualifiers::Volatile);
6531}

6533inline void QualType::removeLocalCVRQualifiers(unsigned Mask) {
assert(!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits")((void)0);
static_assert((int)Qualifiers::CVRMask == (int)Qualifiers::FastMask,
              "Fast bits differ from CVR bits!");

// Fast path: we don't need to touch the slow qualifiers.
removeLocalFastQualifiers(Mask);
6540}

6542/// Check if this type has any address space qualifier.
6543inline bool QualType::hasAddressSpace() const {
return getQualifiers().hasAddressSpace();
6545}

6547/// Return the address space of this type.
6548inline LangAS QualType::getAddressSpace() const {
return getQualifiers().getAddressSpace();
6550}

6552/// Return the gc attribute of this type.
6553inline Qualifiers::GC QualType::getObjCGCAttr() const {
return getQualifiers().getObjCGCAttr();
6555}

6557inline bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveDefaultInitializeCUnion(RD);
return false;
6561}

6563inline bool QualType::hasNonTrivialToPrimitiveDestructCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveDestructCUnion(RD);
return false;
6567}

6569inline bool QualType::hasNonTrivialToPrimitiveCopyCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveCopyCUnion(RD);
return false;
6573}

6575inline FunctionType::ExtInfo getFunctionExtInfo(const Type &t) {
if (const auto *PT = t.getAs<PointerType>()) {
  if (const auto *FT = PT->getPointeeType()->getAs<FunctionType>())
    return FT->getExtInfo();
} else if (const auto *FT = t.getAs<FunctionType>())
  return FT->getExtInfo();

return FunctionType::ExtInfo();
6583}

6585inline FunctionType::ExtInfo getFunctionExtInfo(QualType t) {
return getFunctionExtInfo(*t);
6587}

6589/// Determine whether this type is more
6590/// qualified than the Other type. For example, "const volatile int"
6591/// is more qualified than "const int", "volatile int", and
6592/// "int". However, it is not more qualified than "const volatile
6593/// int".
6594inline bool QualType::isMoreQualifiedThan(QualType other) const {
Qualifiers MyQuals = getQualifiers();
Qualifiers OtherQuals = other.getQualifiers();
return (MyQuals != OtherQuals && MyQuals.compatiblyIncludes(OtherQuals));
6598}

6600/// Determine whether this type is at last
6601/// as qualified as the Other type. For example, "const volatile
6602/// int" is at least as qualified as "const int", "volatile int",
6603/// "int", and "const volatile int".
6604inline bool QualType::isAtLeastAsQualifiedAs(QualType other) const {
Qualifiers OtherQuals = other.getQualifiers();

// Ignore __unaligned qualifier if this type is a void.
if (getUnqualifiedType()->isVoidType())
  OtherQuals.removeUnaligned();

return getQualifiers().compatiblyIncludes(OtherQuals);
6612}

6614/// If Type is a reference type (e.g., const
6615/// int&), returns the type that the reference refers to ("const
6616/// int"). Otherwise, returns the type itself. This routine is used
6617/// throughout Sema to implement C++ 5p6:
6618///
6619///   If an expression initially has the type "reference to T" (8.3.2,
6620///   8.5.3), the type is adjusted to "T" prior to any further
6621///   analysis, the expression designates the object or function
6622///   denoted by the reference, and the expression is an lvalue.
6623inline QualType QualType::getNonReferenceType() const {
if (const auto *RefType = (*this)->getAs<ReferenceType>())
  return RefType->getPointeeType();
else
  return *this;
6628}

6630inline bool QualType::isCForbiddenLValueType() const {
return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
        getTypePtr()->isFunctionType());
6633}

6635/// Tests whether the type is categorized as a fundamental type.
6636///
6637/// \returns True for types specified in C++0x [basic.fundamental].
6638inline bool Type::isFundamentalType() const {
return isVoidType() ||
       isNullPtrType() ||
       // FIXME: It's really annoying that we don't have an
       // 'isArithmeticType()' which agrees with the standard definition.
       (isArithmeticType() && !isEnumeralType());
6644}

6646/// Tests whether the type is categorized as a compound type.
6647///
6648/// \returns True for types specified in C++0x [basic.compound].
6649inline bool Type::isCompoundType() const {
// C++0x [basic.compound]p1:
//   Compound types can be constructed in the following ways:
//    -- arrays of objects of a given type [...];
return isArrayType() ||
//    -- functions, which have parameters of given types [...];
       isFunctionType() ||
//    -- pointers to void or objects or functions [...];
       isPointerType() ||
//    -- references to objects or functions of a given type. [...]
       isReferenceType() ||
//    -- classes containing a sequence of objects of various types, [...];
       isRecordType() ||
//    -- unions, which are classes capable of containing objects of different
//               types at different times;
       isUnionType() ||
//    -- enumerations, which comprise a set of named constant values. [...];
       isEnumeralType() ||
//    -- pointers to non-static class members, [...].
       isMemberPointerType();
6669}

6671inline bool Type::isFunctionType() const {
return isa<FunctionType>(CanonicalType);
6673}

6675inline bool Type::isPointerType() const {
return isa<PointerType>(CanonicalType);
6677}

6679inline bool Type::isAnyPointerType() const {
return isPointerType() || isObjCObjectPointerType();
6681}

6683inline bool Type::isBlockPointerType() const {
return isa<BlockPointerType>(CanonicalType);
6685}

6687inline bool Type::isReferenceType() const {
return isa<ReferenceType>(CanonicalType);
6689}

6691inline bool Type::isLValueReferenceType() const {
return isa<LValueReferenceType>(CanonicalType);
6693}

6695inline bool Type::isRValueReferenceType() const {
return isa<RValueReferenceType>(CanonicalType);
6697}

6699inline bool Type::isObjectPointerType() const {
// Note: an "object pointer type" is not the same thing as a pointer to an
// object type; rather, it is a pointer to an object type or a pointer to cv
// void.
if (const auto *T = getAs<PointerType>())
  return !T->getPointeeType()->isFunctionType();
else
  return false;
6707}

6709inline bool Type::isFunctionPointerType() const {
if (const auto *T = getAs<PointerType>())
  return T->getPointeeType()->isFunctionType();
else
  return false;
6714}

6716inline bool Type::isFunctionReferenceType() const {
if (const auto *T = getAs<ReferenceType>())
  return T->getPointeeType()->isFunctionType();
else
  return false;
6721}

6723inline bool Type::isMemberPointerType() const {
return isa<MemberPointerType>(CanonicalType);
6725}

6727inline bool Type::isMemberFunctionPointerType() const {
if (const auto *T = getAs<MemberPointerType>())
  return T->isMemberFunctionPointer();
else
  return false;
6732}

6734inline bool Type::isMemberDataPointerType() const {
if (const auto *T = getAs<MemberPointerType>())
  return T->isMemberDataPointer();
else
  return false;
6739}

6741inline bool Type::isArrayType() const {
return isa<ArrayType>(CanonicalType);
6743}

6745inline bool Type::isConstantArrayType() const {
return isa<ConstantArrayType>(CanonicalType);
6747}

6749inline bool Type::isIncompleteArrayType() const {
return isa<IncompleteArrayType>(CanonicalType);
6751}

6753inline bool Type::isVariableArrayType() const {
return isa<VariableArrayType>(CanonicalType);
6755}

6757inline bool Type::isDependentSizedArrayType() const {
return isa<DependentSizedArrayType>(CanonicalType);
6759}

6761inline bool Type::isBuiltinType() const {
return isa<BuiltinType>(CanonicalType);
6763}

6765inline bool Type::isRecordType() const {
return isa<RecordType>(CanonicalType);
15
←
Assuming field 'CanonicalType' is a 'RecordType'→
16
←
Returning the value 1, which participates in a condition later→
6767}

6769inline bool Type::isEnumeralType() const {
return isa<EnumType>(CanonicalType);
6771}

6773inline bool Type::isAnyComplexType() const {
return isa<ComplexType>(CanonicalType);
6775}

6777inline bool Type::isVectorType() const {
return isa<VectorType>(CanonicalType);
6779}

6781inline bool Type::isExtVectorType() const {
return isa<ExtVectorType>(CanonicalType);
6783}

6785inline bool Type::isMatrixType() const {
return isa<MatrixType>(CanonicalType);
6787}

6789inline bool Type::isConstantMatrixType() const {
return isa<ConstantMatrixType>(CanonicalType);
6791}

6793inline bool Type::isDependentAddressSpaceType() const {
return isa<DependentAddressSpaceType>(CanonicalType);
6795}

6797inline bool Type::isObjCObjectPointerType() const {
return isa<ObjCObjectPointerType>(CanonicalType);
6799}

6801inline bool Type::isObjCObjectType() const {
return isa<ObjCObjectType>(CanonicalType);
6803}

6805inline bool Type::isObjCObjectOrInterfaceType() const {
return isa<ObjCInterfaceType>(CanonicalType) ||
  isa<ObjCObjectType>(CanonicalType);
6808}

6810inline bool Type::isAtomicType() const {
return isa<AtomicType>(CanonicalType);
6812}

6814inline bool Type::isUndeducedAutoType() const {
return isa<AutoType>(CanonicalType);
6816}

6818inline bool Type::isObjCQualifiedIdType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCQualifiedIdType();
return false;
6822}

6824inline bool Type::isObjCQualifiedClassType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCQualifiedClassType();
return false;
6828}

6830inline bool Type::isObjCIdType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCIdType();
return false;
6834}

6836inline bool Type::isObjCClassType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCClassType();
return false;
6840}

6842inline bool Type::isObjCSelType() const {
if (const auto *OPT = getAs<PointerType>())
  return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
return false;
6846}

6848inline bool Type::isObjCBuiltinType() const {
return isObjCIdType() || isObjCClassType() || isObjCSelType();
6850}

6852inline bool Type::isDecltypeType() const {
return isa<DecltypeType>(this);
6854}

6856#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
inline bool Type::is##Id##Type() const { \
  return isSpecificBuiltinType(BuiltinType::Id); \
}
6860#include "clang/Basic/OpenCLImageTypes.def"

6862inline bool Type::isSamplerT() const {
return isSpecificBuiltinType(BuiltinType::OCLSampler);
6864}

6866inline bool Type::isEventT() const {
return isSpecificBuiltinType(BuiltinType::OCLEvent);
6868}

6870inline bool Type::isClkEventT() const {
return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
6872}

6874inline bool Type::isQueueT() const {
return isSpecificBuiltinType(BuiltinType::OCLQueue);
6876}

6878inline bool Type::isReserveIDT() const {
return isSpecificBuiltinType(BuiltinType::OCLReserveID);
6880}

6882inline bool Type::isImageType() const {
6883#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
return
6885#include "clang/Basic/OpenCLImageTypes.def"
    false; // end boolean or operation
6887}

6889inline bool Type::isPipeType() const {
return isa<PipeType>(CanonicalType);
6891}

6893inline bool Type::isExtIntType() const {
return isa<ExtIntType>(CanonicalType);
6895}

6897#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
inline bool Type::is##Id##Type() const { \
  return isSpecificBuiltinType(BuiltinType::Id); \
}
6901#include "clang/Basic/OpenCLExtensionTypes.def"

6903inline bool Type::isOCLIntelSubgroupAVCType() const {
6904#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
isOCLIntelSubgroupAVC##Id##Type() ||
return
6907#include "clang/Basic/OpenCLExtensionTypes.def"
  false; // end of boolean or operation
6909}

6911inline bool Type::isOCLExtOpaqueType() const {
6912#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
return
6914#include "clang/Basic/OpenCLExtensionTypes.def"
  false; // end of boolean or operation
6916}

6918inline bool Type::isOpenCLSpecificType() const {
return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
       isQueueT() || isReserveIDT() || isPipeType() || isOCLExtOpaqueType();
6921}

6923inline bool Type::isTemplateTypeParmType() const {
return isa<TemplateTypeParmType>(CanonicalType);
6925}

6927inline bool Type::isSpecificBuiltinType(unsigned K) const {
if (const BuiltinType *BT = getAs<BuiltinType>()) {
  return BT->getKind() == static_cast<BuiltinType::Kind>(K);
}
return false;
6932}

6934inline bool Type::isPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return BT->isPlaceholderType();
return false;
6938}

6940inline const BuiltinType *Type::getAsPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  if (BT->isPlaceholderType())
    return BT;
return nullptr;
6945}

6947inline bool Type::isSpecificPlaceholderType(unsigned K) const {
assert(BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K))((void)0);
return isSpecificBuiltinType(K);
6950}

6952inline bool Type::isNonOverloadPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return BT->isNonOverloadPlaceholderType();
return false;
6956}

6958inline bool Type::isVoidType() const {
return isSpecificBuiltinType(BuiltinType::Void);
6960}

6962inline bool Type::isHalfType() const {
// FIXME: Should we allow complex __fp16? Probably not.
return isSpecificBuiltinType(BuiltinType::Half);
6965}

6967inline bool Type::isFloat16Type() const {
return isSpecificBuiltinType(BuiltinType::Float16);
6969}

6971inline bool Type::isBFloat16Type() const {
return isSpecificBuiltinType(BuiltinType::BFloat16);
6973}

6975inline bool Type::isFloat128Type() const {
return isSpecificBuiltinType(BuiltinType::Float128);
6977}

6979inline bool Type::isNullPtrType() const {
return isSpecificBuiltinType(BuiltinType::NullPtr);
6981}

6983bool IsEnumDeclComplete(EnumDecl *);
6984bool IsEnumDeclScoped(EnumDecl *);

6986inline bool Type::isIntegerType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() >= BuiltinType::Bool &&
         BT->getKind() <= BuiltinType::Int128;
if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
  // Incomplete enum types are not treated as integer types.
  // FIXME: In C++, enum types are never integer types.
  return IsEnumDeclComplete(ET->getDecl()) &&
    !IsEnumDeclScoped(ET->getDecl());
}
return isExtIntType();
6997}

6999inline bool Type::isFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return BT->getKind() >= BuiltinType::ShortAccum &&
         BT->getKind() <= BuiltinType::SatULongFract;
}
return false;
7005}

7007inline bool Type::isFixedPointOrIntegerType() const {
return isFixedPointType() || isIntegerType();
7009}

7011inline bool Type::isSaturatedFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return BT->getKind() >= BuiltinType::SatShortAccum &&
         BT->getKind() <= BuiltinType::SatULongFract;
}
return false;
7017}

7019inline bool Type::isUnsaturatedFixedPointType() const {
return isFixedPointType() && !isSaturatedFixedPointType();
7021}

7023inline bool Type::isSignedFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return ((BT->getKind() >= BuiltinType::ShortAccum &&
           BT->getKind() <= BuiltinType::LongAccum) ||
          (BT->getKind() >= BuiltinType::ShortFract &&
           BT->getKind() <= BuiltinType::LongFract) ||
          (BT->getKind() >= BuiltinType::SatShortAccum &&
           BT->getKind() <= BuiltinType::SatLongAccum) ||
          (BT->getKind() >= BuiltinType::SatShortFract &&
           BT->getKind() <= BuiltinType::SatLongFract));
}
return false;
7035}

7037inline bool Type::isUnsignedFixedPointType() const {
return isFixedPointType() && !isSignedFixedPointType();
7039}

7041inline bool Type::isScalarType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() > BuiltinType::Void &&
         BT->getKind() <= BuiltinType::NullPtr;
if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
  // Enums are scalar types, but only if they are defined.  Incomplete enums
  // are not treated as scalar types.
  return IsEnumDeclComplete(ET->getDecl());
return isa<PointerType>(CanonicalType) ||
       isa<BlockPointerType>(CanonicalType) ||
       isa<MemberPointerType>(CanonicalType) ||
       isa<ComplexType>(CanonicalType) ||
       isa<ObjCObjectPointerType>(CanonicalType) ||
       isExtIntType();
7055}

7057inline bool Type::isIntegralOrEnumerationType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() >= BuiltinType::Bool &&
         BT->getKind() <= BuiltinType::Int128;

// Check for a complete enum type; incomplete enum types are not properly an
// enumeration type in the sense required here.
if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
  return IsEnumDeclComplete(ET->getDecl());

return isExtIntType();
7068}

7070inline bool Type::isBooleanType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Bool;
return false;
7074}

7076inline bool Type::isUndeducedType() const {
auto *DT = getContainedDeducedType();
return DT && !DT->isDeduced();
7079}

7081/// Determines whether this is a type for which one can define
7082/// an overloaded operator.
7083inline bool Type::isOverloadableType() const {
return isDependentType() || isRecordType() || isEnumeralType();
7085}

7087/// Determines whether this type is written as a typedef-name.
7088inline bool Type::isTypedefNameType() const {
if (getAs<TypedefType>())
  return true;
if (auto *TST = getAs<TemplateSpecializationType>())
  return TST->isTypeAlias();
return false;
7094}

7096/// Determines whether this type can decay to a pointer type.
7097inline bool Type::canDecayToPointerType() const {
return isFunctionType() || isArrayType();
7099}

7101inline bool Type::hasPointerRepresentation() const {
return (isPointerType() || isReferenceType() || isBlockPointerType() ||
        isObjCObjectPointerType() || isNullPtrType());
7104}

7106inline bool Type::hasObjCPointerRepresentation() const {
return isObjCObjectPointerType();
7108}

7110inline const Type *Type::getBaseElementTypeUnsafe() const {
const Type *type = this;
while (const ArrayType *arrayType = type->getAsArrayTypeUnsafe())
  type = arrayType->getElementType().getTypePtr();
return type;
7115}

7117inline const Type *Type::getPointeeOrArrayElementType() const {
const Type *type = this;
if (type->isAnyPointerType())
  return type->getPointeeType().getTypePtr();
else if (type->isArrayType())
  return type->getBaseElementTypeUnsafe();
return type;
7124}
7125/// Insertion operator for partial diagnostics. This allows sending adress
7126/// spaces into a diagnostic with <<.
7127inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
                                           LangAS AS) {
PD.AddTaggedVal(static_cast<std::underlying_type_t<LangAS>>(AS),
                DiagnosticsEngine::ArgumentKind::ak_addrspace);
return PD;
7132}

7134/// Insertion operator for partial diagnostics. This allows sending Qualifiers
7135/// into a diagnostic with <<.
7136inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
                                           Qualifiers Q) {
PD.AddTaggedVal(Q.getAsOpaqueValue(),
                DiagnosticsEngine::ArgumentKind::ak_qual);
return PD;
7141}

7143/// Insertion operator for partial diagnostics.  This allows sending QualType's
7144/// into a diagnostic with <<.
7145inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
                                           QualType T) {
PD.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
                DiagnosticsEngine::ak_qualtype);
return PD;
7150}

7152// Helper class template that is used by Type::getAs to ensure that one does
7153// not try to look through a qualified type to get to an array type.
7154template <typename T>
7155using TypeIsArrayType =
  std::integral_constant<bool, std::is_same<T, ArrayType>::value ||
                                   std::is_base_of<ArrayType, T>::value>;

7159// Member-template getAs<specific type>'.
7160template <typename T> const T *Type::getAs() const {
static_assert(!TypeIsArrayType<T>::value,
              "ArrayType cannot be used with getAs!");

// If this is directly a T type, return it.
if (const auto *Ty = dyn_cast<T>(this))
  return Ty;

// If the canonical form of this type isn't the right kind, reject it.
if (!isa<T>(CanonicalType))
  return nullptr;

// If this is a typedef for the type, strip the typedef off without
// losing all typedef information.
return cast<T>(getUnqualifiedDesugaredType());
7175}

7177template <typename T> const T *Type::getAsAdjusted() const {
static_assert(!TypeIsArrayType<T>::value, "ArrayType cannot be used with getAsAdjusted!");

// If this is directly a T type, return it.
if (const auto *Ty = dyn_cast<T>(this))
  return Ty;

// If the canonical form of this type isn't the right kind, reject it.
if (!isa<T>(CanonicalType))
  return nullptr;

// Strip off type adjustments that do not modify the underlying nature of the
// type.
const Type *Ty = this;
while (Ty) {
  if (const auto *A = dyn_cast<AttributedType>(Ty))
    Ty = A->getModifiedType().getTypePtr();
  else if (const auto *E = dyn_cast<ElaboratedType>(Ty))
    Ty = E->desugar().getTypePtr();
  else if (const auto *P = dyn_cast<ParenType>(Ty))
    Ty = P->desugar().getTypePtr();
  else if (const auto *A = dyn_cast<AdjustedType>(Ty))
    Ty = A->desugar().getTypePtr();
  else if (const auto *M = dyn_cast<MacroQualifiedType>(Ty))
    Ty = M->desugar().getTypePtr();
  else
    break;
}

// Just because the canonical type is correct does not mean we can use cast<>,
// since we may not have stripped off all the sugar down to the base type.
return dyn_cast<T>(Ty);
7209}

7211inline const ArrayType *Type::getAsArrayTypeUnsafe() const {
// If this is directly an array type, return it.
if (const auto *arr = dyn_cast<ArrayType>(this))
  return arr;

// If the canonical form of this type isn't the right kind, reject it.
if (!isa<ArrayType>(CanonicalType))
  return nullptr;

// If this is a typedef for the type, strip the typedef off without
// losing all typedef information.
return cast<ArrayType>(getUnqualifiedDesugaredType());
7223}

7225template <typename T> const T *Type::castAs() const {
static_assert(!TypeIsArrayType<T>::value,
              "ArrayType cannot be used with castAs!");

if (const auto *ty = dyn_cast<T>(this)) return ty;
assert(isa<T>(CanonicalType))((void)0);
return cast<T>(getUnqualifiedDesugaredType());
7232}

7234inline const ArrayType *Type::castAsArrayTypeUnsafe() const {
assert(isa<ArrayType>(CanonicalType))((void)0);
if (const auto *arr = dyn_cast<ArrayType>(this)) return arr;
return cast<ArrayType>(getUnqualifiedDesugaredType());
7238}

7240DecayedType::DecayedType(QualType OriginalType, QualType DecayedPtr,
                       QualType CanonicalPtr)
  : AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
7243#ifndef NDEBUG1
QualType Adjusted = getAdjustedType();
(void)AttributedType::stripOuterNullability(Adjusted);
assert(isa<PointerType>(Adjusted))((void)0);
7247#endif
7248}

7250QualType DecayedType::getPointeeType() const {
QualType Decayed = getDecayedType();
(void)AttributedType::stripOuterNullability(Decayed);
return cast<PointerType>(Decayed)->getPointeeType();
7254}

7256// Get the decimal string representation of a fixed point type, represented
7257// as a scaled integer.
7258// TODO: At some point, we should change the arguments to instead just accept an
7259// APFixedPoint instead of APSInt and scale.
7260void FixedPointValueToString(SmallVectorImpl<char> &Str, llvm::APSInt Val,
                           unsigned Scale);

7263} // namespace clang

7265#endif // LLVM_CLANG_AST_TYPE_H