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