//===---- CGObjC.cpp - Emit LLVM Code for Objective-C ---------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This contains code to emit Objective-C code as LLVM code.

//

//===----------------------------------------------------------------------===//

#include "CGDebugInfo.h"

#include "CGObjCRuntime.h"

#include "CodeGenFunction.h"

#include "CodeGenModule.h"

#include "ConstantEmitter.h"

#include "TargetInfo.h"

#include "clang/AST/ASTContext.h"

#include "clang/AST/Attr.h"

#include "clang/AST/DeclObjC.h"

#include "clang/AST/StmtObjC.h"

#include "clang/Basic/Diagnostic.h"

#include "clang/CodeGen/CGFunctionInfo.h"

#include "clang/CodeGen/CodeGenABITypes.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/Analysis/ObjCARCUtil.h"

#include "llvm/BinaryFormat/MachO.h"

#include "llvm/IR/Constants.h"

#include "llvm/IR/DataLayout.h"

#include "llvm/IR/InlineAsm.h"

#include <optional>

using namespace clang;

using namespace CodeGen;

typedef llvm::PointerIntPair<llvm::Value*,1,bool> TryEmitResult;

static TryEmitResult

tryEmitARCRetainScalarExpr(CodeGenFunction &CGF, const Expr *e);

static RValue AdjustObjCObjectType(CodeGenFunction &CGF,

                                   QualType ET,

                                   RValue Result);

/// Given the address of a variable of pointer type, find the correct

/// null to store into it.

static llvm::Constant *getNullForVariable(Address addr) {

  llvm::Type *type = addr.getElementType();

  return llvm::ConstantPointerNull::get(cast<llvm::PointerType>(type));

}

/// Emits an instance of NSConstantString representing the object.

llvm::Value *CodeGenFunction::EmitObjCStringLiteral(const ObjCStringLiteral *E)

{

  llvm::Constant *C =

      CGM.getObjCRuntime().GenerateConstantString(E->getString()).getPointer();

  return C;

}

/// EmitObjCBoxedExpr - This routine generates code to call

/// the appropriate expression boxing method. This will either be

/// one of +[NSNumber numberWith<Type>:], or +[NSString stringWithUTF8String:],

/// or [NSValue valueWithBytes:objCType:].

///

llvm::Value *

CodeGenFunction::EmitObjCBoxedExpr(const ObjCBoxedExpr *E) {

  // Generate the correct selector for this literal's concrete type.

  // Get the method.

  const ObjCMethodDecl *BoxingMethod = E->getBoxingMethod();

  const Expr *SubExpr = E->getSubExpr();

  if (E->isExpressibleAsConstantInitializer()) {

    ConstantEmitter ConstEmitter(CGM);

    return ConstEmitter.tryEmitAbstract(E, E->getType());

  }

  assert(BoxingMethod->isClassMethod() && "BoxingMethod must be a class method");

  Selector Sel = BoxingMethod->getSelector();

  // Generate a reference to the class pointer, which will be the receiver.

  // Assumes that the method was introduced in the class that should be

  // messaged (avoids pulling it out of the result type).

  CGObjCRuntime &Runtime = CGM.getObjCRuntime();

  const ObjCInterfaceDecl *ClassDecl = BoxingMethod->getClassInterface();

  llvm::Value *Receiver = Runtime.GetClass(*this, ClassDecl);

  CallArgList Args;

  const ParmVarDecl *ArgDecl = *BoxingMethod->param_begin();

  QualType ArgQT = ArgDecl->getType().getUnqualifiedType();

  // ObjCBoxedExpr supports boxing of structs and unions

  // via [NSValue valueWithBytes:objCType:]

  const QualType ValueType(SubExpr->getType().getCanonicalType());

  if (ValueType->isObjCBoxableRecordType()) {

    // Emit CodeGen for first parameter

    // and cast value to correct type

    Address Temporary = CreateMemTemp(SubExpr->getType());

    EmitAnyExprToMem(SubExpr, Temporary, Qualifiers(), /*isInit*/ true);

    llvm::Value *BitCast =

        Builder.CreateBitCast(Temporary.getPointer(), ConvertType(ArgQT));

    Args.add(RValue::get(BitCast), ArgQT);

    // Create char array to store type encoding

    std::string Str;

    getContext().getObjCEncodingForType(ValueType, Str);

    llvm::Constant *GV = CGM.GetAddrOfConstantCString(Str).getPointer();

    // Cast type encoding to correct type

    const ParmVarDecl *EncodingDecl = BoxingMethod->parameters()[1];

    QualType EncodingQT = EncodingDecl->getType().getUnqualifiedType();

    llvm::Value *Cast = Builder.CreateBitCast(GV, ConvertType(EncodingQT));

    Args.add(RValue::get(Cast), EncodingQT);

  } else {

    Args.add(EmitAnyExpr(SubExpr), ArgQT);

  }

  RValue result = Runtime.GenerateMessageSend(

      *this, ReturnValueSlot(), BoxingMethod->getReturnType(), Sel, Receiver,

      Args, ClassDecl, BoxingMethod);

  return Builder.CreateBitCast(result.getScalarVal(),

                               ConvertType(E->getType()));

}

