| 1 |
//==- CGObjCRuntime.cpp - Interface to Shared Objective-C Runtime Features ==// |
| 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 abstract class defines the interface for Objective-C runtime-specific |
| 10 |
// code generation. It provides some concrete helper methods for functionality |
| 11 |
// shared between all (or most) of the Objective-C runtimes supported by clang. |
| 12 |
// |
| 13 |
//===----------------------------------------------------------------------===// |
| 14 |
|
| 15 |
#include "CGObjCRuntime.h" |
| 16 |
#include "CGCXXABI.h" |
| 17 |
#include "CGCleanup.h" |
| 18 |
#include "CGRecordLayout.h" |
| 19 |
#include "CodeGenFunction.h" |
| 20 |
#include "CodeGenModule.h" |
| 21 |
#include "clang/AST/RecordLayout.h" |
| 22 |
#include "clang/AST/StmtObjC.h" |
| 23 |
#include "clang/CodeGen/CGFunctionInfo.h" |
| 24 |
#include "clang/CodeGen/CodeGenABITypes.h" |
| 25 |
#include "llvm/IR/Instruction.h" |
| 26 |
#include "llvm/Support/SaveAndRestore.h" |
| 27 |
|
| 28 |
using namespace clang; |
| 29 |
using namespace CodeGen; |
| 30 |
|
| 31 |
uint64_t CGObjCRuntime::ComputeIvarBaseOffset(CodeGen::CodeGenModule &CGM, |
| 32 |
const ObjCInterfaceDecl *OID, |
| 33 |
const ObjCIvarDecl *Ivar) { |
| 34 |
return CGM.getContext().lookupFieldBitOffset(OID, nullptr, Ivar) / |
| 35 |
CGM.getContext().getCharWidth(); |
| 36 |
} |
| 37 |
|
| 38 |
uint64_t CGObjCRuntime::ComputeIvarBaseOffset(CodeGen::CodeGenModule &CGM, |
| 39 |
const ObjCImplementationDecl *OID, |
| 40 |
const ObjCIvarDecl *Ivar) { |
| 41 |
return CGM.getContext().lookupFieldBitOffset(OID->getClassInterface(), OID, |
| 42 |
Ivar) / |
| 43 |
CGM.getContext().getCharWidth(); |
| 44 |
} |
| 45 |
|
| 46 |
unsigned CGObjCRuntime::ComputeBitfieldBitOffset( |
| 47 |
CodeGen::CodeGenModule &CGM, |
| 48 |
const ObjCInterfaceDecl *ID, |
| 49 |
const ObjCIvarDecl *Ivar) { |
| 50 |
return CGM.getContext().lookupFieldBitOffset(ID, ID->getImplementation(), |
| 51 |
Ivar); |
| 52 |
} |
| 53 |
|
| 54 |
LValue CGObjCRuntime::EmitValueForIvarAtOffset(CodeGen::CodeGenFunction &CGF, |
| 55 |
const ObjCInterfaceDecl *OID, |
| 56 |
llvm::Value *BaseValue, |
| 57 |
const ObjCIvarDecl *Ivar, |
| 58 |
unsigned CVRQualifiers, |
| 59 |
llvm::Value *Offset) { |
| 60 |
// Compute (type*) ( (char *) BaseValue + Offset) |
| 61 |
QualType InterfaceTy{OID->getTypeForDecl(), 0}; |
| 62 |
QualType ObjectPtrTy = |
| 63 |
CGF.CGM.getContext().getObjCObjectPointerType(InterfaceTy); |
| 64 |
QualType IvarTy = |
| 65 |
Ivar->getUsageType(ObjectPtrTy).withCVRQualifiers(CVRQualifiers); |
| 66 |
llvm::Type *LTy = CGF.CGM.getTypes().ConvertTypeForMem(IvarTy); |
| 67 |
llvm::Value *V = CGF.Builder.CreateBitCast(BaseValue, CGF.Int8PtrTy); |
| 68 |
V = CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, V, Offset, "add.ptr"); |
| 69 |
|
| 70 |
if (!Ivar->isBitField()) { |
| 71 |
V = CGF.Builder.CreateBitCast(V, llvm::PointerType::getUnqual(LTy)); |
| 72 |
LValue LV = CGF.MakeNaturalAlignAddrLValue(V, IvarTy); |
| 73 |
return LV; |
| 74 |
} |
| 75 |
|
| 76 |
// We need to compute an access strategy for this bit-field. We are given the |
| 77 |
// offset to the first byte in the bit-field, the sub-byte offset is taken |
| 78 |
// from the original layout. We reuse the normal bit-field access strategy by |
| 79 |
// treating this as an access to a struct where the bit-field is in byte 0, |
| 80 |
// and adjust the containing type size as appropriate. |
| 81 |
// |
| 82 |
// FIXME: Note that currently we make a very conservative estimate of the |
| 83 |
// alignment of the bit-field, because (a) it is not clear what guarantees the |
| 84 |
// runtime makes us, and (b) we don't have a way to specify that the struct is |
| 85 |
// at an alignment plus offset. |
| 86 |
// |
| 87 |
// Note, there is a subtle invariant here: we can only call this routine on |
| 88 |
// non-synthesized ivars but we may be called for synthesized ivars. However, |
| 89 |
// a synthesized ivar can never be a bit-field, so this is safe. |
| 90 |
uint64_t FieldBitOffset = |
| 91 |
CGF.CGM.getContext().lookupFieldBitOffset(OID, nullptr, Ivar); |
| 92 |
uint64_t BitOffset = FieldBitOffset % CGF.CGM.getContext().getCharWidth(); |
| 93 |
uint64_t AlignmentBits = CGF.CGM.getTarget().getCharAlign(); |
| 94 |
uint64_t BitFieldSize = Ivar->getBitWidthValue(CGF.getContext()); |
| 95 |
CharUnits StorageSize = CGF.CGM.getContext().toCharUnitsFromBits( |
| 96 |
llvm::alignTo(BitOffset + BitFieldSize, AlignmentBits)); |
| 97 |
CharUnits Alignment = CGF.CGM.getContext().toCharUnitsFromBits(AlignmentBits); |
| 98 |
|
| 99 |
// Allocate a new CGBitFieldInfo object to describe this access. |
| 100 |
// |
| 101 |
// FIXME: This is incredibly wasteful, these should be uniqued or part of some |
| 102 |
// layout object. However, this is blocked on other cleanups to the |
| 103 |
// Objective-C code, so for now we just live with allocating a bunch of these |
| 104 |
// objects. |
| 105 |
CGBitFieldInfo *Info = new (CGF.CGM.getContext()) CGBitFieldInfo( |
| 106 |
CGBitFieldInfo::MakeInfo(CGF.CGM.getTypes(), Ivar, BitOffset, BitFieldSize, |
| 107 |
CGF.CGM.getContext().toBits(StorageSize), |
| 108 |
CharUnits::fromQuantity(0))); |
| 109 |
|
| 110 |
Address Addr = Address(V, CGF.Int8Ty, Alignment); |
| 111 |
Addr = CGF.Builder.CreateElementBitCast(Addr, |
| 112 |
llvm::Type::getIntNTy(CGF.getLLVMContext(), |
| 113 |
Info->StorageSize)); |
| 114 |
return LValue::MakeBitfield(Addr, *Info, IvarTy, |
| 115 |
LValueBaseInfo(AlignmentSource::Decl), |
| 116 |
TBAAAccessInfo()); |
| 117 |
} |
| 118 |
|
| 119 |
namespace { |
| 120 |
struct CatchHandler { |
| 121 |
const VarDecl *Variable; |
| 122 |
const Stmt *Body; |
| 123 |
llvm::BasicBlock *Block; |
| 124 |
llvm::Constant *TypeInfo; |
| 125 |
/// Flags used to differentiate cleanups and catchalls in Windows SEH |
| 126 |
unsigned Flags; |
| 127 |
}; |
| 128 |
|
| 129 |
struct CallObjCEndCatch final : EHScopeStack::Cleanup { |
| 130 |
CallObjCEndCatch(bool MightThrow, llvm::FunctionCallee Fn) |
| 131 |
: MightThrow(MightThrow), Fn(Fn) {} |
| 132 |
bool MightThrow; |
| 133 |
llvm::FunctionCallee Fn; |
| 134 |
|
| 135 |
void Emit(CodeGenFunction &CGF, Flags flags) override { |
| 136 |
if (MightThrow) |
| 137 |
CGF.EmitRuntimeCallOrInvoke(Fn); |
| 138 |
else |
| 139 |
CGF.EmitNounwindRuntimeCall(Fn); |
| 140 |
} |
| 141 |
}; |
| 142 |
} |
| 143 |
|
| 144 |
void CGObjCRuntime::EmitTryCatchStmt(CodeGenFunction &CGF, |
| 145 |
const ObjCAtTryStmt &S, |
| 146 |
llvm::FunctionCallee beginCatchFn, |
| 147 |
llvm::FunctionCallee endCatchFn, |
| 148 |
llvm::FunctionCallee exceptionRethrowFn) { |
| 149 |
// Jump destination for falling out of catch bodies. |
| 150 |
CodeGenFunction::JumpDest Cont; |
| 151 |
if (S.getNumCatchStmts()) |
| 152 |
Cont = CGF.getJumpDestInCurrentScope("eh.cont"); |
| 153 |
|
| 154 |
bool useFunclets = EHPersonality::get(CGF).usesFuncletPads(); |
| 155 |
|
| 156 |
CodeGenFunction::FinallyInfo FinallyInfo; |
| 157 |
if (!useFunclets) |
| 158 |
if (const ObjCAtFinallyStmt *Finally = S.getFinallyStmt()) |
| 159 |
FinallyInfo.enter(CGF, Finally->getFinallyBody(), |
| 160 |
beginCatchFn, endCatchFn, exceptionRethrowFn); |
| 161 |
|
| 162 |
SmallVector<CatchHandler, 8> Handlers; |
| 163 |
|
| 164 |
|
| 165 |
// Enter the catch, if there is one. |
| 166 |
if (S.getNumCatchStmts()) { |
| 167 |
for (const ObjCAtCatchStmt *CatchStmt : S.catch_stmts()) { |
| 168 |
const VarDecl *CatchDecl = CatchStmt->getCatchParamDecl(); |
| 169 |
|
| 170 |
Handlers.push_back(CatchHandler()); |
| 171 |
CatchHandler &Handler = Handlers.back(); |
| 172 |
Handler.Variable = CatchDecl; |
| 173 |
Handler.Body = CatchStmt->getCatchBody(); |
| 174 |
Handler.Block = CGF.createBasicBlock("catch"); |
| 175 |
Handler.Flags = 0; |
| 176 |
|
| 177 |
// @catch(...) always matches. |
| 178 |
if (!CatchDecl) { |
| 179 |
auto catchAll = getCatchAllTypeInfo(); |
| 180 |
Handler.TypeInfo = catchAll.RTTI; |
| 181 |
Handler.Flags = catchAll.Flags; |
| 182 |
// Don't consider any other catches. |
| 183 |
break; |
| 184 |
} |
| 185 |
|
| 186 |
Handler.TypeInfo = GetEHType(CatchDecl->getType()); |
| 187 |
} |
| 188 |
|
| 189 |
EHCatchScope *Catch = CGF.EHStack.pushCatch(Handlers.size()); |
| 190 |
for (unsigned I = 0, E = Handlers.size(); I != E; ++I) |
| 191 |
Catch->setHandler(I, { Handlers[I].TypeInfo, Handlers[I].Flags }, Handlers[I].Block); |
| 192 |
} |
| 193 |
|
| 194 |
if (useFunclets) |
| 195 |
if (const ObjCAtFinallyStmt *Finally = S.getFinallyStmt()) { |
| 196 |
CodeGenFunction HelperCGF(CGM, /*suppressNewContext=*/true); |
| 197 |
if (!CGF.CurSEHParent) |
| 198 |
CGF.CurSEHParent = cast<NamedDecl>(CGF.CurFuncDecl); |
| 199 |
// Outline the finally block. |
| 200 |
const Stmt *FinallyBlock = Finally->getFinallyBody(); |
| 201 |
HelperCGF.startOutlinedSEHHelper(CGF, /*isFilter*/false, FinallyBlock); |
| 202 |
|
| 203 |
// Emit the original filter expression, convert to i32, and return. |
| 204 |
HelperCGF.EmitStmt(FinallyBlock); |
| 205 |
|
| 206 |
HelperCGF.FinishFunction(FinallyBlock->getEndLoc()); |
| 207 |
|
| 208 |
llvm::Function *FinallyFunc = HelperCGF.CurFn; |
| 209 |
|
| 210 |
|
| 211 |
// Push a cleanup for __finally blocks. |
| 212 |
CGF.pushSEHCleanup(NormalAndEHCleanup, FinallyFunc); |
| 213 |
} |
| 214 |
|
| 215 |
|
| 216 |
// Emit the try body. |
| 217 |
CGF.EmitStmt(S.getTryBody()); |
| 218 |
|
| 219 |
// Leave the try. |
| 220 |
if (S.getNumCatchStmts()) |
| 221 |
CGF.popCatchScope(); |
| 222 |
|
| 223 |
// Remember where we were. |
| 224 |
CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP(); |
| 225 |
|
| 226 |
// Emit the handlers. |
| 227 |
for (unsigned I = 0, E = Handlers.size(); I != E; ++I) { |
| 228 |
CatchHandler &Handler = Handlers[I]; |
| 229 |
|
| 230 |
CGF.EmitBlock(Handler.Block); |
| 231 |
|
| 232 |
CodeGenFunction::LexicalScope Cleanups(CGF, Handler.Body->getSourceRange()); |
| 233 |
SaveAndRestore RevertAfterScope(CGF.CurrentFuncletPad); |
| 234 |
if (useFunclets) { |
| 235 |
llvm::Instruction *CPICandidate = Handler.Block->getFirstNonPHI(); |
| 236 |
if (auto *CPI = dyn_cast_or_null<llvm::CatchPadInst>(CPICandidate)) { |
| 237 |
CGF.CurrentFuncletPad = CPI; |
| 238 |
CPI->setOperand(2, CGF.getExceptionSlot().getPointer()); |
| 239 |
CGF.EHStack.pushCleanup<CatchRetScope>(NormalCleanup, CPI); |
| 240 |
} |
| 241 |
} |
| 242 |
|
| 243 |
llvm::Value *RawExn = CGF.getExceptionFromSlot(); |
| 244 |
|
| 245 |
// Enter the catch. |
| 246 |
llvm::Value *Exn = RawExn; |
| 247 |
if (beginCatchFn) |
| 248 |
Exn = CGF.EmitNounwindRuntimeCall(beginCatchFn, RawExn, "exn.adjusted"); |
| 249 |
|
| 250 |
if (endCatchFn) { |
| 251 |
// Add a cleanup to leave the catch. |
| 252 |
bool EndCatchMightThrow = (Handler.Variable == nullptr); |
| 253 |
|
| 254 |
CGF.EHStack.pushCleanup<CallObjCEndCatch>(NormalAndEHCleanup, |
| 255 |
EndCatchMightThrow, |
| 256 |
endCatchFn); |
| 257 |
} |
| 258 |
|
| 259 |
// Bind the catch parameter if it exists. |
| 260 |
if (const VarDecl *CatchParam = Handler.Variable) { |
| 261 |
llvm::Type *CatchType = CGF.ConvertType(CatchParam->getType()); |
| 262 |
llvm::Value *CastExn = CGF.Builder.CreateBitCast(Exn, CatchType); |
| 263 |
|
| 264 |
CGF.EmitAutoVarDecl(*CatchParam); |
| 265 |
EmitInitOfCatchParam(CGF, CastExn, CatchParam); |
| 266 |
} |
| 267 |
|
| 268 |
CGF.ObjCEHValueStack.push_back(Exn); |
| 269 |
CGF.EmitStmt(Handler.Body); |
| 270 |
CGF.ObjCEHValueStack.pop_back(); |
| 271 |
|
| 272 |
// Leave any cleanups associated with the catch. |
| 273 |
Cleanups.ForceCleanup(); |
| 274 |
|
| 275 |
CGF.EmitBranchThroughCleanup(Cont); |
| 276 |
} |
| 277 |
|
| 278 |
// Go back to the try-statement fallthrough. |
| 279 |
CGF.Builder.restoreIP(SavedIP); |
| 280 |
|
| 281 |
// Pop out of the finally. |
| 282 |
if (!useFunclets && S.getFinallyStmt()) |
| 283 |
FinallyInfo.exit(CGF); |
| 284 |
|
| 285 |
if (Cont.isValid()) |
| 286 |
CGF.EmitBlock(Cont.getBlock()); |
| 287 |
} |
| 288 |
|
| 289 |
void CGObjCRuntime::EmitInitOfCatchParam(CodeGenFunction &CGF, |
| 290 |
llvm::Value *exn, |
| 291 |
const VarDecl *paramDecl) { |
| 292 |
|
| 293 |
Address paramAddr = CGF.GetAddrOfLocalVar(paramDecl); |
| 294 |
|
| 295 |
switch (paramDecl->getType().getQualifiers().getObjCLifetime()) { |
| 296 |
case Qualifiers::OCL_Strong: |
| 297 |
exn = CGF.EmitARCRetainNonBlock(exn); |
| 298 |
[[fallthrough]]; |
| 299 |
|
| 300 |
case Qualifiers::OCL_None: |
| 301 |
case Qualifiers::OCL_ExplicitNone: |
| 302 |
case Qualifiers::OCL_Autoreleasing: |
| 303 |
CGF.Builder.CreateStore(exn, paramAddr); |
| 304 |
return; |
| 305 |
|
| 306 |
case Qualifiers::OCL_Weak: |
| 307 |
CGF.EmitARCInitWeak(paramAddr, exn); |
| 308 |
return; |
| 309 |
} |
| 310 |
llvm_unreachable("invalid ownership qualifier"); |
| 311 |
} |
| 312 |
|
| 313 |
namespace { |
| 314 |
struct CallSyncExit final : EHScopeStack::Cleanup { |
| 315 |
llvm::FunctionCallee SyncExitFn; |
| 316 |
llvm::Value *SyncArg; |
| 317 |
CallSyncExit(llvm::FunctionCallee SyncExitFn, llvm::Value *SyncArg) |
| 318 |
: SyncExitFn(SyncExitFn), SyncArg(SyncArg) {} |
| 319 |
|
| 320 |
void Emit(CodeGenFunction &CGF, Flags flags) override { |
| 321 |
CGF.EmitNounwindRuntimeCall(SyncExitFn, SyncArg); |
| 322 |
} |
| 323 |
}; |
| 324 |
} |
| 325 |
|
| 326 |
void CGObjCRuntime::EmitAtSynchronizedStmt(CodeGenFunction &CGF, |
| 327 |
const ObjCAtSynchronizedStmt &S, |
| 328 |
llvm::FunctionCallee syncEnterFn, |
| 329 |
llvm::FunctionCallee syncExitFn) { |
| 330 |
CodeGenFunction::RunCleanupsScope cleanups(CGF); |
| 331 |
|
| 332 |
// Evaluate the lock operand. This is guaranteed to dominate the |
| 333 |
// ARC release and lock-release cleanups. |
| 334 |
const Expr *lockExpr = S.getSynchExpr(); |
| 335 |
llvm::Value *lock; |
| 336 |
if (CGF.getLangOpts().ObjCAutoRefCount) { |
| 337 |
lock = CGF.EmitARCRetainScalarExpr(lockExpr); |
| 338 |
lock = CGF.EmitObjCConsumeObject(lockExpr->getType(), lock); |
| 339 |
} else { |
| 340 |
lock = CGF.EmitScalarExpr(lockExpr); |
| 341 |
} |
| 342 |
lock = CGF.Builder.CreateBitCast(lock, CGF.VoidPtrTy); |
| 343 |
|
| 344 |
// Acquire the lock. |
| 345 |
CGF.Builder.CreateCall(syncEnterFn, lock)->setDoesNotThrow(); |
| 346 |
|
| 347 |
// Register an all-paths cleanup to release the lock. |
| 348 |
CGF.EHStack.pushCleanup<CallSyncExit>(NormalAndEHCleanup, syncExitFn, lock); |
| 349 |
|
| 350 |
// Emit the body of the statement. |
| 351 |
CGF.EmitStmt(S.getSynchBody()); |
| 352 |
} |
| 353 |
|
| 354 |
/// Compute the pointer-to-function type to which a message send |
| 355 |
/// should be casted in order to correctly call the given method |
| 356 |
/// with the given arguments. |
| 357 |
/// |
| 358 |
/// \param method - may be null |
| 359 |
/// \param resultType - the result type to use if there's no method |
| 360 |
/// \param callArgs - the actual arguments, including implicit ones |
| 361 |
CGObjCRuntime::MessageSendInfo |
| 362 |
CGObjCRuntime::getMessageSendInfo(const ObjCMethodDecl *method, |
| 363 |
QualType resultType, |
| 364 |
CallArgList &callArgs) { |
| 365 |
unsigned ProgramAS = CGM.getDataLayout().getProgramAddressSpace(); |
| 366 |
|
| 367 |
// If there's a method, use information from that. |
| 368 |
if (method) { |
| 369 |
const CGFunctionInfo &signature = |
| 370 |
CGM.getTypes().arrangeObjCMessageSendSignature(method, callArgs[0].Ty); |
| 371 |
|
| 372 |
llvm::PointerType *signatureType = |
| 373 |
CGM.getTypes().GetFunctionType(signature)->getPointerTo(ProgramAS); |
| 374 |
|
| 375 |
const CGFunctionInfo &signatureForCall = |
| 376 |
CGM.getTypes().arrangeCall(signature, callArgs); |
| 377 |
|
| 378 |
return MessageSendInfo(signatureForCall, signatureType); |
| 379 |
} |
| 380 |
|
| 381 |
// There's no method; just use a default CC. |
| 382 |
const CGFunctionInfo &argsInfo = |
| 383 |
CGM.getTypes().arrangeUnprototypedObjCMessageSend(resultType, callArgs); |
| 384 |
|
| 385 |
// Derive the signature to call from that. |
| 386 |
llvm::PointerType *signatureType = |
| 387 |
CGM.getTypes().GetFunctionType(argsInfo)->getPointerTo(ProgramAS); |
| 388 |
return MessageSendInfo(argsInfo, signatureType); |
| 389 |
} |
| 390 |
|
| 391 |
bool CGObjCRuntime::canMessageReceiverBeNull(CodeGenFunction &CGF, |
| 392 |
const ObjCMethodDecl *method, |
| 393 |
bool isSuper, |
| 394 |
const ObjCInterfaceDecl *classReceiver, |
| 395 |
llvm::Value *receiver) { |
| 396 |
// Super dispatch assumes that self is non-null; even the messenger |
| 397 |
// doesn't have a null check internally. |
| 398 |
if (isSuper) |
| 399 |
return false; |
| 400 |
|
| 401 |
// If this is a direct dispatch of a class method, check whether the class, |
| 402 |
// or anything in its hierarchy, was weak-linked. |
| 403 |
if (classReceiver && method && method->isClassMethod()) |
| 404 |
return isWeakLinkedClass(classReceiver); |
| 405 |
|
| 406 |
// If we're emitting a method, and self is const (meaning just ARC, for now), |
| 407 |
// and the receiver is a load of self, then self is a valid object. |
| 408 |
if (auto curMethod = |
| 409 |
dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl)) { |
| 410 |
auto self = curMethod->getSelfDecl(); |
| 411 |
if (self->getType().isConstQualified()) { |
| 412 |
if (auto LI = dyn_cast<llvm::LoadInst>(receiver->stripPointerCasts())) { |
| 413 |
llvm::Value *selfAddr = CGF.GetAddrOfLocalVar(self).getPointer(); |
| 414 |
if (selfAddr == LI->getPointerOperand()) { |
| 415 |
return false; |
| 416 |
} |
| 417 |
} |
| 418 |
} |
| 419 |
} |
| 420 |
|
| 421 |
// Otherwise, assume it can be null. |
| 422 |
return true; |
| 423 |
} |
| 424 |
|
| 425 |
bool CGObjCRuntime::isWeakLinkedClass(const ObjCInterfaceDecl *ID) { |
| 426 |
do { |
| 427 |
if (ID->isWeakImported()) |
| 428 |
return true; |
| 429 |
} while ((ID = ID->getSuperClass())); |
| 430 |
|
| 431 |
return false; |
| 432 |
} |
| 433 |
|
| 434 |
void CGObjCRuntime::destroyCalleeDestroyedArguments(CodeGenFunction &CGF, |
| 435 |
const ObjCMethodDecl *method, |
| 436 |
const CallArgList &callArgs) { |
| 437 |
CallArgList::const_iterator I = callArgs.begin(); |
| 438 |
for (auto i = method->param_begin(), e = method->param_end(); |
| 439 |
i != e; ++i, ++I) { |
| 440 |
const ParmVarDecl *param = (*i); |
| 441 |
if (param->hasAttr<NSConsumedAttr>()) { |
| 442 |
RValue RV = I->getRValue(CGF); |
| 443 |
assert(RV.isScalar() && |
| 444 |
"NullReturnState::complete - arg not on object"); |
| 445 |
CGF.EmitARCRelease(RV.getScalarVal(), ARCImpreciseLifetime); |
| 446 |
} else { |
| 447 |
QualType QT = param->getType(); |
| 448 |
auto *RT = QT->getAs<RecordType>(); |
| 449 |
if (RT && RT->getDecl()->isParamDestroyedInCallee()) { |
| 450 |
RValue RV = I->getRValue(CGF); |
| 451 |
QualType::DestructionKind DtorKind = QT.isDestructedType(); |
| 452 |
switch (DtorKind) { |
| 453 |
case QualType::DK_cxx_destructor: |
| 454 |
CGF.destroyCXXObject(CGF, RV.getAggregateAddress(), QT); |
| 455 |
break; |
| 456 |
case QualType::DK_nontrivial_c_struct: |
| 457 |
CGF.destroyNonTrivialCStruct(CGF, RV.getAggregateAddress(), QT); |
| 458 |
break; |
| 459 |
default: |
| 460 |
llvm_unreachable("unexpected dtor kind"); |
| 461 |
break; |
| 462 |
} |
| 463 |
} |
| 464 |
} |
| 465 |
} |
| 466 |
} |
| 467 |
|
| 468 |
llvm::Constant * |
| 469 |
clang::CodeGen::emitObjCProtocolObject(CodeGenModule &CGM, |
| 470 |
const ObjCProtocolDecl *protocol) { |
| 471 |
return CGM.getObjCRuntime().GetOrEmitProtocol(protocol); |
| 472 |
} |
| 473 |
|
| 474 |
std::string CGObjCRuntime::getSymbolNameForMethod(const ObjCMethodDecl *OMD, |
| 475 |
bool includeCategoryName) { |
| 476 |
std::string buffer; |
| 477 |
llvm::raw_string_ostream out(buffer); |
| 478 |
CGM.getCXXABI().getMangleContext().mangleObjCMethodName(OMD, out, |
| 479 |
/*includePrefixByte=*/true, |
| 480 |
includeCategoryName); |
| 481 |
return buffer; |
| 482 |
} |