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