llvm::Value *CodeGenFunction::EmitObjCCollectionLiteral(const Expr *E,

                                    const ObjCMethodDecl *MethodWithObjects) {

  ASTContext &Context = CGM.getContext();

  const ObjCDictionaryLiteral *DLE = nullptr;

  const ObjCArrayLiteral *ALE = dyn_cast<ObjCArrayLiteral>(E);

  if (!ALE)

    DLE = cast<ObjCDictionaryLiteral>(E);

  // Optimize empty collections by referencing constants, when available.

  uint64_t NumElements =

    ALE ? ALE->getNumElements() : DLE->getNumElements();

  if (NumElements == 0 && CGM.getLangOpts().ObjCRuntime.hasEmptyCollections()) {

    StringRef ConstantName = ALE ? "__NSArray0__" : "__NSDictionary0__";

    QualType IdTy(CGM.getContext().getObjCIdType());

    llvm::Constant *Constant =

        CGM.CreateRuntimeVariable(ConvertType(IdTy), ConstantName);

    LValue LV = MakeNaturalAlignAddrLValue(Constant, IdTy);

    llvm::Value *Ptr = EmitLoadOfScalar(LV, E->getBeginLoc());

    cast<llvm::LoadInst>(Ptr)->setMetadata(

        llvm::LLVMContext::MD_invariant_load,

        llvm::MDNode::get(getLLVMContext(), std::nullopt));

    return Builder.CreateBitCast(Ptr, ConvertType(E->getType()));

  }

  // Compute the type of the array we're initializing.

  llvm::APInt APNumElements(Context.getTypeSize(Context.getSizeType()),

                            NumElements);

  QualType ElementType = Context.getObjCIdType().withConst();

  QualType ElementArrayType = Context.getConstantArrayType(

      ElementType, APNumElements, nullptr, ArraySizeModifier::Normal,

      /*IndexTypeQuals=*/0);

  // Allocate the temporary array(s).

  Address Objects = CreateMemTemp(ElementArrayType, "objects");

  Address Keys = Address::invalid();

  if (DLE)

    Keys = CreateMemTemp(ElementArrayType, "keys");

  // In ARC, we may need to do extra work to keep all the keys and

  // values alive until after the call.

  SmallVector<llvm::Value *, 16> NeededObjects;

  bool TrackNeededObjects =

    (getLangOpts().ObjCAutoRefCount &&

    CGM.getCodeGenOpts().OptimizationLevel != 0);

  // Perform the actual initialialization of the array(s).

  for (uint64_t i = 0; i < NumElements; i++) {

    if (ALE) {

      // Emit the element and store it to the appropriate array slot.

      const Expr *Rhs = ALE->getElement(i);

      LValue LV = MakeAddrLValue(Builder.CreateConstArrayGEP(Objects, i),

                                 ElementType, AlignmentSource::Decl);

      llvm::Value *value = EmitScalarExpr(Rhs);

      EmitStoreThroughLValue(RValue::get(value), LV, true);

      if (TrackNeededObjects) {

        NeededObjects.push_back(value);

      }

    } else {

      // Emit the key and store it to the appropriate array slot.

      const Expr *Key = DLE->getKeyValueElement(i).Key;

      LValue KeyLV = MakeAddrLValue(Builder.CreateConstArrayGEP(Keys, i),

                                    ElementType, AlignmentSource::Decl);

      llvm::Value *keyValue = EmitScalarExpr(Key);

      EmitStoreThroughLValue(RValue::get(keyValue), KeyLV, /*isInit=*/true);

      // Emit the value and store it to the appropriate array slot.

      const Expr *Value = DLE->getKeyValueElement(i).Value;

      LValue ValueLV = MakeAddrLValue(Builder.CreateConstArrayGEP(Objects, i),

                                      ElementType, AlignmentSource::Decl);

      llvm::Value *valueValue = EmitScalarExpr(Value);

      EmitStoreThroughLValue(RValue::get(valueValue), ValueLV, /*isInit=*/true);

      if (TrackNeededObjects) {

        NeededObjects.push_back(keyValue);

        NeededObjects.push_back(valueValue);

      }

    }

  }

  // Generate the argument list.

  CallArgList Args;

  ObjCMethodDecl::param_const_iterator PI = MethodWithObjects->param_begin();

  const ParmVarDecl *argDecl = *PI++;

  QualType ArgQT = argDecl->getType().getUnqualifiedType();

  Args.add(RValue::get(Objects.getPointer()), ArgQT);

  if (DLE) {

    argDecl = *PI++;

    ArgQT = argDecl->getType().getUnqualifiedType();

    Args.add(RValue::get(Keys.getPointer()), ArgQT);

  }

  argDecl = *PI;

  ArgQT = argDecl->getType().getUnqualifiedType();

  llvm::Value *Count =

    llvm::ConstantInt::get(CGM.getTypes().ConvertType(ArgQT), NumElements);

  Args.add(RValue::get(Count), ArgQT);

  // Generate a reference to the class pointer, which will be the receiver.

  Selector Sel = MethodWithObjects->getSelector();

  QualType ResultType = E->getType();

  const ObjCObjectPointerType *InterfacePointerType

    = ResultType->getAsObjCInterfacePointerType();

  assert(InterfacePointerType && "Unexpected InterfacePointerType - null");

  ObjCInterfaceDecl *Class

    = InterfacePointerType->getObjectType()->getInterface();

  CGObjCRuntime &Runtime = CGM.getObjCRuntime();

  llvm::Value *Receiver = Runtime.GetClass(*this, Class);

  // Generate the message send.

  RValue result = Runtime.GenerateMessageSend(

      *this, ReturnValueSlot(), MethodWithObjects->getReturnType(), Sel,

      Receiver, Args, Class, MethodWithObjects);

  // The above message send needs these objects, but in ARC they are

  // passed in a buffer that is essentially __unsafe_unretained.

  // Therefore we must prevent the optimizer from releasing them until

  // after the call.

  if (TrackNeededObjects) {

    EmitARCIntrinsicUse(NeededObjects);

  }

  return Builder.CreateBitCast(result.getScalarVal(),

                               ConvertType(E->getType()));

}

