xref: /aosp_15_r20/external/clang/lib/CodeGen/CGObjCRuntime.cpp (revision 67e74705e28f6214e480b399dd47ea732279e315)
1  //==- CGObjCRuntime.cpp - Interface to Shared Objective-C Runtime Features ==//
2  //
3  //                     The LLVM Compiler Infrastructure
4  //
5  // This file is distributed under the University of Illinois Open Source
6  // License. See LICENSE.TXT for details.
7  //
8  //===----------------------------------------------------------------------===//
9  //
10  // This abstract class defines the interface for Objective-C runtime-specific
11  // code generation.  It provides some concrete helper methods for functionality
12  // shared between all (or most) of the Objective-C runtimes supported by clang.
13  //
14  //===----------------------------------------------------------------------===//
15  
16  #include "CGObjCRuntime.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 "llvm/IR/CallSite.h"
25  
26  using namespace clang;
27  using namespace CodeGen;
28  
LookupFieldBitOffset(CodeGen::CodeGenModule & CGM,const ObjCInterfaceDecl * OID,const ObjCImplementationDecl * ID,const ObjCIvarDecl * Ivar)29  static uint64_t LookupFieldBitOffset(CodeGen::CodeGenModule &CGM,
30                                       const ObjCInterfaceDecl *OID,
31                                       const ObjCImplementationDecl *ID,
32                                       const ObjCIvarDecl *Ivar) {
33    const ObjCInterfaceDecl *Container = Ivar->getContainingInterface();
34  
35    // FIXME: We should eliminate the need to have ObjCImplementationDecl passed
36    // in here; it should never be necessary because that should be the lexical
37    // decl context for the ivar.
38  
39    // If we know have an implementation (and the ivar is in it) then
40    // look up in the implementation layout.
41    const ASTRecordLayout *RL;
42    if (ID && declaresSameEntity(ID->getClassInterface(), Container))
43      RL = &CGM.getContext().getASTObjCImplementationLayout(ID);
44    else
45      RL = &CGM.getContext().getASTObjCInterfaceLayout(Container);
46  
47    // Compute field index.
48    //
49    // FIXME: The index here is closely tied to how ASTContext::getObjCLayout is
50    // implemented. This should be fixed to get the information from the layout
51    // directly.
52    unsigned Index = 0;
53  
54    for (const ObjCIvarDecl *IVD = Container->all_declared_ivar_begin();
55         IVD; IVD = IVD->getNextIvar()) {
56      if (Ivar == IVD)
57        break;
58      ++Index;
59    }
60    assert(Index < RL->getFieldCount() && "Ivar is not inside record layout!");
61  
62    return RL->getFieldOffset(Index);
63  }
64  
ComputeIvarBaseOffset(CodeGen::CodeGenModule & CGM,const ObjCInterfaceDecl * OID,const ObjCIvarDecl * Ivar)65  uint64_t CGObjCRuntime::ComputeIvarBaseOffset(CodeGen::CodeGenModule &CGM,
66                                                const ObjCInterfaceDecl *OID,
67                                                const ObjCIvarDecl *Ivar) {
68    return LookupFieldBitOffset(CGM, OID, nullptr, Ivar) /
69      CGM.getContext().getCharWidth();
70  }
71  
ComputeIvarBaseOffset(CodeGen::CodeGenModule & CGM,const ObjCImplementationDecl * OID,const ObjCIvarDecl * Ivar)72  uint64_t CGObjCRuntime::ComputeIvarBaseOffset(CodeGen::CodeGenModule &CGM,
73                                                const ObjCImplementationDecl *OID,
74                                                const ObjCIvarDecl *Ivar) {
75    return LookupFieldBitOffset(CGM, OID->getClassInterface(), OID, Ivar) /
76      CGM.getContext().getCharWidth();
77  }
78  
ComputeBitfieldBitOffset(CodeGen::CodeGenModule & CGM,const ObjCInterfaceDecl * ID,const ObjCIvarDecl * Ivar)79  unsigned CGObjCRuntime::ComputeBitfieldBitOffset(
80      CodeGen::CodeGenModule &CGM,
81      const ObjCInterfaceDecl *ID,
82      const ObjCIvarDecl *Ivar) {
83    return LookupFieldBitOffset(CGM, ID, ID->getImplementation(), Ivar);
84  }
85  
EmitValueForIvarAtOffset(CodeGen::CodeGenFunction & CGF,const ObjCInterfaceDecl * OID,llvm::Value * BaseValue,const ObjCIvarDecl * Ivar,unsigned CVRQualifiers,llvm::Value * Offset)86  LValue CGObjCRuntime::EmitValueForIvarAtOffset(CodeGen::CodeGenFunction &CGF,
87                                                 const ObjCInterfaceDecl *OID,
88                                                 llvm::Value *BaseValue,
89                                                 const ObjCIvarDecl *Ivar,
90                                                 unsigned CVRQualifiers,
91                                                 llvm::Value *Offset) {
92    // Compute (type*) ( (char *) BaseValue + Offset)
93    QualType IvarTy = Ivar->getType();
94    llvm::Type *LTy = CGF.CGM.getTypes().ConvertTypeForMem(IvarTy);
95    llvm::Value *V = CGF.Builder.CreateBitCast(BaseValue, CGF.Int8PtrTy);
96    V = CGF.Builder.CreateInBoundsGEP(V, Offset, "add.ptr");
97  
98    if (!Ivar->isBitField()) {
99      V = CGF.Builder.CreateBitCast(V, llvm::PointerType::getUnqual(LTy));
100      LValue LV = CGF.MakeNaturalAlignAddrLValue(V, IvarTy);
101      LV.getQuals().addCVRQualifiers(CVRQualifiers);
102      return LV;
103    }
104  
105    // We need to compute an access strategy for this bit-field. We are given the
106    // offset to the first byte in the bit-field, the sub-byte offset is taken
107    // from the original layout. We reuse the normal bit-field access strategy by
108    // treating this as an access to a struct where the bit-field is in byte 0,
109    // and adjust the containing type size as appropriate.
110    //
111    // FIXME: Note that currently we make a very conservative estimate of the
112    // alignment of the bit-field, because (a) it is not clear what guarantees the
113    // runtime makes us, and (b) we don't have a way to specify that the struct is
114    // at an alignment plus offset.
115    //
116    // Note, there is a subtle invariant here: we can only call this routine on
117    // non-synthesized ivars but we may be called for synthesized ivars.  However,
118    // a synthesized ivar can never be a bit-field, so this is safe.
119    uint64_t FieldBitOffset = LookupFieldBitOffset(CGF.CGM, OID, nullptr, Ivar);
120    uint64_t BitOffset = FieldBitOffset % CGF.CGM.getContext().getCharWidth();
121    uint64_t AlignmentBits = CGF.CGM.getTarget().getCharAlign();
122    uint64_t BitFieldSize = Ivar->getBitWidthValue(CGF.getContext());
123    CharUnits StorageSize = CGF.CGM.getContext().toCharUnitsFromBits(
124        llvm::alignTo(BitOffset + BitFieldSize, AlignmentBits));
125    CharUnits Alignment = CGF.CGM.getContext().toCharUnitsFromBits(AlignmentBits);
126  
127    // Allocate a new CGBitFieldInfo object to describe this access.
128    //
129    // FIXME: This is incredibly wasteful, these should be uniqued or part of some
130    // layout object. However, this is blocked on other cleanups to the
131    // Objective-C code, so for now we just live with allocating a bunch of these
132    // objects.
133    CGBitFieldInfo *Info = new (CGF.CGM.getContext()) CGBitFieldInfo(
134      CGBitFieldInfo::MakeInfo(CGF.CGM.getTypes(), Ivar, BitOffset, BitFieldSize,
135                               CGF.CGM.getContext().toBits(StorageSize),
136                               CharUnits::fromQuantity(0)));
137  
138    Address Addr(V, Alignment);
139    Addr = CGF.Builder.CreateElementBitCast(Addr,
140                                     llvm::Type::getIntNTy(CGF.getLLVMContext(),
141                                                           Info->StorageSize));
142    return LValue::MakeBitfield(Addr, *Info,
143                                IvarTy.withCVRQualifiers(CVRQualifiers),
144                                AlignmentSource::Decl);
145  }
146  
147  namespace {
148    struct CatchHandler {
149      const VarDecl *Variable;
150      const Stmt *Body;
151      llvm::BasicBlock *Block;
152      llvm::Constant *TypeInfo;
153    };
154  
155    struct CallObjCEndCatch final : EHScopeStack::Cleanup {
CallObjCEndCatch__anona71e1ea20111::CallObjCEndCatch156      CallObjCEndCatch(bool MightThrow, llvm::Value *Fn) :
157        MightThrow(MightThrow), Fn(Fn) {}
158      bool MightThrow;
159      llvm::Value *Fn;
160  
Emit__anona71e1ea20111::CallObjCEndCatch161      void Emit(CodeGenFunction &CGF, Flags flags) override {
162        if (!MightThrow) {
163          CGF.Builder.CreateCall(Fn)->setDoesNotThrow();
164          return;
165        }
166  
167        CGF.EmitRuntimeCallOrInvoke(Fn);
168      }
169    };
170  }
171  
172  
EmitTryCatchStmt(CodeGenFunction & CGF,const ObjCAtTryStmt & S,llvm::Constant * beginCatchFn,llvm::Constant * endCatchFn,llvm::Constant * exceptionRethrowFn)173  void CGObjCRuntime::EmitTryCatchStmt(CodeGenFunction &CGF,
174                                       const ObjCAtTryStmt &S,
175                                       llvm::Constant *beginCatchFn,
176                                       llvm::Constant *endCatchFn,
177                                       llvm::Constant *exceptionRethrowFn) {
178    // Jump destination for falling out of catch bodies.
179    CodeGenFunction::JumpDest Cont;
180    if (S.getNumCatchStmts())
181      Cont = CGF.getJumpDestInCurrentScope("eh.cont");
182  
183    CodeGenFunction::FinallyInfo FinallyInfo;
184    if (const ObjCAtFinallyStmt *Finally = S.getFinallyStmt())
185      FinallyInfo.enter(CGF, Finally->getFinallyBody(),
186                        beginCatchFn, endCatchFn, exceptionRethrowFn);
187  
188    SmallVector<CatchHandler, 8> Handlers;
189  
190    // Enter the catch, if there is one.
191    if (S.getNumCatchStmts()) {
192      for (unsigned I = 0, N = S.getNumCatchStmts(); I != N; ++I) {
193        const ObjCAtCatchStmt *CatchStmt = S.getCatchStmt(I);
194        const VarDecl *CatchDecl = CatchStmt->getCatchParamDecl();
195  
196        Handlers.push_back(CatchHandler());
197        CatchHandler &Handler = Handlers.back();
198        Handler.Variable = CatchDecl;
199        Handler.Body = CatchStmt->getCatchBody();
200        Handler.Block = CGF.createBasicBlock("catch");
201  
202        // @catch(...) always matches.
203        if (!CatchDecl) {
204          Handler.TypeInfo = nullptr; // catch-all
205          // Don't consider any other catches.
206          break;
207        }
208  
209        Handler.TypeInfo = GetEHType(CatchDecl->getType());
210      }
211  
212      EHCatchScope *Catch = CGF.EHStack.pushCatch(Handlers.size());
213      for (unsigned I = 0, E = Handlers.size(); I != E; ++I)
214        Catch->setHandler(I, Handlers[I].TypeInfo, Handlers[I].Block);
215    }
216  
217    // Emit the try body.
218    CGF.EmitStmt(S.getTryBody());
219  
220    // Leave the try.
221    if (S.getNumCatchStmts())
222      CGF.popCatchScope();
223  
224    // Remember where we were.
225    CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
226  
227    // Emit the handlers.
228    for (unsigned I = 0, E = Handlers.size(); I != E; ++I) {
229      CatchHandler &Handler = Handlers[I];
230  
231      CGF.EmitBlock(Handler.Block);
232      llvm::Value *RawExn = CGF.getExceptionFromSlot();
233  
234      // Enter the catch.
235      llvm::Value *Exn = RawExn;
236      if (beginCatchFn) {
237        Exn = CGF.Builder.CreateCall(beginCatchFn, RawExn, "exn.adjusted");
238        cast<llvm::CallInst>(Exn)->setDoesNotThrow();
239      }
240  
241      CodeGenFunction::LexicalScope cleanups(CGF, Handler.Body->getSourceRange());
242  
243      if (endCatchFn) {
244        // Add a cleanup to leave the catch.
245        bool EndCatchMightThrow = (Handler.Variable == nullptr);
246  
247        CGF.EHStack.pushCleanup<CallObjCEndCatch>(NormalAndEHCleanup,
248                                                  EndCatchMightThrow,
249                                                  endCatchFn);
250      }
251  
252      // Bind the catch parameter if it exists.
253      if (const VarDecl *CatchParam = Handler.Variable) {
254        llvm::Type *CatchType = CGF.ConvertType(CatchParam->getType());
255        llvm::Value *CastExn = CGF.Builder.CreateBitCast(Exn, CatchType);
256  
257        CGF.EmitAutoVarDecl(*CatchParam);
258        EmitInitOfCatchParam(CGF, CastExn, CatchParam);
259      }
260  
261      CGF.ObjCEHValueStack.push_back(Exn);
262      CGF.EmitStmt(Handler.Body);
263      CGF.ObjCEHValueStack.pop_back();
264  
265      // Leave any cleanups associated with the catch.
266      cleanups.ForceCleanup();
267  
268      CGF.EmitBranchThroughCleanup(Cont);
269    }
270  
271    // Go back to the try-statement fallthrough.
272    CGF.Builder.restoreIP(SavedIP);
273  
274    // Pop out of the finally.
275    if (S.getFinallyStmt())
276      FinallyInfo.exit(CGF);
277  
278    if (Cont.isValid())
279      CGF.EmitBlock(Cont.getBlock());
280  }
281  
EmitInitOfCatchParam(CodeGenFunction & CGF,llvm::Value * exn,const VarDecl * paramDecl)282  void CGObjCRuntime::EmitInitOfCatchParam(CodeGenFunction &CGF,
283                                           llvm::Value *exn,
284                                           const VarDecl *paramDecl) {
285  
286    Address paramAddr = CGF.GetAddrOfLocalVar(paramDecl);
287  
288    switch (paramDecl->getType().getQualifiers().getObjCLifetime()) {
289    case Qualifiers::OCL_Strong:
290      exn = CGF.EmitARCRetainNonBlock(exn);
291      // fallthrough
292  
293    case Qualifiers::OCL_None:
294    case Qualifiers::OCL_ExplicitNone:
295    case Qualifiers::OCL_Autoreleasing:
296      CGF.Builder.CreateStore(exn, paramAddr);
297      return;
298  
299    case Qualifiers::OCL_Weak:
300      CGF.EmitARCInitWeak(paramAddr, exn);
301      return;
302    }
303    llvm_unreachable("invalid ownership qualifier");
304  }
305  
306  namespace {
307    struct CallSyncExit final : EHScopeStack::Cleanup {
308      llvm::Value *SyncExitFn;
309      llvm::Value *SyncArg;
CallSyncExit__anona71e1ea20211::CallSyncExit310      CallSyncExit(llvm::Value *SyncExitFn, llvm::Value *SyncArg)
311        : SyncExitFn(SyncExitFn), SyncArg(SyncArg) {}
312  
Emit__anona71e1ea20211::CallSyncExit313      void Emit(CodeGenFunction &CGF, Flags flags) override {
314        CGF.Builder.CreateCall(SyncExitFn, SyncArg)->setDoesNotThrow();
315      }
316    };
317  }
318  
EmitAtSynchronizedStmt(CodeGenFunction & CGF,const ObjCAtSynchronizedStmt & S,llvm::Function * syncEnterFn,llvm::Function * syncExitFn)319  void CGObjCRuntime::EmitAtSynchronizedStmt(CodeGenFunction &CGF,
320                                             const ObjCAtSynchronizedStmt &S,
321                                             llvm::Function *syncEnterFn,
322                                             llvm::Function *syncExitFn) {
323    CodeGenFunction::RunCleanupsScope cleanups(CGF);
324  
325    // Evaluate the lock operand.  This is guaranteed to dominate the
326    // ARC release and lock-release cleanups.
327    const Expr *lockExpr = S.getSynchExpr();
328    llvm::Value *lock;
329    if (CGF.getLangOpts().ObjCAutoRefCount) {
330      lock = CGF.EmitARCRetainScalarExpr(lockExpr);
331      lock = CGF.EmitObjCConsumeObject(lockExpr->getType(), lock);
332    } else {
333      lock = CGF.EmitScalarExpr(lockExpr);
334    }
335    lock = CGF.Builder.CreateBitCast(lock, CGF.VoidPtrTy);
336  
337    // Acquire the lock.
338    CGF.Builder.CreateCall(syncEnterFn, lock)->setDoesNotThrow();
339  
340    // Register an all-paths cleanup to release the lock.
341    CGF.EHStack.pushCleanup<CallSyncExit>(NormalAndEHCleanup, syncExitFn, lock);
342  
343    // Emit the body of the statement.
344    CGF.EmitStmt(S.getSynchBody());
345  }
346  
347  /// Compute the pointer-to-function type to which a message send
348  /// should be casted in order to correctly call the given method
349  /// with the given arguments.
350  ///
351  /// \param method - may be null
352  /// \param resultType - the result type to use if there's no method
353  /// \param callArgs - the actual arguments, including implicit ones
354  CGObjCRuntime::MessageSendInfo
getMessageSendInfo(const ObjCMethodDecl * method,QualType resultType,CallArgList & callArgs)355  CGObjCRuntime::getMessageSendInfo(const ObjCMethodDecl *method,
356                                    QualType resultType,
357                                    CallArgList &callArgs) {
358    // If there's a method, use information from that.
359    if (method) {
360      const CGFunctionInfo &signature =
361        CGM.getTypes().arrangeObjCMessageSendSignature(method, callArgs[0].Ty);
362  
363      llvm::PointerType *signatureType =
364        CGM.getTypes().GetFunctionType(signature)->getPointerTo();
365  
366      const CGFunctionInfo &signatureForCall =
367        CGM.getTypes().arrangeCall(signature, callArgs);
368  
369      return MessageSendInfo(signatureForCall, signatureType);
370    }
371  
372    // There's no method;  just use a default CC.
373    const CGFunctionInfo &argsInfo =
374      CGM.getTypes().arrangeUnprototypedObjCMessageSend(resultType, callArgs);
375  
376    // Derive the signature to call from that.
377    llvm::PointerType *signatureType =
378      CGM.getTypes().GetFunctionType(argsInfo)->getPointerTo();
379    return MessageSendInfo(argsInfo, signatureType);
380  }
381