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