llvm::Value *CodeGenFunction::EmitObjCArrayLiteral(const ObjCArrayLiteral *E) {

  return EmitObjCCollectionLiteral(E, E->getArrayWithObjectsMethod());

}

llvm::Value *CodeGenFunction::EmitObjCDictionaryLiteral(

                                            const ObjCDictionaryLiteral *E) {

  return EmitObjCCollectionLiteral(E, E->getDictWithObjectsMethod());

}

/// Emit a selector.

llvm::Value *CodeGenFunction::EmitObjCSelectorExpr(const ObjCSelectorExpr *E) {

  // Untyped selector.

  // Note that this implementation allows for non-constant strings to be passed

  // as arguments to @selector().  Currently, the only thing preventing this

  // behaviour is the type checking in the front end.

  return CGM.getObjCRuntime().GetSelector(*this, E->getSelector());

}

llvm::Value *CodeGenFunction::EmitObjCProtocolExpr(const ObjCProtocolExpr *E) {

  // FIXME: This should pass the Decl not the name.

  return CGM.getObjCRuntime().GenerateProtocolRef(*this, E->getProtocol());

}

/// Adjust the type of an Objective-C object that doesn't match up due

/// to type erasure at various points, e.g., related result types or the use

/// of parameterized classes.

static RValue AdjustObjCObjectType(CodeGenFunction &CGF, QualType ExpT,

                                   RValue Result) {

  if (!ExpT->isObjCRetainableType())

    return Result;

  // If the converted types are the same, we're done.

  llvm::Type *ExpLLVMTy = CGF.ConvertType(ExpT);

  if (ExpLLVMTy == Result.getScalarVal()->getType())

    return Result;

  // We have applied a substitution. Cast the rvalue appropriately.

  return RValue::get(CGF.Builder.CreateBitCast(Result.getScalarVal(),

                                               ExpLLVMTy));

}

/// Decide whether to extend the lifetime of the receiver of a

/// returns-inner-pointer message.

static bool

shouldExtendReceiverForInnerPointerMessage(const ObjCMessageExpr *message) {

  switch (message->getReceiverKind()) {

  // For a normal instance message, we should extend unless the

  // receiver is loaded from a variable with precise lifetime.

  case ObjCMessageExpr::Instance: {

    const Expr *receiver = message->getInstanceReceiver();

    // Look through OVEs.

    if (auto opaque = dyn_cast<OpaqueValueExpr>(receiver)) {

      if (opaque->getSourceExpr())

        receiver = opaque->getSourceExpr()->IgnoreParens();

    }

    const ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(receiver);

    if (!ice || ice->getCastKind() != CK_LValueToRValue) return true;

    receiver = ice->getSubExpr()->IgnoreParens();

    // Look through OVEs.

    if (auto opaque = dyn_cast<OpaqueValueExpr>(receiver)) {

      if (opaque->getSourceExpr())

        receiver = opaque->getSourceExpr()->IgnoreParens();

    }

    // Only __strong variables.

    if (receiver->getType().getObjCLifetime() != Qualifiers::OCL_Strong)

      return true;

    // All ivars and fields have precise lifetime.

    if (isa<MemberExpr>(receiver) || isa<ObjCIvarRefExpr>(receiver))

      return false;

    // Otherwise, check for variables.

    const DeclRefExpr *declRef = dyn_cast<DeclRefExpr>(ice->getSubExpr());

    if (!declRef) return true;

    const VarDecl *var = dyn_cast<VarDecl>(declRef->getDecl());

    if (!var) return true;

    // All variables have precise lifetime except local variables with

    // automatic storage duration that aren't specially marked.

    return (var->hasLocalStorage() &&

            !var->hasAttr<ObjCPreciseLifetimeAttr>());

  }

  case ObjCMessageExpr::Class:

  case ObjCMessageExpr::SuperClass:

    // It's never necessary for class objects.

    return false;

  case ObjCMessageExpr::SuperInstance:

    // We generally assume that 'self' lives throughout a method call.

    return false;

  }

  llvm_unreachable("invalid receiver kind");

}

