1 //===------- CGObjCGNU.cpp - Emit LLVM Code from ASTs for a Module --------===// 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 GNU runtime. The 10 // class in this file generates structures used by the GNU Objective-C runtime 11 // library. These structures are defined in objc/objc.h and objc/objc-api.h in 12 // the GNU runtime distribution. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #include "CGObjCRuntime.h" 17 #include "CGCleanup.h" 18 #include "CodeGenFunction.h" 19 #include "CodeGenModule.h" 20 #include "CGCXXABI.h" 21 #include "clang/CodeGen/ConstantInitBuilder.h" 22 #include "clang/AST/ASTContext.h" 23 #include "clang/AST/Decl.h" 24 #include "clang/AST/DeclObjC.h" 25 #include "clang/AST/RecordLayout.h" 26 #include "clang/AST/StmtObjC.h" 27 #include "clang/Basic/FileManager.h" 28 #include "clang/Basic/SourceManager.h" 29 #include "llvm/ADT/SmallVector.h" 30 #include "llvm/ADT/StringMap.h" 31 #include "llvm/IR/DataLayout.h" 32 #include "llvm/IR/Intrinsics.h" 33 #include "llvm/IR/LLVMContext.h" 34 #include "llvm/IR/Module.h" 35 #include "llvm/Support/Compiler.h" 36 #include "llvm/Support/ConvertUTF.h" 37 #include <cctype> 38 39 using namespace clang; 40 using namespace CodeGen; 41 42 namespace { 43 44 std::string SymbolNameForMethod( StringRef ClassName, 45 StringRef CategoryName, const Selector MethodName, 46 bool isClassMethod) { 47 std::string MethodNameColonStripped = MethodName.getAsString(); 48 std::replace(MethodNameColonStripped.begin(), MethodNameColonStripped.end(), 49 ':', '_'); 50 return (Twine(isClassMethod ? "_c_" : "_i_") + ClassName + "_" + 51 CategoryName + "_" + MethodNameColonStripped).str(); 52 } 53 54 /// Class that lazily initialises the runtime function. Avoids inserting the 55 /// types and the function declaration into a module if they're not used, and 56 /// avoids constructing the type more than once if it's used more than once. 57 class LazyRuntimeFunction { 58 CodeGenModule *CGM; 59 llvm::FunctionType *FTy; 60 const char *FunctionName; 61 llvm::FunctionCallee Function; 62 63 public: 64 /// Constructor leaves this class uninitialized, because it is intended to 65 /// be used as a field in another class and not all of the types that are 66 /// used as arguments will necessarily be available at construction time. 67 LazyRuntimeFunction() 68 : CGM(nullptr), FunctionName(nullptr), Function(nullptr) {} 69 70 /// Initialises the lazy function with the name, return type, and the types 71 /// of the arguments. 72 template <typename... Tys> 73 void init(CodeGenModule *Mod, const char *name, llvm::Type *RetTy, 74 Tys *... Types) { 75 CGM = Mod; 76 FunctionName = name; 77 Function = nullptr; 78 if(sizeof...(Tys)) { 79 SmallVector<llvm::Type *, 8> ArgTys({Types...}); 80 FTy = llvm::FunctionType::get(RetTy, ArgTys, false); 81 } 82 else { 83 FTy = llvm::FunctionType::get(RetTy, None, false); 84 } 85 } 86 87 llvm::FunctionType *getType() { return FTy; } 88 89 /// Overloaded cast operator, allows the class to be implicitly cast to an 90 /// LLVM constant. 91 operator llvm::FunctionCallee() { 92 if (!Function) { 93 if (!FunctionName) 94 return nullptr; 95 Function = CGM->CreateRuntimeFunction(FTy, FunctionName); 96 } 97 return Function; 98 } 99 }; 100 101 102 /// GNU Objective-C runtime code generation. This class implements the parts of 103 /// Objective-C support that are specific to the GNU family of runtimes (GCC, 104 /// GNUstep and ObjFW). 105 class CGObjCGNU : public CGObjCRuntime { 106 protected: 107 /// The LLVM module into which output is inserted 108 llvm::Module &TheModule; 109 /// strut objc_super. Used for sending messages to super. This structure 110 /// contains the receiver (object) and the expected class. 111 llvm::StructType *ObjCSuperTy; 112 /// struct objc_super*. The type of the argument to the superclass message 113 /// lookup functions. 114 llvm::PointerType *PtrToObjCSuperTy; 115 /// LLVM type for selectors. Opaque pointer (i8*) unless a header declaring 116 /// SEL is included in a header somewhere, in which case it will be whatever 117 /// type is declared in that header, most likely {i8*, i8*}. 118 llvm::PointerType *SelectorTy; 119 /// LLVM i8 type. Cached here to avoid repeatedly getting it in all of the 120 /// places where it's used 121 llvm::IntegerType *Int8Ty; 122 /// Pointer to i8 - LLVM type of char*, for all of the places where the 123 /// runtime needs to deal with C strings. 124 llvm::PointerType *PtrToInt8Ty; 125 /// struct objc_protocol type 126 llvm::StructType *ProtocolTy; 127 /// Protocol * type. 128 llvm::PointerType *ProtocolPtrTy; 129 /// Instance Method Pointer type. This is a pointer to a function that takes, 130 /// at a minimum, an object and a selector, and is the generic type for 131 /// Objective-C methods. Due to differences between variadic / non-variadic 132 /// calling conventions, it must always be cast to the correct type before 133 /// actually being used. 134 llvm::PointerType *IMPTy; 135 /// Type of an untyped Objective-C object. Clang treats id as a built-in type 136 /// when compiling Objective-C code, so this may be an opaque pointer (i8*), 137 /// but if the runtime header declaring it is included then it may be a 138 /// pointer to a structure. 139 llvm::PointerType *IdTy; 140 /// Pointer to a pointer to an Objective-C object. Used in the new ABI 141 /// message lookup function and some GC-related functions. 142 llvm::PointerType *PtrToIdTy; 143 /// The clang type of id. Used when using the clang CGCall infrastructure to 144 /// call Objective-C methods. 145 CanQualType ASTIdTy; 146 /// LLVM type for C int type. 147 llvm::IntegerType *IntTy; 148 /// LLVM type for an opaque pointer. This is identical to PtrToInt8Ty, but is 149 /// used in the code to document the difference between i8* meaning a pointer 150 /// to a C string and i8* meaning a pointer to some opaque type. 151 llvm::PointerType *PtrTy; 152 /// LLVM type for C long type. The runtime uses this in a lot of places where 153 /// it should be using intptr_t, but we can't fix this without breaking 154 /// compatibility with GCC... 155 llvm::IntegerType *LongTy; 156 /// LLVM type for C size_t. Used in various runtime data structures. 157 llvm::IntegerType *SizeTy; 158 /// LLVM type for C intptr_t. 159 llvm::IntegerType *IntPtrTy; 160 /// LLVM type for C ptrdiff_t. Mainly used in property accessor functions. 161 llvm::IntegerType *PtrDiffTy; 162 /// LLVM type for C int*. Used for GCC-ABI-compatible non-fragile instance 163 /// variables. 164 llvm::PointerType *PtrToIntTy; 165 /// LLVM type for Objective-C BOOL type. 166 llvm::Type *BoolTy; 167 /// 32-bit integer type, to save us needing to look it up every time it's used. 168 llvm::IntegerType *Int32Ty; 169 /// 64-bit integer type, to save us needing to look it up every time it's used. 170 llvm::IntegerType *Int64Ty; 171 /// The type of struct objc_property. 172 llvm::StructType *PropertyMetadataTy; 173 /// Metadata kind used to tie method lookups to message sends. The GNUstep 174 /// runtime provides some LLVM passes that can use this to do things like 175 /// automatic IMP caching and speculative inlining. 176 unsigned msgSendMDKind; 177 /// Does the current target use SEH-based exceptions? False implies 178 /// Itanium-style DWARF unwinding. 179 bool usesSEHExceptions; 180 181 /// Helper to check if we are targeting a specific runtime version or later. 182 bool isRuntime(ObjCRuntime::Kind kind, unsigned major, unsigned minor=0) { 183 const ObjCRuntime &R = CGM.getLangOpts().ObjCRuntime; 184 return (R.getKind() == kind) && 185 (R.getVersion() >= VersionTuple(major, minor)); 186 } 187 188 std::string ManglePublicSymbol(StringRef Name) { 189 return (StringRef(CGM.getTriple().isOSBinFormatCOFF() ? "$_" : "._") + Name).str(); 190 } 191 192 std::string SymbolForProtocol(Twine Name) { 193 return (ManglePublicSymbol("OBJC_PROTOCOL_") + Name).str(); 194 } 195 196 std::string SymbolForProtocolRef(StringRef Name) { 197 return (ManglePublicSymbol("OBJC_REF_PROTOCOL_") + Name).str(); 198 } 199 200 201 /// Helper function that generates a constant string and returns a pointer to 202 /// the start of the string. The result of this function can be used anywhere 203 /// where the C code specifies const char*. 204 llvm::Constant *MakeConstantString(StringRef Str, const char *Name = "") { 205 ConstantAddress Array = CGM.GetAddrOfConstantCString(Str, Name); 206 return llvm::ConstantExpr::getGetElementPtr(Array.getElementType(), 207 Array.getPointer(), Zeros); 208 } 209 210 /// Emits a linkonce_odr string, whose name is the prefix followed by the 211 /// string value. This allows the linker to combine the strings between 212 /// different modules. Used for EH typeinfo names, selector strings, and a 213 /// few other things. 214 llvm::Constant *ExportUniqueString(const std::string &Str, 215 const std::string &prefix, 216 bool Private=false) { 217 std::string name = prefix + Str; 218 auto *ConstStr = TheModule.getGlobalVariable(name); 219 if (!ConstStr) { 220 llvm::Constant *value = llvm::ConstantDataArray::getString(VMContext,Str); 221 auto *GV = new llvm::GlobalVariable(TheModule, value->getType(), true, 222 llvm::GlobalValue::LinkOnceODRLinkage, value, name); 223 GV->setComdat(TheModule.getOrInsertComdat(name)); 224 if (Private) 225 GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 226 ConstStr = GV; 227 } 228 return llvm::ConstantExpr::getGetElementPtr(ConstStr->getValueType(), 229 ConstStr, Zeros); 230 } 231 232 /// Returns a property name and encoding string. 233 llvm::Constant *MakePropertyEncodingString(const ObjCPropertyDecl *PD, 234 const Decl *Container) { 235 assert(!isRuntime(ObjCRuntime::GNUstep, 2)); 236 if (isRuntime(ObjCRuntime::GNUstep, 1, 6)) { 237 std::string NameAndAttributes; 238 std::string TypeStr = 239 CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container); 240 NameAndAttributes += '\0'; 241 NameAndAttributes += TypeStr.length() + 3; 242 NameAndAttributes += TypeStr; 243 NameAndAttributes += '\0'; 244 NameAndAttributes += PD->getNameAsString(); 245 return MakeConstantString(NameAndAttributes); 246 } 247 return MakeConstantString(PD->getNameAsString()); 248 } 249 250 /// Push the property attributes into two structure fields. 251 void PushPropertyAttributes(ConstantStructBuilder &Fields, 252 const ObjCPropertyDecl *property, bool isSynthesized=true, bool 253 isDynamic=true) { 254 int attrs = property->getPropertyAttributes(); 255 // For read-only properties, clear the copy and retain flags 256 if (attrs & ObjCPropertyDecl::OBJC_PR_readonly) { 257 attrs &= ~ObjCPropertyDecl::OBJC_PR_copy; 258 attrs &= ~ObjCPropertyDecl::OBJC_PR_retain; 259 attrs &= ~ObjCPropertyDecl::OBJC_PR_weak; 260 attrs &= ~ObjCPropertyDecl::OBJC_PR_strong; 261 } 262 // The first flags field has the same attribute values as clang uses internally 263 Fields.addInt(Int8Ty, attrs & 0xff); 264 attrs >>= 8; 265 attrs <<= 2; 266 // For protocol properties, synthesized and dynamic have no meaning, so we 267 // reuse these flags to indicate that this is a protocol property (both set 268 // has no meaning, as a property can't be both synthesized and dynamic) 269 attrs |= isSynthesized ? (1<<0) : 0; 270 attrs |= isDynamic ? (1<<1) : 0; 271 // The second field is the next four fields left shifted by two, with the 272 // low bit set to indicate whether the field is synthesized or dynamic. 273 Fields.addInt(Int8Ty, attrs & 0xff); 274 // Two padding fields 275 Fields.addInt(Int8Ty, 0); 276 Fields.addInt(Int8Ty, 0); 277 } 278 279 virtual llvm::Constant *GenerateCategoryProtocolList(const 280 ObjCCategoryDecl *OCD); 281 virtual ConstantArrayBuilder PushPropertyListHeader(ConstantStructBuilder &Fields, 282 int count) { 283 // int count; 284 Fields.addInt(IntTy, count); 285 // int size; (only in GNUstep v2 ABI. 286 if (isRuntime(ObjCRuntime::GNUstep, 2)) { 287 llvm::DataLayout td(&TheModule); 288 Fields.addInt(IntTy, td.getTypeSizeInBits(PropertyMetadataTy) / 289 CGM.getContext().getCharWidth()); 290 } 291 // struct objc_property_list *next; 292 Fields.add(NULLPtr); 293 // struct objc_property properties[] 294 return Fields.beginArray(PropertyMetadataTy); 295 } 296 virtual void PushProperty(ConstantArrayBuilder &PropertiesArray, 297 const ObjCPropertyDecl *property, 298 const Decl *OCD, 299 bool isSynthesized=true, bool 300 isDynamic=true) { 301 auto Fields = PropertiesArray.beginStruct(PropertyMetadataTy); 302 ASTContext &Context = CGM.getContext(); 303 Fields.add(MakePropertyEncodingString(property, OCD)); 304 PushPropertyAttributes(Fields, property, isSynthesized, isDynamic); 305 auto addPropertyMethod = [&](const ObjCMethodDecl *accessor) { 306 if (accessor) { 307 std::string TypeStr = Context.getObjCEncodingForMethodDecl(accessor); 308 llvm::Constant *TypeEncoding = MakeConstantString(TypeStr); 309 Fields.add(MakeConstantString(accessor->getSelector().getAsString())); 310 Fields.add(TypeEncoding); 311 } else { 312 Fields.add(NULLPtr); 313 Fields.add(NULLPtr); 314 } 315 }; 316 addPropertyMethod(property->getGetterMethodDecl()); 317 addPropertyMethod(property->getSetterMethodDecl()); 318 Fields.finishAndAddTo(PropertiesArray); 319 } 320 321 /// Ensures that the value has the required type, by inserting a bitcast if 322 /// required. This function lets us avoid inserting bitcasts that are 323 /// redundant. 324 llvm::Value* EnforceType(CGBuilderTy &B, llvm::Value *V, llvm::Type *Ty) { 325 if (V->getType() == Ty) return V; 326 return B.CreateBitCast(V, Ty); 327 } 328 Address EnforceType(CGBuilderTy &B, Address V, llvm::Type *Ty) { 329 if (V.getType() == Ty) return V; 330 return B.CreateBitCast(V, Ty); 331 } 332 333 // Some zeros used for GEPs in lots of places. 334 llvm::Constant *Zeros[2]; 335 /// Null pointer value. Mainly used as a terminator in various arrays. 336 llvm::Constant *NULLPtr; 337 /// LLVM context. 338 llvm::LLVMContext &VMContext; 339 340 protected: 341 342 /// Placeholder for the class. Lots of things refer to the class before we've 343 /// actually emitted it. We use this alias as a placeholder, and then replace 344 /// it with a pointer to the class structure before finally emitting the 345 /// module. 346 llvm::GlobalAlias *ClassPtrAlias; 347 /// Placeholder for the metaclass. Lots of things refer to the class before 348 /// we've / actually emitted it. We use this alias as a placeholder, and then 349 /// replace / it with a pointer to the metaclass structure before finally 350 /// emitting the / module. 351 llvm::GlobalAlias *MetaClassPtrAlias; 352 /// All of the classes that have been generated for this compilation units. 353 std::vector<llvm::Constant*> Classes; 354 /// All of the categories that have been generated for this compilation units. 355 std::vector<llvm::Constant*> Categories; 356 /// All of the Objective-C constant strings that have been generated for this 357 /// compilation units. 358 std::vector<llvm::Constant*> ConstantStrings; 359 /// Map from string values to Objective-C constant strings in the output. 360 /// Used to prevent emitting Objective-C strings more than once. This should 361 /// not be required at all - CodeGenModule should manage this list. 362 llvm::StringMap<llvm::Constant*> ObjCStrings; 363 /// All of the protocols that have been declared. 364 llvm::StringMap<llvm::Constant*> ExistingProtocols; 365 /// For each variant of a selector, we store the type encoding and a 366 /// placeholder value. For an untyped selector, the type will be the empty 367 /// string. Selector references are all done via the module's selector table, 368 /// so we create an alias as a placeholder and then replace it with the real 369 /// value later. 370 typedef std::pair<std::string, llvm::GlobalAlias*> TypedSelector; 371 /// Type of the selector map. This is roughly equivalent to the structure 372 /// used in the GNUstep runtime, which maintains a list of all of the valid 373 /// types for a selector in a table. 374 typedef llvm::DenseMap<Selector, SmallVector<TypedSelector, 2> > 375 SelectorMap; 376 /// A map from selectors to selector types. This allows us to emit all 377 /// selectors of the same name and type together. 378 SelectorMap SelectorTable; 379 380 /// Selectors related to memory management. When compiling in GC mode, we 381 /// omit these. 382 Selector RetainSel, ReleaseSel, AutoreleaseSel; 383 /// Runtime functions used for memory management in GC mode. Note that clang 384 /// supports code generation for calling these functions, but neither GNU 385 /// runtime actually supports this API properly yet. 386 LazyRuntimeFunction IvarAssignFn, StrongCastAssignFn, MemMoveFn, WeakReadFn, 387 WeakAssignFn, GlobalAssignFn; 388 389 typedef std::pair<std::string, std::string> ClassAliasPair; 390 /// All classes that have aliases set for them. 391 std::vector<ClassAliasPair> ClassAliases; 392 393 protected: 394 /// Function used for throwing Objective-C exceptions. 395 LazyRuntimeFunction ExceptionThrowFn; 396 /// Function used for rethrowing exceptions, used at the end of \@finally or 397 /// \@synchronize blocks. 398 LazyRuntimeFunction ExceptionReThrowFn; 399 /// Function called when entering a catch function. This is required for 400 /// differentiating Objective-C exceptions and foreign exceptions. 401 LazyRuntimeFunction EnterCatchFn; 402 /// Function called when exiting from a catch block. Used to do exception 403 /// cleanup. 404 LazyRuntimeFunction ExitCatchFn; 405 /// Function called when entering an \@synchronize block. Acquires the lock. 406 LazyRuntimeFunction SyncEnterFn; 407 /// Function called when exiting an \@synchronize block. Releases the lock. 408 LazyRuntimeFunction SyncExitFn; 409 410 private: 411 /// Function called if fast enumeration detects that the collection is 412 /// modified during the update. 413 LazyRuntimeFunction EnumerationMutationFn; 414 /// Function for implementing synthesized property getters that return an 415 /// object. 416 LazyRuntimeFunction GetPropertyFn; 417 /// Function for implementing synthesized property setters that return an 418 /// object. 419 LazyRuntimeFunction SetPropertyFn; 420 /// Function used for non-object declared property getters. 421 LazyRuntimeFunction GetStructPropertyFn; 422 /// Function used for non-object declared property setters. 423 LazyRuntimeFunction SetStructPropertyFn; 424 425 protected: 426 /// The version of the runtime that this class targets. Must match the 427 /// version in the runtime. 428 int RuntimeVersion; 429 /// The version of the protocol class. Used to differentiate between ObjC1 430 /// and ObjC2 protocols. Objective-C 1 protocols can not contain optional 431 /// components and can not contain declared properties. We always emit 432 /// Objective-C 2 property structures, but we have to pretend that they're 433 /// Objective-C 1 property structures when targeting the GCC runtime or it 434 /// will abort. 435 const int ProtocolVersion; 436 /// The version of the class ABI. This value is used in the class structure 437 /// and indicates how various fields should be interpreted. 438 const int ClassABIVersion; 439 /// Generates an instance variable list structure. This is a structure 440 /// containing a size and an array of structures containing instance variable 441 /// metadata. This is used purely for introspection in the fragile ABI. In 442 /// the non-fragile ABI, it's used for instance variable fixup. 443 virtual llvm::Constant *GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames, 444 ArrayRef<llvm::Constant *> IvarTypes, 445 ArrayRef<llvm::Constant *> IvarOffsets, 446 ArrayRef<llvm::Constant *> IvarAlign, 447 ArrayRef<Qualifiers::ObjCLifetime> IvarOwnership); 448 449 /// Generates a method list structure. This is a structure containing a size 450 /// and an array of structures containing method metadata. 451 /// 452 /// This structure is used by both classes and categories, and contains a next 453 /// pointer allowing them to be chained together in a linked list. 454 llvm::Constant *GenerateMethodList(StringRef ClassName, 455 StringRef CategoryName, 456 ArrayRef<const ObjCMethodDecl*> Methods, 457 bool isClassMethodList); 458 459 /// Emits an empty protocol. This is used for \@protocol() where no protocol 460 /// is found. The runtime will (hopefully) fix up the pointer to refer to the 461 /// real protocol. 462 virtual llvm::Constant *GenerateEmptyProtocol(StringRef ProtocolName); 463 464 /// Generates a list of property metadata structures. This follows the same 465 /// pattern as method and instance variable metadata lists. 466 llvm::Constant *GeneratePropertyList(const Decl *Container, 467 const ObjCContainerDecl *OCD, 468 bool isClassProperty=false, 469 bool protocolOptionalProperties=false); 470 471 /// Generates a list of referenced protocols. Classes, categories, and 472 /// protocols all use this structure. 473 llvm::Constant *GenerateProtocolList(ArrayRef<std::string> Protocols); 474 475 /// To ensure that all protocols are seen by the runtime, we add a category on 476 /// a class defined in the runtime, declaring no methods, but adopting the 477 /// protocols. This is a horribly ugly hack, but it allows us to collect all 478 /// of the protocols without changing the ABI. 479 void GenerateProtocolHolderCategory(); 480 481 /// Generates a class structure. 482 llvm::Constant *GenerateClassStructure( 483 llvm::Constant *MetaClass, 484 llvm::Constant *SuperClass, 485 unsigned info, 486 const char *Name, 487 llvm::Constant *Version, 488 llvm::Constant *InstanceSize, 489 llvm::Constant *IVars, 490 llvm::Constant *Methods, 491 llvm::Constant *Protocols, 492 llvm::Constant *IvarOffsets, 493 llvm::Constant *Properties, 494 llvm::Constant *StrongIvarBitmap, 495 llvm::Constant *WeakIvarBitmap, 496 bool isMeta=false); 497 498 /// Generates a method list. This is used by protocols to define the required 499 /// and optional methods. 500 virtual llvm::Constant *GenerateProtocolMethodList( 501 ArrayRef<const ObjCMethodDecl*> Methods); 502 /// Emits optional and required method lists. 503 template<class T> 504 void EmitProtocolMethodList(T &&Methods, llvm::Constant *&Required, 505 llvm::Constant *&Optional) { 506 SmallVector<const ObjCMethodDecl*, 16> RequiredMethods; 507 SmallVector<const ObjCMethodDecl*, 16> OptionalMethods; 508 for (const auto *I : Methods) 509 if (I->isOptional()) 510 OptionalMethods.push_back(I); 511 else 512 RequiredMethods.push_back(I); 513 Required = GenerateProtocolMethodList(RequiredMethods); 514 Optional = GenerateProtocolMethodList(OptionalMethods); 515 } 516 517 /// Returns a selector with the specified type encoding. An empty string is 518 /// used to return an untyped selector (with the types field set to NULL). 519 virtual llvm::Value *GetTypedSelector(CodeGenFunction &CGF, Selector Sel, 520 const std::string &TypeEncoding); 521 522 /// Returns the name of ivar offset variables. In the GNUstep v1 ABI, this 523 /// contains the class and ivar names, in the v2 ABI this contains the type 524 /// encoding as well. 525 virtual std::string GetIVarOffsetVariableName(const ObjCInterfaceDecl *ID, 526 const ObjCIvarDecl *Ivar) { 527 const std::string Name = "__objc_ivar_offset_" + ID->getNameAsString() 528 + '.' + Ivar->getNameAsString(); 529 return Name; 530 } 531 /// Returns the variable used to store the offset of an instance variable. 532 llvm::GlobalVariable *ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID, 533 const ObjCIvarDecl *Ivar); 534 /// Emits a reference to a class. This allows the linker to object if there 535 /// is no class of the matching name. 536 void EmitClassRef(const std::string &className); 537 538 /// Emits a pointer to the named class 539 virtual llvm::Value *GetClassNamed(CodeGenFunction &CGF, 540 const std::string &Name, bool isWeak); 541 542 /// Looks up the method for sending a message to the specified object. This 543 /// mechanism differs between the GCC and GNU runtimes, so this method must be 544 /// overridden in subclasses. 545 virtual llvm::Value *LookupIMP(CodeGenFunction &CGF, 546 llvm::Value *&Receiver, 547 llvm::Value *cmd, 548 llvm::MDNode *node, 549 MessageSendInfo &MSI) = 0; 550 551 /// Looks up the method for sending a message to a superclass. This 552 /// mechanism differs between the GCC and GNU runtimes, so this method must 553 /// be overridden in subclasses. 554 virtual llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, 555 Address ObjCSuper, 556 llvm::Value *cmd, 557 MessageSendInfo &MSI) = 0; 558 559 /// Libobjc2 uses a bitfield representation where small(ish) bitfields are 560 /// stored in a 64-bit value with the low bit set to 1 and the remaining 63 561 /// bits set to their values, LSB first, while larger ones are stored in a 562 /// structure of this / form: 563 /// 564 /// struct { int32_t length; int32_t values[length]; }; 565 /// 566 /// The values in the array are stored in host-endian format, with the least 567 /// significant bit being assumed to come first in the bitfield. Therefore, 568 /// a bitfield with the 64th bit set will be (int64_t)&{ 2, [0, 1<<31] }, 569 /// while a bitfield / with the 63rd bit set will be 1<<64. 570 llvm::Constant *MakeBitField(ArrayRef<bool> bits); 571 572 public: 573 CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion, 574 unsigned protocolClassVersion, unsigned classABI=1); 575 576 ConstantAddress GenerateConstantString(const StringLiteral *) override; 577 578 RValue 579 GenerateMessageSend(CodeGenFunction &CGF, ReturnValueSlot Return, 580 QualType ResultType, Selector Sel, 581 llvm::Value *Receiver, const CallArgList &CallArgs, 582 const ObjCInterfaceDecl *Class, 583 const ObjCMethodDecl *Method) override; 584 RValue 585 GenerateMessageSendSuper(CodeGenFunction &CGF, ReturnValueSlot Return, 586 QualType ResultType, Selector Sel, 587 const ObjCInterfaceDecl *Class, 588 bool isCategoryImpl, llvm::Value *Receiver, 589 bool IsClassMessage, const CallArgList &CallArgs, 590 const ObjCMethodDecl *Method) override; 591 llvm::Value *GetClass(CodeGenFunction &CGF, 592 const ObjCInterfaceDecl *OID) override; 593 llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override; 594 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override; 595 llvm::Value *GetSelector(CodeGenFunction &CGF, 596 const ObjCMethodDecl *Method) override; 597 virtual llvm::Constant *GetConstantSelector(Selector Sel, 598 const std::string &TypeEncoding) { 599 llvm_unreachable("Runtime unable to generate constant selector"); 600 } 601 llvm::Constant *GetConstantSelector(const ObjCMethodDecl *M) { 602 return GetConstantSelector(M->getSelector(), 603 CGM.getContext().getObjCEncodingForMethodDecl(M)); 604 } 605 llvm::Constant *GetEHType(QualType T) override; 606 607 llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD, 608 const ObjCContainerDecl *CD) override; 609 void GenerateCategory(const ObjCCategoryImplDecl *CMD) override; 610 void GenerateClass(const ObjCImplementationDecl *ClassDecl) override; 611 void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override; 612 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF, 613 const ObjCProtocolDecl *PD) override; 614 void GenerateProtocol(const ObjCProtocolDecl *PD) override; 615 llvm::Function *ModuleInitFunction() override; 616 llvm::FunctionCallee GetPropertyGetFunction() override; 617 llvm::FunctionCallee GetPropertySetFunction() override; 618 llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic, 619 bool copy) override; 620 llvm::FunctionCallee GetSetStructFunction() override; 621 llvm::FunctionCallee GetGetStructFunction() override; 622 llvm::FunctionCallee GetCppAtomicObjectGetFunction() override; 623 llvm::FunctionCallee GetCppAtomicObjectSetFunction() override; 624 llvm::FunctionCallee EnumerationMutationFunction() override; 625 626 void EmitTryStmt(CodeGenFunction &CGF, 627 const ObjCAtTryStmt &S) override; 628 void EmitSynchronizedStmt(CodeGenFunction &CGF, 629 const ObjCAtSynchronizedStmt &S) override; 630 void EmitThrowStmt(CodeGenFunction &CGF, 631 const ObjCAtThrowStmt &S, 632 bool ClearInsertionPoint=true) override; 633 llvm::Value * EmitObjCWeakRead(CodeGenFunction &CGF, 634 Address AddrWeakObj) override; 635 void EmitObjCWeakAssign(CodeGenFunction &CGF, 636 llvm::Value *src, Address dst) override; 637 void EmitObjCGlobalAssign(CodeGenFunction &CGF, 638 llvm::Value *src, Address dest, 639 bool threadlocal=false) override; 640 void EmitObjCIvarAssign(CodeGenFunction &CGF, llvm::Value *src, 641 Address dest, llvm::Value *ivarOffset) override; 642 void EmitObjCStrongCastAssign(CodeGenFunction &CGF, 643 llvm::Value *src, Address dest) override; 644 void EmitGCMemmoveCollectable(CodeGenFunction &CGF, Address DestPtr, 645 Address SrcPtr, 646 llvm::Value *Size) override; 647 LValue EmitObjCValueForIvar(CodeGenFunction &CGF, QualType ObjectTy, 648 llvm::Value *BaseValue, const ObjCIvarDecl *Ivar, 649 unsigned CVRQualifiers) override; 650 llvm::Value *EmitIvarOffset(CodeGenFunction &CGF, 651 const ObjCInterfaceDecl *Interface, 652 const ObjCIvarDecl *Ivar) override; 653 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override; 654 llvm::Constant *BuildGCBlockLayout(CodeGenModule &CGM, 655 const CGBlockInfo &blockInfo) override { 656 return NULLPtr; 657 } 658 llvm::Constant *BuildRCBlockLayout(CodeGenModule &CGM, 659 const CGBlockInfo &blockInfo) override { 660 return NULLPtr; 661 } 662 663 llvm::Constant *BuildByrefLayout(CodeGenModule &CGM, QualType T) override { 664 return NULLPtr; 665 } 666 }; 667 668 /// Class representing the legacy GCC Objective-C ABI. This is the default when 669 /// -fobjc-nonfragile-abi is not specified. 670 /// 671 /// The GCC ABI target actually generates code that is approximately compatible 672 /// with the new GNUstep runtime ABI, but refrains from using any features that 673 /// would not work with the GCC runtime. For example, clang always generates 674 /// the extended form of the class structure, and the extra fields are simply 675 /// ignored by GCC libobjc. 676 class CGObjCGCC : public CGObjCGNU { 677 /// The GCC ABI message lookup function. Returns an IMP pointing to the 678 /// method implementation for this message. 679 LazyRuntimeFunction MsgLookupFn; 680 /// The GCC ABI superclass message lookup function. Takes a pointer to a 681 /// structure describing the receiver and the class, and a selector as 682 /// arguments. Returns the IMP for the corresponding method. 683 LazyRuntimeFunction MsgLookupSuperFn; 684 685 protected: 686 llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver, 687 llvm::Value *cmd, llvm::MDNode *node, 688 MessageSendInfo &MSI) override { 689 CGBuilderTy &Builder = CGF.Builder; 690 llvm::Value *args[] = { 691 EnforceType(Builder, Receiver, IdTy), 692 EnforceType(Builder, cmd, SelectorTy) }; 693 llvm::CallBase *imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFn, args); 694 imp->setMetadata(msgSendMDKind, node); 695 return imp; 696 } 697 698 llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper, 699 llvm::Value *cmd, MessageSendInfo &MSI) override { 700 CGBuilderTy &Builder = CGF.Builder; 701 llvm::Value *lookupArgs[] = {EnforceType(Builder, ObjCSuper, 702 PtrToObjCSuperTy).getPointer(), cmd}; 703 return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs); 704 } 705 706 public: 707 CGObjCGCC(CodeGenModule &Mod) : CGObjCGNU(Mod, 8, 2) { 708 // IMP objc_msg_lookup(id, SEL); 709 MsgLookupFn.init(&CGM, "objc_msg_lookup", IMPTy, IdTy, SelectorTy); 710 // IMP objc_msg_lookup_super(struct objc_super*, SEL); 711 MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy, 712 PtrToObjCSuperTy, SelectorTy); 713 } 714 }; 715 716 /// Class used when targeting the new GNUstep runtime ABI. 717 class CGObjCGNUstep : public CGObjCGNU { 718 /// The slot lookup function. Returns a pointer to a cacheable structure 719 /// that contains (among other things) the IMP. 720 LazyRuntimeFunction SlotLookupFn; 721 /// The GNUstep ABI superclass message lookup function. Takes a pointer to 722 /// a structure describing the receiver and the class, and a selector as 723 /// arguments. Returns the slot for the corresponding method. Superclass 724 /// message lookup rarely changes, so this is a good caching opportunity. 725 LazyRuntimeFunction SlotLookupSuperFn; 726 /// Specialised function for setting atomic retain properties 727 LazyRuntimeFunction SetPropertyAtomic; 728 /// Specialised function for setting atomic copy properties 729 LazyRuntimeFunction SetPropertyAtomicCopy; 730 /// Specialised function for setting nonatomic retain properties 731 LazyRuntimeFunction SetPropertyNonAtomic; 732 /// Specialised function for setting nonatomic copy properties 733 LazyRuntimeFunction SetPropertyNonAtomicCopy; 734 /// Function to perform atomic copies of C++ objects with nontrivial copy 735 /// constructors from Objective-C ivars. 736 LazyRuntimeFunction CxxAtomicObjectGetFn; 737 /// Function to perform atomic copies of C++ objects with nontrivial copy 738 /// constructors to Objective-C ivars. 739 LazyRuntimeFunction CxxAtomicObjectSetFn; 740 /// Type of an slot structure pointer. This is returned by the various 741 /// lookup functions. 742 llvm::Type *SlotTy; 743 744 public: 745 llvm::Constant *GetEHType(QualType T) override; 746 747 protected: 748 llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver, 749 llvm::Value *cmd, llvm::MDNode *node, 750 MessageSendInfo &MSI) override { 751 CGBuilderTy &Builder = CGF.Builder; 752 llvm::FunctionCallee LookupFn = SlotLookupFn; 753 754 // Store the receiver on the stack so that we can reload it later 755 Address ReceiverPtr = 756 CGF.CreateTempAlloca(Receiver->getType(), CGF.getPointerAlign()); 757 Builder.CreateStore(Receiver, ReceiverPtr); 758 759 llvm::Value *self; 760 761 if (isa<ObjCMethodDecl>(CGF.CurCodeDecl)) { 762 self = CGF.LoadObjCSelf(); 763 } else { 764 self = llvm::ConstantPointerNull::get(IdTy); 765 } 766 767 // The lookup function is guaranteed not to capture the receiver pointer. 768 if (auto *LookupFn2 = dyn_cast<llvm::Function>(LookupFn.getCallee())) 769 LookupFn2->addParamAttr(0, llvm::Attribute::NoCapture); 770 771 llvm::Value *args[] = { 772 EnforceType(Builder, ReceiverPtr.getPointer(), PtrToIdTy), 773 EnforceType(Builder, cmd, SelectorTy), 774 EnforceType(Builder, self, IdTy) }; 775 llvm::CallBase *slot = CGF.EmitRuntimeCallOrInvoke(LookupFn, args); 776 slot->setOnlyReadsMemory(); 777 slot->setMetadata(msgSendMDKind, node); 778 779 // Load the imp from the slot 780 llvm::Value *imp = Builder.CreateAlignedLoad( 781 Builder.CreateStructGEP(nullptr, slot, 4), CGF.getPointerAlign()); 782 783 // The lookup function may have changed the receiver, so make sure we use 784 // the new one. 785 Receiver = Builder.CreateLoad(ReceiverPtr, true); 786 return imp; 787 } 788 789 llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper, 790 llvm::Value *cmd, 791 MessageSendInfo &MSI) override { 792 CGBuilderTy &Builder = CGF.Builder; 793 llvm::Value *lookupArgs[] = {ObjCSuper.getPointer(), cmd}; 794 795 llvm::CallInst *slot = 796 CGF.EmitNounwindRuntimeCall(SlotLookupSuperFn, lookupArgs); 797 slot->setOnlyReadsMemory(); 798 799 return Builder.CreateAlignedLoad(Builder.CreateStructGEP(nullptr, slot, 4), 800 CGF.getPointerAlign()); 801 } 802 803 public: 804 CGObjCGNUstep(CodeGenModule &Mod) : CGObjCGNUstep(Mod, 9, 3, 1) {} 805 CGObjCGNUstep(CodeGenModule &Mod, unsigned ABI, unsigned ProtocolABI, 806 unsigned ClassABI) : 807 CGObjCGNU(Mod, ABI, ProtocolABI, ClassABI) { 808 const ObjCRuntime &R = CGM.getLangOpts().ObjCRuntime; 809 810 llvm::StructType *SlotStructTy = 811 llvm::StructType::get(PtrTy, PtrTy, PtrTy, IntTy, IMPTy); 812 SlotTy = llvm::PointerType::getUnqual(SlotStructTy); 813 // Slot_t objc_msg_lookup_sender(id *receiver, SEL selector, id sender); 814 SlotLookupFn.init(&CGM, "objc_msg_lookup_sender", SlotTy, PtrToIdTy, 815 SelectorTy, IdTy); 816 // Slot_t objc_slot_lookup_super(struct objc_super*, SEL); 817 SlotLookupSuperFn.init(&CGM, "objc_slot_lookup_super", SlotTy, 818 PtrToObjCSuperTy, SelectorTy); 819 // If we're in ObjC++ mode, then we want to make 820 if (usesSEHExceptions) { 821 llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext); 822 // void objc_exception_rethrow(void) 823 ExceptionReThrowFn.init(&CGM, "objc_exception_rethrow", VoidTy); 824 } else if (CGM.getLangOpts().CPlusPlus) { 825 llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext); 826 // void *__cxa_begin_catch(void *e) 827 EnterCatchFn.init(&CGM, "__cxa_begin_catch", PtrTy, PtrTy); 828 // void __cxa_end_catch(void) 829 ExitCatchFn.init(&CGM, "__cxa_end_catch", VoidTy); 830 // void _Unwind_Resume_or_Rethrow(void*) 831 ExceptionReThrowFn.init(&CGM, "_Unwind_Resume_or_Rethrow", VoidTy, 832 PtrTy); 833 } else if (R.getVersion() >= VersionTuple(1, 7)) { 834 llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext); 835 // id objc_begin_catch(void *e) 836 EnterCatchFn.init(&CGM, "objc_begin_catch", IdTy, PtrTy); 837 // void objc_end_catch(void) 838 ExitCatchFn.init(&CGM, "objc_end_catch", VoidTy); 839 // void _Unwind_Resume_or_Rethrow(void*) 840 ExceptionReThrowFn.init(&CGM, "objc_exception_rethrow", VoidTy, PtrTy); 841 } 842 llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext); 843 SetPropertyAtomic.init(&CGM, "objc_setProperty_atomic", VoidTy, IdTy, 844 SelectorTy, IdTy, PtrDiffTy); 845 SetPropertyAtomicCopy.init(&CGM, "objc_setProperty_atomic_copy", VoidTy, 846 IdTy, SelectorTy, IdTy, PtrDiffTy); 847 SetPropertyNonAtomic.init(&CGM, "objc_setProperty_nonatomic", VoidTy, 848 IdTy, SelectorTy, IdTy, PtrDiffTy); 849 SetPropertyNonAtomicCopy.init(&CGM, "objc_setProperty_nonatomic_copy", 850 VoidTy, IdTy, SelectorTy, IdTy, PtrDiffTy); 851 // void objc_setCppObjectAtomic(void *dest, const void *src, void 852 // *helper); 853 CxxAtomicObjectSetFn.init(&CGM, "objc_setCppObjectAtomic", VoidTy, PtrTy, 854 PtrTy, PtrTy); 855 // void objc_getCppObjectAtomic(void *dest, const void *src, void 856 // *helper); 857 CxxAtomicObjectGetFn.init(&CGM, "objc_getCppObjectAtomic", VoidTy, PtrTy, 858 PtrTy, PtrTy); 859 } 860 861 llvm::FunctionCallee GetCppAtomicObjectGetFunction() override { 862 // The optimised functions were added in version 1.7 of the GNUstep 863 // runtime. 864 assert (CGM.getLangOpts().ObjCRuntime.getVersion() >= 865 VersionTuple(1, 7)); 866 return CxxAtomicObjectGetFn; 867 } 868 869 llvm::FunctionCallee GetCppAtomicObjectSetFunction() override { 870 // The optimised functions were added in version 1.7 of the GNUstep 871 // runtime. 872 assert (CGM.getLangOpts().ObjCRuntime.getVersion() >= 873 VersionTuple(1, 7)); 874 return CxxAtomicObjectSetFn; 875 } 876 877 llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic, 878 bool copy) override { 879 // The optimised property functions omit the GC check, and so are not 880 // safe to use in GC mode. The standard functions are fast in GC mode, 881 // so there is less advantage in using them. 882 assert ((CGM.getLangOpts().getGC() == LangOptions::NonGC)); 883 // The optimised functions were added in version 1.7 of the GNUstep 884 // runtime. 885 assert (CGM.getLangOpts().ObjCRuntime.getVersion() >= 886 VersionTuple(1, 7)); 887 888 if (atomic) { 889 if (copy) return SetPropertyAtomicCopy; 890 return SetPropertyAtomic; 891 } 892 893 return copy ? SetPropertyNonAtomicCopy : SetPropertyNonAtomic; 894 } 895 }; 896 897 /// GNUstep Objective-C ABI version 2 implementation. 898 /// This is the ABI that provides a clean break with the legacy GCC ABI and 899 /// cleans up a number of things that were added to work around 1980s linkers. 900 class CGObjCGNUstep2 : public CGObjCGNUstep { 901 enum SectionKind 902 { 903 SelectorSection = 0, 904 ClassSection, 905 ClassReferenceSection, 906 CategorySection, 907 ProtocolSection, 908 ProtocolReferenceSection, 909 ClassAliasSection, 910 ConstantStringSection 911 }; 912 static const char *const SectionsBaseNames[8]; 913 static const char *const PECOFFSectionsBaseNames[8]; 914 template<SectionKind K> 915 std::string sectionName() { 916 if (CGM.getTriple().isOSBinFormatCOFF()) { 917 std::string name(PECOFFSectionsBaseNames[K]); 918 name += "$m"; 919 return name; 920 } 921 return SectionsBaseNames[K]; 922 } 923 /// The GCC ABI superclass message lookup function. Takes a pointer to a 924 /// structure describing the receiver and the class, and a selector as 925 /// arguments. Returns the IMP for the corresponding method. 926 LazyRuntimeFunction MsgLookupSuperFn; 927 /// A flag indicating if we've emitted at least one protocol. 928 /// If we haven't, then we need to emit an empty protocol, to ensure that the 929 /// __start__objc_protocols and __stop__objc_protocols sections exist. 930 bool EmittedProtocol = false; 931 /// A flag indicating if we've emitted at least one protocol reference. 932 /// If we haven't, then we need to emit an empty protocol, to ensure that the 933 /// __start__objc_protocol_refs and __stop__objc_protocol_refs sections 934 /// exist. 935 bool EmittedProtocolRef = false; 936 /// A flag indicating if we've emitted at least one class. 937 /// If we haven't, then we need to emit an empty protocol, to ensure that the 938 /// __start__objc_classes and __stop__objc_classes sections / exist. 939 bool EmittedClass = false; 940 /// Generate the name of a symbol for a reference to a class. Accesses to 941 /// classes should be indirected via this. 942 943 typedef std::pair<std::string, std::pair<llvm::Constant*, int>> EarlyInitPair; 944 std::vector<EarlyInitPair> EarlyInitList; 945 946 std::string SymbolForClassRef(StringRef Name, bool isWeak) { 947 if (isWeak) 948 return (ManglePublicSymbol("OBJC_WEAK_REF_CLASS_") + Name).str(); 949 else 950 return (ManglePublicSymbol("OBJC_REF_CLASS_") + Name).str(); 951 } 952 /// Generate the name of a class symbol. 953 std::string SymbolForClass(StringRef Name) { 954 return (ManglePublicSymbol("OBJC_CLASS_") + Name).str(); 955 } 956 void CallRuntimeFunction(CGBuilderTy &B, StringRef FunctionName, 957 ArrayRef<llvm::Value*> Args) { 958 SmallVector<llvm::Type *,8> Types; 959 for (auto *Arg : Args) 960 Types.push_back(Arg->getType()); 961 llvm::FunctionType *FT = llvm::FunctionType::get(B.getVoidTy(), Types, 962 false); 963 llvm::FunctionCallee Fn = CGM.CreateRuntimeFunction(FT, FunctionName); 964 B.CreateCall(Fn, Args); 965 } 966 967 ConstantAddress GenerateConstantString(const StringLiteral *SL) override { 968 969 auto Str = SL->getString(); 970 CharUnits Align = CGM.getPointerAlign(); 971 972 // Look for an existing one 973 llvm::StringMap<llvm::Constant*>::iterator old = ObjCStrings.find(Str); 974 if (old != ObjCStrings.end()) 975 return ConstantAddress(old->getValue(), Align); 976 977 bool isNonASCII = SL->containsNonAscii(); 978 979 auto LiteralLength = SL->getLength(); 980 981 if ((CGM.getTarget().getPointerWidth(0) == 64) && 982 (LiteralLength < 9) && !isNonASCII) { 983 // Tiny strings are only used on 64-bit platforms. They store 8 7-bit 984 // ASCII characters in the high 56 bits, followed by a 4-bit length and a 985 // 3-bit tag (which is always 4). 986 uint64_t str = 0; 987 // Fill in the characters 988 for (unsigned i=0 ; i<LiteralLength ; i++) 989 str |= ((uint64_t)SL->getCodeUnit(i)) << ((64 - 4 - 3) - (i*7)); 990 // Fill in the length 991 str |= LiteralLength << 3; 992 // Set the tag 993 str |= 4; 994 auto *ObjCStr = llvm::ConstantExpr::getIntToPtr( 995 llvm::ConstantInt::get(Int64Ty, str), IdTy); 996 ObjCStrings[Str] = ObjCStr; 997 return ConstantAddress(ObjCStr, Align); 998 } 999 1000 StringRef StringClass = CGM.getLangOpts().ObjCConstantStringClass; 1001 1002 if (StringClass.empty()) StringClass = "NSConstantString"; 1003 1004 std::string Sym = SymbolForClass(StringClass); 1005 1006 llvm::Constant *isa = TheModule.getNamedGlobal(Sym); 1007 1008 if (!isa) { 1009 isa = new llvm::GlobalVariable(TheModule, IdTy, /* isConstant */false, 1010 llvm::GlobalValue::ExternalLinkage, nullptr, Sym); 1011 if (CGM.getTriple().isOSBinFormatCOFF()) { 1012 cast<llvm::GlobalValue>(isa)->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass); 1013 } 1014 } else if (isa->getType() != PtrToIdTy) 1015 isa = llvm::ConstantExpr::getBitCast(isa, PtrToIdTy); 1016 1017 // struct 1018 // { 1019 // Class isa; 1020 // uint32_t flags; 1021 // uint32_t length; // Number of codepoints 1022 // uint32_t size; // Number of bytes 1023 // uint32_t hash; 1024 // const char *data; 1025 // }; 1026 1027 ConstantInitBuilder Builder(CGM); 1028 auto Fields = Builder.beginStruct(); 1029 if (!CGM.getTriple().isOSBinFormatCOFF()) { 1030 Fields.add(isa); 1031 } else { 1032 Fields.addNullPointer(PtrTy); 1033 } 1034 // For now, all non-ASCII strings are represented as UTF-16. As such, the 1035 // number of bytes is simply double the number of UTF-16 codepoints. In 1036 // ASCII strings, the number of bytes is equal to the number of non-ASCII 1037 // codepoints. 1038 if (isNonASCII) { 1039 unsigned NumU8CodeUnits = Str.size(); 1040 // A UTF-16 representation of a unicode string contains at most the same 1041 // number of code units as a UTF-8 representation. Allocate that much 1042 // space, plus one for the final null character. 1043 SmallVector<llvm::UTF16, 128> ToBuf(NumU8CodeUnits + 1); 1044 const llvm::UTF8 *FromPtr = (const llvm::UTF8 *)Str.data(); 1045 llvm::UTF16 *ToPtr = &ToBuf[0]; 1046 (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumU8CodeUnits, 1047 &ToPtr, ToPtr + NumU8CodeUnits, llvm::strictConversion); 1048 uint32_t StringLength = ToPtr - &ToBuf[0]; 1049 // Add null terminator 1050 *ToPtr = 0; 1051 // Flags: 2 indicates UTF-16 encoding 1052 Fields.addInt(Int32Ty, 2); 1053 // Number of UTF-16 codepoints 1054 Fields.addInt(Int32Ty, StringLength); 1055 // Number of bytes 1056 Fields.addInt(Int32Ty, StringLength * 2); 1057 // Hash. Not currently initialised by the compiler. 1058 Fields.addInt(Int32Ty, 0); 1059 // pointer to the data string. 1060 auto Arr = llvm::makeArrayRef(&ToBuf[0], ToPtr+1); 1061 auto *C = llvm::ConstantDataArray::get(VMContext, Arr); 1062 auto *Buffer = new llvm::GlobalVariable(TheModule, C->getType(), 1063 /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, C, ".str"); 1064 Buffer->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); 1065 Fields.add(Buffer); 1066 } else { 1067 // Flags: 0 indicates ASCII encoding 1068 Fields.addInt(Int32Ty, 0); 1069 // Number of UTF-16 codepoints, each ASCII byte is a UTF-16 codepoint 1070 Fields.addInt(Int32Ty, Str.size()); 1071 // Number of bytes 1072 Fields.addInt(Int32Ty, Str.size()); 1073 // Hash. Not currently initialised by the compiler. 1074 Fields.addInt(Int32Ty, 0); 1075 // Data pointer 1076 Fields.add(MakeConstantString(Str)); 1077 } 1078 std::string StringName; 1079 bool isNamed = !isNonASCII; 1080 if (isNamed) { 1081 StringName = ".objc_str_"; 1082 for (int i=0,e=Str.size() ; i<e ; ++i) { 1083 unsigned char c = Str[i]; 1084 if (isalnum(c)) 1085 StringName += c; 1086 else if (c == ' ') 1087 StringName += '_'; 1088 else { 1089 isNamed = false; 1090 break; 1091 } 1092 } 1093 } 1094 auto *ObjCStrGV = 1095 Fields.finishAndCreateGlobal( 1096 isNamed ? StringRef(StringName) : ".objc_string", 1097 Align, false, isNamed ? llvm::GlobalValue::LinkOnceODRLinkage 1098 : llvm::GlobalValue::PrivateLinkage); 1099 ObjCStrGV->setSection(sectionName<ConstantStringSection>()); 1100 if (isNamed) { 1101 ObjCStrGV->setComdat(TheModule.getOrInsertComdat(StringName)); 1102 ObjCStrGV->setVisibility(llvm::GlobalValue::HiddenVisibility); 1103 } 1104 if (CGM.getTriple().isOSBinFormatCOFF()) { 1105 std::pair<llvm::Constant*, int> v{ObjCStrGV, 0}; 1106 EarlyInitList.emplace_back(Sym, v); 1107 } 1108 llvm::Constant *ObjCStr = llvm::ConstantExpr::getBitCast(ObjCStrGV, IdTy); 1109 ObjCStrings[Str] = ObjCStr; 1110 ConstantStrings.push_back(ObjCStr); 1111 return ConstantAddress(ObjCStr, Align); 1112 } 1113 1114 void PushProperty(ConstantArrayBuilder &PropertiesArray, 1115 const ObjCPropertyDecl *property, 1116 const Decl *OCD, 1117 bool isSynthesized=true, bool 1118 isDynamic=true) override { 1119 // struct objc_property 1120 // { 1121 // const char *name; 1122 // const char *attributes; 1123 // const char *type; 1124 // SEL getter; 1125 // SEL setter; 1126 // }; 1127 auto Fields = PropertiesArray.beginStruct(PropertyMetadataTy); 1128 ASTContext &Context = CGM.getContext(); 1129 Fields.add(MakeConstantString(property->getNameAsString())); 1130 std::string TypeStr = 1131 CGM.getContext().getObjCEncodingForPropertyDecl(property, OCD); 1132 Fields.add(MakeConstantString(TypeStr)); 1133 std::string typeStr; 1134 Context.getObjCEncodingForType(property->getType(), typeStr); 1135 Fields.add(MakeConstantString(typeStr)); 1136 auto addPropertyMethod = [&](const ObjCMethodDecl *accessor) { 1137 if (accessor) { 1138 std::string TypeStr = Context.getObjCEncodingForMethodDecl(accessor); 1139 Fields.add(GetConstantSelector(accessor->getSelector(), TypeStr)); 1140 } else { 1141 Fields.add(NULLPtr); 1142 } 1143 }; 1144 addPropertyMethod(property->getGetterMethodDecl()); 1145 addPropertyMethod(property->getSetterMethodDecl()); 1146 Fields.finishAndAddTo(PropertiesArray); 1147 } 1148 1149 llvm::Constant * 1150 GenerateProtocolMethodList(ArrayRef<const ObjCMethodDecl*> Methods) override { 1151 // struct objc_protocol_method_description 1152 // { 1153 // SEL selector; 1154 // const char *types; 1155 // }; 1156 llvm::StructType *ObjCMethodDescTy = 1157 llvm::StructType::get(CGM.getLLVMContext(), 1158 { PtrToInt8Ty, PtrToInt8Ty }); 1159 ASTContext &Context = CGM.getContext(); 1160 ConstantInitBuilder Builder(CGM); 1161 // struct objc_protocol_method_description_list 1162 // { 1163 // int count; 1164 // int size; 1165 // struct objc_protocol_method_description methods[]; 1166 // }; 1167 auto MethodList = Builder.beginStruct(); 1168 // int count; 1169 MethodList.addInt(IntTy, Methods.size()); 1170 // int size; // sizeof(struct objc_method_description) 1171 llvm::DataLayout td(&TheModule); 1172 MethodList.addInt(IntTy, td.getTypeSizeInBits(ObjCMethodDescTy) / 1173 CGM.getContext().getCharWidth()); 1174 // struct objc_method_description[] 1175 auto MethodArray = MethodList.beginArray(ObjCMethodDescTy); 1176 for (auto *M : Methods) { 1177 auto Method = MethodArray.beginStruct(ObjCMethodDescTy); 1178 Method.add(CGObjCGNU::GetConstantSelector(M)); 1179 Method.add(GetTypeString(Context.getObjCEncodingForMethodDecl(M, true))); 1180 Method.finishAndAddTo(MethodArray); 1181 } 1182 MethodArray.finishAndAddTo(MethodList); 1183 return MethodList.finishAndCreateGlobal(".objc_protocol_method_list", 1184 CGM.getPointerAlign()); 1185 } 1186 llvm::Constant *GenerateCategoryProtocolList(const ObjCCategoryDecl *OCD) 1187 override { 1188 SmallVector<llvm::Constant*, 16> Protocols; 1189 for (const auto *PI : OCD->getReferencedProtocols()) 1190 Protocols.push_back( 1191 llvm::ConstantExpr::getBitCast(GenerateProtocolRef(PI), 1192 ProtocolPtrTy)); 1193 return GenerateProtocolList(Protocols); 1194 } 1195 1196 llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper, 1197 llvm::Value *cmd, MessageSendInfo &MSI) override { 1198 // Don't access the slot unless we're trying to cache the result. 1199 CGBuilderTy &Builder = CGF.Builder; 1200 llvm::Value *lookupArgs[] = {CGObjCGNU::EnforceType(Builder, ObjCSuper, 1201 PtrToObjCSuperTy).getPointer(), cmd}; 1202 return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs); 1203 } 1204 1205 llvm::GlobalVariable *GetClassVar(StringRef Name, bool isWeak=false) { 1206 std::string SymbolName = SymbolForClassRef(Name, isWeak); 1207 auto *ClassSymbol = TheModule.getNamedGlobal(SymbolName); 1208 if (ClassSymbol) 1209 return ClassSymbol; 1210 ClassSymbol = new llvm::GlobalVariable(TheModule, 1211 IdTy, false, llvm::GlobalValue::ExternalLinkage, 1212 nullptr, SymbolName); 1213 // If this is a weak symbol, then we are creating a valid definition for 1214 // the symbol, pointing to a weak definition of the real class pointer. If 1215 // this is not a weak reference, then we are expecting another compilation 1216 // unit to provide the real indirection symbol. 1217 if (isWeak) 1218 ClassSymbol->setInitializer(new llvm::GlobalVariable(TheModule, 1219 Int8Ty, false, llvm::GlobalValue::ExternalWeakLinkage, 1220 nullptr, SymbolForClass(Name))); 1221 else { 1222 if (CGM.getTriple().isOSBinFormatCOFF()) { 1223 IdentifierInfo &II = CGM.getContext().Idents.get(Name); 1224 TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl(); 1225 DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl); 1226 1227 const ObjCInterfaceDecl *OID = nullptr; 1228 for (const auto &Result : DC->lookup(&II)) 1229 if ((OID = dyn_cast<ObjCInterfaceDecl>(Result))) 1230 break; 1231 1232 // The first Interface we find may be a @class, 1233 // which should only be treated as the source of 1234 // truth in the absence of a true declaration. 1235 const ObjCInterfaceDecl *OIDDef = OID->getDefinition(); 1236 if (OIDDef != nullptr) 1237 OID = OIDDef; 1238 1239 auto Storage = llvm::GlobalValue::DefaultStorageClass; 1240 if (OID->hasAttr<DLLImportAttr>()) 1241 Storage = llvm::GlobalValue::DLLImportStorageClass; 1242 else if (OID->hasAttr<DLLExportAttr>()) 1243 Storage = llvm::GlobalValue::DLLExportStorageClass; 1244 1245 cast<llvm::GlobalValue>(ClassSymbol)->setDLLStorageClass(Storage); 1246 } 1247 } 1248 assert(ClassSymbol->getName() == SymbolName); 1249 return ClassSymbol; 1250 } 1251 llvm::Value *GetClassNamed(CodeGenFunction &CGF, 1252 const std::string &Name, 1253 bool isWeak) override { 1254 return CGF.Builder.CreateLoad(Address(GetClassVar(Name, isWeak), 1255 CGM.getPointerAlign())); 1256 } 1257 int32_t FlagsForOwnership(Qualifiers::ObjCLifetime Ownership) { 1258 // typedef enum { 1259 // ownership_invalid = 0, 1260 // ownership_strong = 1, 1261 // ownership_weak = 2, 1262 // ownership_unsafe = 3 1263 // } ivar_ownership; 1264 int Flag; 1265 switch (Ownership) { 1266 case Qualifiers::OCL_Strong: 1267 Flag = 1; 1268 break; 1269 case Qualifiers::OCL_Weak: 1270 Flag = 2; 1271 break; 1272 case Qualifiers::OCL_ExplicitNone: 1273 Flag = 3; 1274 break; 1275 case Qualifiers::OCL_None: 1276 case Qualifiers::OCL_Autoreleasing: 1277 assert(Ownership != Qualifiers::OCL_Autoreleasing); 1278 Flag = 0; 1279 } 1280 return Flag; 1281 } 1282 llvm::Constant *GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames, 1283 ArrayRef<llvm::Constant *> IvarTypes, 1284 ArrayRef<llvm::Constant *> IvarOffsets, 1285 ArrayRef<llvm::Constant *> IvarAlign, 1286 ArrayRef<Qualifiers::ObjCLifetime> IvarOwnership) override { 1287 llvm_unreachable("Method should not be called!"); 1288 } 1289 1290 llvm::Constant *GenerateEmptyProtocol(StringRef ProtocolName) override { 1291 std::string Name = SymbolForProtocol(ProtocolName); 1292 auto *GV = TheModule.getGlobalVariable(Name); 1293 if (!GV) { 1294 // Emit a placeholder symbol. 1295 GV = new llvm::GlobalVariable(TheModule, ProtocolTy, false, 1296 llvm::GlobalValue::ExternalLinkage, nullptr, Name); 1297 GV->setAlignment(CGM.getPointerAlign().getQuantity()); 1298 } 1299 return llvm::ConstantExpr::getBitCast(GV, ProtocolPtrTy); 1300 } 1301 1302 /// Existing protocol references. 1303 llvm::StringMap<llvm::Constant*> ExistingProtocolRefs; 1304 1305 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF, 1306 const ObjCProtocolDecl *PD) override { 1307 auto Name = PD->getNameAsString(); 1308 auto *&Ref = ExistingProtocolRefs[Name]; 1309 if (!Ref) { 1310 auto *&Protocol = ExistingProtocols[Name]; 1311 if (!Protocol) 1312 Protocol = GenerateProtocolRef(PD); 1313 std::string RefName = SymbolForProtocolRef(Name); 1314 assert(!TheModule.getGlobalVariable(RefName)); 1315 // Emit a reference symbol. 1316 auto GV = new llvm::GlobalVariable(TheModule, ProtocolPtrTy, 1317 false, llvm::GlobalValue::LinkOnceODRLinkage, 1318 llvm::ConstantExpr::getBitCast(Protocol, ProtocolPtrTy), RefName); 1319 GV->setComdat(TheModule.getOrInsertComdat(RefName)); 1320 GV->setSection(sectionName<ProtocolReferenceSection>()); 1321 GV->setAlignment(CGM.getPointerAlign().getQuantity()); 1322 Ref = GV; 1323 } 1324 EmittedProtocolRef = true; 1325 return CGF.Builder.CreateAlignedLoad(Ref, CGM.getPointerAlign()); 1326 } 1327 1328 llvm::Constant *GenerateProtocolList(ArrayRef<llvm::Constant*> Protocols) { 1329 llvm::ArrayType *ProtocolArrayTy = llvm::ArrayType::get(ProtocolPtrTy, 1330 Protocols.size()); 1331 llvm::Constant * ProtocolArray = llvm::ConstantArray::get(ProtocolArrayTy, 1332 Protocols); 1333 ConstantInitBuilder builder(CGM); 1334 auto ProtocolBuilder = builder.beginStruct(); 1335 ProtocolBuilder.addNullPointer(PtrTy); 1336 ProtocolBuilder.addInt(SizeTy, Protocols.size()); 1337 ProtocolBuilder.add(ProtocolArray); 1338 return ProtocolBuilder.finishAndCreateGlobal(".objc_protocol_list", 1339 CGM.getPointerAlign(), false, llvm::GlobalValue::InternalLinkage); 1340 } 1341 1342 void GenerateProtocol(const ObjCProtocolDecl *PD) override { 1343 // Do nothing - we only emit referenced protocols. 1344 } 1345 llvm::Constant *GenerateProtocolRef(const ObjCProtocolDecl *PD) { 1346 std::string ProtocolName = PD->getNameAsString(); 1347 auto *&Protocol = ExistingProtocols[ProtocolName]; 1348 if (Protocol) 1349 return Protocol; 1350 1351 EmittedProtocol = true; 1352 1353 auto SymName = SymbolForProtocol(ProtocolName); 1354 auto *OldGV = TheModule.getGlobalVariable(SymName); 1355 1356 // Use the protocol definition, if there is one. 1357 if (const ObjCProtocolDecl *Def = PD->getDefinition()) 1358 PD = Def; 1359 else { 1360 // If there is no definition, then create an external linkage symbol and 1361 // hope that someone else fills it in for us (and fail to link if they 1362 // don't). 1363 assert(!OldGV); 1364 Protocol = new llvm::GlobalVariable(TheModule, ProtocolTy, 1365 /*isConstant*/false, 1366 llvm::GlobalValue::ExternalLinkage, nullptr, SymName); 1367 return Protocol; 1368 } 1369 1370 SmallVector<llvm::Constant*, 16> Protocols; 1371 for (const auto *PI : PD->protocols()) 1372 Protocols.push_back( 1373 llvm::ConstantExpr::getBitCast(GenerateProtocolRef(PI), 1374 ProtocolPtrTy)); 1375 llvm::Constant *ProtocolList = GenerateProtocolList(Protocols); 1376 1377 // Collect information about methods 1378 llvm::Constant *InstanceMethodList, *OptionalInstanceMethodList; 1379 llvm::Constant *ClassMethodList, *OptionalClassMethodList; 1380 EmitProtocolMethodList(PD->instance_methods(), InstanceMethodList, 1381 OptionalInstanceMethodList); 1382 EmitProtocolMethodList(PD->class_methods(), ClassMethodList, 1383 OptionalClassMethodList); 1384 1385 // The isa pointer must be set to a magic number so the runtime knows it's 1386 // the correct layout. 1387 ConstantInitBuilder builder(CGM); 1388 auto ProtocolBuilder = builder.beginStruct(); 1389 ProtocolBuilder.add(llvm::ConstantExpr::getIntToPtr( 1390 llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy)); 1391 ProtocolBuilder.add(MakeConstantString(ProtocolName)); 1392 ProtocolBuilder.add(ProtocolList); 1393 ProtocolBuilder.add(InstanceMethodList); 1394 ProtocolBuilder.add(ClassMethodList); 1395 ProtocolBuilder.add(OptionalInstanceMethodList); 1396 ProtocolBuilder.add(OptionalClassMethodList); 1397 // Required instance properties 1398 ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, false, false)); 1399 // Optional instance properties 1400 ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, false, true)); 1401 // Required class properties 1402 ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, true, false)); 1403 // Optional class properties 1404 ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, true, true)); 1405 1406 auto *GV = ProtocolBuilder.finishAndCreateGlobal(SymName, 1407 CGM.getPointerAlign(), false, llvm::GlobalValue::ExternalLinkage); 1408 GV->setSection(sectionName<ProtocolSection>()); 1409 GV->setComdat(TheModule.getOrInsertComdat(SymName)); 1410 if (OldGV) { 1411 OldGV->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GV, 1412 OldGV->getType())); 1413 OldGV->removeFromParent(); 1414 GV->setName(SymName); 1415 } 1416 Protocol = GV; 1417 return GV; 1418 } 1419 llvm::Constant *EnforceType(llvm::Constant *Val, llvm::Type *Ty) { 1420 if (Val->getType() == Ty) 1421 return Val; 1422 return llvm::ConstantExpr::getBitCast(Val, Ty); 1423 } 1424 llvm::Value *GetTypedSelector(CodeGenFunction &CGF, Selector Sel, 1425 const std::string &TypeEncoding) override { 1426 return GetConstantSelector(Sel, TypeEncoding); 1427 } 1428 llvm::Constant *GetTypeString(llvm::StringRef TypeEncoding) { 1429 if (TypeEncoding.empty()) 1430 return NULLPtr; 1431 std::string MangledTypes = TypeEncoding; 1432 std::replace(MangledTypes.begin(), MangledTypes.end(), 1433 '@', '\1'); 1434 std::string TypesVarName = ".objc_sel_types_" + MangledTypes; 1435 auto *TypesGlobal = TheModule.getGlobalVariable(TypesVarName); 1436 if (!TypesGlobal) { 1437 llvm::Constant *Init = llvm::ConstantDataArray::getString(VMContext, 1438 TypeEncoding); 1439 auto *GV = new llvm::GlobalVariable(TheModule, Init->getType(), 1440 true, llvm::GlobalValue::LinkOnceODRLinkage, Init, TypesVarName); 1441 GV->setComdat(TheModule.getOrInsertComdat(TypesVarName)); 1442 GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 1443 TypesGlobal = GV; 1444 } 1445 return llvm::ConstantExpr::getGetElementPtr(TypesGlobal->getValueType(), 1446 TypesGlobal, Zeros); 1447 } 1448 llvm::Constant *GetConstantSelector(Selector Sel, 1449 const std::string &TypeEncoding) override { 1450 // @ is used as a special character in symbol names (used for symbol 1451 // versioning), so mangle the name to not include it. Replace it with a 1452 // character that is not a valid type encoding character (and, being 1453 // non-printable, never will be!) 1454 std::string MangledTypes = TypeEncoding; 1455 std::replace(MangledTypes.begin(), MangledTypes.end(), 1456 '@', '\1'); 1457 auto SelVarName = (StringRef(".objc_selector_") + Sel.getAsString() + "_" + 1458 MangledTypes).str(); 1459 if (auto *GV = TheModule.getNamedGlobal(SelVarName)) 1460 return EnforceType(GV, SelectorTy); 1461 ConstantInitBuilder builder(CGM); 1462 auto SelBuilder = builder.beginStruct(); 1463 SelBuilder.add(ExportUniqueString(Sel.getAsString(), ".objc_sel_name_", 1464 true)); 1465 SelBuilder.add(GetTypeString(TypeEncoding)); 1466 auto *GV = SelBuilder.finishAndCreateGlobal(SelVarName, 1467 CGM.getPointerAlign(), false, llvm::GlobalValue::LinkOnceODRLinkage); 1468 GV->setComdat(TheModule.getOrInsertComdat(SelVarName)); 1469 GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 1470 GV->setSection(sectionName<SelectorSection>()); 1471 auto *SelVal = EnforceType(GV, SelectorTy); 1472 return SelVal; 1473 } 1474 llvm::StructType *emptyStruct = nullptr; 1475 1476 /// Return pointers to the start and end of a section. On ELF platforms, we 1477 /// use the __start_ and __stop_ symbols that GNU-compatible linkers will set 1478 /// to the start and end of section names, as long as those section names are 1479 /// valid identifiers and the symbols are referenced but not defined. On 1480 /// Windows, we use the fact that MSVC-compatible linkers will lexically sort 1481 /// by subsections and place everything that we want to reference in a middle 1482 /// subsection and then insert zero-sized symbols in subsections a and z. 1483 std::pair<llvm::Constant*,llvm::Constant*> 1484 GetSectionBounds(StringRef Section) { 1485 if (CGM.getTriple().isOSBinFormatCOFF()) { 1486 if (emptyStruct == nullptr) { 1487 emptyStruct = llvm::StructType::create(VMContext, ".objc_section_sentinel"); 1488 emptyStruct->setBody({}, /*isPacked*/true); 1489 } 1490 auto ZeroInit = llvm::Constant::getNullValue(emptyStruct); 1491 auto Sym = [&](StringRef Prefix, StringRef SecSuffix) { 1492 auto *Sym = new llvm::GlobalVariable(TheModule, emptyStruct, 1493 /*isConstant*/false, 1494 llvm::GlobalValue::LinkOnceODRLinkage, ZeroInit, Prefix + 1495 Section); 1496 Sym->setVisibility(llvm::GlobalValue::HiddenVisibility); 1497 Sym->setSection((Section + SecSuffix).str()); 1498 Sym->setComdat(TheModule.getOrInsertComdat((Prefix + 1499 Section).str())); 1500 Sym->setAlignment(CGM.getPointerAlign().getQuantity()); 1501 return Sym; 1502 }; 1503 return { Sym("__start_", "$a"), Sym("__stop", "$z") }; 1504 } 1505 auto *Start = new llvm::GlobalVariable(TheModule, PtrTy, 1506 /*isConstant*/false, 1507 llvm::GlobalValue::ExternalLinkage, nullptr, StringRef("__start_") + 1508 Section); 1509 Start->setVisibility(llvm::GlobalValue::HiddenVisibility); 1510 auto *Stop = new llvm::GlobalVariable(TheModule, PtrTy, 1511 /*isConstant*/false, 1512 llvm::GlobalValue::ExternalLinkage, nullptr, StringRef("__stop_") + 1513 Section); 1514 Stop->setVisibility(llvm::GlobalValue::HiddenVisibility); 1515 return { Start, Stop }; 1516 } 1517 CatchTypeInfo getCatchAllTypeInfo() override { 1518 return CGM.getCXXABI().getCatchAllTypeInfo(); 1519 } 1520 llvm::Function *ModuleInitFunction() override { 1521 llvm::Function *LoadFunction = llvm::Function::Create( 1522 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false), 1523 llvm::GlobalValue::LinkOnceODRLinkage, ".objcv2_load_function", 1524 &TheModule); 1525 LoadFunction->setVisibility(llvm::GlobalValue::HiddenVisibility); 1526 LoadFunction->setComdat(TheModule.getOrInsertComdat(".objcv2_load_function")); 1527 1528 llvm::BasicBlock *EntryBB = 1529 llvm::BasicBlock::Create(VMContext, "entry", LoadFunction); 1530 CGBuilderTy B(CGM, VMContext); 1531 B.SetInsertPoint(EntryBB); 1532 ConstantInitBuilder builder(CGM); 1533 auto InitStructBuilder = builder.beginStruct(); 1534 InitStructBuilder.addInt(Int64Ty, 0); 1535 auto §ionVec = CGM.getTriple().isOSBinFormatCOFF() ? PECOFFSectionsBaseNames : SectionsBaseNames; 1536 for (auto *s : sectionVec) { 1537 auto bounds = GetSectionBounds(s); 1538 InitStructBuilder.add(bounds.first); 1539 InitStructBuilder.add(bounds.second); 1540 } 1541 auto *InitStruct = InitStructBuilder.finishAndCreateGlobal(".objc_init", 1542 CGM.getPointerAlign(), false, llvm::GlobalValue::LinkOnceODRLinkage); 1543 InitStruct->setVisibility(llvm::GlobalValue::HiddenVisibility); 1544 InitStruct->setComdat(TheModule.getOrInsertComdat(".objc_init")); 1545 1546 CallRuntimeFunction(B, "__objc_load", {InitStruct});; 1547 B.CreateRetVoid(); 1548 // Make sure that the optimisers don't delete this function. 1549 CGM.addCompilerUsedGlobal(LoadFunction); 1550 // FIXME: Currently ELF only! 1551 // We have to do this by hand, rather than with @llvm.ctors, so that the 1552 // linker can remove the duplicate invocations. 1553 auto *InitVar = new llvm::GlobalVariable(TheModule, LoadFunction->getType(), 1554 /*isConstant*/true, llvm::GlobalValue::LinkOnceAnyLinkage, 1555 LoadFunction, ".objc_ctor"); 1556 // Check that this hasn't been renamed. This shouldn't happen, because 1557 // this function should be called precisely once. 1558 assert(InitVar->getName() == ".objc_ctor"); 1559 // In Windows, initialisers are sorted by the suffix. XCL is for library 1560 // initialisers, which run before user initialisers. We are running 1561 // Objective-C loads at the end of library load. This means +load methods 1562 // will run before any other static constructors, but that static 1563 // constructors can see a fully initialised Objective-C state. 1564 if (CGM.getTriple().isOSBinFormatCOFF()) 1565 InitVar->setSection(".CRT$XCLz"); 1566 else 1567 { 1568 if (CGM.getCodeGenOpts().UseInitArray) 1569 InitVar->setSection(".init_array"); 1570 else 1571 InitVar->setSection(".ctors"); 1572 } 1573 InitVar->setVisibility(llvm::GlobalValue::HiddenVisibility); 1574 InitVar->setComdat(TheModule.getOrInsertComdat(".objc_ctor")); 1575 CGM.addUsedGlobal(InitVar); 1576 for (auto *C : Categories) { 1577 auto *Cat = cast<llvm::GlobalVariable>(C->stripPointerCasts()); 1578 Cat->setSection(sectionName<CategorySection>()); 1579 CGM.addUsedGlobal(Cat); 1580 } 1581 auto createNullGlobal = [&](StringRef Name, ArrayRef<llvm::Constant*> Init, 1582 StringRef Section) { 1583 auto nullBuilder = builder.beginStruct(); 1584 for (auto *F : Init) 1585 nullBuilder.add(F); 1586 auto GV = nullBuilder.finishAndCreateGlobal(Name, CGM.getPointerAlign(), 1587 false, llvm::GlobalValue::LinkOnceODRLinkage); 1588 GV->setSection(Section); 1589 GV->setComdat(TheModule.getOrInsertComdat(Name)); 1590 GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 1591 CGM.addUsedGlobal(GV); 1592 return GV; 1593 }; 1594 for (auto clsAlias : ClassAliases) 1595 createNullGlobal(std::string(".objc_class_alias") + 1596 clsAlias.second, { MakeConstantString(clsAlias.second), 1597 GetClassVar(clsAlias.first) }, sectionName<ClassAliasSection>()); 1598 // On ELF platforms, add a null value for each special section so that we 1599 // can always guarantee that the _start and _stop symbols will exist and be 1600 // meaningful. This is not required on COFF platforms, where our start and 1601 // stop symbols will create the section. 1602 if (!CGM.getTriple().isOSBinFormatCOFF()) { 1603 createNullGlobal(".objc_null_selector", {NULLPtr, NULLPtr}, 1604 sectionName<SelectorSection>()); 1605 if (Categories.empty()) 1606 createNullGlobal(".objc_null_category", {NULLPtr, NULLPtr, 1607 NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr}, 1608 sectionName<CategorySection>()); 1609 if (!EmittedClass) { 1610 createNullGlobal(".objc_null_cls_init_ref", NULLPtr, 1611 sectionName<ClassSection>()); 1612 createNullGlobal(".objc_null_class_ref", { NULLPtr, NULLPtr }, 1613 sectionName<ClassReferenceSection>()); 1614 } 1615 if (!EmittedProtocol) 1616 createNullGlobal(".objc_null_protocol", {NULLPtr, NULLPtr, NULLPtr, 1617 NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr, 1618 NULLPtr}, sectionName<ProtocolSection>()); 1619 if (!EmittedProtocolRef) 1620 createNullGlobal(".objc_null_protocol_ref", {NULLPtr}, 1621 sectionName<ProtocolReferenceSection>()); 1622 if (ClassAliases.empty()) 1623 createNullGlobal(".objc_null_class_alias", { NULLPtr, NULLPtr }, 1624 sectionName<ClassAliasSection>()); 1625 if (ConstantStrings.empty()) { 1626 auto i32Zero = llvm::ConstantInt::get(Int32Ty, 0); 1627 createNullGlobal(".objc_null_constant_string", { NULLPtr, i32Zero, 1628 i32Zero, i32Zero, i32Zero, NULLPtr }, 1629 sectionName<ConstantStringSection>()); 1630 } 1631 } 1632 ConstantStrings.clear(); 1633 Categories.clear(); 1634 Classes.clear(); 1635 1636 if (EarlyInitList.size() > 0) { 1637 auto *Init = llvm::Function::Create(llvm::FunctionType::get(CGM.VoidTy, 1638 {}), llvm::GlobalValue::InternalLinkage, ".objc_early_init", 1639 &CGM.getModule()); 1640 llvm::IRBuilder<> b(llvm::BasicBlock::Create(CGM.getLLVMContext(), "entry", 1641 Init)); 1642 for (const auto &lateInit : EarlyInitList) { 1643 auto *global = TheModule.getGlobalVariable(lateInit.first); 1644 if (global) { 1645 b.CreateAlignedStore(global, 1646 b.CreateStructGEP(lateInit.second.first, lateInit.second.second), CGM.getPointerAlign().getQuantity()); 1647 } 1648 } 1649 b.CreateRetVoid(); 1650 // We can't use the normal LLVM global initialisation array, because we 1651 // need to specify that this runs early in library initialisation. 1652 auto *InitVar = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), 1653 /*isConstant*/true, llvm::GlobalValue::InternalLinkage, 1654 Init, ".objc_early_init_ptr"); 1655 InitVar->setSection(".CRT$XCLb"); 1656 CGM.addUsedGlobal(InitVar); 1657 } 1658 return nullptr; 1659 } 1660 /// In the v2 ABI, ivar offset variables use the type encoding in their name 1661 /// to trigger linker failures if the types don't match. 1662 std::string GetIVarOffsetVariableName(const ObjCInterfaceDecl *ID, 1663 const ObjCIvarDecl *Ivar) override { 1664 std::string TypeEncoding; 1665 CGM.getContext().getObjCEncodingForType(Ivar->getType(), TypeEncoding); 1666 // Prevent the @ from being interpreted as a symbol version. 1667 std::replace(TypeEncoding.begin(), TypeEncoding.end(), 1668 '@', '\1'); 1669 const std::string Name = "__objc_ivar_offset_" + ID->getNameAsString() 1670 + '.' + Ivar->getNameAsString() + '.' + TypeEncoding; 1671 return Name; 1672 } 1673 llvm::Value *EmitIvarOffset(CodeGenFunction &CGF, 1674 const ObjCInterfaceDecl *Interface, 1675 const ObjCIvarDecl *Ivar) override { 1676 const std::string Name = GetIVarOffsetVariableName(Ivar->getContainingInterface(), Ivar); 1677 llvm::GlobalVariable *IvarOffsetPointer = TheModule.getNamedGlobal(Name); 1678 if (!IvarOffsetPointer) 1679 IvarOffsetPointer = new llvm::GlobalVariable(TheModule, IntTy, false, 1680 llvm::GlobalValue::ExternalLinkage, nullptr, Name); 1681 CharUnits Align = CGM.getIntAlign(); 1682 llvm::Value *Offset = CGF.Builder.CreateAlignedLoad(IvarOffsetPointer, Align); 1683 if (Offset->getType() != PtrDiffTy) 1684 Offset = CGF.Builder.CreateZExtOrBitCast(Offset, PtrDiffTy); 1685 return Offset; 1686 } 1687 void GenerateClass(const ObjCImplementationDecl *OID) override { 1688 ASTContext &Context = CGM.getContext(); 1689 bool IsCOFF = CGM.getTriple().isOSBinFormatCOFF(); 1690 1691 // Get the class name 1692 ObjCInterfaceDecl *classDecl = 1693 const_cast<ObjCInterfaceDecl *>(OID->getClassInterface()); 1694 std::string className = classDecl->getNameAsString(); 1695 auto *classNameConstant = MakeConstantString(className); 1696 1697 ConstantInitBuilder builder(CGM); 1698 auto metaclassFields = builder.beginStruct(); 1699 // struct objc_class *isa; 1700 metaclassFields.addNullPointer(PtrTy); 1701 // struct objc_class *super_class; 1702 metaclassFields.addNullPointer(PtrTy); 1703 // const char *name; 1704 metaclassFields.add(classNameConstant); 1705 // long version; 1706 metaclassFields.addInt(LongTy, 0); 1707 // unsigned long info; 1708 // objc_class_flag_meta 1709 metaclassFields.addInt(LongTy, 1); 1710 // long instance_size; 1711 // Setting this to zero is consistent with the older ABI, but it might be 1712 // more sensible to set this to sizeof(struct objc_class) 1713 metaclassFields.addInt(LongTy, 0); 1714 // struct objc_ivar_list *ivars; 1715 metaclassFields.addNullPointer(PtrTy); 1716 // struct objc_method_list *methods 1717 // FIXME: Almost identical code is copied and pasted below for the 1718 // class, but refactoring it cleanly requires C++14 generic lambdas. 1719 if (OID->classmeth_begin() == OID->classmeth_end()) 1720 metaclassFields.addNullPointer(PtrTy); 1721 else { 1722 SmallVector<ObjCMethodDecl*, 16> ClassMethods; 1723 ClassMethods.insert(ClassMethods.begin(), OID->classmeth_begin(), 1724 OID->classmeth_end()); 1725 metaclassFields.addBitCast( 1726 GenerateMethodList(className, "", ClassMethods, true), 1727 PtrTy); 1728 } 1729 // void *dtable; 1730 metaclassFields.addNullPointer(PtrTy); 1731 // IMP cxx_construct; 1732 metaclassFields.addNullPointer(PtrTy); 1733 // IMP cxx_destruct; 1734 metaclassFields.addNullPointer(PtrTy); 1735 // struct objc_class *subclass_list 1736 metaclassFields.addNullPointer(PtrTy); 1737 // struct objc_class *sibling_class 1738 metaclassFields.addNullPointer(PtrTy); 1739 // struct objc_protocol_list *protocols; 1740 metaclassFields.addNullPointer(PtrTy); 1741 // struct reference_list *extra_data; 1742 metaclassFields.addNullPointer(PtrTy); 1743 // long abi_version; 1744 metaclassFields.addInt(LongTy, 0); 1745 // struct objc_property_list *properties 1746 metaclassFields.add(GeneratePropertyList(OID, classDecl, /*isClassProperty*/true)); 1747 1748 auto *metaclass = metaclassFields.finishAndCreateGlobal( 1749 ManglePublicSymbol("OBJC_METACLASS_") + className, 1750 CGM.getPointerAlign()); 1751 1752 auto classFields = builder.beginStruct(); 1753 // struct objc_class *isa; 1754 classFields.add(metaclass); 1755 // struct objc_class *super_class; 1756 // Get the superclass name. 1757 const ObjCInterfaceDecl * SuperClassDecl = 1758 OID->getClassInterface()->getSuperClass(); 1759 llvm::Constant *SuperClass = nullptr; 1760 if (SuperClassDecl) { 1761 auto SuperClassName = SymbolForClass(SuperClassDecl->getNameAsString()); 1762 SuperClass = TheModule.getNamedGlobal(SuperClassName); 1763 if (!SuperClass) 1764 { 1765 SuperClass = new llvm::GlobalVariable(TheModule, PtrTy, false, 1766 llvm::GlobalValue::ExternalLinkage, nullptr, SuperClassName); 1767 if (IsCOFF) { 1768 auto Storage = llvm::GlobalValue::DefaultStorageClass; 1769 if (SuperClassDecl->hasAttr<DLLImportAttr>()) 1770 Storage = llvm::GlobalValue::DLLImportStorageClass; 1771 else if (SuperClassDecl->hasAttr<DLLExportAttr>()) 1772 Storage = llvm::GlobalValue::DLLExportStorageClass; 1773 1774 cast<llvm::GlobalValue>(SuperClass)->setDLLStorageClass(Storage); 1775 } 1776 } 1777 if (!IsCOFF) 1778 classFields.add(llvm::ConstantExpr::getBitCast(SuperClass, PtrTy)); 1779 else 1780 classFields.addNullPointer(PtrTy); 1781 } else 1782 classFields.addNullPointer(PtrTy); 1783 // const char *name; 1784 classFields.add(classNameConstant); 1785 // long version; 1786 classFields.addInt(LongTy, 0); 1787 // unsigned long info; 1788 // !objc_class_flag_meta 1789 classFields.addInt(LongTy, 0); 1790 // long instance_size; 1791 int superInstanceSize = !SuperClassDecl ? 0 : 1792 Context.getASTObjCInterfaceLayout(SuperClassDecl).getSize().getQuantity(); 1793 // Instance size is negative for classes that have not yet had their ivar 1794 // layout calculated. 1795 classFields.addInt(LongTy, 1796 0 - (Context.getASTObjCImplementationLayout(OID).getSize().getQuantity() - 1797 superInstanceSize)); 1798 1799 if (classDecl->all_declared_ivar_begin() == nullptr) 1800 classFields.addNullPointer(PtrTy); 1801 else { 1802 int ivar_count = 0; 1803 for (const ObjCIvarDecl *IVD = classDecl->all_declared_ivar_begin(); IVD; 1804 IVD = IVD->getNextIvar()) ivar_count++; 1805 llvm::DataLayout td(&TheModule); 1806 // struct objc_ivar_list *ivars; 1807 ConstantInitBuilder b(CGM); 1808 auto ivarListBuilder = b.beginStruct(); 1809 // int count; 1810 ivarListBuilder.addInt(IntTy, ivar_count); 1811 // size_t size; 1812 llvm::StructType *ObjCIvarTy = llvm::StructType::get( 1813 PtrToInt8Ty, 1814 PtrToInt8Ty, 1815 PtrToInt8Ty, 1816 Int32Ty, 1817 Int32Ty); 1818 ivarListBuilder.addInt(SizeTy, td.getTypeSizeInBits(ObjCIvarTy) / 1819 CGM.getContext().getCharWidth()); 1820 // struct objc_ivar ivars[] 1821 auto ivarArrayBuilder = ivarListBuilder.beginArray(); 1822 for (const ObjCIvarDecl *IVD = classDecl->all_declared_ivar_begin(); IVD; 1823 IVD = IVD->getNextIvar()) { 1824 auto ivarTy = IVD->getType(); 1825 auto ivarBuilder = ivarArrayBuilder.beginStruct(); 1826 // const char *name; 1827 ivarBuilder.add(MakeConstantString(IVD->getNameAsString())); 1828 // const char *type; 1829 std::string TypeStr; 1830 //Context.getObjCEncodingForType(ivarTy, TypeStr, IVD, true); 1831 Context.getObjCEncodingForMethodParameter(Decl::OBJC_TQ_None, ivarTy, TypeStr, true); 1832 ivarBuilder.add(MakeConstantString(TypeStr)); 1833 // int *offset; 1834 uint64_t BaseOffset = ComputeIvarBaseOffset(CGM, OID, IVD); 1835 uint64_t Offset = BaseOffset - superInstanceSize; 1836 llvm::Constant *OffsetValue = llvm::ConstantInt::get(IntTy, Offset); 1837 std::string OffsetName = GetIVarOffsetVariableName(classDecl, IVD); 1838 llvm::GlobalVariable *OffsetVar = TheModule.getGlobalVariable(OffsetName); 1839 if (OffsetVar) 1840 OffsetVar->setInitializer(OffsetValue); 1841 else 1842 OffsetVar = new llvm::GlobalVariable(TheModule, IntTy, 1843 false, llvm::GlobalValue::ExternalLinkage, 1844 OffsetValue, OffsetName); 1845 auto ivarVisibility = 1846 (IVD->getAccessControl() == ObjCIvarDecl::Private || 1847 IVD->getAccessControl() == ObjCIvarDecl::Package || 1848 classDecl->getVisibility() == HiddenVisibility) ? 1849 llvm::GlobalValue::HiddenVisibility : 1850 llvm::GlobalValue::DefaultVisibility; 1851 OffsetVar->setVisibility(ivarVisibility); 1852 ivarBuilder.add(OffsetVar); 1853 // Ivar size 1854 ivarBuilder.addInt(Int32Ty, 1855 CGM.getContext().getTypeSizeInChars(ivarTy).getQuantity()); 1856 // Alignment will be stored as a base-2 log of the alignment. 1857 int align = llvm::Log2_32(Context.getTypeAlignInChars(ivarTy).getQuantity()); 1858 // Objects that require more than 2^64-byte alignment should be impossible! 1859 assert(align < 64); 1860 // uint32_t flags; 1861 // Bits 0-1 are ownership. 1862 // Bit 2 indicates an extended type encoding 1863 // Bits 3-8 contain log2(aligment) 1864 ivarBuilder.addInt(Int32Ty, 1865 (align << 3) | (1<<2) | 1866 FlagsForOwnership(ivarTy.getQualifiers().getObjCLifetime())); 1867 ivarBuilder.finishAndAddTo(ivarArrayBuilder); 1868 } 1869 ivarArrayBuilder.finishAndAddTo(ivarListBuilder); 1870 auto ivarList = ivarListBuilder.finishAndCreateGlobal(".objc_ivar_list", 1871 CGM.getPointerAlign(), /*constant*/ false, 1872 llvm::GlobalValue::PrivateLinkage); 1873 classFields.add(ivarList); 1874 } 1875 // struct objc_method_list *methods 1876 SmallVector<const ObjCMethodDecl*, 16> InstanceMethods; 1877 InstanceMethods.insert(InstanceMethods.begin(), OID->instmeth_begin(), 1878 OID->instmeth_end()); 1879 for (auto *propImpl : OID->property_impls()) 1880 if (propImpl->getPropertyImplementation() == 1881 ObjCPropertyImplDecl::Synthesize) { 1882 ObjCPropertyDecl *prop = propImpl->getPropertyDecl(); 1883 auto addIfExists = [&](const ObjCMethodDecl* OMD) { 1884 if (OMD) 1885 InstanceMethods.push_back(OMD); 1886 }; 1887 addIfExists(prop->getGetterMethodDecl()); 1888 addIfExists(prop->getSetterMethodDecl()); 1889 } 1890 1891 if (InstanceMethods.size() == 0) 1892 classFields.addNullPointer(PtrTy); 1893 else 1894 classFields.addBitCast( 1895 GenerateMethodList(className, "", InstanceMethods, false), 1896 PtrTy); 1897 // void *dtable; 1898 classFields.addNullPointer(PtrTy); 1899 // IMP cxx_construct; 1900 classFields.addNullPointer(PtrTy); 1901 // IMP cxx_destruct; 1902 classFields.addNullPointer(PtrTy); 1903 // struct objc_class *subclass_list 1904 classFields.addNullPointer(PtrTy); 1905 // struct objc_class *sibling_class 1906 classFields.addNullPointer(PtrTy); 1907 // struct objc_protocol_list *protocols; 1908 SmallVector<llvm::Constant*, 16> Protocols; 1909 for (const auto *I : classDecl->protocols()) 1910 Protocols.push_back( 1911 llvm::ConstantExpr::getBitCast(GenerateProtocolRef(I), 1912 ProtocolPtrTy)); 1913 if (Protocols.empty()) 1914 classFields.addNullPointer(PtrTy); 1915 else 1916 classFields.add(GenerateProtocolList(Protocols)); 1917 // struct reference_list *extra_data; 1918 classFields.addNullPointer(PtrTy); 1919 // long abi_version; 1920 classFields.addInt(LongTy, 0); 1921 // struct objc_property_list *properties 1922 classFields.add(GeneratePropertyList(OID, classDecl)); 1923 1924 auto *classStruct = 1925 classFields.finishAndCreateGlobal(SymbolForClass(className), 1926 CGM.getPointerAlign(), false, llvm::GlobalValue::ExternalLinkage); 1927 1928 auto *classRefSymbol = GetClassVar(className); 1929 classRefSymbol->setSection(sectionName<ClassReferenceSection>()); 1930 classRefSymbol->setInitializer(llvm::ConstantExpr::getBitCast(classStruct, IdTy)); 1931 1932 if (IsCOFF) { 1933 // we can't import a class struct. 1934 if (OID->getClassInterface()->hasAttr<DLLExportAttr>()) { 1935 cast<llvm::GlobalValue>(classStruct)->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); 1936 cast<llvm::GlobalValue>(classRefSymbol)->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); 1937 } 1938 1939 if (SuperClass) { 1940 std::pair<llvm::Constant*, int> v{classStruct, 1}; 1941 EarlyInitList.emplace_back(SuperClass->getName(), std::move(v)); 1942 } 1943 1944 } 1945 1946 1947 // Resolve the class aliases, if they exist. 1948 // FIXME: Class pointer aliases shouldn't exist! 1949 if (ClassPtrAlias) { 1950 ClassPtrAlias->replaceAllUsesWith( 1951 llvm::ConstantExpr::getBitCast(classStruct, IdTy)); 1952 ClassPtrAlias->eraseFromParent(); 1953 ClassPtrAlias = nullptr; 1954 } 1955 if (auto Placeholder = 1956 TheModule.getNamedGlobal(SymbolForClass(className))) 1957 if (Placeholder != classStruct) { 1958 Placeholder->replaceAllUsesWith( 1959 llvm::ConstantExpr::getBitCast(classStruct, Placeholder->getType())); 1960 Placeholder->eraseFromParent(); 1961 classStruct->setName(SymbolForClass(className)); 1962 } 1963 if (MetaClassPtrAlias) { 1964 MetaClassPtrAlias->replaceAllUsesWith( 1965 llvm::ConstantExpr::getBitCast(metaclass, IdTy)); 1966 MetaClassPtrAlias->eraseFromParent(); 1967 MetaClassPtrAlias = nullptr; 1968 } 1969 assert(classStruct->getName() == SymbolForClass(className)); 1970 1971 auto classInitRef = new llvm::GlobalVariable(TheModule, 1972 classStruct->getType(), false, llvm::GlobalValue::ExternalLinkage, 1973 classStruct, ManglePublicSymbol("OBJC_INIT_CLASS_") + className); 1974 classInitRef->setSection(sectionName<ClassSection>()); 1975 CGM.addUsedGlobal(classInitRef); 1976 1977 EmittedClass = true; 1978 } 1979 public: 1980 CGObjCGNUstep2(CodeGenModule &Mod) : CGObjCGNUstep(Mod, 10, 4, 2) { 1981 MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy, 1982 PtrToObjCSuperTy, SelectorTy); 1983 // struct objc_property 1984 // { 1985 // const char *name; 1986 // const char *attributes; 1987 // const char *type; 1988 // SEL getter; 1989 // SEL setter; 1990 // } 1991 PropertyMetadataTy = 1992 llvm::StructType::get(CGM.getLLVMContext(), 1993 { PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty }); 1994 } 1995 1996 }; 1997 1998 const char *const CGObjCGNUstep2::SectionsBaseNames[8] = 1999 { 2000 "__objc_selectors", 2001 "__objc_classes", 2002 "__objc_class_refs", 2003 "__objc_cats", 2004 "__objc_protocols", 2005 "__objc_protocol_refs", 2006 "__objc_class_aliases", 2007 "__objc_constant_string" 2008 }; 2009 2010 const char *const CGObjCGNUstep2::PECOFFSectionsBaseNames[8] = 2011 { 2012 ".objcrt$SEL", 2013 ".objcrt$CLS", 2014 ".objcrt$CLR", 2015 ".objcrt$CAT", 2016 ".objcrt$PCL", 2017 ".objcrt$PCR", 2018 ".objcrt$CAL", 2019 ".objcrt$STR" 2020 }; 2021 2022 /// Support for the ObjFW runtime. 2023 class CGObjCObjFW: public CGObjCGNU { 2024 protected: 2025 /// The GCC ABI message lookup function. Returns an IMP pointing to the 2026 /// method implementation for this message. 2027 LazyRuntimeFunction MsgLookupFn; 2028 /// stret lookup function. While this does not seem to make sense at the 2029 /// first look, this is required to call the correct forwarding function. 2030 LazyRuntimeFunction MsgLookupFnSRet; 2031 /// The GCC ABI superclass message lookup function. Takes a pointer to a 2032 /// structure describing the receiver and the class, and a selector as 2033 /// arguments. Returns the IMP for the corresponding method. 2034 LazyRuntimeFunction MsgLookupSuperFn, MsgLookupSuperFnSRet; 2035 2036 llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver, 2037 llvm::Value *cmd, llvm::MDNode *node, 2038 MessageSendInfo &MSI) override { 2039 CGBuilderTy &Builder = CGF.Builder; 2040 llvm::Value *args[] = { 2041 EnforceType(Builder, Receiver, IdTy), 2042 EnforceType(Builder, cmd, SelectorTy) }; 2043 2044 llvm::CallBase *imp; 2045 if (CGM.ReturnTypeUsesSRet(MSI.CallInfo)) 2046 imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFnSRet, args); 2047 else 2048 imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFn, args); 2049 2050 imp->setMetadata(msgSendMDKind, node); 2051 return imp; 2052 } 2053 2054 llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper, 2055 llvm::Value *cmd, MessageSendInfo &MSI) override { 2056 CGBuilderTy &Builder = CGF.Builder; 2057 llvm::Value *lookupArgs[] = { 2058 EnforceType(Builder, ObjCSuper.getPointer(), PtrToObjCSuperTy), cmd, 2059 }; 2060 2061 if (CGM.ReturnTypeUsesSRet(MSI.CallInfo)) 2062 return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFnSRet, lookupArgs); 2063 else 2064 return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs); 2065 } 2066 2067 llvm::Value *GetClassNamed(CodeGenFunction &CGF, const std::string &Name, 2068 bool isWeak) override { 2069 if (isWeak) 2070 return CGObjCGNU::GetClassNamed(CGF, Name, isWeak); 2071 2072 EmitClassRef(Name); 2073 std::string SymbolName = "_OBJC_CLASS_" + Name; 2074 llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(SymbolName); 2075 if (!ClassSymbol) 2076 ClassSymbol = new llvm::GlobalVariable(TheModule, LongTy, false, 2077 llvm::GlobalValue::ExternalLinkage, 2078 nullptr, SymbolName); 2079 return ClassSymbol; 2080 } 2081 2082 public: 2083 CGObjCObjFW(CodeGenModule &Mod): CGObjCGNU(Mod, 9, 3) { 2084 // IMP objc_msg_lookup(id, SEL); 2085 MsgLookupFn.init(&CGM, "objc_msg_lookup", IMPTy, IdTy, SelectorTy); 2086 MsgLookupFnSRet.init(&CGM, "objc_msg_lookup_stret", IMPTy, IdTy, 2087 SelectorTy); 2088 // IMP objc_msg_lookup_super(struct objc_super*, SEL); 2089 MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy, 2090 PtrToObjCSuperTy, SelectorTy); 2091 MsgLookupSuperFnSRet.init(&CGM, "objc_msg_lookup_super_stret", IMPTy, 2092 PtrToObjCSuperTy, SelectorTy); 2093 } 2094 }; 2095 } // end anonymous namespace 2096 2097 /// Emits a reference to a dummy variable which is emitted with each class. 2098 /// This ensures that a linker error will be generated when trying to link 2099 /// together modules where a referenced class is not defined. 2100 void CGObjCGNU::EmitClassRef(const std::string &className) { 2101 std::string symbolRef = "__objc_class_ref_" + className; 2102 // Don't emit two copies of the same symbol 2103 if (TheModule.getGlobalVariable(symbolRef)) 2104 return; 2105 std::string symbolName = "__objc_class_name_" + className; 2106 llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(symbolName); 2107 if (!ClassSymbol) { 2108 ClassSymbol = new llvm::GlobalVariable(TheModule, LongTy, false, 2109 llvm::GlobalValue::ExternalLinkage, 2110 nullptr, symbolName); 2111 } 2112 new llvm::GlobalVariable(TheModule, ClassSymbol->getType(), true, 2113 llvm::GlobalValue::WeakAnyLinkage, ClassSymbol, symbolRef); 2114 } 2115 2116 CGObjCGNU::CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion, 2117 unsigned protocolClassVersion, unsigned classABI) 2118 : CGObjCRuntime(cgm), TheModule(CGM.getModule()), 2119 VMContext(cgm.getLLVMContext()), ClassPtrAlias(nullptr), 2120 MetaClassPtrAlias(nullptr), RuntimeVersion(runtimeABIVersion), 2121 ProtocolVersion(protocolClassVersion), ClassABIVersion(classABI) { 2122 2123 msgSendMDKind = VMContext.getMDKindID("GNUObjCMessageSend"); 2124 usesSEHExceptions = 2125 cgm.getContext().getTargetInfo().getTriple().isWindowsMSVCEnvironment(); 2126 2127 CodeGenTypes &Types = CGM.getTypes(); 2128 IntTy = cast<llvm::IntegerType>( 2129 Types.ConvertType(CGM.getContext().IntTy)); 2130 LongTy = cast<llvm::IntegerType>( 2131 Types.ConvertType(CGM.getContext().LongTy)); 2132 SizeTy = cast<llvm::IntegerType>( 2133 Types.ConvertType(CGM.getContext().getSizeType())); 2134 PtrDiffTy = cast<llvm::IntegerType>( 2135 Types.ConvertType(CGM.getContext().getPointerDiffType())); 2136 BoolTy = CGM.getTypes().ConvertType(CGM.getContext().BoolTy); 2137 2138 Int8Ty = llvm::Type::getInt8Ty(VMContext); 2139 // C string type. Used in lots of places. 2140 PtrToInt8Ty = llvm::PointerType::getUnqual(Int8Ty); 2141 ProtocolPtrTy = llvm::PointerType::getUnqual( 2142 Types.ConvertType(CGM.getContext().getObjCProtoType())); 2143 2144 Zeros[0] = llvm::ConstantInt::get(LongTy, 0); 2145 Zeros[1] = Zeros[0]; 2146 NULLPtr = llvm::ConstantPointerNull::get(PtrToInt8Ty); 2147 // Get the selector Type. 2148 QualType selTy = CGM.getContext().getObjCSelType(); 2149 if (QualType() == selTy) { 2150 SelectorTy = PtrToInt8Ty; 2151 } else { 2152 SelectorTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(selTy)); 2153 } 2154 2155 PtrToIntTy = llvm::PointerType::getUnqual(IntTy); 2156 PtrTy = PtrToInt8Ty; 2157 2158 Int32Ty = llvm::Type::getInt32Ty(VMContext); 2159 Int64Ty = llvm::Type::getInt64Ty(VMContext); 2160 2161 IntPtrTy = 2162 CGM.getDataLayout().getPointerSizeInBits() == 32 ? Int32Ty : Int64Ty; 2163 2164 // Object type 2165 QualType UnqualIdTy = CGM.getContext().getObjCIdType(); 2166 ASTIdTy = CanQualType(); 2167 if (UnqualIdTy != QualType()) { 2168 ASTIdTy = CGM.getContext().getCanonicalType(UnqualIdTy); 2169 IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy)); 2170 } else { 2171 IdTy = PtrToInt8Ty; 2172 } 2173 PtrToIdTy = llvm::PointerType::getUnqual(IdTy); 2174 ProtocolTy = llvm::StructType::get(IdTy, 2175 PtrToInt8Ty, // name 2176 PtrToInt8Ty, // protocols 2177 PtrToInt8Ty, // instance methods 2178 PtrToInt8Ty, // class methods 2179 PtrToInt8Ty, // optional instance methods 2180 PtrToInt8Ty, // optional class methods 2181 PtrToInt8Ty, // properties 2182 PtrToInt8Ty);// optional properties 2183 2184 // struct objc_property_gsv1 2185 // { 2186 // const char *name; 2187 // char attributes; 2188 // char attributes2; 2189 // char unused1; 2190 // char unused2; 2191 // const char *getter_name; 2192 // const char *getter_types; 2193 // const char *setter_name; 2194 // const char *setter_types; 2195 // } 2196 PropertyMetadataTy = llvm::StructType::get(CGM.getLLVMContext(), { 2197 PtrToInt8Ty, Int8Ty, Int8Ty, Int8Ty, Int8Ty, PtrToInt8Ty, PtrToInt8Ty, 2198 PtrToInt8Ty, PtrToInt8Ty }); 2199 2200 ObjCSuperTy = llvm::StructType::get(IdTy, IdTy); 2201 PtrToObjCSuperTy = llvm::PointerType::getUnqual(ObjCSuperTy); 2202 2203 llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext); 2204 2205 // void objc_exception_throw(id); 2206 ExceptionThrowFn.init(&CGM, "objc_exception_throw", VoidTy, IdTy); 2207 ExceptionReThrowFn.init(&CGM, "objc_exception_throw", VoidTy, IdTy); 2208 // int objc_sync_enter(id); 2209 SyncEnterFn.init(&CGM, "objc_sync_enter", IntTy, IdTy); 2210 // int objc_sync_exit(id); 2211 SyncExitFn.init(&CGM, "objc_sync_exit", IntTy, IdTy); 2212 2213 // void objc_enumerationMutation (id) 2214 EnumerationMutationFn.init(&CGM, "objc_enumerationMutation", VoidTy, IdTy); 2215 2216 // id objc_getProperty(id, SEL, ptrdiff_t, BOOL) 2217 GetPropertyFn.init(&CGM, "objc_getProperty", IdTy, IdTy, SelectorTy, 2218 PtrDiffTy, BoolTy); 2219 // void objc_setProperty(id, SEL, ptrdiff_t, id, BOOL, BOOL) 2220 SetPropertyFn.init(&CGM, "objc_setProperty", VoidTy, IdTy, SelectorTy, 2221 PtrDiffTy, IdTy, BoolTy, BoolTy); 2222 // void objc_setPropertyStruct(void*, void*, ptrdiff_t, BOOL, BOOL) 2223 GetStructPropertyFn.init(&CGM, "objc_getPropertyStruct", VoidTy, PtrTy, PtrTy, 2224 PtrDiffTy, BoolTy, BoolTy); 2225 // void objc_setPropertyStruct(void*, void*, ptrdiff_t, BOOL, BOOL) 2226 SetStructPropertyFn.init(&CGM, "objc_setPropertyStruct", VoidTy, PtrTy, PtrTy, 2227 PtrDiffTy, BoolTy, BoolTy); 2228 2229 // IMP type 2230 llvm::Type *IMPArgs[] = { IdTy, SelectorTy }; 2231 IMPTy = llvm::PointerType::getUnqual(llvm::FunctionType::get(IdTy, IMPArgs, 2232 true)); 2233 2234 const LangOptions &Opts = CGM.getLangOpts(); 2235 if ((Opts.getGC() != LangOptions::NonGC) || Opts.ObjCAutoRefCount) 2236 RuntimeVersion = 10; 2237 2238 // Don't bother initialising the GC stuff unless we're compiling in GC mode 2239 if (Opts.getGC() != LangOptions::NonGC) { 2240 // This is a bit of an hack. We should sort this out by having a proper 2241 // CGObjCGNUstep subclass for GC, but we may want to really support the old 2242 // ABI and GC added in ObjectiveC2.framework, so we fudge it a bit for now 2243 // Get selectors needed in GC mode 2244 RetainSel = GetNullarySelector("retain", CGM.getContext()); 2245 ReleaseSel = GetNullarySelector("release", CGM.getContext()); 2246 AutoreleaseSel = GetNullarySelector("autorelease", CGM.getContext()); 2247 2248 // Get functions needed in GC mode 2249 2250 // id objc_assign_ivar(id, id, ptrdiff_t); 2251 IvarAssignFn.init(&CGM, "objc_assign_ivar", IdTy, IdTy, IdTy, PtrDiffTy); 2252 // id objc_assign_strongCast (id, id*) 2253 StrongCastAssignFn.init(&CGM, "objc_assign_strongCast", IdTy, IdTy, 2254 PtrToIdTy); 2255 // id objc_assign_global(id, id*); 2256 GlobalAssignFn.init(&CGM, "objc_assign_global", IdTy, IdTy, PtrToIdTy); 2257 // id objc_assign_weak(id, id*); 2258 WeakAssignFn.init(&CGM, "objc_assign_weak", IdTy, IdTy, PtrToIdTy); 2259 // id objc_read_weak(id*); 2260 WeakReadFn.init(&CGM, "objc_read_weak", IdTy, PtrToIdTy); 2261 // void *objc_memmove_collectable(void*, void *, size_t); 2262 MemMoveFn.init(&CGM, "objc_memmove_collectable", PtrTy, PtrTy, PtrTy, 2263 SizeTy); 2264 } 2265 } 2266 2267 llvm::Value *CGObjCGNU::GetClassNamed(CodeGenFunction &CGF, 2268 const std::string &Name, bool isWeak) { 2269 llvm::Constant *ClassName = MakeConstantString(Name); 2270 // With the incompatible ABI, this will need to be replaced with a direct 2271 // reference to the class symbol. For the compatible nonfragile ABI we are 2272 // still performing this lookup at run time but emitting the symbol for the 2273 // class externally so that we can make the switch later. 2274 // 2275 // Libobjc2 contains an LLVM pass that replaces calls to objc_lookup_class 2276 // with memoized versions or with static references if it's safe to do so. 2277 if (!isWeak) 2278 EmitClassRef(Name); 2279 2280 llvm::FunctionCallee ClassLookupFn = CGM.CreateRuntimeFunction( 2281 llvm::FunctionType::get(IdTy, PtrToInt8Ty, true), "objc_lookup_class"); 2282 return CGF.EmitNounwindRuntimeCall(ClassLookupFn, ClassName); 2283 } 2284 2285 // This has to perform the lookup every time, since posing and related 2286 // techniques can modify the name -> class mapping. 2287 llvm::Value *CGObjCGNU::GetClass(CodeGenFunction &CGF, 2288 const ObjCInterfaceDecl *OID) { 2289 auto *Value = 2290 GetClassNamed(CGF, OID->getNameAsString(), OID->isWeakImported()); 2291 if (auto *ClassSymbol = dyn_cast<llvm::GlobalVariable>(Value)) 2292 CGM.setGVProperties(ClassSymbol, OID); 2293 return Value; 2294 } 2295 2296 llvm::Value *CGObjCGNU::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) { 2297 auto *Value = GetClassNamed(CGF, "NSAutoreleasePool", false); 2298 if (CGM.getTriple().isOSBinFormatCOFF()) { 2299 if (auto *ClassSymbol = dyn_cast<llvm::GlobalVariable>(Value)) { 2300 IdentifierInfo &II = CGF.CGM.getContext().Idents.get("NSAutoreleasePool"); 2301 TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl(); 2302 DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl); 2303 2304 const VarDecl *VD = nullptr; 2305 for (const auto &Result : DC->lookup(&II)) 2306 if ((VD = dyn_cast<VarDecl>(Result))) 2307 break; 2308 2309 CGM.setGVProperties(ClassSymbol, VD); 2310 } 2311 } 2312 return Value; 2313 } 2314 2315 llvm::Value *CGObjCGNU::GetTypedSelector(CodeGenFunction &CGF, Selector Sel, 2316 const std::string &TypeEncoding) { 2317 SmallVectorImpl<TypedSelector> &Types = SelectorTable[Sel]; 2318 llvm::GlobalAlias *SelValue = nullptr; 2319 2320 for (SmallVectorImpl<TypedSelector>::iterator i = Types.begin(), 2321 e = Types.end() ; i!=e ; i++) { 2322 if (i->first == TypeEncoding) { 2323 SelValue = i->second; 2324 break; 2325 } 2326 } 2327 if (!SelValue) { 2328 SelValue = llvm::GlobalAlias::create( 2329 SelectorTy->getElementType(), 0, llvm::GlobalValue::PrivateLinkage, 2330 ".objc_selector_" + Sel.getAsString(), &TheModule); 2331 Types.emplace_back(TypeEncoding, SelValue); 2332 } 2333 2334 return SelValue; 2335 } 2336 2337 Address CGObjCGNU::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) { 2338 llvm::Value *SelValue = GetSelector(CGF, Sel); 2339 2340 // Store it to a temporary. Does this satisfy the semantics of 2341 // GetAddrOfSelector? Hopefully. 2342 Address tmp = CGF.CreateTempAlloca(SelValue->getType(), 2343 CGF.getPointerAlign()); 2344 CGF.Builder.CreateStore(SelValue, tmp); 2345 return tmp; 2346 } 2347 2348 llvm::Value *CGObjCGNU::GetSelector(CodeGenFunction &CGF, Selector Sel) { 2349 return GetTypedSelector(CGF, Sel, std::string()); 2350 } 2351 2352 llvm::Value *CGObjCGNU::GetSelector(CodeGenFunction &CGF, 2353 const ObjCMethodDecl *Method) { 2354 std::string SelTypes = CGM.getContext().getObjCEncodingForMethodDecl(Method); 2355 return GetTypedSelector(CGF, Method->getSelector(), SelTypes); 2356 } 2357 2358 llvm::Constant *CGObjCGNU::GetEHType(QualType T) { 2359 if (T->isObjCIdType() || T->isObjCQualifiedIdType()) { 2360 // With the old ABI, there was only one kind of catchall, which broke 2361 // foreign exceptions. With the new ABI, we use __objc_id_typeinfo as 2362 // a pointer indicating object catchalls, and NULL to indicate real 2363 // catchalls 2364 if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) { 2365 return MakeConstantString("@id"); 2366 } else { 2367 return nullptr; 2368 } 2369 } 2370 2371 // All other types should be Objective-C interface pointer types. 2372 const ObjCObjectPointerType *OPT = T->getAs<ObjCObjectPointerType>(); 2373 assert(OPT && "Invalid @catch type."); 2374 const ObjCInterfaceDecl *IDecl = OPT->getObjectType()->getInterface(); 2375 assert(IDecl && "Invalid @catch type."); 2376 return MakeConstantString(IDecl->getIdentifier()->getName()); 2377 } 2378 2379 llvm::Constant *CGObjCGNUstep::GetEHType(QualType T) { 2380 if (usesSEHExceptions) 2381 return CGM.getCXXABI().getAddrOfRTTIDescriptor(T); 2382 2383 if (!CGM.getLangOpts().CPlusPlus) 2384 return CGObjCGNU::GetEHType(T); 2385 2386 // For Objective-C++, we want to provide the ability to catch both C++ and 2387 // Objective-C objects in the same function. 2388 2389 // There's a particular fixed type info for 'id'. 2390 if (T->isObjCIdType() || 2391 T->isObjCQualifiedIdType()) { 2392 llvm::Constant *IDEHType = 2393 CGM.getModule().getGlobalVariable("__objc_id_type_info"); 2394 if (!IDEHType) 2395 IDEHType = 2396 new llvm::GlobalVariable(CGM.getModule(), PtrToInt8Ty, 2397 false, 2398 llvm::GlobalValue::ExternalLinkage, 2399 nullptr, "__objc_id_type_info"); 2400 return llvm::ConstantExpr::getBitCast(IDEHType, PtrToInt8Ty); 2401 } 2402 2403 const ObjCObjectPointerType *PT = 2404 T->getAs<ObjCObjectPointerType>(); 2405 assert(PT && "Invalid @catch type."); 2406 const ObjCInterfaceType *IT = PT->getInterfaceType(); 2407 assert(IT && "Invalid @catch type."); 2408 std::string className = IT->getDecl()->getIdentifier()->getName(); 2409 2410 std::string typeinfoName = "__objc_eh_typeinfo_" + className; 2411 2412 // Return the existing typeinfo if it exists 2413 llvm::Constant *typeinfo = TheModule.getGlobalVariable(typeinfoName); 2414 if (typeinfo) 2415 return llvm::ConstantExpr::getBitCast(typeinfo, PtrToInt8Ty); 2416 2417 // Otherwise create it. 2418 2419 // vtable for gnustep::libobjc::__objc_class_type_info 2420 // It's quite ugly hard-coding this. Ideally we'd generate it using the host 2421 // platform's name mangling. 2422 const char *vtableName = "_ZTVN7gnustep7libobjc22__objc_class_type_infoE"; 2423 auto *Vtable = TheModule.getGlobalVariable(vtableName); 2424 if (!Vtable) { 2425 Vtable = new llvm::GlobalVariable(TheModule, PtrToInt8Ty, true, 2426 llvm::GlobalValue::ExternalLinkage, 2427 nullptr, vtableName); 2428 } 2429 llvm::Constant *Two = llvm::ConstantInt::get(IntTy, 2); 2430 auto *BVtable = llvm::ConstantExpr::getBitCast( 2431 llvm::ConstantExpr::getGetElementPtr(Vtable->getValueType(), Vtable, Two), 2432 PtrToInt8Ty); 2433 2434 llvm::Constant *typeName = 2435 ExportUniqueString(className, "__objc_eh_typename_"); 2436 2437 ConstantInitBuilder builder(CGM); 2438 auto fields = builder.beginStruct(); 2439 fields.add(BVtable); 2440 fields.add(typeName); 2441 llvm::Constant *TI = 2442 fields.finishAndCreateGlobal("__objc_eh_typeinfo_" + className, 2443 CGM.getPointerAlign(), 2444 /*constant*/ false, 2445 llvm::GlobalValue::LinkOnceODRLinkage); 2446 return llvm::ConstantExpr::getBitCast(TI, PtrToInt8Ty); 2447 } 2448 2449 /// Generate an NSConstantString object. 2450 ConstantAddress CGObjCGNU::GenerateConstantString(const StringLiteral *SL) { 2451 2452 std::string Str = SL->getString().str(); 2453 CharUnits Align = CGM.getPointerAlign(); 2454 2455 // Look for an existing one 2456 llvm::StringMap<llvm::Constant*>::iterator old = ObjCStrings.find(Str); 2457 if (old != ObjCStrings.end()) 2458 return ConstantAddress(old->getValue(), Align); 2459 2460 StringRef StringClass = CGM.getLangOpts().ObjCConstantStringClass; 2461 2462 if (StringClass.empty()) StringClass = "NSConstantString"; 2463 2464 std::string Sym = "_OBJC_CLASS_"; 2465 Sym += StringClass; 2466 2467 llvm::Constant *isa = TheModule.getNamedGlobal(Sym); 2468 2469 if (!isa) 2470 isa = new llvm::GlobalVariable(TheModule, IdTy, /* isConstant */false, 2471 llvm::GlobalValue::ExternalWeakLinkage, nullptr, Sym); 2472 else if (isa->getType() != PtrToIdTy) 2473 isa = llvm::ConstantExpr::getBitCast(isa, PtrToIdTy); 2474 2475 ConstantInitBuilder Builder(CGM); 2476 auto Fields = Builder.beginStruct(); 2477 Fields.add(isa); 2478 Fields.add(MakeConstantString(Str)); 2479 Fields.addInt(IntTy, Str.size()); 2480 llvm::Constant *ObjCStr = 2481 Fields.finishAndCreateGlobal(".objc_str", Align); 2482 ObjCStr = llvm::ConstantExpr::getBitCast(ObjCStr, PtrToInt8Ty); 2483 ObjCStrings[Str] = ObjCStr; 2484 ConstantStrings.push_back(ObjCStr); 2485 return ConstantAddress(ObjCStr, Align); 2486 } 2487 2488 ///Generates a message send where the super is the receiver. This is a message 2489 ///send to self with special delivery semantics indicating which class's method 2490 ///should be called. 2491 RValue 2492 CGObjCGNU::GenerateMessageSendSuper(CodeGenFunction &CGF, 2493 ReturnValueSlot Return, 2494 QualType ResultType, 2495 Selector Sel, 2496 const ObjCInterfaceDecl *Class, 2497 bool isCategoryImpl, 2498 llvm::Value *Receiver, 2499 bool IsClassMessage, 2500 const CallArgList &CallArgs, 2501 const ObjCMethodDecl *Method) { 2502 CGBuilderTy &Builder = CGF.Builder; 2503 if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) { 2504 if (Sel == RetainSel || Sel == AutoreleaseSel) { 2505 return RValue::get(EnforceType(Builder, Receiver, 2506 CGM.getTypes().ConvertType(ResultType))); 2507 } 2508 if (Sel == ReleaseSel) { 2509 return RValue::get(nullptr); 2510 } 2511 } 2512 2513 llvm::Value *cmd = GetSelector(CGF, Sel); 2514 CallArgList ActualArgs; 2515 2516 ActualArgs.add(RValue::get(EnforceType(Builder, Receiver, IdTy)), ASTIdTy); 2517 ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType()); 2518 ActualArgs.addFrom(CallArgs); 2519 2520 MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs); 2521 2522 llvm::Value *ReceiverClass = nullptr; 2523 bool isV2ABI = isRuntime(ObjCRuntime::GNUstep, 2); 2524 if (isV2ABI) { 2525 ReceiverClass = GetClassNamed(CGF, 2526 Class->getSuperClass()->getNameAsString(), /*isWeak*/false); 2527 if (IsClassMessage) { 2528 // Load the isa pointer of the superclass is this is a class method. 2529 ReceiverClass = Builder.CreateBitCast(ReceiverClass, 2530 llvm::PointerType::getUnqual(IdTy)); 2531 ReceiverClass = 2532 Builder.CreateAlignedLoad(ReceiverClass, CGF.getPointerAlign()); 2533 } 2534 ReceiverClass = EnforceType(Builder, ReceiverClass, IdTy); 2535 } else { 2536 if (isCategoryImpl) { 2537 llvm::FunctionCallee classLookupFunction = nullptr; 2538 if (IsClassMessage) { 2539 classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get( 2540 IdTy, PtrTy, true), "objc_get_meta_class"); 2541 } else { 2542 classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get( 2543 IdTy, PtrTy, true), "objc_get_class"); 2544 } 2545 ReceiverClass = Builder.CreateCall(classLookupFunction, 2546 MakeConstantString(Class->getNameAsString())); 2547 } else { 2548 // Set up global aliases for the metaclass or class pointer if they do not 2549 // already exist. These will are forward-references which will be set to 2550 // pointers to the class and metaclass structure created for the runtime 2551 // load function. To send a message to super, we look up the value of the 2552 // super_class pointer from either the class or metaclass structure. 2553 if (IsClassMessage) { 2554 if (!MetaClassPtrAlias) { 2555 MetaClassPtrAlias = llvm::GlobalAlias::create( 2556 IdTy->getElementType(), 0, llvm::GlobalValue::InternalLinkage, 2557 ".objc_metaclass_ref" + Class->getNameAsString(), &TheModule); 2558 } 2559 ReceiverClass = MetaClassPtrAlias; 2560 } else { 2561 if (!ClassPtrAlias) { 2562 ClassPtrAlias = llvm::GlobalAlias::create( 2563 IdTy->getElementType(), 0, llvm::GlobalValue::InternalLinkage, 2564 ".objc_class_ref" + Class->getNameAsString(), &TheModule); 2565 } 2566 ReceiverClass = ClassPtrAlias; 2567 } 2568 } 2569 // Cast the pointer to a simplified version of the class structure 2570 llvm::Type *CastTy = llvm::StructType::get(IdTy, IdTy); 2571 ReceiverClass = Builder.CreateBitCast(ReceiverClass, 2572 llvm::PointerType::getUnqual(CastTy)); 2573 // Get the superclass pointer 2574 ReceiverClass = Builder.CreateStructGEP(CastTy, ReceiverClass, 1); 2575 // Load the superclass pointer 2576 ReceiverClass = 2577 Builder.CreateAlignedLoad(ReceiverClass, CGF.getPointerAlign()); 2578 } 2579 // Construct the structure used to look up the IMP 2580 llvm::StructType *ObjCSuperTy = 2581 llvm::StructType::get(Receiver->getType(), IdTy); 2582 2583 Address ObjCSuper = CGF.CreateTempAlloca(ObjCSuperTy, 2584 CGF.getPointerAlign()); 2585 2586 Builder.CreateStore(Receiver, Builder.CreateStructGEP(ObjCSuper, 0)); 2587 Builder.CreateStore(ReceiverClass, Builder.CreateStructGEP(ObjCSuper, 1)); 2588 2589 ObjCSuper = EnforceType(Builder, ObjCSuper, PtrToObjCSuperTy); 2590 2591 // Get the IMP 2592 llvm::Value *imp = LookupIMPSuper(CGF, ObjCSuper, cmd, MSI); 2593 imp = EnforceType(Builder, imp, MSI.MessengerType); 2594 2595 llvm::Metadata *impMD[] = { 2596 llvm::MDString::get(VMContext, Sel.getAsString()), 2597 llvm::MDString::get(VMContext, Class->getSuperClass()->getNameAsString()), 2598 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get( 2599 llvm::Type::getInt1Ty(VMContext), IsClassMessage))}; 2600 llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD); 2601 2602 CGCallee callee(CGCalleeInfo(), imp); 2603 2604 llvm::CallBase *call; 2605 RValue msgRet = CGF.EmitCall(MSI.CallInfo, callee, Return, ActualArgs, &call); 2606 call->setMetadata(msgSendMDKind, node); 2607 return msgRet; 2608 } 2609 2610 /// Generate code for a message send expression. 2611 RValue 2612 CGObjCGNU::GenerateMessageSend(CodeGenFunction &CGF, 2613 ReturnValueSlot Return, 2614 QualType ResultType, 2615 Selector Sel, 2616 llvm::Value *Receiver, 2617 const CallArgList &CallArgs, 2618 const ObjCInterfaceDecl *Class, 2619 const ObjCMethodDecl *Method) { 2620 CGBuilderTy &Builder = CGF.Builder; 2621 2622 // Strip out message sends to retain / release in GC mode 2623 if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) { 2624 if (Sel == RetainSel || Sel == AutoreleaseSel) { 2625 return RValue::get(EnforceType(Builder, Receiver, 2626 CGM.getTypes().ConvertType(ResultType))); 2627 } 2628 if (Sel == ReleaseSel) { 2629 return RValue::get(nullptr); 2630 } 2631 } 2632 2633 // If the return type is something that goes in an integer register, the 2634 // runtime will handle 0 returns. For other cases, we fill in the 0 value 2635 // ourselves. 2636 // 2637 // The language spec says the result of this kind of message send is 2638 // undefined, but lots of people seem to have forgotten to read that 2639 // paragraph and insist on sending messages to nil that have structure 2640 // returns. With GCC, this generates a random return value (whatever happens 2641 // to be on the stack / in those registers at the time) on most platforms, 2642 // and generates an illegal instruction trap on SPARC. With LLVM it corrupts 2643 // the stack. 2644 bool isPointerSizedReturn = (ResultType->isAnyPointerType() || 2645 ResultType->isIntegralOrEnumerationType() || ResultType->isVoidType()); 2646 2647 llvm::BasicBlock *startBB = nullptr; 2648 llvm::BasicBlock *messageBB = nullptr; 2649 llvm::BasicBlock *continueBB = nullptr; 2650 2651 if (!isPointerSizedReturn) { 2652 startBB = Builder.GetInsertBlock(); 2653 messageBB = CGF.createBasicBlock("msgSend"); 2654 continueBB = CGF.createBasicBlock("continue"); 2655 2656 llvm::Value *isNil = Builder.CreateICmpEQ(Receiver, 2657 llvm::Constant::getNullValue(Receiver->getType())); 2658 Builder.CreateCondBr(isNil, continueBB, messageBB); 2659 CGF.EmitBlock(messageBB); 2660 } 2661 2662 IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy)); 2663 llvm::Value *cmd; 2664 if (Method) 2665 cmd = GetSelector(CGF, Method); 2666 else 2667 cmd = GetSelector(CGF, Sel); 2668 cmd = EnforceType(Builder, cmd, SelectorTy); 2669 Receiver = EnforceType(Builder, Receiver, IdTy); 2670 2671 llvm::Metadata *impMD[] = { 2672 llvm::MDString::get(VMContext, Sel.getAsString()), 2673 llvm::MDString::get(VMContext, Class ? Class->getNameAsString() : ""), 2674 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get( 2675 llvm::Type::getInt1Ty(VMContext), Class != nullptr))}; 2676 llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD); 2677 2678 CallArgList ActualArgs; 2679 ActualArgs.add(RValue::get(Receiver), ASTIdTy); 2680 ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType()); 2681 ActualArgs.addFrom(CallArgs); 2682 2683 MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs); 2684 2685 // Get the IMP to call 2686 llvm::Value *imp; 2687 2688 // If we have non-legacy dispatch specified, we try using the objc_msgSend() 2689 // functions. These are not supported on all platforms (or all runtimes on a 2690 // given platform), so we 2691 switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) { 2692 case CodeGenOptions::Legacy: 2693 imp = LookupIMP(CGF, Receiver, cmd, node, MSI); 2694 break; 2695 case CodeGenOptions::Mixed: 2696 case CodeGenOptions::NonLegacy: 2697 if (CGM.ReturnTypeUsesFPRet(ResultType)) { 2698 imp = 2699 CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy, IdTy, true), 2700 "objc_msgSend_fpret") 2701 .getCallee(); 2702 } else if (CGM.ReturnTypeUsesSRet(MSI.CallInfo)) { 2703 // The actual types here don't matter - we're going to bitcast the 2704 // function anyway 2705 imp = 2706 CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy, IdTy, true), 2707 "objc_msgSend_stret") 2708 .getCallee(); 2709 } else { 2710 imp = CGM.CreateRuntimeFunction( 2711 llvm::FunctionType::get(IdTy, IdTy, true), "objc_msgSend") 2712 .getCallee(); 2713 } 2714 } 2715 2716 // Reset the receiver in case the lookup modified it 2717 ActualArgs[0] = CallArg(RValue::get(Receiver), ASTIdTy); 2718 2719 imp = EnforceType(Builder, imp, MSI.MessengerType); 2720 2721 llvm::CallBase *call; 2722 CGCallee callee(CGCalleeInfo(), imp); 2723 RValue msgRet = CGF.EmitCall(MSI.CallInfo, callee, Return, ActualArgs, &call); 2724 call->setMetadata(msgSendMDKind, node); 2725 2726 2727 if (!isPointerSizedReturn) { 2728 messageBB = CGF.Builder.GetInsertBlock(); 2729 CGF.Builder.CreateBr(continueBB); 2730 CGF.EmitBlock(continueBB); 2731 if (msgRet.isScalar()) { 2732 llvm::Value *v = msgRet.getScalarVal(); 2733 llvm::PHINode *phi = Builder.CreatePHI(v->getType(), 2); 2734 phi->addIncoming(v, messageBB); 2735 phi->addIncoming(llvm::Constant::getNullValue(v->getType()), startBB); 2736 msgRet = RValue::get(phi); 2737 } else if (msgRet.isAggregate()) { 2738 Address v = msgRet.getAggregateAddress(); 2739 llvm::PHINode *phi = Builder.CreatePHI(v.getType(), 2); 2740 llvm::Type *RetTy = v.getElementType(); 2741 Address NullVal = CGF.CreateTempAlloca(RetTy, v.getAlignment(), "null"); 2742 CGF.InitTempAlloca(NullVal, llvm::Constant::getNullValue(RetTy)); 2743 phi->addIncoming(v.getPointer(), messageBB); 2744 phi->addIncoming(NullVal.getPointer(), startBB); 2745 msgRet = RValue::getAggregate(Address(phi, v.getAlignment())); 2746 } else /* isComplex() */ { 2747 std::pair<llvm::Value*,llvm::Value*> v = msgRet.getComplexVal(); 2748 llvm::PHINode *phi = Builder.CreatePHI(v.first->getType(), 2); 2749 phi->addIncoming(v.first, messageBB); 2750 phi->addIncoming(llvm::Constant::getNullValue(v.first->getType()), 2751 startBB); 2752 llvm::PHINode *phi2 = Builder.CreatePHI(v.second->getType(), 2); 2753 phi2->addIncoming(v.second, messageBB); 2754 phi2->addIncoming(llvm::Constant::getNullValue(v.second->getType()), 2755 startBB); 2756 msgRet = RValue::getComplex(phi, phi2); 2757 } 2758 } 2759 return msgRet; 2760 } 2761 2762 /// Generates a MethodList. Used in construction of a objc_class and 2763 /// objc_category structures. 2764 llvm::Constant *CGObjCGNU:: 2765 GenerateMethodList(StringRef ClassName, 2766 StringRef CategoryName, 2767 ArrayRef<const ObjCMethodDecl*> Methods, 2768 bool isClassMethodList) { 2769 if (Methods.empty()) 2770 return NULLPtr; 2771 2772 ConstantInitBuilder Builder(CGM); 2773 2774 auto MethodList = Builder.beginStruct(); 2775 MethodList.addNullPointer(CGM.Int8PtrTy); 2776 MethodList.addInt(Int32Ty, Methods.size()); 2777 2778 // Get the method structure type. 2779 llvm::StructType *ObjCMethodTy = 2780 llvm::StructType::get(CGM.getLLVMContext(), { 2781 PtrToInt8Ty, // Really a selector, but the runtime creates it us. 2782 PtrToInt8Ty, // Method types 2783 IMPTy // Method pointer 2784 }); 2785 bool isV2ABI = isRuntime(ObjCRuntime::GNUstep, 2); 2786 if (isV2ABI) { 2787 // size_t size; 2788 llvm::DataLayout td(&TheModule); 2789 MethodList.addInt(SizeTy, td.getTypeSizeInBits(ObjCMethodTy) / 2790 CGM.getContext().getCharWidth()); 2791 ObjCMethodTy = 2792 llvm::StructType::get(CGM.getLLVMContext(), { 2793 IMPTy, // Method pointer 2794 PtrToInt8Ty, // Selector 2795 PtrToInt8Ty // Extended type encoding 2796 }); 2797 } else { 2798 ObjCMethodTy = 2799 llvm::StructType::get(CGM.getLLVMContext(), { 2800 PtrToInt8Ty, // Really a selector, but the runtime creates it us. 2801 PtrToInt8Ty, // Method types 2802 IMPTy // Method pointer 2803 }); 2804 } 2805 auto MethodArray = MethodList.beginArray(); 2806 ASTContext &Context = CGM.getContext(); 2807 for (const auto *OMD : Methods) { 2808 llvm::Constant *FnPtr = 2809 TheModule.getFunction(SymbolNameForMethod(ClassName, CategoryName, 2810 OMD->getSelector(), 2811 isClassMethodList)); 2812 assert(FnPtr && "Can't generate metadata for method that doesn't exist"); 2813 auto Method = MethodArray.beginStruct(ObjCMethodTy); 2814 if (isV2ABI) { 2815 Method.addBitCast(FnPtr, IMPTy); 2816 Method.add(GetConstantSelector(OMD->getSelector(), 2817 Context.getObjCEncodingForMethodDecl(OMD))); 2818 Method.add(MakeConstantString(Context.getObjCEncodingForMethodDecl(OMD, true))); 2819 } else { 2820 Method.add(MakeConstantString(OMD->getSelector().getAsString())); 2821 Method.add(MakeConstantString(Context.getObjCEncodingForMethodDecl(OMD))); 2822 Method.addBitCast(FnPtr, IMPTy); 2823 } 2824 Method.finishAndAddTo(MethodArray); 2825 } 2826 MethodArray.finishAndAddTo(MethodList); 2827 2828 // Create an instance of the structure 2829 return MethodList.finishAndCreateGlobal(".objc_method_list", 2830 CGM.getPointerAlign()); 2831 } 2832 2833 /// Generates an IvarList. Used in construction of a objc_class. 2834 llvm::Constant *CGObjCGNU:: 2835 GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames, 2836 ArrayRef<llvm::Constant *> IvarTypes, 2837 ArrayRef<llvm::Constant *> IvarOffsets, 2838 ArrayRef<llvm::Constant *> IvarAlign, 2839 ArrayRef<Qualifiers::ObjCLifetime> IvarOwnership) { 2840 if (IvarNames.empty()) 2841 return NULLPtr; 2842 2843 ConstantInitBuilder Builder(CGM); 2844 2845 // Structure containing array count followed by array. 2846 auto IvarList = Builder.beginStruct(); 2847 IvarList.addInt(IntTy, (int)IvarNames.size()); 2848 2849 // Get the ivar structure type. 2850 llvm::StructType *ObjCIvarTy = 2851 llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty, IntTy); 2852 2853 // Array of ivar structures. 2854 auto Ivars = IvarList.beginArray(ObjCIvarTy); 2855 for (unsigned int i = 0, e = IvarNames.size() ; i < e ; i++) { 2856 auto Ivar = Ivars.beginStruct(ObjCIvarTy); 2857 Ivar.add(IvarNames[i]); 2858 Ivar.add(IvarTypes[i]); 2859 Ivar.add(IvarOffsets[i]); 2860 Ivar.finishAndAddTo(Ivars); 2861 } 2862 Ivars.finishAndAddTo(IvarList); 2863 2864 // Create an instance of the structure 2865 return IvarList.finishAndCreateGlobal(".objc_ivar_list", 2866 CGM.getPointerAlign()); 2867 } 2868 2869 /// Generate a class structure 2870 llvm::Constant *CGObjCGNU::GenerateClassStructure( 2871 llvm::Constant *MetaClass, 2872 llvm::Constant *SuperClass, 2873 unsigned info, 2874 const char *Name, 2875 llvm::Constant *Version, 2876 llvm::Constant *InstanceSize, 2877 llvm::Constant *IVars, 2878 llvm::Constant *Methods, 2879 llvm::Constant *Protocols, 2880 llvm::Constant *IvarOffsets, 2881 llvm::Constant *Properties, 2882 llvm::Constant *StrongIvarBitmap, 2883 llvm::Constant *WeakIvarBitmap, 2884 bool isMeta) { 2885 // Set up the class structure 2886 // Note: Several of these are char*s when they should be ids. This is 2887 // because the runtime performs this translation on load. 2888 // 2889 // Fields marked New ABI are part of the GNUstep runtime. We emit them 2890 // anyway; the classes will still work with the GNU runtime, they will just 2891 // be ignored. 2892 llvm::StructType *ClassTy = llvm::StructType::get( 2893 PtrToInt8Ty, // isa 2894 PtrToInt8Ty, // super_class 2895 PtrToInt8Ty, // name 2896 LongTy, // version 2897 LongTy, // info 2898 LongTy, // instance_size 2899 IVars->getType(), // ivars 2900 Methods->getType(), // methods 2901 // These are all filled in by the runtime, so we pretend 2902 PtrTy, // dtable 2903 PtrTy, // subclass_list 2904 PtrTy, // sibling_class 2905 PtrTy, // protocols 2906 PtrTy, // gc_object_type 2907 // New ABI: 2908 LongTy, // abi_version 2909 IvarOffsets->getType(), // ivar_offsets 2910 Properties->getType(), // properties 2911 IntPtrTy, // strong_pointers 2912 IntPtrTy // weak_pointers 2913 ); 2914 2915 ConstantInitBuilder Builder(CGM); 2916 auto Elements = Builder.beginStruct(ClassTy); 2917 2918 // Fill in the structure 2919 2920 // isa 2921 Elements.addBitCast(MetaClass, PtrToInt8Ty); 2922 // super_class 2923 Elements.add(SuperClass); 2924 // name 2925 Elements.add(MakeConstantString(Name, ".class_name")); 2926 // version 2927 Elements.addInt(LongTy, 0); 2928 // info 2929 Elements.addInt(LongTy, info); 2930 // instance_size 2931 if (isMeta) { 2932 llvm::DataLayout td(&TheModule); 2933 Elements.addInt(LongTy, 2934 td.getTypeSizeInBits(ClassTy) / 2935 CGM.getContext().getCharWidth()); 2936 } else 2937 Elements.add(InstanceSize); 2938 // ivars 2939 Elements.add(IVars); 2940 // methods 2941 Elements.add(Methods); 2942 // These are all filled in by the runtime, so we pretend 2943 // dtable 2944 Elements.add(NULLPtr); 2945 // subclass_list 2946 Elements.add(NULLPtr); 2947 // sibling_class 2948 Elements.add(NULLPtr); 2949 // protocols 2950 Elements.addBitCast(Protocols, PtrTy); 2951 // gc_object_type 2952 Elements.add(NULLPtr); 2953 // abi_version 2954 Elements.addInt(LongTy, ClassABIVersion); 2955 // ivar_offsets 2956 Elements.add(IvarOffsets); 2957 // properties 2958 Elements.add(Properties); 2959 // strong_pointers 2960 Elements.add(StrongIvarBitmap); 2961 // weak_pointers 2962 Elements.add(WeakIvarBitmap); 2963 // Create an instance of the structure 2964 // This is now an externally visible symbol, so that we can speed up class 2965 // messages in the next ABI. We may already have some weak references to 2966 // this, so check and fix them properly. 2967 std::string ClassSym((isMeta ? "_OBJC_METACLASS_": "_OBJC_CLASS_") + 2968 std::string(Name)); 2969 llvm::GlobalVariable *ClassRef = TheModule.getNamedGlobal(ClassSym); 2970 llvm::Constant *Class = 2971 Elements.finishAndCreateGlobal(ClassSym, CGM.getPointerAlign(), false, 2972 llvm::GlobalValue::ExternalLinkage); 2973 if (ClassRef) { 2974 ClassRef->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(Class, 2975 ClassRef->getType())); 2976 ClassRef->removeFromParent(); 2977 Class->setName(ClassSym); 2978 } 2979 return Class; 2980 } 2981 2982 llvm::Constant *CGObjCGNU:: 2983 GenerateProtocolMethodList(ArrayRef<const ObjCMethodDecl*> Methods) { 2984 // Get the method structure type. 2985 llvm::StructType *ObjCMethodDescTy = 2986 llvm::StructType::get(CGM.getLLVMContext(), { PtrToInt8Ty, PtrToInt8Ty }); 2987 ASTContext &Context = CGM.getContext(); 2988 ConstantInitBuilder Builder(CGM); 2989 auto MethodList = Builder.beginStruct(); 2990 MethodList.addInt(IntTy, Methods.size()); 2991 auto MethodArray = MethodList.beginArray(ObjCMethodDescTy); 2992 for (auto *M : Methods) { 2993 auto Method = MethodArray.beginStruct(ObjCMethodDescTy); 2994 Method.add(MakeConstantString(M->getSelector().getAsString())); 2995 Method.add(MakeConstantString(Context.getObjCEncodingForMethodDecl(M))); 2996 Method.finishAndAddTo(MethodArray); 2997 } 2998 MethodArray.finishAndAddTo(MethodList); 2999 return MethodList.finishAndCreateGlobal(".objc_method_list", 3000 CGM.getPointerAlign()); 3001 } 3002 3003 // Create the protocol list structure used in classes, categories and so on 3004 llvm::Constant * 3005 CGObjCGNU::GenerateProtocolList(ArrayRef<std::string> Protocols) { 3006 3007 ConstantInitBuilder Builder(CGM); 3008 auto ProtocolList = Builder.beginStruct(); 3009 ProtocolList.add(NULLPtr); 3010 ProtocolList.addInt(LongTy, Protocols.size()); 3011 3012 auto Elements = ProtocolList.beginArray(PtrToInt8Ty); 3013 for (const std::string *iter = Protocols.begin(), *endIter = Protocols.end(); 3014 iter != endIter ; iter++) { 3015 llvm::Constant *protocol = nullptr; 3016 llvm::StringMap<llvm::Constant*>::iterator value = 3017 ExistingProtocols.find(*iter); 3018 if (value == ExistingProtocols.end()) { 3019 protocol = GenerateEmptyProtocol(*iter); 3020 } else { 3021 protocol = value->getValue(); 3022 } 3023 Elements.addBitCast(protocol, PtrToInt8Ty); 3024 } 3025 Elements.finishAndAddTo(ProtocolList); 3026 return ProtocolList.finishAndCreateGlobal(".objc_protocol_list", 3027 CGM.getPointerAlign()); 3028 } 3029 3030 llvm::Value *CGObjCGNU::GenerateProtocolRef(CodeGenFunction &CGF, 3031 const ObjCProtocolDecl *PD) { 3032 llvm::Constant *&protocol = ExistingProtocols[PD->getNameAsString()]; 3033 if (!protocol) 3034 GenerateProtocol(PD); 3035 llvm::Type *T = 3036 CGM.getTypes().ConvertType(CGM.getContext().getObjCProtoType()); 3037 return CGF.Builder.CreateBitCast(protocol, llvm::PointerType::getUnqual(T)); 3038 } 3039 3040 llvm::Constant * 3041 CGObjCGNU::GenerateEmptyProtocol(StringRef ProtocolName) { 3042 llvm::Constant *ProtocolList = GenerateProtocolList({}); 3043 llvm::Constant *MethodList = GenerateProtocolMethodList({}); 3044 MethodList = llvm::ConstantExpr::getBitCast(MethodList, PtrToInt8Ty); 3045 // Protocols are objects containing lists of the methods implemented and 3046 // protocols adopted. 3047 ConstantInitBuilder Builder(CGM); 3048 auto Elements = Builder.beginStruct(); 3049 3050 // The isa pointer must be set to a magic number so the runtime knows it's 3051 // the correct layout. 3052 Elements.add(llvm::ConstantExpr::getIntToPtr( 3053 llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy)); 3054 3055 Elements.add(MakeConstantString(ProtocolName, ".objc_protocol_name")); 3056 Elements.add(ProtocolList); /* .protocol_list */ 3057 Elements.add(MethodList); /* .instance_methods */ 3058 Elements.add(MethodList); /* .class_methods */ 3059 Elements.add(MethodList); /* .optional_instance_methods */ 3060 Elements.add(MethodList); /* .optional_class_methods */ 3061 Elements.add(NULLPtr); /* .properties */ 3062 Elements.add(NULLPtr); /* .optional_properties */ 3063 return Elements.finishAndCreateGlobal(SymbolForProtocol(ProtocolName), 3064 CGM.getPointerAlign()); 3065 } 3066 3067 void CGObjCGNU::GenerateProtocol(const ObjCProtocolDecl *PD) { 3068 std::string ProtocolName = PD->getNameAsString(); 3069 3070 // Use the protocol definition, if there is one. 3071 if (const ObjCProtocolDecl *Def = PD->getDefinition()) 3072 PD = Def; 3073 3074 SmallVector<std::string, 16> Protocols; 3075 for (const auto *PI : PD->protocols()) 3076 Protocols.push_back(PI->getNameAsString()); 3077 SmallVector<const ObjCMethodDecl*, 16> InstanceMethods; 3078 SmallVector<const ObjCMethodDecl*, 16> OptionalInstanceMethods; 3079 for (const auto *I : PD->instance_methods()) 3080 if (I->isOptional()) 3081 OptionalInstanceMethods.push_back(I); 3082 else 3083 InstanceMethods.push_back(I); 3084 // Collect information about class methods: 3085 SmallVector<const ObjCMethodDecl*, 16> ClassMethods; 3086 SmallVector<const ObjCMethodDecl*, 16> OptionalClassMethods; 3087 for (const auto *I : PD->class_methods()) 3088 if (I->isOptional()) 3089 OptionalClassMethods.push_back(I); 3090 else 3091 ClassMethods.push_back(I); 3092 3093 llvm::Constant *ProtocolList = GenerateProtocolList(Protocols); 3094 llvm::Constant *InstanceMethodList = 3095 GenerateProtocolMethodList(InstanceMethods); 3096 llvm::Constant *ClassMethodList = 3097 GenerateProtocolMethodList(ClassMethods); 3098 llvm::Constant *OptionalInstanceMethodList = 3099 GenerateProtocolMethodList(OptionalInstanceMethods); 3100 llvm::Constant *OptionalClassMethodList = 3101 GenerateProtocolMethodList(OptionalClassMethods); 3102 3103 // Property metadata: name, attributes, isSynthesized, setter name, setter 3104 // types, getter name, getter types. 3105 // The isSynthesized value is always set to 0 in a protocol. It exists to 3106 // simplify the runtime library by allowing it to use the same data 3107 // structures for protocol metadata everywhere. 3108 3109 llvm::Constant *PropertyList = 3110 GeneratePropertyList(nullptr, PD, false, false); 3111 llvm::Constant *OptionalPropertyList = 3112 GeneratePropertyList(nullptr, PD, false, true); 3113 3114 // Protocols are objects containing lists of the methods implemented and 3115 // protocols adopted. 3116 // The isa pointer must be set to a magic number so the runtime knows it's 3117 // the correct layout. 3118 ConstantInitBuilder Builder(CGM); 3119 auto Elements = Builder.beginStruct(); 3120 Elements.add( 3121 llvm::ConstantExpr::getIntToPtr( 3122 llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy)); 3123 Elements.add(MakeConstantString(ProtocolName)); 3124 Elements.add(ProtocolList); 3125 Elements.add(InstanceMethodList); 3126 Elements.add(ClassMethodList); 3127 Elements.add(OptionalInstanceMethodList); 3128 Elements.add(OptionalClassMethodList); 3129 Elements.add(PropertyList); 3130 Elements.add(OptionalPropertyList); 3131 ExistingProtocols[ProtocolName] = 3132 llvm::ConstantExpr::getBitCast( 3133 Elements.finishAndCreateGlobal(".objc_protocol", CGM.getPointerAlign()), 3134 IdTy); 3135 } 3136 void CGObjCGNU::GenerateProtocolHolderCategory() { 3137 // Collect information about instance methods 3138 3139 ConstantInitBuilder Builder(CGM); 3140 auto Elements = Builder.beginStruct(); 3141 3142 const std::string ClassName = "__ObjC_Protocol_Holder_Ugly_Hack"; 3143 const std::string CategoryName = "AnotherHack"; 3144 Elements.add(MakeConstantString(CategoryName)); 3145 Elements.add(MakeConstantString(ClassName)); 3146 // Instance method list 3147 Elements.addBitCast(GenerateMethodList( 3148 ClassName, CategoryName, {}, false), PtrTy); 3149 // Class method list 3150 Elements.addBitCast(GenerateMethodList( 3151 ClassName, CategoryName, {}, true), PtrTy); 3152 3153 // Protocol list 3154 ConstantInitBuilder ProtocolListBuilder(CGM); 3155 auto ProtocolList = ProtocolListBuilder.beginStruct(); 3156 ProtocolList.add(NULLPtr); 3157 ProtocolList.addInt(LongTy, ExistingProtocols.size()); 3158 auto ProtocolElements = ProtocolList.beginArray(PtrTy); 3159 for (auto iter = ExistingProtocols.begin(), endIter = ExistingProtocols.end(); 3160 iter != endIter ; iter++) { 3161 ProtocolElements.addBitCast(iter->getValue(), PtrTy); 3162 } 3163 ProtocolElements.finishAndAddTo(ProtocolList); 3164 Elements.addBitCast( 3165 ProtocolList.finishAndCreateGlobal(".objc_protocol_list", 3166 CGM.getPointerAlign()), 3167 PtrTy); 3168 Categories.push_back(llvm::ConstantExpr::getBitCast( 3169 Elements.finishAndCreateGlobal("", CGM.getPointerAlign()), 3170 PtrTy)); 3171 } 3172 3173 /// Libobjc2 uses a bitfield representation where small(ish) bitfields are 3174 /// stored in a 64-bit value with the low bit set to 1 and the remaining 63 3175 /// bits set to their values, LSB first, while larger ones are stored in a 3176 /// structure of this / form: 3177 /// 3178 /// struct { int32_t length; int32_t values[length]; }; 3179 /// 3180 /// The values in the array are stored in host-endian format, with the least 3181 /// significant bit being assumed to come first in the bitfield. Therefore, a 3182 /// bitfield with the 64th bit set will be (int64_t)&{ 2, [0, 1<<31] }, while a 3183 /// bitfield / with the 63rd bit set will be 1<<64. 3184 llvm::Constant *CGObjCGNU::MakeBitField(ArrayRef<bool> bits) { 3185 int bitCount = bits.size(); 3186 int ptrBits = CGM.getDataLayout().getPointerSizeInBits(); 3187 if (bitCount < ptrBits) { 3188 uint64_t val = 1; 3189 for (int i=0 ; i<bitCount ; ++i) { 3190 if (bits[i]) val |= 1ULL<<(i+1); 3191 } 3192 return llvm::ConstantInt::get(IntPtrTy, val); 3193 } 3194 SmallVector<llvm::Constant *, 8> values; 3195 int v=0; 3196 while (v < bitCount) { 3197 int32_t word = 0; 3198 for (int i=0 ; (i<32) && (v<bitCount) ; ++i) { 3199 if (bits[v]) word |= 1<<i; 3200 v++; 3201 } 3202 values.push_back(llvm::ConstantInt::get(Int32Ty, word)); 3203 } 3204 3205 ConstantInitBuilder builder(CGM); 3206 auto fields = builder.beginStruct(); 3207 fields.addInt(Int32Ty, values.size()); 3208 auto array = fields.beginArray(); 3209 for (auto v : values) array.add(v); 3210 array.finishAndAddTo(fields); 3211 3212 llvm::Constant *GS = 3213 fields.finishAndCreateGlobal("", CharUnits::fromQuantity(4)); 3214 llvm::Constant *ptr = llvm::ConstantExpr::getPtrToInt(GS, IntPtrTy); 3215 return ptr; 3216 } 3217 3218 llvm::Constant *CGObjCGNU::GenerateCategoryProtocolList(const 3219 ObjCCategoryDecl *OCD) { 3220 SmallVector<std::string, 16> Protocols; 3221 for (const auto *PD : OCD->getReferencedProtocols()) 3222 Protocols.push_back(PD->getNameAsString()); 3223 return GenerateProtocolList(Protocols); 3224 } 3225 3226 void CGObjCGNU::GenerateCategory(const ObjCCategoryImplDecl *OCD) { 3227 const ObjCInterfaceDecl *Class = OCD->getClassInterface(); 3228 std::string ClassName = Class->getNameAsString(); 3229 std::string CategoryName = OCD->getNameAsString(); 3230 3231 // Collect the names of referenced protocols 3232 const ObjCCategoryDecl *CatDecl = OCD->getCategoryDecl(); 3233 3234 ConstantInitBuilder Builder(CGM); 3235 auto Elements = Builder.beginStruct(); 3236 Elements.add(MakeConstantString(CategoryName)); 3237 Elements.add(MakeConstantString(ClassName)); 3238 // Instance method list 3239 SmallVector<ObjCMethodDecl*, 16> InstanceMethods; 3240 InstanceMethods.insert(InstanceMethods.begin(), OCD->instmeth_begin(), 3241 OCD->instmeth_end()); 3242 Elements.addBitCast( 3243 GenerateMethodList(ClassName, CategoryName, InstanceMethods, false), 3244 PtrTy); 3245 // Class method list 3246 3247 SmallVector<ObjCMethodDecl*, 16> ClassMethods; 3248 ClassMethods.insert(ClassMethods.begin(), OCD->classmeth_begin(), 3249 OCD->classmeth_end()); 3250 Elements.addBitCast( 3251 GenerateMethodList(ClassName, CategoryName, ClassMethods, true), 3252 PtrTy); 3253 // Protocol list 3254 Elements.addBitCast(GenerateCategoryProtocolList(CatDecl), PtrTy); 3255 if (isRuntime(ObjCRuntime::GNUstep, 2)) { 3256 const ObjCCategoryDecl *Category = 3257 Class->FindCategoryDeclaration(OCD->getIdentifier()); 3258 if (Category) { 3259 // Instance properties 3260 Elements.addBitCast(GeneratePropertyList(OCD, Category, false), PtrTy); 3261 // Class properties 3262 Elements.addBitCast(GeneratePropertyList(OCD, Category, true), PtrTy); 3263 } else { 3264 Elements.addNullPointer(PtrTy); 3265 Elements.addNullPointer(PtrTy); 3266 } 3267 } 3268 3269 Categories.push_back(llvm::ConstantExpr::getBitCast( 3270 Elements.finishAndCreateGlobal( 3271 std::string(".objc_category_")+ClassName+CategoryName, 3272 CGM.getPointerAlign()), 3273 PtrTy)); 3274 } 3275 3276 llvm::Constant *CGObjCGNU::GeneratePropertyList(const Decl *Container, 3277 const ObjCContainerDecl *OCD, 3278 bool isClassProperty, 3279 bool protocolOptionalProperties) { 3280 3281 SmallVector<const ObjCPropertyDecl *, 16> Properties; 3282 llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet; 3283 bool isProtocol = isa<ObjCProtocolDecl>(OCD); 3284 ASTContext &Context = CGM.getContext(); 3285 3286 std::function<void(const ObjCProtocolDecl *Proto)> collectProtocolProperties 3287 = [&](const ObjCProtocolDecl *Proto) { 3288 for (const auto *P : Proto->protocols()) 3289 collectProtocolProperties(P); 3290 for (const auto *PD : Proto->properties()) { 3291 if (isClassProperty != PD->isClassProperty()) 3292 continue; 3293 // Skip any properties that are declared in protocols that this class 3294 // conforms to but are not actually implemented by this class. 3295 if (!isProtocol && !Context.getObjCPropertyImplDeclForPropertyDecl(PD, Container)) 3296 continue; 3297 if (!PropertySet.insert(PD->getIdentifier()).second) 3298 continue; 3299 Properties.push_back(PD); 3300 } 3301 }; 3302 3303 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) 3304 for (const ObjCCategoryDecl *ClassExt : OID->known_extensions()) 3305 for (auto *PD : ClassExt->properties()) { 3306 if (isClassProperty != PD->isClassProperty()) 3307 continue; 3308 PropertySet.insert(PD->getIdentifier()); 3309 Properties.push_back(PD); 3310 } 3311 3312 for (const auto *PD : OCD->properties()) { 3313 if (isClassProperty != PD->isClassProperty()) 3314 continue; 3315 // If we're generating a list for a protocol, skip optional / required ones 3316 // when generating the other list. 3317 if (isProtocol && (protocolOptionalProperties != PD->isOptional())) 3318 continue; 3319 // Don't emit duplicate metadata for properties that were already in a 3320 // class extension. 3321 if (!PropertySet.insert(PD->getIdentifier()).second) 3322 continue; 3323 3324 Properties.push_back(PD); 3325 } 3326 3327 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) 3328 for (const auto *P : OID->all_referenced_protocols()) 3329 collectProtocolProperties(P); 3330 else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) 3331 for (const auto *P : CD->protocols()) 3332 collectProtocolProperties(P); 3333 3334 auto numProperties = Properties.size(); 3335 3336 if (numProperties == 0) 3337 return NULLPtr; 3338 3339 ConstantInitBuilder builder(CGM); 3340 auto propertyList = builder.beginStruct(); 3341 auto properties = PushPropertyListHeader(propertyList, numProperties); 3342 3343 // Add all of the property methods need adding to the method list and to the 3344 // property metadata list. 3345 for (auto *property : Properties) { 3346 bool isSynthesized = false; 3347 bool isDynamic = false; 3348 if (!isProtocol) { 3349 auto *propertyImpl = Context.getObjCPropertyImplDeclForPropertyDecl(property, Container); 3350 if (propertyImpl) { 3351 isSynthesized = (propertyImpl->getPropertyImplementation() == 3352 ObjCPropertyImplDecl::Synthesize); 3353 isDynamic = (propertyImpl->getPropertyImplementation() == 3354 ObjCPropertyImplDecl::Dynamic); 3355 } 3356 } 3357 PushProperty(properties, property, Container, isSynthesized, isDynamic); 3358 } 3359 properties.finishAndAddTo(propertyList); 3360 3361 return propertyList.finishAndCreateGlobal(".objc_property_list", 3362 CGM.getPointerAlign()); 3363 } 3364 3365 void CGObjCGNU::RegisterAlias(const ObjCCompatibleAliasDecl *OAD) { 3366 // Get the class declaration for which the alias is specified. 3367 ObjCInterfaceDecl *ClassDecl = 3368 const_cast<ObjCInterfaceDecl *>(OAD->getClassInterface()); 3369 ClassAliases.emplace_back(ClassDecl->getNameAsString(), 3370 OAD->getNameAsString()); 3371 } 3372 3373 void CGObjCGNU::GenerateClass(const ObjCImplementationDecl *OID) { 3374 ASTContext &Context = CGM.getContext(); 3375 3376 // Get the superclass name. 3377 const ObjCInterfaceDecl * SuperClassDecl = 3378 OID->getClassInterface()->getSuperClass(); 3379 std::string SuperClassName; 3380 if (SuperClassDecl) { 3381 SuperClassName = SuperClassDecl->getNameAsString(); 3382 EmitClassRef(SuperClassName); 3383 } 3384 3385 // Get the class name 3386 ObjCInterfaceDecl *ClassDecl = 3387 const_cast<ObjCInterfaceDecl *>(OID->getClassInterface()); 3388 std::string ClassName = ClassDecl->getNameAsString(); 3389 3390 // Emit the symbol that is used to generate linker errors if this class is 3391 // referenced in other modules but not declared. 3392 std::string classSymbolName = "__objc_class_name_" + ClassName; 3393 if (auto *symbol = TheModule.getGlobalVariable(classSymbolName)) { 3394 symbol->setInitializer(llvm::ConstantInt::get(LongTy, 0)); 3395 } else { 3396 new llvm::GlobalVariable(TheModule, LongTy, false, 3397 llvm::GlobalValue::ExternalLinkage, 3398 llvm::ConstantInt::get(LongTy, 0), 3399 classSymbolName); 3400 } 3401 3402 // Get the size of instances. 3403 int instanceSize = 3404 Context.getASTObjCImplementationLayout(OID).getSize().getQuantity(); 3405 3406 // Collect information about instance variables. 3407 SmallVector<llvm::Constant*, 16> IvarNames; 3408 SmallVector<llvm::Constant*, 16> IvarTypes; 3409 SmallVector<llvm::Constant*, 16> IvarOffsets; 3410 SmallVector<llvm::Constant*, 16> IvarAligns; 3411 SmallVector<Qualifiers::ObjCLifetime, 16> IvarOwnership; 3412 3413 ConstantInitBuilder IvarOffsetBuilder(CGM); 3414 auto IvarOffsetValues = IvarOffsetBuilder.beginArray(PtrToIntTy); 3415 SmallVector<bool, 16> WeakIvars; 3416 SmallVector<bool, 16> StrongIvars; 3417 3418 int superInstanceSize = !SuperClassDecl ? 0 : 3419 Context.getASTObjCInterfaceLayout(SuperClassDecl).getSize().getQuantity(); 3420 // For non-fragile ivars, set the instance size to 0 - {the size of just this 3421 // class}. The runtime will then set this to the correct value on load. 3422 if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) { 3423 instanceSize = 0 - (instanceSize - superInstanceSize); 3424 } 3425 3426 for (const ObjCIvarDecl *IVD = ClassDecl->all_declared_ivar_begin(); IVD; 3427 IVD = IVD->getNextIvar()) { 3428 // Store the name 3429 IvarNames.push_back(MakeConstantString(IVD->getNameAsString())); 3430 // Get the type encoding for this ivar 3431 std::string TypeStr; 3432 Context.getObjCEncodingForType(IVD->getType(), TypeStr, IVD); 3433 IvarTypes.push_back(MakeConstantString(TypeStr)); 3434 IvarAligns.push_back(llvm::ConstantInt::get(IntTy, 3435 Context.getTypeSize(IVD->getType()))); 3436 // Get the offset 3437 uint64_t BaseOffset = ComputeIvarBaseOffset(CGM, OID, IVD); 3438 uint64_t Offset = BaseOffset; 3439 if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) { 3440 Offset = BaseOffset - superInstanceSize; 3441 } 3442 llvm::Constant *OffsetValue = llvm::ConstantInt::get(IntTy, Offset); 3443 // Create the direct offset value 3444 std::string OffsetName = "__objc_ivar_offset_value_" + ClassName +"." + 3445 IVD->getNameAsString(); 3446 3447 llvm::GlobalVariable *OffsetVar = TheModule.getGlobalVariable(OffsetName); 3448 if (OffsetVar) { 3449 OffsetVar->setInitializer(OffsetValue); 3450 // If this is the real definition, change its linkage type so that 3451 // different modules will use this one, rather than their private 3452 // copy. 3453 OffsetVar->setLinkage(llvm::GlobalValue::ExternalLinkage); 3454 } else 3455 OffsetVar = new llvm::GlobalVariable(TheModule, Int32Ty, 3456 false, llvm::GlobalValue::ExternalLinkage, 3457 OffsetValue, OffsetName); 3458 IvarOffsets.push_back(OffsetValue); 3459 IvarOffsetValues.add(OffsetVar); 3460 Qualifiers::ObjCLifetime lt = IVD->getType().getQualifiers().getObjCLifetime(); 3461 IvarOwnership.push_back(lt); 3462 switch (lt) { 3463 case Qualifiers::OCL_Strong: 3464 StrongIvars.push_back(true); 3465 WeakIvars.push_back(false); 3466 break; 3467 case Qualifiers::OCL_Weak: 3468 StrongIvars.push_back(false); 3469 WeakIvars.push_back(true); 3470 break; 3471 default: 3472 StrongIvars.push_back(false); 3473 WeakIvars.push_back(false); 3474 } 3475 } 3476 llvm::Constant *StrongIvarBitmap = MakeBitField(StrongIvars); 3477 llvm::Constant *WeakIvarBitmap = MakeBitField(WeakIvars); 3478 llvm::GlobalVariable *IvarOffsetArray = 3479 IvarOffsetValues.finishAndCreateGlobal(".ivar.offsets", 3480 CGM.getPointerAlign()); 3481 3482 // Collect information about instance methods 3483 SmallVector<const ObjCMethodDecl*, 16> InstanceMethods; 3484 InstanceMethods.insert(InstanceMethods.begin(), OID->instmeth_begin(), 3485 OID->instmeth_end()); 3486 3487 SmallVector<const ObjCMethodDecl*, 16> ClassMethods; 3488 ClassMethods.insert(ClassMethods.begin(), OID->classmeth_begin(), 3489 OID->classmeth_end()); 3490 3491 // Collect the same information about synthesized properties, which don't 3492 // show up in the instance method lists. 3493 for (auto *propertyImpl : OID->property_impls()) 3494 if (propertyImpl->getPropertyImplementation() == 3495 ObjCPropertyImplDecl::Synthesize) { 3496 ObjCPropertyDecl *property = propertyImpl->getPropertyDecl(); 3497 auto addPropertyMethod = [&](const ObjCMethodDecl *accessor) { 3498 if (accessor) 3499 InstanceMethods.push_back(accessor); 3500 }; 3501 addPropertyMethod(property->getGetterMethodDecl()); 3502 addPropertyMethod(property->getSetterMethodDecl()); 3503 } 3504 3505 llvm::Constant *Properties = GeneratePropertyList(OID, ClassDecl); 3506 3507 // Collect the names of referenced protocols 3508 SmallVector<std::string, 16> Protocols; 3509 for (const auto *I : ClassDecl->protocols()) 3510 Protocols.push_back(I->getNameAsString()); 3511 3512 // Get the superclass pointer. 3513 llvm::Constant *SuperClass; 3514 if (!SuperClassName.empty()) { 3515 SuperClass = MakeConstantString(SuperClassName, ".super_class_name"); 3516 } else { 3517 SuperClass = llvm::ConstantPointerNull::get(PtrToInt8Ty); 3518 } 3519 // Empty vector used to construct empty method lists 3520 SmallVector<llvm::Constant*, 1> empty; 3521 // Generate the method and instance variable lists 3522 llvm::Constant *MethodList = GenerateMethodList(ClassName, "", 3523 InstanceMethods, false); 3524 llvm::Constant *ClassMethodList = GenerateMethodList(ClassName, "", 3525 ClassMethods, true); 3526 llvm::Constant *IvarList = GenerateIvarList(IvarNames, IvarTypes, 3527 IvarOffsets, IvarAligns, IvarOwnership); 3528 // Irrespective of whether we are compiling for a fragile or non-fragile ABI, 3529 // we emit a symbol containing the offset for each ivar in the class. This 3530 // allows code compiled for the non-Fragile ABI to inherit from code compiled 3531 // for the legacy ABI, without causing problems. The converse is also 3532 // possible, but causes all ivar accesses to be fragile. 3533 3534 // Offset pointer for getting at the correct field in the ivar list when 3535 // setting up the alias. These are: The base address for the global, the 3536 // ivar array (second field), the ivar in this list (set for each ivar), and 3537 // the offset (third field in ivar structure) 3538 llvm::Type *IndexTy = Int32Ty; 3539 llvm::Constant *offsetPointerIndexes[] = {Zeros[0], 3540 llvm::ConstantInt::get(IndexTy, ClassABIVersion > 1 ? 2 : 1), nullptr, 3541 llvm::ConstantInt::get(IndexTy, ClassABIVersion > 1 ? 3 : 2) }; 3542 3543 unsigned ivarIndex = 0; 3544 for (const ObjCIvarDecl *IVD = ClassDecl->all_declared_ivar_begin(); IVD; 3545 IVD = IVD->getNextIvar()) { 3546 const std::string Name = GetIVarOffsetVariableName(ClassDecl, IVD); 3547 offsetPointerIndexes[2] = llvm::ConstantInt::get(IndexTy, ivarIndex); 3548 // Get the correct ivar field 3549 llvm::Constant *offsetValue = llvm::ConstantExpr::getGetElementPtr( 3550 cast<llvm::GlobalVariable>(IvarList)->getValueType(), IvarList, 3551 offsetPointerIndexes); 3552 // Get the existing variable, if one exists. 3553 llvm::GlobalVariable *offset = TheModule.getNamedGlobal(Name); 3554 if (offset) { 3555 offset->setInitializer(offsetValue); 3556 // If this is the real definition, change its linkage type so that 3557 // different modules will use this one, rather than their private 3558 // copy. 3559 offset->setLinkage(llvm::GlobalValue::ExternalLinkage); 3560 } else 3561 // Add a new alias if there isn't one already. 3562 new llvm::GlobalVariable(TheModule, offsetValue->getType(), 3563 false, llvm::GlobalValue::ExternalLinkage, offsetValue, Name); 3564 ++ivarIndex; 3565 } 3566 llvm::Constant *ZeroPtr = llvm::ConstantInt::get(IntPtrTy, 0); 3567 3568 //Generate metaclass for class methods 3569 llvm::Constant *MetaClassStruct = GenerateClassStructure( 3570 NULLPtr, NULLPtr, 0x12L, ClassName.c_str(), nullptr, Zeros[0], 3571 NULLPtr, ClassMethodList, NULLPtr, NULLPtr, 3572 GeneratePropertyList(OID, ClassDecl, true), ZeroPtr, ZeroPtr, true); 3573 CGM.setGVProperties(cast<llvm::GlobalValue>(MetaClassStruct), 3574 OID->getClassInterface()); 3575 3576 // Generate the class structure 3577 llvm::Constant *ClassStruct = GenerateClassStructure( 3578 MetaClassStruct, SuperClass, 0x11L, ClassName.c_str(), nullptr, 3579 llvm::ConstantInt::get(LongTy, instanceSize), IvarList, MethodList, 3580 GenerateProtocolList(Protocols), IvarOffsetArray, Properties, 3581 StrongIvarBitmap, WeakIvarBitmap); 3582 CGM.setGVProperties(cast<llvm::GlobalValue>(ClassStruct), 3583 OID->getClassInterface()); 3584 3585 // Resolve the class aliases, if they exist. 3586 if (ClassPtrAlias) { 3587 ClassPtrAlias->replaceAllUsesWith( 3588 llvm::ConstantExpr::getBitCast(ClassStruct, IdTy)); 3589 ClassPtrAlias->eraseFromParent(); 3590 ClassPtrAlias = nullptr; 3591 } 3592 if (MetaClassPtrAlias) { 3593 MetaClassPtrAlias->replaceAllUsesWith( 3594 llvm::ConstantExpr::getBitCast(MetaClassStruct, IdTy)); 3595 MetaClassPtrAlias->eraseFromParent(); 3596 MetaClassPtrAlias = nullptr; 3597 } 3598 3599 // Add class structure to list to be added to the symtab later 3600 ClassStruct = llvm::ConstantExpr::getBitCast(ClassStruct, PtrToInt8Ty); 3601 Classes.push_back(ClassStruct); 3602 } 3603 3604 llvm::Function *CGObjCGNU::ModuleInitFunction() { 3605 // Only emit an ObjC load function if no Objective-C stuff has been called 3606 if (Classes.empty() && Categories.empty() && ConstantStrings.empty() && 3607 ExistingProtocols.empty() && SelectorTable.empty()) 3608 return nullptr; 3609 3610 // Add all referenced protocols to a category. 3611 GenerateProtocolHolderCategory(); 3612 3613 llvm::StructType *selStructTy = 3614 dyn_cast<llvm::StructType>(SelectorTy->getElementType()); 3615 llvm::Type *selStructPtrTy = SelectorTy; 3616 if (!selStructTy) { 3617 selStructTy = llvm::StructType::get(CGM.getLLVMContext(), 3618 { PtrToInt8Ty, PtrToInt8Ty }); 3619 selStructPtrTy = llvm::PointerType::getUnqual(selStructTy); 3620 } 3621 3622 // Generate statics list: 3623 llvm::Constant *statics = NULLPtr; 3624 if (!ConstantStrings.empty()) { 3625 llvm::GlobalVariable *fileStatics = [&] { 3626 ConstantInitBuilder builder(CGM); 3627 auto staticsStruct = builder.beginStruct(); 3628 3629 StringRef stringClass = CGM.getLangOpts().ObjCConstantStringClass; 3630 if (stringClass.empty()) stringClass = "NXConstantString"; 3631 staticsStruct.add(MakeConstantString(stringClass, 3632 ".objc_static_class_name")); 3633 3634 auto array = staticsStruct.beginArray(); 3635 array.addAll(ConstantStrings); 3636 array.add(NULLPtr); 3637 array.finishAndAddTo(staticsStruct); 3638 3639 return staticsStruct.finishAndCreateGlobal(".objc_statics", 3640 CGM.getPointerAlign()); 3641 }(); 3642 3643 ConstantInitBuilder builder(CGM); 3644 auto allStaticsArray = builder.beginArray(fileStatics->getType()); 3645 allStaticsArray.add(fileStatics); 3646 allStaticsArray.addNullPointer(fileStatics->getType()); 3647 3648 statics = allStaticsArray.finishAndCreateGlobal(".objc_statics_ptr", 3649 CGM.getPointerAlign()); 3650 statics = llvm::ConstantExpr::getBitCast(statics, PtrTy); 3651 } 3652 3653 // Array of classes, categories, and constant objects. 3654 3655 SmallVector<llvm::GlobalAlias*, 16> selectorAliases; 3656 unsigned selectorCount; 3657 3658 // Pointer to an array of selectors used in this module. 3659 llvm::GlobalVariable *selectorList = [&] { 3660 ConstantInitBuilder builder(CGM); 3661 auto selectors = builder.beginArray(selStructTy); 3662 auto &table = SelectorTable; // MSVC workaround 3663 std::vector<Selector> allSelectors; 3664 for (auto &entry : table) 3665 allSelectors.push_back(entry.first); 3666 llvm::sort(allSelectors); 3667 3668 for (auto &untypedSel : allSelectors) { 3669 std::string selNameStr = untypedSel.getAsString(); 3670 llvm::Constant *selName = ExportUniqueString(selNameStr, ".objc_sel_name"); 3671 3672 for (TypedSelector &sel : table[untypedSel]) { 3673 llvm::Constant *selectorTypeEncoding = NULLPtr; 3674 if (!sel.first.empty()) 3675 selectorTypeEncoding = 3676 MakeConstantString(sel.first, ".objc_sel_types"); 3677 3678 auto selStruct = selectors.beginStruct(selStructTy); 3679 selStruct.add(selName); 3680 selStruct.add(selectorTypeEncoding); 3681 selStruct.finishAndAddTo(selectors); 3682 3683 // Store the selector alias for later replacement 3684 selectorAliases.push_back(sel.second); 3685 } 3686 } 3687 3688 // Remember the number of entries in the selector table. 3689 selectorCount = selectors.size(); 3690 3691 // NULL-terminate the selector list. This should not actually be required, 3692 // because the selector list has a length field. Unfortunately, the GCC 3693 // runtime decides to ignore the length field and expects a NULL terminator, 3694 // and GCC cooperates with this by always setting the length to 0. 3695 auto selStruct = selectors.beginStruct(selStructTy); 3696 selStruct.add(NULLPtr); 3697 selStruct.add(NULLPtr); 3698 selStruct.finishAndAddTo(selectors); 3699 3700 return selectors.finishAndCreateGlobal(".objc_selector_list", 3701 CGM.getPointerAlign()); 3702 }(); 3703 3704 // Now that all of the static selectors exist, create pointers to them. 3705 for (unsigned i = 0; i < selectorCount; ++i) { 3706 llvm::Constant *idxs[] = { 3707 Zeros[0], 3708 llvm::ConstantInt::get(Int32Ty, i) 3709 }; 3710 // FIXME: We're generating redundant loads and stores here! 3711 llvm::Constant *selPtr = llvm::ConstantExpr::getGetElementPtr( 3712 selectorList->getValueType(), selectorList, idxs); 3713 // If selectors are defined as an opaque type, cast the pointer to this 3714 // type. 3715 selPtr = llvm::ConstantExpr::getBitCast(selPtr, SelectorTy); 3716 selectorAliases[i]->replaceAllUsesWith(selPtr); 3717 selectorAliases[i]->eraseFromParent(); 3718 } 3719 3720 llvm::GlobalVariable *symtab = [&] { 3721 ConstantInitBuilder builder(CGM); 3722 auto symtab = builder.beginStruct(); 3723 3724 // Number of static selectors 3725 symtab.addInt(LongTy, selectorCount); 3726 3727 symtab.addBitCast(selectorList, selStructPtrTy); 3728 3729 // Number of classes defined. 3730 symtab.addInt(CGM.Int16Ty, Classes.size()); 3731 // Number of categories defined 3732 symtab.addInt(CGM.Int16Ty, Categories.size()); 3733 3734 // Create an array of classes, then categories, then static object instances 3735 auto classList = symtab.beginArray(PtrToInt8Ty); 3736 classList.addAll(Classes); 3737 classList.addAll(Categories); 3738 // NULL-terminated list of static object instances (mainly constant strings) 3739 classList.add(statics); 3740 classList.add(NULLPtr); 3741 classList.finishAndAddTo(symtab); 3742 3743 // Construct the symbol table. 3744 return symtab.finishAndCreateGlobal("", CGM.getPointerAlign()); 3745 }(); 3746 3747 // The symbol table is contained in a module which has some version-checking 3748 // constants 3749 llvm::Constant *module = [&] { 3750 llvm::Type *moduleEltTys[] = { 3751 LongTy, LongTy, PtrToInt8Ty, symtab->getType(), IntTy 3752 }; 3753 llvm::StructType *moduleTy = 3754 llvm::StructType::get(CGM.getLLVMContext(), 3755 makeArrayRef(moduleEltTys).drop_back(unsigned(RuntimeVersion < 10))); 3756 3757 ConstantInitBuilder builder(CGM); 3758 auto module = builder.beginStruct(moduleTy); 3759 // Runtime version, used for ABI compatibility checking. 3760 module.addInt(LongTy, RuntimeVersion); 3761 // sizeof(ModuleTy) 3762 module.addInt(LongTy, CGM.getDataLayout().getTypeStoreSize(moduleTy)); 3763 3764 // The path to the source file where this module was declared 3765 SourceManager &SM = CGM.getContext().getSourceManager(); 3766 const FileEntry *mainFile = SM.getFileEntryForID(SM.getMainFileID()); 3767 std::string path = 3768 (Twine(mainFile->getDir()->getName()) + "/" + mainFile->getName()).str(); 3769 module.add(MakeConstantString(path, ".objc_source_file_name")); 3770 module.add(symtab); 3771 3772 if (RuntimeVersion >= 10) { 3773 switch (CGM.getLangOpts().getGC()) { 3774 case LangOptions::GCOnly: 3775 module.addInt(IntTy, 2); 3776 break; 3777 case LangOptions::NonGC: 3778 if (CGM.getLangOpts().ObjCAutoRefCount) 3779 module.addInt(IntTy, 1); 3780 else 3781 module.addInt(IntTy, 0); 3782 break; 3783 case LangOptions::HybridGC: 3784 module.addInt(IntTy, 1); 3785 break; 3786 } 3787 } 3788 3789 return module.finishAndCreateGlobal("", CGM.getPointerAlign()); 3790 }(); 3791 3792 // Create the load function calling the runtime entry point with the module 3793 // structure 3794 llvm::Function * LoadFunction = llvm::Function::Create( 3795 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false), 3796 llvm::GlobalValue::InternalLinkage, ".objc_load_function", 3797 &TheModule); 3798 llvm::BasicBlock *EntryBB = 3799 llvm::BasicBlock::Create(VMContext, "entry", LoadFunction); 3800 CGBuilderTy Builder(CGM, VMContext); 3801 Builder.SetInsertPoint(EntryBB); 3802 3803 llvm::FunctionType *FT = 3804 llvm::FunctionType::get(Builder.getVoidTy(), module->getType(), true); 3805 llvm::FunctionCallee Register = 3806 CGM.CreateRuntimeFunction(FT, "__objc_exec_class"); 3807 Builder.CreateCall(Register, module); 3808 3809 if (!ClassAliases.empty()) { 3810 llvm::Type *ArgTypes[2] = {PtrTy, PtrToInt8Ty}; 3811 llvm::FunctionType *RegisterAliasTy = 3812 llvm::FunctionType::get(Builder.getVoidTy(), 3813 ArgTypes, false); 3814 llvm::Function *RegisterAlias = llvm::Function::Create( 3815 RegisterAliasTy, 3816 llvm::GlobalValue::ExternalWeakLinkage, "class_registerAlias_np", 3817 &TheModule); 3818 llvm::BasicBlock *AliasBB = 3819 llvm::BasicBlock::Create(VMContext, "alias", LoadFunction); 3820 llvm::BasicBlock *NoAliasBB = 3821 llvm::BasicBlock::Create(VMContext, "no_alias", LoadFunction); 3822 3823 // Branch based on whether the runtime provided class_registerAlias_np() 3824 llvm::Value *HasRegisterAlias = Builder.CreateICmpNE(RegisterAlias, 3825 llvm::Constant::getNullValue(RegisterAlias->getType())); 3826 Builder.CreateCondBr(HasRegisterAlias, AliasBB, NoAliasBB); 3827 3828 // The true branch (has alias registration function): 3829 Builder.SetInsertPoint(AliasBB); 3830 // Emit alias registration calls: 3831 for (std::vector<ClassAliasPair>::iterator iter = ClassAliases.begin(); 3832 iter != ClassAliases.end(); ++iter) { 3833 llvm::Constant *TheClass = 3834 TheModule.getGlobalVariable("_OBJC_CLASS_" + iter->first, true); 3835 if (TheClass) { 3836 TheClass = llvm::ConstantExpr::getBitCast(TheClass, PtrTy); 3837 Builder.CreateCall(RegisterAlias, 3838 {TheClass, MakeConstantString(iter->second)}); 3839 } 3840 } 3841 // Jump to end: 3842 Builder.CreateBr(NoAliasBB); 3843 3844 // Missing alias registration function, just return from the function: 3845 Builder.SetInsertPoint(NoAliasBB); 3846 } 3847 Builder.CreateRetVoid(); 3848 3849 return LoadFunction; 3850 } 3851 3852 llvm::Function *CGObjCGNU::GenerateMethod(const ObjCMethodDecl *OMD, 3853 const ObjCContainerDecl *CD) { 3854 const ObjCCategoryImplDecl *OCD = 3855 dyn_cast<ObjCCategoryImplDecl>(OMD->getDeclContext()); 3856 StringRef CategoryName = OCD ? OCD->getName() : ""; 3857 StringRef ClassName = CD->getName(); 3858 Selector MethodName = OMD->getSelector(); 3859 bool isClassMethod = !OMD->isInstanceMethod(); 3860 3861 CodeGenTypes &Types = CGM.getTypes(); 3862 llvm::FunctionType *MethodTy = 3863 Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD)); 3864 std::string FunctionName = SymbolNameForMethod(ClassName, CategoryName, 3865 MethodName, isClassMethod); 3866 3867 llvm::Function *Method 3868 = llvm::Function::Create(MethodTy, 3869 llvm::GlobalValue::InternalLinkage, 3870 FunctionName, 3871 &TheModule); 3872 return Method; 3873 } 3874 3875 llvm::FunctionCallee CGObjCGNU::GetPropertyGetFunction() { 3876 return GetPropertyFn; 3877 } 3878 3879 llvm::FunctionCallee CGObjCGNU::GetPropertySetFunction() { 3880 return SetPropertyFn; 3881 } 3882 3883 llvm::FunctionCallee CGObjCGNU::GetOptimizedPropertySetFunction(bool atomic, 3884 bool copy) { 3885 return nullptr; 3886 } 3887 3888 llvm::FunctionCallee CGObjCGNU::GetGetStructFunction() { 3889 return GetStructPropertyFn; 3890 } 3891 3892 llvm::FunctionCallee CGObjCGNU::GetSetStructFunction() { 3893 return SetStructPropertyFn; 3894 } 3895 3896 llvm::FunctionCallee CGObjCGNU::GetCppAtomicObjectGetFunction() { 3897 return nullptr; 3898 } 3899 3900 llvm::FunctionCallee CGObjCGNU::GetCppAtomicObjectSetFunction() { 3901 return nullptr; 3902 } 3903 3904 llvm::FunctionCallee CGObjCGNU::EnumerationMutationFunction() { 3905 return EnumerationMutationFn; 3906 } 3907 3908 void CGObjCGNU::EmitSynchronizedStmt(CodeGenFunction &CGF, 3909 const ObjCAtSynchronizedStmt &S) { 3910 EmitAtSynchronizedStmt(CGF, S, SyncEnterFn, SyncExitFn); 3911 } 3912 3913 3914 void CGObjCGNU::EmitTryStmt(CodeGenFunction &CGF, 3915 const ObjCAtTryStmt &S) { 3916 // Unlike the Apple non-fragile runtimes, which also uses 3917 // unwind-based zero cost exceptions, the GNU Objective C runtime's 3918 // EH support isn't a veneer over C++ EH. Instead, exception 3919 // objects are created by objc_exception_throw and destroyed by 3920 // the personality function; this avoids the need for bracketing 3921 // catch handlers with calls to __blah_begin_catch/__blah_end_catch 3922 // (or even _Unwind_DeleteException), but probably doesn't 3923 // interoperate very well with foreign exceptions. 3924 // 3925 // In Objective-C++ mode, we actually emit something equivalent to the C++ 3926 // exception handler. 3927 EmitTryCatchStmt(CGF, S, EnterCatchFn, ExitCatchFn, ExceptionReThrowFn); 3928 } 3929 3930 void CGObjCGNU::EmitThrowStmt(CodeGenFunction &CGF, 3931 const ObjCAtThrowStmt &S, 3932 bool ClearInsertionPoint) { 3933 llvm::Value *ExceptionAsObject; 3934 bool isRethrow = false; 3935 3936 if (const Expr *ThrowExpr = S.getThrowExpr()) { 3937 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr); 3938 ExceptionAsObject = Exception; 3939 } else { 3940 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) && 3941 "Unexpected rethrow outside @catch block."); 3942 ExceptionAsObject = CGF.ObjCEHValueStack.back(); 3943 isRethrow = true; 3944 } 3945 if (isRethrow && usesSEHExceptions) { 3946 // For SEH, ExceptionAsObject may be undef, because the catch handler is 3947 // not passed it for catchalls and so it is not visible to the catch 3948 // funclet. The real thrown object will still be live on the stack at this 3949 // point and will be rethrown. If we are explicitly rethrowing the object 3950 // that was passed into the `@catch` block, then this code path is not 3951 // reached and we will instead call `objc_exception_throw` with an explicit 3952 // argument. 3953 llvm::CallBase *Throw = CGF.EmitRuntimeCallOrInvoke(ExceptionReThrowFn); 3954 Throw->setDoesNotReturn(); 3955 } 3956 else { 3957 ExceptionAsObject = CGF.Builder.CreateBitCast(ExceptionAsObject, IdTy); 3958 llvm::CallBase *Throw = 3959 CGF.EmitRuntimeCallOrInvoke(ExceptionThrowFn, ExceptionAsObject); 3960 Throw->setDoesNotReturn(); 3961 } 3962 CGF.Builder.CreateUnreachable(); 3963 if (ClearInsertionPoint) 3964 CGF.Builder.ClearInsertionPoint(); 3965 } 3966 3967 llvm::Value * CGObjCGNU::EmitObjCWeakRead(CodeGenFunction &CGF, 3968 Address AddrWeakObj) { 3969 CGBuilderTy &B = CGF.Builder; 3970 AddrWeakObj = EnforceType(B, AddrWeakObj, PtrToIdTy); 3971 return B.CreateCall(WeakReadFn, AddrWeakObj.getPointer()); 3972 } 3973 3974 void CGObjCGNU::EmitObjCWeakAssign(CodeGenFunction &CGF, 3975 llvm::Value *src, Address dst) { 3976 CGBuilderTy &B = CGF.Builder; 3977 src = EnforceType(B, src, IdTy); 3978 dst = EnforceType(B, dst, PtrToIdTy); 3979 B.CreateCall(WeakAssignFn, {src, dst.getPointer()}); 3980 } 3981 3982 void CGObjCGNU::EmitObjCGlobalAssign(CodeGenFunction &CGF, 3983 llvm::Value *src, Address dst, 3984 bool threadlocal) { 3985 CGBuilderTy &B = CGF.Builder; 3986 src = EnforceType(B, src, IdTy); 3987 dst = EnforceType(B, dst, PtrToIdTy); 3988 // FIXME. Add threadloca assign API 3989 assert(!threadlocal && "EmitObjCGlobalAssign - Threal Local API NYI"); 3990 B.CreateCall(GlobalAssignFn, {src, dst.getPointer()}); 3991 } 3992 3993 void CGObjCGNU::EmitObjCIvarAssign(CodeGenFunction &CGF, 3994 llvm::Value *src, Address dst, 3995 llvm::Value *ivarOffset) { 3996 CGBuilderTy &B = CGF.Builder; 3997 src = EnforceType(B, src, IdTy); 3998 dst = EnforceType(B, dst, IdTy); 3999 B.CreateCall(IvarAssignFn, {src, dst.getPointer(), ivarOffset}); 4000 } 4001 4002 void CGObjCGNU::EmitObjCStrongCastAssign(CodeGenFunction &CGF, 4003 llvm::Value *src, Address dst) { 4004 CGBuilderTy &B = CGF.Builder; 4005 src = EnforceType(B, src, IdTy); 4006 dst = EnforceType(B, dst, PtrToIdTy); 4007 B.CreateCall(StrongCastAssignFn, {src, dst.getPointer()}); 4008 } 4009 4010 void CGObjCGNU::EmitGCMemmoveCollectable(CodeGenFunction &CGF, 4011 Address DestPtr, 4012 Address SrcPtr, 4013 llvm::Value *Size) { 4014 CGBuilderTy &B = CGF.Builder; 4015 DestPtr = EnforceType(B, DestPtr, PtrTy); 4016 SrcPtr = EnforceType(B, SrcPtr, PtrTy); 4017 4018 B.CreateCall(MemMoveFn, {DestPtr.getPointer(), SrcPtr.getPointer(), Size}); 4019 } 4020 4021 llvm::GlobalVariable *CGObjCGNU::ObjCIvarOffsetVariable( 4022 const ObjCInterfaceDecl *ID, 4023 const ObjCIvarDecl *Ivar) { 4024 const std::string Name = GetIVarOffsetVariableName(ID, Ivar); 4025 // Emit the variable and initialize it with what we think the correct value 4026 // is. This allows code compiled with non-fragile ivars to work correctly 4027 // when linked against code which isn't (most of the time). 4028 llvm::GlobalVariable *IvarOffsetPointer = TheModule.getNamedGlobal(Name); 4029 if (!IvarOffsetPointer) 4030 IvarOffsetPointer = new llvm::GlobalVariable(TheModule, 4031 llvm::Type::getInt32PtrTy(VMContext), false, 4032 llvm::GlobalValue::ExternalLinkage, nullptr, Name); 4033 return IvarOffsetPointer; 4034 } 4035 4036 LValue CGObjCGNU::EmitObjCValueForIvar(CodeGenFunction &CGF, 4037 QualType ObjectTy, 4038 llvm::Value *BaseValue, 4039 const ObjCIvarDecl *Ivar, 4040 unsigned CVRQualifiers) { 4041 const ObjCInterfaceDecl *ID = 4042 ObjectTy->getAs<ObjCObjectType>()->getInterface(); 4043 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers, 4044 EmitIvarOffset(CGF, ID, Ivar)); 4045 } 4046 4047 static const ObjCInterfaceDecl *FindIvarInterface(ASTContext &Context, 4048 const ObjCInterfaceDecl *OID, 4049 const ObjCIvarDecl *OIVD) { 4050 for (const ObjCIvarDecl *next = OID->all_declared_ivar_begin(); next; 4051 next = next->getNextIvar()) { 4052 if (OIVD == next) 4053 return OID; 4054 } 4055 4056 // Otherwise check in the super class. 4057 if (const ObjCInterfaceDecl *Super = OID->getSuperClass()) 4058 return FindIvarInterface(Context, Super, OIVD); 4059 4060 return nullptr; 4061 } 4062 4063 llvm::Value *CGObjCGNU::EmitIvarOffset(CodeGenFunction &CGF, 4064 const ObjCInterfaceDecl *Interface, 4065 const ObjCIvarDecl *Ivar) { 4066 if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) { 4067 Interface = FindIvarInterface(CGM.getContext(), Interface, Ivar); 4068 4069 // The MSVC linker cannot have a single global defined as LinkOnceAnyLinkage 4070 // and ExternalLinkage, so create a reference to the ivar global and rely on 4071 // the definition being created as part of GenerateClass. 4072 if (RuntimeVersion < 10 || 4073 CGF.CGM.getTarget().getTriple().isKnownWindowsMSVCEnvironment()) 4074 return CGF.Builder.CreateZExtOrBitCast( 4075 CGF.Builder.CreateAlignedLoad( 4076 Int32Ty, CGF.Builder.CreateAlignedLoad( 4077 ObjCIvarOffsetVariable(Interface, Ivar), 4078 CGF.getPointerAlign(), "ivar"), 4079 CharUnits::fromQuantity(4)), 4080 PtrDiffTy); 4081 std::string name = "__objc_ivar_offset_value_" + 4082 Interface->getNameAsString() +"." + Ivar->getNameAsString(); 4083 CharUnits Align = CGM.getIntAlign(); 4084 llvm::Value *Offset = TheModule.getGlobalVariable(name); 4085 if (!Offset) { 4086 auto GV = new llvm::GlobalVariable(TheModule, IntTy, 4087 false, llvm::GlobalValue::LinkOnceAnyLinkage, 4088 llvm::Constant::getNullValue(IntTy), name); 4089 GV->setAlignment(Align.getQuantity()); 4090 Offset = GV; 4091 } 4092 Offset = CGF.Builder.CreateAlignedLoad(Offset, Align); 4093 if (Offset->getType() != PtrDiffTy) 4094 Offset = CGF.Builder.CreateZExtOrBitCast(Offset, PtrDiffTy); 4095 return Offset; 4096 } 4097 uint64_t Offset = ComputeIvarBaseOffset(CGF.CGM, Interface, Ivar); 4098 return llvm::ConstantInt::get(PtrDiffTy, Offset, /*isSigned*/true); 4099 } 4100 4101 CGObjCRuntime * 4102 clang::CodeGen::CreateGNUObjCRuntime(CodeGenModule &CGM) { 4103 auto Runtime = CGM.getLangOpts().ObjCRuntime; 4104 switch (Runtime.getKind()) { 4105 case ObjCRuntime::GNUstep: 4106 if (Runtime.getVersion() >= VersionTuple(2, 0)) 4107 return new CGObjCGNUstep2(CGM); 4108 return new CGObjCGNUstep(CGM); 4109 4110 case ObjCRuntime::GCC: 4111 return new CGObjCGCC(CGM); 4112 4113 case ObjCRuntime::ObjFW: 4114 return new CGObjCObjFW(CGM); 4115 4116 case ObjCRuntime::FragileMacOSX: 4117 case ObjCRuntime::MacOSX: 4118 case ObjCRuntime::iOS: 4119 case ObjCRuntime::WatchOS: 4120 llvm_unreachable("these runtimes are not GNU runtimes"); 4121 } 4122 llvm_unreachable("bad runtime"); 4123 } 4124