CGObjCMac.cpp revision 3715328021f69ed55e7b4cd65465fc761a8b6457
1//===------- CGObjCMac.cpp - Interface to Apple Objective-C Runtime -------===// 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 provides Objective-C code generation targetting the Apple runtime. 11// 12//===----------------------------------------------------------------------===// 13 14#include "CGObjCRuntime.h" 15 16#include "CodeGenModule.h" 17#include "CodeGenFunction.h" 18#include "clang/AST/ASTContext.h" 19#include "clang/AST/Decl.h" 20#include "clang/AST/DeclObjC.h" 21#include "clang/AST/RecordLayout.h" 22#include "clang/AST/StmtObjC.h" 23#include "clang/Basic/LangOptions.h" 24 25#include "llvm/Intrinsics.h" 26#include "llvm/Module.h" 27#include "llvm/ADT/DenseSet.h" 28#include "llvm/Target/TargetData.h" 29#include <sstream> 30 31using namespace clang; 32using namespace CodeGen; 33 34// Common CGObjCRuntime functions, these don't belong here, but they 35// don't belong in CGObjCRuntime either so we will live with it for 36// now. 37 38/// FindIvarInterface - Find the interface containing the ivar. 39/// 40/// FIXME: We shouldn't need to do this, the containing context should 41/// be fixed. 42static const ObjCInterfaceDecl *FindIvarInterface(ASTContext &Context, 43 const ObjCInterfaceDecl *OID, 44 const ObjCIvarDecl *OIVD, 45 unsigned &Index) { 46 const ObjCInterfaceDecl *Super = OID->getSuperClass(); 47 48 // FIXME: The index here is closely tied to how 49 // ASTContext::getObjCLayout is implemented. This should be fixed to 50 // get the information from the layout directly. 51 Index = 0; 52 for (ObjCInterfaceDecl::ivar_iterator IVI = OID->ivar_begin(), 53 IVE = OID->ivar_end(); IVI != IVE; ++IVI, ++Index) 54 if (OIVD == *IVI) 55 return OID; 56 57 // Also look in synthesized ivars. 58 for (ObjCInterfaceDecl::prop_iterator I = OID->prop_begin(Context), 59 E = OID->prop_end(Context); I != E; ++I) { 60 if (ObjCIvarDecl *Ivar = (*I)->getPropertyIvarDecl()) { 61 if (OIVD == Ivar) 62 return OID; 63 ++Index; 64 } 65 } 66 67 // Otherwise check in the super class. 68 if (Super) 69 return FindIvarInterface(Context, Super, OIVD, Index); 70 71 return 0; 72} 73 74static uint64_t LookupFieldBitOffset(CodeGen::CodeGenModule &CGM, 75 const ObjCInterfaceDecl *OID, 76 const ObjCImplementationDecl *ID, 77 const ObjCIvarDecl *Ivar) { 78 unsigned Index; 79 const ObjCInterfaceDecl *Container = 80 FindIvarInterface(CGM.getContext(), OID, Ivar, Index); 81 assert(Container && "Unable to find ivar container"); 82 83 // If we know have an implementation (and the ivar is in it) then 84 // look up in the implementation layout. 85 const ASTRecordLayout *RL; 86 if (ID && ID->getClassInterface() == Container) 87 RL = &CGM.getContext().getASTObjCImplementationLayout(ID); 88 else 89 RL = &CGM.getContext().getASTObjCInterfaceLayout(Container); 90 return RL->getFieldOffset(Index); 91} 92 93uint64_t CGObjCRuntime::ComputeIvarBaseOffset(CodeGen::CodeGenModule &CGM, 94 const ObjCInterfaceDecl *OID, 95 const ObjCIvarDecl *Ivar) { 96 return LookupFieldBitOffset(CGM, OID, 0, Ivar) / 8; 97} 98 99uint64_t CGObjCRuntime::ComputeIvarBaseOffset(CodeGen::CodeGenModule &CGM, 100 const ObjCImplementationDecl *OID, 101 const ObjCIvarDecl *Ivar) { 102 return LookupFieldBitOffset(CGM, OID->getClassInterface(), OID, Ivar) / 8; 103} 104 105LValue CGObjCRuntime::EmitValueForIvarAtOffset(CodeGen::CodeGenFunction &CGF, 106 const ObjCInterfaceDecl *OID, 107 llvm::Value *BaseValue, 108 const ObjCIvarDecl *Ivar, 109 unsigned CVRQualifiers, 110 llvm::Value *Offset) { 111 // Compute (type*) ( (char *) BaseValue + Offset) 112 llvm::Type *I8Ptr = llvm::PointerType::getUnqual(llvm::Type::Int8Ty); 113 QualType IvarTy = Ivar->getType(); 114 const llvm::Type *LTy = CGF.CGM.getTypes().ConvertTypeForMem(IvarTy); 115 llvm::Value *V = CGF.Builder.CreateBitCast(BaseValue, I8Ptr); 116 V = CGF.Builder.CreateGEP(V, Offset, "add.ptr"); 117 V = CGF.Builder.CreateBitCast(V, llvm::PointerType::getUnqual(LTy)); 118 119 if (Ivar->isBitField()) { 120 // We need to compute the bit offset for the bit-field, the offset 121 // is to the byte. Note, there is a subtle invariant here: we can 122 // only call this routine on non-sythesized ivars but we may be 123 // called for synthesized ivars. However, a synthesized ivar can 124 // never be a bit-field so this is safe. 125 uint64_t BitOffset = LookupFieldBitOffset(CGF.CGM, OID, 0, Ivar) % 8; 126 127 uint64_t BitFieldSize = 128 Ivar->getBitWidth()->EvaluateAsInt(CGF.getContext()).getZExtValue(); 129 return LValue::MakeBitfield(V, BitOffset, BitFieldSize, 130 IvarTy->isSignedIntegerType(), 131 IvarTy.getCVRQualifiers()|CVRQualifiers); 132 } 133 134 LValue LV = LValue::MakeAddr(V, IvarTy.getCVRQualifiers()|CVRQualifiers, 135 CGF.CGM.getContext().getObjCGCAttrKind(IvarTy)); 136 LValue::SetObjCIvar(LV, true); 137 return LV; 138} 139 140/// 141 142namespace { 143 144 typedef std::vector<llvm::Constant*> ConstantVector; 145 146 // FIXME: We should find a nicer way to make the labels for 147 // metadata, string concatenation is lame. 148 149class ObjCCommonTypesHelper { 150protected: 151 CodeGen::CodeGenModule &CGM; 152 153public: 154 const llvm::Type *ShortTy, *IntTy, *LongTy, *LongLongTy; 155 const llvm::Type *Int8PtrTy; 156 157 /// ObjectPtrTy - LLVM type for object handles (typeof(id)) 158 const llvm::Type *ObjectPtrTy; 159 160 /// PtrObjectPtrTy - LLVM type for id * 161 const llvm::Type *PtrObjectPtrTy; 162 163 /// SelectorPtrTy - LLVM type for selector handles (typeof(SEL)) 164 const llvm::Type *SelectorPtrTy; 165 /// ProtocolPtrTy - LLVM type for external protocol handles 166 /// (typeof(Protocol)) 167 const llvm::Type *ExternalProtocolPtrTy; 168 169 // SuperCTy - clang type for struct objc_super. 170 QualType SuperCTy; 171 // SuperPtrCTy - clang type for struct objc_super *. 172 QualType SuperPtrCTy; 173 174 /// SuperTy - LLVM type for struct objc_super. 175 const llvm::StructType *SuperTy; 176 /// SuperPtrTy - LLVM type for struct objc_super *. 177 const llvm::Type *SuperPtrTy; 178 179 /// PropertyTy - LLVM type for struct objc_property (struct _prop_t 180 /// in GCC parlance). 181 const llvm::StructType *PropertyTy; 182 183 /// PropertyListTy - LLVM type for struct objc_property_list 184 /// (_prop_list_t in GCC parlance). 185 const llvm::StructType *PropertyListTy; 186 /// PropertyListPtrTy - LLVM type for struct objc_property_list*. 187 const llvm::Type *PropertyListPtrTy; 188 189 // MethodTy - LLVM type for struct objc_method. 190 const llvm::StructType *MethodTy; 191 192 /// CacheTy - LLVM type for struct objc_cache. 193 const llvm::Type *CacheTy; 194 /// CachePtrTy - LLVM type for struct objc_cache *. 195 const llvm::Type *CachePtrTy; 196 197 llvm::Constant *getGetPropertyFn() { 198 CodeGen::CodeGenTypes &Types = CGM.getTypes(); 199 ASTContext &Ctx = CGM.getContext(); 200 // id objc_getProperty (id, SEL, ptrdiff_t, bool) 201 llvm::SmallVector<QualType,16> Params; 202 QualType IdType = Ctx.getObjCIdType(); 203 QualType SelType = Ctx.getObjCSelType(); 204 Params.push_back(IdType); 205 Params.push_back(SelType); 206 Params.push_back(Ctx.LongTy); 207 Params.push_back(Ctx.BoolTy); 208 const llvm::FunctionType *FTy = 209 Types.GetFunctionType(Types.getFunctionInfo(IdType, Params), false); 210 return CGM.CreateRuntimeFunction(FTy, "objc_getProperty"); 211 } 212 213 llvm::Constant *getSetPropertyFn() { 214 CodeGen::CodeGenTypes &Types = CGM.getTypes(); 215 ASTContext &Ctx = CGM.getContext(); 216 // void objc_setProperty (id, SEL, ptrdiff_t, id, bool, bool) 217 llvm::SmallVector<QualType,16> Params; 218 QualType IdType = Ctx.getObjCIdType(); 219 QualType SelType = Ctx.getObjCSelType(); 220 Params.push_back(IdType); 221 Params.push_back(SelType); 222 Params.push_back(Ctx.LongTy); 223 Params.push_back(IdType); 224 Params.push_back(Ctx.BoolTy); 225 Params.push_back(Ctx.BoolTy); 226 const llvm::FunctionType *FTy = 227 Types.GetFunctionType(Types.getFunctionInfo(Ctx.VoidTy, Params), false); 228 return CGM.CreateRuntimeFunction(FTy, "objc_setProperty"); 229 } 230 231 llvm::Constant *getEnumerationMutationFn() { 232 // void objc_enumerationMutation (id) 233 std::vector<const llvm::Type*> Args; 234 Args.push_back(ObjectPtrTy); 235 llvm::FunctionType *FTy = 236 llvm::FunctionType::get(llvm::Type::VoidTy, Args, false); 237 return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation"); 238 } 239 240 /// GcReadWeakFn -- LLVM objc_read_weak (id *src) function. 241 llvm::Constant *getGcReadWeakFn() { 242 // id objc_read_weak (id *) 243 std::vector<const llvm::Type*> Args; 244 Args.push_back(ObjectPtrTy->getPointerTo()); 245 llvm::FunctionType *FTy = llvm::FunctionType::get(ObjectPtrTy, Args, false); 246 return CGM.CreateRuntimeFunction(FTy, "objc_read_weak"); 247 } 248 249 /// GcAssignWeakFn -- LLVM objc_assign_weak function. 250 llvm::Constant *getGcAssignWeakFn() { 251 // id objc_assign_weak (id, id *) 252 std::vector<const llvm::Type*> Args(1, ObjectPtrTy); 253 Args.push_back(ObjectPtrTy->getPointerTo()); 254 llvm::FunctionType *FTy = 255 llvm::FunctionType::get(ObjectPtrTy, Args, false); 256 return CGM.CreateRuntimeFunction(FTy, "objc_assign_weak"); 257 } 258 259 /// GcAssignGlobalFn -- LLVM objc_assign_global function. 260 llvm::Constant *getGcAssignGlobalFn() { 261 // id objc_assign_global(id, id *) 262 std::vector<const llvm::Type*> Args(1, ObjectPtrTy); 263 Args.push_back(ObjectPtrTy->getPointerTo()); 264 llvm::FunctionType *FTy = llvm::FunctionType::get(ObjectPtrTy, Args, false); 265 return CGM.CreateRuntimeFunction(FTy, "objc_assign_global"); 266 } 267 268 /// GcAssignIvarFn -- LLVM objc_assign_ivar function. 269 llvm::Constant *getGcAssignIvarFn() { 270 // id objc_assign_ivar(id, id *) 271 std::vector<const llvm::Type*> Args(1, ObjectPtrTy); 272 Args.push_back(ObjectPtrTy->getPointerTo()); 273 llvm::FunctionType *FTy = llvm::FunctionType::get(ObjectPtrTy, Args, false); 274 return CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar"); 275 } 276 277 /// GcAssignStrongCastFn -- LLVM objc_assign_strongCast function. 278 llvm::Constant *getGcAssignStrongCastFn() { 279 // id objc_assign_global(id, id *) 280 std::vector<const llvm::Type*> Args(1, ObjectPtrTy); 281 Args.push_back(ObjectPtrTy->getPointerTo()); 282 llvm::FunctionType *FTy = llvm::FunctionType::get(ObjectPtrTy, Args, false); 283 return CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast"); 284 } 285 286 /// ExceptionThrowFn - LLVM objc_exception_throw function. 287 llvm::Constant *getExceptionThrowFn() { 288 // void objc_exception_throw(id) 289 std::vector<const llvm::Type*> Args(1, ObjectPtrTy); 290 llvm::FunctionType *FTy = 291 llvm::FunctionType::get(llvm::Type::VoidTy, Args, false); 292 return CGM.CreateRuntimeFunction(FTy, "objc_exception_throw"); 293 } 294 295 /// SyncEnterFn - LLVM object_sync_enter function. 296 llvm::Constant *getSyncEnterFn() { 297 // void objc_sync_enter (id) 298 std::vector<const llvm::Type*> Args(1, ObjectPtrTy); 299 llvm::FunctionType *FTy = 300 llvm::FunctionType::get(llvm::Type::VoidTy, Args, false); 301 return CGM.CreateRuntimeFunction(FTy, "objc_sync_enter"); 302 } 303 304 /// SyncExitFn - LLVM object_sync_exit function. 305 llvm::Constant *getSyncExitFn() { 306 // void objc_sync_exit (id) 307 std::vector<const llvm::Type*> Args(1, ObjectPtrTy); 308 llvm::FunctionType *FTy = 309 llvm::FunctionType::get(llvm::Type::VoidTy, Args, false); 310 return CGM.CreateRuntimeFunction(FTy, "objc_sync_exit"); 311 } 312 313 ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm); 314 ~ObjCCommonTypesHelper(){} 315}; 316 317/// ObjCTypesHelper - Helper class that encapsulates lazy 318/// construction of varies types used during ObjC generation. 319class ObjCTypesHelper : public ObjCCommonTypesHelper { 320private: 321 322 llvm::Constant *getMessageSendFn() { 323 // id objc_msgSend (id, SEL, ...) 324 std::vector<const llvm::Type*> Params; 325 Params.push_back(ObjectPtrTy); 326 Params.push_back(SelectorPtrTy); 327 return 328 CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 329 Params, true), 330 "objc_msgSend"); 331 } 332 333 llvm::Constant *getMessageSendStretFn() { 334 // id objc_msgSend_stret (id, SEL, ...) 335 std::vector<const llvm::Type*> Params; 336 Params.push_back(ObjectPtrTy); 337 Params.push_back(SelectorPtrTy); 338 return 339 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::VoidTy, 340 Params, true), 341 "objc_msgSend_stret"); 342 343 } 344 345 llvm::Constant *getMessageSendFpretFn() { 346 // FIXME: This should be long double on x86_64? 347 // [double | long double] objc_msgSend_fpret(id self, SEL op, ...) 348 std::vector<const llvm::Type*> Params; 349 Params.push_back(ObjectPtrTy); 350 Params.push_back(SelectorPtrTy); 351 return 352 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::DoubleTy, 353 Params, 354 true), 355 "objc_msgSend_fpret"); 356 357 } 358 359 llvm::Constant *getMessageSendSuperFn() { 360 // id objc_msgSendSuper(struct objc_super *super, SEL op, ...) 361 std::vector<const llvm::Type*> Params; 362 Params.push_back(SuperPtrTy); 363 Params.push_back(SelectorPtrTy); 364 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 365 Params, true), 366 "objc_msgSendSuper"); 367 } 368 llvm::Constant *getMessageSendSuperStretFn() { 369 // void objc_msgSendSuper_stret(void * stretAddr, struct objc_super *super, 370 // SEL op, ...) 371 std::vector<const llvm::Type*> Params; 372 Params.push_back(Int8PtrTy); 373 Params.push_back(SuperPtrTy); 374 Params.push_back(SelectorPtrTy); 375 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::VoidTy, 376 Params, true), 377 "objc_msgSendSuper_stret"); 378 } 379 380 llvm::Constant *getMessageSendSuperFpretFn() { 381 // There is no objc_msgSendSuper_fpret? How can that work? 382 return getMessageSendSuperFn(); 383 } 384 385public: 386 /// SymtabTy - LLVM type for struct objc_symtab. 387 const llvm::StructType *SymtabTy; 388 /// SymtabPtrTy - LLVM type for struct objc_symtab *. 389 const llvm::Type *SymtabPtrTy; 390 /// ModuleTy - LLVM type for struct objc_module. 391 const llvm::StructType *ModuleTy; 392 393 /// ProtocolTy - LLVM type for struct objc_protocol. 394 const llvm::StructType *ProtocolTy; 395 /// ProtocolPtrTy - LLVM type for struct objc_protocol *. 396 const llvm::Type *ProtocolPtrTy; 397 /// ProtocolExtensionTy - LLVM type for struct 398 /// objc_protocol_extension. 399 const llvm::StructType *ProtocolExtensionTy; 400 /// ProtocolExtensionTy - LLVM type for struct 401 /// objc_protocol_extension *. 402 const llvm::Type *ProtocolExtensionPtrTy; 403 /// MethodDescriptionTy - LLVM type for struct 404 /// objc_method_description. 405 const llvm::StructType *MethodDescriptionTy; 406 /// MethodDescriptionListTy - LLVM type for struct 407 /// objc_method_description_list. 408 const llvm::StructType *MethodDescriptionListTy; 409 /// MethodDescriptionListPtrTy - LLVM type for struct 410 /// objc_method_description_list *. 411 const llvm::Type *MethodDescriptionListPtrTy; 412 /// ProtocolListTy - LLVM type for struct objc_property_list. 413 const llvm::Type *ProtocolListTy; 414 /// ProtocolListPtrTy - LLVM type for struct objc_property_list*. 415 const llvm::Type *ProtocolListPtrTy; 416 /// CategoryTy - LLVM type for struct objc_category. 417 const llvm::StructType *CategoryTy; 418 /// ClassTy - LLVM type for struct objc_class. 419 const llvm::StructType *ClassTy; 420 /// ClassPtrTy - LLVM type for struct objc_class *. 421 const llvm::Type *ClassPtrTy; 422 /// ClassExtensionTy - LLVM type for struct objc_class_ext. 423 const llvm::StructType *ClassExtensionTy; 424 /// ClassExtensionPtrTy - LLVM type for struct objc_class_ext *. 425 const llvm::Type *ClassExtensionPtrTy; 426 // IvarTy - LLVM type for struct objc_ivar. 427 const llvm::StructType *IvarTy; 428 /// IvarListTy - LLVM type for struct objc_ivar_list. 429 const llvm::Type *IvarListTy; 430 /// IvarListPtrTy - LLVM type for struct objc_ivar_list *. 431 const llvm::Type *IvarListPtrTy; 432 /// MethodListTy - LLVM type for struct objc_method_list. 433 const llvm::Type *MethodListTy; 434 /// MethodListPtrTy - LLVM type for struct objc_method_list *. 435 const llvm::Type *MethodListPtrTy; 436 437 /// ExceptionDataTy - LLVM type for struct _objc_exception_data. 438 const llvm::Type *ExceptionDataTy; 439 440 /// ExceptionTryEnterFn - LLVM objc_exception_try_enter function. 441 llvm::Constant *getExceptionTryEnterFn() { 442 std::vector<const llvm::Type*> Params; 443 Params.push_back(llvm::PointerType::getUnqual(ExceptionDataTy)); 444 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::VoidTy, 445 Params, false), 446 "objc_exception_try_enter"); 447 } 448 449 /// ExceptionTryExitFn - LLVM objc_exception_try_exit function. 450 llvm::Constant *getExceptionTryExitFn() { 451 std::vector<const llvm::Type*> Params; 452 Params.push_back(llvm::PointerType::getUnqual(ExceptionDataTy)); 453 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::VoidTy, 454 Params, false), 455 "objc_exception_try_exit"); 456 } 457 458 /// ExceptionExtractFn - LLVM objc_exception_extract function. 459 llvm::Constant *getExceptionExtractFn() { 460 std::vector<const llvm::Type*> Params; 461 Params.push_back(llvm::PointerType::getUnqual(ExceptionDataTy)); 462 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 463 Params, false), 464 "objc_exception_extract"); 465 466 } 467 468 /// ExceptionMatchFn - LLVM objc_exception_match function. 469 llvm::Constant *getExceptionMatchFn() { 470 std::vector<const llvm::Type*> Params; 471 Params.push_back(ClassPtrTy); 472 Params.push_back(ObjectPtrTy); 473 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::Int32Ty, 474 Params, false), 475 "objc_exception_match"); 476 477 } 478 479 /// SetJmpFn - LLVM _setjmp function. 480 llvm::Constant *getSetJmpFn() { 481 std::vector<const llvm::Type*> Params; 482 Params.push_back(llvm::PointerType::getUnqual(llvm::Type::Int32Ty)); 483 return 484 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::Int32Ty, 485 Params, false), 486 "_setjmp"); 487 488 } 489 490public: 491 ObjCTypesHelper(CodeGen::CodeGenModule &cgm); 492 ~ObjCTypesHelper() {} 493 494 495 llvm::Constant *getSendFn(bool IsSuper) { 496 return IsSuper ? getMessageSendSuperFn() : getMessageSendFn(); 497 } 498 499 llvm::Constant *getSendStretFn(bool IsSuper) { 500 return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn(); 501 } 502 503 llvm::Constant *getSendFpretFn(bool IsSuper) { 504 return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn(); 505 } 506}; 507 508/// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's 509/// modern abi 510class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper { 511public: 512 513 // MethodListnfABITy - LLVM for struct _method_list_t 514 const llvm::StructType *MethodListnfABITy; 515 516 // MethodListnfABIPtrTy - LLVM for struct _method_list_t* 517 const llvm::Type *MethodListnfABIPtrTy; 518 519 // ProtocolnfABITy = LLVM for struct _protocol_t 520 const llvm::StructType *ProtocolnfABITy; 521 522 // ProtocolnfABIPtrTy = LLVM for struct _protocol_t* 523 const llvm::Type *ProtocolnfABIPtrTy; 524 525 // ProtocolListnfABITy - LLVM for struct _objc_protocol_list 526 const llvm::StructType *ProtocolListnfABITy; 527 528 // ProtocolListnfABIPtrTy - LLVM for struct _objc_protocol_list* 529 const llvm::Type *ProtocolListnfABIPtrTy; 530 531 // ClassnfABITy - LLVM for struct _class_t 532 const llvm::StructType *ClassnfABITy; 533 534 // ClassnfABIPtrTy - LLVM for struct _class_t* 535 const llvm::Type *ClassnfABIPtrTy; 536 537 // IvarnfABITy - LLVM for struct _ivar_t 538 const llvm::StructType *IvarnfABITy; 539 540 // IvarListnfABITy - LLVM for struct _ivar_list_t 541 const llvm::StructType *IvarListnfABITy; 542 543 // IvarListnfABIPtrTy = LLVM for struct _ivar_list_t* 544 const llvm::Type *IvarListnfABIPtrTy; 545 546 // ClassRonfABITy - LLVM for struct _class_ro_t 547 const llvm::StructType *ClassRonfABITy; 548 549 // ImpnfABITy - LLVM for id (*)(id, SEL, ...) 550 const llvm::Type *ImpnfABITy; 551 552 // CategorynfABITy - LLVM for struct _category_t 553 const llvm::StructType *CategorynfABITy; 554 555 // New types for nonfragile abi messaging. 556 557 // MessageRefTy - LLVM for: 558 // struct _message_ref_t { 559 // IMP messenger; 560 // SEL name; 561 // }; 562 const llvm::StructType *MessageRefTy; 563 // MessageRefCTy - clang type for struct _message_ref_t 564 QualType MessageRefCTy; 565 566 // MessageRefPtrTy - LLVM for struct _message_ref_t* 567 const llvm::Type *MessageRefPtrTy; 568 // MessageRefCPtrTy - clang type for struct _message_ref_t* 569 QualType MessageRefCPtrTy; 570 571 // MessengerTy - Type of the messenger (shown as IMP above) 572 const llvm::FunctionType *MessengerTy; 573 574 // SuperMessageRefTy - LLVM for: 575 // struct _super_message_ref_t { 576 // SUPER_IMP messenger; 577 // SEL name; 578 // }; 579 const llvm::StructType *SuperMessageRefTy; 580 581 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t* 582 const llvm::Type *SuperMessageRefPtrTy; 583 584 llvm::Constant *getMessageSendFixupFn() { 585 // id objc_msgSend_fixup(id, struct message_ref_t*, ...) 586 std::vector<const llvm::Type*> Params; 587 Params.push_back(ObjectPtrTy); 588 Params.push_back(MessageRefPtrTy); 589 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 590 Params, true), 591 "objc_msgSend_fixup"); 592 } 593 594 llvm::Constant *getMessageSendFpretFixupFn() { 595 // id objc_msgSend_fpret_fixup(id, struct message_ref_t*, ...) 596 std::vector<const llvm::Type*> Params; 597 Params.push_back(ObjectPtrTy); 598 Params.push_back(MessageRefPtrTy); 599 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 600 Params, true), 601 "objc_msgSend_fpret_fixup"); 602 } 603 604 llvm::Constant *getMessageSendStretFixupFn() { 605 // id objc_msgSend_stret_fixup(id, struct message_ref_t*, ...) 606 std::vector<const llvm::Type*> Params; 607 Params.push_back(ObjectPtrTy); 608 Params.push_back(MessageRefPtrTy); 609 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 610 Params, true), 611 "objc_msgSend_stret_fixup"); 612 } 613 614 llvm::Constant *getMessageSendIdFixupFn() { 615 // id objc_msgSendId_fixup(id, struct message_ref_t*, ...) 616 std::vector<const llvm::Type*> Params; 617 Params.push_back(ObjectPtrTy); 618 Params.push_back(MessageRefPtrTy); 619 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 620 Params, true), 621 "objc_msgSendId_fixup"); 622 } 623 624 llvm::Constant *getMessageSendIdStretFixupFn() { 625 // id objc_msgSendId_stret_fixup(id, struct message_ref_t*, ...) 626 std::vector<const llvm::Type*> Params; 627 Params.push_back(ObjectPtrTy); 628 Params.push_back(MessageRefPtrTy); 629 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 630 Params, true), 631 "objc_msgSendId_stret_fixup"); 632 } 633 llvm::Constant *getMessageSendSuper2FixupFn() { 634 // id objc_msgSendSuper2_fixup (struct objc_super *, 635 // struct _super_message_ref_t*, ...) 636 std::vector<const llvm::Type*> Params; 637 Params.push_back(SuperPtrTy); 638 Params.push_back(SuperMessageRefPtrTy); 639 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 640 Params, true), 641 "objc_msgSendSuper2_fixup"); 642 } 643 644 llvm::Constant *getMessageSendSuper2StretFixupFn() { 645 // id objc_msgSendSuper2_stret_fixup(struct objc_super *, 646 // struct _super_message_ref_t*, ...) 647 std::vector<const llvm::Type*> Params; 648 Params.push_back(SuperPtrTy); 649 Params.push_back(SuperMessageRefPtrTy); 650 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 651 Params, true), 652 "objc_msgSendSuper2_stret_fixup"); 653 } 654 655 656 657 /// EHPersonalityPtr - LLVM value for an i8* to the Objective-C 658 /// exception personality function. 659 llvm::Value *getEHPersonalityPtr() { 660 llvm::Constant *Personality = 661 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::Int32Ty, 662 std::vector<const llvm::Type*>(), 663 true), 664 "__objc_personality_v0"); 665 return llvm::ConstantExpr::getBitCast(Personality, Int8PtrTy); 666 } 667 668 llvm::Constant *getUnwindResumeOrRethrowFn() { 669 std::vector<const llvm::Type*> Params; 670 Params.push_back(Int8PtrTy); 671 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::VoidTy, 672 Params, false), 673 "_Unwind_Resume_or_Rethrow"); 674 } 675 676 llvm::Constant *getObjCEndCatchFn() { 677 std::vector<const llvm::Type*> Params; 678 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::VoidTy, 679 Params, false), 680 "objc_end_catch"); 681 682 } 683 684 llvm::Constant *getObjCBeginCatchFn() { 685 std::vector<const llvm::Type*> Params; 686 Params.push_back(Int8PtrTy); 687 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy, 688 Params, false), 689 "objc_begin_catch"); 690 } 691 692 const llvm::StructType *EHTypeTy; 693 const llvm::Type *EHTypePtrTy; 694 695 ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm); 696 ~ObjCNonFragileABITypesHelper(){} 697}; 698 699class CGObjCCommonMac : public CodeGen::CGObjCRuntime { 700public: 701 // FIXME - accessibility 702 class GC_IVAR { 703 public: 704 unsigned ivar_bytepos; 705 unsigned ivar_size; 706 GC_IVAR(unsigned bytepos = 0, unsigned size = 0) 707 : ivar_bytepos(bytepos), ivar_size(size) {} 708 709 // Allow sorting based on byte pos. 710 bool operator<(const GC_IVAR &b) const { 711 return ivar_bytepos < b.ivar_bytepos; 712 } 713 }; 714 715 class SKIP_SCAN { 716 public: 717 unsigned skip; 718 unsigned scan; 719 SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0) 720 : skip(_skip), scan(_scan) {} 721 }; 722 723protected: 724 CodeGen::CodeGenModule &CGM; 725 // FIXME! May not be needing this after all. 726 unsigned ObjCABI; 727 728 // gc ivar layout bitmap calculation helper caches. 729 llvm::SmallVector<GC_IVAR, 16> SkipIvars; 730 llvm::SmallVector<GC_IVAR, 16> IvarsInfo; 731 732 /// LazySymbols - Symbols to generate a lazy reference for. See 733 /// DefinedSymbols and FinishModule(). 734 std::set<IdentifierInfo*> LazySymbols; 735 736 /// DefinedSymbols - External symbols which are defined by this 737 /// module. The symbols in this list and LazySymbols are used to add 738 /// special linker symbols which ensure that Objective-C modules are 739 /// linked properly. 740 std::set<IdentifierInfo*> DefinedSymbols; 741 742 /// ClassNames - uniqued class names. 743 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassNames; 744 745 /// MethodVarNames - uniqued method variable names. 746 llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames; 747 748 /// MethodVarTypes - uniqued method type signatures. We have to use 749 /// a StringMap here because have no other unique reference. 750 llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes; 751 752 /// MethodDefinitions - map of methods which have been defined in 753 /// this translation unit. 754 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions; 755 756 /// PropertyNames - uniqued method variable names. 757 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames; 758 759 /// ClassReferences - uniqued class references. 760 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences; 761 762 /// SelectorReferences - uniqued selector references. 763 llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences; 764 765 /// Protocols - Protocols for which an objc_protocol structure has 766 /// been emitted. Forward declarations are handled by creating an 767 /// empty structure whose initializer is filled in when/if defined. 768 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols; 769 770 /// DefinedProtocols - Protocols which have actually been 771 /// defined. We should not need this, see FIXME in GenerateProtocol. 772 llvm::DenseSet<IdentifierInfo*> DefinedProtocols; 773 774 /// DefinedClasses - List of defined classes. 775 std::vector<llvm::GlobalValue*> DefinedClasses; 776 777 /// DefinedCategories - List of defined categories. 778 std::vector<llvm::GlobalValue*> DefinedCategories; 779 780 /// UsedGlobals - List of globals to pack into the llvm.used metadata 781 /// to prevent them from being clobbered. 782 std::vector<llvm::GlobalVariable*> UsedGlobals; 783 784 /// GetNameForMethod - Return a name for the given method. 785 /// \param[out] NameOut - The return value. 786 void GetNameForMethod(const ObjCMethodDecl *OMD, 787 const ObjCContainerDecl *CD, 788 std::string &NameOut); 789 790 /// GetMethodVarName - Return a unique constant for the given 791 /// selector's name. The return value has type char *. 792 llvm::Constant *GetMethodVarName(Selector Sel); 793 llvm::Constant *GetMethodVarName(IdentifierInfo *Ident); 794 llvm::Constant *GetMethodVarName(const std::string &Name); 795 796 /// GetMethodVarType - Return a unique constant for the given 797 /// selector's name. The return value has type char *. 798 799 // FIXME: This is a horrible name. 800 llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D); 801 llvm::Constant *GetMethodVarType(const FieldDecl *D); 802 803 /// GetPropertyName - Return a unique constant for the given 804 /// name. The return value has type char *. 805 llvm::Constant *GetPropertyName(IdentifierInfo *Ident); 806 807 // FIXME: This can be dropped once string functions are unified. 808 llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD, 809 const Decl *Container); 810 811 /// GetClassName - Return a unique constant for the given selector's 812 /// name. The return value has type char *. 813 llvm::Constant *GetClassName(IdentifierInfo *Ident); 814 815 /// BuildIvarLayout - Builds ivar layout bitmap for the class 816 /// implementation for the __strong or __weak case. 817 /// 818 llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI, 819 bool ForStrongLayout); 820 821 void BuildAggrIvarRecordLayout(const RecordType *RT, 822 unsigned int BytePos, bool ForStrongLayout, 823 bool &HasUnion); 824 void BuildAggrIvarLayout(const ObjCImplementationDecl *OI, 825 const llvm::StructLayout *Layout, 826 const RecordDecl *RD, 827 const llvm::SmallVectorImpl<FieldDecl*> &RecFields, 828 unsigned int BytePos, bool ForStrongLayout, 829 bool &HasUnion); 830 831 /// GetIvarLayoutName - Returns a unique constant for the given 832 /// ivar layout bitmap. 833 llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident, 834 const ObjCCommonTypesHelper &ObjCTypes); 835 836 /// EmitPropertyList - Emit the given property list. The return 837 /// value has type PropertyListPtrTy. 838 llvm::Constant *EmitPropertyList(const std::string &Name, 839 const Decl *Container, 840 const ObjCContainerDecl *OCD, 841 const ObjCCommonTypesHelper &ObjCTypes); 842 843 /// GetProtocolRef - Return a reference to the internal protocol 844 /// description, creating an empty one if it has not been 845 /// defined. The return value has type ProtocolPtrTy. 846 llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD); 847 848 /// CreateMetadataVar - Create a global variable with internal 849 /// linkage for use by the Objective-C runtime. 850 /// 851 /// This is a convenience wrapper which not only creates the 852 /// variable, but also sets the section and alignment and adds the 853 /// global to the UsedGlobals list. 854 /// 855 /// \param Name - The variable name. 856 /// \param Init - The variable initializer; this is also used to 857 /// define the type of the variable. 858 /// \param Section - The section the variable should go into, or 0. 859 /// \param Align - The alignment for the variable, or 0. 860 /// \param AddToUsed - Whether the variable should be added to 861 /// "llvm.used". 862 llvm::GlobalVariable *CreateMetadataVar(const std::string &Name, 863 llvm::Constant *Init, 864 const char *Section, 865 unsigned Align, 866 bool AddToUsed); 867 868 /// GetNamedIvarList - Return the list of ivars in the interface 869 /// itself (not including super classes and not including unnamed 870 /// bitfields). 871 /// 872 /// For the non-fragile ABI, this also includes synthesized property 873 /// ivars. 874 void GetNamedIvarList(const ObjCInterfaceDecl *OID, 875 llvm::SmallVector<ObjCIvarDecl*, 16> &Res) const; 876 877public: 878 CGObjCCommonMac(CodeGen::CodeGenModule &cgm) : CGM(cgm) 879 { } 880 881 virtual llvm::Constant *GenerateConstantString(const ObjCStringLiteral *SL); 882 883 virtual llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD, 884 const ObjCContainerDecl *CD=0); 885 886 virtual void GenerateProtocol(const ObjCProtocolDecl *PD); 887 888 /// GetOrEmitProtocol - Get the protocol object for the given 889 /// declaration, emitting it if necessary. The return value has type 890 /// ProtocolPtrTy. 891 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD)=0; 892 893 /// GetOrEmitProtocolRef - Get a forward reference to the protocol 894 /// object for the given declaration, emitting it if needed. These 895 /// forward references will be filled in with empty bodies if no 896 /// definition is seen. The return value has type ProtocolPtrTy. 897 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0; 898}; 899 900class CGObjCMac : public CGObjCCommonMac { 901private: 902 ObjCTypesHelper ObjCTypes; 903 /// EmitImageInfo - Emit the image info marker used to encode some module 904 /// level information. 905 void EmitImageInfo(); 906 907 /// EmitModuleInfo - Another marker encoding module level 908 /// information. 909 void EmitModuleInfo(); 910 911 /// EmitModuleSymols - Emit module symbols, the list of defined 912 /// classes and categories. The result has type SymtabPtrTy. 913 llvm::Constant *EmitModuleSymbols(); 914 915 /// FinishModule - Write out global data structures at the end of 916 /// processing a translation unit. 917 void FinishModule(); 918 919 /// EmitClassExtension - Generate the class extension structure used 920 /// to store the weak ivar layout and properties. The return value 921 /// has type ClassExtensionPtrTy. 922 llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID); 923 924 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy, 925 /// for the given class. 926 llvm::Value *EmitClassRef(CGBuilderTy &Builder, 927 const ObjCInterfaceDecl *ID); 928 929 CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF, 930 QualType ResultType, 931 Selector Sel, 932 llvm::Value *Arg0, 933 QualType Arg0Ty, 934 bool IsSuper, 935 const CallArgList &CallArgs); 936 937 /// EmitIvarList - Emit the ivar list for the given 938 /// implementation. If ForClass is true the list of class ivars 939 /// (i.e. metaclass ivars) is emitted, otherwise the list of 940 /// interface ivars will be emitted. The return value has type 941 /// IvarListPtrTy. 942 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID, 943 bool ForClass); 944 945 /// EmitMetaClass - Emit a forward reference to the class structure 946 /// for the metaclass of the given interface. The return value has 947 /// type ClassPtrTy. 948 llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID); 949 950 /// EmitMetaClass - Emit a class structure for the metaclass of the 951 /// given implementation. The return value has type ClassPtrTy. 952 llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID, 953 llvm::Constant *Protocols, 954 const ConstantVector &Methods); 955 956 llvm::Constant *GetMethodConstant(const ObjCMethodDecl *MD); 957 958 llvm::Constant *GetMethodDescriptionConstant(const ObjCMethodDecl *MD); 959 960 /// EmitMethodList - Emit the method list for the given 961 /// implementation. The return value has type MethodListPtrTy. 962 llvm::Constant *EmitMethodList(const std::string &Name, 963 const char *Section, 964 const ConstantVector &Methods); 965 966 /// EmitMethodDescList - Emit a method description list for a list of 967 /// method declarations. 968 /// - TypeName: The name for the type containing the methods. 969 /// - IsProtocol: True iff these methods are for a protocol. 970 /// - ClassMethds: True iff these are class methods. 971 /// - Required: When true, only "required" methods are 972 /// listed. Similarly, when false only "optional" methods are 973 /// listed. For classes this should always be true. 974 /// - begin, end: The method list to output. 975 /// 976 /// The return value has type MethodDescriptionListPtrTy. 977 llvm::Constant *EmitMethodDescList(const std::string &Name, 978 const char *Section, 979 const ConstantVector &Methods); 980 981 /// GetOrEmitProtocol - Get the protocol object for the given 982 /// declaration, emitting it if necessary. The return value has type 983 /// ProtocolPtrTy. 984 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD); 985 986 /// GetOrEmitProtocolRef - Get a forward reference to the protocol 987 /// object for the given declaration, emitting it if needed. These 988 /// forward references will be filled in with empty bodies if no 989 /// definition is seen. The return value has type ProtocolPtrTy. 990 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD); 991 992 /// EmitProtocolExtension - Generate the protocol extension 993 /// structure used to store optional instance and class methods, and 994 /// protocol properties. The return value has type 995 /// ProtocolExtensionPtrTy. 996 llvm::Constant * 997 EmitProtocolExtension(const ObjCProtocolDecl *PD, 998 const ConstantVector &OptInstanceMethods, 999 const ConstantVector &OptClassMethods); 1000 1001 /// EmitProtocolList - Generate the list of referenced 1002 /// protocols. The return value has type ProtocolListPtrTy. 1003 llvm::Constant *EmitProtocolList(const std::string &Name, 1004 ObjCProtocolDecl::protocol_iterator begin, 1005 ObjCProtocolDecl::protocol_iterator end); 1006 1007 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy, 1008 /// for the given selector. 1009 llvm::Value *EmitSelector(CGBuilderTy &Builder, Selector Sel); 1010 1011 public: 1012 CGObjCMac(CodeGen::CodeGenModule &cgm); 1013 1014 virtual llvm::Function *ModuleInitFunction(); 1015 1016 virtual CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF, 1017 QualType ResultType, 1018 Selector Sel, 1019 llvm::Value *Receiver, 1020 bool IsClassMessage, 1021 const CallArgList &CallArgs); 1022 1023 virtual CodeGen::RValue 1024 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, 1025 QualType ResultType, 1026 Selector Sel, 1027 const ObjCInterfaceDecl *Class, 1028 bool isCategoryImpl, 1029 llvm::Value *Receiver, 1030 bool IsClassMessage, 1031 const CallArgList &CallArgs); 1032 1033 virtual llvm::Value *GetClass(CGBuilderTy &Builder, 1034 const ObjCInterfaceDecl *ID); 1035 1036 virtual llvm::Value *GetSelector(CGBuilderTy &Builder, Selector Sel); 1037 1038 virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD); 1039 1040 virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl); 1041 1042 virtual llvm::Value *GenerateProtocolRef(CGBuilderTy &Builder, 1043 const ObjCProtocolDecl *PD); 1044 1045 virtual llvm::Constant *GetPropertyGetFunction(); 1046 virtual llvm::Constant *GetPropertySetFunction(); 1047 virtual llvm::Constant *EnumerationMutationFunction(); 1048 1049 virtual void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, 1050 const Stmt &S); 1051 virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, 1052 const ObjCAtThrowStmt &S); 1053 virtual llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, 1054 llvm::Value *AddrWeakObj); 1055 virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, 1056 llvm::Value *src, llvm::Value *dst); 1057 virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, 1058 llvm::Value *src, llvm::Value *dest); 1059 virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, 1060 llvm::Value *src, llvm::Value *dest); 1061 virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, 1062 llvm::Value *src, llvm::Value *dest); 1063 1064 virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, 1065 QualType ObjectTy, 1066 llvm::Value *BaseValue, 1067 const ObjCIvarDecl *Ivar, 1068 unsigned CVRQualifiers); 1069 virtual llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF, 1070 const ObjCInterfaceDecl *Interface, 1071 const ObjCIvarDecl *Ivar); 1072}; 1073 1074class CGObjCNonFragileABIMac : public CGObjCCommonMac { 1075private: 1076 ObjCNonFragileABITypesHelper ObjCTypes; 1077 llvm::GlobalVariable* ObjCEmptyCacheVar; 1078 llvm::GlobalVariable* ObjCEmptyVtableVar; 1079 1080 /// SuperClassReferences - uniqued super class references. 1081 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences; 1082 1083 /// MetaClassReferences - uniqued meta class references. 1084 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences; 1085 1086 /// EHTypeReferences - uniqued class ehtype references. 1087 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences; 1088 1089 /// FinishNonFragileABIModule - Write out global data structures at the end of 1090 /// processing a translation unit. 1091 void FinishNonFragileABIModule(); 1092 1093 llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags, 1094 unsigned InstanceStart, 1095 unsigned InstanceSize, 1096 const ObjCImplementationDecl *ID); 1097 llvm::GlobalVariable * BuildClassMetaData(std::string &ClassName, 1098 llvm::Constant *IsAGV, 1099 llvm::Constant *SuperClassGV, 1100 llvm::Constant *ClassRoGV, 1101 bool HiddenVisibility); 1102 1103 llvm::Constant *GetMethodConstant(const ObjCMethodDecl *MD); 1104 1105 llvm::Constant *GetMethodDescriptionConstant(const ObjCMethodDecl *MD); 1106 1107 /// EmitMethodList - Emit the method list for the given 1108 /// implementation. The return value has type MethodListnfABITy. 1109 llvm::Constant *EmitMethodList(const std::string &Name, 1110 const char *Section, 1111 const ConstantVector &Methods); 1112 /// EmitIvarList - Emit the ivar list for the given 1113 /// implementation. If ForClass is true the list of class ivars 1114 /// (i.e. metaclass ivars) is emitted, otherwise the list of 1115 /// interface ivars will be emitted. The return value has type 1116 /// IvarListnfABIPtrTy. 1117 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID); 1118 1119 llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID, 1120 const ObjCIvarDecl *Ivar, 1121 unsigned long int offset); 1122 1123 /// GetOrEmitProtocol - Get the protocol object for the given 1124 /// declaration, emitting it if necessary. The return value has type 1125 /// ProtocolPtrTy. 1126 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD); 1127 1128 /// GetOrEmitProtocolRef - Get a forward reference to the protocol 1129 /// object for the given declaration, emitting it if needed. These 1130 /// forward references will be filled in with empty bodies if no 1131 /// definition is seen. The return value has type ProtocolPtrTy. 1132 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD); 1133 1134 /// EmitProtocolList - Generate the list of referenced 1135 /// protocols. The return value has type ProtocolListPtrTy. 1136 llvm::Constant *EmitProtocolList(const std::string &Name, 1137 ObjCProtocolDecl::protocol_iterator begin, 1138 ObjCProtocolDecl::protocol_iterator end); 1139 1140 CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF, 1141 QualType ResultType, 1142 Selector Sel, 1143 llvm::Value *Receiver, 1144 QualType Arg0Ty, 1145 bool IsSuper, 1146 const CallArgList &CallArgs); 1147 1148 /// GetClassGlobal - Return the global variable for the Objective-C 1149 /// class of the given name. 1150 llvm::GlobalVariable *GetClassGlobal(const std::string &Name); 1151 1152 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy, 1153 /// for the given class reference. 1154 llvm::Value *EmitClassRef(CGBuilderTy &Builder, 1155 const ObjCInterfaceDecl *ID); 1156 1157 /// EmitSuperClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy, 1158 /// for the given super class reference. 1159 llvm::Value *EmitSuperClassRef(CGBuilderTy &Builder, 1160 const ObjCInterfaceDecl *ID); 1161 1162 /// EmitMetaClassRef - Return a Value * of the address of _class_t 1163 /// meta-data 1164 llvm::Value *EmitMetaClassRef(CGBuilderTy &Builder, 1165 const ObjCInterfaceDecl *ID); 1166 1167 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for 1168 /// the given ivar. 1169 /// 1170 llvm::GlobalVariable * ObjCIvarOffsetVariable( 1171 const ObjCInterfaceDecl *ID, 1172 const ObjCIvarDecl *Ivar); 1173 1174 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy, 1175 /// for the given selector. 1176 llvm::Value *EmitSelector(CGBuilderTy &Builder, Selector Sel); 1177 1178 /// GetInterfaceEHType - Get the cached ehtype for the given Objective-C 1179 /// interface. The return value has type EHTypePtrTy. 1180 llvm::Value *GetInterfaceEHType(const ObjCInterfaceDecl *ID, 1181 bool ForDefinition); 1182 1183 const char *getMetaclassSymbolPrefix() const { 1184 return "OBJC_METACLASS_$_"; 1185 } 1186 1187 const char *getClassSymbolPrefix() const { 1188 return "OBJC_CLASS_$_"; 1189 } 1190 1191 void GetClassSizeInfo(const ObjCImplementationDecl *OID, 1192 uint32_t &InstanceStart, 1193 uint32_t &InstanceSize); 1194 1195public: 1196 CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm); 1197 // FIXME. All stubs for now! 1198 virtual llvm::Function *ModuleInitFunction(); 1199 1200 virtual CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF, 1201 QualType ResultType, 1202 Selector Sel, 1203 llvm::Value *Receiver, 1204 bool IsClassMessage, 1205 const CallArgList &CallArgs); 1206 1207 virtual CodeGen::RValue 1208 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, 1209 QualType ResultType, 1210 Selector Sel, 1211 const ObjCInterfaceDecl *Class, 1212 bool isCategoryImpl, 1213 llvm::Value *Receiver, 1214 bool IsClassMessage, 1215 const CallArgList &CallArgs); 1216 1217 virtual llvm::Value *GetClass(CGBuilderTy &Builder, 1218 const ObjCInterfaceDecl *ID); 1219 1220 virtual llvm::Value *GetSelector(CGBuilderTy &Builder, Selector Sel) 1221 { return EmitSelector(Builder, Sel); } 1222 1223 virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD); 1224 1225 virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl); 1226 virtual llvm::Value *GenerateProtocolRef(CGBuilderTy &Builder, 1227 const ObjCProtocolDecl *PD); 1228 1229 virtual llvm::Constant *GetPropertyGetFunction() { 1230 return ObjCTypes.getGetPropertyFn(); 1231 } 1232 virtual llvm::Constant *GetPropertySetFunction() { 1233 return ObjCTypes.getSetPropertyFn(); 1234 } 1235 virtual llvm::Constant *EnumerationMutationFunction() { 1236 return ObjCTypes.getEnumerationMutationFn(); 1237 } 1238 1239 virtual void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, 1240 const Stmt &S); 1241 virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, 1242 const ObjCAtThrowStmt &S); 1243 virtual llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, 1244 llvm::Value *AddrWeakObj); 1245 virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, 1246 llvm::Value *src, llvm::Value *dst); 1247 virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, 1248 llvm::Value *src, llvm::Value *dest); 1249 virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, 1250 llvm::Value *src, llvm::Value *dest); 1251 virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, 1252 llvm::Value *src, llvm::Value *dest); 1253 virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, 1254 QualType ObjectTy, 1255 llvm::Value *BaseValue, 1256 const ObjCIvarDecl *Ivar, 1257 unsigned CVRQualifiers); 1258 virtual llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF, 1259 const ObjCInterfaceDecl *Interface, 1260 const ObjCIvarDecl *Ivar); 1261}; 1262 1263} // end anonymous namespace 1264 1265/* *** Helper Functions *** */ 1266 1267/// getConstantGEP() - Help routine to construct simple GEPs. 1268static llvm::Constant *getConstantGEP(llvm::Constant *C, 1269 unsigned idx0, 1270 unsigned idx1) { 1271 llvm::Value *Idxs[] = { 1272 llvm::ConstantInt::get(llvm::Type::Int32Ty, idx0), 1273 llvm::ConstantInt::get(llvm::Type::Int32Ty, idx1) 1274 }; 1275 return llvm::ConstantExpr::getGetElementPtr(C, Idxs, 2); 1276} 1277 1278/// hasObjCExceptionAttribute - Return true if this class or any super 1279/// class has the __objc_exception__ attribute. 1280static bool hasObjCExceptionAttribute(const ObjCInterfaceDecl *OID) { 1281 if (OID->hasAttr<ObjCExceptionAttr>()) 1282 return true; 1283 if (const ObjCInterfaceDecl *Super = OID->getSuperClass()) 1284 return hasObjCExceptionAttribute(Super); 1285 return false; 1286} 1287 1288/* *** CGObjCMac Public Interface *** */ 1289 1290CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm), 1291 ObjCTypes(cgm) 1292{ 1293 ObjCABI = 1; 1294 EmitImageInfo(); 1295} 1296 1297/// GetClass - Return a reference to the class for the given interface 1298/// decl. 1299llvm::Value *CGObjCMac::GetClass(CGBuilderTy &Builder, 1300 const ObjCInterfaceDecl *ID) { 1301 return EmitClassRef(Builder, ID); 1302} 1303 1304/// GetSelector - Return the pointer to the unique'd string for this selector. 1305llvm::Value *CGObjCMac::GetSelector(CGBuilderTy &Builder, Selector Sel) { 1306 return EmitSelector(Builder, Sel); 1307} 1308 1309/// Generate a constant CFString object. 1310/* 1311 struct __builtin_CFString { 1312 const int *isa; // point to __CFConstantStringClassReference 1313 int flags; 1314 const char *str; 1315 long length; 1316 }; 1317*/ 1318 1319llvm::Constant *CGObjCCommonMac::GenerateConstantString( 1320 const ObjCStringLiteral *SL) { 1321 return CGM.GetAddrOfConstantCFString(SL->getString()); 1322} 1323 1324/// Generates a message send where the super is the receiver. This is 1325/// a message send to self with special delivery semantics indicating 1326/// which class's method should be called. 1327CodeGen::RValue 1328CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, 1329 QualType ResultType, 1330 Selector Sel, 1331 const ObjCInterfaceDecl *Class, 1332 bool isCategoryImpl, 1333 llvm::Value *Receiver, 1334 bool IsClassMessage, 1335 const CodeGen::CallArgList &CallArgs) { 1336 // Create and init a super structure; this is a (receiver, class) 1337 // pair we will pass to objc_msgSendSuper. 1338 llvm::Value *ObjCSuper = 1339 CGF.Builder.CreateAlloca(ObjCTypes.SuperTy, 0, "objc_super"); 1340 llvm::Value *ReceiverAsObject = 1341 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy); 1342 CGF.Builder.CreateStore(ReceiverAsObject, 1343 CGF.Builder.CreateStructGEP(ObjCSuper, 0)); 1344 1345 // If this is a class message the metaclass is passed as the target. 1346 llvm::Value *Target; 1347 if (IsClassMessage) { 1348 if (isCategoryImpl) { 1349 // Message sent to 'super' in a class method defined in a category 1350 // implementation requires an odd treatment. 1351 // If we are in a class method, we must retrieve the 1352 // _metaclass_ for the current class, pointed at by 1353 // the class's "isa" pointer. The following assumes that 1354 // isa" is the first ivar in a class (which it must be). 1355 Target = EmitClassRef(CGF.Builder, Class->getSuperClass()); 1356 Target = CGF.Builder.CreateStructGEP(Target, 0); 1357 Target = CGF.Builder.CreateLoad(Target); 1358 } 1359 else { 1360 llvm::Value *MetaClassPtr = EmitMetaClassRef(Class); 1361 llvm::Value *SuperPtr = CGF.Builder.CreateStructGEP(MetaClassPtr, 1); 1362 llvm::Value *Super = CGF.Builder.CreateLoad(SuperPtr); 1363 Target = Super; 1364 } 1365 } else { 1366 Target = EmitClassRef(CGF.Builder, Class->getSuperClass()); 1367 } 1368 // FIXME: We shouldn't need to do this cast, rectify the ASTContext 1369 // and ObjCTypes types. 1370 const llvm::Type *ClassTy = 1371 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType()); 1372 Target = CGF.Builder.CreateBitCast(Target, ClassTy); 1373 CGF.Builder.CreateStore(Target, 1374 CGF.Builder.CreateStructGEP(ObjCSuper, 1)); 1375 1376 return EmitMessageSend(CGF, ResultType, Sel, 1377 ObjCSuper, ObjCTypes.SuperPtrCTy, 1378 true, CallArgs); 1379} 1380 1381/// Generate code for a message send expression. 1382CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF, 1383 QualType ResultType, 1384 Selector Sel, 1385 llvm::Value *Receiver, 1386 bool IsClassMessage, 1387 const CallArgList &CallArgs) { 1388 return EmitMessageSend(CGF, ResultType, Sel, 1389 Receiver, CGF.getContext().getObjCIdType(), 1390 false, CallArgs); 1391} 1392 1393CodeGen::RValue CGObjCMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF, 1394 QualType ResultType, 1395 Selector Sel, 1396 llvm::Value *Arg0, 1397 QualType Arg0Ty, 1398 bool IsSuper, 1399 const CallArgList &CallArgs) { 1400 CallArgList ActualArgs; 1401 if (!IsSuper) 1402 Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy, "tmp"); 1403 ActualArgs.push_back(std::make_pair(RValue::get(Arg0), Arg0Ty)); 1404 ActualArgs.push_back(std::make_pair(RValue::get(EmitSelector(CGF.Builder, 1405 Sel)), 1406 CGF.getContext().getObjCSelType())); 1407 ActualArgs.insert(ActualArgs.end(), CallArgs.begin(), CallArgs.end()); 1408 1409 CodeGenTypes &Types = CGM.getTypes(); 1410 const CGFunctionInfo &FnInfo = Types.getFunctionInfo(ResultType, ActualArgs); 1411 // FIXME. vararg flag must be true when this API is used for 64bit code gen. 1412 const llvm::FunctionType *FTy = Types.GetFunctionType(FnInfo, false); 1413 1414 llvm::Constant *Fn; 1415 if (CGM.ReturnTypeUsesSret(FnInfo)) { 1416 Fn = ObjCTypes.getSendStretFn(IsSuper); 1417 } else if (ResultType->isFloatingType()) { 1418 // FIXME: Sadly, this is wrong. This actually depends on the 1419 // architecture. This happens to be right for x86-32 though. 1420 Fn = ObjCTypes.getSendFpretFn(IsSuper); 1421 } else { 1422 Fn = ObjCTypes.getSendFn(IsSuper); 1423 } 1424 Fn = llvm::ConstantExpr::getBitCast(Fn, llvm::PointerType::getUnqual(FTy)); 1425 return CGF.EmitCall(FnInfo, Fn, ActualArgs); 1426} 1427 1428llvm::Value *CGObjCMac::GenerateProtocolRef(CGBuilderTy &Builder, 1429 const ObjCProtocolDecl *PD) { 1430 // FIXME: I don't understand why gcc generates this, or where it is 1431 // resolved. Investigate. Its also wasteful to look this up over and 1432 // over. 1433 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol")); 1434 1435 return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD), 1436 ObjCTypes.ExternalProtocolPtrTy); 1437} 1438 1439void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) { 1440 // FIXME: We shouldn't need this, the protocol decl should contain 1441 // enough information to tell us whether this was a declaration or a 1442 // definition. 1443 DefinedProtocols.insert(PD->getIdentifier()); 1444 1445 // If we have generated a forward reference to this protocol, emit 1446 // it now. Otherwise do nothing, the protocol objects are lazily 1447 // emitted. 1448 if (Protocols.count(PD->getIdentifier())) 1449 GetOrEmitProtocol(PD); 1450} 1451 1452llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) { 1453 if (DefinedProtocols.count(PD->getIdentifier())) 1454 return GetOrEmitProtocol(PD); 1455 return GetOrEmitProtocolRef(PD); 1456} 1457 1458/* 1459 // APPLE LOCAL radar 4585769 - Objective-C 1.0 extensions 1460 struct _objc_protocol { 1461 struct _objc_protocol_extension *isa; 1462 char *protocol_name; 1463 struct _objc_protocol_list *protocol_list; 1464 struct _objc__method_prototype_list *instance_methods; 1465 struct _objc__method_prototype_list *class_methods 1466 }; 1467 1468 See EmitProtocolExtension(). 1469*/ 1470llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) { 1471 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()]; 1472 1473 // Early exit if a defining object has already been generated. 1474 if (Entry && Entry->hasInitializer()) 1475 return Entry; 1476 1477 // FIXME: I don't understand why gcc generates this, or where it is 1478 // resolved. Investigate. Its also wasteful to look this up over and 1479 // over. 1480 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol")); 1481 1482 const char *ProtocolName = PD->getNameAsCString(); 1483 1484 // Construct method lists. 1485 std::vector<llvm::Constant*> InstanceMethods, ClassMethods; 1486 std::vector<llvm::Constant*> OptInstanceMethods, OptClassMethods; 1487 for (ObjCProtocolDecl::instmeth_iterator 1488 i = PD->instmeth_begin(CGM.getContext()), 1489 e = PD->instmeth_end(CGM.getContext()); i != e; ++i) { 1490 ObjCMethodDecl *MD = *i; 1491 llvm::Constant *C = GetMethodDescriptionConstant(MD); 1492 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) { 1493 OptInstanceMethods.push_back(C); 1494 } else { 1495 InstanceMethods.push_back(C); 1496 } 1497 } 1498 1499 for (ObjCProtocolDecl::classmeth_iterator 1500 i = PD->classmeth_begin(CGM.getContext()), 1501 e = PD->classmeth_end(CGM.getContext()); i != e; ++i) { 1502 ObjCMethodDecl *MD = *i; 1503 llvm::Constant *C = GetMethodDescriptionConstant(MD); 1504 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) { 1505 OptClassMethods.push_back(C); 1506 } else { 1507 ClassMethods.push_back(C); 1508 } 1509 } 1510 1511 std::vector<llvm::Constant*> Values(5); 1512 Values[0] = EmitProtocolExtension(PD, OptInstanceMethods, OptClassMethods); 1513 Values[1] = GetClassName(PD->getIdentifier()); 1514 Values[2] = 1515 EmitProtocolList("\01L_OBJC_PROTOCOL_REFS_" + PD->getNameAsString(), 1516 PD->protocol_begin(), 1517 PD->protocol_end()); 1518 Values[3] = 1519 EmitMethodDescList("\01L_OBJC_PROTOCOL_INSTANCE_METHODS_" 1520 + PD->getNameAsString(), 1521 "__OBJC,__cat_inst_meth,regular,no_dead_strip", 1522 InstanceMethods); 1523 Values[4] = 1524 EmitMethodDescList("\01L_OBJC_PROTOCOL_CLASS_METHODS_" 1525 + PD->getNameAsString(), 1526 "__OBJC,__cat_cls_meth,regular,no_dead_strip", 1527 ClassMethods); 1528 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ProtocolTy, 1529 Values); 1530 1531 if (Entry) { 1532 // Already created, fix the linkage and update the initializer. 1533 Entry->setLinkage(llvm::GlobalValue::InternalLinkage); 1534 Entry->setInitializer(Init); 1535 } else { 1536 Entry = 1537 new llvm::GlobalVariable(ObjCTypes.ProtocolTy, false, 1538 llvm::GlobalValue::InternalLinkage, 1539 Init, 1540 std::string("\01L_OBJC_PROTOCOL_")+ProtocolName, 1541 &CGM.getModule()); 1542 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip"); 1543 Entry->setAlignment(4); 1544 UsedGlobals.push_back(Entry); 1545 // FIXME: Is this necessary? Why only for protocol? 1546 Entry->setAlignment(4); 1547 } 1548 1549 return Entry; 1550} 1551 1552llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) { 1553 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()]; 1554 1555 if (!Entry) { 1556 // We use the initializer as a marker of whether this is a forward 1557 // reference or not. At module finalization we add the empty 1558 // contents for protocols which were referenced but never defined. 1559 Entry = 1560 new llvm::GlobalVariable(ObjCTypes.ProtocolTy, false, 1561 llvm::GlobalValue::ExternalLinkage, 1562 0, 1563 "\01L_OBJC_PROTOCOL_" + PD->getNameAsString(), 1564 &CGM.getModule()); 1565 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip"); 1566 Entry->setAlignment(4); 1567 UsedGlobals.push_back(Entry); 1568 // FIXME: Is this necessary? Why only for protocol? 1569 Entry->setAlignment(4); 1570 } 1571 1572 return Entry; 1573} 1574 1575/* 1576 struct _objc_protocol_extension { 1577 uint32_t size; 1578 struct objc_method_description_list *optional_instance_methods; 1579 struct objc_method_description_list *optional_class_methods; 1580 struct objc_property_list *instance_properties; 1581 }; 1582*/ 1583llvm::Constant * 1584CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD, 1585 const ConstantVector &OptInstanceMethods, 1586 const ConstantVector &OptClassMethods) { 1587 uint64_t Size = 1588 CGM.getTargetData().getTypePaddedSize(ObjCTypes.ProtocolExtensionTy); 1589 std::vector<llvm::Constant*> Values(4); 1590 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size); 1591 Values[1] = 1592 EmitMethodDescList("\01L_OBJC_PROTOCOL_INSTANCE_METHODS_OPT_" 1593 + PD->getNameAsString(), 1594 "__OBJC,__cat_inst_meth,regular,no_dead_strip", 1595 OptInstanceMethods); 1596 Values[2] = 1597 EmitMethodDescList("\01L_OBJC_PROTOCOL_CLASS_METHODS_OPT_" 1598 + PD->getNameAsString(), 1599 "__OBJC,__cat_cls_meth,regular,no_dead_strip", 1600 OptClassMethods); 1601 Values[3] = EmitPropertyList("\01L_OBJC_$_PROP_PROTO_LIST_" + 1602 PD->getNameAsString(), 1603 0, PD, ObjCTypes); 1604 1605 // Return null if no extension bits are used. 1606 if (Values[1]->isNullValue() && Values[2]->isNullValue() && 1607 Values[3]->isNullValue()) 1608 return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy); 1609 1610 llvm::Constant *Init = 1611 llvm::ConstantStruct::get(ObjCTypes.ProtocolExtensionTy, Values); 1612 1613 // No special section, but goes in llvm.used 1614 return CreateMetadataVar("\01L_OBJC_PROTOCOLEXT_" + PD->getNameAsString(), 1615 Init, 1616 0, 0, true); 1617} 1618 1619/* 1620 struct objc_protocol_list { 1621 struct objc_protocol_list *next; 1622 long count; 1623 Protocol *list[]; 1624 }; 1625*/ 1626llvm::Constant * 1627CGObjCMac::EmitProtocolList(const std::string &Name, 1628 ObjCProtocolDecl::protocol_iterator begin, 1629 ObjCProtocolDecl::protocol_iterator end) { 1630 std::vector<llvm::Constant*> ProtocolRefs; 1631 1632 for (; begin != end; ++begin) 1633 ProtocolRefs.push_back(GetProtocolRef(*begin)); 1634 1635 // Just return null for empty protocol lists 1636 if (ProtocolRefs.empty()) 1637 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy); 1638 1639 // This list is null terminated. 1640 ProtocolRefs.push_back(llvm::Constant::getNullValue(ObjCTypes.ProtocolPtrTy)); 1641 1642 std::vector<llvm::Constant*> Values(3); 1643 // This field is only used by the runtime. 1644 Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy); 1645 Values[1] = llvm::ConstantInt::get(ObjCTypes.LongTy, ProtocolRefs.size() - 1); 1646 Values[2] = 1647 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.ProtocolPtrTy, 1648 ProtocolRefs.size()), 1649 ProtocolRefs); 1650 1651 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 1652 llvm::GlobalVariable *GV = 1653 CreateMetadataVar(Name, Init, "__OBJC,__cat_cls_meth,regular,no_dead_strip", 1654 4, false); 1655 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy); 1656} 1657 1658/* 1659 struct _objc_property { 1660 const char * const name; 1661 const char * const attributes; 1662 }; 1663 1664 struct _objc_property_list { 1665 uint32_t entsize; // sizeof (struct _objc_property) 1666 uint32_t prop_count; 1667 struct _objc_property[prop_count]; 1668 }; 1669*/ 1670llvm::Constant *CGObjCCommonMac::EmitPropertyList(const std::string &Name, 1671 const Decl *Container, 1672 const ObjCContainerDecl *OCD, 1673 const ObjCCommonTypesHelper &ObjCTypes) { 1674 std::vector<llvm::Constant*> Properties, Prop(2); 1675 for (ObjCContainerDecl::prop_iterator I = OCD->prop_begin(CGM.getContext()), 1676 E = OCD->prop_end(CGM.getContext()); I != E; ++I) { 1677 const ObjCPropertyDecl *PD = *I; 1678 Prop[0] = GetPropertyName(PD->getIdentifier()); 1679 Prop[1] = GetPropertyTypeString(PD, Container); 1680 Properties.push_back(llvm::ConstantStruct::get(ObjCTypes.PropertyTy, 1681 Prop)); 1682 } 1683 1684 // Return null for empty list. 1685 if (Properties.empty()) 1686 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy); 1687 1688 unsigned PropertySize = 1689 CGM.getTargetData().getTypePaddedSize(ObjCTypes.PropertyTy); 1690 std::vector<llvm::Constant*> Values(3); 1691 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, PropertySize); 1692 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Properties.size()); 1693 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.PropertyTy, 1694 Properties.size()); 1695 Values[2] = llvm::ConstantArray::get(AT, Properties); 1696 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 1697 1698 llvm::GlobalVariable *GV = 1699 CreateMetadataVar(Name, Init, 1700 (ObjCABI == 2) ? "__DATA, __objc_const" : 1701 "__OBJC,__property,regular,no_dead_strip", 1702 (ObjCABI == 2) ? 8 : 4, 1703 true); 1704 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy); 1705} 1706 1707/* 1708 struct objc_method_description_list { 1709 int count; 1710 struct objc_method_description list[]; 1711 }; 1712*/ 1713llvm::Constant * 1714CGObjCMac::GetMethodDescriptionConstant(const ObjCMethodDecl *MD) { 1715 std::vector<llvm::Constant*> Desc(2); 1716 Desc[0] = llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()), 1717 ObjCTypes.SelectorPtrTy); 1718 Desc[1] = GetMethodVarType(MD); 1719 return llvm::ConstantStruct::get(ObjCTypes.MethodDescriptionTy, 1720 Desc); 1721} 1722 1723llvm::Constant *CGObjCMac::EmitMethodDescList(const std::string &Name, 1724 const char *Section, 1725 const ConstantVector &Methods) { 1726 // Return null for empty list. 1727 if (Methods.empty()) 1728 return llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy); 1729 1730 std::vector<llvm::Constant*> Values(2); 1731 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size()); 1732 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodDescriptionTy, 1733 Methods.size()); 1734 Values[1] = llvm::ConstantArray::get(AT, Methods); 1735 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 1736 1737 llvm::GlobalVariable *GV = CreateMetadataVar(Name, Init, Section, 4, true); 1738 return llvm::ConstantExpr::getBitCast(GV, 1739 ObjCTypes.MethodDescriptionListPtrTy); 1740} 1741 1742/* 1743 struct _objc_category { 1744 char *category_name; 1745 char *class_name; 1746 struct _objc_method_list *instance_methods; 1747 struct _objc_method_list *class_methods; 1748 struct _objc_protocol_list *protocols; 1749 uint32_t size; // <rdar://4585769> 1750 struct _objc_property_list *instance_properties; 1751 }; 1752 */ 1753void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) { 1754 unsigned Size = CGM.getTargetData().getTypePaddedSize(ObjCTypes.CategoryTy); 1755 1756 // FIXME: This is poor design, the OCD should have a pointer to the 1757 // category decl. Additionally, note that Category can be null for 1758 // the @implementation w/o an @interface case. Sema should just 1759 // create one for us as it does for @implementation so everyone else 1760 // can live life under a clear blue sky. 1761 const ObjCInterfaceDecl *Interface = OCD->getClassInterface(); 1762 const ObjCCategoryDecl *Category = 1763 Interface->FindCategoryDeclaration(OCD->getIdentifier()); 1764 std::string ExtName(Interface->getNameAsString() + "_" + 1765 OCD->getNameAsString()); 1766 1767 std::vector<llvm::Constant*> InstanceMethods, ClassMethods; 1768 for (ObjCCategoryImplDecl::instmeth_iterator 1769 i = OCD->instmeth_begin(CGM.getContext()), 1770 e = OCD->instmeth_end(CGM.getContext()); i != e; ++i) { 1771 // Instance methods should always be defined. 1772 InstanceMethods.push_back(GetMethodConstant(*i)); 1773 } 1774 for (ObjCCategoryImplDecl::classmeth_iterator 1775 i = OCD->classmeth_begin(CGM.getContext()), 1776 e = OCD->classmeth_end(CGM.getContext()); i != e; ++i) { 1777 // Class methods should always be defined. 1778 ClassMethods.push_back(GetMethodConstant(*i)); 1779 } 1780 1781 std::vector<llvm::Constant*> Values(7); 1782 Values[0] = GetClassName(OCD->getIdentifier()); 1783 Values[1] = GetClassName(Interface->getIdentifier()); 1784 LazySymbols.insert(Interface->getIdentifier()); 1785 Values[2] = 1786 EmitMethodList(std::string("\01L_OBJC_CATEGORY_INSTANCE_METHODS_") + 1787 ExtName, 1788 "__OBJC,__cat_inst_meth,regular,no_dead_strip", 1789 InstanceMethods); 1790 Values[3] = 1791 EmitMethodList(std::string("\01L_OBJC_CATEGORY_CLASS_METHODS_") + ExtName, 1792 "__OBJC,__cat_cls_meth,regular,no_dead_strip", 1793 ClassMethods); 1794 if (Category) { 1795 Values[4] = 1796 EmitProtocolList(std::string("\01L_OBJC_CATEGORY_PROTOCOLS_") + ExtName, 1797 Category->protocol_begin(), 1798 Category->protocol_end()); 1799 } else { 1800 Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy); 1801 } 1802 Values[5] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size); 1803 1804 // If there is no category @interface then there can be no properties. 1805 if (Category) { 1806 Values[6] = EmitPropertyList(std::string("\01l_OBJC_$_PROP_LIST_") + ExtName, 1807 OCD, Category, ObjCTypes); 1808 } else { 1809 Values[6] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy); 1810 } 1811 1812 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.CategoryTy, 1813 Values); 1814 1815 llvm::GlobalVariable *GV = 1816 CreateMetadataVar(std::string("\01L_OBJC_CATEGORY_")+ExtName, Init, 1817 "__OBJC,__category,regular,no_dead_strip", 1818 4, true); 1819 DefinedCategories.push_back(GV); 1820} 1821 1822// FIXME: Get from somewhere? 1823enum ClassFlags { 1824 eClassFlags_Factory = 0x00001, 1825 eClassFlags_Meta = 0x00002, 1826 // <rdr://5142207> 1827 eClassFlags_HasCXXStructors = 0x02000, 1828 eClassFlags_Hidden = 0x20000, 1829 eClassFlags_ABI2_Hidden = 0x00010, 1830 eClassFlags_ABI2_HasCXXStructors = 0x00004 // <rdr://4923634> 1831}; 1832 1833/* 1834 struct _objc_class { 1835 Class isa; 1836 Class super_class; 1837 const char *name; 1838 long version; 1839 long info; 1840 long instance_size; 1841 struct _objc_ivar_list *ivars; 1842 struct _objc_method_list *methods; 1843 struct _objc_cache *cache; 1844 struct _objc_protocol_list *protocols; 1845 // Objective-C 1.0 extensions (<rdr://4585769>) 1846 const char *ivar_layout; 1847 struct _objc_class_ext *ext; 1848 }; 1849 1850 See EmitClassExtension(); 1851 */ 1852void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) { 1853 DefinedSymbols.insert(ID->getIdentifier()); 1854 1855 std::string ClassName = ID->getNameAsString(); 1856 // FIXME: Gross 1857 ObjCInterfaceDecl *Interface = 1858 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface()); 1859 llvm::Constant *Protocols = 1860 EmitProtocolList("\01L_OBJC_CLASS_PROTOCOLS_" + ID->getNameAsString(), 1861 Interface->protocol_begin(), 1862 Interface->protocol_end()); 1863 unsigned Flags = eClassFlags_Factory; 1864 unsigned Size = 1865 CGM.getContext().getASTObjCImplementationLayout(ID).getSize() / 8; 1866 1867 // FIXME: Set CXX-structors flag. 1868 if (CGM.getDeclVisibilityMode(ID->getClassInterface()) == LangOptions::Hidden) 1869 Flags |= eClassFlags_Hidden; 1870 1871 std::vector<llvm::Constant*> InstanceMethods, ClassMethods; 1872 for (ObjCImplementationDecl::instmeth_iterator 1873 i = ID->instmeth_begin(CGM.getContext()), 1874 e = ID->instmeth_end(CGM.getContext()); i != e; ++i) { 1875 // Instance methods should always be defined. 1876 InstanceMethods.push_back(GetMethodConstant(*i)); 1877 } 1878 for (ObjCImplementationDecl::classmeth_iterator 1879 i = ID->classmeth_begin(CGM.getContext()), 1880 e = ID->classmeth_end(CGM.getContext()); i != e; ++i) { 1881 // Class methods should always be defined. 1882 ClassMethods.push_back(GetMethodConstant(*i)); 1883 } 1884 1885 for (ObjCImplementationDecl::propimpl_iterator 1886 i = ID->propimpl_begin(CGM.getContext()), 1887 e = ID->propimpl_end(CGM.getContext()); i != e; ++i) { 1888 ObjCPropertyImplDecl *PID = *i; 1889 1890 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) { 1891 ObjCPropertyDecl *PD = PID->getPropertyDecl(); 1892 1893 if (ObjCMethodDecl *MD = PD->getGetterMethodDecl()) 1894 if (llvm::Constant *C = GetMethodConstant(MD)) 1895 InstanceMethods.push_back(C); 1896 if (ObjCMethodDecl *MD = PD->getSetterMethodDecl()) 1897 if (llvm::Constant *C = GetMethodConstant(MD)) 1898 InstanceMethods.push_back(C); 1899 } 1900 } 1901 1902 std::vector<llvm::Constant*> Values(12); 1903 Values[ 0] = EmitMetaClass(ID, Protocols, ClassMethods); 1904 if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) { 1905 // Record a reference to the super class. 1906 LazySymbols.insert(Super->getIdentifier()); 1907 1908 Values[ 1] = 1909 llvm::ConstantExpr::getBitCast(GetClassName(Super->getIdentifier()), 1910 ObjCTypes.ClassPtrTy); 1911 } else { 1912 Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy); 1913 } 1914 Values[ 2] = GetClassName(ID->getIdentifier()); 1915 // Version is always 0. 1916 Values[ 3] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0); 1917 Values[ 4] = llvm::ConstantInt::get(ObjCTypes.LongTy, Flags); 1918 Values[ 5] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size); 1919 Values[ 6] = EmitIvarList(ID, false); 1920 Values[ 7] = 1921 EmitMethodList("\01L_OBJC_INSTANCE_METHODS_" + ID->getNameAsString(), 1922 "__OBJC,__inst_meth,regular,no_dead_strip", 1923 InstanceMethods); 1924 // cache is always NULL. 1925 Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy); 1926 Values[ 9] = Protocols; 1927 Values[10] = BuildIvarLayout(ID, true); 1928 Values[11] = EmitClassExtension(ID); 1929 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy, 1930 Values); 1931 1932 llvm::GlobalVariable *GV = 1933 CreateMetadataVar(std::string("\01L_OBJC_CLASS_")+ClassName, Init, 1934 "__OBJC,__class,regular,no_dead_strip", 1935 4, true); 1936 DefinedClasses.push_back(GV); 1937} 1938 1939llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID, 1940 llvm::Constant *Protocols, 1941 const ConstantVector &Methods) { 1942 unsigned Flags = eClassFlags_Meta; 1943 unsigned Size = CGM.getTargetData().getTypePaddedSize(ObjCTypes.ClassTy); 1944 1945 if (CGM.getDeclVisibilityMode(ID->getClassInterface()) == LangOptions::Hidden) 1946 Flags |= eClassFlags_Hidden; 1947 1948 std::vector<llvm::Constant*> Values(12); 1949 // The isa for the metaclass is the root of the hierarchy. 1950 const ObjCInterfaceDecl *Root = ID->getClassInterface(); 1951 while (const ObjCInterfaceDecl *Super = Root->getSuperClass()) 1952 Root = Super; 1953 Values[ 0] = 1954 llvm::ConstantExpr::getBitCast(GetClassName(Root->getIdentifier()), 1955 ObjCTypes.ClassPtrTy); 1956 // The super class for the metaclass is emitted as the name of the 1957 // super class. The runtime fixes this up to point to the 1958 // *metaclass* for the super class. 1959 if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) { 1960 Values[ 1] = 1961 llvm::ConstantExpr::getBitCast(GetClassName(Super->getIdentifier()), 1962 ObjCTypes.ClassPtrTy); 1963 } else { 1964 Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy); 1965 } 1966 Values[ 2] = GetClassName(ID->getIdentifier()); 1967 // Version is always 0. 1968 Values[ 3] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0); 1969 Values[ 4] = llvm::ConstantInt::get(ObjCTypes.LongTy, Flags); 1970 Values[ 5] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size); 1971 Values[ 6] = EmitIvarList(ID, true); 1972 Values[ 7] = 1973 EmitMethodList("\01L_OBJC_CLASS_METHODS_" + ID->getNameAsString(), 1974 "__OBJC,__cls_meth,regular,no_dead_strip", 1975 Methods); 1976 // cache is always NULL. 1977 Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy); 1978 Values[ 9] = Protocols; 1979 // ivar_layout for metaclass is always NULL. 1980 Values[10] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy); 1981 // The class extension is always unused for metaclasses. 1982 Values[11] = llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy); 1983 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy, 1984 Values); 1985 1986 std::string Name("\01L_OBJC_METACLASS_"); 1987 Name += ID->getNameAsCString(); 1988 1989 // Check for a forward reference. 1990 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name); 1991 if (GV) { 1992 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy && 1993 "Forward metaclass reference has incorrect type."); 1994 GV->setLinkage(llvm::GlobalValue::InternalLinkage); 1995 GV->setInitializer(Init); 1996 } else { 1997 GV = new llvm::GlobalVariable(ObjCTypes.ClassTy, false, 1998 llvm::GlobalValue::InternalLinkage, 1999 Init, Name, 2000 &CGM.getModule()); 2001 } 2002 GV->setSection("__OBJC,__meta_class,regular,no_dead_strip"); 2003 GV->setAlignment(4); 2004 UsedGlobals.push_back(GV); 2005 2006 return GV; 2007} 2008 2009llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) { 2010 std::string Name = "\01L_OBJC_METACLASS_" + ID->getNameAsString(); 2011 2012 // FIXME: Should we look these up somewhere other than the 2013 // module. Its a bit silly since we only generate these while 2014 // processing an implementation, so exactly one pointer would work 2015 // if know when we entered/exitted an implementation block. 2016 2017 // Check for an existing forward reference. 2018 // Previously, metaclass with internal linkage may have been defined. 2019 // pass 'true' as 2nd argument so it is returned. 2020 if (llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true)) { 2021 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy && 2022 "Forward metaclass reference has incorrect type."); 2023 return GV; 2024 } else { 2025 // Generate as an external reference to keep a consistent 2026 // module. This will be patched up when we emit the metaclass. 2027 return new llvm::GlobalVariable(ObjCTypes.ClassTy, false, 2028 llvm::GlobalValue::ExternalLinkage, 2029 0, 2030 Name, 2031 &CGM.getModule()); 2032 } 2033} 2034 2035/* 2036 struct objc_class_ext { 2037 uint32_t size; 2038 const char *weak_ivar_layout; 2039 struct _objc_property_list *properties; 2040 }; 2041*/ 2042llvm::Constant * 2043CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID) { 2044 uint64_t Size = 2045 CGM.getTargetData().getTypePaddedSize(ObjCTypes.ClassExtensionTy); 2046 2047 std::vector<llvm::Constant*> Values(3); 2048 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size); 2049 Values[1] = BuildIvarLayout(ID, false); 2050 Values[2] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ID->getNameAsString(), 2051 ID, ID->getClassInterface(), ObjCTypes); 2052 2053 // Return null if no extension bits are used. 2054 if (Values[1]->isNullValue() && Values[2]->isNullValue()) 2055 return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy); 2056 2057 llvm::Constant *Init = 2058 llvm::ConstantStruct::get(ObjCTypes.ClassExtensionTy, Values); 2059 return CreateMetadataVar("\01L_OBJC_CLASSEXT_" + ID->getNameAsString(), 2060 Init, "__OBJC,__class_ext,regular,no_dead_strip", 2061 4, true); 2062} 2063 2064/// getInterfaceDeclForIvar - Get the interface declaration node where 2065/// this ivar is declared in. 2066/// FIXME. Ideally, this info should be in the ivar node. But currently 2067/// it is not and prevailing wisdom is that ASTs should not have more 2068/// info than is absolutely needed, even though this info reflects the 2069/// source language. 2070/// 2071static const ObjCInterfaceDecl *getInterfaceDeclForIvar( 2072 const ObjCInterfaceDecl *OI, 2073 const ObjCIvarDecl *IVD, 2074 ASTContext &Context) { 2075 if (!OI) 2076 return 0; 2077 assert(isa<ObjCInterfaceDecl>(OI) && "OI is not an interface"); 2078 for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(), 2079 E = OI->ivar_end(); I != E; ++I) 2080 if ((*I)->getIdentifier() == IVD->getIdentifier()) 2081 return OI; 2082 // look into properties. 2083 for (ObjCInterfaceDecl::prop_iterator I = OI->prop_begin(Context), 2084 E = OI->prop_end(Context); I != E; ++I) { 2085 ObjCPropertyDecl *PDecl = (*I); 2086 if (ObjCIvarDecl *IV = PDecl->getPropertyIvarDecl()) 2087 if (IV->getIdentifier() == IVD->getIdentifier()) 2088 return OI; 2089 } 2090 return getInterfaceDeclForIvar(OI->getSuperClass(), IVD, Context); 2091} 2092 2093/* 2094 struct objc_ivar { 2095 char *ivar_name; 2096 char *ivar_type; 2097 int ivar_offset; 2098 }; 2099 2100 struct objc_ivar_list { 2101 int ivar_count; 2102 struct objc_ivar list[count]; 2103 }; 2104 */ 2105llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID, 2106 bool ForClass) { 2107 std::vector<llvm::Constant*> Ivars, Ivar(3); 2108 2109 // When emitting the root class GCC emits ivar entries for the 2110 // actual class structure. It is not clear if we need to follow this 2111 // behavior; for now lets try and get away with not doing it. If so, 2112 // the cleanest solution would be to make up an ObjCInterfaceDecl 2113 // for the class. 2114 if (ForClass) 2115 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy); 2116 2117 ObjCInterfaceDecl *OID = 2118 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface()); 2119 2120 llvm::SmallVector<ObjCIvarDecl*, 16> OIvars; 2121 GetNamedIvarList(OID, OIvars); 2122 2123 for (unsigned i = 0, e = OIvars.size(); i != e; ++i) { 2124 ObjCIvarDecl *IVD = OIvars[i]; 2125 Ivar[0] = GetMethodVarName(IVD->getIdentifier()); 2126 Ivar[1] = GetMethodVarType(IVD); 2127 Ivar[2] = llvm::ConstantInt::get(ObjCTypes.IntTy, 2128 ComputeIvarBaseOffset(CGM, OID, IVD)); 2129 Ivars.push_back(llvm::ConstantStruct::get(ObjCTypes.IvarTy, Ivar)); 2130 } 2131 2132 // Return null for empty list. 2133 if (Ivars.empty()) 2134 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy); 2135 2136 std::vector<llvm::Constant*> Values(2); 2137 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Ivars.size()); 2138 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.IvarTy, 2139 Ivars.size()); 2140 Values[1] = llvm::ConstantArray::get(AT, Ivars); 2141 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 2142 2143 llvm::GlobalVariable *GV; 2144 if (ForClass) 2145 GV = CreateMetadataVar("\01L_OBJC_CLASS_VARIABLES_" + ID->getNameAsString(), 2146 Init, "__OBJC,__class_vars,regular,no_dead_strip", 2147 4, true); 2148 else 2149 GV = CreateMetadataVar("\01L_OBJC_INSTANCE_VARIABLES_" 2150 + ID->getNameAsString(), 2151 Init, "__OBJC,__instance_vars,regular,no_dead_strip", 2152 4, true); 2153 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy); 2154} 2155 2156/* 2157 struct objc_method { 2158 SEL method_name; 2159 char *method_types; 2160 void *method; 2161 }; 2162 2163 struct objc_method_list { 2164 struct objc_method_list *obsolete; 2165 int count; 2166 struct objc_method methods_list[count]; 2167 }; 2168*/ 2169 2170/// GetMethodConstant - Return a struct objc_method constant for the 2171/// given method if it has been defined. The result is null if the 2172/// method has not been defined. The return value has type MethodPtrTy. 2173llvm::Constant *CGObjCMac::GetMethodConstant(const ObjCMethodDecl *MD) { 2174 // FIXME: Use DenseMap::lookup 2175 llvm::Function *Fn = MethodDefinitions[MD]; 2176 if (!Fn) 2177 return 0; 2178 2179 std::vector<llvm::Constant*> Method(3); 2180 Method[0] = 2181 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()), 2182 ObjCTypes.SelectorPtrTy); 2183 Method[1] = GetMethodVarType(MD); 2184 Method[2] = llvm::ConstantExpr::getBitCast(Fn, ObjCTypes.Int8PtrTy); 2185 return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Method); 2186} 2187 2188llvm::Constant *CGObjCMac::EmitMethodList(const std::string &Name, 2189 const char *Section, 2190 const ConstantVector &Methods) { 2191 // Return null for empty list. 2192 if (Methods.empty()) 2193 return llvm::Constant::getNullValue(ObjCTypes.MethodListPtrTy); 2194 2195 std::vector<llvm::Constant*> Values(3); 2196 Values[0] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy); 2197 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size()); 2198 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodTy, 2199 Methods.size()); 2200 Values[2] = llvm::ConstantArray::get(AT, Methods); 2201 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 2202 2203 llvm::GlobalVariable *GV = CreateMetadataVar(Name, Init, Section, 4, true); 2204 return llvm::ConstantExpr::getBitCast(GV, 2205 ObjCTypes.MethodListPtrTy); 2206} 2207 2208llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD, 2209 const ObjCContainerDecl *CD) { 2210 std::string Name; 2211 GetNameForMethod(OMD, CD, Name); 2212 2213 CodeGenTypes &Types = CGM.getTypes(); 2214 const llvm::FunctionType *MethodTy = 2215 Types.GetFunctionType(Types.getFunctionInfo(OMD), OMD->isVariadic()); 2216 llvm::Function *Method = 2217 llvm::Function::Create(MethodTy, 2218 llvm::GlobalValue::InternalLinkage, 2219 Name, 2220 &CGM.getModule()); 2221 MethodDefinitions.insert(std::make_pair(OMD, Method)); 2222 2223 return Method; 2224} 2225 2226llvm::GlobalVariable * 2227CGObjCCommonMac::CreateMetadataVar(const std::string &Name, 2228 llvm::Constant *Init, 2229 const char *Section, 2230 unsigned Align, 2231 bool AddToUsed) { 2232 const llvm::Type *Ty = Init->getType(); 2233 llvm::GlobalVariable *GV = 2234 new llvm::GlobalVariable(Ty, false, 2235 llvm::GlobalValue::InternalLinkage, 2236 Init, 2237 Name, 2238 &CGM.getModule()); 2239 if (Section) 2240 GV->setSection(Section); 2241 if (Align) 2242 GV->setAlignment(Align); 2243 if (AddToUsed) 2244 UsedGlobals.push_back(GV); 2245 return GV; 2246} 2247 2248llvm::Function *CGObjCMac::ModuleInitFunction() { 2249 // Abuse this interface function as a place to finalize. 2250 FinishModule(); 2251 2252 return NULL; 2253} 2254 2255llvm::Constant *CGObjCMac::GetPropertyGetFunction() { 2256 return ObjCTypes.getGetPropertyFn(); 2257} 2258 2259llvm::Constant *CGObjCMac::GetPropertySetFunction() { 2260 return ObjCTypes.getSetPropertyFn(); 2261} 2262 2263llvm::Constant *CGObjCMac::EnumerationMutationFunction() { 2264 return ObjCTypes.getEnumerationMutationFn(); 2265} 2266 2267/* 2268 2269Objective-C setjmp-longjmp (sjlj) Exception Handling 2270-- 2271 2272The basic framework for a @try-catch-finally is as follows: 2273{ 2274 objc_exception_data d; 2275 id _rethrow = null; 2276 bool _call_try_exit = true; 2277 2278 objc_exception_try_enter(&d); 2279 if (!setjmp(d.jmp_buf)) { 2280 ... try body ... 2281 } else { 2282 // exception path 2283 id _caught = objc_exception_extract(&d); 2284 2285 // enter new try scope for handlers 2286 if (!setjmp(d.jmp_buf)) { 2287 ... match exception and execute catch blocks ... 2288 2289 // fell off end, rethrow. 2290 _rethrow = _caught; 2291 ... jump-through-finally to finally_rethrow ... 2292 } else { 2293 // exception in catch block 2294 _rethrow = objc_exception_extract(&d); 2295 _call_try_exit = false; 2296 ... jump-through-finally to finally_rethrow ... 2297 } 2298 } 2299 ... jump-through-finally to finally_end ... 2300 2301finally: 2302 if (_call_try_exit) 2303 objc_exception_try_exit(&d); 2304 2305 ... finally block .... 2306 ... dispatch to finally destination ... 2307 2308finally_rethrow: 2309 objc_exception_throw(_rethrow); 2310 2311finally_end: 2312} 2313 2314This framework differs slightly from the one gcc uses, in that gcc 2315uses _rethrow to determine if objc_exception_try_exit should be called 2316and if the object should be rethrown. This breaks in the face of 2317throwing nil and introduces unnecessary branches. 2318 2319We specialize this framework for a few particular circumstances: 2320 2321 - If there are no catch blocks, then we avoid emitting the second 2322 exception handling context. 2323 2324 - If there is a catch-all catch block (i.e. @catch(...) or @catch(id 2325 e)) we avoid emitting the code to rethrow an uncaught exception. 2326 2327 - FIXME: If there is no @finally block we can do a few more 2328 simplifications. 2329 2330Rethrows and Jumps-Through-Finally 2331-- 2332 2333Support for implicit rethrows and jumping through the finally block is 2334handled by storing the current exception-handling context in 2335ObjCEHStack. 2336 2337In order to implement proper @finally semantics, we support one basic 2338mechanism for jumping through the finally block to an arbitrary 2339destination. Constructs which generate exits from a @try or @catch 2340block use this mechanism to implement the proper semantics by chaining 2341jumps, as necessary. 2342 2343This mechanism works like the one used for indirect goto: we 2344arbitrarily assign an ID to each destination and store the ID for the 2345destination in a variable prior to entering the finally block. At the 2346end of the finally block we simply create a switch to the proper 2347destination. 2348 2349Code gen for @synchronized(expr) stmt; 2350Effectively generating code for: 2351objc_sync_enter(expr); 2352@try stmt @finally { objc_sync_exit(expr); } 2353*/ 2354 2355void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, 2356 const Stmt &S) { 2357 bool isTry = isa<ObjCAtTryStmt>(S); 2358 // Create various blocks we refer to for handling @finally. 2359 llvm::BasicBlock *FinallyBlock = CGF.createBasicBlock("finally"); 2360 llvm::BasicBlock *FinallyExit = CGF.createBasicBlock("finally.exit"); 2361 llvm::BasicBlock *FinallyNoExit = CGF.createBasicBlock("finally.noexit"); 2362 llvm::BasicBlock *FinallyRethrow = CGF.createBasicBlock("finally.throw"); 2363 llvm::BasicBlock *FinallyEnd = CGF.createBasicBlock("finally.end"); 2364 2365 // For @synchronized, call objc_sync_enter(sync.expr). The 2366 // evaluation of the expression must occur before we enter the 2367 // @synchronized. We can safely avoid a temp here because jumps into 2368 // @synchronized are illegal & this will dominate uses. 2369 llvm::Value *SyncArg = 0; 2370 if (!isTry) { 2371 SyncArg = 2372 CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr()); 2373 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy); 2374 CGF.Builder.CreateCall(ObjCTypes.getSyncEnterFn(), SyncArg); 2375 } 2376 2377 // Push an EH context entry, used for handling rethrows and jumps 2378 // through finally. 2379 CGF.PushCleanupBlock(FinallyBlock); 2380 2381 CGF.ObjCEHValueStack.push_back(0); 2382 2383 // Allocate memory for the exception data and rethrow pointer. 2384 llvm::Value *ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy, 2385 "exceptiondata.ptr"); 2386 llvm::Value *RethrowPtr = CGF.CreateTempAlloca(ObjCTypes.ObjectPtrTy, 2387 "_rethrow"); 2388 llvm::Value *CallTryExitPtr = CGF.CreateTempAlloca(llvm::Type::Int1Ty, 2389 "_call_try_exit"); 2390 CGF.Builder.CreateStore(llvm::ConstantInt::getTrue(), CallTryExitPtr); 2391 2392 // Enter a new try block and call setjmp. 2393 CGF.Builder.CreateCall(ObjCTypes.getExceptionTryEnterFn(), ExceptionData); 2394 llvm::Value *JmpBufPtr = CGF.Builder.CreateStructGEP(ExceptionData, 0, 2395 "jmpbufarray"); 2396 JmpBufPtr = CGF.Builder.CreateStructGEP(JmpBufPtr, 0, "tmp"); 2397 llvm::Value *SetJmpResult = CGF.Builder.CreateCall(ObjCTypes.getSetJmpFn(), 2398 JmpBufPtr, "result"); 2399 2400 llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try"); 2401 llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler"); 2402 CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(SetJmpResult, "threw"), 2403 TryHandler, TryBlock); 2404 2405 // Emit the @try block. 2406 CGF.EmitBlock(TryBlock); 2407 CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody() 2408 : cast<ObjCAtSynchronizedStmt>(S).getSynchBody()); 2409 CGF.EmitBranchThroughCleanup(FinallyEnd); 2410 2411 // Emit the "exception in @try" block. 2412 CGF.EmitBlock(TryHandler); 2413 2414 // Retrieve the exception object. We may emit multiple blocks but 2415 // nothing can cross this so the value is already in SSA form. 2416 llvm::Value *Caught = 2417 CGF.Builder.CreateCall(ObjCTypes.getExceptionExtractFn(), 2418 ExceptionData, "caught"); 2419 CGF.ObjCEHValueStack.back() = Caught; 2420 if (!isTry) 2421 { 2422 CGF.Builder.CreateStore(Caught, RethrowPtr); 2423 CGF.Builder.CreateStore(llvm::ConstantInt::getFalse(), CallTryExitPtr); 2424 CGF.EmitBranchThroughCleanup(FinallyRethrow); 2425 } 2426 else if (const ObjCAtCatchStmt* CatchStmt = 2427 cast<ObjCAtTryStmt>(S).getCatchStmts()) 2428 { 2429 // Enter a new exception try block (in case a @catch block throws 2430 // an exception). 2431 CGF.Builder.CreateCall(ObjCTypes.getExceptionTryEnterFn(), ExceptionData); 2432 2433 llvm::Value *SetJmpResult = CGF.Builder.CreateCall(ObjCTypes.getSetJmpFn(), 2434 JmpBufPtr, "result"); 2435 llvm::Value *Threw = CGF.Builder.CreateIsNotNull(SetJmpResult, "threw"); 2436 2437 llvm::BasicBlock *CatchBlock = CGF.createBasicBlock("catch"); 2438 llvm::BasicBlock *CatchHandler = CGF.createBasicBlock("catch.handler"); 2439 CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock); 2440 2441 CGF.EmitBlock(CatchBlock); 2442 2443 // Handle catch list. As a special case we check if everything is 2444 // matched and avoid generating code for falling off the end if 2445 // so. 2446 bool AllMatched = false; 2447 for (; CatchStmt; CatchStmt = CatchStmt->getNextCatchStmt()) { 2448 llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch"); 2449 2450 const ParmVarDecl *CatchParam = CatchStmt->getCatchParamDecl(); 2451 const PointerType *PT = 0; 2452 2453 // catch(...) always matches. 2454 if (!CatchParam) { 2455 AllMatched = true; 2456 } else { 2457 PT = CatchParam->getType()->getAsPointerType(); 2458 2459 // catch(id e) always matches. 2460 // FIXME: For the time being we also match id<X>; this should 2461 // be rejected by Sema instead. 2462 if ((PT && CGF.getContext().isObjCIdStructType(PT->getPointeeType())) || 2463 CatchParam->getType()->isObjCQualifiedIdType()) 2464 AllMatched = true; 2465 } 2466 2467 if (AllMatched) { 2468 if (CatchParam) { 2469 CGF.EmitLocalBlockVarDecl(*CatchParam); 2470 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?"); 2471 CGF.Builder.CreateStore(Caught, CGF.GetAddrOfLocalVar(CatchParam)); 2472 } 2473 2474 CGF.EmitStmt(CatchStmt->getCatchBody()); 2475 CGF.EmitBranchThroughCleanup(FinallyEnd); 2476 break; 2477 } 2478 2479 assert(PT && "Unexpected non-pointer type in @catch"); 2480 QualType T = PT->getPointeeType(); 2481 const ObjCInterfaceType *ObjCType = T->getAsObjCInterfaceType(); 2482 assert(ObjCType && "Catch parameter must have Objective-C type!"); 2483 2484 // Check if the @catch block matches the exception object. 2485 llvm::Value *Class = EmitClassRef(CGF.Builder, ObjCType->getDecl()); 2486 2487 llvm::Value *Match = 2488 CGF.Builder.CreateCall2(ObjCTypes.getExceptionMatchFn(), 2489 Class, Caught, "match"); 2490 2491 llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("matched"); 2492 2493 CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"), 2494 MatchedBlock, NextCatchBlock); 2495 2496 // Emit the @catch block. 2497 CGF.EmitBlock(MatchedBlock); 2498 CGF.EmitLocalBlockVarDecl(*CatchParam); 2499 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?"); 2500 2501 llvm::Value *Tmp = 2502 CGF.Builder.CreateBitCast(Caught, CGF.ConvertType(CatchParam->getType()), 2503 "tmp"); 2504 CGF.Builder.CreateStore(Tmp, CGF.GetAddrOfLocalVar(CatchParam)); 2505 2506 CGF.EmitStmt(CatchStmt->getCatchBody()); 2507 CGF.EmitBranchThroughCleanup(FinallyEnd); 2508 2509 CGF.EmitBlock(NextCatchBlock); 2510 } 2511 2512 if (!AllMatched) { 2513 // None of the handlers caught the exception, so store it to be 2514 // rethrown at the end of the @finally block. 2515 CGF.Builder.CreateStore(Caught, RethrowPtr); 2516 CGF.EmitBranchThroughCleanup(FinallyRethrow); 2517 } 2518 2519 // Emit the exception handler for the @catch blocks. 2520 CGF.EmitBlock(CatchHandler); 2521 CGF.Builder.CreateStore( 2522 CGF.Builder.CreateCall(ObjCTypes.getExceptionExtractFn(), 2523 ExceptionData), 2524 RethrowPtr); 2525 CGF.Builder.CreateStore(llvm::ConstantInt::getFalse(), CallTryExitPtr); 2526 CGF.EmitBranchThroughCleanup(FinallyRethrow); 2527 } else { 2528 CGF.Builder.CreateStore(Caught, RethrowPtr); 2529 CGF.Builder.CreateStore(llvm::ConstantInt::getFalse(), CallTryExitPtr); 2530 CGF.EmitBranchThroughCleanup(FinallyRethrow); 2531 } 2532 2533 // Pop the exception-handling stack entry. It is important to do 2534 // this now, because the code in the @finally block is not in this 2535 // context. 2536 CodeGenFunction::CleanupBlockInfo Info = CGF.PopCleanupBlock(); 2537 2538 CGF.ObjCEHValueStack.pop_back(); 2539 2540 // Emit the @finally block. 2541 CGF.EmitBlock(FinallyBlock); 2542 llvm::Value* CallTryExit = CGF.Builder.CreateLoad(CallTryExitPtr, "tmp"); 2543 2544 CGF.Builder.CreateCondBr(CallTryExit, FinallyExit, FinallyNoExit); 2545 2546 CGF.EmitBlock(FinallyExit); 2547 CGF.Builder.CreateCall(ObjCTypes.getExceptionTryExitFn(), ExceptionData); 2548 2549 CGF.EmitBlock(FinallyNoExit); 2550 if (isTry) { 2551 if (const ObjCAtFinallyStmt* FinallyStmt = 2552 cast<ObjCAtTryStmt>(S).getFinallyStmt()) 2553 CGF.EmitStmt(FinallyStmt->getFinallyBody()); 2554 } else { 2555 // Emit objc_sync_exit(expr); as finally's sole statement for 2556 // @synchronized. 2557 CGF.Builder.CreateCall(ObjCTypes.getSyncExitFn(), SyncArg); 2558 } 2559 2560 // Emit the switch block 2561 if (Info.SwitchBlock) 2562 CGF.EmitBlock(Info.SwitchBlock); 2563 if (Info.EndBlock) 2564 CGF.EmitBlock(Info.EndBlock); 2565 2566 CGF.EmitBlock(FinallyRethrow); 2567 CGF.Builder.CreateCall(ObjCTypes.getExceptionThrowFn(), 2568 CGF.Builder.CreateLoad(RethrowPtr)); 2569 CGF.Builder.CreateUnreachable(); 2570 2571 CGF.EmitBlock(FinallyEnd); 2572} 2573 2574void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF, 2575 const ObjCAtThrowStmt &S) { 2576 llvm::Value *ExceptionAsObject; 2577 2578 if (const Expr *ThrowExpr = S.getThrowExpr()) { 2579 llvm::Value *Exception = CGF.EmitScalarExpr(ThrowExpr); 2580 ExceptionAsObject = 2581 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy, "tmp"); 2582 } else { 2583 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) && 2584 "Unexpected rethrow outside @catch block."); 2585 ExceptionAsObject = CGF.ObjCEHValueStack.back(); 2586 } 2587 2588 CGF.Builder.CreateCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject); 2589 CGF.Builder.CreateUnreachable(); 2590 2591 // Clear the insertion point to indicate we are in unreachable code. 2592 CGF.Builder.ClearInsertionPoint(); 2593} 2594 2595/// EmitObjCWeakRead - Code gen for loading value of a __weak 2596/// object: objc_read_weak (id *src) 2597/// 2598llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, 2599 llvm::Value *AddrWeakObj) 2600{ 2601 const llvm::Type* DestTy = 2602 cast<llvm::PointerType>(AddrWeakObj->getType())->getElementType(); 2603 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy); 2604 llvm::Value *read_weak = CGF.Builder.CreateCall(ObjCTypes.getGcReadWeakFn(), 2605 AddrWeakObj, "weakread"); 2606 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy); 2607 return read_weak; 2608} 2609 2610/// EmitObjCWeakAssign - Code gen for assigning to a __weak object. 2611/// objc_assign_weak (id src, id *dst) 2612/// 2613void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, 2614 llvm::Value *src, llvm::Value *dst) 2615{ 2616 const llvm::Type * SrcTy = src->getType(); 2617 if (!isa<llvm::PointerType>(SrcTy)) { 2618 unsigned Size = CGM.getTargetData().getTypePaddedSize(SrcTy); 2619 assert(Size <= 8 && "does not support size > 8"); 2620 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy) 2621 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy); 2622 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 2623 } 2624 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 2625 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); 2626 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignWeakFn(), 2627 src, dst, "weakassign"); 2628 return; 2629} 2630 2631/// EmitObjCGlobalAssign - Code gen for assigning to a __strong object. 2632/// objc_assign_global (id src, id *dst) 2633/// 2634void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, 2635 llvm::Value *src, llvm::Value *dst) 2636{ 2637 const llvm::Type * SrcTy = src->getType(); 2638 if (!isa<llvm::PointerType>(SrcTy)) { 2639 unsigned Size = CGM.getTargetData().getTypePaddedSize(SrcTy); 2640 assert(Size <= 8 && "does not support size > 8"); 2641 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy) 2642 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy); 2643 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 2644 } 2645 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 2646 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); 2647 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignGlobalFn(), 2648 src, dst, "globalassign"); 2649 return; 2650} 2651 2652/// EmitObjCIvarAssign - Code gen for assigning to a __strong object. 2653/// objc_assign_ivar (id src, id *dst) 2654/// 2655void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, 2656 llvm::Value *src, llvm::Value *dst) 2657{ 2658 const llvm::Type * SrcTy = src->getType(); 2659 if (!isa<llvm::PointerType>(SrcTy)) { 2660 unsigned Size = CGM.getTargetData().getTypePaddedSize(SrcTy); 2661 assert(Size <= 8 && "does not support size > 8"); 2662 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy) 2663 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy); 2664 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 2665 } 2666 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 2667 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); 2668 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignIvarFn(), 2669 src, dst, "assignivar"); 2670 return; 2671} 2672 2673/// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object. 2674/// objc_assign_strongCast (id src, id *dst) 2675/// 2676void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, 2677 llvm::Value *src, llvm::Value *dst) 2678{ 2679 const llvm::Type * SrcTy = src->getType(); 2680 if (!isa<llvm::PointerType>(SrcTy)) { 2681 unsigned Size = CGM.getTargetData().getTypePaddedSize(SrcTy); 2682 assert(Size <= 8 && "does not support size > 8"); 2683 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy) 2684 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy); 2685 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 2686 } 2687 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 2688 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); 2689 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignStrongCastFn(), 2690 src, dst, "weakassign"); 2691 return; 2692} 2693 2694/// EmitObjCValueForIvar - Code Gen for ivar reference. 2695/// 2696LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, 2697 QualType ObjectTy, 2698 llvm::Value *BaseValue, 2699 const ObjCIvarDecl *Ivar, 2700 unsigned CVRQualifiers) { 2701 const ObjCInterfaceDecl *ID = ObjectTy->getAsObjCInterfaceType()->getDecl(); 2702 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers, 2703 EmitIvarOffset(CGF, ID, Ivar)); 2704} 2705 2706llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF, 2707 const ObjCInterfaceDecl *Interface, 2708 const ObjCIvarDecl *Ivar) { 2709 uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar); 2710 return llvm::ConstantInt::get( 2711 CGM.getTypes().ConvertType(CGM.getContext().LongTy), 2712 Offset); 2713} 2714 2715/* *** Private Interface *** */ 2716 2717/// EmitImageInfo - Emit the image info marker used to encode some module 2718/// level information. 2719/// 2720/// See: <rdr://4810609&4810587&4810587> 2721/// struct IMAGE_INFO { 2722/// unsigned version; 2723/// unsigned flags; 2724/// }; 2725enum ImageInfoFlags { 2726 eImageInfo_FixAndContinue = (1 << 0), // FIXME: Not sure what 2727 // this implies. 2728 eImageInfo_GarbageCollected = (1 << 1), 2729 eImageInfo_GCOnly = (1 << 2), 2730 eImageInfo_OptimizedByDyld = (1 << 3), // FIXME: When is this set. 2731 2732 // A flag indicating that the module has no instances of an 2733 // @synthesize of a superclass variable. <rdar://problem/6803242> 2734 eImageInfo_CorrectedSynthesize = (1 << 4) 2735}; 2736 2737void CGObjCMac::EmitImageInfo() { 2738 unsigned version = 0; // Version is unused? 2739 unsigned flags = 0; 2740 2741 // FIXME: Fix and continue? 2742 if (CGM.getLangOptions().getGCMode() != LangOptions::NonGC) 2743 flags |= eImageInfo_GarbageCollected; 2744 if (CGM.getLangOptions().getGCMode() == LangOptions::GCOnly) 2745 flags |= eImageInfo_GCOnly; 2746 2747 // We never allow @synthesize of a superclass property. 2748 flags |= eImageInfo_CorrectedSynthesize; 2749 2750 // Emitted as int[2]; 2751 llvm::Constant *values[2] = { 2752 llvm::ConstantInt::get(llvm::Type::Int32Ty, version), 2753 llvm::ConstantInt::get(llvm::Type::Int32Ty, flags) 2754 }; 2755 llvm::ArrayType *AT = llvm::ArrayType::get(llvm::Type::Int32Ty, 2); 2756 2757 const char *Section; 2758 if (ObjCABI == 1) 2759 Section = "__OBJC, __image_info,regular"; 2760 else 2761 Section = "__DATA, __objc_imageinfo, regular, no_dead_strip"; 2762 llvm::GlobalVariable *GV = 2763 CreateMetadataVar("\01L_OBJC_IMAGE_INFO", 2764 llvm::ConstantArray::get(AT, values, 2), 2765 Section, 2766 0, 2767 true); 2768 GV->setConstant(true); 2769} 2770 2771 2772// struct objc_module { 2773// unsigned long version; 2774// unsigned long size; 2775// const char *name; 2776// Symtab symtab; 2777// }; 2778 2779// FIXME: Get from somewhere 2780static const int ModuleVersion = 7; 2781 2782void CGObjCMac::EmitModuleInfo() { 2783 uint64_t Size = CGM.getTargetData().getTypePaddedSize(ObjCTypes.ModuleTy); 2784 2785 std::vector<llvm::Constant*> Values(4); 2786 Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, ModuleVersion); 2787 Values[1] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size); 2788 // This used to be the filename, now it is unused. <rdr://4327263> 2789 Values[2] = GetClassName(&CGM.getContext().Idents.get("")); 2790 Values[3] = EmitModuleSymbols(); 2791 CreateMetadataVar("\01L_OBJC_MODULES", 2792 llvm::ConstantStruct::get(ObjCTypes.ModuleTy, Values), 2793 "__OBJC,__module_info,regular,no_dead_strip", 2794 4, true); 2795} 2796 2797llvm::Constant *CGObjCMac::EmitModuleSymbols() { 2798 unsigned NumClasses = DefinedClasses.size(); 2799 unsigned NumCategories = DefinedCategories.size(); 2800 2801 // Return null if no symbols were defined. 2802 if (!NumClasses && !NumCategories) 2803 return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy); 2804 2805 std::vector<llvm::Constant*> Values(5); 2806 Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0); 2807 Values[1] = llvm::Constant::getNullValue(ObjCTypes.SelectorPtrTy); 2808 Values[2] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumClasses); 2809 Values[3] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumCategories); 2810 2811 // The runtime expects exactly the list of defined classes followed 2812 // by the list of defined categories, in a single array. 2813 std::vector<llvm::Constant*> Symbols(NumClasses + NumCategories); 2814 for (unsigned i=0; i<NumClasses; i++) 2815 Symbols[i] = llvm::ConstantExpr::getBitCast(DefinedClasses[i], 2816 ObjCTypes.Int8PtrTy); 2817 for (unsigned i=0; i<NumCategories; i++) 2818 Symbols[NumClasses + i] = 2819 llvm::ConstantExpr::getBitCast(DefinedCategories[i], 2820 ObjCTypes.Int8PtrTy); 2821 2822 Values[4] = 2823 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy, 2824 NumClasses + NumCategories), 2825 Symbols); 2826 2827 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 2828 2829 llvm::GlobalVariable *GV = 2830 CreateMetadataVar("\01L_OBJC_SYMBOLS", Init, 2831 "__OBJC,__symbols,regular,no_dead_strip", 2832 4, true); 2833 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy); 2834} 2835 2836llvm::Value *CGObjCMac::EmitClassRef(CGBuilderTy &Builder, 2837 const ObjCInterfaceDecl *ID) { 2838 LazySymbols.insert(ID->getIdentifier()); 2839 2840 llvm::GlobalVariable *&Entry = ClassReferences[ID->getIdentifier()]; 2841 2842 if (!Entry) { 2843 llvm::Constant *Casted = 2844 llvm::ConstantExpr::getBitCast(GetClassName(ID->getIdentifier()), 2845 ObjCTypes.ClassPtrTy); 2846 Entry = 2847 CreateMetadataVar("\01L_OBJC_CLASS_REFERENCES_", Casted, 2848 "__OBJC,__cls_refs,literal_pointers,no_dead_strip", 2849 4, true); 2850 } 2851 2852 return Builder.CreateLoad(Entry, false, "tmp"); 2853} 2854 2855llvm::Value *CGObjCMac::EmitSelector(CGBuilderTy &Builder, Selector Sel) { 2856 llvm::GlobalVariable *&Entry = SelectorReferences[Sel]; 2857 2858 if (!Entry) { 2859 llvm::Constant *Casted = 2860 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel), 2861 ObjCTypes.SelectorPtrTy); 2862 Entry = 2863 CreateMetadataVar("\01L_OBJC_SELECTOR_REFERENCES_", Casted, 2864 "__OBJC,__message_refs,literal_pointers,no_dead_strip", 2865 4, true); 2866 } 2867 2868 return Builder.CreateLoad(Entry, false, "tmp"); 2869} 2870 2871llvm::Constant *CGObjCCommonMac::GetClassName(IdentifierInfo *Ident) { 2872 llvm::GlobalVariable *&Entry = ClassNames[Ident]; 2873 2874 if (!Entry) 2875 Entry = CreateMetadataVar("\01L_OBJC_CLASS_NAME_", 2876 llvm::ConstantArray::get(Ident->getName()), 2877 "__TEXT,__cstring,cstring_literals", 2878 1, true); 2879 2880 return getConstantGEP(Entry, 0, 0); 2881} 2882 2883/// GetIvarLayoutName - Returns a unique constant for the given 2884/// ivar layout bitmap. 2885llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident, 2886 const ObjCCommonTypesHelper &ObjCTypes) { 2887 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy); 2888} 2889 2890static QualType::GCAttrTypes GetGCAttrTypeForType(ASTContext &Ctx, 2891 QualType FQT) { 2892 if (FQT.isObjCGCStrong()) 2893 return QualType::Strong; 2894 2895 if (FQT.isObjCGCWeak()) 2896 return QualType::Weak; 2897 2898 if (Ctx.isObjCObjectPointerType(FQT)) 2899 return QualType::Strong; 2900 2901 if (const PointerType *PT = FQT->getAsPointerType()) 2902 return GetGCAttrTypeForType(Ctx, PT->getPointeeType()); 2903 2904 return QualType::GCNone; 2905} 2906 2907void CGObjCCommonMac::BuildAggrIvarRecordLayout(const RecordType *RT, 2908 unsigned int BytePos, 2909 bool ForStrongLayout, 2910 bool &HasUnion) { 2911 const RecordDecl *RD = RT->getDecl(); 2912 // FIXME - Use iterator. 2913 llvm::SmallVector<FieldDecl*, 16> Fields(RD->field_begin(CGM.getContext()), 2914 RD->field_end(CGM.getContext())); 2915 const llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0)); 2916 const llvm::StructLayout *RecLayout = 2917 CGM.getTargetData().getStructLayout(cast<llvm::StructType>(Ty)); 2918 2919 BuildAggrIvarLayout(0, RecLayout, RD, Fields, BytePos, 2920 ForStrongLayout, HasUnion); 2921} 2922 2923void CGObjCCommonMac::BuildAggrIvarLayout(const ObjCImplementationDecl *OI, 2924 const llvm::StructLayout *Layout, 2925 const RecordDecl *RD, 2926 const llvm::SmallVectorImpl<FieldDecl*> &RecFields, 2927 unsigned int BytePos, bool ForStrongLayout, 2928 bool &HasUnion) { 2929 bool IsUnion = (RD && RD->isUnion()); 2930 uint64_t MaxUnionIvarSize = 0; 2931 uint64_t MaxSkippedUnionIvarSize = 0; 2932 FieldDecl *MaxField = 0; 2933 FieldDecl *MaxSkippedField = 0; 2934 FieldDecl *LastFieldBitfield = 0; 2935 uint64_t MaxFieldOffset = 0; 2936 uint64_t MaxSkippedFieldOffset = 0; 2937 uint64_t LastBitfieldOffset = 0; 2938 2939 if (RecFields.empty()) 2940 return; 2941 unsigned WordSizeInBits = CGM.getContext().Target.getPointerWidth(0); 2942 unsigned ByteSizeInBits = CGM.getContext().Target.getCharWidth(); 2943 2944 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { 2945 FieldDecl *Field = RecFields[i]; 2946 uint64_t FieldOffset; 2947 if (RD) 2948 FieldOffset = 2949 Layout->getElementOffset(CGM.getTypes().getLLVMFieldNo(Field)); 2950 else 2951 FieldOffset = ComputeIvarBaseOffset(CGM, OI, cast<ObjCIvarDecl>(Field)); 2952 2953 // Skip over unnamed or bitfields 2954 if (!Field->getIdentifier() || Field->isBitField()) { 2955 LastFieldBitfield = Field; 2956 LastBitfieldOffset = FieldOffset; 2957 continue; 2958 } 2959 2960 LastFieldBitfield = 0; 2961 QualType FQT = Field->getType(); 2962 if (FQT->isRecordType() || FQT->isUnionType()) { 2963 if (FQT->isUnionType()) 2964 HasUnion = true; 2965 2966 BuildAggrIvarRecordLayout(FQT->getAsRecordType(), 2967 BytePos + FieldOffset, 2968 ForStrongLayout, HasUnion); 2969 continue; 2970 } 2971 2972 if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) { 2973 const ConstantArrayType *CArray = 2974 dyn_cast_or_null<ConstantArrayType>(Array); 2975 uint64_t ElCount = CArray->getSize().getZExtValue(); 2976 assert(CArray && "only array with known element size is supported"); 2977 FQT = CArray->getElementType(); 2978 while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) { 2979 const ConstantArrayType *CArray = 2980 dyn_cast_or_null<ConstantArrayType>(Array); 2981 ElCount *= CArray->getSize().getZExtValue(); 2982 FQT = CArray->getElementType(); 2983 } 2984 2985 assert(!FQT->isUnionType() && 2986 "layout for array of unions not supported"); 2987 if (FQT->isRecordType()) { 2988 int OldIndex = IvarsInfo.size() - 1; 2989 int OldSkIndex = SkipIvars.size() -1; 2990 2991 const RecordType *RT = FQT->getAsRecordType(); 2992 BuildAggrIvarRecordLayout(RT, BytePos + FieldOffset, 2993 ForStrongLayout, HasUnion); 2994 2995 // Replicate layout information for each array element. Note that 2996 // one element is already done. 2997 uint64_t ElIx = 1; 2998 for (int FirstIndex = IvarsInfo.size() - 1, 2999 FirstSkIndex = SkipIvars.size() - 1 ;ElIx < ElCount; ElIx++) { 3000 uint64_t Size = CGM.getContext().getTypeSize(RT)/ByteSizeInBits; 3001 for (int i = OldIndex+1; i <= FirstIndex; ++i) 3002 IvarsInfo.push_back(GC_IVAR(IvarsInfo[i].ivar_bytepos + Size*ElIx, 3003 IvarsInfo[i].ivar_size)); 3004 for (int i = OldSkIndex+1; i <= FirstSkIndex; ++i) 3005 SkipIvars.push_back(GC_IVAR(SkipIvars[i].ivar_bytepos + Size*ElIx, 3006 SkipIvars[i].ivar_size)); 3007 } 3008 continue; 3009 } 3010 } 3011 // At this point, we are done with Record/Union and array there of. 3012 // For other arrays we are down to its element type. 3013 QualType::GCAttrTypes GCAttr = GetGCAttrTypeForType(CGM.getContext(), FQT); 3014 3015 unsigned FieldSize = CGM.getContext().getTypeSize(Field->getType()); 3016 if ((ForStrongLayout && GCAttr == QualType::Strong) 3017 || (!ForStrongLayout && GCAttr == QualType::Weak)) { 3018 if (IsUnion) { 3019 uint64_t UnionIvarSize = FieldSize / WordSizeInBits; 3020 if (UnionIvarSize > MaxUnionIvarSize) { 3021 MaxUnionIvarSize = UnionIvarSize; 3022 MaxField = Field; 3023 MaxFieldOffset = FieldOffset; 3024 } 3025 } else { 3026 IvarsInfo.push_back(GC_IVAR(BytePos + FieldOffset, 3027 FieldSize / WordSizeInBits)); 3028 } 3029 } else if ((ForStrongLayout && 3030 (GCAttr == QualType::GCNone || GCAttr == QualType::Weak)) 3031 || (!ForStrongLayout && GCAttr != QualType::Weak)) { 3032 if (IsUnion) { 3033 // FIXME: Why the asymmetry? We divide by word size in bits on 3034 // other side. 3035 uint64_t UnionIvarSize = FieldSize; 3036 if (UnionIvarSize > MaxSkippedUnionIvarSize) { 3037 MaxSkippedUnionIvarSize = UnionIvarSize; 3038 MaxSkippedField = Field; 3039 MaxSkippedFieldOffset = FieldOffset; 3040 } 3041 } else { 3042 // FIXME: Why the asymmetry, we divide by byte size in bits here? 3043 SkipIvars.push_back(GC_IVAR(BytePos + FieldOffset, 3044 FieldSize / ByteSizeInBits)); 3045 } 3046 } 3047 } 3048 3049 if (LastFieldBitfield) { 3050 // Last field was a bitfield. Must update skip info. 3051 Expr *BitWidth = LastFieldBitfield->getBitWidth(); 3052 uint64_t BitFieldSize = 3053 BitWidth->EvaluateAsInt(CGM.getContext()).getZExtValue(); 3054 GC_IVAR skivar; 3055 skivar.ivar_bytepos = BytePos + LastBitfieldOffset; 3056 skivar.ivar_size = (BitFieldSize / ByteSizeInBits) 3057 + ((BitFieldSize % ByteSizeInBits) != 0); 3058 SkipIvars.push_back(skivar); 3059 } 3060 3061 if (MaxField) 3062 IvarsInfo.push_back(GC_IVAR(BytePos + MaxFieldOffset, 3063 MaxUnionIvarSize)); 3064 if (MaxSkippedField) 3065 SkipIvars.push_back(GC_IVAR(BytePos + MaxSkippedFieldOffset, 3066 MaxSkippedUnionIvarSize)); 3067} 3068 3069/// BuildIvarLayout - Builds ivar layout bitmap for the class 3070/// implementation for the __strong or __weak case. 3071/// The layout map displays which words in ivar list must be skipped 3072/// and which must be scanned by GC (see below). String is built of bytes. 3073/// Each byte is divided up in two nibbles (4-bit each). Left nibble is count 3074/// of words to skip and right nibble is count of words to scan. So, each 3075/// nibble represents up to 15 workds to skip or scan. Skipping the rest is 3076/// represented by a 0x00 byte which also ends the string. 3077/// 1. when ForStrongLayout is true, following ivars are scanned: 3078/// - id, Class 3079/// - object * 3080/// - __strong anything 3081/// 3082/// 2. When ForStrongLayout is false, following ivars are scanned: 3083/// - __weak anything 3084/// 3085llvm::Constant *CGObjCCommonMac::BuildIvarLayout( 3086 const ObjCImplementationDecl *OMD, 3087 bool ForStrongLayout) { 3088 bool hasUnion = false; 3089 3090 unsigned int WordsToScan, WordsToSkip; 3091 const llvm::Type *PtrTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty); 3092 if (CGM.getLangOptions().getGCMode() == LangOptions::NonGC) 3093 return llvm::Constant::getNullValue(PtrTy); 3094 3095 llvm::SmallVector<FieldDecl*, 32> RecFields; 3096 const ObjCInterfaceDecl *OI = OMD->getClassInterface(); 3097 CGM.getContext().CollectObjCIvars(OI, RecFields); 3098 3099 // Add this implementations synthesized ivars. 3100 for (ObjCInterfaceDecl::prop_iterator I = OI->prop_begin(CGM.getContext()), 3101 E = OI->prop_end(CGM.getContext()); I != E; ++I) { 3102 if (ObjCIvarDecl *IV = (*I)->getPropertyIvarDecl()) 3103 RecFields.push_back(cast<FieldDecl>(IV)); 3104 } 3105 3106 if (RecFields.empty()) 3107 return llvm::Constant::getNullValue(PtrTy); 3108 3109 SkipIvars.clear(); 3110 IvarsInfo.clear(); 3111 3112 BuildAggrIvarLayout(OMD, 0, 0, RecFields, 0, ForStrongLayout, hasUnion); 3113 if (IvarsInfo.empty()) 3114 return llvm::Constant::getNullValue(PtrTy); 3115 3116 // Sort on byte position in case we encounterred a union nested in 3117 // the ivar list. 3118 if (hasUnion && !IvarsInfo.empty()) 3119 std::sort(IvarsInfo.begin(), IvarsInfo.end()); 3120 if (hasUnion && !SkipIvars.empty()) 3121 std::sort(SkipIvars.begin(), SkipIvars.end()); 3122 3123 // Build the string of skip/scan nibbles 3124 llvm::SmallVector<SKIP_SCAN, 32> SkipScanIvars; 3125 unsigned int WordSize = 3126 CGM.getTypes().getTargetData().getTypePaddedSize(PtrTy); 3127 if (IvarsInfo[0].ivar_bytepos == 0) { 3128 WordsToSkip = 0; 3129 WordsToScan = IvarsInfo[0].ivar_size; 3130 } else { 3131 WordsToSkip = IvarsInfo[0].ivar_bytepos/WordSize; 3132 WordsToScan = IvarsInfo[0].ivar_size; 3133 } 3134 for (unsigned int i=1, Last=IvarsInfo.size(); i != Last; i++) { 3135 unsigned int TailPrevGCObjC = 3136 IvarsInfo[i-1].ivar_bytepos + IvarsInfo[i-1].ivar_size * WordSize; 3137 if (IvarsInfo[i].ivar_bytepos == TailPrevGCObjC) { 3138 // consecutive 'scanned' object pointers. 3139 WordsToScan += IvarsInfo[i].ivar_size; 3140 } else { 3141 // Skip over 'gc'able object pointer which lay over each other. 3142 if (TailPrevGCObjC > IvarsInfo[i].ivar_bytepos) 3143 continue; 3144 // Must skip over 1 or more words. We save current skip/scan values 3145 // and start a new pair. 3146 SKIP_SCAN SkScan; 3147 SkScan.skip = WordsToSkip; 3148 SkScan.scan = WordsToScan; 3149 SkipScanIvars.push_back(SkScan); 3150 3151 // Skip the hole. 3152 SkScan.skip = (IvarsInfo[i].ivar_bytepos - TailPrevGCObjC) / WordSize; 3153 SkScan.scan = 0; 3154 SkipScanIvars.push_back(SkScan); 3155 WordsToSkip = 0; 3156 WordsToScan = IvarsInfo[i].ivar_size; 3157 } 3158 } 3159 if (WordsToScan > 0) { 3160 SKIP_SCAN SkScan; 3161 SkScan.skip = WordsToSkip; 3162 SkScan.scan = WordsToScan; 3163 SkipScanIvars.push_back(SkScan); 3164 } 3165 3166 bool BytesSkipped = false; 3167 if (!SkipIvars.empty()) { 3168 unsigned int LastIndex = SkipIvars.size()-1; 3169 int LastByteSkipped = 3170 SkipIvars[LastIndex].ivar_bytepos + SkipIvars[LastIndex].ivar_size; 3171 LastIndex = IvarsInfo.size()-1; 3172 int LastByteScanned = 3173 IvarsInfo[LastIndex].ivar_bytepos + 3174 IvarsInfo[LastIndex].ivar_size * WordSize; 3175 BytesSkipped = (LastByteSkipped > LastByteScanned); 3176 // Compute number of bytes to skip at the tail end of the last ivar scanned. 3177 if (BytesSkipped) { 3178 unsigned int TotalWords = (LastByteSkipped + (WordSize -1)) / WordSize; 3179 SKIP_SCAN SkScan; 3180 SkScan.skip = TotalWords - (LastByteScanned/WordSize); 3181 SkScan.scan = 0; 3182 SkipScanIvars.push_back(SkScan); 3183 } 3184 } 3185 // Mini optimization of nibbles such that an 0xM0 followed by 0x0N is produced 3186 // as 0xMN. 3187 int SkipScan = SkipScanIvars.size()-1; 3188 for (int i = 0; i <= SkipScan; i++) { 3189 if ((i < SkipScan) && SkipScanIvars[i].skip && SkipScanIvars[i].scan == 0 3190 && SkipScanIvars[i+1].skip == 0 && SkipScanIvars[i+1].scan) { 3191 // 0xM0 followed by 0x0N detected. 3192 SkipScanIvars[i].scan = SkipScanIvars[i+1].scan; 3193 for (int j = i+1; j < SkipScan; j++) 3194 SkipScanIvars[j] = SkipScanIvars[j+1]; 3195 --SkipScan; 3196 } 3197 } 3198 3199 // Generate the string. 3200 std::string BitMap; 3201 for (int i = 0; i <= SkipScan; i++) { 3202 unsigned char byte; 3203 unsigned int skip_small = SkipScanIvars[i].skip % 0xf; 3204 unsigned int scan_small = SkipScanIvars[i].scan % 0xf; 3205 unsigned int skip_big = SkipScanIvars[i].skip / 0xf; 3206 unsigned int scan_big = SkipScanIvars[i].scan / 0xf; 3207 3208 if (skip_small > 0 || skip_big > 0) 3209 BytesSkipped = true; 3210 // first skip big. 3211 for (unsigned int ix = 0; ix < skip_big; ix++) 3212 BitMap += (unsigned char)(0xf0); 3213 3214 // next (skip small, scan) 3215 if (skip_small) { 3216 byte = skip_small << 4; 3217 if (scan_big > 0) { 3218 byte |= 0xf; 3219 --scan_big; 3220 } else if (scan_small) { 3221 byte |= scan_small; 3222 scan_small = 0; 3223 } 3224 BitMap += byte; 3225 } 3226 // next scan big 3227 for (unsigned int ix = 0; ix < scan_big; ix++) 3228 BitMap += (unsigned char)(0x0f); 3229 // last scan small 3230 if (scan_small) { 3231 byte = scan_small; 3232 BitMap += byte; 3233 } 3234 } 3235 // null terminate string. 3236 unsigned char zero = 0; 3237 BitMap += zero; 3238 3239 if (CGM.getLangOptions().ObjCGCBitmapPrint) { 3240 printf("\n%s ivar layout for class '%s': ", 3241 ForStrongLayout ? "strong" : "weak", 3242 OMD->getClassInterface()->getNameAsCString()); 3243 const unsigned char *s = (unsigned char*)BitMap.c_str(); 3244 for (unsigned i = 0; i < BitMap.size(); i++) 3245 if (!(s[i] & 0xf0)) 3246 printf("0x0%x%s", s[i], s[i] != 0 ? ", " : ""); 3247 else 3248 printf("0x%x%s", s[i], s[i] != 0 ? ", " : ""); 3249 printf("\n"); 3250 } 3251 3252 // if ivar_layout bitmap is all 1 bits (nothing skipped) then use NULL as 3253 // final layout. 3254 if (ForStrongLayout && !BytesSkipped) 3255 return llvm::Constant::getNullValue(PtrTy); 3256 llvm::GlobalVariable * Entry = CreateMetadataVar("\01L_OBJC_CLASS_NAME_", 3257 llvm::ConstantArray::get(BitMap.c_str()), 3258 "__TEXT,__cstring,cstring_literals", 3259 1, true); 3260 return getConstantGEP(Entry, 0, 0); 3261} 3262 3263llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) { 3264 llvm::GlobalVariable *&Entry = MethodVarNames[Sel]; 3265 3266 // FIXME: Avoid std::string copying. 3267 if (!Entry) 3268 Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_NAME_", 3269 llvm::ConstantArray::get(Sel.getAsString()), 3270 "__TEXT,__cstring,cstring_literals", 3271 1, true); 3272 3273 return getConstantGEP(Entry, 0, 0); 3274} 3275 3276// FIXME: Merge into a single cstring creation function. 3277llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) { 3278 return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID)); 3279} 3280 3281// FIXME: Merge into a single cstring creation function. 3282llvm::Constant *CGObjCCommonMac::GetMethodVarName(const std::string &Name) { 3283 return GetMethodVarName(&CGM.getContext().Idents.get(Name)); 3284} 3285 3286llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) { 3287 std::string TypeStr; 3288 CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field); 3289 3290 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr]; 3291 3292 if (!Entry) 3293 Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_TYPE_", 3294 llvm::ConstantArray::get(TypeStr), 3295 "__TEXT,__cstring,cstring_literals", 3296 1, true); 3297 3298 return getConstantGEP(Entry, 0, 0); 3299} 3300 3301llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D) { 3302 std::string TypeStr; 3303 CGM.getContext().getObjCEncodingForMethodDecl(const_cast<ObjCMethodDecl*>(D), 3304 TypeStr); 3305 3306 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr]; 3307 3308 if (!Entry) 3309 Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_TYPE_", 3310 llvm::ConstantArray::get(TypeStr), 3311 "__TEXT,__cstring,cstring_literals", 3312 1, true); 3313 3314 return getConstantGEP(Entry, 0, 0); 3315} 3316 3317// FIXME: Merge into a single cstring creation function. 3318llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) { 3319 llvm::GlobalVariable *&Entry = PropertyNames[Ident]; 3320 3321 if (!Entry) 3322 Entry = CreateMetadataVar("\01L_OBJC_PROP_NAME_ATTR_", 3323 llvm::ConstantArray::get(Ident->getName()), 3324 "__TEXT,__cstring,cstring_literals", 3325 1, true); 3326 3327 return getConstantGEP(Entry, 0, 0); 3328} 3329 3330// FIXME: Merge into a single cstring creation function. 3331// FIXME: This Decl should be more precise. 3332llvm::Constant * 3333 CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD, 3334 const Decl *Container) { 3335 std::string TypeStr; 3336 CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container, TypeStr); 3337 return GetPropertyName(&CGM.getContext().Idents.get(TypeStr)); 3338} 3339 3340void CGObjCCommonMac::GetNameForMethod(const ObjCMethodDecl *D, 3341 const ObjCContainerDecl *CD, 3342 std::string &NameOut) { 3343 NameOut = '\01'; 3344 NameOut += (D->isInstanceMethod() ? '-' : '+'); 3345 NameOut += '['; 3346 assert (CD && "Missing container decl in GetNameForMethod"); 3347 NameOut += CD->getNameAsString(); 3348 if (const ObjCCategoryImplDecl *CID = 3349 dyn_cast<ObjCCategoryImplDecl>(D->getDeclContext())) { 3350 NameOut += '('; 3351 NameOut += CID->getNameAsString(); 3352 NameOut+= ')'; 3353 } 3354 NameOut += ' '; 3355 NameOut += D->getSelector().getAsString(); 3356 NameOut += ']'; 3357} 3358 3359void CGObjCMac::FinishModule() { 3360 EmitModuleInfo(); 3361 3362 // Emit the dummy bodies for any protocols which were referenced but 3363 // never defined. 3364 for (llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*>::iterator 3365 i = Protocols.begin(), e = Protocols.end(); i != e; ++i) { 3366 if (i->second->hasInitializer()) 3367 continue; 3368 3369 std::vector<llvm::Constant*> Values(5); 3370 Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy); 3371 Values[1] = GetClassName(i->first); 3372 Values[2] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy); 3373 Values[3] = Values[4] = 3374 llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy); 3375 i->second->setLinkage(llvm::GlobalValue::InternalLinkage); 3376 i->second->setInitializer(llvm::ConstantStruct::get(ObjCTypes.ProtocolTy, 3377 Values)); 3378 } 3379 3380 std::vector<llvm::Constant*> Used; 3381 for (std::vector<llvm::GlobalVariable*>::iterator i = UsedGlobals.begin(), 3382 e = UsedGlobals.end(); i != e; ++i) { 3383 Used.push_back(llvm::ConstantExpr::getBitCast(*i, ObjCTypes.Int8PtrTy)); 3384 } 3385 3386 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy, Used.size()); 3387 llvm::GlobalValue *GV = 3388 new llvm::GlobalVariable(AT, false, 3389 llvm::GlobalValue::AppendingLinkage, 3390 llvm::ConstantArray::get(AT, Used), 3391 "llvm.used", 3392 &CGM.getModule()); 3393 3394 GV->setSection("llvm.metadata"); 3395 3396 // Add assembler directives to add lazy undefined symbol references 3397 // for classes which are referenced but not defined. This is 3398 // important for correct linker interaction. 3399 3400 // FIXME: Uh, this isn't particularly portable. 3401 std::stringstream s; 3402 3403 if (!CGM.getModule().getModuleInlineAsm().empty()) 3404 s << "\n"; 3405 3406 for (std::set<IdentifierInfo*>::iterator i = LazySymbols.begin(), 3407 e = LazySymbols.end(); i != e; ++i) { 3408 s << "\t.lazy_reference .objc_class_name_" << (*i)->getName() << "\n"; 3409 } 3410 for (std::set<IdentifierInfo*>::iterator i = DefinedSymbols.begin(), 3411 e = DefinedSymbols.end(); i != e; ++i) { 3412 s << "\t.objc_class_name_" << (*i)->getName() << "=0\n" 3413 << "\t.globl .objc_class_name_" << (*i)->getName() << "\n"; 3414 } 3415 3416 CGM.getModule().appendModuleInlineAsm(s.str()); 3417} 3418 3419CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm) 3420 : CGObjCCommonMac(cgm), 3421 ObjCTypes(cgm) 3422{ 3423 ObjCEmptyCacheVar = ObjCEmptyVtableVar = NULL; 3424 ObjCABI = 2; 3425} 3426 3427/* *** */ 3428 3429ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm) 3430: CGM(cgm) 3431{ 3432 CodeGen::CodeGenTypes &Types = CGM.getTypes(); 3433 ASTContext &Ctx = CGM.getContext(); 3434 3435 ShortTy = Types.ConvertType(Ctx.ShortTy); 3436 IntTy = Types.ConvertType(Ctx.IntTy); 3437 LongTy = Types.ConvertType(Ctx.LongTy); 3438 LongLongTy = Types.ConvertType(Ctx.LongLongTy); 3439 Int8PtrTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty); 3440 3441 ObjectPtrTy = Types.ConvertType(Ctx.getObjCIdType()); 3442 PtrObjectPtrTy = llvm::PointerType::getUnqual(ObjectPtrTy); 3443 SelectorPtrTy = Types.ConvertType(Ctx.getObjCSelType()); 3444 3445 // FIXME: It would be nice to unify this with the opaque type, so 3446 // that the IR comes out a bit cleaner. 3447 const llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType()); 3448 ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T); 3449 3450 // I'm not sure I like this. The implicit coordination is a bit 3451 // gross. We should solve this in a reasonable fashion because this 3452 // is a pretty common task (match some runtime data structure with 3453 // an LLVM data structure). 3454 3455 // FIXME: This is leaked. 3456 // FIXME: Merge with rewriter code? 3457 3458 // struct _objc_super { 3459 // id self; 3460 // Class cls; 3461 // } 3462 RecordDecl *RD = RecordDecl::Create(Ctx, TagDecl::TK_struct, 0, 3463 SourceLocation(), 3464 &Ctx.Idents.get("_objc_super")); 3465 RD->addDecl(Ctx, FieldDecl::Create(Ctx, RD, SourceLocation(), 0, 3466 Ctx.getObjCIdType(), 0, false)); 3467 RD->addDecl(Ctx, FieldDecl::Create(Ctx, RD, SourceLocation(), 0, 3468 Ctx.getObjCClassType(), 0, false)); 3469 RD->completeDefinition(Ctx); 3470 3471 SuperCTy = Ctx.getTagDeclType(RD); 3472 SuperPtrCTy = Ctx.getPointerType(SuperCTy); 3473 3474 SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy)); 3475 SuperPtrTy = llvm::PointerType::getUnqual(SuperTy); 3476 3477 // struct _prop_t { 3478 // char *name; 3479 // char *attributes; 3480 // } 3481 PropertyTy = llvm::StructType::get(Int8PtrTy, Int8PtrTy, NULL); 3482 CGM.getModule().addTypeName("struct._prop_t", 3483 PropertyTy); 3484 3485 // struct _prop_list_t { 3486 // uint32_t entsize; // sizeof(struct _prop_t) 3487 // uint32_t count_of_properties; 3488 // struct _prop_t prop_list[count_of_properties]; 3489 // } 3490 PropertyListTy = llvm::StructType::get(IntTy, 3491 IntTy, 3492 llvm::ArrayType::get(PropertyTy, 0), 3493 NULL); 3494 CGM.getModule().addTypeName("struct._prop_list_t", 3495 PropertyListTy); 3496 // struct _prop_list_t * 3497 PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy); 3498 3499 // struct _objc_method { 3500 // SEL _cmd; 3501 // char *method_type; 3502 // char *_imp; 3503 // } 3504 MethodTy = llvm::StructType::get(SelectorPtrTy, 3505 Int8PtrTy, 3506 Int8PtrTy, 3507 NULL); 3508 CGM.getModule().addTypeName("struct._objc_method", MethodTy); 3509 3510 // struct _objc_cache * 3511 CacheTy = llvm::OpaqueType::get(); 3512 CGM.getModule().addTypeName("struct._objc_cache", CacheTy); 3513 CachePtrTy = llvm::PointerType::getUnqual(CacheTy); 3514} 3515 3516ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm) 3517 : ObjCCommonTypesHelper(cgm) 3518{ 3519 // struct _objc_method_description { 3520 // SEL name; 3521 // char *types; 3522 // } 3523 MethodDescriptionTy = 3524 llvm::StructType::get(SelectorPtrTy, 3525 Int8PtrTy, 3526 NULL); 3527 CGM.getModule().addTypeName("struct._objc_method_description", 3528 MethodDescriptionTy); 3529 3530 // struct _objc_method_description_list { 3531 // int count; 3532 // struct _objc_method_description[1]; 3533 // } 3534 MethodDescriptionListTy = 3535 llvm::StructType::get(IntTy, 3536 llvm::ArrayType::get(MethodDescriptionTy, 0), 3537 NULL); 3538 CGM.getModule().addTypeName("struct._objc_method_description_list", 3539 MethodDescriptionListTy); 3540 3541 // struct _objc_method_description_list * 3542 MethodDescriptionListPtrTy = 3543 llvm::PointerType::getUnqual(MethodDescriptionListTy); 3544 3545 // Protocol description structures 3546 3547 // struct _objc_protocol_extension { 3548 // uint32_t size; // sizeof(struct _objc_protocol_extension) 3549 // struct _objc_method_description_list *optional_instance_methods; 3550 // struct _objc_method_description_list *optional_class_methods; 3551 // struct _objc_property_list *instance_properties; 3552 // } 3553 ProtocolExtensionTy = 3554 llvm::StructType::get(IntTy, 3555 MethodDescriptionListPtrTy, 3556 MethodDescriptionListPtrTy, 3557 PropertyListPtrTy, 3558 NULL); 3559 CGM.getModule().addTypeName("struct._objc_protocol_extension", 3560 ProtocolExtensionTy); 3561 3562 // struct _objc_protocol_extension * 3563 ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy); 3564 3565 // Handle recursive construction of Protocol and ProtocolList types 3566 3567 llvm::PATypeHolder ProtocolTyHolder = llvm::OpaqueType::get(); 3568 llvm::PATypeHolder ProtocolListTyHolder = llvm::OpaqueType::get(); 3569 3570 const llvm::Type *T = 3571 llvm::StructType::get(llvm::PointerType::getUnqual(ProtocolListTyHolder), 3572 LongTy, 3573 llvm::ArrayType::get(ProtocolTyHolder, 0), 3574 NULL); 3575 cast<llvm::OpaqueType>(ProtocolListTyHolder.get())->refineAbstractTypeTo(T); 3576 3577 // struct _objc_protocol { 3578 // struct _objc_protocol_extension *isa; 3579 // char *protocol_name; 3580 // struct _objc_protocol **_objc_protocol_list; 3581 // struct _objc_method_description_list *instance_methods; 3582 // struct _objc_method_description_list *class_methods; 3583 // } 3584 T = llvm::StructType::get(ProtocolExtensionPtrTy, 3585 Int8PtrTy, 3586 llvm::PointerType::getUnqual(ProtocolListTyHolder), 3587 MethodDescriptionListPtrTy, 3588 MethodDescriptionListPtrTy, 3589 NULL); 3590 cast<llvm::OpaqueType>(ProtocolTyHolder.get())->refineAbstractTypeTo(T); 3591 3592 ProtocolListTy = cast<llvm::StructType>(ProtocolListTyHolder.get()); 3593 CGM.getModule().addTypeName("struct._objc_protocol_list", 3594 ProtocolListTy); 3595 // struct _objc_protocol_list * 3596 ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy); 3597 3598 ProtocolTy = cast<llvm::StructType>(ProtocolTyHolder.get()); 3599 CGM.getModule().addTypeName("struct._objc_protocol", ProtocolTy); 3600 ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy); 3601 3602 // Class description structures 3603 3604 // struct _objc_ivar { 3605 // char *ivar_name; 3606 // char *ivar_type; 3607 // int ivar_offset; 3608 // } 3609 IvarTy = llvm::StructType::get(Int8PtrTy, 3610 Int8PtrTy, 3611 IntTy, 3612 NULL); 3613 CGM.getModule().addTypeName("struct._objc_ivar", IvarTy); 3614 3615 // struct _objc_ivar_list * 3616 IvarListTy = llvm::OpaqueType::get(); 3617 CGM.getModule().addTypeName("struct._objc_ivar_list", IvarListTy); 3618 IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy); 3619 3620 // struct _objc_method_list * 3621 MethodListTy = llvm::OpaqueType::get(); 3622 CGM.getModule().addTypeName("struct._objc_method_list", MethodListTy); 3623 MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy); 3624 3625 // struct _objc_class_extension * 3626 ClassExtensionTy = 3627 llvm::StructType::get(IntTy, 3628 Int8PtrTy, 3629 PropertyListPtrTy, 3630 NULL); 3631 CGM.getModule().addTypeName("struct._objc_class_extension", ClassExtensionTy); 3632 ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy); 3633 3634 llvm::PATypeHolder ClassTyHolder = llvm::OpaqueType::get(); 3635 3636 // struct _objc_class { 3637 // Class isa; 3638 // Class super_class; 3639 // char *name; 3640 // long version; 3641 // long info; 3642 // long instance_size; 3643 // struct _objc_ivar_list *ivars; 3644 // struct _objc_method_list *methods; 3645 // struct _objc_cache *cache; 3646 // struct _objc_protocol_list *protocols; 3647 // char *ivar_layout; 3648 // struct _objc_class_ext *ext; 3649 // }; 3650 T = llvm::StructType::get(llvm::PointerType::getUnqual(ClassTyHolder), 3651 llvm::PointerType::getUnqual(ClassTyHolder), 3652 Int8PtrTy, 3653 LongTy, 3654 LongTy, 3655 LongTy, 3656 IvarListPtrTy, 3657 MethodListPtrTy, 3658 CachePtrTy, 3659 ProtocolListPtrTy, 3660 Int8PtrTy, 3661 ClassExtensionPtrTy, 3662 NULL); 3663 cast<llvm::OpaqueType>(ClassTyHolder.get())->refineAbstractTypeTo(T); 3664 3665 ClassTy = cast<llvm::StructType>(ClassTyHolder.get()); 3666 CGM.getModule().addTypeName("struct._objc_class", ClassTy); 3667 ClassPtrTy = llvm::PointerType::getUnqual(ClassTy); 3668 3669 // struct _objc_category { 3670 // char *category_name; 3671 // char *class_name; 3672 // struct _objc_method_list *instance_method; 3673 // struct _objc_method_list *class_method; 3674 // uint32_t size; // sizeof(struct _objc_category) 3675 // struct _objc_property_list *instance_properties;// category's @property 3676 // } 3677 CategoryTy = llvm::StructType::get(Int8PtrTy, 3678 Int8PtrTy, 3679 MethodListPtrTy, 3680 MethodListPtrTy, 3681 ProtocolListPtrTy, 3682 IntTy, 3683 PropertyListPtrTy, 3684 NULL); 3685 CGM.getModule().addTypeName("struct._objc_category", CategoryTy); 3686 3687 // Global metadata structures 3688 3689 // struct _objc_symtab { 3690 // long sel_ref_cnt; 3691 // SEL *refs; 3692 // short cls_def_cnt; 3693 // short cat_def_cnt; 3694 // char *defs[cls_def_cnt + cat_def_cnt]; 3695 // } 3696 SymtabTy = llvm::StructType::get(LongTy, 3697 SelectorPtrTy, 3698 ShortTy, 3699 ShortTy, 3700 llvm::ArrayType::get(Int8PtrTy, 0), 3701 NULL); 3702 CGM.getModule().addTypeName("struct._objc_symtab", SymtabTy); 3703 SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy); 3704 3705 // struct _objc_module { 3706 // long version; 3707 // long size; // sizeof(struct _objc_module) 3708 // char *name; 3709 // struct _objc_symtab* symtab; 3710 // } 3711 ModuleTy = 3712 llvm::StructType::get(LongTy, 3713 LongTy, 3714 Int8PtrTy, 3715 SymtabPtrTy, 3716 NULL); 3717 CGM.getModule().addTypeName("struct._objc_module", ModuleTy); 3718 3719 3720 // FIXME: This is the size of the setjmp buffer and should be 3721 // target specific. 18 is what's used on 32-bit X86. 3722 uint64_t SetJmpBufferSize = 18; 3723 3724 // Exceptions 3725 const llvm::Type *StackPtrTy = 3726 llvm::ArrayType::get(llvm::PointerType::getUnqual(llvm::Type::Int8Ty), 4); 3727 3728 ExceptionDataTy = 3729 llvm::StructType::get(llvm::ArrayType::get(llvm::Type::Int32Ty, 3730 SetJmpBufferSize), 3731 StackPtrTy, NULL); 3732 CGM.getModule().addTypeName("struct._objc_exception_data", 3733 ExceptionDataTy); 3734 3735} 3736 3737ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm) 3738: ObjCCommonTypesHelper(cgm) 3739{ 3740 // struct _method_list_t { 3741 // uint32_t entsize; // sizeof(struct _objc_method) 3742 // uint32_t method_count; 3743 // struct _objc_method method_list[method_count]; 3744 // } 3745 MethodListnfABITy = llvm::StructType::get(IntTy, 3746 IntTy, 3747 llvm::ArrayType::get(MethodTy, 0), 3748 NULL); 3749 CGM.getModule().addTypeName("struct.__method_list_t", 3750 MethodListnfABITy); 3751 // struct method_list_t * 3752 MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy); 3753 3754 // struct _protocol_t { 3755 // id isa; // NULL 3756 // const char * const protocol_name; 3757 // const struct _protocol_list_t * protocol_list; // super protocols 3758 // const struct method_list_t * const instance_methods; 3759 // const struct method_list_t * const class_methods; 3760 // const struct method_list_t *optionalInstanceMethods; 3761 // const struct method_list_t *optionalClassMethods; 3762 // const struct _prop_list_t * properties; 3763 // const uint32_t size; // sizeof(struct _protocol_t) 3764 // const uint32_t flags; // = 0 3765 // } 3766 3767 // Holder for struct _protocol_list_t * 3768 llvm::PATypeHolder ProtocolListTyHolder = llvm::OpaqueType::get(); 3769 3770 ProtocolnfABITy = llvm::StructType::get(ObjectPtrTy, 3771 Int8PtrTy, 3772 llvm::PointerType::getUnqual( 3773 ProtocolListTyHolder), 3774 MethodListnfABIPtrTy, 3775 MethodListnfABIPtrTy, 3776 MethodListnfABIPtrTy, 3777 MethodListnfABIPtrTy, 3778 PropertyListPtrTy, 3779 IntTy, 3780 IntTy, 3781 NULL); 3782 CGM.getModule().addTypeName("struct._protocol_t", 3783 ProtocolnfABITy); 3784 3785 // struct _protocol_t* 3786 ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy); 3787 3788 // struct _protocol_list_t { 3789 // long protocol_count; // Note, this is 32/64 bit 3790 // struct _protocol_t *[protocol_count]; 3791 // } 3792 ProtocolListnfABITy = llvm::StructType::get(LongTy, 3793 llvm::ArrayType::get( 3794 ProtocolnfABIPtrTy, 0), 3795 NULL); 3796 CGM.getModule().addTypeName("struct._objc_protocol_list", 3797 ProtocolListnfABITy); 3798 cast<llvm::OpaqueType>(ProtocolListTyHolder.get())->refineAbstractTypeTo( 3799 ProtocolListnfABITy); 3800 3801 // struct _objc_protocol_list* 3802 ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy); 3803 3804 // struct _ivar_t { 3805 // unsigned long int *offset; // pointer to ivar offset location 3806 // char *name; 3807 // char *type; 3808 // uint32_t alignment; 3809 // uint32_t size; 3810 // } 3811 IvarnfABITy = llvm::StructType::get(llvm::PointerType::getUnqual(LongTy), 3812 Int8PtrTy, 3813 Int8PtrTy, 3814 IntTy, 3815 IntTy, 3816 NULL); 3817 CGM.getModule().addTypeName("struct._ivar_t", IvarnfABITy); 3818 3819 // struct _ivar_list_t { 3820 // uint32 entsize; // sizeof(struct _ivar_t) 3821 // uint32 count; 3822 // struct _iver_t list[count]; 3823 // } 3824 IvarListnfABITy = llvm::StructType::get(IntTy, 3825 IntTy, 3826 llvm::ArrayType::get( 3827 IvarnfABITy, 0), 3828 NULL); 3829 CGM.getModule().addTypeName("struct._ivar_list_t", IvarListnfABITy); 3830 3831 IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy); 3832 3833 // struct _class_ro_t { 3834 // uint32_t const flags; 3835 // uint32_t const instanceStart; 3836 // uint32_t const instanceSize; 3837 // uint32_t const reserved; // only when building for 64bit targets 3838 // const uint8_t * const ivarLayout; 3839 // const char *const name; 3840 // const struct _method_list_t * const baseMethods; 3841 // const struct _objc_protocol_list *const baseProtocols; 3842 // const struct _ivar_list_t *const ivars; 3843 // const uint8_t * const weakIvarLayout; 3844 // const struct _prop_list_t * const properties; 3845 // } 3846 3847 // FIXME. Add 'reserved' field in 64bit abi mode! 3848 ClassRonfABITy = llvm::StructType::get(IntTy, 3849 IntTy, 3850 IntTy, 3851 Int8PtrTy, 3852 Int8PtrTy, 3853 MethodListnfABIPtrTy, 3854 ProtocolListnfABIPtrTy, 3855 IvarListnfABIPtrTy, 3856 Int8PtrTy, 3857 PropertyListPtrTy, 3858 NULL); 3859 CGM.getModule().addTypeName("struct._class_ro_t", 3860 ClassRonfABITy); 3861 3862 // ImpnfABITy - LLVM for id (*)(id, SEL, ...) 3863 std::vector<const llvm::Type*> Params; 3864 Params.push_back(ObjectPtrTy); 3865 Params.push_back(SelectorPtrTy); 3866 ImpnfABITy = llvm::PointerType::getUnqual( 3867 llvm::FunctionType::get(ObjectPtrTy, Params, false)); 3868 3869 // struct _class_t { 3870 // struct _class_t *isa; 3871 // struct _class_t * const superclass; 3872 // void *cache; 3873 // IMP *vtable; 3874 // struct class_ro_t *ro; 3875 // } 3876 3877 llvm::PATypeHolder ClassTyHolder = llvm::OpaqueType::get(); 3878 ClassnfABITy = llvm::StructType::get(llvm::PointerType::getUnqual(ClassTyHolder), 3879 llvm::PointerType::getUnqual(ClassTyHolder), 3880 CachePtrTy, 3881 llvm::PointerType::getUnqual(ImpnfABITy), 3882 llvm::PointerType::getUnqual( 3883 ClassRonfABITy), 3884 NULL); 3885 CGM.getModule().addTypeName("struct._class_t", ClassnfABITy); 3886 3887 cast<llvm::OpaqueType>(ClassTyHolder.get())->refineAbstractTypeTo( 3888 ClassnfABITy); 3889 3890 // LLVM for struct _class_t * 3891 ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy); 3892 3893 // struct _category_t { 3894 // const char * const name; 3895 // struct _class_t *const cls; 3896 // const struct _method_list_t * const instance_methods; 3897 // const struct _method_list_t * const class_methods; 3898 // const struct _protocol_list_t * const protocols; 3899 // const struct _prop_list_t * const properties; 3900 // } 3901 CategorynfABITy = llvm::StructType::get(Int8PtrTy, 3902 ClassnfABIPtrTy, 3903 MethodListnfABIPtrTy, 3904 MethodListnfABIPtrTy, 3905 ProtocolListnfABIPtrTy, 3906 PropertyListPtrTy, 3907 NULL); 3908 CGM.getModule().addTypeName("struct._category_t", CategorynfABITy); 3909 3910 // New types for nonfragile abi messaging. 3911 CodeGen::CodeGenTypes &Types = CGM.getTypes(); 3912 ASTContext &Ctx = CGM.getContext(); 3913 3914 // MessageRefTy - LLVM for: 3915 // struct _message_ref_t { 3916 // IMP messenger; 3917 // SEL name; 3918 // }; 3919 3920 // First the clang type for struct _message_ref_t 3921 RecordDecl *RD = RecordDecl::Create(Ctx, TagDecl::TK_struct, 0, 3922 SourceLocation(), 3923 &Ctx.Idents.get("_message_ref_t")); 3924 RD->addDecl(Ctx, FieldDecl::Create(Ctx, RD, SourceLocation(), 0, 3925 Ctx.VoidPtrTy, 0, false)); 3926 RD->addDecl(Ctx, FieldDecl::Create(Ctx, RD, SourceLocation(), 0, 3927 Ctx.getObjCSelType(), 0, false)); 3928 RD->completeDefinition(Ctx); 3929 3930 MessageRefCTy = Ctx.getTagDeclType(RD); 3931 MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy); 3932 MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy)); 3933 3934 // MessageRefPtrTy - LLVM for struct _message_ref_t* 3935 MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy); 3936 3937 // SuperMessageRefTy - LLVM for: 3938 // struct _super_message_ref_t { 3939 // SUPER_IMP messenger; 3940 // SEL name; 3941 // }; 3942 SuperMessageRefTy = llvm::StructType::get(ImpnfABITy, 3943 SelectorPtrTy, 3944 NULL); 3945 CGM.getModule().addTypeName("struct._super_message_ref_t", SuperMessageRefTy); 3946 3947 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t* 3948 SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy); 3949 3950 3951 // struct objc_typeinfo { 3952 // const void** vtable; // objc_ehtype_vtable + 2 3953 // const char* name; // c++ typeinfo string 3954 // Class cls; 3955 // }; 3956 EHTypeTy = llvm::StructType::get(llvm::PointerType::getUnqual(Int8PtrTy), 3957 Int8PtrTy, 3958 ClassnfABIPtrTy, 3959 NULL); 3960 CGM.getModule().addTypeName("struct._objc_typeinfo", EHTypeTy); 3961 EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy); 3962} 3963 3964llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() { 3965 FinishNonFragileABIModule(); 3966 3967 return NULL; 3968} 3969 3970void CGObjCNonFragileABIMac::FinishNonFragileABIModule() { 3971 // nonfragile abi has no module definition. 3972 3973 // Build list of all implemented classe addresses in array 3974 // L_OBJC_LABEL_CLASS_$. 3975 // FIXME. Also generate in L_OBJC_LABEL_NONLAZY_CLASS_$ 3976 // list of 'nonlazy' implementations (defined as those with a +load{} 3977 // method!!). 3978 unsigned NumClasses = DefinedClasses.size(); 3979 if (NumClasses) { 3980 std::vector<llvm::Constant*> Symbols(NumClasses); 3981 for (unsigned i=0; i<NumClasses; i++) 3982 Symbols[i] = llvm::ConstantExpr::getBitCast(DefinedClasses[i], 3983 ObjCTypes.Int8PtrTy); 3984 llvm::Constant* Init = 3985 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy, 3986 NumClasses), 3987 Symbols); 3988 3989 llvm::GlobalVariable *GV = 3990 new llvm::GlobalVariable(Init->getType(), false, 3991 llvm::GlobalValue::InternalLinkage, 3992 Init, 3993 "\01L_OBJC_LABEL_CLASS_$", 3994 &CGM.getModule()); 3995 GV->setAlignment(8); 3996 GV->setSection("__DATA, __objc_classlist, regular, no_dead_strip"); 3997 UsedGlobals.push_back(GV); 3998 } 3999 4000 // Build list of all implemented category addresses in array 4001 // L_OBJC_LABEL_CATEGORY_$. 4002 // FIXME. Also generate in L_OBJC_LABEL_NONLAZY_CATEGORY_$ 4003 // list of 'nonlazy' category implementations (defined as those with a +load{} 4004 // method!!). 4005 unsigned NumCategory = DefinedCategories.size(); 4006 if (NumCategory) { 4007 std::vector<llvm::Constant*> Symbols(NumCategory); 4008 for (unsigned i=0; i<NumCategory; i++) 4009 Symbols[i] = llvm::ConstantExpr::getBitCast(DefinedCategories[i], 4010 ObjCTypes.Int8PtrTy); 4011 llvm::Constant* Init = 4012 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy, 4013 NumCategory), 4014 Symbols); 4015 4016 llvm::GlobalVariable *GV = 4017 new llvm::GlobalVariable(Init->getType(), false, 4018 llvm::GlobalValue::InternalLinkage, 4019 Init, 4020 "\01L_OBJC_LABEL_CATEGORY_$", 4021 &CGM.getModule()); 4022 GV->setAlignment(8); 4023 GV->setSection("__DATA, __objc_catlist, regular, no_dead_strip"); 4024 UsedGlobals.push_back(GV); 4025 } 4026 4027 // static int L_OBJC_IMAGE_INFO[2] = { 0, flags }; 4028 // FIXME. flags can be 0 | 1 | 2 | 6. For now just use 0 4029 std::vector<llvm::Constant*> Values(2); 4030 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, 0); 4031 unsigned int flags = 0; 4032 // FIXME: Fix and continue? 4033 if (CGM.getLangOptions().getGCMode() != LangOptions::NonGC) 4034 flags |= eImageInfo_GarbageCollected; 4035 if (CGM.getLangOptions().getGCMode() == LangOptions::GCOnly) 4036 flags |= eImageInfo_GCOnly; 4037 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, flags); 4038 llvm::Constant* Init = llvm::ConstantArray::get( 4039 llvm::ArrayType::get(ObjCTypes.IntTy, 2), 4040 Values); 4041 llvm::GlobalVariable *IMGV = 4042 new llvm::GlobalVariable(Init->getType(), false, 4043 llvm::GlobalValue::InternalLinkage, 4044 Init, 4045 "\01L_OBJC_IMAGE_INFO", 4046 &CGM.getModule()); 4047 IMGV->setSection("__DATA, __objc_imageinfo, regular, no_dead_strip"); 4048 IMGV->setConstant(true); 4049 UsedGlobals.push_back(IMGV); 4050 4051 std::vector<llvm::Constant*> Used; 4052 4053 for (std::vector<llvm::GlobalVariable*>::iterator i = UsedGlobals.begin(), 4054 e = UsedGlobals.end(); i != e; ++i) { 4055 Used.push_back(llvm::ConstantExpr::getBitCast(*i, ObjCTypes.Int8PtrTy)); 4056 } 4057 4058 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy, Used.size()); 4059 llvm::GlobalValue *GV = 4060 new llvm::GlobalVariable(AT, false, 4061 llvm::GlobalValue::AppendingLinkage, 4062 llvm::ConstantArray::get(AT, Used), 4063 "llvm.used", 4064 &CGM.getModule()); 4065 4066 GV->setSection("llvm.metadata"); 4067 4068} 4069 4070// Metadata flags 4071enum MetaDataDlags { 4072 CLS = 0x0, 4073 CLS_META = 0x1, 4074 CLS_ROOT = 0x2, 4075 OBJC2_CLS_HIDDEN = 0x10, 4076 CLS_EXCEPTION = 0x20 4077}; 4078/// BuildClassRoTInitializer - generate meta-data for: 4079/// struct _class_ro_t { 4080/// uint32_t const flags; 4081/// uint32_t const instanceStart; 4082/// uint32_t const instanceSize; 4083/// uint32_t const reserved; // only when building for 64bit targets 4084/// const uint8_t * const ivarLayout; 4085/// const char *const name; 4086/// const struct _method_list_t * const baseMethods; 4087/// const struct _protocol_list_t *const baseProtocols; 4088/// const struct _ivar_list_t *const ivars; 4089/// const uint8_t * const weakIvarLayout; 4090/// const struct _prop_list_t * const properties; 4091/// } 4092/// 4093llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer( 4094 unsigned flags, 4095 unsigned InstanceStart, 4096 unsigned InstanceSize, 4097 const ObjCImplementationDecl *ID) { 4098 std::string ClassName = ID->getNameAsString(); 4099 std::vector<llvm::Constant*> Values(10); // 11 for 64bit targets! 4100 Values[ 0] = llvm::ConstantInt::get(ObjCTypes.IntTy, flags); 4101 Values[ 1] = llvm::ConstantInt::get(ObjCTypes.IntTy, InstanceStart); 4102 Values[ 2] = llvm::ConstantInt::get(ObjCTypes.IntTy, InstanceSize); 4103 // FIXME. For 64bit targets add 0 here. 4104 Values[ 3] = (flags & CLS_META) ? GetIvarLayoutName(0, ObjCTypes) 4105 : BuildIvarLayout(ID, true); 4106 Values[ 4] = GetClassName(ID->getIdentifier()); 4107 // const struct _method_list_t * const baseMethods; 4108 std::vector<llvm::Constant*> Methods; 4109 std::string MethodListName("\01l_OBJC_$_"); 4110 if (flags & CLS_META) { 4111 MethodListName += "CLASS_METHODS_" + ID->getNameAsString(); 4112 for (ObjCImplementationDecl::classmeth_iterator 4113 i = ID->classmeth_begin(CGM.getContext()), 4114 e = ID->classmeth_end(CGM.getContext()); i != e; ++i) { 4115 // Class methods should always be defined. 4116 Methods.push_back(GetMethodConstant(*i)); 4117 } 4118 } else { 4119 MethodListName += "INSTANCE_METHODS_" + ID->getNameAsString(); 4120 for (ObjCImplementationDecl::instmeth_iterator 4121 i = ID->instmeth_begin(CGM.getContext()), 4122 e = ID->instmeth_end(CGM.getContext()); i != e; ++i) { 4123 // Instance methods should always be defined. 4124 Methods.push_back(GetMethodConstant(*i)); 4125 } 4126 for (ObjCImplementationDecl::propimpl_iterator 4127 i = ID->propimpl_begin(CGM.getContext()), 4128 e = ID->propimpl_end(CGM.getContext()); i != e; ++i) { 4129 ObjCPropertyImplDecl *PID = *i; 4130 4131 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize){ 4132 ObjCPropertyDecl *PD = PID->getPropertyDecl(); 4133 4134 if (ObjCMethodDecl *MD = PD->getGetterMethodDecl()) 4135 if (llvm::Constant *C = GetMethodConstant(MD)) 4136 Methods.push_back(C); 4137 if (ObjCMethodDecl *MD = PD->getSetterMethodDecl()) 4138 if (llvm::Constant *C = GetMethodConstant(MD)) 4139 Methods.push_back(C); 4140 } 4141 } 4142 } 4143 Values[ 5] = EmitMethodList(MethodListName, 4144 "__DATA, __objc_const", Methods); 4145 4146 const ObjCInterfaceDecl *OID = ID->getClassInterface(); 4147 assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer"); 4148 Values[ 6] = EmitProtocolList("\01l_OBJC_CLASS_PROTOCOLS_$_" 4149 + OID->getNameAsString(), 4150 OID->protocol_begin(), 4151 OID->protocol_end()); 4152 4153 if (flags & CLS_META) 4154 Values[ 7] = llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy); 4155 else 4156 Values[ 7] = EmitIvarList(ID); 4157 Values[ 8] = (flags & CLS_META) ? GetIvarLayoutName(0, ObjCTypes) 4158 : BuildIvarLayout(ID, false); 4159 if (flags & CLS_META) 4160 Values[ 9] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy); 4161 else 4162 Values[ 9] = 4163 EmitPropertyList( 4164 "\01l_OBJC_$_PROP_LIST_" + ID->getNameAsString(), 4165 ID, ID->getClassInterface(), ObjCTypes); 4166 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassRonfABITy, 4167 Values); 4168 llvm::GlobalVariable *CLASS_RO_GV = 4169 new llvm::GlobalVariable(ObjCTypes.ClassRonfABITy, false, 4170 llvm::GlobalValue::InternalLinkage, 4171 Init, 4172 (flags & CLS_META) ? 4173 std::string("\01l_OBJC_METACLASS_RO_$_")+ClassName : 4174 std::string("\01l_OBJC_CLASS_RO_$_")+ClassName, 4175 &CGM.getModule()); 4176 CLASS_RO_GV->setAlignment( 4177 CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.ClassRonfABITy)); 4178 CLASS_RO_GV->setSection("__DATA, __objc_const"); 4179 return CLASS_RO_GV; 4180 4181} 4182 4183/// BuildClassMetaData - This routine defines that to-level meta-data 4184/// for the given ClassName for: 4185/// struct _class_t { 4186/// struct _class_t *isa; 4187/// struct _class_t * const superclass; 4188/// void *cache; 4189/// IMP *vtable; 4190/// struct class_ro_t *ro; 4191/// } 4192/// 4193llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassMetaData( 4194 std::string &ClassName, 4195 llvm::Constant *IsAGV, 4196 llvm::Constant *SuperClassGV, 4197 llvm::Constant *ClassRoGV, 4198 bool HiddenVisibility) { 4199 std::vector<llvm::Constant*> Values(5); 4200 Values[0] = IsAGV; 4201 Values[1] = SuperClassGV 4202 ? SuperClassGV 4203 : llvm::Constant::getNullValue(ObjCTypes.ClassnfABIPtrTy); 4204 Values[2] = ObjCEmptyCacheVar; // &ObjCEmptyCacheVar 4205 Values[3] = ObjCEmptyVtableVar; // &ObjCEmptyVtableVar 4206 Values[4] = ClassRoGV; // &CLASS_RO_GV 4207 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassnfABITy, 4208 Values); 4209 llvm::GlobalVariable *GV = GetClassGlobal(ClassName); 4210 GV->setInitializer(Init); 4211 GV->setSection("__DATA, __objc_data"); 4212 GV->setAlignment( 4213 CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.ClassnfABITy)); 4214 if (HiddenVisibility) 4215 GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 4216 return GV; 4217} 4218 4219void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID, 4220 uint32_t &InstanceStart, 4221 uint32_t &InstanceSize) { 4222 // Find first and last (non-padding) ivars in this interface. 4223 4224 // FIXME: Use iterator. 4225 llvm::SmallVector<ObjCIvarDecl*, 16> OIvars; 4226 GetNamedIvarList(OID->getClassInterface(), OIvars); 4227 4228 if (OIvars.empty()) { 4229 InstanceStart = InstanceSize = 0; 4230 return; 4231 } 4232 4233 const ObjCIvarDecl *First = OIvars.front(); 4234 const ObjCIvarDecl *Last = OIvars.back(); 4235 4236 InstanceStart = ComputeIvarBaseOffset(CGM, OID, First); 4237 const llvm::Type *FieldTy = 4238 CGM.getTypes().ConvertTypeForMem(Last->getType()); 4239 unsigned Size = CGM.getTargetData().getTypePaddedSize(FieldTy); 4240// FIXME. This breaks compatibility with llvm-gcc-4.2 (but makes it compatible 4241// with gcc-4.2). We postpone this for now. 4242#if 0 4243 if (Last->isBitField()) { 4244 Expr *BitWidth = Last->getBitWidth(); 4245 uint64_t BitFieldSize = 4246 BitWidth->EvaluateAsInt(CGM.getContext()).getZExtValue(); 4247 Size = (BitFieldSize / 8) + ((BitFieldSize % 8) != 0); 4248 } 4249#endif 4250 InstanceSize = ComputeIvarBaseOffset(CGM, OID, Last) + Size; 4251} 4252 4253void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) { 4254 std::string ClassName = ID->getNameAsString(); 4255 if (!ObjCEmptyCacheVar) { 4256 ObjCEmptyCacheVar = new llvm::GlobalVariable( 4257 ObjCTypes.CacheTy, 4258 false, 4259 llvm::GlobalValue::ExternalLinkage, 4260 0, 4261 "_objc_empty_cache", 4262 &CGM.getModule()); 4263 4264 ObjCEmptyVtableVar = new llvm::GlobalVariable( 4265 ObjCTypes.ImpnfABITy, 4266 false, 4267 llvm::GlobalValue::ExternalLinkage, 4268 0, 4269 "_objc_empty_vtable", 4270 &CGM.getModule()); 4271 } 4272 assert(ID->getClassInterface() && 4273 "CGObjCNonFragileABIMac::GenerateClass - class is 0"); 4274 // FIXME: Is this correct (that meta class size is never computed)? 4275 uint32_t InstanceStart = 4276 CGM.getTargetData().getTypePaddedSize(ObjCTypes.ClassnfABITy); 4277 uint32_t InstanceSize = InstanceStart; 4278 uint32_t flags = CLS_META; 4279 std::string ObjCMetaClassName(getMetaclassSymbolPrefix()); 4280 std::string ObjCClassName(getClassSymbolPrefix()); 4281 4282 llvm::GlobalVariable *SuperClassGV, *IsAGV; 4283 4284 bool classIsHidden = 4285 CGM.getDeclVisibilityMode(ID->getClassInterface()) == LangOptions::Hidden; 4286 if (classIsHidden) 4287 flags |= OBJC2_CLS_HIDDEN; 4288 if (!ID->getClassInterface()->getSuperClass()) { 4289 // class is root 4290 flags |= CLS_ROOT; 4291 SuperClassGV = GetClassGlobal(ObjCClassName + ClassName); 4292 IsAGV = GetClassGlobal(ObjCMetaClassName + ClassName); 4293 } else { 4294 // Has a root. Current class is not a root. 4295 const ObjCInterfaceDecl *Root = ID->getClassInterface(); 4296 while (const ObjCInterfaceDecl *Super = Root->getSuperClass()) 4297 Root = Super; 4298 IsAGV = GetClassGlobal(ObjCMetaClassName + Root->getNameAsString()); 4299 // work on super class metadata symbol. 4300 std::string SuperClassName = 4301 ObjCMetaClassName + ID->getClassInterface()->getSuperClass()->getNameAsString(); 4302 SuperClassGV = GetClassGlobal(SuperClassName); 4303 } 4304 llvm::GlobalVariable *CLASS_RO_GV = BuildClassRoTInitializer(flags, 4305 InstanceStart, 4306 InstanceSize,ID); 4307 std::string TClassName = ObjCMetaClassName + ClassName; 4308 llvm::GlobalVariable *MetaTClass = 4309 BuildClassMetaData(TClassName, IsAGV, SuperClassGV, CLASS_RO_GV, 4310 classIsHidden); 4311 4312 // Metadata for the class 4313 flags = CLS; 4314 if (classIsHidden) 4315 flags |= OBJC2_CLS_HIDDEN; 4316 4317 if (hasObjCExceptionAttribute(ID->getClassInterface())) 4318 flags |= CLS_EXCEPTION; 4319 4320 if (!ID->getClassInterface()->getSuperClass()) { 4321 flags |= CLS_ROOT; 4322 SuperClassGV = 0; 4323 } else { 4324 // Has a root. Current class is not a root. 4325 std::string RootClassName = 4326 ID->getClassInterface()->getSuperClass()->getNameAsString(); 4327 SuperClassGV = GetClassGlobal(ObjCClassName + RootClassName); 4328 } 4329 GetClassSizeInfo(ID, InstanceStart, InstanceSize); 4330 CLASS_RO_GV = BuildClassRoTInitializer(flags, 4331 InstanceStart, 4332 InstanceSize, 4333 ID); 4334 4335 TClassName = ObjCClassName + ClassName; 4336 llvm::GlobalVariable *ClassMD = 4337 BuildClassMetaData(TClassName, MetaTClass, SuperClassGV, CLASS_RO_GV, 4338 classIsHidden); 4339 DefinedClasses.push_back(ClassMD); 4340 4341 // Force the definition of the EHType if necessary. 4342 if (flags & CLS_EXCEPTION) 4343 GetInterfaceEHType(ID->getClassInterface(), true); 4344} 4345 4346/// GenerateProtocolRef - This routine is called to generate code for 4347/// a protocol reference expression; as in: 4348/// @code 4349/// @protocol(Proto1); 4350/// @endcode 4351/// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1 4352/// which will hold address of the protocol meta-data. 4353/// 4354llvm::Value *CGObjCNonFragileABIMac::GenerateProtocolRef(CGBuilderTy &Builder, 4355 const ObjCProtocolDecl *PD) { 4356 4357 // This routine is called for @protocol only. So, we must build definition 4358 // of protocol's meta-data (not a reference to it!) 4359 // 4360 llvm::Constant *Init = llvm::ConstantExpr::getBitCast(GetOrEmitProtocol(PD), 4361 ObjCTypes.ExternalProtocolPtrTy); 4362 4363 std::string ProtocolName("\01l_OBJC_PROTOCOL_REFERENCE_$_"); 4364 ProtocolName += PD->getNameAsCString(); 4365 4366 llvm::GlobalVariable *PTGV = CGM.getModule().getGlobalVariable(ProtocolName); 4367 if (PTGV) 4368 return Builder.CreateLoad(PTGV, false, "tmp"); 4369 PTGV = new llvm::GlobalVariable( 4370 Init->getType(), false, 4371 llvm::GlobalValue::WeakAnyLinkage, 4372 Init, 4373 ProtocolName, 4374 &CGM.getModule()); 4375 PTGV->setSection("__DATA, __objc_protorefs, coalesced, no_dead_strip"); 4376 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility); 4377 UsedGlobals.push_back(PTGV); 4378 return Builder.CreateLoad(PTGV, false, "tmp"); 4379} 4380 4381/// GenerateCategory - Build metadata for a category implementation. 4382/// struct _category_t { 4383/// const char * const name; 4384/// struct _class_t *const cls; 4385/// const struct _method_list_t * const instance_methods; 4386/// const struct _method_list_t * const class_methods; 4387/// const struct _protocol_list_t * const protocols; 4388/// const struct _prop_list_t * const properties; 4389/// } 4390/// 4391void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) 4392{ 4393 const ObjCInterfaceDecl *Interface = OCD->getClassInterface(); 4394 const char *Prefix = "\01l_OBJC_$_CATEGORY_"; 4395 std::string ExtCatName(Prefix + Interface->getNameAsString()+ 4396 "_$_" + OCD->getNameAsString()); 4397 std::string ExtClassName(getClassSymbolPrefix() + 4398 Interface->getNameAsString()); 4399 4400 std::vector<llvm::Constant*> Values(6); 4401 Values[0] = GetClassName(OCD->getIdentifier()); 4402 // meta-class entry symbol 4403 llvm::GlobalVariable *ClassGV = GetClassGlobal(ExtClassName); 4404 Values[1] = ClassGV; 4405 std::vector<llvm::Constant*> Methods; 4406 std::string MethodListName(Prefix); 4407 MethodListName += "INSTANCE_METHODS_" + Interface->getNameAsString() + 4408 "_$_" + OCD->getNameAsString(); 4409 4410 for (ObjCCategoryImplDecl::instmeth_iterator 4411 i = OCD->instmeth_begin(CGM.getContext()), 4412 e = OCD->instmeth_end(CGM.getContext()); i != e; ++i) { 4413 // Instance methods should always be defined. 4414 Methods.push_back(GetMethodConstant(*i)); 4415 } 4416 4417 Values[2] = EmitMethodList(MethodListName, 4418 "__DATA, __objc_const", 4419 Methods); 4420 4421 MethodListName = Prefix; 4422 MethodListName += "CLASS_METHODS_" + Interface->getNameAsString() + "_$_" + 4423 OCD->getNameAsString(); 4424 Methods.clear(); 4425 for (ObjCCategoryImplDecl::classmeth_iterator 4426 i = OCD->classmeth_begin(CGM.getContext()), 4427 e = OCD->classmeth_end(CGM.getContext()); i != e; ++i) { 4428 // Class methods should always be defined. 4429 Methods.push_back(GetMethodConstant(*i)); 4430 } 4431 4432 Values[3] = EmitMethodList(MethodListName, 4433 "__DATA, __objc_const", 4434 Methods); 4435 const ObjCCategoryDecl *Category = 4436 Interface->FindCategoryDeclaration(OCD->getIdentifier()); 4437 if (Category) { 4438 std::string ExtName(Interface->getNameAsString() + "_$_" + 4439 OCD->getNameAsString()); 4440 Values[4] = EmitProtocolList("\01l_OBJC_CATEGORY_PROTOCOLS_$_" 4441 + Interface->getNameAsString() + "_$_" 4442 + Category->getNameAsString(), 4443 Category->protocol_begin(), 4444 Category->protocol_end()); 4445 Values[5] = 4446 EmitPropertyList(std::string("\01l_OBJC_$_PROP_LIST_") + ExtName, 4447 OCD, Category, ObjCTypes); 4448 } 4449 else { 4450 Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy); 4451 Values[5] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy); 4452 } 4453 4454 llvm::Constant *Init = 4455 llvm::ConstantStruct::get(ObjCTypes.CategorynfABITy, 4456 Values); 4457 llvm::GlobalVariable *GCATV 4458 = new llvm::GlobalVariable(ObjCTypes.CategorynfABITy, 4459 false, 4460 llvm::GlobalValue::InternalLinkage, 4461 Init, 4462 ExtCatName, 4463 &CGM.getModule()); 4464 GCATV->setAlignment( 4465 CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.CategorynfABITy)); 4466 GCATV->setSection("__DATA, __objc_const"); 4467 UsedGlobals.push_back(GCATV); 4468 DefinedCategories.push_back(GCATV); 4469} 4470 4471/// GetMethodConstant - Return a struct objc_method constant for the 4472/// given method if it has been defined. The result is null if the 4473/// method has not been defined. The return value has type MethodPtrTy. 4474llvm::Constant *CGObjCNonFragileABIMac::GetMethodConstant( 4475 const ObjCMethodDecl *MD) { 4476 // FIXME: Use DenseMap::lookup 4477 llvm::Function *Fn = MethodDefinitions[MD]; 4478 if (!Fn) 4479 return 0; 4480 4481 std::vector<llvm::Constant*> Method(3); 4482 Method[0] = 4483 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()), 4484 ObjCTypes.SelectorPtrTy); 4485 Method[1] = GetMethodVarType(MD); 4486 Method[2] = llvm::ConstantExpr::getBitCast(Fn, ObjCTypes.Int8PtrTy); 4487 return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Method); 4488} 4489 4490/// EmitMethodList - Build meta-data for method declarations 4491/// struct _method_list_t { 4492/// uint32_t entsize; // sizeof(struct _objc_method) 4493/// uint32_t method_count; 4494/// struct _objc_method method_list[method_count]; 4495/// } 4496/// 4497llvm::Constant *CGObjCNonFragileABIMac::EmitMethodList( 4498 const std::string &Name, 4499 const char *Section, 4500 const ConstantVector &Methods) { 4501 // Return null for empty list. 4502 if (Methods.empty()) 4503 return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy); 4504 4505 std::vector<llvm::Constant*> Values(3); 4506 // sizeof(struct _objc_method) 4507 unsigned Size = CGM.getTargetData().getTypePaddedSize(ObjCTypes.MethodTy); 4508 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size); 4509 // method_count 4510 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size()); 4511 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodTy, 4512 Methods.size()); 4513 Values[2] = llvm::ConstantArray::get(AT, Methods); 4514 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 4515 4516 llvm::GlobalVariable *GV = 4517 new llvm::GlobalVariable(Init->getType(), false, 4518 llvm::GlobalValue::InternalLinkage, 4519 Init, 4520 Name, 4521 &CGM.getModule()); 4522 GV->setAlignment( 4523 CGM.getTargetData().getPrefTypeAlignment(Init->getType())); 4524 GV->setSection(Section); 4525 UsedGlobals.push_back(GV); 4526 return llvm::ConstantExpr::getBitCast(GV, 4527 ObjCTypes.MethodListnfABIPtrTy); 4528} 4529 4530/// ObjCIvarOffsetVariable - Returns the ivar offset variable for 4531/// the given ivar. 4532/// 4533llvm::GlobalVariable * CGObjCNonFragileABIMac::ObjCIvarOffsetVariable( 4534 const ObjCInterfaceDecl *ID, 4535 const ObjCIvarDecl *Ivar) { 4536 std::string Name = "OBJC_IVAR_$_" + 4537 getInterfaceDeclForIvar(ID, Ivar, CGM.getContext())->getNameAsString() + 4538 '.' + Ivar->getNameAsString(); 4539 llvm::GlobalVariable *IvarOffsetGV = 4540 CGM.getModule().getGlobalVariable(Name); 4541 if (!IvarOffsetGV) 4542 IvarOffsetGV = 4543 new llvm::GlobalVariable(ObjCTypes.LongTy, 4544 false, 4545 llvm::GlobalValue::ExternalLinkage, 4546 0, 4547 Name, 4548 &CGM.getModule()); 4549 return IvarOffsetGV; 4550} 4551 4552llvm::Constant * CGObjCNonFragileABIMac::EmitIvarOffsetVar( 4553 const ObjCInterfaceDecl *ID, 4554 const ObjCIvarDecl *Ivar, 4555 unsigned long int Offset) { 4556 llvm::GlobalVariable *IvarOffsetGV = ObjCIvarOffsetVariable(ID, Ivar); 4557 IvarOffsetGV->setInitializer(llvm::ConstantInt::get(ObjCTypes.LongTy, 4558 Offset)); 4559 IvarOffsetGV->setAlignment( 4560 CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.LongTy)); 4561 4562 // FIXME: This matches gcc, but shouldn't the visibility be set on 4563 // the use as well (i.e., in ObjCIvarOffsetVariable). 4564 if (Ivar->getAccessControl() == ObjCIvarDecl::Private || 4565 Ivar->getAccessControl() == ObjCIvarDecl::Package || 4566 CGM.getDeclVisibilityMode(ID) == LangOptions::Hidden) 4567 IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility); 4568 else 4569 IvarOffsetGV->setVisibility(llvm::GlobalValue::DefaultVisibility); 4570 IvarOffsetGV->setSection("__DATA, __objc_const"); 4571 return IvarOffsetGV; 4572} 4573 4574/// EmitIvarList - Emit the ivar list for the given 4575/// implementation. The return value has type 4576/// IvarListnfABIPtrTy. 4577/// struct _ivar_t { 4578/// unsigned long int *offset; // pointer to ivar offset location 4579/// char *name; 4580/// char *type; 4581/// uint32_t alignment; 4582/// uint32_t size; 4583/// } 4584/// struct _ivar_list_t { 4585/// uint32 entsize; // sizeof(struct _ivar_t) 4586/// uint32 count; 4587/// struct _iver_t list[count]; 4588/// } 4589/// 4590 4591void CGObjCCommonMac::GetNamedIvarList(const ObjCInterfaceDecl *OID, 4592 llvm::SmallVector<ObjCIvarDecl*, 16> &Res) const { 4593 for (ObjCInterfaceDecl::ivar_iterator I = OID->ivar_begin(), 4594 E = OID->ivar_end(); I != E; ++I) { 4595 // Ignore unnamed bit-fields. 4596 if (!(*I)->getDeclName()) 4597 continue; 4598 4599 Res.push_back(*I); 4600 } 4601 4602 for (ObjCInterfaceDecl::prop_iterator I = OID->prop_begin(CGM.getContext()), 4603 E = OID->prop_end(CGM.getContext()); I != E; ++I) 4604 if (ObjCIvarDecl *IV = (*I)->getPropertyIvarDecl()) 4605 Res.push_back(IV); 4606} 4607 4608llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList( 4609 const ObjCImplementationDecl *ID) { 4610 4611 std::vector<llvm::Constant*> Ivars, Ivar(5); 4612 4613 const ObjCInterfaceDecl *OID = ID->getClassInterface(); 4614 assert(OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface"); 4615 4616 // FIXME. Consolidate this with similar code in GenerateClass. 4617 4618 // Collect declared and synthesized ivars in a small vector. 4619 llvm::SmallVector<ObjCIvarDecl*, 16> OIvars; 4620 GetNamedIvarList(OID, OIvars); 4621 4622 for (unsigned i = 0, e = OIvars.size(); i != e; ++i) { 4623 ObjCIvarDecl *IVD = OIvars[i]; 4624 Ivar[0] = EmitIvarOffsetVar(ID->getClassInterface(), IVD, 4625 ComputeIvarBaseOffset(CGM, ID, IVD)); 4626 Ivar[1] = GetMethodVarName(IVD->getIdentifier()); 4627 Ivar[2] = GetMethodVarType(IVD); 4628 const llvm::Type *FieldTy = 4629 CGM.getTypes().ConvertTypeForMem(IVD->getType()); 4630 unsigned Size = CGM.getTargetData().getTypePaddedSize(FieldTy); 4631 unsigned Align = CGM.getContext().getPreferredTypeAlign( 4632 IVD->getType().getTypePtr()) >> 3; 4633 Align = llvm::Log2_32(Align); 4634 Ivar[3] = llvm::ConstantInt::get(ObjCTypes.IntTy, Align); 4635 // NOTE. Size of a bitfield does not match gcc's, because of the 4636 // way bitfields are treated special in each. But I am told that 4637 // 'size' for bitfield ivars is ignored by the runtime so it does 4638 // not matter. If it matters, there is enough info to get the 4639 // bitfield right! 4640 Ivar[4] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size); 4641 Ivars.push_back(llvm::ConstantStruct::get(ObjCTypes.IvarnfABITy, Ivar)); 4642 } 4643 // Return null for empty list. 4644 if (Ivars.empty()) 4645 return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy); 4646 std::vector<llvm::Constant*> Values(3); 4647 unsigned Size = CGM.getTargetData().getTypePaddedSize(ObjCTypes.IvarnfABITy); 4648 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size); 4649 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Ivars.size()); 4650 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.IvarnfABITy, 4651 Ivars.size()); 4652 Values[2] = llvm::ConstantArray::get(AT, Ivars); 4653 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 4654 const char *Prefix = "\01l_OBJC_$_INSTANCE_VARIABLES_"; 4655 llvm::GlobalVariable *GV = 4656 new llvm::GlobalVariable(Init->getType(), false, 4657 llvm::GlobalValue::InternalLinkage, 4658 Init, 4659 Prefix + OID->getNameAsString(), 4660 &CGM.getModule()); 4661 GV->setAlignment( 4662 CGM.getTargetData().getPrefTypeAlignment(Init->getType())); 4663 GV->setSection("__DATA, __objc_const"); 4664 4665 UsedGlobals.push_back(GV); 4666 return llvm::ConstantExpr::getBitCast(GV, 4667 ObjCTypes.IvarListnfABIPtrTy); 4668} 4669 4670llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocolRef( 4671 const ObjCProtocolDecl *PD) { 4672 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()]; 4673 4674 if (!Entry) { 4675 // We use the initializer as a marker of whether this is a forward 4676 // reference or not. At module finalization we add the empty 4677 // contents for protocols which were referenced but never defined. 4678 Entry = 4679 new llvm::GlobalVariable(ObjCTypes.ProtocolnfABITy, false, 4680 llvm::GlobalValue::ExternalLinkage, 4681 0, 4682 "\01l_OBJC_PROTOCOL_$_" + PD->getNameAsString(), 4683 &CGM.getModule()); 4684 Entry->setSection("__DATA,__datacoal_nt,coalesced"); 4685 UsedGlobals.push_back(Entry); 4686 } 4687 4688 return Entry; 4689} 4690 4691/// GetOrEmitProtocol - Generate the protocol meta-data: 4692/// @code 4693/// struct _protocol_t { 4694/// id isa; // NULL 4695/// const char * const protocol_name; 4696/// const struct _protocol_list_t * protocol_list; // super protocols 4697/// const struct method_list_t * const instance_methods; 4698/// const struct method_list_t * const class_methods; 4699/// const struct method_list_t *optionalInstanceMethods; 4700/// const struct method_list_t *optionalClassMethods; 4701/// const struct _prop_list_t * properties; 4702/// const uint32_t size; // sizeof(struct _protocol_t) 4703/// const uint32_t flags; // = 0 4704/// } 4705/// @endcode 4706/// 4707 4708llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol( 4709 const ObjCProtocolDecl *PD) { 4710 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()]; 4711 4712 // Early exit if a defining object has already been generated. 4713 if (Entry && Entry->hasInitializer()) 4714 return Entry; 4715 4716 const char *ProtocolName = PD->getNameAsCString(); 4717 4718 // Construct method lists. 4719 std::vector<llvm::Constant*> InstanceMethods, ClassMethods; 4720 std::vector<llvm::Constant*> OptInstanceMethods, OptClassMethods; 4721 for (ObjCProtocolDecl::instmeth_iterator 4722 i = PD->instmeth_begin(CGM.getContext()), 4723 e = PD->instmeth_end(CGM.getContext()); 4724 i != e; ++i) { 4725 ObjCMethodDecl *MD = *i; 4726 llvm::Constant *C = GetMethodDescriptionConstant(MD); 4727 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) { 4728 OptInstanceMethods.push_back(C); 4729 } else { 4730 InstanceMethods.push_back(C); 4731 } 4732 } 4733 4734 for (ObjCProtocolDecl::classmeth_iterator 4735 i = PD->classmeth_begin(CGM.getContext()), 4736 e = PD->classmeth_end(CGM.getContext()); 4737 i != e; ++i) { 4738 ObjCMethodDecl *MD = *i; 4739 llvm::Constant *C = GetMethodDescriptionConstant(MD); 4740 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) { 4741 OptClassMethods.push_back(C); 4742 } else { 4743 ClassMethods.push_back(C); 4744 } 4745 } 4746 4747 std::vector<llvm::Constant*> Values(10); 4748 // isa is NULL 4749 Values[0] = llvm::Constant::getNullValue(ObjCTypes.ObjectPtrTy); 4750 Values[1] = GetClassName(PD->getIdentifier()); 4751 Values[2] = EmitProtocolList( 4752 "\01l_OBJC_$_PROTOCOL_REFS_" + PD->getNameAsString(), 4753 PD->protocol_begin(), 4754 PD->protocol_end()); 4755 4756 Values[3] = EmitMethodList("\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_" 4757 + PD->getNameAsString(), 4758 "__DATA, __objc_const", 4759 InstanceMethods); 4760 Values[4] = EmitMethodList("\01l_OBJC_$_PROTOCOL_CLASS_METHODS_" 4761 + PD->getNameAsString(), 4762 "__DATA, __objc_const", 4763 ClassMethods); 4764 Values[5] = EmitMethodList("\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_" 4765 + PD->getNameAsString(), 4766 "__DATA, __objc_const", 4767 OptInstanceMethods); 4768 Values[6] = EmitMethodList("\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_" 4769 + PD->getNameAsString(), 4770 "__DATA, __objc_const", 4771 OptClassMethods); 4772 Values[7] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + PD->getNameAsString(), 4773 0, PD, ObjCTypes); 4774 uint32_t Size = 4775 CGM.getTargetData().getTypePaddedSize(ObjCTypes.ProtocolnfABITy); 4776 Values[8] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size); 4777 Values[9] = llvm::Constant::getNullValue(ObjCTypes.IntTy); 4778 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ProtocolnfABITy, 4779 Values); 4780 4781 if (Entry) { 4782 // Already created, fix the linkage and update the initializer. 4783 Entry->setLinkage(llvm::GlobalValue::WeakAnyLinkage); 4784 Entry->setInitializer(Init); 4785 } else { 4786 Entry = 4787 new llvm::GlobalVariable(ObjCTypes.ProtocolnfABITy, false, 4788 llvm::GlobalValue::WeakAnyLinkage, 4789 Init, 4790 std::string("\01l_OBJC_PROTOCOL_$_")+ProtocolName, 4791 &CGM.getModule()); 4792 Entry->setAlignment( 4793 CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.ProtocolnfABITy)); 4794 Entry->setSection("__DATA,__datacoal_nt,coalesced"); 4795 } 4796 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility); 4797 4798 // Use this protocol meta-data to build protocol list table in section 4799 // __DATA, __objc_protolist 4800 llvm::GlobalVariable *PTGV = new llvm::GlobalVariable( 4801 ObjCTypes.ProtocolnfABIPtrTy, false, 4802 llvm::GlobalValue::WeakAnyLinkage, 4803 Entry, 4804 std::string("\01l_OBJC_LABEL_PROTOCOL_$_") 4805 +ProtocolName, 4806 &CGM.getModule()); 4807 PTGV->setAlignment( 4808 CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.ProtocolnfABIPtrTy)); 4809 PTGV->setSection("__DATA, __objc_protolist, coalesced, no_dead_strip"); 4810 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility); 4811 UsedGlobals.push_back(PTGV); 4812 return Entry; 4813} 4814 4815/// EmitProtocolList - Generate protocol list meta-data: 4816/// @code 4817/// struct _protocol_list_t { 4818/// long protocol_count; // Note, this is 32/64 bit 4819/// struct _protocol_t[protocol_count]; 4820/// } 4821/// @endcode 4822/// 4823llvm::Constant * 4824CGObjCNonFragileABIMac::EmitProtocolList(const std::string &Name, 4825 ObjCProtocolDecl::protocol_iterator begin, 4826 ObjCProtocolDecl::protocol_iterator end) { 4827 std::vector<llvm::Constant*> ProtocolRefs; 4828 4829 // Just return null for empty protocol lists 4830 if (begin == end) 4831 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy); 4832 4833 // FIXME: We shouldn't need to do this lookup here, should we? 4834 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true); 4835 if (GV) 4836 return llvm::ConstantExpr::getBitCast(GV, 4837 ObjCTypes.ProtocolListnfABIPtrTy); 4838 4839 for (; begin != end; ++begin) 4840 ProtocolRefs.push_back(GetProtocolRef(*begin)); // Implemented??? 4841 4842 // This list is null terminated. 4843 ProtocolRefs.push_back(llvm::Constant::getNullValue( 4844 ObjCTypes.ProtocolnfABIPtrTy)); 4845 4846 std::vector<llvm::Constant*> Values(2); 4847 Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, ProtocolRefs.size() - 1); 4848 Values[1] = 4849 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.ProtocolnfABIPtrTy, 4850 ProtocolRefs.size()), 4851 ProtocolRefs); 4852 4853 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 4854 GV = new llvm::GlobalVariable(Init->getType(), false, 4855 llvm::GlobalValue::InternalLinkage, 4856 Init, 4857 Name, 4858 &CGM.getModule()); 4859 GV->setSection("__DATA, __objc_const"); 4860 GV->setAlignment( 4861 CGM.getTargetData().getPrefTypeAlignment(Init->getType())); 4862 UsedGlobals.push_back(GV); 4863 return llvm::ConstantExpr::getBitCast(GV, 4864 ObjCTypes.ProtocolListnfABIPtrTy); 4865} 4866 4867/// GetMethodDescriptionConstant - This routine build following meta-data: 4868/// struct _objc_method { 4869/// SEL _cmd; 4870/// char *method_type; 4871/// char *_imp; 4872/// } 4873 4874llvm::Constant * 4875CGObjCNonFragileABIMac::GetMethodDescriptionConstant(const ObjCMethodDecl *MD) { 4876 std::vector<llvm::Constant*> Desc(3); 4877 Desc[0] = llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()), 4878 ObjCTypes.SelectorPtrTy); 4879 Desc[1] = GetMethodVarType(MD); 4880 // Protocol methods have no implementation. So, this entry is always NULL. 4881 Desc[2] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy); 4882 return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Desc); 4883} 4884 4885/// EmitObjCValueForIvar - Code Gen for nonfragile ivar reference. 4886/// This code gen. amounts to generating code for: 4887/// @code 4888/// (type *)((char *)base + _OBJC_IVAR_$_.ivar; 4889/// @encode 4890/// 4891LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar( 4892 CodeGen::CodeGenFunction &CGF, 4893 QualType ObjectTy, 4894 llvm::Value *BaseValue, 4895 const ObjCIvarDecl *Ivar, 4896 unsigned CVRQualifiers) { 4897 const ObjCInterfaceDecl *ID = ObjectTy->getAsObjCInterfaceType()->getDecl(); 4898 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers, 4899 EmitIvarOffset(CGF, ID, Ivar)); 4900} 4901 4902llvm::Value *CGObjCNonFragileABIMac::EmitIvarOffset( 4903 CodeGen::CodeGenFunction &CGF, 4904 const ObjCInterfaceDecl *Interface, 4905 const ObjCIvarDecl *Ivar) { 4906 return CGF.Builder.CreateLoad(ObjCIvarOffsetVariable(Interface, Ivar), 4907 false, "ivar"); 4908} 4909 4910CodeGen::RValue CGObjCNonFragileABIMac::EmitMessageSend( 4911 CodeGen::CodeGenFunction &CGF, 4912 QualType ResultType, 4913 Selector Sel, 4914 llvm::Value *Receiver, 4915 QualType Arg0Ty, 4916 bool IsSuper, 4917 const CallArgList &CallArgs) { 4918 // FIXME. Even though IsSuper is passes. This function doese not 4919 // handle calls to 'super' receivers. 4920 CodeGenTypes &Types = CGM.getTypes(); 4921 llvm::Value *Arg0 = Receiver; 4922 if (!IsSuper) 4923 Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy, "tmp"); 4924 4925 // Find the message function name. 4926 // FIXME. This is too much work to get the ABI-specific result type 4927 // needed to find the message name. 4928 const CGFunctionInfo &FnInfo = Types.getFunctionInfo(ResultType, 4929 llvm::SmallVector<QualType, 16>()); 4930 llvm::Constant *Fn = 0; 4931 std::string Name("\01l_"); 4932 if (CGM.ReturnTypeUsesSret(FnInfo)) { 4933#if 0 4934 // unlike what is documented. gcc never generates this API!! 4935 if (Receiver->getType() == ObjCTypes.ObjectPtrTy) { 4936 Fn = ObjCTypes.getMessageSendIdStretFixupFn(); 4937 // FIXME. Is there a better way of getting these names. 4938 // They are available in RuntimeFunctions vector pair. 4939 Name += "objc_msgSendId_stret_fixup"; 4940 } 4941 else 4942#endif 4943 if (IsSuper) { 4944 Fn = ObjCTypes.getMessageSendSuper2StretFixupFn(); 4945 Name += "objc_msgSendSuper2_stret_fixup"; 4946 } 4947 else 4948 { 4949 Fn = ObjCTypes.getMessageSendStretFixupFn(); 4950 Name += "objc_msgSend_stret_fixup"; 4951 } 4952 } 4953 else if (!IsSuper && ResultType->isFloatingType()) { 4954 if (const BuiltinType *BT = ResultType->getAsBuiltinType()) { 4955 BuiltinType::Kind k = BT->getKind(); 4956 if (k == BuiltinType::LongDouble) { 4957 Fn = ObjCTypes.getMessageSendFpretFixupFn(); 4958 Name += "objc_msgSend_fpret_fixup"; 4959 } 4960 else { 4961 Fn = ObjCTypes.getMessageSendFixupFn(); 4962 Name += "objc_msgSend_fixup"; 4963 } 4964 } 4965 } 4966 else { 4967#if 0 4968// unlike what is documented. gcc never generates this API!! 4969 if (Receiver->getType() == ObjCTypes.ObjectPtrTy) { 4970 Fn = ObjCTypes.getMessageSendIdFixupFn(); 4971 Name += "objc_msgSendId_fixup"; 4972 } 4973 else 4974#endif 4975 if (IsSuper) { 4976 Fn = ObjCTypes.getMessageSendSuper2FixupFn(); 4977 Name += "objc_msgSendSuper2_fixup"; 4978 } 4979 else 4980 { 4981 Fn = ObjCTypes.getMessageSendFixupFn(); 4982 Name += "objc_msgSend_fixup"; 4983 } 4984 } 4985 assert(Fn && "CGObjCNonFragileABIMac::EmitMessageSend"); 4986 Name += '_'; 4987 std::string SelName(Sel.getAsString()); 4988 // Replace all ':' in selector name with '_' ouch! 4989 for(unsigned i = 0; i < SelName.size(); i++) 4990 if (SelName[i] == ':') 4991 SelName[i] = '_'; 4992 Name += SelName; 4993 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name); 4994 if (!GV) { 4995 // Build message ref table entry. 4996 std::vector<llvm::Constant*> Values(2); 4997 Values[0] = Fn; 4998 Values[1] = GetMethodVarName(Sel); 4999 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 5000 GV = new llvm::GlobalVariable(Init->getType(), false, 5001 llvm::GlobalValue::WeakAnyLinkage, 5002 Init, 5003 Name, 5004 &CGM.getModule()); 5005 GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 5006 GV->setAlignment(16); 5007 GV->setSection("__DATA, __objc_msgrefs, coalesced"); 5008 } 5009 llvm::Value *Arg1 = CGF.Builder.CreateBitCast(GV, ObjCTypes.MessageRefPtrTy); 5010 5011 CallArgList ActualArgs; 5012 ActualArgs.push_back(std::make_pair(RValue::get(Arg0), Arg0Ty)); 5013 ActualArgs.push_back(std::make_pair(RValue::get(Arg1), 5014 ObjCTypes.MessageRefCPtrTy)); 5015 ActualArgs.insert(ActualArgs.end(), CallArgs.begin(), CallArgs.end()); 5016 const CGFunctionInfo &FnInfo1 = Types.getFunctionInfo(ResultType, ActualArgs); 5017 llvm::Value *Callee = CGF.Builder.CreateStructGEP(Arg1, 0); 5018 Callee = CGF.Builder.CreateLoad(Callee); 5019 const llvm::FunctionType *FTy = Types.GetFunctionType(FnInfo1, true); 5020 Callee = CGF.Builder.CreateBitCast(Callee, 5021 llvm::PointerType::getUnqual(FTy)); 5022 return CGF.EmitCall(FnInfo1, Callee, ActualArgs); 5023} 5024 5025/// Generate code for a message send expression in the nonfragile abi. 5026CodeGen::RValue CGObjCNonFragileABIMac::GenerateMessageSend( 5027 CodeGen::CodeGenFunction &CGF, 5028 QualType ResultType, 5029 Selector Sel, 5030 llvm::Value *Receiver, 5031 bool IsClassMessage, 5032 const CallArgList &CallArgs) { 5033 return EmitMessageSend(CGF, ResultType, Sel, 5034 Receiver, CGF.getContext().getObjCIdType(), 5035 false, CallArgs); 5036} 5037 5038llvm::GlobalVariable * 5039CGObjCNonFragileABIMac::GetClassGlobal(const std::string &Name) { 5040 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name); 5041 5042 if (!GV) { 5043 GV = new llvm::GlobalVariable(ObjCTypes.ClassnfABITy, false, 5044 llvm::GlobalValue::ExternalLinkage, 5045 0, Name, &CGM.getModule()); 5046 } 5047 5048 return GV; 5049} 5050 5051llvm::Value *CGObjCNonFragileABIMac::EmitClassRef(CGBuilderTy &Builder, 5052 const ObjCInterfaceDecl *ID) { 5053 llvm::GlobalVariable *&Entry = ClassReferences[ID->getIdentifier()]; 5054 5055 if (!Entry) { 5056 std::string ClassName(getClassSymbolPrefix() + ID->getNameAsString()); 5057 llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName); 5058 Entry = 5059 new llvm::GlobalVariable(ObjCTypes.ClassnfABIPtrTy, false, 5060 llvm::GlobalValue::InternalLinkage, 5061 ClassGV, 5062 "\01L_OBJC_CLASSLIST_REFERENCES_$_", 5063 &CGM.getModule()); 5064 Entry->setAlignment( 5065 CGM.getTargetData().getPrefTypeAlignment( 5066 ObjCTypes.ClassnfABIPtrTy)); 5067 Entry->setSection("__DATA, __objc_classrefs, regular, no_dead_strip"); 5068 UsedGlobals.push_back(Entry); 5069 } 5070 5071 return Builder.CreateLoad(Entry, false, "tmp"); 5072} 5073 5074llvm::Value * 5075CGObjCNonFragileABIMac::EmitSuperClassRef(CGBuilderTy &Builder, 5076 const ObjCInterfaceDecl *ID) { 5077 llvm::GlobalVariable *&Entry = SuperClassReferences[ID->getIdentifier()]; 5078 5079 if (!Entry) { 5080 std::string ClassName(getClassSymbolPrefix() + ID->getNameAsString()); 5081 llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName); 5082 Entry = 5083 new llvm::GlobalVariable(ObjCTypes.ClassnfABIPtrTy, false, 5084 llvm::GlobalValue::InternalLinkage, 5085 ClassGV, 5086 "\01L_OBJC_CLASSLIST_SUP_REFS_$_", 5087 &CGM.getModule()); 5088 Entry->setAlignment( 5089 CGM.getTargetData().getPrefTypeAlignment( 5090 ObjCTypes.ClassnfABIPtrTy)); 5091 Entry->setSection("__DATA, __objc_superrefs, regular, no_dead_strip"); 5092 UsedGlobals.push_back(Entry); 5093 } 5094 5095 return Builder.CreateLoad(Entry, false, "tmp"); 5096} 5097 5098/// EmitMetaClassRef - Return a Value * of the address of _class_t 5099/// meta-data 5100/// 5101llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef(CGBuilderTy &Builder, 5102 const ObjCInterfaceDecl *ID) { 5103 llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()]; 5104 if (Entry) 5105 return Builder.CreateLoad(Entry, false, "tmp"); 5106 5107 std::string MetaClassName(getMetaclassSymbolPrefix() + ID->getNameAsString()); 5108 llvm::GlobalVariable *MetaClassGV = GetClassGlobal(MetaClassName); 5109 Entry = 5110 new llvm::GlobalVariable(ObjCTypes.ClassnfABIPtrTy, false, 5111 llvm::GlobalValue::InternalLinkage, 5112 MetaClassGV, 5113 "\01L_OBJC_CLASSLIST_SUP_REFS_$_", 5114 &CGM.getModule()); 5115 Entry->setAlignment( 5116 CGM.getTargetData().getPrefTypeAlignment( 5117 ObjCTypes.ClassnfABIPtrTy)); 5118 5119 Entry->setSection("__DATA, __objc_superrefs, regular, no_dead_strip"); 5120 UsedGlobals.push_back(Entry); 5121 5122 return Builder.CreateLoad(Entry, false, "tmp"); 5123} 5124 5125/// GetClass - Return a reference to the class for the given interface 5126/// decl. 5127llvm::Value *CGObjCNonFragileABIMac::GetClass(CGBuilderTy &Builder, 5128 const ObjCInterfaceDecl *ID) { 5129 return EmitClassRef(Builder, ID); 5130} 5131 5132/// Generates a message send where the super is the receiver. This is 5133/// a message send to self with special delivery semantics indicating 5134/// which class's method should be called. 5135CodeGen::RValue 5136CGObjCNonFragileABIMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, 5137 QualType ResultType, 5138 Selector Sel, 5139 const ObjCInterfaceDecl *Class, 5140 bool isCategoryImpl, 5141 llvm::Value *Receiver, 5142 bool IsClassMessage, 5143 const CodeGen::CallArgList &CallArgs) { 5144 // ... 5145 // Create and init a super structure; this is a (receiver, class) 5146 // pair we will pass to objc_msgSendSuper. 5147 llvm::Value *ObjCSuper = 5148 CGF.Builder.CreateAlloca(ObjCTypes.SuperTy, 0, "objc_super"); 5149 5150 llvm::Value *ReceiverAsObject = 5151 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy); 5152 CGF.Builder.CreateStore(ReceiverAsObject, 5153 CGF.Builder.CreateStructGEP(ObjCSuper, 0)); 5154 5155 // If this is a class message the metaclass is passed as the target. 5156 llvm::Value *Target; 5157 if (IsClassMessage) { 5158 if (isCategoryImpl) { 5159 // Message sent to "super' in a class method defined in 5160 // a category implementation. 5161 Target = EmitClassRef(CGF.Builder, Class); 5162 Target = CGF.Builder.CreateStructGEP(Target, 0); 5163 Target = CGF.Builder.CreateLoad(Target); 5164 } 5165 else 5166 Target = EmitMetaClassRef(CGF.Builder, Class); 5167 } 5168 else 5169 Target = EmitSuperClassRef(CGF.Builder, Class); 5170 5171 // FIXME: We shouldn't need to do this cast, rectify the ASTContext 5172 // and ObjCTypes types. 5173 const llvm::Type *ClassTy = 5174 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType()); 5175 Target = CGF.Builder.CreateBitCast(Target, ClassTy); 5176 CGF.Builder.CreateStore(Target, 5177 CGF.Builder.CreateStructGEP(ObjCSuper, 1)); 5178 5179 return EmitMessageSend(CGF, ResultType, Sel, 5180 ObjCSuper, ObjCTypes.SuperPtrCTy, 5181 true, CallArgs); 5182} 5183 5184llvm::Value *CGObjCNonFragileABIMac::EmitSelector(CGBuilderTy &Builder, 5185 Selector Sel) { 5186 llvm::GlobalVariable *&Entry = SelectorReferences[Sel]; 5187 5188 if (!Entry) { 5189 llvm::Constant *Casted = 5190 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel), 5191 ObjCTypes.SelectorPtrTy); 5192 Entry = 5193 new llvm::GlobalVariable(ObjCTypes.SelectorPtrTy, false, 5194 llvm::GlobalValue::InternalLinkage, 5195 Casted, "\01L_OBJC_SELECTOR_REFERENCES_", 5196 &CGM.getModule()); 5197 Entry->setSection("__DATA,__objc_selrefs,literal_pointers,no_dead_strip"); 5198 UsedGlobals.push_back(Entry); 5199 } 5200 5201 return Builder.CreateLoad(Entry, false, "tmp"); 5202} 5203/// EmitObjCIvarAssign - Code gen for assigning to a __strong object. 5204/// objc_assign_ivar (id src, id *dst) 5205/// 5206void CGObjCNonFragileABIMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, 5207 llvm::Value *src, llvm::Value *dst) 5208{ 5209 const llvm::Type * SrcTy = src->getType(); 5210 if (!isa<llvm::PointerType>(SrcTy)) { 5211 unsigned Size = CGM.getTargetData().getTypePaddedSize(SrcTy); 5212 assert(Size <= 8 && "does not support size > 8"); 5213 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy) 5214 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy)); 5215 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 5216 } 5217 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 5218 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); 5219 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignIvarFn(), 5220 src, dst, "assignivar"); 5221 return; 5222} 5223 5224/// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object. 5225/// objc_assign_strongCast (id src, id *dst) 5226/// 5227void CGObjCNonFragileABIMac::EmitObjCStrongCastAssign( 5228 CodeGen::CodeGenFunction &CGF, 5229 llvm::Value *src, llvm::Value *dst) 5230{ 5231 const llvm::Type * SrcTy = src->getType(); 5232 if (!isa<llvm::PointerType>(SrcTy)) { 5233 unsigned Size = CGM.getTargetData().getTypePaddedSize(SrcTy); 5234 assert(Size <= 8 && "does not support size > 8"); 5235 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy) 5236 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy)); 5237 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 5238 } 5239 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 5240 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); 5241 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignStrongCastFn(), 5242 src, dst, "weakassign"); 5243 return; 5244} 5245 5246/// EmitObjCWeakRead - Code gen for loading value of a __weak 5247/// object: objc_read_weak (id *src) 5248/// 5249llvm::Value * CGObjCNonFragileABIMac::EmitObjCWeakRead( 5250 CodeGen::CodeGenFunction &CGF, 5251 llvm::Value *AddrWeakObj) 5252{ 5253 const llvm::Type* DestTy = 5254 cast<llvm::PointerType>(AddrWeakObj->getType())->getElementType(); 5255 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy); 5256 llvm::Value *read_weak = CGF.Builder.CreateCall(ObjCTypes.getGcReadWeakFn(), 5257 AddrWeakObj, "weakread"); 5258 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy); 5259 return read_weak; 5260} 5261 5262/// EmitObjCWeakAssign - Code gen for assigning to a __weak object. 5263/// objc_assign_weak (id src, id *dst) 5264/// 5265void CGObjCNonFragileABIMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, 5266 llvm::Value *src, llvm::Value *dst) 5267{ 5268 const llvm::Type * SrcTy = src->getType(); 5269 if (!isa<llvm::PointerType>(SrcTy)) { 5270 unsigned Size = CGM.getTargetData().getTypePaddedSize(SrcTy); 5271 assert(Size <= 8 && "does not support size > 8"); 5272 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy) 5273 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy)); 5274 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 5275 } 5276 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 5277 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); 5278 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignWeakFn(), 5279 src, dst, "weakassign"); 5280 return; 5281} 5282 5283/// EmitObjCGlobalAssign - Code gen for assigning to a __strong object. 5284/// objc_assign_global (id src, id *dst) 5285/// 5286void CGObjCNonFragileABIMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, 5287 llvm::Value *src, llvm::Value *dst) 5288{ 5289 const llvm::Type * SrcTy = src->getType(); 5290 if (!isa<llvm::PointerType>(SrcTy)) { 5291 unsigned Size = CGM.getTargetData().getTypePaddedSize(SrcTy); 5292 assert(Size <= 8 && "does not support size > 8"); 5293 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy) 5294 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy)); 5295 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 5296 } 5297 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 5298 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); 5299 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignGlobalFn(), 5300 src, dst, "globalassign"); 5301 return; 5302} 5303 5304void 5305CGObjCNonFragileABIMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, 5306 const Stmt &S) { 5307 bool isTry = isa<ObjCAtTryStmt>(S); 5308 llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try"); 5309 llvm::BasicBlock *PrevLandingPad = CGF.getInvokeDest(); 5310 llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler"); 5311 llvm::BasicBlock *FinallyBlock = CGF.createBasicBlock("finally"); 5312 llvm::BasicBlock *FinallyRethrow = CGF.createBasicBlock("finally.throw"); 5313 llvm::BasicBlock *FinallyEnd = CGF.createBasicBlock("finally.end"); 5314 5315 // For @synchronized, call objc_sync_enter(sync.expr). The 5316 // evaluation of the expression must occur before we enter the 5317 // @synchronized. We can safely avoid a temp here because jumps into 5318 // @synchronized are illegal & this will dominate uses. 5319 llvm::Value *SyncArg = 0; 5320 if (!isTry) { 5321 SyncArg = 5322 CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr()); 5323 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy); 5324 CGF.Builder.CreateCall(ObjCTypes.getSyncEnterFn(), SyncArg); 5325 } 5326 5327 // Push an EH context entry, used for handling rethrows and jumps 5328 // through finally. 5329 CGF.PushCleanupBlock(FinallyBlock); 5330 5331 CGF.setInvokeDest(TryHandler); 5332 5333 CGF.EmitBlock(TryBlock); 5334 CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody() 5335 : cast<ObjCAtSynchronizedStmt>(S).getSynchBody()); 5336 CGF.EmitBranchThroughCleanup(FinallyEnd); 5337 5338 // Emit the exception handler. 5339 5340 CGF.EmitBlock(TryHandler); 5341 5342 llvm::Value *llvm_eh_exception = 5343 CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_exception); 5344 llvm::Value *llvm_eh_selector_i64 = 5345 CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_selector_i64); 5346 llvm::Value *llvm_eh_typeid_for_i64 = 5347 CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for_i64); 5348 llvm::Value *Exc = CGF.Builder.CreateCall(llvm_eh_exception, "exc"); 5349 llvm::Value *RethrowPtr = CGF.CreateTempAlloca(Exc->getType(), "_rethrow"); 5350 5351 llvm::SmallVector<llvm::Value*, 8> SelectorArgs; 5352 SelectorArgs.push_back(Exc); 5353 SelectorArgs.push_back(ObjCTypes.getEHPersonalityPtr()); 5354 5355 // Construct the lists of (type, catch body) to handle. 5356 llvm::SmallVector<std::pair<const ParmVarDecl*, const Stmt*>, 8> Handlers; 5357 bool HasCatchAll = false; 5358 if (isTry) { 5359 if (const ObjCAtCatchStmt* CatchStmt = 5360 cast<ObjCAtTryStmt>(S).getCatchStmts()) { 5361 for (; CatchStmt; CatchStmt = CatchStmt->getNextCatchStmt()) { 5362 const ParmVarDecl *CatchDecl = CatchStmt->getCatchParamDecl(); 5363 Handlers.push_back(std::make_pair(CatchDecl, CatchStmt->getCatchBody())); 5364 5365 // catch(...) always matches. 5366 if (!CatchDecl) { 5367 // Use i8* null here to signal this is a catch all, not a cleanup. 5368 llvm::Value *Null = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy); 5369 SelectorArgs.push_back(Null); 5370 HasCatchAll = true; 5371 break; 5372 } 5373 5374 if (CGF.getContext().isObjCIdType(CatchDecl->getType()) || 5375 CatchDecl->getType()->isObjCQualifiedIdType()) { 5376 llvm::Value *IDEHType = 5377 CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id"); 5378 if (!IDEHType) 5379 IDEHType = 5380 new llvm::GlobalVariable(ObjCTypes.EHTypeTy, false, 5381 llvm::GlobalValue::ExternalLinkage, 5382 0, "OBJC_EHTYPE_id", &CGM.getModule()); 5383 SelectorArgs.push_back(IDEHType); 5384 HasCatchAll = true; 5385 break; 5386 } 5387 5388 // All other types should be Objective-C interface pointer types. 5389 const PointerType *PT = CatchDecl->getType()->getAsPointerType(); 5390 assert(PT && "Invalid @catch type."); 5391 const ObjCInterfaceType *IT = 5392 PT->getPointeeType()->getAsObjCInterfaceType(); 5393 assert(IT && "Invalid @catch type."); 5394 llvm::Value *EHType = GetInterfaceEHType(IT->getDecl(), false); 5395 SelectorArgs.push_back(EHType); 5396 } 5397 } 5398 } 5399 5400 // We use a cleanup unless there was already a catch all. 5401 if (!HasCatchAll) { 5402 SelectorArgs.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, 0)); 5403 Handlers.push_back(std::make_pair((const ParmVarDecl*) 0, (const Stmt*) 0)); 5404 } 5405 5406 llvm::Value *Selector = 5407 CGF.Builder.CreateCall(llvm_eh_selector_i64, 5408 SelectorArgs.begin(), SelectorArgs.end(), 5409 "selector"); 5410 for (unsigned i = 0, e = Handlers.size(); i != e; ++i) { 5411 const ParmVarDecl *CatchParam = Handlers[i].first; 5412 const Stmt *CatchBody = Handlers[i].second; 5413 5414 llvm::BasicBlock *Next = 0; 5415 5416 // The last handler always matches. 5417 if (i + 1 != e) { 5418 assert(CatchParam && "Only last handler can be a catch all."); 5419 5420 llvm::BasicBlock *Match = CGF.createBasicBlock("match"); 5421 Next = CGF.createBasicBlock("catch.next"); 5422 llvm::Value *Id = 5423 CGF.Builder.CreateCall(llvm_eh_typeid_for_i64, 5424 CGF.Builder.CreateBitCast(SelectorArgs[i+2], 5425 ObjCTypes.Int8PtrTy)); 5426 CGF.Builder.CreateCondBr(CGF.Builder.CreateICmpEQ(Selector, Id), 5427 Match, Next); 5428 5429 CGF.EmitBlock(Match); 5430 } 5431 5432 if (CatchBody) { 5433 llvm::BasicBlock *MatchEnd = CGF.createBasicBlock("match.end"); 5434 llvm::BasicBlock *MatchHandler = CGF.createBasicBlock("match.handler"); 5435 5436 // Cleanups must call objc_end_catch. 5437 // 5438 // FIXME: It seems incorrect for objc_begin_catch to be inside 5439 // this context, but this matches gcc. 5440 CGF.PushCleanupBlock(MatchEnd); 5441 CGF.setInvokeDest(MatchHandler); 5442 5443 llvm::Value *ExcObject = 5444 CGF.Builder.CreateCall(ObjCTypes.getObjCBeginCatchFn(), Exc); 5445 5446 // Bind the catch parameter if it exists. 5447 if (CatchParam) { 5448 ExcObject = 5449 CGF.Builder.CreateBitCast(ExcObject, 5450 CGF.ConvertType(CatchParam->getType())); 5451 // CatchParam is a ParmVarDecl because of the grammar 5452 // construction used to handle this, but for codegen purposes 5453 // we treat this as a local decl. 5454 CGF.EmitLocalBlockVarDecl(*CatchParam); 5455 CGF.Builder.CreateStore(ExcObject, CGF.GetAddrOfLocalVar(CatchParam)); 5456 } 5457 5458 CGF.ObjCEHValueStack.push_back(ExcObject); 5459 CGF.EmitStmt(CatchBody); 5460 CGF.ObjCEHValueStack.pop_back(); 5461 5462 CGF.EmitBranchThroughCleanup(FinallyEnd); 5463 5464 CGF.EmitBlock(MatchHandler); 5465 5466 llvm::Value *Exc = CGF.Builder.CreateCall(llvm_eh_exception, "exc"); 5467 // We are required to emit this call to satisfy LLVM, even 5468 // though we don't use the result. 5469 llvm::SmallVector<llvm::Value*, 8> Args; 5470 Args.push_back(Exc); 5471 Args.push_back(ObjCTypes.getEHPersonalityPtr()); 5472 Args.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, 5473 0)); 5474 CGF.Builder.CreateCall(llvm_eh_selector_i64, Args.begin(), Args.end()); 5475 CGF.Builder.CreateStore(Exc, RethrowPtr); 5476 CGF.EmitBranchThroughCleanup(FinallyRethrow); 5477 5478 CodeGenFunction::CleanupBlockInfo Info = CGF.PopCleanupBlock(); 5479 5480 CGF.EmitBlock(MatchEnd); 5481 5482 // Unfortunately, we also have to generate another EH frame here 5483 // in case this throws. 5484 llvm::BasicBlock *MatchEndHandler = 5485 CGF.createBasicBlock("match.end.handler"); 5486 llvm::BasicBlock *Cont = CGF.createBasicBlock("invoke.cont"); 5487 CGF.Builder.CreateInvoke(ObjCTypes.getObjCEndCatchFn(), 5488 Cont, MatchEndHandler, 5489 Args.begin(), Args.begin()); 5490 5491 CGF.EmitBlock(Cont); 5492 if (Info.SwitchBlock) 5493 CGF.EmitBlock(Info.SwitchBlock); 5494 if (Info.EndBlock) 5495 CGF.EmitBlock(Info.EndBlock); 5496 5497 CGF.EmitBlock(MatchEndHandler); 5498 Exc = CGF.Builder.CreateCall(llvm_eh_exception, "exc"); 5499 // We are required to emit this call to satisfy LLVM, even 5500 // though we don't use the result. 5501 Args.clear(); 5502 Args.push_back(Exc); 5503 Args.push_back(ObjCTypes.getEHPersonalityPtr()); 5504 Args.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, 5505 0)); 5506 CGF.Builder.CreateCall(llvm_eh_selector_i64, Args.begin(), Args.end()); 5507 CGF.Builder.CreateStore(Exc, RethrowPtr); 5508 CGF.EmitBranchThroughCleanup(FinallyRethrow); 5509 5510 if (Next) 5511 CGF.EmitBlock(Next); 5512 } else { 5513 assert(!Next && "catchup should be last handler."); 5514 5515 CGF.Builder.CreateStore(Exc, RethrowPtr); 5516 CGF.EmitBranchThroughCleanup(FinallyRethrow); 5517 } 5518 } 5519 5520 // Pop the cleanup entry, the @finally is outside this cleanup 5521 // scope. 5522 CodeGenFunction::CleanupBlockInfo Info = CGF.PopCleanupBlock(); 5523 CGF.setInvokeDest(PrevLandingPad); 5524 5525 CGF.EmitBlock(FinallyBlock); 5526 5527 if (isTry) { 5528 if (const ObjCAtFinallyStmt* FinallyStmt = 5529 cast<ObjCAtTryStmt>(S).getFinallyStmt()) 5530 CGF.EmitStmt(FinallyStmt->getFinallyBody()); 5531 } else { 5532 // Emit 'objc_sync_exit(expr)' as finally's sole statement for 5533 // @synchronized. 5534 CGF.Builder.CreateCall(ObjCTypes.getSyncExitFn(), SyncArg); 5535 } 5536 5537 if (Info.SwitchBlock) 5538 CGF.EmitBlock(Info.SwitchBlock); 5539 if (Info.EndBlock) 5540 CGF.EmitBlock(Info.EndBlock); 5541 5542 // Branch around the rethrow code. 5543 CGF.EmitBranch(FinallyEnd); 5544 5545 CGF.EmitBlock(FinallyRethrow); 5546 CGF.Builder.CreateCall(ObjCTypes.getUnwindResumeOrRethrowFn(), 5547 CGF.Builder.CreateLoad(RethrowPtr)); 5548 CGF.Builder.CreateUnreachable(); 5549 5550 CGF.EmitBlock(FinallyEnd); 5551} 5552 5553/// EmitThrowStmt - Generate code for a throw statement. 5554void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF, 5555 const ObjCAtThrowStmt &S) { 5556 llvm::Value *Exception; 5557 if (const Expr *ThrowExpr = S.getThrowExpr()) { 5558 Exception = CGF.EmitScalarExpr(ThrowExpr); 5559 } else { 5560 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) && 5561 "Unexpected rethrow outside @catch block."); 5562 Exception = CGF.ObjCEHValueStack.back(); 5563 } 5564 5565 llvm::Value *ExceptionAsObject = 5566 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy, "tmp"); 5567 llvm::BasicBlock *InvokeDest = CGF.getInvokeDest(); 5568 if (InvokeDest) { 5569 llvm::BasicBlock *Cont = CGF.createBasicBlock("invoke.cont"); 5570 CGF.Builder.CreateInvoke(ObjCTypes.getExceptionThrowFn(), 5571 Cont, InvokeDest, 5572 &ExceptionAsObject, &ExceptionAsObject + 1); 5573 CGF.EmitBlock(Cont); 5574 } else 5575 CGF.Builder.CreateCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject); 5576 CGF.Builder.CreateUnreachable(); 5577 5578 // Clear the insertion point to indicate we are in unreachable code. 5579 CGF.Builder.ClearInsertionPoint(); 5580} 5581 5582llvm::Value * 5583CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceDecl *ID, 5584 bool ForDefinition) { 5585 llvm::GlobalVariable * &Entry = EHTypeReferences[ID->getIdentifier()]; 5586 5587 // If we don't need a definition, return the entry if found or check 5588 // if we use an external reference. 5589 if (!ForDefinition) { 5590 if (Entry) 5591 return Entry; 5592 5593 // If this type (or a super class) has the __objc_exception__ 5594 // attribute, emit an external reference. 5595 if (hasObjCExceptionAttribute(ID)) 5596 return Entry = 5597 new llvm::GlobalVariable(ObjCTypes.EHTypeTy, false, 5598 llvm::GlobalValue::ExternalLinkage, 5599 0, 5600 (std::string("OBJC_EHTYPE_$_") + 5601 ID->getIdentifier()->getName()), 5602 &CGM.getModule()); 5603 } 5604 5605 // Otherwise we need to either make a new entry or fill in the 5606 // initializer. 5607 assert((!Entry || !Entry->hasInitializer()) && "Duplicate EHType definition"); 5608 std::string ClassName(getClassSymbolPrefix() + ID->getNameAsString()); 5609 std::string VTableName = "objc_ehtype_vtable"; 5610 llvm::GlobalVariable *VTableGV = 5611 CGM.getModule().getGlobalVariable(VTableName); 5612 if (!VTableGV) 5613 VTableGV = new llvm::GlobalVariable(ObjCTypes.Int8PtrTy, false, 5614 llvm::GlobalValue::ExternalLinkage, 5615 0, VTableName, &CGM.getModule()); 5616 5617 llvm::Value *VTableIdx = llvm::ConstantInt::get(llvm::Type::Int32Ty, 2); 5618 5619 std::vector<llvm::Constant*> Values(3); 5620 Values[0] = llvm::ConstantExpr::getGetElementPtr(VTableGV, &VTableIdx, 1); 5621 Values[1] = GetClassName(ID->getIdentifier()); 5622 Values[2] = GetClassGlobal(ClassName); 5623 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.EHTypeTy, Values); 5624 5625 if (Entry) { 5626 Entry->setInitializer(Init); 5627 } else { 5628 Entry = new llvm::GlobalVariable(ObjCTypes.EHTypeTy, false, 5629 llvm::GlobalValue::WeakAnyLinkage, 5630 Init, 5631 (std::string("OBJC_EHTYPE_$_") + 5632 ID->getIdentifier()->getName()), 5633 &CGM.getModule()); 5634 } 5635 5636 if (CGM.getLangOptions().getVisibilityMode() == LangOptions::Hidden) 5637 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility); 5638 Entry->setAlignment(8); 5639 5640 if (ForDefinition) { 5641 Entry->setSection("__DATA,__objc_const"); 5642 Entry->setLinkage(llvm::GlobalValue::ExternalLinkage); 5643 } else { 5644 Entry->setSection("__DATA,__datacoal_nt,coalesced"); 5645 } 5646 5647 return Entry; 5648} 5649 5650/* *** */ 5651 5652CodeGen::CGObjCRuntime * 5653CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) { 5654 return new CGObjCMac(CGM); 5655} 5656 5657CodeGen::CGObjCRuntime * 5658CodeGen::CreateMacNonFragileABIObjCRuntime(CodeGen::CodeGenModule &CGM) { 5659 return new CGObjCNonFragileABIMac(CGM); 5660} 5661