/// Given an expression of ObjC pointer type, check whether it was

/// immediately loaded from an ARC __weak l-value.

static const Expr *findWeakLValue(const Expr *E) {

  assert(E->getType()->isObjCRetainableType());

  E = E->IgnoreParens();

  if (auto CE = dyn_cast<CastExpr>(E)) {

    if (CE->getCastKind() == CK_LValueToRValue) {

      if (CE->getSubExpr()->getType().getObjCLifetime() == Qualifiers::OCL_Weak)

        return CE->getSubExpr();

    }

  }

  return nullptr;

}

/// The ObjC runtime may provide entrypoints that are likely to be faster

/// than an ordinary message send of the appropriate selector.

///

/// The entrypoints are guaranteed to be equivalent to just sending the

/// corresponding message.  If the entrypoint is implemented naively as just a

/// message send, using it is a trade-off: it sacrifices a few cycles of

/// overhead to save a small amount of code.  However, it's possible for

/// runtimes to detect and special-case classes that use "standard"

/// behavior; if that's dynamically a large proportion of all objects, using

/// the entrypoint will also be faster than using a message send.

///

/// If the runtime does support a required entrypoint, then this method will

/// generate a call and return the resulting value.  Otherwise it will return

/// std::nullopt and the caller can generate a msgSend instead.

static std::optional<llvm::Value *> tryGenerateSpecializedMessageSend(

    CodeGenFunction &CGF, QualType ResultType, llvm::Value *Receiver,

    const CallArgList &Args, Selector Sel, const ObjCMethodDecl *method,

    bool isClassMessage) {

  auto &CGM = CGF.CGM;

  if (!CGM.getCodeGenOpts().ObjCConvertMessagesToRuntimeCalls)

    return std::nullopt;

  auto &Runtime = CGM.getLangOpts().ObjCRuntime;

  switch (Sel.getMethodFamily()) {

  case OMF_alloc:

    if (isClassMessage &&

        Runtime.shouldUseRuntimeFunctionsForAlloc() &&

        ResultType->isObjCObjectPointerType()) {

        // [Foo alloc] -> objc_alloc(Foo) or

        // [self alloc] -> objc_alloc(self)

        if (Sel.isUnarySelector() && Sel.getNameForSlot(0) == "alloc")

          return CGF.EmitObjCAlloc(Receiver, CGF.ConvertType(ResultType));

        // [Foo allocWithZone:nil] -> objc_allocWithZone(Foo) or

        // [self allocWithZone:nil] -> objc_allocWithZone(self)

        if (Sel.isKeywordSelector() && Sel.getNumArgs() == 1 &&

            Args.size() == 1 && Args.front().getType()->isPointerType() &&

            Sel.getNameForSlot(0) == "allocWithZone") {

          const llvm::Value* arg = Args.front().getKnownRValue().getScalarVal();

          if (isa<llvm::ConstantPointerNull>(arg))

            return CGF.EmitObjCAllocWithZone(Receiver,

                                             CGF.ConvertType(ResultType));

          return std::nullopt;

        }

    }

    break;

  case OMF_autorelease:

    if (ResultType->isObjCObjectPointerType() &&

        CGM.getLangOpts().getGC() == LangOptions::NonGC &&

        Runtime.shouldUseARCFunctionsForRetainRelease())

      return CGF.EmitObjCAutorelease(Receiver, CGF.ConvertType(ResultType));

    break;

  case OMF_retain:

    if (ResultType->isObjCObjectPointerType() &&

        CGM.getLangOpts().getGC() == LangOptions::NonGC &&

        Runtime.shouldUseARCFunctionsForRetainRelease())

      return CGF.EmitObjCRetainNonBlock(Receiver, CGF.ConvertType(ResultType));

    break;

  case OMF_release:

    if (ResultType->isVoidType() &&

        CGM.getLangOpts().getGC() == LangOptions::NonGC &&

        Runtime.shouldUseARCFunctionsForRetainRelease()) {

      CGF.EmitObjCRelease(Receiver, ARCPreciseLifetime);

      return nullptr;

    }

    break;

  default:

    break;

  }

  return std::nullopt;

}

CodeGen::RValue CGObjCRuntime::GeneratePossiblySpecializedMessageSend(

    CodeGenFunction &CGF, ReturnValueSlot Return, QualType ResultType,

    Selector Sel, llvm::Value *Receiver, const CallArgList &Args,

    const ObjCInterfaceDecl *OID, const ObjCMethodDecl *Method,

    bool isClassMessage) {

  if (std::optional<llvm::Value *> SpecializedResult =

          tryGenerateSpecializedMessageSend(CGF, ResultType, Receiver, Args,

                                            Sel, Method, isClassMessage)) {

    return RValue::get(*SpecializedResult);

  }

  return GenerateMessageSend(CGF, Return, ResultType, Sel, Receiver, Args, OID,

                             Method);

}

