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