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