static void AppendFirstImpliedRuntimeProtocols(

    const ObjCProtocolDecl *PD,

    llvm::UniqueVector<const ObjCProtocolDecl *> &PDs) {

  if (!PD->isNonRuntimeProtocol()) {

    const auto *Can = PD->getCanonicalDecl();

    PDs.insert(Can);

    return;

  }

  for (const auto *ParentPD : PD->protocols())

    AppendFirstImpliedRuntimeProtocols(ParentPD, PDs);

}

std::vector<const ObjCProtocolDecl *>

CGObjCRuntime::GetRuntimeProtocolList(ObjCProtocolDecl::protocol_iterator begin,

                                      ObjCProtocolDecl::protocol_iterator end) {

  std::vector<const ObjCProtocolDecl *> RuntimePds;

  llvm::DenseSet<const ObjCProtocolDecl *> NonRuntimePDs;

  for (; begin != end; ++begin) {

    const auto *It = *begin;

    const auto *Can = It->getCanonicalDecl();

    if (Can->isNonRuntimeProtocol())

      NonRuntimePDs.insert(Can);

    else

      RuntimePds.push_back(Can);

  }

  // If there are no non-runtime protocols then we can just stop now.

  if (NonRuntimePDs.empty())

    return RuntimePds;

  // Else we have to search through the non-runtime protocol's inheritancy

  // hierarchy DAG stopping whenever a branch either finds a runtime protocol or

  // a non-runtime protocol without any parents. These are the "first-implied"

  // protocols from a non-runtime protocol.

  llvm::UniqueVector<const ObjCProtocolDecl *> FirstImpliedProtos;

  for (const auto *PD : NonRuntimePDs)

    AppendFirstImpliedRuntimeProtocols(PD, FirstImpliedProtos);

  // Walk the Runtime list to get all protocols implied via the inclusion of

  // this protocol, e.g. all protocols it inherits from including itself.

  llvm::DenseSet<const ObjCProtocolDecl *> AllImpliedProtocols;

  for (const auto *PD : RuntimePds) {

    const auto *Can = PD->getCanonicalDecl();

    AllImpliedProtocols.insert(Can);

    Can->getImpliedProtocols(AllImpliedProtocols);

  }

  // Similar to above, walk the list of first-implied protocols to find the set

  // all the protocols implied excluding the listed protocols themselves since

  // they are not yet a part of the `RuntimePds` list.

  for (const auto *PD : FirstImpliedProtos) {

    PD->getImpliedProtocols(AllImpliedProtocols);

  }

  // From the first-implied list we have to finish building the final protocol

  // list. If a protocol in the first-implied list was already implied via some

  // inheritance path through some other protocols then it would be redundant to

  // add it here and so we skip over it.

  for (const auto *PD : FirstImpliedProtos) {

    if (!AllImpliedProtocols.contains(PD)) {

      RuntimePds.push_back(PD);

    }

  }

  return RuntimePds;

}

/// Instead of '[[MyClass alloc] init]', try to generate

/// 'objc_alloc_init(MyClass)'. This provides a code size improvement on the

/// caller side, as well as the optimized objc_alloc.

static std::optional<llvm::Value *>

tryEmitSpecializedAllocInit(CodeGenFunction &CGF, const ObjCMessageExpr *OME) {

  auto &Runtime = CGF.getLangOpts().ObjCRuntime;

  if (!Runtime.shouldUseRuntimeFunctionForCombinedAllocInit())

    return std::nullopt;

  // Match the exact pattern '[[MyClass alloc] init]'.

  Selector Sel = OME->getSelector();

  if (OME->getReceiverKind() != ObjCMessageExpr::Instance ||

      !OME->getType()->isObjCObjectPointerType() || !Sel.isUnarySelector() ||

      Sel.getNameForSlot(0) != "init")

    return std::nullopt;

  // Okay, this is '[receiver init]', check if 'receiver' is '[cls alloc]'

  // with 'cls' a Class.

  auto *SubOME =

      dyn_cast<ObjCMessageExpr>(OME->getInstanceReceiver()->IgnoreParenCasts());

  if (!SubOME)

    return std::nullopt;

  Selector SubSel = SubOME->getSelector();

  if (!SubOME->getType()->isObjCObjectPointerType() ||

      !SubSel.isUnarySelector() || SubSel.getNameForSlot(0) != "alloc")

    return std::nullopt;

  llvm::Value *Receiver = nullptr;

  switch (SubOME->getReceiverKind()) {

  case ObjCMessageExpr::Instance:

    if (!SubOME->getInstanceReceiver()->getType()->isObjCClassType())

      return std::nullopt;

    Receiver = CGF.EmitScalarExpr(SubOME->getInstanceReceiver());

    break;

  case ObjCMessageExpr::Class: {

    QualType ReceiverType = SubOME->getClassReceiver();

    const ObjCObjectType *ObjTy = ReceiverType->castAs<ObjCObjectType>();

    const ObjCInterfaceDecl *ID = ObjTy->getInterface();

    assert(ID && "null interface should be impossible here");

    Receiver = CGF.CGM.getObjCRuntime().GetClass(CGF, ID);

    break;

  }

  case ObjCMessageExpr::SuperInstance:

  case ObjCMessageExpr::SuperClass:

    return std::nullopt;

  }

  return CGF.EmitObjCAllocInit(Receiver, CGF.ConvertType(OME->getType()));

}

