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