RValue CodeGenFunction::EmitObjCMessageExpr(const ObjCMessageExpr *E,

                                            ReturnValueSlot Return) {

  // Only the lookup mechanism and first two arguments of the method

  // implementation vary between runtimes.  We can get the receiver and

  // arguments in generic code.

  bool isDelegateInit = E->isDelegateInitCall();

  const ObjCMethodDecl *method = E->getMethodDecl();

  // If the method is -retain, and the receiver's being loaded from

  // a __weak variable, peephole the entire operation to objc_loadWeakRetained.

  if (method && E->getReceiverKind() == ObjCMessageExpr::Instance &&

      method->getMethodFamily() == OMF_retain) {

    if (auto lvalueExpr = findWeakLValue(E->getInstanceReceiver())) {

      LValue lvalue = EmitLValue(lvalueExpr);

      llvm::Value *result = EmitARCLoadWeakRetained(lvalue.getAddress(*this));

      return AdjustObjCObjectType(*this, E->getType(), RValue::get(result));

    }

  }

  if (std::optional<llvm::Value *> Val = tryEmitSpecializedAllocInit(*this, E))

    return AdjustObjCObjectType(*this, E->getType(), RValue::get(*Val));

  // We don't retain the receiver in delegate init calls, and this is

  // safe because the receiver value is always loaded from 'self',

  // which we zero out.  We don't want to Block_copy block receivers,

  // though.

  bool retainSelf =

    (!isDelegateInit &&

     CGM.getLangOpts().ObjCAutoRefCount &&

     method &&

     method->hasAttr<NSConsumesSelfAttr>());

  CGObjCRuntime &Runtime = CGM.getObjCRuntime();

  bool isSuperMessage = false;

  bool isClassMessage = false;

  ObjCInterfaceDecl *OID = nullptr;

  // Find the receiver

  QualType ReceiverType;

  llvm::Value *Receiver = nullptr;

  switch (E->getReceiverKind()) {

  case ObjCMessageExpr::Instance:

    ReceiverType = E->getInstanceReceiver()->getType();

    isClassMessage = ReceiverType->isObjCClassType();

    if (retainSelf) {

      TryEmitResult ter = tryEmitARCRetainScalarExpr(*this,

                                                   E->getInstanceReceiver());

      Receiver = ter.getPointer();

      if (ter.getInt()) retainSelf = false;

    } else

      Receiver = EmitScalarExpr(E->getInstanceReceiver());

    break;

  case ObjCMessageExpr::Class: {

    ReceiverType = E->getClassReceiver();

    OID = ReceiverType->castAs<ObjCObjectType>()->getInterface();

    assert(OID && "Invalid Objective-C class message send");

    Receiver = Runtime.GetClass(*this, OID);

    isClassMessage = true;

    break;

  }

  case ObjCMessageExpr::SuperInstance:

    ReceiverType = E->getSuperType();

    Receiver = LoadObjCSelf();

    isSuperMessage = true;

    break;

  case ObjCMessageExpr::SuperClass:

    ReceiverType = E->getSuperType();

    Receiver = LoadObjCSelf();

    isSuperMessage = true;

    isClassMessage = true;

    break;

  }

  if (retainSelf)

    Receiver = EmitARCRetainNonBlock(Receiver);

  // In ARC, we sometimes want to "extend the lifetime"

  // (i.e. retain+autorelease) of receivers of returns-inner-pointer

  // messages.

  if (getLangOpts().ObjCAutoRefCount && method &&

      method->hasAttr<ObjCReturnsInnerPointerAttr>() &&

      shouldExtendReceiverForInnerPointerMessage(E))

    Receiver = EmitARCRetainAutorelease(ReceiverType, Receiver);

  QualType ResultType = method ? method->getReturnType() : E->getType();

  CallArgList Args;

  EmitCallArgs(Args, method, E->arguments(), /*AC*/AbstractCallee(method));

  // For delegate init calls in ARC, do an unsafe store of null into

  // self.  This represents the call taking direct ownership of that

  // value.  We have to do this after emitting the other call

  // arguments because they might also reference self, but we don't

  // have to worry about any of them modifying self because that would

  // be an undefined read and write of an object in unordered

  // expressions.

  if (isDelegateInit) {

    assert(getLangOpts().ObjCAutoRefCount &&

           "delegate init calls should only be marked in ARC");

    // Do an unsafe store of null into self.

    Address selfAddr =

      GetAddrOfLocalVar(cast<ObjCMethodDecl>(CurCodeDecl)->getSelfDecl());

    Builder.CreateStore(getNullForVariable(selfAddr), selfAddr);

  }

  RValue result;

  if (isSuperMessage) {

    // super is only valid in an Objective-C method

    const ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(CurFuncDecl);

    bool isCategoryImpl = isa<ObjCCategoryImplDecl>(OMD->getDeclContext());

    result = Runtime.GenerateMessageSendSuper(*this, Return, ResultType,

                                              E->getSelector(),

                                              OMD->getClassInterface(),

                                              isCategoryImpl,

                                              Receiver,

                                              isClassMessage,

                                              Args,

                                              method);

  } else {

    // Call runtime methods directly if we can.

    result = Runtime.GeneratePossiblySpecializedMessageSend(

        *this, Return, ResultType, E->getSelector(), Receiver, Args, OID,

        method, isClassMessage);

  }

  // For delegate init calls in ARC, implicitly store the result of

  // the call back into self.  This takes ownership of the value.

  if (isDelegateInit) {

    Address selfAddr =

      GetAddrOfLocalVar(cast<ObjCMethodDecl>(CurCodeDecl)->getSelfDecl());

    llvm::Value *newSelf = result.getScalarVal();

    // The delegate return type isn't necessarily a matching type; in

    // fact, it's quite likely to be 'id'.

    llvm::Type *selfTy = selfAddr.getElementType();

    newSelf = Builder.CreateBitCast(newSelf, selfTy);

    Builder.CreateStore(newSelf, selfAddr);

  }

  return AdjustObjCObjectType(*this, E->getType(), result);

}

namespace {

struct FinishARCDealloc final : EHScopeStack::Cleanup {

  void Emit(CodeGenFunction &CGF, Flags flags) override {

    const ObjCMethodDecl *method = cast<ObjCMethodDecl>(CGF.CurCodeDecl);

    const ObjCImplDecl *impl = cast<ObjCImplDecl>(method->getDeclContext());

    const ObjCInterfaceDecl *iface = impl->getClassInterface();

    if (!iface->getSuperClass()) return;

    bool isCategory = isa<ObjCCategoryImplDecl>(impl);

    // Call [super dealloc] if we have a superclass.

    llvm::Value *self = CGF.LoadObjCSelf();

    CallArgList args;

    CGF.CGM.getObjCRuntime().GenerateMessageSendSuper(CGF, ReturnValueSlot(),

                                                      CGF.getContext().VoidTy,

                                                      method->getSelector(),

                                                      iface,

                                                      isCategory,

                                                      self,

                                                      /*is class msg*/ false,

                                                      args,

                                                      method);

  }

};

}

/// StartObjCMethod - Begin emission of an ObjCMethod. This generates

/// the LLVM function and sets the other context used by

/// CodeGenFunction.

void CodeGenFunction::StartObjCMethod(const ObjCMethodDecl *OMD,

                                      const ObjCContainerDecl *CD) {

  SourceLocation StartLoc = OMD->getBeginLoc();

  FunctionArgList args;

  // Check if we should generate debug info for this method.

  if (OMD->hasAttr<NoDebugAttr>())

    DebugInfo = nullptr; // disable debug info indefinitely for this function

  llvm::Function *Fn = CGM.getObjCRuntime().GenerateMethod(OMD, CD);

  const CGFunctionInfo &FI = CGM.getTypes().arrangeObjCMethodDeclaration(OMD);

  if (OMD->isDirectMethod()) {

    Fn->setVisibility(llvm::Function::HiddenVisibility);

    CGM.SetLLVMFunctionAttributes(OMD, FI, Fn, /*IsThunk=*/false);

    CGM.SetLLVMFunctionAttributesForDefinition(OMD, Fn);

  } else {

    CGM.SetInternalFunctionAttributes(OMD, Fn, FI);

  }

  args.push_back(OMD->getSelfDecl());

  if (!OMD->isDirectMethod())

    args.push_back(OMD->getCmdDecl());

  args.append(OMD->param_begin(), OMD->param_end());

  CurGD = OMD;

  CurEHLocation = OMD->getEndLoc();

  StartFunction(OMD, OMD->getReturnType(), Fn, FI, args,

                OMD->getLocation(), StartLoc);

  if (OMD->isDirectMethod()) {

    // This function is a direct call, it has to implement a nil check

    // on entry.

    //

    // TODO: possibly have several entry points to elide the check

    CGM.getObjCRuntime().GenerateDirectMethodPrologue(*this, Fn, OMD, CD);

  }

  // In ARC, certain methods get an extra cleanup.

  if (CGM.getLangOpts().ObjCAutoRefCount &&

      OMD->isInstanceMethod() &&

      OMD->getSelector().isUnarySelector()) {

    const IdentifierInfo *ident =

      OMD->getSelector().getIdentifierInfoForSlot(0);

    if (ident->isStr("dealloc"))

      EHStack.pushCleanup<FinishARCDealloc>(getARCCleanupKind());

  }

}

static llvm::Value *emitARCRetainLoadOfScalar(CodeGenFunction &CGF,

                                              LValue lvalue, QualType type);

/// Generate an Objective-C method.  An Objective-C method is a C function with

/// its pointer, name, and types registered in the class structure.

void CodeGenFunction::GenerateObjCMethod(const ObjCMethodDecl *OMD) {

  StartObjCMethod(OMD, OMD->getClassInterface());

  PGO.assignRegionCounters(GlobalDecl(OMD), CurFn);

  assert(isa<CompoundStmt>(OMD->getBody()));

  incrementProfileCounter(OMD->getBody());

  EmitCompoundStmtWithoutScope(*cast<CompoundStmt>(OMD->getBody()));

  FinishFunction(OMD->getBodyRBrace());

}

/// emitStructGetterCall - Call the runtime function to load a property

/// into the return value slot.

static void emitStructGetterCall(CodeGenFunction &CGF, ObjCIvarDecl *ivar,

                                 bool isAtomic, bool hasStrong) {

  ASTContext &Context = CGF.getContext();

  llvm::Value *src =

      CGF.EmitLValueForIvar(CGF.TypeOfSelfObject(), CGF.LoadObjCSelf(), ivar, 0)

          .getPointer(CGF);

  // objc_copyStruct (ReturnValue, &structIvar,

  //                  sizeof (Type of Ivar), isAtomic, false);

  CallArgList args;

  llvm::Value *dest = CGF.ReturnValue.getPointer();

  args.add(RValue::get(dest), Context.VoidPtrTy);

  args.add(RValue::get(src), Context.VoidPtrTy);

  CharUnits size = CGF.getContext().getTypeSizeInChars(ivar->getType());

  args.add(RValue::get(CGF.CGM.getSize(size)), Context.getSizeType());

  args.add(RValue::get(CGF.Builder.getInt1(isAtomic)), Context.BoolTy);

  args.add(RValue::get(CGF.Builder.getInt1(hasStrong)), Context.BoolTy);

  llvm::FunctionCallee fn = CGF.CGM.getObjCRuntime().GetGetStructFunction();

  CGCallee callee = CGCallee::forDirect(fn);

  CGF.EmitCall(CGF.getTypes().arrangeBuiltinFunctionCall(Context.VoidTy, args),

               callee, ReturnValueSlot(), args);

}

/// Determine whether the given architecture supports unaligned atomic

/// accesses.  They don't have to be fast, just faster than a function

/// call and a mutex.

static bool hasUnalignedAtomics(llvm::Triple::ArchType arch) {

  // FIXME: Allow unaligned atomic load/store on x86.  (It is not

  // currently supported by the backend.)

  return false;

}

/// Return the maximum size that permits atomic accesses for the given

/// architecture.

static CharUnits getMaxAtomicAccessSize(CodeGenModule &CGM,

                                        llvm::Triple::ArchType arch) {

  // ARM has 8-byte atomic accesses, but it's not clear whether we

  // want to rely on them here.

  // In the default case, just assume that any size up to a pointer is

  // fine given adequate alignment.

  return CharUnits::fromQuantity(CGM.PointerSizeInBytes);

}

namespace {

  class PropertyImplStrategy {

  public:

    enum StrategyKind {

      /// The 'native' strategy is to use the architecture's provided

      /// reads and writes.

      Native,

      /// Use objc_setProperty and objc_getProperty.

      GetSetProperty,

      /// Use objc_setProperty for the setter, but use expression

      /// evaluation for the getter.

      SetPropertyAndExpressionGet,

      /// Use objc_copyStruct.

      CopyStruct,

      /// The 'expression' strategy is to emit normal assignment or

      /// lvalue-to-rvalue expressions.

      Expression

    };

    StrategyKind getKind() const { return StrategyKind(Kind); }

    bool hasStrongMember() const { return HasStrong; }

    bool isAtomic() const { return IsAtomic; }

    bool isCopy() const { return IsCopy; }

    CharUnits getIvarSize() const { return IvarSize; }

    CharUnits getIvarAlignment() const { return IvarAlignment; }

    PropertyImplStrategy(CodeGenModule &CGM,

                         const ObjCPropertyImplDecl *propImpl);

  private:

    unsigned Kind : 8;

    unsigned IsAtomic : 1;

    unsigned IsCopy : 1;

    unsigned HasStrong : 1;

    CharUnits IvarSize;

    CharUnits IvarAlignment;

  };

}

/// Pick an implementation strategy for the given property synthesis.

PropertyImplStrategy::PropertyImplStrategy(CodeGenModule &CGM,

                                     const ObjCPropertyImplDecl *propImpl) {

  const ObjCPropertyDecl *prop = propImpl->getPropertyDecl();

  ObjCPropertyDecl::SetterKind setterKind = prop->getSetterKind();

  IsCopy = (setterKind == ObjCPropertyDecl::Copy);

  IsAtomic = prop->isAtomic();

  HasStrong = false; // doesn't matter here.

  // Evaluate the ivar's size and alignment.

  ObjCIvarDecl *ivar = propImpl->getPropertyIvarDecl();

  QualType ivarType = ivar->getType();