CGObjCMac.cpp revision 3b8a652d60ddc4419c1fab5c7b5347560283cdc1
1//===------- CGObjCMac.cpp - Interface to Apple Objective-C Runtime -------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This provides Objective-C code generation targetting the Apple runtime. 11// 12//===----------------------------------------------------------------------===// 13 14#include "CGObjCRuntime.h" 15 16#include "CodeGenModule.h" 17#include "CodeGenFunction.h" 18#include "clang/AST/ASTContext.h" 19#include "clang/AST/Decl.h" 20#include "clang/AST/DeclObjC.h" 21#include "clang/Basic/LangOptions.h" 22 23#include "llvm/Intrinsics.h" 24#include "llvm/Module.h" 25#include "llvm/ADT/DenseSet.h" 26#include "llvm/Target/TargetData.h" 27#include <sstream> 28 29using namespace clang; 30using namespace CodeGen; 31 32namespace { 33 34 typedef std::vector<llvm::Constant*> ConstantVector; 35 36 // FIXME: We should find a nicer way to make the labels for 37 // metadata, string concatenation is lame. 38 39class ObjCCommonTypesHelper { 40protected: 41 CodeGen::CodeGenModule &CGM; 42 43public: 44 const llvm::Type *ShortTy, *IntTy, *LongTy; 45 const llvm::Type *Int8PtrTy; 46 47 /// ObjectPtrTy - LLVM type for object handles (typeof(id)) 48 const llvm::Type *ObjectPtrTy; 49 50 /// PtrObjectPtrTy - LLVM type for id * 51 const llvm::Type *PtrObjectPtrTy; 52 53 /// SelectorPtrTy - LLVM type for selector handles (typeof(SEL)) 54 const llvm::Type *SelectorPtrTy; 55 /// ProtocolPtrTy - LLVM type for external protocol handles 56 /// (typeof(Protocol)) 57 const llvm::Type *ExternalProtocolPtrTy; 58 59 // SuperCTy - clang type for struct objc_super. 60 QualType SuperCTy; 61 // SuperPtrCTy - clang type for struct objc_super *. 62 QualType SuperPtrCTy; 63 64 /// SuperTy - LLVM type for struct objc_super. 65 const llvm::StructType *SuperTy; 66 /// SuperPtrTy - LLVM type for struct objc_super *. 67 const llvm::Type *SuperPtrTy; 68 69 /// PropertyTy - LLVM type for struct objc_property (struct _prop_t 70 /// in GCC parlance). 71 const llvm::StructType *PropertyTy; 72 73 /// PropertyListTy - LLVM type for struct objc_property_list 74 /// (_prop_list_t in GCC parlance). 75 const llvm::StructType *PropertyListTy; 76 /// PropertyListPtrTy - LLVM type for struct objc_property_list*. 77 const llvm::Type *PropertyListPtrTy; 78 79 // MethodTy - LLVM type for struct objc_method. 80 const llvm::StructType *MethodTy; 81 82 /// CacheTy - LLVM type for struct objc_cache. 83 const llvm::Type *CacheTy; 84 /// CachePtrTy - LLVM type for struct objc_cache *. 85 const llvm::Type *CachePtrTy; 86 87 llvm::Function *GetPropertyFn, *SetPropertyFn; 88 89 llvm::Function *EnumerationMutationFn; 90 91 /// GcReadWeakFn -- LLVM objc_read_weak (id *src) function. 92 llvm::Function *GcReadWeakFn; 93 94 /// GcAssignWeakFn -- LLVM objc_assign_weak function. 95 llvm::Function *GcAssignWeakFn; 96 97 /// GcAssignGlobalFn -- LLVM objc_assign_global function. 98 llvm::Function *GcAssignGlobalFn; 99 100 /// GcAssignIvarFn -- LLVM objc_assign_ivar function. 101 llvm::Function *GcAssignIvarFn; 102 103 /// GcAssignStrongCastFn -- LLVM objc_assign_strongCast function. 104 llvm::Function *GcAssignStrongCastFn; 105 106 /// ExceptionThrowFn - LLVM objc_exception_throw function. 107 llvm::Function *ExceptionThrowFn; 108 109 /// SyncEnterFn - LLVM object_sync_enter function. 110 llvm::Function *SyncEnterFn; 111 112 /// SyncExitFn - LLVM object_sync_exit function. 113 llvm::Function *SyncExitFn; 114 115 ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm); 116 ~ObjCCommonTypesHelper(){} 117}; 118 119/// ObjCTypesHelper - Helper class that encapsulates lazy 120/// construction of varies types used during ObjC generation. 121class ObjCTypesHelper : public ObjCCommonTypesHelper { 122private: 123 124 llvm::Function *MessageSendFn, *MessageSendStretFn, *MessageSendFpretFn; 125 llvm::Function *MessageSendSuperFn, *MessageSendSuperStretFn, 126 *MessageSendSuperFpretFn; 127 128public: 129 /// SymtabTy - LLVM type for struct objc_symtab. 130 const llvm::StructType *SymtabTy; 131 /// SymtabPtrTy - LLVM type for struct objc_symtab *. 132 const llvm::Type *SymtabPtrTy; 133 /// ModuleTy - LLVM type for struct objc_module. 134 const llvm::StructType *ModuleTy; 135 136 /// ProtocolTy - LLVM type for struct objc_protocol. 137 const llvm::StructType *ProtocolTy; 138 /// ProtocolPtrTy - LLVM type for struct objc_protocol *. 139 const llvm::Type *ProtocolPtrTy; 140 /// ProtocolExtensionTy - LLVM type for struct 141 /// objc_protocol_extension. 142 const llvm::StructType *ProtocolExtensionTy; 143 /// ProtocolExtensionTy - LLVM type for struct 144 /// objc_protocol_extension *. 145 const llvm::Type *ProtocolExtensionPtrTy; 146 /// MethodDescriptionTy - LLVM type for struct 147 /// objc_method_description. 148 const llvm::StructType *MethodDescriptionTy; 149 /// MethodDescriptionListTy - LLVM type for struct 150 /// objc_method_description_list. 151 const llvm::StructType *MethodDescriptionListTy; 152 /// MethodDescriptionListPtrTy - LLVM type for struct 153 /// objc_method_description_list *. 154 const llvm::Type *MethodDescriptionListPtrTy; 155 /// ProtocolListTy - LLVM type for struct objc_property_list. 156 const llvm::Type *ProtocolListTy; 157 /// ProtocolListPtrTy - LLVM type for struct objc_property_list*. 158 const llvm::Type *ProtocolListPtrTy; 159 /// CategoryTy - LLVM type for struct objc_category. 160 const llvm::StructType *CategoryTy; 161 /// ClassTy - LLVM type for struct objc_class. 162 const llvm::StructType *ClassTy; 163 /// ClassPtrTy - LLVM type for struct objc_class *. 164 const llvm::Type *ClassPtrTy; 165 /// ClassExtensionTy - LLVM type for struct objc_class_ext. 166 const llvm::StructType *ClassExtensionTy; 167 /// ClassExtensionPtrTy - LLVM type for struct objc_class_ext *. 168 const llvm::Type *ClassExtensionPtrTy; 169 // IvarTy - LLVM type for struct objc_ivar. 170 const llvm::StructType *IvarTy; 171 /// IvarListTy - LLVM type for struct objc_ivar_list. 172 const llvm::Type *IvarListTy; 173 /// IvarListPtrTy - LLVM type for struct objc_ivar_list *. 174 const llvm::Type *IvarListPtrTy; 175 /// MethodListTy - LLVM type for struct objc_method_list. 176 const llvm::Type *MethodListTy; 177 /// MethodListPtrTy - LLVM type for struct objc_method_list *. 178 const llvm::Type *MethodListPtrTy; 179 180 /// ExceptionDataTy - LLVM type for struct _objc_exception_data. 181 const llvm::Type *ExceptionDataTy; 182 183 /// ExceptionTryEnterFn - LLVM objc_exception_try_enter function. 184 llvm::Function *ExceptionTryEnterFn; 185 186 /// ExceptionTryExitFn - LLVM objc_exception_try_exit function. 187 llvm::Function *ExceptionTryExitFn; 188 189 /// ExceptionExtractFn - LLVM objc_exception_extract function. 190 llvm::Function *ExceptionExtractFn; 191 192 /// ExceptionMatchFn - LLVM objc_exception_match function. 193 llvm::Function *ExceptionMatchFn; 194 195 /// SetJmpFn - LLVM _setjmp function. 196 llvm::Function *SetJmpFn; 197 198public: 199 ObjCTypesHelper(CodeGen::CodeGenModule &cgm); 200 ~ObjCTypesHelper() {} 201 202 203 llvm::Function *getSendFn(bool IsSuper) { 204 return IsSuper ? MessageSendSuperFn : MessageSendFn; 205 } 206 207 llvm::Function *getSendStretFn(bool IsSuper) { 208 return IsSuper ? MessageSendSuperStretFn : MessageSendStretFn; 209 } 210 211 llvm::Function *getSendFpretFn(bool IsSuper) { 212 return IsSuper ? MessageSendSuperFpretFn : MessageSendFpretFn; 213 } 214}; 215 216/// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's 217/// modern abi 218class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper { 219public: 220 llvm::Function *MessageSendFixupFn, *MessageSendFpretFixupFn, 221 *MessageSendStretFixupFn, *MessageSendIdFixupFn, 222 *MessageSendIdStretFixupFn, *MessageSendSuper2FixupFn, 223 *MessageSendSuper2StretFixupFn; 224 225 // MethodListnfABITy - LLVM for struct _method_list_t 226 const llvm::StructType *MethodListnfABITy; 227 228 // MethodListnfABIPtrTy - LLVM for struct _method_list_t* 229 const llvm::Type *MethodListnfABIPtrTy; 230 231 // ProtocolnfABITy = LLVM for struct _protocol_t 232 const llvm::StructType *ProtocolnfABITy; 233 234 // ProtocolnfABIPtrTy = LLVM for struct _protocol_t* 235 const llvm::Type *ProtocolnfABIPtrTy; 236 237 // ProtocolListnfABITy - LLVM for struct _objc_protocol_list 238 const llvm::StructType *ProtocolListnfABITy; 239 240 // ProtocolListnfABIPtrTy - LLVM for struct _objc_protocol_list* 241 const llvm::Type *ProtocolListnfABIPtrTy; 242 243 // ClassnfABITy - LLVM for struct _class_t 244 const llvm::StructType *ClassnfABITy; 245 246 // ClassnfABIPtrTy - LLVM for struct _class_t* 247 const llvm::Type *ClassnfABIPtrTy; 248 249 // IvarnfABITy - LLVM for struct _ivar_t 250 const llvm::StructType *IvarnfABITy; 251 252 // IvarListnfABITy - LLVM for struct _ivar_list_t 253 const llvm::StructType *IvarListnfABITy; 254 255 // IvarListnfABIPtrTy = LLVM for struct _ivar_list_t* 256 const llvm::Type *IvarListnfABIPtrTy; 257 258 // ClassRonfABITy - LLVM for struct _class_ro_t 259 const llvm::StructType *ClassRonfABITy; 260 261 // ImpnfABITy - LLVM for id (*)(id, SEL, ...) 262 const llvm::Type *ImpnfABITy; 263 264 // CategorynfABITy - LLVM for struct _category_t 265 const llvm::StructType *CategorynfABITy; 266 267 // New types for nonfragile abi messaging. 268 269 // MessageRefTy - LLVM for: 270 // struct _message_ref_t { 271 // IMP messenger; 272 // SEL name; 273 // }; 274 const llvm::StructType *MessageRefTy; 275 // MessageRefCTy - clang type for struct _message_ref_t 276 QualType MessageRefCTy; 277 278 // MessageRefPtrTy - LLVM for struct _message_ref_t* 279 const llvm::Type *MessageRefPtrTy; 280 // MessageRefCPtrTy - clang type for struct _message_ref_t* 281 QualType MessageRefCPtrTy; 282 283 // MessengerTy - Type of the messenger (shown as IMP above) 284 const llvm::FunctionType *MessengerTy; 285 286 // SuperMessageRefTy - LLVM for: 287 // struct _super_message_ref_t { 288 // SUPER_IMP messenger; 289 // SEL name; 290 // }; 291 const llvm::StructType *SuperMessageRefTy; 292 293 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t* 294 const llvm::Type *SuperMessageRefPtrTy; 295 296 /// EHPersonalityPtr - LLVM value for an i8* to the Objective-C 297 /// exception personality function. 298 llvm::Value *EHPersonalityPtr; 299 300 llvm::Function *UnwindResumeOrRethrowFn, *ObjCBeginCatchFn, *ObjCEndCatchFn; 301 302 const llvm::StructType *EHTypeTy; 303 const llvm::Type *EHTypePtrTy; 304 305 ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm); 306 ~ObjCNonFragileABITypesHelper(){} 307}; 308 309class CGObjCCommonMac : public CodeGen::CGObjCRuntime { 310public: 311 // FIXME - accessibility 312 class GC_IVAR { 313 public: 314 unsigned int ivar_bytepos; 315 unsigned int ivar_size; 316 GC_IVAR() : ivar_bytepos(0), ivar_size(0) {} 317 }; 318 319 class SKIP_SCAN { 320 public: 321 unsigned int skip; 322 unsigned int scan; 323 SKIP_SCAN() : skip(0), scan(0) {} 324 }; 325 326protected: 327 CodeGen::CodeGenModule &CGM; 328 // FIXME! May not be needing this after all. 329 unsigned ObjCABI; 330 331 // gc ivar layout bitmap calculation helper caches. 332 llvm::SmallVector<GC_IVAR, 16> SkipIvars; 333 llvm::SmallVector<GC_IVAR, 16> IvarsInfo; 334 llvm::SmallVector<SKIP_SCAN, 32> SkipScanIvars; 335 336 /// LazySymbols - Symbols to generate a lazy reference for. See 337 /// DefinedSymbols and FinishModule(). 338 std::set<IdentifierInfo*> LazySymbols; 339 340 /// DefinedSymbols - External symbols which are defined by this 341 /// module. The symbols in this list and LazySymbols are used to add 342 /// special linker symbols which ensure that Objective-C modules are 343 /// linked properly. 344 std::set<IdentifierInfo*> DefinedSymbols; 345 346 /// ClassNames - uniqued class names. 347 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassNames; 348 349 /// MethodVarNames - uniqued method variable names. 350 llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames; 351 352 /// MethodVarTypes - uniqued method type signatures. We have to use 353 /// a StringMap here because have no other unique reference. 354 llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes; 355 356 /// MethodDefinitions - map of methods which have been defined in 357 /// this translation unit. 358 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions; 359 360 /// PropertyNames - uniqued method variable names. 361 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames; 362 363 /// ClassReferences - uniqued class references. 364 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences; 365 366 /// SelectorReferences - uniqued selector references. 367 llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences; 368 369 /// Protocols - Protocols for which an objc_protocol structure has 370 /// been emitted. Forward declarations are handled by creating an 371 /// empty structure whose initializer is filled in when/if defined. 372 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols; 373 374 /// DefinedProtocols - Protocols which have actually been 375 /// defined. We should not need this, see FIXME in GenerateProtocol. 376 llvm::DenseSet<IdentifierInfo*> DefinedProtocols; 377 378 /// DefinedClasses - List of defined classes. 379 std::vector<llvm::GlobalValue*> DefinedClasses; 380 381 /// DefinedCategories - List of defined categories. 382 std::vector<llvm::GlobalValue*> DefinedCategories; 383 384 /// UsedGlobals - List of globals to pack into the llvm.used metadata 385 /// to prevent them from being clobbered. 386 std::vector<llvm::GlobalVariable*> UsedGlobals; 387 388 /// GetNameForMethod - Return a name for the given method. 389 /// \param[out] NameOut - The return value. 390 void GetNameForMethod(const ObjCMethodDecl *OMD, 391 const ObjCContainerDecl *CD, 392 std::string &NameOut); 393 394 /// GetMethodVarName - Return a unique constant for the given 395 /// selector's name. The return value has type char *. 396 llvm::Constant *GetMethodVarName(Selector Sel); 397 llvm::Constant *GetMethodVarName(IdentifierInfo *Ident); 398 llvm::Constant *GetMethodVarName(const std::string &Name); 399 400 /// GetMethodVarType - Return a unique constant for the given 401 /// selector's name. The return value has type char *. 402 403 // FIXME: This is a horrible name. 404 llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D); 405 llvm::Constant *GetMethodVarType(FieldDecl *D); 406 407 /// GetPropertyName - Return a unique constant for the given 408 /// name. The return value has type char *. 409 llvm::Constant *GetPropertyName(IdentifierInfo *Ident); 410 411 // FIXME: This can be dropped once string functions are unified. 412 llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD, 413 const Decl *Container); 414 415 /// GetClassName - Return a unique constant for the given selector's 416 /// name. The return value has type char *. 417 llvm::Constant *GetClassName(IdentifierInfo *Ident); 418 419 /// GetInterfaceDeclStructLayout - Get layout for ivars of given 420 /// interface declaration. 421 const llvm::StructLayout *GetInterfaceDeclStructLayout( 422 const ObjCInterfaceDecl *ID) const; 423 424 /// BuildIvarLayout - Builds ivar layout bitmap for the class 425 /// implementation for the __strong or __weak case. 426 /// 427 llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI, 428 bool ForStrongLayout); 429 430 void BuildAggrIvarLayout(const ObjCInterfaceDecl *OI, 431 const llvm::StructLayout *Layout, 432 const RecordDecl *RD, 433 const std::vector<FieldDecl*>& RecFields, 434 unsigned int BytePos, bool ForStrongLayout, 435 int &Index, int &SkIndex, bool &HasUnion); 436 437 /// GetIvarLayoutName - Returns a unique constant for the given 438 /// ivar layout bitmap. 439 llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident, 440 const ObjCCommonTypesHelper &ObjCTypes); 441 442 const RecordDecl *GetFirstIvarInRecord(const ObjCInterfaceDecl *OID, 443 RecordDecl::field_iterator &FIV, 444 RecordDecl::field_iterator &PIV); 445 /// EmitPropertyList - Emit the given property list. The return 446 /// value has type PropertyListPtrTy. 447 llvm::Constant *EmitPropertyList(const std::string &Name, 448 const Decl *Container, 449 const ObjCContainerDecl *OCD, 450 const ObjCCommonTypesHelper &ObjCTypes); 451 452 /// GetProtocolRef - Return a reference to the internal protocol 453 /// description, creating an empty one if it has not been 454 /// defined. The return value has type ProtocolPtrTy. 455 llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD); 456 457 /// GetIvarBaseOffset - returns ivars byte offset. 458 uint64_t GetIvarBaseOffset(const llvm::StructLayout *Layout, 459 FieldDecl *Field); 460 461 /// GetFieldBaseOffset - return's field byt offset. 462 uint64_t GetFieldBaseOffset(const ObjCInterfaceDecl *OI, 463 const llvm::StructLayout *Layout, 464 FieldDecl *Field); 465 466 /// CreateMetadataVar - Create a global variable with internal 467 /// linkage for use by the Objective-C runtime. 468 /// 469 /// This is a convenience wrapper which not only creates the 470 /// variable, but also sets the section and alignment and adds the 471 /// global to the UsedGlobals list. 472 /// 473 /// \param Name - The variable name. 474 /// \param Init - The variable initializer; this is also used to 475 /// define the type of the variable. 476 /// \param Section - The section the variable should go into, or 0. 477 /// \param Align - The alignment for the variable, or 0. 478 /// \param AddToUsed - Whether the variable should be added to 479 /// llvm. 480 llvm::GlobalVariable *CreateMetadataVar(const std::string &Name, 481 llvm::Constant *Init, 482 const char *Section, 483 unsigned Align, 484 bool AddToUsed); 485 486public: 487 CGObjCCommonMac(CodeGen::CodeGenModule &cgm) : CGM(cgm) 488 { } 489 490 virtual llvm::Constant *GenerateConstantString(const std::string &String); 491 492 virtual llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD, 493 const ObjCContainerDecl *CD=0); 494 495 virtual void GenerateProtocol(const ObjCProtocolDecl *PD); 496 497 /// GetOrEmitProtocol - Get the protocol object for the given 498 /// declaration, emitting it if necessary. The return value has type 499 /// ProtocolPtrTy. 500 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD)=0; 501 502 /// GetOrEmitProtocolRef - Get a forward reference to the protocol 503 /// object for the given declaration, emitting it if needed. These 504 /// forward references will be filled in with empty bodies if no 505 /// definition is seen. The return value has type ProtocolPtrTy. 506 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0; 507}; 508 509class CGObjCMac : public CGObjCCommonMac { 510private: 511 ObjCTypesHelper ObjCTypes; 512 /// EmitImageInfo - Emit the image info marker used to encode some module 513 /// level information. 514 void EmitImageInfo(); 515 516 /// EmitModuleInfo - Another marker encoding module level 517 /// information. 518 void EmitModuleInfo(); 519 520 /// EmitModuleSymols - Emit module symbols, the list of defined 521 /// classes and categories. The result has type SymtabPtrTy. 522 llvm::Constant *EmitModuleSymbols(); 523 524 /// FinishModule - Write out global data structures at the end of 525 /// processing a translation unit. 526 void FinishModule(); 527 528 /// EmitClassExtension - Generate the class extension structure used 529 /// to store the weak ivar layout and properties. The return value 530 /// has type ClassExtensionPtrTy. 531 llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID); 532 533 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy, 534 /// for the given class. 535 llvm::Value *EmitClassRef(CGBuilderTy &Builder, 536 const ObjCInterfaceDecl *ID); 537 538 CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF, 539 QualType ResultType, 540 Selector Sel, 541 llvm::Value *Arg0, 542 QualType Arg0Ty, 543 bool IsSuper, 544 const CallArgList &CallArgs); 545 546 /// EmitIvarList - Emit the ivar list for the given 547 /// implementation. If ForClass is true the list of class ivars 548 /// (i.e. metaclass ivars) is emitted, otherwise the list of 549 /// interface ivars will be emitted. The return value has type 550 /// IvarListPtrTy. 551 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID, 552 bool ForClass); 553 554 /// EmitMetaClass - Emit a forward reference to the class structure 555 /// for the metaclass of the given interface. The return value has 556 /// type ClassPtrTy. 557 llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID); 558 559 /// EmitMetaClass - Emit a class structure for the metaclass of the 560 /// given implementation. The return value has type ClassPtrTy. 561 llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID, 562 llvm::Constant *Protocols, 563 const llvm::Type *InterfaceTy, 564 const ConstantVector &Methods); 565 566 llvm::Constant *GetMethodConstant(const ObjCMethodDecl *MD); 567 568 llvm::Constant *GetMethodDescriptionConstant(const ObjCMethodDecl *MD); 569 570 /// EmitMethodList - Emit the method list for the given 571 /// implementation. The return value has type MethodListPtrTy. 572 llvm::Constant *EmitMethodList(const std::string &Name, 573 const char *Section, 574 const ConstantVector &Methods); 575 576 /// EmitMethodDescList - Emit a method description list for a list of 577 /// method declarations. 578 /// - TypeName: The name for the type containing the methods. 579 /// - IsProtocol: True iff these methods are for a protocol. 580 /// - ClassMethds: True iff these are class methods. 581 /// - Required: When true, only "required" methods are 582 /// listed. Similarly, when false only "optional" methods are 583 /// listed. For classes this should always be true. 584 /// - begin, end: The method list to output. 585 /// 586 /// The return value has type MethodDescriptionListPtrTy. 587 llvm::Constant *EmitMethodDescList(const std::string &Name, 588 const char *Section, 589 const ConstantVector &Methods); 590 591 /// GetOrEmitProtocol - Get the protocol object for the given 592 /// declaration, emitting it if necessary. The return value has type 593 /// ProtocolPtrTy. 594 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD); 595 596 /// GetOrEmitProtocolRef - Get a forward reference to the protocol 597 /// object for the given declaration, emitting it if needed. These 598 /// forward references will be filled in with empty bodies if no 599 /// definition is seen. The return value has type ProtocolPtrTy. 600 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD); 601 602 /// EmitProtocolExtension - Generate the protocol extension 603 /// structure used to store optional instance and class methods, and 604 /// protocol properties. The return value has type 605 /// ProtocolExtensionPtrTy. 606 llvm::Constant * 607 EmitProtocolExtension(const ObjCProtocolDecl *PD, 608 const ConstantVector &OptInstanceMethods, 609 const ConstantVector &OptClassMethods); 610 611 /// EmitProtocolList - Generate the list of referenced 612 /// protocols. The return value has type ProtocolListPtrTy. 613 llvm::Constant *EmitProtocolList(const std::string &Name, 614 ObjCProtocolDecl::protocol_iterator begin, 615 ObjCProtocolDecl::protocol_iterator end); 616 617 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy, 618 /// for the given selector. 619 llvm::Value *EmitSelector(CGBuilderTy &Builder, Selector Sel); 620 621 public: 622 CGObjCMac(CodeGen::CodeGenModule &cgm); 623 624 virtual llvm::Function *ModuleInitFunction(); 625 626 virtual CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF, 627 QualType ResultType, 628 Selector Sel, 629 llvm::Value *Receiver, 630 bool IsClassMessage, 631 const CallArgList &CallArgs); 632 633 virtual CodeGen::RValue 634 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, 635 QualType ResultType, 636 Selector Sel, 637 const ObjCInterfaceDecl *Class, 638 bool isCategoryImpl, 639 llvm::Value *Receiver, 640 bool IsClassMessage, 641 const CallArgList &CallArgs); 642 643 virtual llvm::Value *GetClass(CGBuilderTy &Builder, 644 const ObjCInterfaceDecl *ID); 645 646 virtual llvm::Value *GetSelector(CGBuilderTy &Builder, Selector Sel); 647 648 virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD); 649 650 virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl); 651 652 virtual llvm::Value *GenerateProtocolRef(CGBuilderTy &Builder, 653 const ObjCProtocolDecl *PD); 654 655 virtual llvm::Function *GetPropertyGetFunction(); 656 virtual llvm::Function *GetPropertySetFunction(); 657 virtual llvm::Function *EnumerationMutationFunction(); 658 659 virtual void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, 660 const Stmt &S); 661 virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, 662 const ObjCAtThrowStmt &S); 663 virtual llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, 664 llvm::Value *AddrWeakObj); 665 virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, 666 llvm::Value *src, llvm::Value *dst); 667 virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, 668 llvm::Value *src, llvm::Value *dest); 669 virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, 670 llvm::Value *src, llvm::Value *dest); 671 virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, 672 llvm::Value *src, llvm::Value *dest); 673 674 virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, 675 QualType ObjectTy, 676 llvm::Value *BaseValue, 677 const ObjCIvarDecl *Ivar, 678 const FieldDecl *Field, 679 unsigned CVRQualifiers); 680 virtual llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF, 681 ObjCInterfaceDecl *Interface, 682 const ObjCIvarDecl *Ivar); 683}; 684 685class CGObjCNonFragileABIMac : public CGObjCCommonMac { 686private: 687 ObjCNonFragileABITypesHelper ObjCTypes; 688 llvm::GlobalVariable* ObjCEmptyCacheVar; 689 llvm::GlobalVariable* ObjCEmptyVtableVar; 690 691 /// MetaClassReferences - uniqued meta class references. 692 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences; 693 694 /// EHTypeReferences - uniqued class ehtype references. 695 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences; 696 697 /// FinishNonFragileABIModule - Write out global data structures at the end of 698 /// processing a translation unit. 699 void FinishNonFragileABIModule(); 700 701 llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags, 702 unsigned InstanceStart, 703 unsigned InstanceSize, 704 const ObjCImplementationDecl *ID); 705 llvm::GlobalVariable * BuildClassMetaData(std::string &ClassName, 706 llvm::Constant *IsAGV, 707 llvm::Constant *SuperClassGV, 708 llvm::Constant *ClassRoGV, 709 bool HiddenVisibility); 710 711 llvm::Constant *GetMethodConstant(const ObjCMethodDecl *MD); 712 713 llvm::Constant *GetMethodDescriptionConstant(const ObjCMethodDecl *MD); 714 715 /// EmitMethodList - Emit the method list for the given 716 /// implementation. The return value has type MethodListnfABITy. 717 llvm::Constant *EmitMethodList(const std::string &Name, 718 const char *Section, 719 const ConstantVector &Methods); 720 /// EmitIvarList - Emit the ivar list for the given 721 /// implementation. If ForClass is true the list of class ivars 722 /// (i.e. metaclass ivars) is emitted, otherwise the list of 723 /// interface ivars will be emitted. The return value has type 724 /// IvarListnfABIPtrTy. 725 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID); 726 727 llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID, 728 const ObjCIvarDecl *Ivar, 729 unsigned long int offset); 730 731 /// GetOrEmitProtocol - Get the protocol object for the given 732 /// declaration, emitting it if necessary. The return value has type 733 /// ProtocolPtrTy. 734 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD); 735 736 /// GetOrEmitProtocolRef - Get a forward reference to the protocol 737 /// object for the given declaration, emitting it if needed. These 738 /// forward references will be filled in with empty bodies if no 739 /// definition is seen. The return value has type ProtocolPtrTy. 740 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD); 741 742 /// EmitProtocolList - Generate the list of referenced 743 /// protocols. The return value has type ProtocolListPtrTy. 744 llvm::Constant *EmitProtocolList(const std::string &Name, 745 ObjCProtocolDecl::protocol_iterator begin, 746 ObjCProtocolDecl::protocol_iterator end); 747 748 CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF, 749 QualType ResultType, 750 Selector Sel, 751 llvm::Value *Receiver, 752 QualType Arg0Ty, 753 bool IsSuper, 754 const CallArgList &CallArgs); 755 756 /// GetClassGlobal - Return the global variable for the Objective-C 757 /// class of the given name. 758 llvm::GlobalVariable *GetClassGlobal(const std::string &Name); 759 760 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy, 761 /// for the given class. 762 llvm::Value *EmitClassRef(CGBuilderTy &Builder, 763 const ObjCInterfaceDecl *ID, 764 bool IsSuper = false); 765 766 /// EmitMetaClassRef - Return a Value * of the address of _class_t 767 /// meta-data 768 llvm::Value *EmitMetaClassRef(CGBuilderTy &Builder, 769 const ObjCInterfaceDecl *ID); 770 771 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for 772 /// the given ivar. 773 /// 774 llvm::GlobalVariable * ObjCIvarOffsetVariable(std::string &Name, 775 const ObjCInterfaceDecl *ID, 776 const ObjCIvarDecl *Ivar); 777 778 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy, 779 /// for the given selector. 780 llvm::Value *EmitSelector(CGBuilderTy &Builder, Selector Sel); 781 782 /// GetInterfaceEHType - Get the ehtype for the given Objective-C 783 /// interface. The return value has type EHTypePtrTy. 784 llvm::Value *GetInterfaceEHType(const ObjCInterfaceType *IT); 785 786public: 787 CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm); 788 // FIXME. All stubs for now! 789 virtual llvm::Function *ModuleInitFunction(); 790 791 virtual CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF, 792 QualType ResultType, 793 Selector Sel, 794 llvm::Value *Receiver, 795 bool IsClassMessage, 796 const CallArgList &CallArgs); 797 798 virtual CodeGen::RValue 799 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, 800 QualType ResultType, 801 Selector Sel, 802 const ObjCInterfaceDecl *Class, 803 bool isCategoryImpl, 804 llvm::Value *Receiver, 805 bool IsClassMessage, 806 const CallArgList &CallArgs); 807 808 virtual llvm::Value *GetClass(CGBuilderTy &Builder, 809 const ObjCInterfaceDecl *ID); 810 811 virtual llvm::Value *GetSelector(CGBuilderTy &Builder, Selector Sel) 812 { return EmitSelector(Builder, Sel); } 813 814 virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD); 815 816 virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl); 817 virtual llvm::Value *GenerateProtocolRef(CGBuilderTy &Builder, 818 const ObjCProtocolDecl *PD); 819 820 virtual llvm::Function *GetPropertyGetFunction(){ 821 return ObjCTypes.GetPropertyFn; 822 } 823 virtual llvm::Function *GetPropertySetFunction(){ 824 return ObjCTypes.SetPropertyFn; 825 } 826 virtual llvm::Function *EnumerationMutationFunction() { 827 return ObjCTypes.EnumerationMutationFn; 828 } 829 830 virtual void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, 831 const Stmt &S); 832 virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, 833 const ObjCAtThrowStmt &S); 834 virtual llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, 835 llvm::Value *AddrWeakObj); 836 virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, 837 llvm::Value *src, llvm::Value *dst); 838 virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, 839 llvm::Value *src, llvm::Value *dest); 840 virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, 841 llvm::Value *src, llvm::Value *dest); 842 virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, 843 llvm::Value *src, llvm::Value *dest); 844 virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, 845 QualType ObjectTy, 846 llvm::Value *BaseValue, 847 const ObjCIvarDecl *Ivar, 848 const FieldDecl *Field, 849 unsigned CVRQualifiers); 850 virtual llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF, 851 ObjCInterfaceDecl *Interface, 852 const ObjCIvarDecl *Ivar); 853}; 854 855} // end anonymous namespace 856 857/* *** Helper Functions *** */ 858 859/// getConstantGEP() - Help routine to construct simple GEPs. 860static llvm::Constant *getConstantGEP(llvm::Constant *C, 861 unsigned idx0, 862 unsigned idx1) { 863 llvm::Value *Idxs[] = { 864 llvm::ConstantInt::get(llvm::Type::Int32Ty, idx0), 865 llvm::ConstantInt::get(llvm::Type::Int32Ty, idx1) 866 }; 867 return llvm::ConstantExpr::getGetElementPtr(C, Idxs, 2); 868} 869 870/* *** CGObjCMac Public Interface *** */ 871 872CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm), 873 ObjCTypes(cgm) 874{ 875 ObjCABI = 1; 876 EmitImageInfo(); 877} 878 879/// GetClass - Return a reference to the class for the given interface 880/// decl. 881llvm::Value *CGObjCMac::GetClass(CGBuilderTy &Builder, 882 const ObjCInterfaceDecl *ID) { 883 return EmitClassRef(Builder, ID); 884} 885 886/// GetSelector - Return the pointer to the unique'd string for this selector. 887llvm::Value *CGObjCMac::GetSelector(CGBuilderTy &Builder, Selector Sel) { 888 return EmitSelector(Builder, Sel); 889} 890 891/// Generate a constant CFString object. 892/* 893 struct __builtin_CFString { 894 const int *isa; // point to __CFConstantStringClassReference 895 int flags; 896 const char *str; 897 long length; 898 }; 899*/ 900 901llvm::Constant *CGObjCCommonMac::GenerateConstantString( 902 const std::string &String) { 903 return CGM.GetAddrOfConstantCFString(String); 904} 905 906/// Generates a message send where the super is the receiver. This is 907/// a message send to self with special delivery semantics indicating 908/// which class's method should be called. 909CodeGen::RValue 910CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, 911 QualType ResultType, 912 Selector Sel, 913 const ObjCInterfaceDecl *Class, 914 bool isCategoryImpl, 915 llvm::Value *Receiver, 916 bool IsClassMessage, 917 const CodeGen::CallArgList &CallArgs) { 918 // Create and init a super structure; this is a (receiver, class) 919 // pair we will pass to objc_msgSendSuper. 920 llvm::Value *ObjCSuper = 921 CGF.Builder.CreateAlloca(ObjCTypes.SuperTy, 0, "objc_super"); 922 llvm::Value *ReceiverAsObject = 923 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy); 924 CGF.Builder.CreateStore(ReceiverAsObject, 925 CGF.Builder.CreateStructGEP(ObjCSuper, 0)); 926 927 // If this is a class message the metaclass is passed as the target. 928 llvm::Value *Target; 929 if (IsClassMessage) { 930 if (isCategoryImpl) { 931 // Message sent to 'super' in a class method defined in a category 932 // implementation requires an odd treatment. 933 // If we are in a class method, we must retrieve the 934 // _metaclass_ for the current class, pointed at by 935 // the class's "isa" pointer. The following assumes that 936 // isa" is the first ivar in a class (which it must be). 937 Target = EmitClassRef(CGF.Builder, Class->getSuperClass()); 938 Target = CGF.Builder.CreateStructGEP(Target, 0); 939 Target = CGF.Builder.CreateLoad(Target); 940 } 941 else { 942 llvm::Value *MetaClassPtr = EmitMetaClassRef(Class); 943 llvm::Value *SuperPtr = CGF.Builder.CreateStructGEP(MetaClassPtr, 1); 944 llvm::Value *Super = CGF.Builder.CreateLoad(SuperPtr); 945 Target = Super; 946 } 947 } else { 948 Target = EmitClassRef(CGF.Builder, Class->getSuperClass()); 949 } 950 // FIXME: We shouldn't need to do this cast, rectify the ASTContext 951 // and ObjCTypes types. 952 const llvm::Type *ClassTy = 953 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType()); 954 Target = CGF.Builder.CreateBitCast(Target, ClassTy); 955 CGF.Builder.CreateStore(Target, 956 CGF.Builder.CreateStructGEP(ObjCSuper, 1)); 957 958 return EmitMessageSend(CGF, ResultType, Sel, 959 ObjCSuper, ObjCTypes.SuperPtrCTy, 960 true, CallArgs); 961} 962 963/// Generate code for a message send expression. 964CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF, 965 QualType ResultType, 966 Selector Sel, 967 llvm::Value *Receiver, 968 bool IsClassMessage, 969 const CallArgList &CallArgs) { 970 llvm::Value *Arg0 = 971 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy, "tmp"); 972 return EmitMessageSend(CGF, ResultType, Sel, 973 Arg0, CGF.getContext().getObjCIdType(), 974 false, CallArgs); 975} 976 977CodeGen::RValue CGObjCMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF, 978 QualType ResultType, 979 Selector Sel, 980 llvm::Value *Arg0, 981 QualType Arg0Ty, 982 bool IsSuper, 983 const CallArgList &CallArgs) { 984 CallArgList ActualArgs; 985 ActualArgs.push_back(std::make_pair(RValue::get(Arg0), Arg0Ty)); 986 ActualArgs.push_back(std::make_pair(RValue::get(EmitSelector(CGF.Builder, 987 Sel)), 988 CGF.getContext().getObjCSelType())); 989 ActualArgs.insert(ActualArgs.end(), CallArgs.begin(), CallArgs.end()); 990 991 CodeGenTypes &Types = CGM.getTypes(); 992 const CGFunctionInfo &FnInfo = Types.getFunctionInfo(ResultType, ActualArgs); 993 const llvm::FunctionType *FTy = Types.GetFunctionType(FnInfo, false); 994 995 llvm::Constant *Fn; 996 if (CGM.ReturnTypeUsesSret(FnInfo)) { 997 Fn = ObjCTypes.getSendStretFn(IsSuper); 998 } else if (ResultType->isFloatingType()) { 999 // FIXME: Sadly, this is wrong. This actually depends on the 1000 // architecture. This happens to be right for x86-32 though. 1001 Fn = ObjCTypes.getSendFpretFn(IsSuper); 1002 } else { 1003 Fn = ObjCTypes.getSendFn(IsSuper); 1004 } 1005 Fn = llvm::ConstantExpr::getBitCast(Fn, llvm::PointerType::getUnqual(FTy)); 1006 return CGF.EmitCall(FnInfo, Fn, ActualArgs); 1007} 1008 1009llvm::Value *CGObjCMac::GenerateProtocolRef(CGBuilderTy &Builder, 1010 const ObjCProtocolDecl *PD) { 1011 // FIXME: I don't understand why gcc generates this, or where it is 1012 // resolved. Investigate. Its also wasteful to look this up over and 1013 // over. 1014 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol")); 1015 1016 return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD), 1017 ObjCTypes.ExternalProtocolPtrTy); 1018} 1019 1020void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) { 1021 // FIXME: We shouldn't need this, the protocol decl should contain 1022 // enough information to tell us whether this was a declaration or a 1023 // definition. 1024 DefinedProtocols.insert(PD->getIdentifier()); 1025 1026 // If we have generated a forward reference to this protocol, emit 1027 // it now. Otherwise do nothing, the protocol objects are lazily 1028 // emitted. 1029 if (Protocols.count(PD->getIdentifier())) 1030 GetOrEmitProtocol(PD); 1031} 1032 1033llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) { 1034 if (DefinedProtocols.count(PD->getIdentifier())) 1035 return GetOrEmitProtocol(PD); 1036 return GetOrEmitProtocolRef(PD); 1037} 1038 1039/* 1040 // APPLE LOCAL radar 4585769 - Objective-C 1.0 extensions 1041 struct _objc_protocol { 1042 struct _objc_protocol_extension *isa; 1043 char *protocol_name; 1044 struct _objc_protocol_list *protocol_list; 1045 struct _objc__method_prototype_list *instance_methods; 1046 struct _objc__method_prototype_list *class_methods 1047 }; 1048 1049 See EmitProtocolExtension(). 1050*/ 1051llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) { 1052 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()]; 1053 1054 // Early exit if a defining object has already been generated. 1055 if (Entry && Entry->hasInitializer()) 1056 return Entry; 1057 1058 // FIXME: I don't understand why gcc generates this, or where it is 1059 // resolved. Investigate. Its also wasteful to look this up over and 1060 // over. 1061 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol")); 1062 1063 const char *ProtocolName = PD->getNameAsCString(); 1064 1065 // Construct method lists. 1066 std::vector<llvm::Constant*> InstanceMethods, ClassMethods; 1067 std::vector<llvm::Constant*> OptInstanceMethods, OptClassMethods; 1068 for (ObjCProtocolDecl::instmeth_iterator i = PD->instmeth_begin(), 1069 e = PD->instmeth_end(); i != e; ++i) { 1070 ObjCMethodDecl *MD = *i; 1071 llvm::Constant *C = GetMethodDescriptionConstant(MD); 1072 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) { 1073 OptInstanceMethods.push_back(C); 1074 } else { 1075 InstanceMethods.push_back(C); 1076 } 1077 } 1078 1079 for (ObjCProtocolDecl::classmeth_iterator i = PD->classmeth_begin(), 1080 e = PD->classmeth_end(); i != e; ++i) { 1081 ObjCMethodDecl *MD = *i; 1082 llvm::Constant *C = GetMethodDescriptionConstant(MD); 1083 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) { 1084 OptClassMethods.push_back(C); 1085 } else { 1086 ClassMethods.push_back(C); 1087 } 1088 } 1089 1090 std::vector<llvm::Constant*> Values(5); 1091 Values[0] = EmitProtocolExtension(PD, OptInstanceMethods, OptClassMethods); 1092 Values[1] = GetClassName(PD->getIdentifier()); 1093 Values[2] = 1094 EmitProtocolList("\01L_OBJC_PROTOCOL_REFS_" + PD->getNameAsString(), 1095 PD->protocol_begin(), 1096 PD->protocol_end()); 1097 Values[3] = 1098 EmitMethodDescList("\01L_OBJC_PROTOCOL_INSTANCE_METHODS_" 1099 + PD->getNameAsString(), 1100 "__OBJC,__cat_inst_meth,regular,no_dead_strip", 1101 InstanceMethods); 1102 Values[4] = 1103 EmitMethodDescList("\01L_OBJC_PROTOCOL_CLASS_METHODS_" 1104 + PD->getNameAsString(), 1105 "__OBJC,__cat_cls_meth,regular,no_dead_strip", 1106 ClassMethods); 1107 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ProtocolTy, 1108 Values); 1109 1110 if (Entry) { 1111 // Already created, fix the linkage and update the initializer. 1112 Entry->setLinkage(llvm::GlobalValue::InternalLinkage); 1113 Entry->setInitializer(Init); 1114 } else { 1115 Entry = 1116 new llvm::GlobalVariable(ObjCTypes.ProtocolTy, false, 1117 llvm::GlobalValue::InternalLinkage, 1118 Init, 1119 std::string("\01L_OBJC_PROTOCOL_")+ProtocolName, 1120 &CGM.getModule()); 1121 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip"); 1122 Entry->setAlignment(4); 1123 UsedGlobals.push_back(Entry); 1124 // FIXME: Is this necessary? Why only for protocol? 1125 Entry->setAlignment(4); 1126 } 1127 1128 return Entry; 1129} 1130 1131llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) { 1132 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()]; 1133 1134 if (!Entry) { 1135 // We use the initializer as a marker of whether this is a forward 1136 // reference or not. At module finalization we add the empty 1137 // contents for protocols which were referenced but never defined. 1138 Entry = 1139 new llvm::GlobalVariable(ObjCTypes.ProtocolTy, false, 1140 llvm::GlobalValue::ExternalLinkage, 1141 0, 1142 "\01L_OBJC_PROTOCOL_" + PD->getNameAsString(), 1143 &CGM.getModule()); 1144 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip"); 1145 Entry->setAlignment(4); 1146 UsedGlobals.push_back(Entry); 1147 // FIXME: Is this necessary? Why only for protocol? 1148 Entry->setAlignment(4); 1149 } 1150 1151 return Entry; 1152} 1153 1154/* 1155 struct _objc_protocol_extension { 1156 uint32_t size; 1157 struct objc_method_description_list *optional_instance_methods; 1158 struct objc_method_description_list *optional_class_methods; 1159 struct objc_property_list *instance_properties; 1160 }; 1161*/ 1162llvm::Constant * 1163CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD, 1164 const ConstantVector &OptInstanceMethods, 1165 const ConstantVector &OptClassMethods) { 1166 uint64_t Size = 1167 CGM.getTargetData().getTypePaddedSize(ObjCTypes.ProtocolExtensionTy); 1168 std::vector<llvm::Constant*> Values(4); 1169 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size); 1170 Values[1] = 1171 EmitMethodDescList("\01L_OBJC_PROTOCOL_INSTANCE_METHODS_OPT_" 1172 + PD->getNameAsString(), 1173 "__OBJC,__cat_inst_meth,regular,no_dead_strip", 1174 OptInstanceMethods); 1175 Values[2] = 1176 EmitMethodDescList("\01L_OBJC_PROTOCOL_CLASS_METHODS_OPT_" 1177 + PD->getNameAsString(), 1178 "__OBJC,__cat_cls_meth,regular,no_dead_strip", 1179 OptClassMethods); 1180 Values[3] = EmitPropertyList("\01L_OBJC_$_PROP_PROTO_LIST_" + 1181 PD->getNameAsString(), 1182 0, PD, ObjCTypes); 1183 1184 // Return null if no extension bits are used. 1185 if (Values[1]->isNullValue() && Values[2]->isNullValue() && 1186 Values[3]->isNullValue()) 1187 return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy); 1188 1189 llvm::Constant *Init = 1190 llvm::ConstantStruct::get(ObjCTypes.ProtocolExtensionTy, Values); 1191 1192 // No special section, but goes in llvm.used 1193 return CreateMetadataVar("\01L_OBJC_PROTOCOLEXT_" + PD->getNameAsString(), 1194 Init, 1195 0, 0, true); 1196} 1197 1198/* 1199 struct objc_protocol_list { 1200 struct objc_protocol_list *next; 1201 long count; 1202 Protocol *list[]; 1203 }; 1204*/ 1205llvm::Constant * 1206CGObjCMac::EmitProtocolList(const std::string &Name, 1207 ObjCProtocolDecl::protocol_iterator begin, 1208 ObjCProtocolDecl::protocol_iterator end) { 1209 std::vector<llvm::Constant*> ProtocolRefs; 1210 1211 for (; begin != end; ++begin) 1212 ProtocolRefs.push_back(GetProtocolRef(*begin)); 1213 1214 // Just return null for empty protocol lists 1215 if (ProtocolRefs.empty()) 1216 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy); 1217 1218 // This list is null terminated. 1219 ProtocolRefs.push_back(llvm::Constant::getNullValue(ObjCTypes.ProtocolPtrTy)); 1220 1221 std::vector<llvm::Constant*> Values(3); 1222 // This field is only used by the runtime. 1223 Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy); 1224 Values[1] = llvm::ConstantInt::get(ObjCTypes.LongTy, ProtocolRefs.size() - 1); 1225 Values[2] = 1226 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.ProtocolPtrTy, 1227 ProtocolRefs.size()), 1228 ProtocolRefs); 1229 1230 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 1231 llvm::GlobalVariable *GV = 1232 CreateMetadataVar(Name, Init, "__OBJC,__cat_cls_meth,regular,no_dead_strip", 1233 4, false); 1234 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy); 1235} 1236 1237/* 1238 struct _objc_property { 1239 const char * const name; 1240 const char * const attributes; 1241 }; 1242 1243 struct _objc_property_list { 1244 uint32_t entsize; // sizeof (struct _objc_property) 1245 uint32_t prop_count; 1246 struct _objc_property[prop_count]; 1247 }; 1248*/ 1249llvm::Constant *CGObjCCommonMac::EmitPropertyList(const std::string &Name, 1250 const Decl *Container, 1251 const ObjCContainerDecl *OCD, 1252 const ObjCCommonTypesHelper &ObjCTypes) { 1253 std::vector<llvm::Constant*> Properties, Prop(2); 1254 for (ObjCContainerDecl::prop_iterator I = OCD->prop_begin(), 1255 E = OCD->prop_end(); I != E; ++I) { 1256 const ObjCPropertyDecl *PD = *I; 1257 Prop[0] = GetPropertyName(PD->getIdentifier()); 1258 Prop[1] = GetPropertyTypeString(PD, Container); 1259 Properties.push_back(llvm::ConstantStruct::get(ObjCTypes.PropertyTy, 1260 Prop)); 1261 } 1262 1263 // Return null for empty list. 1264 if (Properties.empty()) 1265 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy); 1266 1267 unsigned PropertySize = 1268 CGM.getTargetData().getTypePaddedSize(ObjCTypes.PropertyTy); 1269 std::vector<llvm::Constant*> Values(3); 1270 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, PropertySize); 1271 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Properties.size()); 1272 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.PropertyTy, 1273 Properties.size()); 1274 Values[2] = llvm::ConstantArray::get(AT, Properties); 1275 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 1276 1277 // No special section on property lists? 1278 llvm::GlobalVariable *GV = 1279 CreateMetadataVar(Name, Init, (ObjCABI == 2) ? "__DATA, __objc_const" : 0, 1280 0, true); 1281 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy); 1282} 1283 1284/* 1285 struct objc_method_description_list { 1286 int count; 1287 struct objc_method_description list[]; 1288 }; 1289*/ 1290llvm::Constant * 1291CGObjCMac::GetMethodDescriptionConstant(const ObjCMethodDecl *MD) { 1292 std::vector<llvm::Constant*> Desc(2); 1293 Desc[0] = llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()), 1294 ObjCTypes.SelectorPtrTy); 1295 Desc[1] = GetMethodVarType(MD); 1296 return llvm::ConstantStruct::get(ObjCTypes.MethodDescriptionTy, 1297 Desc); 1298} 1299 1300llvm::Constant *CGObjCMac::EmitMethodDescList(const std::string &Name, 1301 const char *Section, 1302 const ConstantVector &Methods) { 1303 // Return null for empty list. 1304 if (Methods.empty()) 1305 return llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy); 1306 1307 std::vector<llvm::Constant*> Values(2); 1308 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size()); 1309 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodDescriptionTy, 1310 Methods.size()); 1311 Values[1] = llvm::ConstantArray::get(AT, Methods); 1312 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 1313 1314 llvm::GlobalVariable *GV = CreateMetadataVar(Name, Init, Section, 0, true); 1315 return llvm::ConstantExpr::getBitCast(GV, 1316 ObjCTypes.MethodDescriptionListPtrTy); 1317} 1318 1319/* 1320 struct _objc_category { 1321 char *category_name; 1322 char *class_name; 1323 struct _objc_method_list *instance_methods; 1324 struct _objc_method_list *class_methods; 1325 struct _objc_protocol_list *protocols; 1326 uint32_t size; // <rdar://4585769> 1327 struct _objc_property_list *instance_properties; 1328 }; 1329 */ 1330void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) { 1331 unsigned Size = CGM.getTargetData().getTypePaddedSize(ObjCTypes.CategoryTy); 1332 1333 // FIXME: This is poor design, the OCD should have a pointer to the 1334 // category decl. Additionally, note that Category can be null for 1335 // the @implementation w/o an @interface case. Sema should just 1336 // create one for us as it does for @implementation so everyone else 1337 // can live life under a clear blue sky. 1338 const ObjCInterfaceDecl *Interface = OCD->getClassInterface(); 1339 const ObjCCategoryDecl *Category = 1340 Interface->FindCategoryDeclaration(OCD->getIdentifier()); 1341 std::string ExtName(Interface->getNameAsString() + "_" + 1342 OCD->getNameAsString()); 1343 1344 std::vector<llvm::Constant*> InstanceMethods, ClassMethods; 1345 for (ObjCCategoryImplDecl::instmeth_iterator i = OCD->instmeth_begin(), 1346 e = OCD->instmeth_end(); i != e; ++i) { 1347 // Instance methods should always be defined. 1348 InstanceMethods.push_back(GetMethodConstant(*i)); 1349 } 1350 for (ObjCCategoryImplDecl::classmeth_iterator i = OCD->classmeth_begin(), 1351 e = OCD->classmeth_end(); i != e; ++i) { 1352 // Class methods should always be defined. 1353 ClassMethods.push_back(GetMethodConstant(*i)); 1354 } 1355 1356 std::vector<llvm::Constant*> Values(7); 1357 Values[0] = GetClassName(OCD->getIdentifier()); 1358 Values[1] = GetClassName(Interface->getIdentifier()); 1359 Values[2] = 1360 EmitMethodList(std::string("\01L_OBJC_CATEGORY_INSTANCE_METHODS_") + 1361 ExtName, 1362 "__OBJC,__cat_inst_meth,regular,no_dead_strip", 1363 InstanceMethods); 1364 Values[3] = 1365 EmitMethodList(std::string("\01L_OBJC_CATEGORY_CLASS_METHODS_") + ExtName, 1366 "__OBJC,__cat_class_meth,regular,no_dead_strip", 1367 ClassMethods); 1368 if (Category) { 1369 Values[4] = 1370 EmitProtocolList(std::string("\01L_OBJC_CATEGORY_PROTOCOLS_") + ExtName, 1371 Category->protocol_begin(), 1372 Category->protocol_end()); 1373 } else { 1374 Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy); 1375 } 1376 Values[5] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size); 1377 1378 // If there is no category @interface then there can be no properties. 1379 if (Category) { 1380 Values[6] = EmitPropertyList(std::string("\01L_OBJC_$_PROP_LIST_") + ExtName, 1381 OCD, Category, ObjCTypes); 1382 } else { 1383 Values[6] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy); 1384 } 1385 1386 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.CategoryTy, 1387 Values); 1388 1389 llvm::GlobalVariable *GV = 1390 CreateMetadataVar(std::string("\01L_OBJC_CATEGORY_")+ExtName, Init, 1391 "__OBJC,__category,regular,no_dead_strip", 1392 4, true); 1393 DefinedCategories.push_back(GV); 1394} 1395 1396// FIXME: Get from somewhere? 1397enum ClassFlags { 1398 eClassFlags_Factory = 0x00001, 1399 eClassFlags_Meta = 0x00002, 1400 // <rdr://5142207> 1401 eClassFlags_HasCXXStructors = 0x02000, 1402 eClassFlags_Hidden = 0x20000, 1403 eClassFlags_ABI2_Hidden = 0x00010, 1404 eClassFlags_ABI2_HasCXXStructors = 0x00004 // <rdr://4923634> 1405}; 1406 1407// <rdr://5142207&4705298&4843145> 1408static bool IsClassHidden(const ObjCInterfaceDecl *ID) { 1409 if (const VisibilityAttr *attr = ID->getAttr<VisibilityAttr>()) { 1410 // FIXME: Support -fvisibility 1411 switch (attr->getVisibility()) { 1412 default: 1413 assert(0 && "Unknown visibility"); 1414 return false; 1415 case VisibilityAttr::DefaultVisibility: 1416 case VisibilityAttr::ProtectedVisibility: // FIXME: What do we do here? 1417 return false; 1418 case VisibilityAttr::HiddenVisibility: 1419 return true; 1420 } 1421 } else { 1422 return false; // FIXME: Support -fvisibility 1423 } 1424} 1425 1426/* 1427 struct _objc_class { 1428 Class isa; 1429 Class super_class; 1430 const char *name; 1431 long version; 1432 long info; 1433 long instance_size; 1434 struct _objc_ivar_list *ivars; 1435 struct _objc_method_list *methods; 1436 struct _objc_cache *cache; 1437 struct _objc_protocol_list *protocols; 1438 // Objective-C 1.0 extensions (<rdr://4585769>) 1439 const char *ivar_layout; 1440 struct _objc_class_ext *ext; 1441 }; 1442 1443 See EmitClassExtension(); 1444 */ 1445void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) { 1446 DefinedSymbols.insert(ID->getIdentifier()); 1447 1448 std::string ClassName = ID->getNameAsString(); 1449 // FIXME: Gross 1450 ObjCInterfaceDecl *Interface = 1451 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface()); 1452 llvm::Constant *Protocols = 1453 EmitProtocolList("\01L_OBJC_CLASS_PROTOCOLS_" + ID->getNameAsString(), 1454 Interface->protocol_begin(), 1455 Interface->protocol_end()); 1456 const llvm::Type *InterfaceTy = 1457 CGM.getTypes().ConvertType(CGM.getContext().buildObjCInterfaceType(Interface)); 1458 unsigned Flags = eClassFlags_Factory; 1459 unsigned Size = CGM.getTargetData().getTypePaddedSize(InterfaceTy); 1460 1461 // FIXME: Set CXX-structors flag. 1462 if (IsClassHidden(ID->getClassInterface())) 1463 Flags |= eClassFlags_Hidden; 1464 1465 std::vector<llvm::Constant*> InstanceMethods, ClassMethods; 1466 for (ObjCImplementationDecl::instmeth_iterator i = ID->instmeth_begin(), 1467 e = ID->instmeth_end(); i != e; ++i) { 1468 // Instance methods should always be defined. 1469 InstanceMethods.push_back(GetMethodConstant(*i)); 1470 } 1471 for (ObjCImplementationDecl::classmeth_iterator i = ID->classmeth_begin(), 1472 e = ID->classmeth_end(); i != e; ++i) { 1473 // Class methods should always be defined. 1474 ClassMethods.push_back(GetMethodConstant(*i)); 1475 } 1476 1477 for (ObjCImplementationDecl::propimpl_iterator i = ID->propimpl_begin(), 1478 e = ID->propimpl_end(); i != e; ++i) { 1479 ObjCPropertyImplDecl *PID = *i; 1480 1481 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) { 1482 ObjCPropertyDecl *PD = PID->getPropertyDecl(); 1483 1484 if (ObjCMethodDecl *MD = PD->getGetterMethodDecl()) 1485 if (llvm::Constant *C = GetMethodConstant(MD)) 1486 InstanceMethods.push_back(C); 1487 if (ObjCMethodDecl *MD = PD->getSetterMethodDecl()) 1488 if (llvm::Constant *C = GetMethodConstant(MD)) 1489 InstanceMethods.push_back(C); 1490 } 1491 } 1492 1493 std::vector<llvm::Constant*> Values(12); 1494 Values[ 0] = EmitMetaClass(ID, Protocols, InterfaceTy, ClassMethods); 1495 if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) { 1496 // Record a reference to the super class. 1497 LazySymbols.insert(Super->getIdentifier()); 1498 1499 Values[ 1] = 1500 llvm::ConstantExpr::getBitCast(GetClassName(Super->getIdentifier()), 1501 ObjCTypes.ClassPtrTy); 1502 } else { 1503 Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy); 1504 } 1505 Values[ 2] = GetClassName(ID->getIdentifier()); 1506 // Version is always 0. 1507 Values[ 3] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0); 1508 Values[ 4] = llvm::ConstantInt::get(ObjCTypes.LongTy, Flags); 1509 Values[ 5] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size); 1510 Values[ 6] = EmitIvarList(ID, false); 1511 Values[ 7] = 1512 EmitMethodList("\01L_OBJC_INSTANCE_METHODS_" + ID->getNameAsString(), 1513 "__OBJC,__inst_meth,regular,no_dead_strip", 1514 InstanceMethods); 1515 // cache is always NULL. 1516 Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy); 1517 Values[ 9] = Protocols; 1518 // FIXME: Set ivar_layout 1519 Values[10] = GetIvarLayoutName(0, ObjCTypes); 1520 Values[11] = EmitClassExtension(ID); 1521 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy, 1522 Values); 1523 1524 llvm::GlobalVariable *GV = 1525 CreateMetadataVar(std::string("\01L_OBJC_CLASS_")+ClassName, Init, 1526 "__OBJC,__class,regular,no_dead_strip", 1527 4, true); 1528 DefinedClasses.push_back(GV); 1529} 1530 1531llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID, 1532 llvm::Constant *Protocols, 1533 const llvm::Type *InterfaceTy, 1534 const ConstantVector &Methods) { 1535 unsigned Flags = eClassFlags_Meta; 1536 unsigned Size = CGM.getTargetData().getTypePaddedSize(ObjCTypes.ClassTy); 1537 1538 if (IsClassHidden(ID->getClassInterface())) 1539 Flags |= eClassFlags_Hidden; 1540 1541 std::vector<llvm::Constant*> Values(12); 1542 // The isa for the metaclass is the root of the hierarchy. 1543 const ObjCInterfaceDecl *Root = ID->getClassInterface(); 1544 while (const ObjCInterfaceDecl *Super = Root->getSuperClass()) 1545 Root = Super; 1546 Values[ 0] = 1547 llvm::ConstantExpr::getBitCast(GetClassName(Root->getIdentifier()), 1548 ObjCTypes.ClassPtrTy); 1549 // The super class for the metaclass is emitted as the name of the 1550 // super class. The runtime fixes this up to point to the 1551 // *metaclass* for the super class. 1552 if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) { 1553 Values[ 1] = 1554 llvm::ConstantExpr::getBitCast(GetClassName(Super->getIdentifier()), 1555 ObjCTypes.ClassPtrTy); 1556 } else { 1557 Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy); 1558 } 1559 Values[ 2] = GetClassName(ID->getIdentifier()); 1560 // Version is always 0. 1561 Values[ 3] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0); 1562 Values[ 4] = llvm::ConstantInt::get(ObjCTypes.LongTy, Flags); 1563 Values[ 5] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size); 1564 Values[ 6] = EmitIvarList(ID, true); 1565 Values[ 7] = 1566 EmitMethodList("\01L_OBJC_CLASS_METHODS_" + ID->getNameAsString(), 1567 "__OBJC,__inst_meth,regular,no_dead_strip", 1568 Methods); 1569 // cache is always NULL. 1570 Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy); 1571 Values[ 9] = Protocols; 1572 // ivar_layout for metaclass is always NULL. 1573 Values[10] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy); 1574 // The class extension is always unused for metaclasses. 1575 Values[11] = llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy); 1576 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy, 1577 Values); 1578 1579 std::string Name("\01L_OBJC_METACLASS_"); 1580 Name += ID->getNameAsCString(); 1581 1582 // Check for a forward reference. 1583 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name); 1584 if (GV) { 1585 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy && 1586 "Forward metaclass reference has incorrect type."); 1587 GV->setLinkage(llvm::GlobalValue::InternalLinkage); 1588 GV->setInitializer(Init); 1589 } else { 1590 GV = new llvm::GlobalVariable(ObjCTypes.ClassTy, false, 1591 llvm::GlobalValue::InternalLinkage, 1592 Init, Name, 1593 &CGM.getModule()); 1594 } 1595 GV->setSection("__OBJC,__meta_class,regular,no_dead_strip"); 1596 GV->setAlignment(4); 1597 UsedGlobals.push_back(GV); 1598 1599 return GV; 1600} 1601 1602llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) { 1603 std::string Name = "\01L_OBJC_METACLASS_" + ID->getNameAsString(); 1604 1605 // FIXME: Should we look these up somewhere other than the 1606 // module. Its a bit silly since we only generate these while 1607 // processing an implementation, so exactly one pointer would work 1608 // if know when we entered/exitted an implementation block. 1609 1610 // Check for an existing forward reference. 1611 // Previously, metaclass with internal linkage may have been defined. 1612 // pass 'true' as 2nd argument so it is returned. 1613 if (llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true)) { 1614 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy && 1615 "Forward metaclass reference has incorrect type."); 1616 return GV; 1617 } else { 1618 // Generate as an external reference to keep a consistent 1619 // module. This will be patched up when we emit the metaclass. 1620 return new llvm::GlobalVariable(ObjCTypes.ClassTy, false, 1621 llvm::GlobalValue::ExternalLinkage, 1622 0, 1623 Name, 1624 &CGM.getModule()); 1625 } 1626} 1627 1628/* 1629 struct objc_class_ext { 1630 uint32_t size; 1631 const char *weak_ivar_layout; 1632 struct _objc_property_list *properties; 1633 }; 1634*/ 1635llvm::Constant * 1636CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID) { 1637 uint64_t Size = 1638 CGM.getTargetData().getTypePaddedSize(ObjCTypes.ClassExtensionTy); 1639 1640 std::vector<llvm::Constant*> Values(3); 1641 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size); 1642 // FIXME: Output weak_ivar_layout string. 1643 Values[1] = GetIvarLayoutName(0, ObjCTypes); 1644 Values[2] = EmitPropertyList("\01L_OBJC_$_PROP_LIST_" + ID->getNameAsString(), 1645 ID, ID->getClassInterface(), ObjCTypes); 1646 1647 // Return null if no extension bits are used. 1648 if (Values[1]->isNullValue() && Values[2]->isNullValue()) 1649 return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy); 1650 1651 llvm::Constant *Init = 1652 llvm::ConstantStruct::get(ObjCTypes.ClassExtensionTy, Values); 1653 return CreateMetadataVar("\01L_OBJC_CLASSEXT_" + ID->getNameAsString(), 1654 Init, 0, 0, true); 1655} 1656 1657/// countInheritedIvars - count number of ivars in class and its super class(s) 1658/// 1659static int countInheritedIvars(const ObjCInterfaceDecl *OI) { 1660 int count = 0; 1661 if (!OI) 1662 return 0; 1663 const ObjCInterfaceDecl *SuperClass = OI->getSuperClass(); 1664 if (SuperClass) 1665 count += countInheritedIvars(SuperClass); 1666 for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(), 1667 E = OI->ivar_end(); I != E; ++I) 1668 ++count; 1669 return count; 1670} 1671 1672/// getInterfaceDeclForIvar - Get the interface declaration node where 1673/// this ivar is declared in. 1674/// FIXME. Ideally, this info should be in the ivar node. But currently 1675/// it is not and prevailing wisdom is that ASTs should not have more 1676/// info than is absolutely needed, even though this info reflects the 1677/// source language. 1678/// 1679static const ObjCInterfaceDecl *getInterfaceDeclForIvar( 1680 const ObjCInterfaceDecl *OI, 1681 const ObjCIvarDecl *IVD) { 1682 if (!OI) 1683 return 0; 1684 assert(isa<ObjCInterfaceDecl>(OI) && "OI is not an interface"); 1685 for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(), 1686 E = OI->ivar_end(); I != E; ++I) 1687 if ((*I)->getIdentifier() == IVD->getIdentifier()) 1688 return OI; 1689 return getInterfaceDeclForIvar(OI->getSuperClass(), IVD); 1690} 1691 1692/* 1693 struct objc_ivar { 1694 char *ivar_name; 1695 char *ivar_type; 1696 int ivar_offset; 1697 }; 1698 1699 struct objc_ivar_list { 1700 int ivar_count; 1701 struct objc_ivar list[count]; 1702 }; 1703 */ 1704llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID, 1705 bool ForClass) { 1706 std::vector<llvm::Constant*> Ivars, Ivar(3); 1707 1708 // When emitting the root class GCC emits ivar entries for the 1709 // actual class structure. It is not clear if we need to follow this 1710 // behavior; for now lets try and get away with not doing it. If so, 1711 // the cleanest solution would be to make up an ObjCInterfaceDecl 1712 // for the class. 1713 if (ForClass) 1714 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy); 1715 1716 ObjCInterfaceDecl *OID = 1717 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface()); 1718 const llvm::StructLayout *Layout = GetInterfaceDeclStructLayout(OID); 1719 1720 RecordDecl::field_iterator ifield, pfield; 1721 const RecordDecl *RD = GetFirstIvarInRecord(OID, ifield, pfield); 1722 for (RecordDecl::field_iterator e = RD->field_end(); ifield != e; ++ifield) { 1723 FieldDecl *Field = *ifield; 1724 uint64_t Offset = GetIvarBaseOffset(Layout, Field); 1725 if (Field->getIdentifier()) 1726 Ivar[0] = GetMethodVarName(Field->getIdentifier()); 1727 else 1728 Ivar[0] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy); 1729 Ivar[1] = GetMethodVarType(Field); 1730 Ivar[2] = llvm::ConstantInt::get(ObjCTypes.IntTy, Offset); 1731 Ivars.push_back(llvm::ConstantStruct::get(ObjCTypes.IvarTy, Ivar)); 1732 } 1733 1734 // Return null for empty list. 1735 if (Ivars.empty()) 1736 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy); 1737 1738 std::vector<llvm::Constant*> Values(2); 1739 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Ivars.size()); 1740 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.IvarTy, 1741 Ivars.size()); 1742 Values[1] = llvm::ConstantArray::get(AT, Ivars); 1743 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 1744 1745 llvm::GlobalVariable *GV; 1746 if (ForClass) 1747 GV = CreateMetadataVar("\01L_OBJC_CLASS_VARIABLES_" + ID->getNameAsString(), 1748 Init, "__OBJC,__class_vars,regular,no_dead_strip", 1749 4, true); 1750 else 1751 GV = CreateMetadataVar("\01L_OBJC_INSTANCE_VARIABLES_" 1752 + ID->getNameAsString(), 1753 Init, "__OBJC,__instance_vars,regular,no_dead_strip", 1754 0, true); 1755 return llvm::ConstantExpr::getBitCast(GV, 1756 ObjCTypes.IvarListPtrTy); 1757} 1758 1759/* 1760 struct objc_method { 1761 SEL method_name; 1762 char *method_types; 1763 void *method; 1764 }; 1765 1766 struct objc_method_list { 1767 struct objc_method_list *obsolete; 1768 int count; 1769 struct objc_method methods_list[count]; 1770 }; 1771*/ 1772 1773/// GetMethodConstant - Return a struct objc_method constant for the 1774/// given method if it has been defined. The result is null if the 1775/// method has not been defined. The return value has type MethodPtrTy. 1776llvm::Constant *CGObjCMac::GetMethodConstant(const ObjCMethodDecl *MD) { 1777 // FIXME: Use DenseMap::lookup 1778 llvm::Function *Fn = MethodDefinitions[MD]; 1779 if (!Fn) 1780 return 0; 1781 1782 std::vector<llvm::Constant*> Method(3); 1783 Method[0] = 1784 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()), 1785 ObjCTypes.SelectorPtrTy); 1786 Method[1] = GetMethodVarType(MD); 1787 Method[2] = llvm::ConstantExpr::getBitCast(Fn, ObjCTypes.Int8PtrTy); 1788 return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Method); 1789} 1790 1791llvm::Constant *CGObjCMac::EmitMethodList(const std::string &Name, 1792 const char *Section, 1793 const ConstantVector &Methods) { 1794 // Return null for empty list. 1795 if (Methods.empty()) 1796 return llvm::Constant::getNullValue(ObjCTypes.MethodListPtrTy); 1797 1798 std::vector<llvm::Constant*> Values(3); 1799 Values[0] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy); 1800 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size()); 1801 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodTy, 1802 Methods.size()); 1803 Values[2] = llvm::ConstantArray::get(AT, Methods); 1804 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 1805 1806 llvm::GlobalVariable *GV = CreateMetadataVar(Name, Init, Section, 0, true); 1807 return llvm::ConstantExpr::getBitCast(GV, 1808 ObjCTypes.MethodListPtrTy); 1809} 1810 1811llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD, 1812 const ObjCContainerDecl *CD) { 1813 std::string Name; 1814 GetNameForMethod(OMD, CD, Name); 1815 1816 CodeGenTypes &Types = CGM.getTypes(); 1817 const llvm::FunctionType *MethodTy = 1818 Types.GetFunctionType(Types.getFunctionInfo(OMD), OMD->isVariadic()); 1819 llvm::Function *Method = 1820 llvm::Function::Create(MethodTy, 1821 llvm::GlobalValue::InternalLinkage, 1822 Name, 1823 &CGM.getModule()); 1824 MethodDefinitions.insert(std::make_pair(OMD, Method)); 1825 1826 return Method; 1827} 1828 1829uint64_t CGObjCCommonMac::GetIvarBaseOffset(const llvm::StructLayout *Layout, 1830 FieldDecl *Field) { 1831 if (!Field->isBitField()) 1832 return Layout->getElementOffset( 1833 CGM.getTypes().getLLVMFieldNo(Field)); 1834 // FIXME. Must be a better way of getting a bitfield base offset. 1835 uint64_t offset = CGM.getTypes().getLLVMFieldNo(Field); 1836 const llvm::Type *Ty = CGM.getTypes().ConvertTypeForMemRecursive(Field->getType()); 1837 uint64_t size = CGM.getTypes().getTargetData().getTypePaddedSizeInBits(Ty); 1838 offset = (offset*size)/8; 1839 return offset; 1840} 1841 1842/// GetFieldBaseOffset - return's field byt offset. 1843uint64_t CGObjCCommonMac::GetFieldBaseOffset(const ObjCInterfaceDecl *OI, 1844 const llvm::StructLayout *Layout, 1845 FieldDecl *Field) { 1846 const ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(Field); 1847 Field = const_cast<ObjCInterfaceDecl*>(OI)->lookupFieldDeclForIvar( 1848 CGM.getContext(), Ivar); 1849 uint64_t Offset = GetIvarBaseOffset(Layout, Field); 1850 return Offset; 1851} 1852 1853llvm::GlobalVariable * 1854CGObjCCommonMac::CreateMetadataVar(const std::string &Name, 1855 llvm::Constant *Init, 1856 const char *Section, 1857 unsigned Align, 1858 bool AddToUsed) { 1859 const llvm::Type *Ty = Init->getType(); 1860 llvm::GlobalVariable *GV = 1861 new llvm::GlobalVariable(Ty, false, 1862 llvm::GlobalValue::InternalLinkage, 1863 Init, 1864 Name, 1865 &CGM.getModule()); 1866 if (Section) 1867 GV->setSection(Section); 1868 if (Align) 1869 GV->setAlignment(Align); 1870 if (AddToUsed) 1871 UsedGlobals.push_back(GV); 1872 return GV; 1873} 1874 1875llvm::Function *CGObjCMac::ModuleInitFunction() { 1876 // Abuse this interface function as a place to finalize. 1877 FinishModule(); 1878 1879 return NULL; 1880} 1881 1882llvm::Function *CGObjCMac::GetPropertyGetFunction() { 1883 return ObjCTypes.GetPropertyFn; 1884} 1885 1886llvm::Function *CGObjCMac::GetPropertySetFunction() { 1887 return ObjCTypes.SetPropertyFn; 1888} 1889 1890llvm::Function *CGObjCMac::EnumerationMutationFunction() 1891{ 1892 return ObjCTypes.EnumerationMutationFn; 1893} 1894 1895/* 1896 1897Objective-C setjmp-longjmp (sjlj) Exception Handling 1898-- 1899 1900The basic framework for a @try-catch-finally is as follows: 1901{ 1902 objc_exception_data d; 1903 id _rethrow = null; 1904 bool _call_try_exit = true; 1905 1906 objc_exception_try_enter(&d); 1907 if (!setjmp(d.jmp_buf)) { 1908 ... try body ... 1909 } else { 1910 // exception path 1911 id _caught = objc_exception_extract(&d); 1912 1913 // enter new try scope for handlers 1914 if (!setjmp(d.jmp_buf)) { 1915 ... match exception and execute catch blocks ... 1916 1917 // fell off end, rethrow. 1918 _rethrow = _caught; 1919 ... jump-through-finally to finally_rethrow ... 1920 } else { 1921 // exception in catch block 1922 _rethrow = objc_exception_extract(&d); 1923 _call_try_exit = false; 1924 ... jump-through-finally to finally_rethrow ... 1925 } 1926 } 1927 ... jump-through-finally to finally_end ... 1928 1929finally: 1930 if (_call_try_exit) 1931 objc_exception_try_exit(&d); 1932 1933 ... finally block .... 1934 ... dispatch to finally destination ... 1935 1936finally_rethrow: 1937 objc_exception_throw(_rethrow); 1938 1939finally_end: 1940} 1941 1942This framework differs slightly from the one gcc uses, in that gcc 1943uses _rethrow to determine if objc_exception_try_exit should be called 1944and if the object should be rethrown. This breaks in the face of 1945throwing nil and introduces unnecessary branches. 1946 1947We specialize this framework for a few particular circumstances: 1948 1949 - If there are no catch blocks, then we avoid emitting the second 1950 exception handling context. 1951 1952 - If there is a catch-all catch block (i.e. @catch(...) or @catch(id 1953 e)) we avoid emitting the code to rethrow an uncaught exception. 1954 1955 - FIXME: If there is no @finally block we can do a few more 1956 simplifications. 1957 1958Rethrows and Jumps-Through-Finally 1959-- 1960 1961Support for implicit rethrows and jumping through the finally block is 1962handled by storing the current exception-handling context in 1963ObjCEHStack. 1964 1965In order to implement proper @finally semantics, we support one basic 1966mechanism for jumping through the finally block to an arbitrary 1967destination. Constructs which generate exits from a @try or @catch 1968block use this mechanism to implement the proper semantics by chaining 1969jumps, as necessary. 1970 1971This mechanism works like the one used for indirect goto: we 1972arbitrarily assign an ID to each destination and store the ID for the 1973destination in a variable prior to entering the finally block. At the 1974end of the finally block we simply create a switch to the proper 1975destination. 1976 1977Code gen for @synchronized(expr) stmt; 1978Effectively generating code for: 1979objc_sync_enter(expr); 1980@try stmt @finally { objc_sync_exit(expr); } 1981*/ 1982 1983void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, 1984 const Stmt &S) { 1985 bool isTry = isa<ObjCAtTryStmt>(S); 1986 // Create various blocks we refer to for handling @finally. 1987 llvm::BasicBlock *FinallyBlock = CGF.createBasicBlock("finally"); 1988 llvm::BasicBlock *FinallyExit = CGF.createBasicBlock("finally.exit"); 1989 llvm::BasicBlock *FinallyNoExit = CGF.createBasicBlock("finally.noexit"); 1990 llvm::BasicBlock *FinallyRethrow = CGF.createBasicBlock("finally.throw"); 1991 llvm::BasicBlock *FinallyEnd = CGF.createBasicBlock("finally.end"); 1992 1993 // For @synchronized, call objc_sync_enter(sync.expr). The 1994 // evaluation of the expression must occur before we enter the 1995 // @synchronized. We can safely avoid a temp here because jumps into 1996 // @synchronized are illegal & this will dominate uses. 1997 llvm::Value *SyncArg = 0; 1998 if (!isTry) { 1999 SyncArg = 2000 CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr()); 2001 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy); 2002 CGF.Builder.CreateCall(ObjCTypes.SyncEnterFn, SyncArg); 2003 } 2004 2005 // Push an EH context entry, used for handling rethrows and jumps 2006 // through finally. 2007 CGF.PushCleanupBlock(FinallyBlock); 2008 2009 CGF.ObjCEHValueStack.push_back(0); 2010 2011 // Allocate memory for the exception data and rethrow pointer. 2012 llvm::Value *ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy, 2013 "exceptiondata.ptr"); 2014 llvm::Value *RethrowPtr = CGF.CreateTempAlloca(ObjCTypes.ObjectPtrTy, 2015 "_rethrow"); 2016 llvm::Value *CallTryExitPtr = CGF.CreateTempAlloca(llvm::Type::Int1Ty, 2017 "_call_try_exit"); 2018 CGF.Builder.CreateStore(llvm::ConstantInt::getTrue(), CallTryExitPtr); 2019 2020 // Enter a new try block and call setjmp. 2021 CGF.Builder.CreateCall(ObjCTypes.ExceptionTryEnterFn, ExceptionData); 2022 llvm::Value *JmpBufPtr = CGF.Builder.CreateStructGEP(ExceptionData, 0, 2023 "jmpbufarray"); 2024 JmpBufPtr = CGF.Builder.CreateStructGEP(JmpBufPtr, 0, "tmp"); 2025 llvm::Value *SetJmpResult = CGF.Builder.CreateCall(ObjCTypes.SetJmpFn, 2026 JmpBufPtr, "result"); 2027 2028 llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try"); 2029 llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler"); 2030 CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(SetJmpResult, "threw"), 2031 TryHandler, TryBlock); 2032 2033 // Emit the @try block. 2034 CGF.EmitBlock(TryBlock); 2035 CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody() 2036 : cast<ObjCAtSynchronizedStmt>(S).getSynchBody()); 2037 CGF.EmitBranchThroughCleanup(FinallyEnd); 2038 2039 // Emit the "exception in @try" block. 2040 CGF.EmitBlock(TryHandler); 2041 2042 // Retrieve the exception object. We may emit multiple blocks but 2043 // nothing can cross this so the value is already in SSA form. 2044 llvm::Value *Caught = CGF.Builder.CreateCall(ObjCTypes.ExceptionExtractFn, 2045 ExceptionData, 2046 "caught"); 2047 CGF.ObjCEHValueStack.back() = Caught; 2048 if (!isTry) 2049 { 2050 CGF.Builder.CreateStore(Caught, RethrowPtr); 2051 CGF.Builder.CreateStore(llvm::ConstantInt::getFalse(), CallTryExitPtr); 2052 CGF.EmitBranchThroughCleanup(FinallyRethrow); 2053 } 2054 else if (const ObjCAtCatchStmt* CatchStmt = 2055 cast<ObjCAtTryStmt>(S).getCatchStmts()) 2056 { 2057 // Enter a new exception try block (in case a @catch block throws 2058 // an exception). 2059 CGF.Builder.CreateCall(ObjCTypes.ExceptionTryEnterFn, ExceptionData); 2060 2061 llvm::Value *SetJmpResult = CGF.Builder.CreateCall(ObjCTypes.SetJmpFn, 2062 JmpBufPtr, "result"); 2063 llvm::Value *Threw = CGF.Builder.CreateIsNotNull(SetJmpResult, "threw"); 2064 2065 llvm::BasicBlock *CatchBlock = CGF.createBasicBlock("catch"); 2066 llvm::BasicBlock *CatchHandler = CGF.createBasicBlock("catch.handler"); 2067 CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock); 2068 2069 CGF.EmitBlock(CatchBlock); 2070 2071 // Handle catch list. As a special case we check if everything is 2072 // matched and avoid generating code for falling off the end if 2073 // so. 2074 bool AllMatched = false; 2075 for (; CatchStmt; CatchStmt = CatchStmt->getNextCatchStmt()) { 2076 llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch"); 2077 2078 const ParmVarDecl *CatchParam = CatchStmt->getCatchParamDecl(); 2079 const PointerType *PT = 0; 2080 2081 // catch(...) always matches. 2082 if (!CatchParam) { 2083 AllMatched = true; 2084 } else { 2085 PT = CatchParam->getType()->getAsPointerType(); 2086 2087 // catch(id e) always matches. 2088 // FIXME: For the time being we also match id<X>; this should 2089 // be rejected by Sema instead. 2090 if ((PT && CGF.getContext().isObjCIdStructType(PT->getPointeeType())) || 2091 CatchParam->getType()->isObjCQualifiedIdType()) 2092 AllMatched = true; 2093 } 2094 2095 if (AllMatched) { 2096 if (CatchParam) { 2097 CGF.EmitLocalBlockVarDecl(*CatchParam); 2098 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?"); 2099 CGF.Builder.CreateStore(Caught, CGF.GetAddrOfLocalVar(CatchParam)); 2100 } 2101 2102 CGF.EmitStmt(CatchStmt->getCatchBody()); 2103 CGF.EmitBranchThroughCleanup(FinallyEnd); 2104 break; 2105 } 2106 2107 assert(PT && "Unexpected non-pointer type in @catch"); 2108 QualType T = PT->getPointeeType(); 2109 const ObjCInterfaceType *ObjCType = T->getAsObjCInterfaceType(); 2110 assert(ObjCType && "Catch parameter must have Objective-C type!"); 2111 2112 // Check if the @catch block matches the exception object. 2113 llvm::Value *Class = EmitClassRef(CGF.Builder, ObjCType->getDecl()); 2114 2115 llvm::Value *Match = CGF.Builder.CreateCall2(ObjCTypes.ExceptionMatchFn, 2116 Class, Caught, "match"); 2117 2118 llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("matched"); 2119 2120 CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"), 2121 MatchedBlock, NextCatchBlock); 2122 2123 // Emit the @catch block. 2124 CGF.EmitBlock(MatchedBlock); 2125 CGF.EmitLocalBlockVarDecl(*CatchParam); 2126 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?"); 2127 2128 llvm::Value *Tmp = 2129 CGF.Builder.CreateBitCast(Caught, CGF.ConvertType(CatchParam->getType()), 2130 "tmp"); 2131 CGF.Builder.CreateStore(Tmp, CGF.GetAddrOfLocalVar(CatchParam)); 2132 2133 CGF.EmitStmt(CatchStmt->getCatchBody()); 2134 CGF.EmitBranchThroughCleanup(FinallyEnd); 2135 2136 CGF.EmitBlock(NextCatchBlock); 2137 } 2138 2139 if (!AllMatched) { 2140 // None of the handlers caught the exception, so store it to be 2141 // rethrown at the end of the @finally block. 2142 CGF.Builder.CreateStore(Caught, RethrowPtr); 2143 CGF.EmitBranchThroughCleanup(FinallyRethrow); 2144 } 2145 2146 // Emit the exception handler for the @catch blocks. 2147 CGF.EmitBlock(CatchHandler); 2148 CGF.Builder.CreateStore(CGF.Builder.CreateCall(ObjCTypes.ExceptionExtractFn, 2149 ExceptionData), 2150 RethrowPtr); 2151 CGF.Builder.CreateStore(llvm::ConstantInt::getFalse(), CallTryExitPtr); 2152 CGF.EmitBranchThroughCleanup(FinallyRethrow); 2153 } else { 2154 CGF.Builder.CreateStore(Caught, RethrowPtr); 2155 CGF.Builder.CreateStore(llvm::ConstantInt::getFalse(), CallTryExitPtr); 2156 CGF.EmitBranchThroughCleanup(FinallyRethrow); 2157 } 2158 2159 // Pop the exception-handling stack entry. It is important to do 2160 // this now, because the code in the @finally block is not in this 2161 // context. 2162 CodeGenFunction::CleanupBlockInfo Info = CGF.PopCleanupBlock(); 2163 2164 CGF.ObjCEHValueStack.pop_back(); 2165 2166 // Emit the @finally block. 2167 CGF.EmitBlock(FinallyBlock); 2168 llvm::Value* CallTryExit = CGF.Builder.CreateLoad(CallTryExitPtr, "tmp"); 2169 2170 CGF.Builder.CreateCondBr(CallTryExit, FinallyExit, FinallyNoExit); 2171 2172 CGF.EmitBlock(FinallyExit); 2173 CGF.Builder.CreateCall(ObjCTypes.ExceptionTryExitFn, ExceptionData); 2174 2175 CGF.EmitBlock(FinallyNoExit); 2176 if (isTry) { 2177 if (const ObjCAtFinallyStmt* FinallyStmt = 2178 cast<ObjCAtTryStmt>(S).getFinallyStmt()) 2179 CGF.EmitStmt(FinallyStmt->getFinallyBody()); 2180 } else { 2181 // Emit objc_sync_exit(expr); as finally's sole statement for 2182 // @synchronized. 2183 CGF.Builder.CreateCall(ObjCTypes.SyncExitFn, SyncArg); 2184 } 2185 2186 // Emit the switch block 2187 if (Info.SwitchBlock) 2188 CGF.EmitBlock(Info.SwitchBlock); 2189 if (Info.EndBlock) 2190 CGF.EmitBlock(Info.EndBlock); 2191 2192 CGF.EmitBlock(FinallyRethrow); 2193 CGF.Builder.CreateCall(ObjCTypes.ExceptionThrowFn, 2194 CGF.Builder.CreateLoad(RethrowPtr)); 2195 CGF.Builder.CreateUnreachable(); 2196 2197 CGF.EmitBlock(FinallyEnd); 2198} 2199 2200void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF, 2201 const ObjCAtThrowStmt &S) { 2202 llvm::Value *ExceptionAsObject; 2203 2204 if (const Expr *ThrowExpr = S.getThrowExpr()) { 2205 llvm::Value *Exception = CGF.EmitScalarExpr(ThrowExpr); 2206 ExceptionAsObject = 2207 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy, "tmp"); 2208 } else { 2209 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) && 2210 "Unexpected rethrow outside @catch block."); 2211 ExceptionAsObject = CGF.ObjCEHValueStack.back(); 2212 } 2213 2214 CGF.Builder.CreateCall(ObjCTypes.ExceptionThrowFn, ExceptionAsObject); 2215 CGF.Builder.CreateUnreachable(); 2216 2217 // Clear the insertion point to indicate we are in unreachable code. 2218 CGF.Builder.ClearInsertionPoint(); 2219} 2220 2221/// EmitObjCWeakRead - Code gen for loading value of a __weak 2222/// object: objc_read_weak (id *src) 2223/// 2224llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, 2225 llvm::Value *AddrWeakObj) 2226{ 2227 const llvm::Type* DestTy = 2228 cast<llvm::PointerType>(AddrWeakObj->getType())->getElementType(); 2229 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy); 2230 llvm::Value *read_weak = CGF.Builder.CreateCall(ObjCTypes.GcReadWeakFn, 2231 AddrWeakObj, "weakread"); 2232 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy); 2233 return read_weak; 2234} 2235 2236/// EmitObjCWeakAssign - Code gen for assigning to a __weak object. 2237/// objc_assign_weak (id src, id *dst) 2238/// 2239void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, 2240 llvm::Value *src, llvm::Value *dst) 2241{ 2242 if (!isa<llvm::PointerType>(src->getType())) { 2243 src = CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy); 2244 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 2245 } 2246 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 2247 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); 2248 CGF.Builder.CreateCall2(ObjCTypes.GcAssignWeakFn, 2249 src, dst, "weakassign"); 2250 return; 2251} 2252 2253/// EmitObjCGlobalAssign - Code gen for assigning to a __strong object. 2254/// objc_assign_global (id src, id *dst) 2255/// 2256void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, 2257 llvm::Value *src, llvm::Value *dst) 2258{ 2259 if (!isa<llvm::PointerType>(src->getType())) { 2260 src = CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy); 2261 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 2262 } 2263 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 2264 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); 2265 CGF.Builder.CreateCall2(ObjCTypes.GcAssignGlobalFn, 2266 src, dst, "globalassign"); 2267 return; 2268} 2269 2270/// EmitObjCIvarAssign - Code gen for assigning to a __strong object. 2271/// objc_assign_ivar (id src, id *dst) 2272/// 2273void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, 2274 llvm::Value *src, llvm::Value *dst) 2275{ 2276 if (!isa<llvm::PointerType>(src->getType())) { 2277 src = CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy); 2278 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 2279 } 2280 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 2281 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); 2282 CGF.Builder.CreateCall2(ObjCTypes.GcAssignIvarFn, 2283 src, dst, "assignivar"); 2284 return; 2285} 2286 2287/// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object. 2288/// objc_assign_strongCast (id src, id *dst) 2289/// 2290void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, 2291 llvm::Value *src, llvm::Value *dst) 2292{ 2293 if (!isa<llvm::PointerType>(src->getType())) { 2294 src = CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy); 2295 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 2296 } 2297 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 2298 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); 2299 CGF.Builder.CreateCall2(ObjCTypes.GcAssignStrongCastFn, 2300 src, dst, "weakassign"); 2301 return; 2302} 2303 2304/// EmitObjCValueForIvar - Code Gen for ivar reference. 2305/// 2306LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, 2307 QualType ObjectTy, 2308 llvm::Value *BaseValue, 2309 const ObjCIvarDecl *Ivar, 2310 const FieldDecl *Field, 2311 unsigned CVRQualifiers) { 2312 if (Ivar->isBitField()) 2313 return CGF.EmitLValueForBitfield(BaseValue, const_cast<FieldDecl *>(Field), 2314 CVRQualifiers); 2315 // TODO: Add a special case for isa (index 0) 2316 unsigned Index = CGM.getTypes().getLLVMFieldNo(Field); 2317 llvm::Value *V = CGF.Builder.CreateStructGEP(BaseValue, Index, "tmp"); 2318 LValue LV = LValue::MakeAddr(V, 2319 Ivar->getType().getCVRQualifiers()|CVRQualifiers, 2320 CGM.getContext().getObjCGCAttrKind(Ivar->getType())); 2321 LValue::SetObjCIvar(LV, true); 2322 return LV; 2323} 2324 2325llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF, 2326 ObjCInterfaceDecl *Interface, 2327 const ObjCIvarDecl *Ivar) { 2328 const llvm::StructLayout *Layout = GetInterfaceDeclStructLayout(Interface); 2329 FieldDecl *Field = Interface->lookupFieldDeclForIvar(CGM.getContext(), Ivar); 2330 uint64_t Offset = GetIvarBaseOffset(Layout, Field); 2331 return llvm::ConstantInt::get( 2332 CGM.getTypes().ConvertType(CGM.getContext().LongTy), 2333 Offset); 2334} 2335 2336/* *** Private Interface *** */ 2337 2338/// EmitImageInfo - Emit the image info marker used to encode some module 2339/// level information. 2340/// 2341/// See: <rdr://4810609&4810587&4810587> 2342/// struct IMAGE_INFO { 2343/// unsigned version; 2344/// unsigned flags; 2345/// }; 2346enum ImageInfoFlags { 2347 eImageInfo_FixAndContinue = (1 << 0), // FIXME: Not sure what this implies 2348 eImageInfo_GarbageCollected = (1 << 1), 2349 eImageInfo_GCOnly = (1 << 2) 2350}; 2351 2352void CGObjCMac::EmitImageInfo() { 2353 unsigned version = 0; // Version is unused? 2354 unsigned flags = 0; 2355 2356 // FIXME: Fix and continue? 2357 if (CGM.getLangOptions().getGCMode() != LangOptions::NonGC) 2358 flags |= eImageInfo_GarbageCollected; 2359 if (CGM.getLangOptions().getGCMode() == LangOptions::GCOnly) 2360 flags |= eImageInfo_GCOnly; 2361 2362 // Emitted as int[2]; 2363 llvm::Constant *values[2] = { 2364 llvm::ConstantInt::get(llvm::Type::Int32Ty, version), 2365 llvm::ConstantInt::get(llvm::Type::Int32Ty, flags) 2366 }; 2367 llvm::ArrayType *AT = llvm::ArrayType::get(llvm::Type::Int32Ty, 2); 2368 2369 const char *Section; 2370 if (ObjCABI == 1) 2371 Section = "__OBJC, __image_info,regular"; 2372 else 2373 Section = "__DATA, __objc_imageinfo, regular, no_dead_strip"; 2374 llvm::GlobalVariable *GV = 2375 CreateMetadataVar("\01L_OBJC_IMAGE_INFO", 2376 llvm::ConstantArray::get(AT, values, 2), 2377 Section, 2378 0, 2379 true); 2380 GV->setConstant(true); 2381} 2382 2383 2384// struct objc_module { 2385// unsigned long version; 2386// unsigned long size; 2387// const char *name; 2388// Symtab symtab; 2389// }; 2390 2391// FIXME: Get from somewhere 2392static const int ModuleVersion = 7; 2393 2394void CGObjCMac::EmitModuleInfo() { 2395 uint64_t Size = CGM.getTargetData().getTypePaddedSize(ObjCTypes.ModuleTy); 2396 2397 std::vector<llvm::Constant*> Values(4); 2398 Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, ModuleVersion); 2399 Values[1] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size); 2400 // This used to be the filename, now it is unused. <rdr://4327263> 2401 Values[2] = GetClassName(&CGM.getContext().Idents.get("")); 2402 Values[3] = EmitModuleSymbols(); 2403 CreateMetadataVar("\01L_OBJC_MODULES", 2404 llvm::ConstantStruct::get(ObjCTypes.ModuleTy, Values), 2405 "__OBJC,__module_info,regular,no_dead_strip", 2406 4, true); 2407} 2408 2409llvm::Constant *CGObjCMac::EmitModuleSymbols() { 2410 unsigned NumClasses = DefinedClasses.size(); 2411 unsigned NumCategories = DefinedCategories.size(); 2412 2413 // Return null if no symbols were defined. 2414 if (!NumClasses && !NumCategories) 2415 return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy); 2416 2417 std::vector<llvm::Constant*> Values(5); 2418 Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0); 2419 Values[1] = llvm::Constant::getNullValue(ObjCTypes.SelectorPtrTy); 2420 Values[2] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumClasses); 2421 Values[3] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumCategories); 2422 2423 // The runtime expects exactly the list of defined classes followed 2424 // by the list of defined categories, in a single array. 2425 std::vector<llvm::Constant*> Symbols(NumClasses + NumCategories); 2426 for (unsigned i=0; i<NumClasses; i++) 2427 Symbols[i] = llvm::ConstantExpr::getBitCast(DefinedClasses[i], 2428 ObjCTypes.Int8PtrTy); 2429 for (unsigned i=0; i<NumCategories; i++) 2430 Symbols[NumClasses + i] = 2431 llvm::ConstantExpr::getBitCast(DefinedCategories[i], 2432 ObjCTypes.Int8PtrTy); 2433 2434 Values[4] = 2435 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy, 2436 NumClasses + NumCategories), 2437 Symbols); 2438 2439 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 2440 2441 llvm::GlobalVariable *GV = 2442 CreateMetadataVar("\01L_OBJC_SYMBOLS", Init, 2443 "__OBJC,__symbols,regular,no_dead_strip", 2444 0, true); 2445 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy); 2446} 2447 2448llvm::Value *CGObjCMac::EmitClassRef(CGBuilderTy &Builder, 2449 const ObjCInterfaceDecl *ID) { 2450 LazySymbols.insert(ID->getIdentifier()); 2451 2452 llvm::GlobalVariable *&Entry = ClassReferences[ID->getIdentifier()]; 2453 2454 if (!Entry) { 2455 llvm::Constant *Casted = 2456 llvm::ConstantExpr::getBitCast(GetClassName(ID->getIdentifier()), 2457 ObjCTypes.ClassPtrTy); 2458 Entry = 2459 CreateMetadataVar("\01L_OBJC_CLASS_REFERENCES_", Casted, 2460 "__OBJC,__cls_refs,literal_pointers,no_dead_strip", 2461 0, true); 2462 } 2463 2464 return Builder.CreateLoad(Entry, false, "tmp"); 2465} 2466 2467llvm::Value *CGObjCMac::EmitSelector(CGBuilderTy &Builder, Selector Sel) { 2468 llvm::GlobalVariable *&Entry = SelectorReferences[Sel]; 2469 2470 if (!Entry) { 2471 llvm::Constant *Casted = 2472 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel), 2473 ObjCTypes.SelectorPtrTy); 2474 Entry = 2475 CreateMetadataVar("\01L_OBJC_SELECTOR_REFERENCES_", Casted, 2476 "__OBJC,__message_refs,literal_pointers,no_dead_strip", 2477 0, true); 2478 } 2479 2480 return Builder.CreateLoad(Entry, false, "tmp"); 2481} 2482 2483llvm::Constant *CGObjCCommonMac::GetClassName(IdentifierInfo *Ident) { 2484 llvm::GlobalVariable *&Entry = ClassNames[Ident]; 2485 2486 if (!Entry) 2487 Entry = CreateMetadataVar("\01L_OBJC_CLASS_NAME_", 2488 llvm::ConstantArray::get(Ident->getName()), 2489 "__TEXT,__cstring,cstring_literals", 2490 0, true); 2491 2492 return getConstantGEP(Entry, 0, 0); 2493} 2494 2495/// GetInterfaceDeclStructLayout - Get layout for ivars of given 2496/// interface declaration. 2497const llvm::StructLayout *CGObjCCommonMac::GetInterfaceDeclStructLayout( 2498 const ObjCInterfaceDecl *OID) const { 2499 const llvm::Type *InterfaceTy = 2500 CGM.getTypes().ConvertType( 2501 CGM.getContext().getObjCInterfaceType( 2502 const_cast<ObjCInterfaceDecl*>(OID))); 2503 const llvm::StructLayout *Layout = 2504 CGM.getTargetData().getStructLayout(cast<llvm::StructType>(InterfaceTy)); 2505 return Layout; 2506} 2507 2508/// GetIvarLayoutName - Returns a unique constant for the given 2509/// ivar layout bitmap. 2510llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident, 2511 const ObjCCommonTypesHelper &ObjCTypes) { 2512 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy); 2513} 2514 2515void CGObjCCommonMac::BuildAggrIvarLayout(const ObjCInterfaceDecl *OI, 2516 const llvm::StructLayout *Layout, 2517 const RecordDecl *RD, 2518 const std::vector<FieldDecl*>& RecFields, 2519 unsigned int BytePos, bool ForStrongLayout, 2520 int &Index, int &SkIndex, bool &HasUnion) { 2521 bool IsUnion = (RD && RD->isUnion()); 2522 uint64_t MaxUnionIvarSize = 0; 2523 uint64_t MaxSkippedUnionIvarSize = 0; 2524 FieldDecl *MaxField = 0; 2525 FieldDecl *MaxSkippedField = 0; 2526 unsigned int base = 0; 2527 if (RecFields.empty()) 2528 return; 2529 if (IsUnion) 2530 base = BytePos + GetFieldBaseOffset(OI, Layout, RecFields[0]); 2531 unsigned WordSizeInBits = CGM.getContext().getTypeSize( 2532 CGM.getContext().VoidPtrTy); 2533 unsigned ByteSizeInBits = CGM.getContext().getTypeSize( 2534 CGM.getContext().CharTy); 2535 for (unsigned i = 0; i < RecFields.size(); i++) { 2536 FieldDecl *Field = RecFields[i]; 2537 // Skip over unnamed or bitfields 2538 if (!Field->getIdentifier() || Field->isBitField()) 2539 continue; 2540 QualType FQT = Field->getType(); 2541 if (FQT->isAggregateType()) { 2542 std::vector<FieldDecl*> NestedRecFields; 2543 if (FQT->isUnionType()) 2544 HasUnion = true; 2545 else 2546 assert(FQT->isRecordType() && 2547 "only union/record is supported for ivar layout bitmap"); 2548 2549 const RecordType *RT = FQT->getAsRecordType(); 2550 const RecordDecl *RD = RT->getDecl(); 2551 // FIXME - Find a more efficiant way of passing records down. 2552 unsigned j = 0; 2553 for (RecordDecl::field_iterator i = RD->field_begin(), 2554 e = RD->field_end(); i != e; ++i) 2555 NestedRecFields[j++] = (*i); 2556 // FIXME - Is Layout correct? 2557 BuildAggrIvarLayout(OI, Layout, RD, NestedRecFields, 2558 BytePos + GetFieldBaseOffset(OI, Layout, Field), 2559 ForStrongLayout, Index, SkIndex, 2560 HasUnion); 2561 continue; 2562 } 2563 else if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) { 2564 const ConstantArrayType *CArray = 2565 dyn_cast_or_null<ConstantArrayType>(Array); 2566 assert(CArray && "only array with know element size is supported"); 2567 FQT = CArray->getElementType(); 2568 assert(!FQT->isUnionType() && 2569 "layout for array of unions not supported"); 2570 if (FQT->isRecordType()) { 2571 uint64_t ElCount = CArray->getSize().getZExtValue(); 2572 int OldIndex = Index; 2573 int OldSkIndex = SkIndex; 2574 2575 std::vector<FieldDecl*> ElementRecFields; 2576 // FIXME - Use a common routine with the above! 2577 const RecordType *RT = FQT->getAsRecordType(); 2578 const RecordDecl *RD = RT->getDecl(); 2579 // FIXME - Find a more efficiant way of passing records down. 2580 unsigned j = 0; 2581 for (RecordDecl::field_iterator i = RD->field_begin(), 2582 e = RD->field_end(); i != e; ++i) 2583 ElementRecFields[j++] = (*i); 2584 BuildAggrIvarLayout(OI, Layout, RD, 2585 ElementRecFields, 2586 BytePos + GetFieldBaseOffset(OI, Layout, Field), 2587 ForStrongLayout, Index, SkIndex, 2588 HasUnion); 2589 // Replicate layout information for each array element. Note that 2590 // one element is already done. 2591 uint64_t ElIx = 1; 2592 for (int FirstIndex = Index, FirstSkIndex = SkIndex; 2593 ElIx < ElCount; ElIx++) { 2594 uint64_t Size = CGM.getContext().getTypeSize(RT)/ByteSizeInBits; 2595 for (int i = OldIndex+1; i <= FirstIndex; ++i) 2596 { 2597 GC_IVAR gcivar; 2598 gcivar.ivar_bytepos = IvarsInfo[i].ivar_bytepos + Size*ElIx; 2599 gcivar.ivar_size = IvarsInfo[i].ivar_size; 2600 IvarsInfo.push_back(gcivar); ++Index; 2601 } 2602 2603 for (int i = OldSkIndex+1; i <= FirstSkIndex; ++i) 2604 { 2605 GC_IVAR skivar; 2606 skivar.ivar_bytepos = SkipIvars[i].ivar_bytepos + Size*ElIx; 2607 skivar.ivar_size = SkipIvars[i].ivar_size; 2608 SkipIvars.push_back(skivar); ++SkIndex; 2609 } 2610 } 2611 continue; 2612 } 2613 } 2614 // At this point, we are done with Record/Union and array there of. 2615 // For other arrays we are down to its element type. 2616 QualType::GCAttrTypes GCAttr = QualType::GCNone; 2617 do { 2618 if (FQT.isObjCGCStrong() || FQT.isObjCGCWeak()) { 2619 GCAttr = FQT.isObjCGCStrong() ? QualType::Strong : QualType::Weak; 2620 break; 2621 } 2622 else if (CGM.getContext().isObjCObjectPointerType(FQT)) { 2623 GCAttr = QualType::Strong; 2624 break; 2625 } 2626 else if (const PointerType *PT = FQT->getAsPointerType()) { 2627 FQT = PT->getPointeeType(); 2628 } 2629 else { 2630 break; 2631 } 2632 } while (true); 2633 if ((ForStrongLayout && GCAttr == QualType::Strong) 2634 || (!ForStrongLayout && GCAttr == QualType::Weak)) { 2635 if (IsUnion) 2636 { 2637 uint64_t UnionIvarSize = CGM.getContext().getTypeSize(Field->getType()) 2638 / WordSizeInBits; 2639 if (UnionIvarSize > MaxUnionIvarSize) 2640 { 2641 MaxUnionIvarSize = UnionIvarSize; 2642 MaxField = Field; 2643 } 2644 } 2645 else 2646 { 2647 GC_IVAR gcivar; 2648 gcivar.ivar_bytepos = BytePos + GetFieldBaseOffset(OI, Layout, Field); 2649 gcivar.ivar_size = CGM.getContext().getTypeSize(Field->getType()) / 2650 WordSizeInBits; 2651 IvarsInfo.push_back(gcivar); ++Index; 2652 } 2653 } 2654 else if ((ForStrongLayout && 2655 (GCAttr == QualType::GCNone || GCAttr == QualType::Weak)) 2656 || (!ForStrongLayout && GCAttr != QualType::Weak)) { 2657 if (IsUnion) 2658 { 2659 uint64_t UnionIvarSize = CGM.getContext().getTypeSize(Field->getType()); 2660 if (UnionIvarSize > MaxSkippedUnionIvarSize) 2661 { 2662 MaxSkippedUnionIvarSize = UnionIvarSize; 2663 MaxSkippedField = Field; 2664 } 2665 } 2666 else 2667 { 2668 GC_IVAR skivar; 2669 skivar.ivar_bytepos = BytePos + GetFieldBaseOffset(OI, Layout, Field); 2670 skivar.ivar_size = CGM.getContext().getTypeSize(Field->getType()) / 2671 WordSizeInBits; 2672 SkipIvars.push_back(skivar); ++SkIndex; 2673 } 2674 } 2675 } 2676 if (MaxField) 2677 { 2678 GC_IVAR gcivar; 2679 gcivar.ivar_bytepos = BytePos + GetFieldBaseOffset(OI, Layout, MaxField); 2680 gcivar.ivar_size = MaxUnionIvarSize; 2681 IvarsInfo.push_back(gcivar); ++Index; 2682 } 2683 if (MaxSkippedField) 2684 { 2685 GC_IVAR skivar; 2686 skivar.ivar_bytepos = BytePos + 2687 GetFieldBaseOffset(OI, Layout, MaxSkippedField); 2688 skivar.ivar_size = MaxSkippedUnionIvarSize; 2689 SkipIvars.push_back(skivar); ++SkIndex; 2690 } 2691 return; 2692} 2693 2694static int 2695IvarBytePosCompare (const void *a, const void *b) 2696{ 2697 unsigned int sa = ((CGObjCCommonMac::GC_IVAR *)a)->ivar_bytepos; 2698 unsigned int sb = ((CGObjCCommonMac::GC_IVAR *)b)->ivar_bytepos; 2699 2700 if (sa < sb) 2701 return -1; 2702 if (sa > sb) 2703 return 1; 2704 return 0; 2705} 2706 2707/// BuildIvarLayout - Builds ivar layout bitmap for the class 2708/// implementation for the __strong or __weak case. 2709/// The layout map displays which words in ivar list must be skipped 2710/// and which must be scanned by GC (see below). String is built of bytes. 2711/// Each byte is divided up in two nibbles (4-bit each). Left nibble is count 2712/// of words to skip and right nibble is count of words to scan. So, each 2713/// nibble represents up to 15 workds to skip or scan. Skipping the rest is 2714/// represented by a 0x00 byte which also ends the string. 2715/// 1. when ForStrongLayout is true, following ivars are scanned: 2716/// - id, Class 2717/// - object * 2718/// - __strong anything 2719/// 2720/// 2. When ForStrongLayout is false, following ivars are scanned: 2721/// - __weak anything 2722/// 2723llvm::Constant *CGObjCCommonMac::BuildIvarLayout( 2724 const ObjCImplementationDecl *OMD, 2725 bool ForStrongLayout) { 2726 int Index = -1; 2727 int SkIndex = -1; 2728 bool hasUnion = false; 2729 int SkipScan; 2730 unsigned int WordsToScan, WordsToSkip; 2731 const llvm::Type *PtrTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty); 2732 if (CGM.getLangOptions().getGCMode() == LangOptions::NonGC) 2733 return llvm::Constant::getNullValue(PtrTy); 2734 2735 std::vector<FieldDecl*> RecFields; 2736 const ObjCInterfaceDecl *OI = OMD->getClassInterface(); 2737 CGM.getContext().CollectObjCIvars(OI, RecFields); 2738 if (RecFields.empty()) 2739 return llvm::Constant::getNullValue(PtrTy); 2740 SkipIvars.clear(); 2741 IvarsInfo.clear(); 2742 2743 const llvm::StructLayout *Layout = GetInterfaceDeclStructLayout(OI); 2744 BuildAggrIvarLayout (OI, Layout, 0, RecFields, 0, ForStrongLayout, 2745 Index, SkIndex, hasUnion); 2746 if (Index == -1) 2747 return llvm::Constant::getNullValue(PtrTy); 2748 2749 // Sort on byte position in case we encounterred a union nested in 2750 // the ivar list. 2751 if (hasUnion && !IvarsInfo.empty()) 2752 qsort(&IvarsInfo[0], Index+1, sizeof(GC_IVAR), IvarBytePosCompare); 2753 if (hasUnion && !SkipIvars.empty()) 2754 qsort(&SkipIvars[0], Index+1, sizeof(GC_IVAR), IvarBytePosCompare); 2755 2756 // Build the string of skip/scan nibbles 2757 SkipScan = -1; 2758 SkipScanIvars.clear(); 2759 unsigned int WordSize = 2760 CGM.getTypes().getTargetData().getTypePaddedSize(PtrTy); 2761 if (IvarsInfo[0].ivar_bytepos == 0) { 2762 WordsToSkip = 0; 2763 WordsToScan = IvarsInfo[0].ivar_size; 2764 } 2765 else { 2766 WordsToSkip = IvarsInfo[0].ivar_bytepos/WordSize; 2767 WordsToScan = IvarsInfo[0].ivar_size; 2768 } 2769 for (unsigned int i=1, Last=IvarsInfo.size(); i != Last; i++) 2770 { 2771 unsigned int TailPrevGCObjC = 2772 IvarsInfo[i-1].ivar_bytepos + IvarsInfo[i-1].ivar_size * WordSize; 2773 if (IvarsInfo[i].ivar_bytepos == TailPrevGCObjC) 2774 { 2775 // consecutive 'scanned' object pointers. 2776 WordsToScan += IvarsInfo[i].ivar_size; 2777 } 2778 else 2779 { 2780 // Skip over 'gc'able object pointer which lay over each other. 2781 if (TailPrevGCObjC > IvarsInfo[i].ivar_bytepos) 2782 continue; 2783 // Must skip over 1 or more words. We save current skip/scan values 2784 // and start a new pair. 2785 SKIP_SCAN SkScan; 2786 SkScan.skip = WordsToSkip; 2787 SkScan.scan = WordsToScan; 2788 SkipScanIvars.push_back(SkScan); ++SkipScan; 2789 2790 // Skip the hole. 2791 SkScan.skip = (IvarsInfo[i].ivar_bytepos - TailPrevGCObjC) / WordSize; 2792 SkScan.scan = 0; 2793 SkipScanIvars.push_back(SkScan); ++SkipScan; 2794 WordsToSkip = 0; 2795 WordsToScan = IvarsInfo[i].ivar_size; 2796 } 2797 } 2798 if (WordsToScan > 0) 2799 { 2800 SKIP_SCAN SkScan; 2801 SkScan.skip = WordsToSkip; 2802 SkScan.scan = WordsToScan; 2803 SkipScanIvars.push_back(SkScan); ++SkipScan; 2804 } 2805 2806 bool BytesSkipped = false; 2807 if (!SkipIvars.empty()) 2808 { 2809 int LastByteSkipped = 2810 SkipIvars[SkIndex].ivar_bytepos + SkipIvars[SkIndex].ivar_size; 2811 int LastByteScanned = 2812 IvarsInfo[Index].ivar_bytepos + IvarsInfo[Index].ivar_size * WordSize; 2813 BytesSkipped = (LastByteSkipped > LastByteScanned); 2814 // Compute number of bytes to skip at the tail end of the last ivar scanned. 2815 if (BytesSkipped) 2816 { 2817 unsigned int TotalWords = (LastByteSkipped + (WordSize -1)) / WordSize; 2818 SKIP_SCAN SkScan; 2819 SkScan.skip = TotalWords - (LastByteScanned/WordSize); 2820 SkScan.scan = 0; 2821 SkipScanIvars.push_back(SkScan); ++SkipScan; 2822 } 2823 } 2824 // Mini optimization of nibbles such that an 0xM0 followed by 0x0N is produced 2825 // as 0xMN. 2826 for (int i = 0; i <= SkipScan; i++) 2827 { 2828 if ((i < SkipScan) && SkipScanIvars[i].skip && SkipScanIvars[i].scan == 0 2829 && SkipScanIvars[i+1].skip == 0 && SkipScanIvars[i+1].scan) { 2830 // 0xM0 followed by 0x0N detected. 2831 SkipScanIvars[i].scan = SkipScanIvars[i+1].scan; 2832 for (int j = i+1; j < SkipScan; j++) 2833 SkipScanIvars[j] = SkipScanIvars[j+1]; 2834 --SkipScan; 2835 } 2836 } 2837 2838 // Generate the string. 2839 std::string BitMap; 2840 for (int i = 0; i <= SkipScan; i++) 2841 { 2842 unsigned char byte; 2843 unsigned int skip_small = SkipScanIvars[i].skip % 0xf; 2844 unsigned int scan_small = SkipScanIvars[i].scan % 0xf; 2845 unsigned int skip_big = SkipScanIvars[i].skip / 0xf; 2846 unsigned int scan_big = SkipScanIvars[i].scan / 0xf; 2847 2848 if (skip_small > 0 || skip_big > 0) 2849 BytesSkipped = true; 2850 // first skip big. 2851 for (unsigned int ix = 0; ix < skip_big; ix++) 2852 BitMap += (unsigned char)(0xf0); 2853 2854 // next (skip small, scan) 2855 if (skip_small) 2856 { 2857 byte = skip_small << 4; 2858 if (scan_big > 0) 2859 { 2860 byte |= 0xf; 2861 --scan_big; 2862 } 2863 else if (scan_small) 2864 { 2865 byte |= scan_small; 2866 scan_small = 0; 2867 } 2868 BitMap += byte; 2869 } 2870 // next scan big 2871 for (unsigned int ix = 0; ix < scan_big; ix++) 2872 BitMap += (unsigned char)(0x0f); 2873 // last scan small 2874 if (scan_small) 2875 { 2876 byte = scan_small; 2877 BitMap += byte; 2878 } 2879 } 2880 // null terminate string. 2881 // BitMap += (unsigned char)0; 2882 // if ivar_layout bitmap is all 1 bits (nothing skipped) then use NULL as 2883 // final layout. 2884 if (ForStrongLayout && !BytesSkipped) 2885 return llvm::Constant::getNullValue(PtrTy); 2886 llvm::GlobalVariable * Entry = CreateMetadataVar("\01L_OBJC_CLASS_NAME_", 2887 llvm::ConstantArray::get(BitMap.c_str()), 2888 "__TEXT,__cstring,cstring_literals", 2889 0, true); 2890 return getConstantGEP(Entry, 0, 0); 2891} 2892 2893llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) { 2894 llvm::GlobalVariable *&Entry = MethodVarNames[Sel]; 2895 2896 // FIXME: Avoid std::string copying. 2897 if (!Entry) 2898 Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_NAME_", 2899 llvm::ConstantArray::get(Sel.getAsString()), 2900 "__TEXT,__cstring,cstring_literals", 2901 0, true); 2902 2903 return getConstantGEP(Entry, 0, 0); 2904} 2905 2906// FIXME: Merge into a single cstring creation function. 2907llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) { 2908 return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID)); 2909} 2910 2911// FIXME: Merge into a single cstring creation function. 2912llvm::Constant *CGObjCCommonMac::GetMethodVarName(const std::string &Name) { 2913 return GetMethodVarName(&CGM.getContext().Idents.get(Name)); 2914} 2915 2916llvm::Constant *CGObjCCommonMac::GetMethodVarType(FieldDecl *Field) { 2917 std::string TypeStr; 2918 CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field); 2919 2920 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr]; 2921 2922 if (!Entry) 2923 Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_TYPE_", 2924 llvm::ConstantArray::get(TypeStr), 2925 "__TEXT,__cstring,cstring_literals", 2926 0, true); 2927 2928 return getConstantGEP(Entry, 0, 0); 2929} 2930 2931llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D) { 2932 std::string TypeStr; 2933 CGM.getContext().getObjCEncodingForMethodDecl(const_cast<ObjCMethodDecl*>(D), 2934 TypeStr); 2935 2936 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr]; 2937 2938 if (!Entry) { 2939 llvm::Constant *C = llvm::ConstantArray::get(TypeStr); 2940 Entry = 2941 new llvm::GlobalVariable(C->getType(), false, 2942 llvm::GlobalValue::InternalLinkage, 2943 C, "\01L_OBJC_METH_VAR_TYPE_", 2944 &CGM.getModule()); 2945 Entry->setSection("__TEXT,__cstring,cstring_literals"); 2946 UsedGlobals.push_back(Entry); 2947 } 2948 2949 return getConstantGEP(Entry, 0, 0); 2950} 2951 2952// FIXME: Merge into a single cstring creation function. 2953llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) { 2954 llvm::GlobalVariable *&Entry = PropertyNames[Ident]; 2955 2956 if (!Entry) 2957 Entry = CreateMetadataVar("\01L_OBJC_PROP_NAME_ATTR_", 2958 llvm::ConstantArray::get(Ident->getName()), 2959 "__TEXT,__cstring,cstring_literals", 2960 0, true); 2961 2962 return getConstantGEP(Entry, 0, 0); 2963} 2964 2965// FIXME: Merge into a single cstring creation function. 2966// FIXME: This Decl should be more precise. 2967llvm::Constant * 2968 CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD, 2969 const Decl *Container) { 2970 std::string TypeStr; 2971 CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container, TypeStr); 2972 return GetPropertyName(&CGM.getContext().Idents.get(TypeStr)); 2973} 2974 2975void CGObjCCommonMac::GetNameForMethod(const ObjCMethodDecl *D, 2976 const ObjCContainerDecl *CD, 2977 std::string &NameOut) { 2978 // FIXME: Find the mangling GCC uses. 2979 NameOut = (D->isInstanceMethod() ? "-" : "+"); 2980 NameOut += '['; 2981 assert (CD && "Missing container decl in GetNameForMethod"); 2982 NameOut += CD->getNameAsString(); 2983 // FIXME. For a method in a category, (CAT_NAME) is inserted here. 2984 // Right now! there is not enough info. to do this. 2985 NameOut += ' '; 2986 NameOut += D->getSelector().getAsString(); 2987 NameOut += ']'; 2988} 2989 2990/// GetFirstIvarInRecord - This routine returns the record for the 2991/// implementation of the fiven class OID. It also returns field 2992/// corresponding to the first ivar in the class in FIV. It also 2993/// returns the one before the first ivar. 2994/// 2995const RecordDecl *CGObjCCommonMac::GetFirstIvarInRecord( 2996 const ObjCInterfaceDecl *OID, 2997 RecordDecl::field_iterator &FIV, 2998 RecordDecl::field_iterator &PIV) { 2999 int countSuperClassIvars = countInheritedIvars(OID->getSuperClass()); 3000 const RecordDecl *RD = CGM.getContext().addRecordToClass(OID); 3001 RecordDecl::field_iterator ifield = RD->field_begin(); 3002 RecordDecl::field_iterator pfield = RD->field_end(); 3003 while (countSuperClassIvars-- > 0) { 3004 pfield = ifield; 3005 ++ifield; 3006 } 3007 FIV = ifield; 3008 PIV = pfield; 3009 return RD; 3010} 3011 3012void CGObjCMac::FinishModule() { 3013 EmitModuleInfo(); 3014 3015 // Emit the dummy bodies for any protocols which were referenced but 3016 // never defined. 3017 for (llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*>::iterator 3018 i = Protocols.begin(), e = Protocols.end(); i != e; ++i) { 3019 if (i->second->hasInitializer()) 3020 continue; 3021 3022 std::vector<llvm::Constant*> Values(5); 3023 Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy); 3024 Values[1] = GetClassName(i->first); 3025 Values[2] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy); 3026 Values[3] = Values[4] = 3027 llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy); 3028 i->second->setLinkage(llvm::GlobalValue::InternalLinkage); 3029 i->second->setInitializer(llvm::ConstantStruct::get(ObjCTypes.ProtocolTy, 3030 Values)); 3031 } 3032 3033 std::vector<llvm::Constant*> Used; 3034 for (std::vector<llvm::GlobalVariable*>::iterator i = UsedGlobals.begin(), 3035 e = UsedGlobals.end(); i != e; ++i) { 3036 Used.push_back(llvm::ConstantExpr::getBitCast(*i, ObjCTypes.Int8PtrTy)); 3037 } 3038 3039 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy, Used.size()); 3040 llvm::GlobalValue *GV = 3041 new llvm::GlobalVariable(AT, false, 3042 llvm::GlobalValue::AppendingLinkage, 3043 llvm::ConstantArray::get(AT, Used), 3044 "llvm.used", 3045 &CGM.getModule()); 3046 3047 GV->setSection("llvm.metadata"); 3048 3049 // Add assembler directives to add lazy undefined symbol references 3050 // for classes which are referenced but not defined. This is 3051 // important for correct linker interaction. 3052 3053 // FIXME: Uh, this isn't particularly portable. 3054 std::stringstream s; 3055 3056 if (!CGM.getModule().getModuleInlineAsm().empty()) 3057 s << "\n"; 3058 3059 for (std::set<IdentifierInfo*>::iterator i = LazySymbols.begin(), 3060 e = LazySymbols.end(); i != e; ++i) { 3061 s << "\t.lazy_reference .objc_class_name_" << (*i)->getName() << "\n"; 3062 } 3063 for (std::set<IdentifierInfo*>::iterator i = DefinedSymbols.begin(), 3064 e = DefinedSymbols.end(); i != e; ++i) { 3065 s << "\t.objc_class_name_" << (*i)->getName() << "=0\n" 3066 << "\t.globl .objc_class_name_" << (*i)->getName() << "\n"; 3067 } 3068 3069 CGM.getModule().appendModuleInlineAsm(s.str()); 3070} 3071 3072CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm) 3073 : CGObjCCommonMac(cgm), 3074 ObjCTypes(cgm) 3075{ 3076 ObjCEmptyCacheVar = ObjCEmptyVtableVar = NULL; 3077 ObjCABI = 2; 3078} 3079 3080/* *** */ 3081 3082ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm) 3083: CGM(cgm) 3084{ 3085 CodeGen::CodeGenTypes &Types = CGM.getTypes(); 3086 ASTContext &Ctx = CGM.getContext(); 3087 3088 ShortTy = Types.ConvertType(Ctx.ShortTy); 3089 IntTy = Types.ConvertType(Ctx.IntTy); 3090 LongTy = Types.ConvertType(Ctx.LongTy); 3091 Int8PtrTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty); 3092 3093 ObjectPtrTy = Types.ConvertType(Ctx.getObjCIdType()); 3094 PtrObjectPtrTy = llvm::PointerType::getUnqual(ObjectPtrTy); 3095 SelectorPtrTy = Types.ConvertType(Ctx.getObjCSelType()); 3096 3097 // FIXME: It would be nice to unify this with the opaque type, so 3098 // that the IR comes out a bit cleaner. 3099 const llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType()); 3100 ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T); 3101 3102 // I'm not sure I like this. The implicit coordination is a bit 3103 // gross. We should solve this in a reasonable fashion because this 3104 // is a pretty common task (match some runtime data structure with 3105 // an LLVM data structure). 3106 3107 // FIXME: This is leaked. 3108 // FIXME: Merge with rewriter code? 3109 3110 // struct _objc_super { 3111 // id self; 3112 // Class cls; 3113 // } 3114 RecordDecl *RD = RecordDecl::Create(Ctx, TagDecl::TK_struct, 0, 3115 SourceLocation(), 3116 &Ctx.Idents.get("_objc_super")); 3117 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), 0, 3118 Ctx.getObjCIdType(), 0, false)); 3119 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), 0, 3120 Ctx.getObjCClassType(), 0, false)); 3121 RD->completeDefinition(Ctx); 3122 3123 SuperCTy = Ctx.getTagDeclType(RD); 3124 SuperPtrCTy = Ctx.getPointerType(SuperCTy); 3125 3126 SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy)); 3127 SuperPtrTy = llvm::PointerType::getUnqual(SuperTy); 3128 3129 // struct _prop_t { 3130 // char *name; 3131 // char *attributes; 3132 // } 3133 PropertyTy = llvm::StructType::get(Int8PtrTy, 3134 Int8PtrTy, 3135 NULL); 3136 CGM.getModule().addTypeName("struct._prop_t", 3137 PropertyTy); 3138 3139 // struct _prop_list_t { 3140 // uint32_t entsize; // sizeof(struct _prop_t) 3141 // uint32_t count_of_properties; 3142 // struct _prop_t prop_list[count_of_properties]; 3143 // } 3144 PropertyListTy = llvm::StructType::get(IntTy, 3145 IntTy, 3146 llvm::ArrayType::get(PropertyTy, 0), 3147 NULL); 3148 CGM.getModule().addTypeName("struct._prop_list_t", 3149 PropertyListTy); 3150 // struct _prop_list_t * 3151 PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy); 3152 3153 // struct _objc_method { 3154 // SEL _cmd; 3155 // char *method_type; 3156 // char *_imp; 3157 // } 3158 MethodTy = llvm::StructType::get(SelectorPtrTy, 3159 Int8PtrTy, 3160 Int8PtrTy, 3161 NULL); 3162 CGM.getModule().addTypeName("struct._objc_method", MethodTy); 3163 3164 // struct _objc_cache * 3165 CacheTy = llvm::OpaqueType::get(); 3166 CGM.getModule().addTypeName("struct._objc_cache", CacheTy); 3167 CachePtrTy = llvm::PointerType::getUnqual(CacheTy); 3168 3169 // Property manipulation functions. 3170 3171 QualType IdType = Ctx.getObjCIdType(); 3172 QualType SelType = Ctx.getObjCSelType(); 3173 llvm::SmallVector<QualType,16> Params; 3174 const llvm::FunctionType *FTy; 3175 3176 // id objc_getProperty (id, SEL, ptrdiff_t, bool) 3177 Params.push_back(IdType); 3178 Params.push_back(SelType); 3179 Params.push_back(Ctx.LongTy); 3180 Params.push_back(Ctx.BoolTy); 3181 FTy = Types.GetFunctionType(Types.getFunctionInfo(IdType, Params), 3182 false); 3183 GetPropertyFn = CGM.CreateRuntimeFunction(FTy, "objc_getProperty"); 3184 3185 // void objc_setProperty (id, SEL, ptrdiff_t, id, bool, bool) 3186 Params.clear(); 3187 Params.push_back(IdType); 3188 Params.push_back(SelType); 3189 Params.push_back(Ctx.LongTy); 3190 Params.push_back(IdType); 3191 Params.push_back(Ctx.BoolTy); 3192 Params.push_back(Ctx.BoolTy); 3193 FTy = Types.GetFunctionType(Types.getFunctionInfo(Ctx.VoidTy, Params), false); 3194 SetPropertyFn = CGM.CreateRuntimeFunction(FTy, "objc_setProperty"); 3195 3196 // Enumeration mutation. 3197 3198 // void objc_enumerationMutation (id) 3199 Params.clear(); 3200 Params.push_back(IdType); 3201 FTy = Types.GetFunctionType(Types.getFunctionInfo(Ctx.VoidTy, Params), false); 3202 EnumerationMutationFn = CGM.CreateRuntimeFunction(FTy, 3203 "objc_enumerationMutation"); 3204 3205 // gc's API 3206 // id objc_read_weak (id *) 3207 Params.clear(); 3208 Params.push_back(Ctx.getPointerType(IdType)); 3209 FTy = Types.GetFunctionType(Types.getFunctionInfo(IdType, Params), false); 3210 GcReadWeakFn = CGM.CreateRuntimeFunction(FTy, "objc_read_weak"); 3211 3212 // id objc_assign_weak (id, id *) 3213 Params.clear(); 3214 Params.push_back(IdType); 3215 Params.push_back(Ctx.getPointerType(IdType)); 3216 3217 FTy = Types.GetFunctionType(Types.getFunctionInfo(IdType, Params), false); 3218 GcAssignWeakFn = CGM.CreateRuntimeFunction(FTy, "objc_assign_weak"); 3219 GcAssignGlobalFn = CGM.CreateRuntimeFunction(FTy, "objc_assign_global"); 3220 GcAssignIvarFn = CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar"); 3221 GcAssignStrongCastFn = 3222 CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast"); 3223 3224 // void objc_exception_throw(id) 3225 Params.clear(); 3226 Params.push_back(IdType); 3227 3228 FTy = Types.GetFunctionType(Types.getFunctionInfo(Ctx.VoidTy, Params), false); 3229 ExceptionThrowFn = 3230 CGM.CreateRuntimeFunction(FTy, "objc_exception_throw"); 3231 3232 // synchronized APIs 3233 // void objc_sync_enter (id) 3234 // void objc_sync_exit (id) 3235 Params.clear(); 3236 Params.push_back(IdType); 3237 3238 FTy = Types.GetFunctionType(Types.getFunctionInfo(Ctx.VoidTy, Params), false); 3239 SyncEnterFn = CGM.CreateRuntimeFunction(FTy, "objc_sync_enter"); 3240 SyncExitFn = CGM.CreateRuntimeFunction(FTy, "objc_sync_exit"); 3241} 3242 3243ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm) 3244 : ObjCCommonTypesHelper(cgm) 3245{ 3246 // struct _objc_method_description { 3247 // SEL name; 3248 // char *types; 3249 // } 3250 MethodDescriptionTy = 3251 llvm::StructType::get(SelectorPtrTy, 3252 Int8PtrTy, 3253 NULL); 3254 CGM.getModule().addTypeName("struct._objc_method_description", 3255 MethodDescriptionTy); 3256 3257 // struct _objc_method_description_list { 3258 // int count; 3259 // struct _objc_method_description[1]; 3260 // } 3261 MethodDescriptionListTy = 3262 llvm::StructType::get(IntTy, 3263 llvm::ArrayType::get(MethodDescriptionTy, 0), 3264 NULL); 3265 CGM.getModule().addTypeName("struct._objc_method_description_list", 3266 MethodDescriptionListTy); 3267 3268 // struct _objc_method_description_list * 3269 MethodDescriptionListPtrTy = 3270 llvm::PointerType::getUnqual(MethodDescriptionListTy); 3271 3272 // Protocol description structures 3273 3274 // struct _objc_protocol_extension { 3275 // uint32_t size; // sizeof(struct _objc_protocol_extension) 3276 // struct _objc_method_description_list *optional_instance_methods; 3277 // struct _objc_method_description_list *optional_class_methods; 3278 // struct _objc_property_list *instance_properties; 3279 // } 3280 ProtocolExtensionTy = 3281 llvm::StructType::get(IntTy, 3282 MethodDescriptionListPtrTy, 3283 MethodDescriptionListPtrTy, 3284 PropertyListPtrTy, 3285 NULL); 3286 CGM.getModule().addTypeName("struct._objc_protocol_extension", 3287 ProtocolExtensionTy); 3288 3289 // struct _objc_protocol_extension * 3290 ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy); 3291 3292 // Handle recursive construction of Protocol and ProtocolList types 3293 3294 llvm::PATypeHolder ProtocolTyHolder = llvm::OpaqueType::get(); 3295 llvm::PATypeHolder ProtocolListTyHolder = llvm::OpaqueType::get(); 3296 3297 const llvm::Type *T = 3298 llvm::StructType::get(llvm::PointerType::getUnqual(ProtocolListTyHolder), 3299 LongTy, 3300 llvm::ArrayType::get(ProtocolTyHolder, 0), 3301 NULL); 3302 cast<llvm::OpaqueType>(ProtocolListTyHolder.get())->refineAbstractTypeTo(T); 3303 3304 // struct _objc_protocol { 3305 // struct _objc_protocol_extension *isa; 3306 // char *protocol_name; 3307 // struct _objc_protocol **_objc_protocol_list; 3308 // struct _objc_method_description_list *instance_methods; 3309 // struct _objc_method_description_list *class_methods; 3310 // } 3311 T = llvm::StructType::get(ProtocolExtensionPtrTy, 3312 Int8PtrTy, 3313 llvm::PointerType::getUnqual(ProtocolListTyHolder), 3314 MethodDescriptionListPtrTy, 3315 MethodDescriptionListPtrTy, 3316 NULL); 3317 cast<llvm::OpaqueType>(ProtocolTyHolder.get())->refineAbstractTypeTo(T); 3318 3319 ProtocolListTy = cast<llvm::StructType>(ProtocolListTyHolder.get()); 3320 CGM.getModule().addTypeName("struct._objc_protocol_list", 3321 ProtocolListTy); 3322 // struct _objc_protocol_list * 3323 ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy); 3324 3325 ProtocolTy = cast<llvm::StructType>(ProtocolTyHolder.get()); 3326 CGM.getModule().addTypeName("struct._objc_protocol", ProtocolTy); 3327 ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy); 3328 3329 // Class description structures 3330 3331 // struct _objc_ivar { 3332 // char *ivar_name; 3333 // char *ivar_type; 3334 // int ivar_offset; 3335 // } 3336 IvarTy = llvm::StructType::get(Int8PtrTy, 3337 Int8PtrTy, 3338 IntTy, 3339 NULL); 3340 CGM.getModule().addTypeName("struct._objc_ivar", IvarTy); 3341 3342 // struct _objc_ivar_list * 3343 IvarListTy = llvm::OpaqueType::get(); 3344 CGM.getModule().addTypeName("struct._objc_ivar_list", IvarListTy); 3345 IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy); 3346 3347 // struct _objc_method_list * 3348 MethodListTy = llvm::OpaqueType::get(); 3349 CGM.getModule().addTypeName("struct._objc_method_list", MethodListTy); 3350 MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy); 3351 3352 // struct _objc_class_extension * 3353 ClassExtensionTy = 3354 llvm::StructType::get(IntTy, 3355 Int8PtrTy, 3356 PropertyListPtrTy, 3357 NULL); 3358 CGM.getModule().addTypeName("struct._objc_class_extension", ClassExtensionTy); 3359 ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy); 3360 3361 llvm::PATypeHolder ClassTyHolder = llvm::OpaqueType::get(); 3362 3363 // struct _objc_class { 3364 // Class isa; 3365 // Class super_class; 3366 // char *name; 3367 // long version; 3368 // long info; 3369 // long instance_size; 3370 // struct _objc_ivar_list *ivars; 3371 // struct _objc_method_list *methods; 3372 // struct _objc_cache *cache; 3373 // struct _objc_protocol_list *protocols; 3374 // char *ivar_layout; 3375 // struct _objc_class_ext *ext; 3376 // }; 3377 T = llvm::StructType::get(llvm::PointerType::getUnqual(ClassTyHolder), 3378 llvm::PointerType::getUnqual(ClassTyHolder), 3379 Int8PtrTy, 3380 LongTy, 3381 LongTy, 3382 LongTy, 3383 IvarListPtrTy, 3384 MethodListPtrTy, 3385 CachePtrTy, 3386 ProtocolListPtrTy, 3387 Int8PtrTy, 3388 ClassExtensionPtrTy, 3389 NULL); 3390 cast<llvm::OpaqueType>(ClassTyHolder.get())->refineAbstractTypeTo(T); 3391 3392 ClassTy = cast<llvm::StructType>(ClassTyHolder.get()); 3393 CGM.getModule().addTypeName("struct._objc_class", ClassTy); 3394 ClassPtrTy = llvm::PointerType::getUnqual(ClassTy); 3395 3396 // struct _objc_category { 3397 // char *category_name; 3398 // char *class_name; 3399 // struct _objc_method_list *instance_method; 3400 // struct _objc_method_list *class_method; 3401 // uint32_t size; // sizeof(struct _objc_category) 3402 // struct _objc_property_list *instance_properties;// category's @property 3403 // } 3404 CategoryTy = llvm::StructType::get(Int8PtrTy, 3405 Int8PtrTy, 3406 MethodListPtrTy, 3407 MethodListPtrTy, 3408 ProtocolListPtrTy, 3409 IntTy, 3410 PropertyListPtrTy, 3411 NULL); 3412 CGM.getModule().addTypeName("struct._objc_category", CategoryTy); 3413 3414 // Global metadata structures 3415 3416 // struct _objc_symtab { 3417 // long sel_ref_cnt; 3418 // SEL *refs; 3419 // short cls_def_cnt; 3420 // short cat_def_cnt; 3421 // char *defs[cls_def_cnt + cat_def_cnt]; 3422 // } 3423 SymtabTy = llvm::StructType::get(LongTy, 3424 SelectorPtrTy, 3425 ShortTy, 3426 ShortTy, 3427 llvm::ArrayType::get(Int8PtrTy, 0), 3428 NULL); 3429 CGM.getModule().addTypeName("struct._objc_symtab", SymtabTy); 3430 SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy); 3431 3432 // struct _objc_module { 3433 // long version; 3434 // long size; // sizeof(struct _objc_module) 3435 // char *name; 3436 // struct _objc_symtab* symtab; 3437 // } 3438 ModuleTy = 3439 llvm::StructType::get(LongTy, 3440 LongTy, 3441 Int8PtrTy, 3442 SymtabPtrTy, 3443 NULL); 3444 CGM.getModule().addTypeName("struct._objc_module", ModuleTy); 3445 3446 // Message send functions. 3447 3448 // id objc_msgSend (id, SEL, ...) 3449 std::vector<const llvm::Type*> Params; 3450 Params.push_back(ObjectPtrTy); 3451 Params.push_back(SelectorPtrTy); 3452 MessageSendFn = 3453 CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 3454 Params, 3455 true), 3456 "objc_msgSend"); 3457 3458 // id objc_msgSend_stret (id, SEL, ...) 3459 Params.clear(); 3460 Params.push_back(ObjectPtrTy); 3461 Params.push_back(SelectorPtrTy); 3462 MessageSendStretFn = 3463 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::VoidTy, 3464 Params, 3465 true), 3466 "objc_msgSend_stret"); 3467 3468 // 3469 Params.clear(); 3470 Params.push_back(ObjectPtrTy); 3471 Params.push_back(SelectorPtrTy); 3472 // FIXME: This should be long double on x86_64? 3473 // [double | long double] objc_msgSend_fpret(id self, SEL op, ...) 3474 MessageSendFpretFn = 3475 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::DoubleTy, 3476 Params, 3477 true), 3478 "objc_msgSend_fpret"); 3479 3480 // id objc_msgSendSuper(struct objc_super *super, SEL op, ...) 3481 Params.clear(); 3482 Params.push_back(SuperPtrTy); 3483 Params.push_back(SelectorPtrTy); 3484 MessageSendSuperFn = 3485 CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 3486 Params, 3487 true), 3488 "objc_msgSendSuper"); 3489 3490 // void objc_msgSendSuper_stret(void * stretAddr, struct objc_super *super, 3491 // SEL op, ...) 3492 Params.clear(); 3493 Params.push_back(Int8PtrTy); 3494 Params.push_back(SuperPtrTy); 3495 Params.push_back(SelectorPtrTy); 3496 MessageSendSuperStretFn = 3497 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::VoidTy, 3498 Params, 3499 true), 3500 "objc_msgSendSuper_stret"); 3501 3502 // There is no objc_msgSendSuper_fpret? How can that work? 3503 MessageSendSuperFpretFn = MessageSendSuperFn; 3504 3505 // FIXME: This is the size of the setjmp buffer and should be 3506 // target specific. 18 is what's used on 32-bit X86. 3507 uint64_t SetJmpBufferSize = 18; 3508 3509 // Exceptions 3510 const llvm::Type *StackPtrTy = 3511 llvm::ArrayType::get(llvm::PointerType::getUnqual(llvm::Type::Int8Ty), 4); 3512 3513 ExceptionDataTy = 3514 llvm::StructType::get(llvm::ArrayType::get(llvm::Type::Int32Ty, 3515 SetJmpBufferSize), 3516 StackPtrTy, NULL); 3517 CGM.getModule().addTypeName("struct._objc_exception_data", 3518 ExceptionDataTy); 3519 3520 Params.clear(); 3521 Params.push_back(llvm::PointerType::getUnqual(ExceptionDataTy)); 3522 ExceptionTryEnterFn = 3523 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::VoidTy, 3524 Params, 3525 false), 3526 "objc_exception_try_enter"); 3527 ExceptionTryExitFn = 3528 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::VoidTy, 3529 Params, 3530 false), 3531 "objc_exception_try_exit"); 3532 ExceptionExtractFn = 3533 CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 3534 Params, 3535 false), 3536 "objc_exception_extract"); 3537 3538 Params.clear(); 3539 Params.push_back(ClassPtrTy); 3540 Params.push_back(ObjectPtrTy); 3541 ExceptionMatchFn = 3542 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::Int32Ty, 3543 Params, 3544 false), 3545 "objc_exception_match"); 3546 3547 Params.clear(); 3548 Params.push_back(llvm::PointerType::getUnqual(llvm::Type::Int32Ty)); 3549 SetJmpFn = 3550 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::Int32Ty, 3551 Params, 3552 false), 3553 "_setjmp"); 3554 3555} 3556 3557ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm) 3558: ObjCCommonTypesHelper(cgm) 3559{ 3560 // struct _method_list_t { 3561 // uint32_t entsize; // sizeof(struct _objc_method) 3562 // uint32_t method_count; 3563 // struct _objc_method method_list[method_count]; 3564 // } 3565 MethodListnfABITy = llvm::StructType::get(IntTy, 3566 IntTy, 3567 llvm::ArrayType::get(MethodTy, 0), 3568 NULL); 3569 CGM.getModule().addTypeName("struct.__method_list_t", 3570 MethodListnfABITy); 3571 // struct method_list_t * 3572 MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy); 3573 3574 // struct _protocol_t { 3575 // id isa; // NULL 3576 // const char * const protocol_name; 3577 // const struct _protocol_list_t * protocol_list; // super protocols 3578 // const struct method_list_t * const instance_methods; 3579 // const struct method_list_t * const class_methods; 3580 // const struct method_list_t *optionalInstanceMethods; 3581 // const struct method_list_t *optionalClassMethods; 3582 // const struct _prop_list_t * properties; 3583 // const uint32_t size; // sizeof(struct _protocol_t) 3584 // const uint32_t flags; // = 0 3585 // } 3586 3587 // Holder for struct _protocol_list_t * 3588 llvm::PATypeHolder ProtocolListTyHolder = llvm::OpaqueType::get(); 3589 3590 ProtocolnfABITy = llvm::StructType::get(ObjectPtrTy, 3591 Int8PtrTy, 3592 llvm::PointerType::getUnqual( 3593 ProtocolListTyHolder), 3594 MethodListnfABIPtrTy, 3595 MethodListnfABIPtrTy, 3596 MethodListnfABIPtrTy, 3597 MethodListnfABIPtrTy, 3598 PropertyListPtrTy, 3599 IntTy, 3600 IntTy, 3601 NULL); 3602 CGM.getModule().addTypeName("struct._protocol_t", 3603 ProtocolnfABITy); 3604 3605 // struct _protocol_t* 3606 ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy); 3607 3608 // struct _protocol_list_t { 3609 // long protocol_count; // Note, this is 32/64 bit 3610 // struct _protocol_t *[protocol_count]; 3611 // } 3612 ProtocolListnfABITy = llvm::StructType::get(LongTy, 3613 llvm::ArrayType::get( 3614 ProtocolnfABIPtrTy, 0), 3615 NULL); 3616 CGM.getModule().addTypeName("struct._objc_protocol_list", 3617 ProtocolListnfABITy); 3618 cast<llvm::OpaqueType>(ProtocolListTyHolder.get())->refineAbstractTypeTo( 3619 ProtocolListnfABITy); 3620 3621 // struct _objc_protocol_list* 3622 ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy); 3623 3624 // struct _ivar_t { 3625 // unsigned long int *offset; // pointer to ivar offset location 3626 // char *name; 3627 // char *type; 3628 // uint32_t alignment; 3629 // uint32_t size; 3630 // } 3631 IvarnfABITy = llvm::StructType::get(llvm::PointerType::getUnqual(LongTy), 3632 Int8PtrTy, 3633 Int8PtrTy, 3634 IntTy, 3635 IntTy, 3636 NULL); 3637 CGM.getModule().addTypeName("struct._ivar_t", IvarnfABITy); 3638 3639 // struct _ivar_list_t { 3640 // uint32 entsize; // sizeof(struct _ivar_t) 3641 // uint32 count; 3642 // struct _iver_t list[count]; 3643 // } 3644 IvarListnfABITy = llvm::StructType::get(IntTy, 3645 IntTy, 3646 llvm::ArrayType::get( 3647 IvarnfABITy, 0), 3648 NULL); 3649 CGM.getModule().addTypeName("struct._ivar_list_t", IvarListnfABITy); 3650 3651 IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy); 3652 3653 // struct _class_ro_t { 3654 // uint32_t const flags; 3655 // uint32_t const instanceStart; 3656 // uint32_t const instanceSize; 3657 // uint32_t const reserved; // only when building for 64bit targets 3658 // const uint8_t * const ivarLayout; 3659 // const char *const name; 3660 // const struct _method_list_t * const baseMethods; 3661 // const struct _objc_protocol_list *const baseProtocols; 3662 // const struct _ivar_list_t *const ivars; 3663 // const uint8_t * const weakIvarLayout; 3664 // const struct _prop_list_t * const properties; 3665 // } 3666 3667 // FIXME. Add 'reserved' field in 64bit abi mode! 3668 ClassRonfABITy = llvm::StructType::get(IntTy, 3669 IntTy, 3670 IntTy, 3671 Int8PtrTy, 3672 Int8PtrTy, 3673 MethodListnfABIPtrTy, 3674 ProtocolListnfABIPtrTy, 3675 IvarListnfABIPtrTy, 3676 Int8PtrTy, 3677 PropertyListPtrTy, 3678 NULL); 3679 CGM.getModule().addTypeName("struct._class_ro_t", 3680 ClassRonfABITy); 3681 3682 // ImpnfABITy - LLVM for id (*)(id, SEL, ...) 3683 std::vector<const llvm::Type*> Params; 3684 Params.push_back(ObjectPtrTy); 3685 Params.push_back(SelectorPtrTy); 3686 ImpnfABITy = llvm::PointerType::getUnqual( 3687 llvm::FunctionType::get(ObjectPtrTy, Params, false)); 3688 3689 // struct _class_t { 3690 // struct _class_t *isa; 3691 // struct _class_t * const superclass; 3692 // void *cache; 3693 // IMP *vtable; 3694 // struct class_ro_t *ro; 3695 // } 3696 3697 llvm::PATypeHolder ClassTyHolder = llvm::OpaqueType::get(); 3698 ClassnfABITy = llvm::StructType::get(llvm::PointerType::getUnqual(ClassTyHolder), 3699 llvm::PointerType::getUnqual(ClassTyHolder), 3700 CachePtrTy, 3701 llvm::PointerType::getUnqual(ImpnfABITy), 3702 llvm::PointerType::getUnqual( 3703 ClassRonfABITy), 3704 NULL); 3705 CGM.getModule().addTypeName("struct._class_t", ClassnfABITy); 3706 3707 cast<llvm::OpaqueType>(ClassTyHolder.get())->refineAbstractTypeTo( 3708 ClassnfABITy); 3709 3710 // LLVM for struct _class_t * 3711 ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy); 3712 3713 // struct _category_t { 3714 // const char * const name; 3715 // struct _class_t *const cls; 3716 // const struct _method_list_t * const instance_methods; 3717 // const struct _method_list_t * const class_methods; 3718 // const struct _protocol_list_t * const protocols; 3719 // const struct _prop_list_t * const properties; 3720 // } 3721 CategorynfABITy = llvm::StructType::get(Int8PtrTy, 3722 ClassnfABIPtrTy, 3723 MethodListnfABIPtrTy, 3724 MethodListnfABIPtrTy, 3725 ProtocolListnfABIPtrTy, 3726 PropertyListPtrTy, 3727 NULL); 3728 CGM.getModule().addTypeName("struct._category_t", CategorynfABITy); 3729 3730 // New types for nonfragile abi messaging. 3731 CodeGen::CodeGenTypes &Types = CGM.getTypes(); 3732 ASTContext &Ctx = CGM.getContext(); 3733 3734 // MessageRefTy - LLVM for: 3735 // struct _message_ref_t { 3736 // IMP messenger; 3737 // SEL name; 3738 // }; 3739 3740 // First the clang type for struct _message_ref_t 3741 RecordDecl *RD = RecordDecl::Create(Ctx, TagDecl::TK_struct, 0, 3742 SourceLocation(), 3743 &Ctx.Idents.get("_message_ref_t")); 3744 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), 0, 3745 Ctx.VoidPtrTy, 0, false)); 3746 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), 0, 3747 Ctx.getObjCSelType(), 0, false)); 3748 RD->completeDefinition(Ctx); 3749 3750 MessageRefCTy = Ctx.getTagDeclType(RD); 3751 MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy); 3752 MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy)); 3753 3754 // MessageRefPtrTy - LLVM for struct _message_ref_t* 3755 MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy); 3756 3757 // SuperMessageRefTy - LLVM for: 3758 // struct _super_message_ref_t { 3759 // SUPER_IMP messenger; 3760 // SEL name; 3761 // }; 3762 SuperMessageRefTy = llvm::StructType::get(ImpnfABITy, 3763 SelectorPtrTy, 3764 NULL); 3765 CGM.getModule().addTypeName("struct._super_message_ref_t", SuperMessageRefTy); 3766 3767 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t* 3768 SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy); 3769 3770 // id objc_msgSend_fixup (id, struct message_ref_t*, ...) 3771 Params.clear(); 3772 Params.push_back(ObjectPtrTy); 3773 Params.push_back(MessageRefPtrTy); 3774 MessengerTy = llvm::FunctionType::get(ObjectPtrTy, 3775 Params, 3776 true); 3777 MessageSendFixupFn = 3778 CGM.CreateRuntimeFunction(MessengerTy, 3779 "objc_msgSend_fixup"); 3780 3781 // id objc_msgSend_fpret_fixup (id, struct message_ref_t*, ...) 3782 MessageSendFpretFixupFn = 3783 CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 3784 Params, 3785 true), 3786 "objc_msgSend_fpret_fixup"); 3787 3788 // id objc_msgSend_stret_fixup (id, struct message_ref_t*, ...) 3789 MessageSendStretFixupFn = 3790 CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 3791 Params, 3792 true), 3793 "objc_msgSend_stret_fixup"); 3794 3795 // id objc_msgSendId_fixup (id, struct message_ref_t*, ...) 3796 MessageSendIdFixupFn = 3797 CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 3798 Params, 3799 true), 3800 "objc_msgSendId_fixup"); 3801 3802 3803 // id objc_msgSendId_stret_fixup (id, struct message_ref_t*, ...) 3804 MessageSendIdStretFixupFn = 3805 CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 3806 Params, 3807 true), 3808 "objc_msgSendId_stret_fixup"); 3809 3810 // id objc_msgSendSuper2_fixup (struct objc_super *, 3811 // struct _super_message_ref_t*, ...) 3812 Params.clear(); 3813 Params.push_back(SuperPtrTy); 3814 Params.push_back(SuperMessageRefPtrTy); 3815 MessageSendSuper2FixupFn = 3816 CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 3817 Params, 3818 true), 3819 "objc_msgSendSuper2_fixup"); 3820 3821 3822 // id objc_msgSendSuper2_stret_fixup (struct objc_super *, 3823 // struct _super_message_ref_t*, ...) 3824 MessageSendSuper2StretFixupFn = 3825 CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, 3826 Params, 3827 true), 3828 "objc_msgSendSuper2_stret_fixup"); 3829 3830 Params.clear(); 3831 llvm::Constant *Personality = 3832 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::Int32Ty, 3833 Params, 3834 true), 3835 "__objc_personality_v0"); 3836 EHPersonalityPtr = llvm::ConstantExpr::getBitCast(Personality, Int8PtrTy); 3837 3838 Params.clear(); 3839 Params.push_back(Int8PtrTy); 3840 UnwindResumeOrRethrowFn = 3841 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::VoidTy, 3842 Params, 3843 false), 3844 "_Unwind_Resume_or_Rethrow"); 3845 ObjCBeginCatchFn = 3846 CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy, 3847 Params, 3848 false), 3849 "objc_begin_catch"); 3850 3851 Params.clear(); 3852 ObjCEndCatchFn = 3853 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::VoidTy, 3854 Params, 3855 false), 3856 "objc_end_catch"); 3857 3858 // struct objc_typeinfo { 3859 // const void** vtable; // objc_ehtype_vtable + 2 3860 // const char* name; // c++ typeinfo string 3861 // Class cls; 3862 // }; 3863 EHTypeTy = llvm::StructType::get(llvm::PointerType::getUnqual(Int8PtrTy), 3864 Int8PtrTy, 3865 ClassnfABIPtrTy, 3866 NULL); 3867 CGM.getModule().addTypeName("struct._objc_typeinfo", EHTypeTy); 3868 EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy); 3869} 3870 3871llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() { 3872 FinishNonFragileABIModule(); 3873 3874 return NULL; 3875} 3876 3877void CGObjCNonFragileABIMac::FinishNonFragileABIModule() { 3878 // nonfragile abi has no module definition. 3879 3880 // Build list of all implemented classe addresses in array 3881 // L_OBJC_LABEL_CLASS_$. 3882 // FIXME. Also generate in L_OBJC_LABEL_NONLAZY_CLASS_$ 3883 // list of 'nonlazy' implementations (defined as those with a +load{} 3884 // method!!). 3885 unsigned NumClasses = DefinedClasses.size(); 3886 if (NumClasses) { 3887 std::vector<llvm::Constant*> Symbols(NumClasses); 3888 for (unsigned i=0; i<NumClasses; i++) 3889 Symbols[i] = llvm::ConstantExpr::getBitCast(DefinedClasses[i], 3890 ObjCTypes.Int8PtrTy); 3891 llvm::Constant* Init = 3892 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy, 3893 NumClasses), 3894 Symbols); 3895 3896 llvm::GlobalVariable *GV = 3897 new llvm::GlobalVariable(Init->getType(), false, 3898 llvm::GlobalValue::InternalLinkage, 3899 Init, 3900 "\01L_OBJC_LABEL_CLASS_$", 3901 &CGM.getModule()); 3902 GV->setAlignment(8); 3903 GV->setSection("__DATA, __objc_classlist, regular, no_dead_strip"); 3904 UsedGlobals.push_back(GV); 3905 } 3906 3907 // Build list of all implemented category addresses in array 3908 // L_OBJC_LABEL_CATEGORY_$. 3909 // FIXME. Also generate in L_OBJC_LABEL_NONLAZY_CATEGORY_$ 3910 // list of 'nonlazy' category implementations (defined as those with a +load{} 3911 // method!!). 3912 unsigned NumCategory = DefinedCategories.size(); 3913 if (NumCategory) { 3914 std::vector<llvm::Constant*> Symbols(NumCategory); 3915 for (unsigned i=0; i<NumCategory; i++) 3916 Symbols[i] = llvm::ConstantExpr::getBitCast(DefinedCategories[i], 3917 ObjCTypes.Int8PtrTy); 3918 llvm::Constant* Init = 3919 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy, 3920 NumCategory), 3921 Symbols); 3922 3923 llvm::GlobalVariable *GV = 3924 new llvm::GlobalVariable(Init->getType(), false, 3925 llvm::GlobalValue::InternalLinkage, 3926 Init, 3927 "\01L_OBJC_LABEL_CATEGORY_$", 3928 &CGM.getModule()); 3929 GV->setAlignment(8); 3930 GV->setSection("__DATA, __objc_catlist, regular, no_dead_strip"); 3931 UsedGlobals.push_back(GV); 3932 } 3933 3934 // static int L_OBJC_IMAGE_INFO[2] = { 0, flags }; 3935 // FIXME. flags can be 0 | 1 | 2 | 6. For now just use 0 3936 std::vector<llvm::Constant*> Values(2); 3937 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, 0); 3938 unsigned int flags = 0; 3939 // FIXME: Fix and continue? 3940 if (CGM.getLangOptions().getGCMode() != LangOptions::NonGC) 3941 flags |= eImageInfo_GarbageCollected; 3942 if (CGM.getLangOptions().getGCMode() == LangOptions::GCOnly) 3943 flags |= eImageInfo_GCOnly; 3944 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, flags); 3945 llvm::Constant* Init = llvm::ConstantArray::get( 3946 llvm::ArrayType::get(ObjCTypes.IntTy, 2), 3947 Values); 3948 llvm::GlobalVariable *IMGV = 3949 new llvm::GlobalVariable(Init->getType(), false, 3950 llvm::GlobalValue::InternalLinkage, 3951 Init, 3952 "\01L_OBJC_IMAGE_INFO", 3953 &CGM.getModule()); 3954 IMGV->setSection("__DATA, __objc_imageinfo, regular, no_dead_strip"); 3955 UsedGlobals.push_back(IMGV); 3956 3957 std::vector<llvm::Constant*> Used; 3958 for (std::vector<llvm::GlobalVariable*>::iterator i = UsedGlobals.begin(), 3959 e = UsedGlobals.end(); i != e; ++i) { 3960 Used.push_back(llvm::ConstantExpr::getBitCast(*i, ObjCTypes.Int8PtrTy)); 3961 } 3962 3963 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy, Used.size()); 3964 llvm::GlobalValue *GV = 3965 new llvm::GlobalVariable(AT, false, 3966 llvm::GlobalValue::AppendingLinkage, 3967 llvm::ConstantArray::get(AT, Used), 3968 "llvm.used", 3969 &CGM.getModule()); 3970 3971 GV->setSection("llvm.metadata"); 3972 3973} 3974 3975// Metadata flags 3976enum MetaDataDlags { 3977 CLS = 0x0, 3978 CLS_META = 0x1, 3979 CLS_ROOT = 0x2, 3980 OBJC2_CLS_HIDDEN = 0x10, 3981 CLS_EXCEPTION = 0x20 3982}; 3983/// BuildClassRoTInitializer - generate meta-data for: 3984/// struct _class_ro_t { 3985/// uint32_t const flags; 3986/// uint32_t const instanceStart; 3987/// uint32_t const instanceSize; 3988/// uint32_t const reserved; // only when building for 64bit targets 3989/// const uint8_t * const ivarLayout; 3990/// const char *const name; 3991/// const struct _method_list_t * const baseMethods; 3992/// const struct _protocol_list_t *const baseProtocols; 3993/// const struct _ivar_list_t *const ivars; 3994/// const uint8_t * const weakIvarLayout; 3995/// const struct _prop_list_t * const properties; 3996/// } 3997/// 3998llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer( 3999 unsigned flags, 4000 unsigned InstanceStart, 4001 unsigned InstanceSize, 4002 const ObjCImplementationDecl *ID) { 4003 std::string ClassName = ID->getNameAsString(); 4004 std::vector<llvm::Constant*> Values(10); // 11 for 64bit targets! 4005 Values[ 0] = llvm::ConstantInt::get(ObjCTypes.IntTy, flags); 4006 Values[ 1] = llvm::ConstantInt::get(ObjCTypes.IntTy, InstanceStart); 4007 Values[ 2] = llvm::ConstantInt::get(ObjCTypes.IntTy, InstanceSize); 4008 // FIXME. For 64bit targets add 0 here. 4009 // FIXME. ivarLayout is currently null! 4010 Values[ 3] = GetIvarLayoutName(0, ObjCTypes); 4011 Values[ 4] = GetClassName(ID->getIdentifier()); 4012 // const struct _method_list_t * const baseMethods; 4013 std::vector<llvm::Constant*> Methods; 4014 std::string MethodListName("\01l_OBJC_$_"); 4015 if (flags & CLS_META) { 4016 MethodListName += "CLASS_METHODS_" + ID->getNameAsString(); 4017 for (ObjCImplementationDecl::classmeth_iterator i = ID->classmeth_begin(), 4018 e = ID->classmeth_end(); i != e; ++i) { 4019 // Class methods should always be defined. 4020 Methods.push_back(GetMethodConstant(*i)); 4021 } 4022 } else { 4023 MethodListName += "INSTANCE_METHODS_" + ID->getNameAsString(); 4024 for (ObjCImplementationDecl::instmeth_iterator i = ID->instmeth_begin(), 4025 e = ID->instmeth_end(); i != e; ++i) { 4026 // Instance methods should always be defined. 4027 Methods.push_back(GetMethodConstant(*i)); 4028 } 4029 for (ObjCImplementationDecl::propimpl_iterator i = ID->propimpl_begin(), 4030 e = ID->propimpl_end(); i != e; ++i) { 4031 ObjCPropertyImplDecl *PID = *i; 4032 4033 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize){ 4034 ObjCPropertyDecl *PD = PID->getPropertyDecl(); 4035 4036 if (ObjCMethodDecl *MD = PD->getGetterMethodDecl()) 4037 if (llvm::Constant *C = GetMethodConstant(MD)) 4038 Methods.push_back(C); 4039 if (ObjCMethodDecl *MD = PD->getSetterMethodDecl()) 4040 if (llvm::Constant *C = GetMethodConstant(MD)) 4041 Methods.push_back(C); 4042 } 4043 } 4044 } 4045 Values[ 5] = EmitMethodList(MethodListName, 4046 "__DATA, __objc_const", Methods); 4047 4048 const ObjCInterfaceDecl *OID = ID->getClassInterface(); 4049 assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer"); 4050 Values[ 6] = EmitProtocolList("\01l_OBJC_CLASS_PROTOCOLS_$_" 4051 + OID->getNameAsString(), 4052 OID->protocol_begin(), 4053 OID->protocol_end()); 4054 4055 if (flags & CLS_META) 4056 Values[ 7] = llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy); 4057 else 4058 Values[ 7] = EmitIvarList(ID); 4059 // FIXME. weakIvarLayout is currently null. 4060 Values[ 8] = GetIvarLayoutName(0, ObjCTypes); 4061 if (flags & CLS_META) 4062 Values[ 9] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy); 4063 else 4064 Values[ 9] = 4065 EmitPropertyList( 4066 "\01l_OBJC_$_PROP_LIST_" + ID->getNameAsString(), 4067 ID, ID->getClassInterface(), ObjCTypes); 4068 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassRonfABITy, 4069 Values); 4070 llvm::GlobalVariable *CLASS_RO_GV = 4071 new llvm::GlobalVariable(ObjCTypes.ClassRonfABITy, false, 4072 llvm::GlobalValue::InternalLinkage, 4073 Init, 4074 (flags & CLS_META) ? 4075 std::string("\01l_OBJC_METACLASS_RO_$_")+ClassName : 4076 std::string("\01l_OBJC_CLASS_RO_$_")+ClassName, 4077 &CGM.getModule()); 4078 CLASS_RO_GV->setAlignment( 4079 CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.ClassRonfABITy)); 4080 CLASS_RO_GV->setSection("__DATA, __objc_const"); 4081 UsedGlobals.push_back(CLASS_RO_GV); 4082 return CLASS_RO_GV; 4083 4084} 4085 4086/// BuildClassMetaData - This routine defines that to-level meta-data 4087/// for the given ClassName for: 4088/// struct _class_t { 4089/// struct _class_t *isa; 4090/// struct _class_t * const superclass; 4091/// void *cache; 4092/// IMP *vtable; 4093/// struct class_ro_t *ro; 4094/// } 4095/// 4096llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassMetaData( 4097 std::string &ClassName, 4098 llvm::Constant *IsAGV, 4099 llvm::Constant *SuperClassGV, 4100 llvm::Constant *ClassRoGV, 4101 bool HiddenVisibility) { 4102 std::vector<llvm::Constant*> Values(5); 4103 Values[0] = IsAGV; 4104 Values[1] = SuperClassGV 4105 ? SuperClassGV 4106 : llvm::Constant::getNullValue(ObjCTypes.ClassnfABIPtrTy); 4107 Values[2] = ObjCEmptyCacheVar; // &ObjCEmptyCacheVar 4108 Values[3] = ObjCEmptyVtableVar; // &ObjCEmptyVtableVar 4109 Values[4] = ClassRoGV; // &CLASS_RO_GV 4110 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassnfABITy, 4111 Values); 4112 llvm::GlobalVariable *GV = GetClassGlobal(ClassName); 4113 GV->setInitializer(Init); 4114 GV->setSection("__DATA, __objc_data"); 4115 GV->setAlignment( 4116 CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.ClassnfABITy)); 4117 if (HiddenVisibility) 4118 GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 4119 UsedGlobals.push_back(GV); 4120 return GV; 4121} 4122 4123void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) { 4124 std::string ClassName = ID->getNameAsString(); 4125 if (!ObjCEmptyCacheVar) { 4126 ObjCEmptyCacheVar = new llvm::GlobalVariable( 4127 ObjCTypes.CacheTy, 4128 false, 4129 llvm::GlobalValue::ExternalLinkage, 4130 0, 4131 "\01__objc_empty_cache", 4132 &CGM.getModule()); 4133 UsedGlobals.push_back(ObjCEmptyCacheVar); 4134 4135 ObjCEmptyVtableVar = new llvm::GlobalVariable( 4136 ObjCTypes.ImpnfABITy, 4137 false, 4138 llvm::GlobalValue::ExternalLinkage, 4139 0, 4140 "\01__objc_empty_vtable", 4141 &CGM.getModule()); 4142 UsedGlobals.push_back(ObjCEmptyVtableVar); 4143 } 4144 assert(ID->getClassInterface() && 4145 "CGObjCNonFragileABIMac::GenerateClass - class is 0"); 4146 uint32_t InstanceStart = 4147 CGM.getTargetData().getTypePaddedSize(ObjCTypes.ClassnfABITy); 4148 uint32_t InstanceSize = InstanceStart; 4149 uint32_t flags = CLS_META; 4150 std::string ObjCMetaClassName("\01_OBJC_METACLASS_$_"); 4151 std::string ObjCClassName("\01_OBJC_CLASS_$_"); 4152 4153 llvm::GlobalVariable *SuperClassGV, *IsAGV; 4154 4155 bool classIsHidden = IsClassHidden(ID->getClassInterface()); 4156 if (classIsHidden) 4157 flags |= OBJC2_CLS_HIDDEN; 4158 if (!ID->getClassInterface()->getSuperClass()) { 4159 // class is root 4160 flags |= CLS_ROOT; 4161 SuperClassGV = GetClassGlobal(ObjCClassName + ClassName); 4162 IsAGV = GetClassGlobal(ObjCMetaClassName + ClassName); 4163 } else { 4164 // Has a root. Current class is not a root. 4165 const ObjCInterfaceDecl *Root = ID->getClassInterface(); 4166 while (const ObjCInterfaceDecl *Super = Root->getSuperClass()) 4167 Root = Super; 4168 IsAGV = GetClassGlobal(ObjCMetaClassName + Root->getNameAsString()); 4169 // work on super class metadata symbol. 4170 std::string SuperClassName = 4171 ObjCMetaClassName + ID->getClassInterface()->getSuperClass()->getNameAsString(); 4172 SuperClassGV = GetClassGlobal(SuperClassName); 4173 } 4174 llvm::GlobalVariable *CLASS_RO_GV = BuildClassRoTInitializer(flags, 4175 InstanceStart, 4176 InstanceSize,ID); 4177 std::string TClassName = ObjCMetaClassName + ClassName; 4178 llvm::GlobalVariable *MetaTClass = 4179 BuildClassMetaData(TClassName, IsAGV, SuperClassGV, CLASS_RO_GV, 4180 classIsHidden); 4181 4182 // Metadata for the class 4183 flags = CLS; 4184 if (classIsHidden) 4185 flags |= OBJC2_CLS_HIDDEN; 4186 if (!ID->getClassInterface()->getSuperClass()) { 4187 flags |= CLS_ROOT; 4188 SuperClassGV = 0; 4189 } 4190 else { 4191 // Has a root. Current class is not a root. 4192 std::string RootClassName = 4193 ID->getClassInterface()->getSuperClass()->getNameAsString(); 4194 SuperClassGV = GetClassGlobal(ObjCClassName + RootClassName); 4195 } 4196 4197 InstanceStart = InstanceSize = 0; 4198 if (ObjCInterfaceDecl *OID = 4199 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface())) { 4200 // FIXME. Share this with the one in EmitIvarList. 4201 const llvm::StructLayout *Layout = GetInterfaceDeclStructLayout(OID); 4202 4203 RecordDecl::field_iterator firstField, lastField; 4204 const RecordDecl *RD = GetFirstIvarInRecord(OID, firstField, lastField); 4205 4206 for (RecordDecl::field_iterator e = RD->field_end(), 4207 ifield = firstField; ifield != e; ++ifield) 4208 lastField = ifield; 4209 4210 if (lastField != RD->field_end()) { 4211 FieldDecl *Field = *lastField; 4212 const llvm::Type *FieldTy = 4213 CGM.getTypes().ConvertTypeForMem(Field->getType()); 4214 unsigned Size = CGM.getTargetData().getTypePaddedSize(FieldTy); 4215 InstanceSize = GetIvarBaseOffset(Layout, Field) + Size; 4216 if (firstField == RD->field_end()) 4217 InstanceStart = InstanceSize; 4218 else { 4219 Field = *firstField; 4220 InstanceStart = GetIvarBaseOffset(Layout, Field); 4221 } 4222 } 4223 } 4224 CLASS_RO_GV = BuildClassRoTInitializer(flags, 4225 InstanceStart, 4226 InstanceSize, 4227 ID); 4228 4229 TClassName = ObjCClassName + ClassName; 4230 llvm::GlobalVariable *ClassMD = 4231 BuildClassMetaData(TClassName, MetaTClass, SuperClassGV, CLASS_RO_GV, 4232 classIsHidden); 4233 DefinedClasses.push_back(ClassMD); 4234} 4235 4236/// GenerateProtocolRef - This routine is called to generate code for 4237/// a protocol reference expression; as in: 4238/// @code 4239/// @protocol(Proto1); 4240/// @endcode 4241/// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1 4242/// which will hold address of the protocol meta-data. 4243/// 4244llvm::Value *CGObjCNonFragileABIMac::GenerateProtocolRef(CGBuilderTy &Builder, 4245 const ObjCProtocolDecl *PD) { 4246 4247 llvm::Constant *Init = llvm::ConstantExpr::getBitCast(GetProtocolRef(PD), 4248 ObjCTypes.ExternalProtocolPtrTy); 4249 4250 std::string ProtocolName("\01l_OBJC_PROTOCOL_REFERENCE_$_"); 4251 ProtocolName += PD->getNameAsCString(); 4252 4253 llvm::GlobalVariable *PTGV = CGM.getModule().getGlobalVariable(ProtocolName); 4254 if (PTGV) 4255 return Builder.CreateLoad(PTGV, false, "tmp"); 4256 PTGV = new llvm::GlobalVariable( 4257 Init->getType(), false, 4258 // FIXME: review, was WeakLinkage, 4259 // also review all other WeakLinkage changes 4260 llvm::GlobalValue::WeakAnyLinkage, 4261 Init, 4262 ProtocolName, 4263 &CGM.getModule()); 4264 PTGV->setSection("__DATA, __objc_protorefs, coalesced, no_dead_strip"); 4265 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility); 4266 UsedGlobals.push_back(PTGV); 4267 return Builder.CreateLoad(PTGV, false, "tmp"); 4268} 4269 4270/// GenerateCategory - Build metadata for a category implementation. 4271/// struct _category_t { 4272/// const char * const name; 4273/// struct _class_t *const cls; 4274/// const struct _method_list_t * const instance_methods; 4275/// const struct _method_list_t * const class_methods; 4276/// const struct _protocol_list_t * const protocols; 4277/// const struct _prop_list_t * const properties; 4278/// } 4279/// 4280void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) 4281{ 4282 const ObjCInterfaceDecl *Interface = OCD->getClassInterface(); 4283 const char *Prefix = "\01l_OBJC_$_CATEGORY_"; 4284 std::string ExtCatName(Prefix + Interface->getNameAsString()+ 4285 "_$_" + OCD->getNameAsString()); 4286 std::string ExtClassName("\01_OBJC_CLASS_$_" + Interface->getNameAsString()); 4287 4288 std::vector<llvm::Constant*> Values(6); 4289 Values[0] = GetClassName(OCD->getIdentifier()); 4290 // meta-class entry symbol 4291 llvm::GlobalVariable *ClassGV = GetClassGlobal(ExtClassName); 4292 Values[1] = ClassGV; 4293 std::vector<llvm::Constant*> Methods; 4294 std::string MethodListName(Prefix); 4295 MethodListName += "INSTANCE_METHODS_" + Interface->getNameAsString() + 4296 "_$_" + OCD->getNameAsString(); 4297 4298 for (ObjCCategoryImplDecl::instmeth_iterator i = OCD->instmeth_begin(), 4299 e = OCD->instmeth_end(); i != e; ++i) { 4300 // Instance methods should always be defined. 4301 Methods.push_back(GetMethodConstant(*i)); 4302 } 4303 4304 Values[2] = EmitMethodList(MethodListName, 4305 "__DATA, __objc_const", 4306 Methods); 4307 4308 MethodListName = Prefix; 4309 MethodListName += "CLASS_METHODS_" + Interface->getNameAsString() + "_$_" + 4310 OCD->getNameAsString(); 4311 Methods.clear(); 4312 for (ObjCCategoryImplDecl::classmeth_iterator i = OCD->classmeth_begin(), 4313 e = OCD->classmeth_end(); i != e; ++i) { 4314 // Class methods should always be defined. 4315 Methods.push_back(GetMethodConstant(*i)); 4316 } 4317 4318 Values[3] = EmitMethodList(MethodListName, 4319 "__DATA, __objc_const", 4320 Methods); 4321 const ObjCCategoryDecl *Category = 4322 Interface->FindCategoryDeclaration(OCD->getIdentifier()); 4323 if (Category) { 4324 std::string ExtName(Interface->getNameAsString() + "_$_" + 4325 OCD->getNameAsString()); 4326 Values[4] = EmitProtocolList("\01l_OBJC_CATEGORY_PROTOCOLS_$_" 4327 + Interface->getNameAsString() + "_$_" 4328 + Category->getNameAsString(), 4329 Category->protocol_begin(), 4330 Category->protocol_end()); 4331 Values[5] = 4332 EmitPropertyList(std::string("\01l_OBJC_$_PROP_LIST_") + ExtName, 4333 OCD, Category, ObjCTypes); 4334 } 4335 else { 4336 Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy); 4337 Values[5] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy); 4338 } 4339 4340 llvm::Constant *Init = 4341 llvm::ConstantStruct::get(ObjCTypes.CategorynfABITy, 4342 Values); 4343 llvm::GlobalVariable *GCATV 4344 = new llvm::GlobalVariable(ObjCTypes.CategorynfABITy, 4345 false, 4346 llvm::GlobalValue::InternalLinkage, 4347 Init, 4348 ExtCatName, 4349 &CGM.getModule()); 4350 GCATV->setAlignment( 4351 CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.CategorynfABITy)); 4352 GCATV->setSection("__DATA, __objc_const"); 4353 UsedGlobals.push_back(GCATV); 4354 DefinedCategories.push_back(GCATV); 4355} 4356 4357/// GetMethodConstant - Return a struct objc_method constant for the 4358/// given method if it has been defined. The result is null if the 4359/// method has not been defined. The return value has type MethodPtrTy. 4360llvm::Constant *CGObjCNonFragileABIMac::GetMethodConstant( 4361 const ObjCMethodDecl *MD) { 4362 // FIXME: Use DenseMap::lookup 4363 llvm::Function *Fn = MethodDefinitions[MD]; 4364 if (!Fn) 4365 return 0; 4366 4367 std::vector<llvm::Constant*> Method(3); 4368 Method[0] = 4369 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()), 4370 ObjCTypes.SelectorPtrTy); 4371 Method[1] = GetMethodVarType(MD); 4372 Method[2] = llvm::ConstantExpr::getBitCast(Fn, ObjCTypes.Int8PtrTy); 4373 return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Method); 4374} 4375 4376/// EmitMethodList - Build meta-data for method declarations 4377/// struct _method_list_t { 4378/// uint32_t entsize; // sizeof(struct _objc_method) 4379/// uint32_t method_count; 4380/// struct _objc_method method_list[method_count]; 4381/// } 4382/// 4383llvm::Constant *CGObjCNonFragileABIMac::EmitMethodList( 4384 const std::string &Name, 4385 const char *Section, 4386 const ConstantVector &Methods) { 4387 // Return null for empty list. 4388 if (Methods.empty()) 4389 return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy); 4390 4391 std::vector<llvm::Constant*> Values(3); 4392 // sizeof(struct _objc_method) 4393 unsigned Size = CGM.getTargetData().getTypePaddedSize(ObjCTypes.MethodTy); 4394 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size); 4395 // method_count 4396 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size()); 4397 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodTy, 4398 Methods.size()); 4399 Values[2] = llvm::ConstantArray::get(AT, Methods); 4400 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 4401 4402 llvm::GlobalVariable *GV = 4403 new llvm::GlobalVariable(Init->getType(), false, 4404 llvm::GlobalValue::InternalLinkage, 4405 Init, 4406 Name, 4407 &CGM.getModule()); 4408 GV->setAlignment( 4409 CGM.getTargetData().getPrefTypeAlignment(Init->getType())); 4410 GV->setSection(Section); 4411 UsedGlobals.push_back(GV); 4412 return llvm::ConstantExpr::getBitCast(GV, 4413 ObjCTypes.MethodListnfABIPtrTy); 4414} 4415 4416/// ObjCIvarOffsetVariable - Returns the ivar offset variable for 4417/// the given ivar. 4418/// 4419llvm::GlobalVariable * CGObjCNonFragileABIMac::ObjCIvarOffsetVariable( 4420 std::string &Name, 4421 const ObjCInterfaceDecl *ID, 4422 const ObjCIvarDecl *Ivar) { 4423 Name += "\01_OBJC_IVAR_$_" + 4424 getInterfaceDeclForIvar(ID, Ivar)->getNameAsString() + '.' 4425 + Ivar->getNameAsString(); 4426 llvm::GlobalVariable *IvarOffsetGV = 4427 CGM.getModule().getGlobalVariable(Name); 4428 if (!IvarOffsetGV) 4429 IvarOffsetGV = 4430 new llvm::GlobalVariable(ObjCTypes.LongTy, 4431 false, 4432 llvm::GlobalValue::ExternalLinkage, 4433 0, 4434 Name, 4435 &CGM.getModule()); 4436 return IvarOffsetGV; 4437} 4438 4439llvm::Constant * CGObjCNonFragileABIMac::EmitIvarOffsetVar( 4440 const ObjCInterfaceDecl *ID, 4441 const ObjCIvarDecl *Ivar, 4442 unsigned long int Offset) { 4443 4444 assert(ID && "EmitIvarOffsetVar - null interface decl."); 4445 std::string ExternalName("\01_OBJC_IVAR_$_" + ID->getNameAsString() + '.' 4446 + Ivar->getNameAsString()); 4447 llvm::Constant *Init = llvm::ConstantInt::get(ObjCTypes.LongTy, Offset); 4448 4449 llvm::GlobalVariable *IvarOffsetGV = 4450 CGM.getModule().getGlobalVariable(ExternalName); 4451 if (IvarOffsetGV) { 4452 // ivar offset symbol already built due to user code referencing it. 4453 IvarOffsetGV->setAlignment( 4454 CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.LongTy)); 4455 IvarOffsetGV->setInitializer(Init); 4456 IvarOffsetGV->setSection("__DATA, __objc_const"); 4457 UsedGlobals.push_back(IvarOffsetGV); 4458 return IvarOffsetGV; 4459 } 4460 4461 IvarOffsetGV = 4462 new llvm::GlobalVariable(Init->getType(), 4463 false, 4464 llvm::GlobalValue::ExternalLinkage, 4465 Init, 4466 ExternalName, 4467 &CGM.getModule()); 4468 IvarOffsetGV->setAlignment( 4469 CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.LongTy)); 4470 // @private and @package have hidden visibility. 4471 bool globalVisibility = (Ivar->getAccessControl() == ObjCIvarDecl::Public || 4472 Ivar->getAccessControl() == ObjCIvarDecl::Protected); 4473 if (!globalVisibility) 4474 IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility); 4475 else 4476 if (IsClassHidden(ID)) 4477 IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility); 4478 4479 IvarOffsetGV->setSection("__DATA, __objc_const"); 4480 UsedGlobals.push_back(IvarOffsetGV); 4481 return IvarOffsetGV; 4482} 4483 4484/// EmitIvarList - Emit the ivar list for the given 4485/// implementation. If ForClass is true the list of class ivars 4486/// (i.e. metaclass ivars) is emitted, otherwise the list of 4487/// interface ivars will be emitted. The return value has type 4488/// IvarListnfABIPtrTy. 4489/// struct _ivar_t { 4490/// unsigned long int *offset; // pointer to ivar offset location 4491/// char *name; 4492/// char *type; 4493/// uint32_t alignment; 4494/// uint32_t size; 4495/// } 4496/// struct _ivar_list_t { 4497/// uint32 entsize; // sizeof(struct _ivar_t) 4498/// uint32 count; 4499/// struct _iver_t list[count]; 4500/// } 4501/// 4502llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList( 4503 const ObjCImplementationDecl *ID) { 4504 4505 std::vector<llvm::Constant*> Ivars, Ivar(5); 4506 4507 const ObjCInterfaceDecl *OID = ID->getClassInterface(); 4508 assert(OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface"); 4509 4510 // FIXME. Consolidate this with similar code in GenerateClass. 4511 const llvm::StructLayout *Layout = GetInterfaceDeclStructLayout(OID); 4512 4513 RecordDecl::field_iterator i,p; 4514 const RecordDecl *RD = GetFirstIvarInRecord(OID, i,p); 4515 ObjCInterfaceDecl::ivar_iterator I = OID->ivar_begin(); 4516 4517 for (RecordDecl::field_iterator e = RD->field_end(); i != e; ++i) { 4518 FieldDecl *Field = *i; 4519 uint64_t offset = GetIvarBaseOffset(Layout, Field); 4520 const ObjCIvarDecl *ivarDecl = *I++; 4521 Ivar[0] = EmitIvarOffsetVar(ID->getClassInterface(), ivarDecl, offset); 4522 if (Field->getIdentifier()) 4523 Ivar[1] = GetMethodVarName(Field->getIdentifier()); 4524 else 4525 Ivar[1] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy); 4526 Ivar[2] = GetMethodVarType(Field); 4527 const llvm::Type *FieldTy = 4528 CGM.getTypes().ConvertTypeForMem(Field->getType()); 4529 unsigned Size = CGM.getTargetData().getTypePaddedSize(FieldTy); 4530 unsigned Align = CGM.getContext().getPreferredTypeAlign( 4531 Field->getType().getTypePtr()) >> 3; 4532 Align = llvm::Log2_32(Align); 4533 Ivar[3] = llvm::ConstantInt::get(ObjCTypes.IntTy, Align); 4534 // NOTE. Size of a bitfield does not match gcc's, because of the way 4535 // bitfields are treated special in each. But I am told that 'size' 4536 // for bitfield ivars is ignored by the runtime so it does not matter. 4537 // (even if it matters, some day, there is enough info. to get the bitfield 4538 // right! 4539 Ivar[4] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size); 4540 Ivars.push_back(llvm::ConstantStruct::get(ObjCTypes.IvarnfABITy, Ivar)); 4541 } 4542 // Return null for empty list. 4543 if (Ivars.empty()) 4544 return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy); 4545 std::vector<llvm::Constant*> Values(3); 4546 unsigned Size = CGM.getTargetData().getTypePaddedSize(ObjCTypes.IvarnfABITy); 4547 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size); 4548 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Ivars.size()); 4549 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.IvarnfABITy, 4550 Ivars.size()); 4551 Values[2] = llvm::ConstantArray::get(AT, Ivars); 4552 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 4553 const char *Prefix = "\01l_OBJC_$_INSTANCE_VARIABLES_"; 4554 llvm::GlobalVariable *GV = 4555 new llvm::GlobalVariable(Init->getType(), false, 4556 llvm::GlobalValue::InternalLinkage, 4557 Init, 4558 Prefix + OID->getNameAsString(), 4559 &CGM.getModule()); 4560 GV->setAlignment( 4561 CGM.getTargetData().getPrefTypeAlignment(Init->getType())); 4562 GV->setSection("__DATA, __objc_const"); 4563 4564 UsedGlobals.push_back(GV); 4565 return llvm::ConstantExpr::getBitCast(GV, 4566 ObjCTypes.IvarListnfABIPtrTy); 4567} 4568 4569llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocolRef( 4570 const ObjCProtocolDecl *PD) { 4571 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()]; 4572 4573 if (!Entry) { 4574 // We use the initializer as a marker of whether this is a forward 4575 // reference or not. At module finalization we add the empty 4576 // contents for protocols which were referenced but never defined. 4577 Entry = 4578 new llvm::GlobalVariable(ObjCTypes.ProtocolnfABITy, false, 4579 llvm::GlobalValue::ExternalLinkage, 4580 0, 4581 "\01l_OBJC_PROTOCOL_$_" + PD->getNameAsString(), 4582 &CGM.getModule()); 4583 Entry->setSection("__DATA,__datacoal_nt,coalesced"); 4584 UsedGlobals.push_back(Entry); 4585 } 4586 4587 return Entry; 4588} 4589 4590/// GetOrEmitProtocol - Generate the protocol meta-data: 4591/// @code 4592/// struct _protocol_t { 4593/// id isa; // NULL 4594/// const char * const protocol_name; 4595/// const struct _protocol_list_t * protocol_list; // super protocols 4596/// const struct method_list_t * const instance_methods; 4597/// const struct method_list_t * const class_methods; 4598/// const struct method_list_t *optionalInstanceMethods; 4599/// const struct method_list_t *optionalClassMethods; 4600/// const struct _prop_list_t * properties; 4601/// const uint32_t size; // sizeof(struct _protocol_t) 4602/// const uint32_t flags; // = 0 4603/// } 4604/// @endcode 4605/// 4606 4607llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol( 4608 const ObjCProtocolDecl *PD) { 4609 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()]; 4610 4611 // Early exit if a defining object has already been generated. 4612 if (Entry && Entry->hasInitializer()) 4613 return Entry; 4614 4615 const char *ProtocolName = PD->getNameAsCString(); 4616 4617 // Construct method lists. 4618 std::vector<llvm::Constant*> InstanceMethods, ClassMethods; 4619 std::vector<llvm::Constant*> OptInstanceMethods, OptClassMethods; 4620 for (ObjCProtocolDecl::instmeth_iterator i = PD->instmeth_begin(), 4621 e = PD->instmeth_end(); i != e; ++i) { 4622 ObjCMethodDecl *MD = *i; 4623 llvm::Constant *C = GetMethodDescriptionConstant(MD); 4624 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) { 4625 OptInstanceMethods.push_back(C); 4626 } else { 4627 InstanceMethods.push_back(C); 4628 } 4629 } 4630 4631 for (ObjCProtocolDecl::classmeth_iterator i = PD->classmeth_begin(), 4632 e = PD->classmeth_end(); i != e; ++i) { 4633 ObjCMethodDecl *MD = *i; 4634 llvm::Constant *C = GetMethodDescriptionConstant(MD); 4635 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) { 4636 OptClassMethods.push_back(C); 4637 } else { 4638 ClassMethods.push_back(C); 4639 } 4640 } 4641 4642 std::vector<llvm::Constant*> Values(10); 4643 // isa is NULL 4644 Values[0] = llvm::Constant::getNullValue(ObjCTypes.ObjectPtrTy); 4645 Values[1] = GetClassName(PD->getIdentifier()); 4646 Values[2] = EmitProtocolList( 4647 "\01l_OBJC_$_PROTOCOL_REFS_" + PD->getNameAsString(), 4648 PD->protocol_begin(), 4649 PD->protocol_end()); 4650 4651 Values[3] = EmitMethodList("\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_" 4652 + PD->getNameAsString(), 4653 "__DATA, __objc_const", 4654 InstanceMethods); 4655 Values[4] = EmitMethodList("\01l_OBJC_$_PROTOCOL_CLASS_METHODS_" 4656 + PD->getNameAsString(), 4657 "__DATA, __objc_const", 4658 ClassMethods); 4659 Values[5] = EmitMethodList("\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_" 4660 + PD->getNameAsString(), 4661 "__DATA, __objc_const", 4662 OptInstanceMethods); 4663 Values[6] = EmitMethodList("\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_" 4664 + PD->getNameAsString(), 4665 "__DATA, __objc_const", 4666 OptClassMethods); 4667 Values[7] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + PD->getNameAsString(), 4668 0, PD, ObjCTypes); 4669 uint32_t Size = 4670 CGM.getTargetData().getTypePaddedSize(ObjCTypes.ProtocolnfABITy); 4671 Values[8] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size); 4672 Values[9] = llvm::Constant::getNullValue(ObjCTypes.IntTy); 4673 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ProtocolnfABITy, 4674 Values); 4675 4676 if (Entry) { 4677 // Already created, fix the linkage and update the initializer. 4678 Entry->setLinkage(llvm::GlobalValue::WeakAnyLinkage); 4679 Entry->setInitializer(Init); 4680 } else { 4681 Entry = 4682 new llvm::GlobalVariable(ObjCTypes.ProtocolnfABITy, false, 4683 llvm::GlobalValue::WeakAnyLinkage, 4684 Init, 4685 std::string("\01l_OBJC_PROTOCOL_$_")+ProtocolName, 4686 &CGM.getModule()); 4687 Entry->setAlignment( 4688 CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.ProtocolnfABITy)); 4689 Entry->setSection("__DATA,__datacoal_nt,coalesced"); 4690 } 4691 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility); 4692 4693 // Use this protocol meta-data to build protocol list table in section 4694 // __DATA, __objc_protolist 4695 llvm::GlobalVariable *PTGV = new llvm::GlobalVariable( 4696 ObjCTypes.ProtocolnfABIPtrTy, false, 4697 llvm::GlobalValue::WeakAnyLinkage, 4698 Entry, 4699 std::string("\01l_OBJC_LABEL_PROTOCOL_$_") 4700 +ProtocolName, 4701 &CGM.getModule()); 4702 PTGV->setAlignment( 4703 CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.ProtocolnfABIPtrTy)); 4704 PTGV->setSection("__DATA, __objc_protolist"); 4705 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility); 4706 UsedGlobals.push_back(PTGV); 4707 return Entry; 4708} 4709 4710/// EmitProtocolList - Generate protocol list meta-data: 4711/// @code 4712/// struct _protocol_list_t { 4713/// long protocol_count; // Note, this is 32/64 bit 4714/// struct _protocol_t[protocol_count]; 4715/// } 4716/// @endcode 4717/// 4718llvm::Constant * 4719CGObjCNonFragileABIMac::EmitProtocolList(const std::string &Name, 4720 ObjCProtocolDecl::protocol_iterator begin, 4721 ObjCProtocolDecl::protocol_iterator end) { 4722 std::vector<llvm::Constant*> ProtocolRefs; 4723 4724 // Just return null for empty protocol lists 4725 if (begin == end) 4726 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy); 4727 4728 // FIXME: We shouldn't need to do this lookup here, should we? 4729 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true); 4730 if (GV) 4731 return llvm::ConstantExpr::getBitCast(GV, 4732 ObjCTypes.ProtocolListnfABIPtrTy); 4733 4734 for (; begin != end; ++begin) 4735 ProtocolRefs.push_back(GetProtocolRef(*begin)); // Implemented??? 4736 4737 // This list is null terminated. 4738 ProtocolRefs.push_back(llvm::Constant::getNullValue( 4739 ObjCTypes.ProtocolnfABIPtrTy)); 4740 4741 std::vector<llvm::Constant*> Values(2); 4742 Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, ProtocolRefs.size() - 1); 4743 Values[1] = 4744 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.ProtocolnfABIPtrTy, 4745 ProtocolRefs.size()), 4746 ProtocolRefs); 4747 4748 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 4749 GV = new llvm::GlobalVariable(Init->getType(), false, 4750 llvm::GlobalValue::InternalLinkage, 4751 Init, 4752 Name, 4753 &CGM.getModule()); 4754 GV->setSection("__DATA, __objc_const"); 4755 GV->setAlignment( 4756 CGM.getTargetData().getPrefTypeAlignment(Init->getType())); 4757 UsedGlobals.push_back(GV); 4758 return llvm::ConstantExpr::getBitCast(GV, 4759 ObjCTypes.ProtocolListnfABIPtrTy); 4760} 4761 4762/// GetMethodDescriptionConstant - This routine build following meta-data: 4763/// struct _objc_method { 4764/// SEL _cmd; 4765/// char *method_type; 4766/// char *_imp; 4767/// } 4768 4769llvm::Constant * 4770CGObjCNonFragileABIMac::GetMethodDescriptionConstant(const ObjCMethodDecl *MD) { 4771 std::vector<llvm::Constant*> Desc(3); 4772 Desc[0] = llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()), 4773 ObjCTypes.SelectorPtrTy); 4774 Desc[1] = GetMethodVarType(MD); 4775 // Protocol methods have no implementation. So, this entry is always NULL. 4776 Desc[2] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy); 4777 return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Desc); 4778} 4779 4780/// EmitObjCValueForIvar - Code Gen for nonfragile ivar reference. 4781/// This code gen. amounts to generating code for: 4782/// @code 4783/// (type *)((char *)base + _OBJC_IVAR_$_.ivar; 4784/// @encode 4785/// 4786LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar( 4787 CodeGen::CodeGenFunction &CGF, 4788 QualType ObjectTy, 4789 llvm::Value *BaseValue, 4790 const ObjCIvarDecl *Ivar, 4791 const FieldDecl *Field, 4792 unsigned CVRQualifiers) { 4793 assert(ObjectTy->isObjCInterfaceType() && 4794 "CGObjCNonFragileABIMac::EmitObjCValueForIvar"); 4795 ObjCInterfaceDecl *ID = ObjectTy->getAsObjCInterfaceType()->getDecl(); 4796 std::string ExternalName; 4797 llvm::GlobalVariable *IvarOffsetGV = 4798 ObjCIvarOffsetVariable(ExternalName, ID, Ivar); 4799 4800 // (char *) BaseValue 4801 llvm::Value *V = CGF.Builder.CreateBitCast(BaseValue, 4802 ObjCTypes.Int8PtrTy); 4803 llvm::Value *Offset = CGF.Builder.CreateLoad(IvarOffsetGV); 4804 // (char*)BaseValue + Offset_symbol 4805 V = CGF.Builder.CreateGEP(V, Offset, "add.ptr"); 4806 // (type *)((char*)BaseValue + Offset_symbol) 4807 const llvm::Type *IvarTy = 4808 CGM.getTypes().ConvertType(Ivar->getType()); 4809 llvm::Type *ptrIvarTy = llvm::PointerType::getUnqual(IvarTy); 4810 V = CGF.Builder.CreateBitCast(V, ptrIvarTy); 4811 4812 if (Ivar->isBitField()) { 4813 CodeGenTypes::BitFieldInfo bitFieldInfo = 4814 CGM.getTypes().getBitFieldInfo(Field); 4815 return LValue::MakeBitfield(V, bitFieldInfo.Begin, bitFieldInfo.Size, 4816 Field->getType()->isSignedIntegerType(), 4817 Field->getType().getCVRQualifiers()|CVRQualifiers); 4818 } 4819 4820 LValue LV = LValue::MakeAddr(V, 4821 Ivar->getType().getCVRQualifiers()|CVRQualifiers, 4822 CGM.getContext().getObjCGCAttrKind(Ivar->getType())); 4823 LValue::SetObjCIvar(LV, true); 4824 return LV; 4825} 4826 4827llvm::Value *CGObjCNonFragileABIMac::EmitIvarOffset( 4828 CodeGen::CodeGenFunction &CGF, 4829 ObjCInterfaceDecl *Interface, 4830 const ObjCIvarDecl *Ivar) { 4831 std::string ExternalName; 4832 llvm::GlobalVariable *IvarOffsetGV = 4833 ObjCIvarOffsetVariable(ExternalName, Interface, Ivar); 4834 4835 return CGF.Builder.CreateLoad(IvarOffsetGV, false, "ivar"); 4836} 4837 4838CodeGen::RValue CGObjCNonFragileABIMac::EmitMessageSend( 4839 CodeGen::CodeGenFunction &CGF, 4840 QualType ResultType, 4841 Selector Sel, 4842 llvm::Value *Receiver, 4843 QualType Arg0Ty, 4844 bool IsSuper, 4845 const CallArgList &CallArgs) { 4846 // FIXME. Even though IsSuper is passes. This function doese not 4847 // handle calls to 'super' receivers. 4848 CodeGenTypes &Types = CGM.getTypes(); 4849 llvm::Value *Arg0 = Receiver; 4850 if (!IsSuper) 4851 Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy, "tmp"); 4852 4853 // Find the message function name. 4854 // FIXME. This is too much work to get the ABI-specific result type 4855 // needed to find the message name. 4856 const CGFunctionInfo &FnInfo = Types.getFunctionInfo(ResultType, 4857 llvm::SmallVector<QualType, 16>()); 4858 llvm::Constant *Fn; 4859 std::string Name("\01l_"); 4860 if (CGM.ReturnTypeUsesSret(FnInfo)) { 4861#if 0 4862 // unlike what is documented. gcc never generates this API!! 4863 if (Receiver->getType() == ObjCTypes.ObjectPtrTy) { 4864 Fn = ObjCTypes.MessageSendIdStretFixupFn; 4865 // FIXME. Is there a better way of getting these names. 4866 // They are available in RuntimeFunctions vector pair. 4867 Name += "objc_msgSendId_stret_fixup"; 4868 } 4869 else 4870#endif 4871 if (IsSuper) { 4872 Fn = ObjCTypes.MessageSendSuper2StretFixupFn; 4873 Name += "objc_msgSendSuper2_stret_fixup"; 4874 } 4875 else 4876 { 4877 Fn = ObjCTypes.MessageSendStretFixupFn; 4878 Name += "objc_msgSend_stret_fixup"; 4879 } 4880 } 4881 else if (ResultType->isFloatingType() && 4882 // Selection of frret API only happens in 32bit nonfragile ABI. 4883 CGM.getTargetData().getTypePaddedSize(ObjCTypes.LongTy) == 4) { 4884 Fn = ObjCTypes.MessageSendFpretFixupFn; 4885 Name += "objc_msgSend_fpret_fixup"; 4886 } 4887 else { 4888#if 0 4889// unlike what is documented. gcc never generates this API!! 4890 if (Receiver->getType() == ObjCTypes.ObjectPtrTy) { 4891 Fn = ObjCTypes.MessageSendIdFixupFn; 4892 Name += "objc_msgSendId_fixup"; 4893 } 4894 else 4895#endif 4896 if (IsSuper) { 4897 Fn = ObjCTypes.MessageSendSuper2FixupFn; 4898 Name += "objc_msgSendSuper2_fixup"; 4899 } 4900 else 4901 { 4902 Fn = ObjCTypes.MessageSendFixupFn; 4903 Name += "objc_msgSend_fixup"; 4904 } 4905 } 4906 Name += '_'; 4907 std::string SelName(Sel.getAsString()); 4908 // Replace all ':' in selector name with '_' ouch! 4909 for(unsigned i = 0; i < SelName.size(); i++) 4910 if (SelName[i] == ':') 4911 SelName[i] = '_'; 4912 Name += SelName; 4913 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name); 4914 if (!GV) { 4915 // Build messafe ref table entry. 4916 std::vector<llvm::Constant*> Values(2); 4917 Values[0] = Fn; 4918 Values[1] = GetMethodVarName(Sel); 4919 llvm::Constant *Init = llvm::ConstantStruct::get(Values); 4920 GV = new llvm::GlobalVariable(Init->getType(), false, 4921 llvm::GlobalValue::WeakAnyLinkage, 4922 Init, 4923 Name, 4924 &CGM.getModule()); 4925 GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 4926 GV->setAlignment( 4927 CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.MessageRefTy)); 4928 GV->setSection("__DATA, __objc_msgrefs, coalesced"); 4929 UsedGlobals.push_back(GV); 4930 } 4931 llvm::Value *Arg1 = CGF.Builder.CreateBitCast(GV, ObjCTypes.MessageRefPtrTy); 4932 4933 CallArgList ActualArgs; 4934 ActualArgs.push_back(std::make_pair(RValue::get(Arg0), Arg0Ty)); 4935 ActualArgs.push_back(std::make_pair(RValue::get(Arg1), 4936 ObjCTypes.MessageRefCPtrTy)); 4937 ActualArgs.insert(ActualArgs.end(), CallArgs.begin(), CallArgs.end()); 4938 const CGFunctionInfo &FnInfo1 = Types.getFunctionInfo(ResultType, ActualArgs); 4939 llvm::Value *Callee = CGF.Builder.CreateStructGEP(Arg1, 0); 4940 Callee = CGF.Builder.CreateLoad(Callee); 4941 const llvm::FunctionType *FTy = Types.GetFunctionType(FnInfo1, true); 4942 Callee = CGF.Builder.CreateBitCast(Callee, 4943 llvm::PointerType::getUnqual(FTy)); 4944 return CGF.EmitCall(FnInfo1, Callee, ActualArgs); 4945} 4946 4947/// Generate code for a message send expression in the nonfragile abi. 4948CodeGen::RValue CGObjCNonFragileABIMac::GenerateMessageSend( 4949 CodeGen::CodeGenFunction &CGF, 4950 QualType ResultType, 4951 Selector Sel, 4952 llvm::Value *Receiver, 4953 bool IsClassMessage, 4954 const CallArgList &CallArgs) { 4955 return EmitMessageSend(CGF, ResultType, Sel, 4956 Receiver, CGF.getContext().getObjCIdType(), 4957 false, CallArgs); 4958} 4959 4960llvm::GlobalVariable * 4961CGObjCNonFragileABIMac::GetClassGlobal(const std::string &Name) { 4962 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name); 4963 4964 if (!GV) { 4965 GV = new llvm::GlobalVariable(ObjCTypes.ClassnfABITy, false, 4966 llvm::GlobalValue::ExternalLinkage, 4967 0, Name, &CGM.getModule()); 4968 UsedGlobals.push_back(GV); 4969 } 4970 4971 return GV; 4972} 4973 4974llvm::Value *CGObjCNonFragileABIMac::EmitClassRef(CGBuilderTy &Builder, 4975 const ObjCInterfaceDecl *ID, 4976 bool IsSuper) { 4977 4978 llvm::GlobalVariable *&Entry = ClassReferences[ID->getIdentifier()]; 4979 4980 if (!Entry) { 4981 std::string ClassName("\01_OBJC_CLASS_$_" + ID->getNameAsString()); 4982 llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName); 4983 Entry = 4984 new llvm::GlobalVariable(ObjCTypes.ClassnfABIPtrTy, false, 4985 llvm::GlobalValue::InternalLinkage, 4986 ClassGV, 4987 IsSuper ? "\01L_OBJC_CLASSLIST_SUP_REFS_$_" 4988 : "\01L_OBJC_CLASSLIST_REFERENCES_$_", 4989 &CGM.getModule()); 4990 Entry->setAlignment( 4991 CGM.getTargetData().getPrefTypeAlignment( 4992 ObjCTypes.ClassnfABIPtrTy)); 4993 4994 if (IsSuper) 4995 Entry->setSection("__DATA,__objc_superrefs,regular,no_dead_strip"); 4996 else 4997 Entry->setSection("__DATA,__objc_classrefs,regular,no_dead_strip"); 4998 UsedGlobals.push_back(Entry); 4999 } 5000 5001 return Builder.CreateLoad(Entry, false, "tmp"); 5002} 5003 5004/// EmitMetaClassRef - Return a Value * of the address of _class_t 5005/// meta-data 5006/// 5007llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef(CGBuilderTy &Builder, 5008 const ObjCInterfaceDecl *ID) { 5009 llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()]; 5010 if (Entry) 5011 return Builder.CreateLoad(Entry, false, "tmp"); 5012 5013 std::string MetaClassName("\01_OBJC_METACLASS_$_" + ID->getNameAsString()); 5014 llvm::GlobalVariable *MetaClassGV = GetClassGlobal(MetaClassName); 5015 Entry = 5016 new llvm::GlobalVariable(ObjCTypes.ClassnfABIPtrTy, false, 5017 llvm::GlobalValue::InternalLinkage, 5018 MetaClassGV, 5019 "\01L_OBJC_CLASSLIST_SUP_REFS_$_", 5020 &CGM.getModule()); 5021 Entry->setAlignment( 5022 CGM.getTargetData().getPrefTypeAlignment( 5023 ObjCTypes.ClassnfABIPtrTy)); 5024 5025 Entry->setSection("__OBJC,__objc_superrefs,regular,no_dead_strip"); 5026 UsedGlobals.push_back(Entry); 5027 5028 return Builder.CreateLoad(Entry, false, "tmp"); 5029} 5030 5031/// GetClass - Return a reference to the class for the given interface 5032/// decl. 5033llvm::Value *CGObjCNonFragileABIMac::GetClass(CGBuilderTy &Builder, 5034 const ObjCInterfaceDecl *ID) { 5035 return EmitClassRef(Builder, ID); 5036} 5037 5038/// Generates a message send where the super is the receiver. This is 5039/// a message send to self with special delivery semantics indicating 5040/// which class's method should be called. 5041CodeGen::RValue 5042CGObjCNonFragileABIMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, 5043 QualType ResultType, 5044 Selector Sel, 5045 const ObjCInterfaceDecl *Class, 5046 bool isCategoryImpl, 5047 llvm::Value *Receiver, 5048 bool IsClassMessage, 5049 const CodeGen::CallArgList &CallArgs) { 5050 // ... 5051 // Create and init a super structure; this is a (receiver, class) 5052 // pair we will pass to objc_msgSendSuper. 5053 llvm::Value *ObjCSuper = 5054 CGF.Builder.CreateAlloca(ObjCTypes.SuperTy, 0, "objc_super"); 5055 5056 llvm::Value *ReceiverAsObject = 5057 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy); 5058 CGF.Builder.CreateStore(ReceiverAsObject, 5059 CGF.Builder.CreateStructGEP(ObjCSuper, 0)); 5060 5061 // If this is a class message the metaclass is passed as the target. 5062 llvm::Value *Target; 5063 if (IsClassMessage) { 5064 if (isCategoryImpl) { 5065 // Message sent to "super' in a class method defined in 5066 // a category implementation. 5067 Target = EmitClassRef(CGF.Builder, Class, false); 5068 Target = CGF.Builder.CreateStructGEP(Target, 0); 5069 Target = CGF.Builder.CreateLoad(Target); 5070 } 5071 else 5072 Target = EmitMetaClassRef(CGF.Builder, Class); 5073 } 5074 else 5075 Target = EmitClassRef(CGF.Builder, Class, true); 5076 5077 // FIXME: We shouldn't need to do this cast, rectify the ASTContext 5078 // and ObjCTypes types. 5079 const llvm::Type *ClassTy = 5080 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType()); 5081 Target = CGF.Builder.CreateBitCast(Target, ClassTy); 5082 CGF.Builder.CreateStore(Target, 5083 CGF.Builder.CreateStructGEP(ObjCSuper, 1)); 5084 5085 return EmitMessageSend(CGF, ResultType, Sel, 5086 ObjCSuper, ObjCTypes.SuperPtrCTy, 5087 true, CallArgs); 5088} 5089 5090llvm::Value *CGObjCNonFragileABIMac::EmitSelector(CGBuilderTy &Builder, 5091 Selector Sel) { 5092 llvm::GlobalVariable *&Entry = SelectorReferences[Sel]; 5093 5094 if (!Entry) { 5095 llvm::Constant *Casted = 5096 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel), 5097 ObjCTypes.SelectorPtrTy); 5098 Entry = 5099 new llvm::GlobalVariable(ObjCTypes.SelectorPtrTy, false, 5100 llvm::GlobalValue::InternalLinkage, 5101 Casted, "\01L_OBJC_SELECTOR_REFERENCES_", 5102 &CGM.getModule()); 5103 Entry->setSection("__DATA,__objc_selrefs,literal_pointers,no_dead_strip"); 5104 UsedGlobals.push_back(Entry); 5105 } 5106 5107 return Builder.CreateLoad(Entry, false, "tmp"); 5108} 5109/// EmitObjCIvarAssign - Code gen for assigning to a __strong object. 5110/// objc_assign_ivar (id src, id *dst) 5111/// 5112void CGObjCNonFragileABIMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, 5113 llvm::Value *src, llvm::Value *dst) 5114{ 5115 if (!isa<llvm::PointerType>(src->getType())) { 5116 src = CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy); 5117 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 5118 } 5119 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 5120 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); 5121 CGF.Builder.CreateCall2(ObjCTypes.GcAssignIvarFn, 5122 src, dst, "assignivar"); 5123 return; 5124} 5125 5126/// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object. 5127/// objc_assign_strongCast (id src, id *dst) 5128/// 5129void CGObjCNonFragileABIMac::EmitObjCStrongCastAssign( 5130 CodeGen::CodeGenFunction &CGF, 5131 llvm::Value *src, llvm::Value *dst) 5132{ 5133 if (!isa<llvm::PointerType>(src->getType())) { 5134 src = CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy); 5135 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 5136 } 5137 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 5138 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); 5139 CGF.Builder.CreateCall2(ObjCTypes.GcAssignStrongCastFn, 5140 src, dst, "weakassign"); 5141 return; 5142} 5143 5144/// EmitObjCWeakRead - Code gen for loading value of a __weak 5145/// object: objc_read_weak (id *src) 5146/// 5147llvm::Value * CGObjCNonFragileABIMac::EmitObjCWeakRead( 5148 CodeGen::CodeGenFunction &CGF, 5149 llvm::Value *AddrWeakObj) 5150{ 5151 const llvm::Type* DestTy = 5152 cast<llvm::PointerType>(AddrWeakObj->getType())->getElementType(); 5153 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy); 5154 llvm::Value *read_weak = CGF.Builder.CreateCall(ObjCTypes.GcReadWeakFn, 5155 AddrWeakObj, "weakread"); 5156 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy); 5157 return read_weak; 5158} 5159 5160/// EmitObjCWeakAssign - Code gen for assigning to a __weak object. 5161/// objc_assign_weak (id src, id *dst) 5162/// 5163void CGObjCNonFragileABIMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, 5164 llvm::Value *src, llvm::Value *dst) 5165{ 5166 if (!isa<llvm::PointerType>(src->getType())) { 5167 src = CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy); 5168 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 5169 } 5170 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 5171 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); 5172 CGF.Builder.CreateCall2(ObjCTypes.GcAssignWeakFn, 5173 src, dst, "weakassign"); 5174 return; 5175} 5176 5177/// EmitObjCGlobalAssign - Code gen for assigning to a __strong object. 5178/// objc_assign_global (id src, id *dst) 5179/// 5180void CGObjCNonFragileABIMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, 5181 llvm::Value *src, llvm::Value *dst) 5182{ 5183 if (!isa<llvm::PointerType>(src->getType())) { 5184 src = CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy); 5185 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); 5186 } 5187 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); 5188 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy); 5189 CGF.Builder.CreateCall2(ObjCTypes.GcAssignGlobalFn, 5190 src, dst, "globalassign"); 5191 return; 5192} 5193 5194void 5195CGObjCNonFragileABIMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, 5196 const Stmt &S) { 5197 bool isTry = isa<ObjCAtTryStmt>(S); 5198 llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try"); 5199 llvm::BasicBlock *PrevLandingPad = CGF.getInvokeDest(); 5200 llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler"); 5201 llvm::BasicBlock *FinallyBlock = CGF.createBasicBlock("finally"); 5202 llvm::BasicBlock *FinallyRethrow = CGF.createBasicBlock("finally.throw"); 5203 llvm::BasicBlock *FinallyEnd = CGF.createBasicBlock("finally.end"); 5204 5205 // For @synchronized, call objc_sync_enter(sync.expr). The 5206 // evaluation of the expression must occur before we enter the 5207 // @synchronized. We can safely avoid a temp here because jumps into 5208 // @synchronized are illegal & this will dominate uses. 5209 llvm::Value *SyncArg = 0; 5210 if (!isTry) { 5211 SyncArg = 5212 CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr()); 5213 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy); 5214 CGF.Builder.CreateCall(ObjCTypes.SyncEnterFn, SyncArg); 5215 } 5216 5217 // Push an EH context entry, used for handling rethrows and jumps 5218 // through finally. 5219 CGF.PushCleanupBlock(FinallyBlock); 5220 5221 CGF.setInvokeDest(TryHandler); 5222 5223 CGF.EmitBlock(TryBlock); 5224 CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody() 5225 : cast<ObjCAtSynchronizedStmt>(S).getSynchBody()); 5226 CGF.EmitBranchThroughCleanup(FinallyEnd); 5227 5228 // Emit the exception handler. 5229 5230 CGF.EmitBlock(TryHandler); 5231 5232 llvm::Value *llvm_eh_exception = 5233 CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_exception); 5234 llvm::Value *llvm_eh_selector_i64 = 5235 CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_selector_i64); 5236 llvm::Value *llvm_eh_typeid_for_i64 = 5237 CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for_i64); 5238 llvm::Value *Exc = CGF.Builder.CreateCall(llvm_eh_exception, "exc"); 5239 llvm::Value *RethrowPtr = CGF.CreateTempAlloca(Exc->getType(), "_rethrow"); 5240 5241 llvm::SmallVector<llvm::Value*, 8> SelectorArgs; 5242 SelectorArgs.push_back(Exc); 5243 SelectorArgs.push_back(ObjCTypes.EHPersonalityPtr); 5244 5245 // Construct the lists of (type, catch body) to handle. 5246 llvm::SmallVector<std::pair<const ParmVarDecl*, const Stmt*>, 8> Handlers; 5247 bool HasCatchAll = false; 5248 if (isTry) { 5249 if (const ObjCAtCatchStmt* CatchStmt = 5250 cast<ObjCAtTryStmt>(S).getCatchStmts()) { 5251 for (; CatchStmt; CatchStmt = CatchStmt->getNextCatchStmt()) { 5252 const ParmVarDecl *CatchDecl = CatchStmt->getCatchParamDecl(); 5253 Handlers.push_back(std::make_pair(CatchDecl, CatchStmt->getCatchBody())); 5254 5255 // catch(...) always matches. 5256 if (!CatchDecl) { 5257 // Use i8* null here to signal this is a catch all, not a cleanup. 5258 llvm::Value *Null = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy); 5259 SelectorArgs.push_back(Null); 5260 HasCatchAll = true; 5261 break; 5262 } 5263 5264 if (CGF.getContext().isObjCIdType(CatchDecl->getType()) || 5265 CatchDecl->getType()->isObjCQualifiedIdType()) { 5266 llvm::Value *IDEHType = 5267 CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id"); 5268 if (!IDEHType) 5269 IDEHType = 5270 new llvm::GlobalVariable(ObjCTypes.EHTypeTy, false, 5271 llvm::GlobalValue::ExternalLinkage, 5272 0, "OBJC_EHTYPE_id", &CGM.getModule()); 5273 SelectorArgs.push_back(IDEHType); 5274 HasCatchAll = true; 5275 break; 5276 } 5277 5278 // All other types should be Objective-C interface pointer types. 5279 const PointerType *PT = CatchDecl->getType()->getAsPointerType(); 5280 assert(PT && "Invalid @catch type."); 5281 const ObjCInterfaceType *IT = 5282 PT->getPointeeType()->getAsObjCInterfaceType(); 5283 assert(IT && "Invalid @catch type."); 5284 llvm::Value *EHType = GetInterfaceEHType(IT); 5285 SelectorArgs.push_back(EHType); 5286 } 5287 } 5288 } 5289 5290 // We use a cleanup unless there was already a catch all. 5291 if (!HasCatchAll) { 5292 SelectorArgs.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, 0)); 5293 Handlers.push_back(std::make_pair((const ParmVarDecl*) 0, (const Stmt*) 0)); 5294 } 5295 5296 llvm::Value *Selector = 5297 CGF.Builder.CreateCall(llvm_eh_selector_i64, 5298 SelectorArgs.begin(), SelectorArgs.end(), 5299 "selector"); 5300 for (unsigned i = 0, e = Handlers.size(); i != e; ++i) { 5301 const ParmVarDecl *CatchParam = Handlers[i].first; 5302 const Stmt *CatchBody = Handlers[i].second; 5303 5304 llvm::BasicBlock *Next = 0; 5305 5306 // The last handler always matches. 5307 if (i + 1 != e) { 5308 assert(CatchParam && "Only last handler can be a catch all."); 5309 5310 llvm::BasicBlock *Match = CGF.createBasicBlock("match"); 5311 Next = CGF.createBasicBlock("catch.next"); 5312 llvm::Value *Id = 5313 CGF.Builder.CreateCall(llvm_eh_typeid_for_i64, 5314 CGF.Builder.CreateBitCast(SelectorArgs[i+2], 5315 ObjCTypes.Int8PtrTy)); 5316 CGF.Builder.CreateCondBr(CGF.Builder.CreateICmpEQ(Selector, Id), 5317 Match, Next); 5318 5319 CGF.EmitBlock(Match); 5320 } 5321 5322 if (CatchBody) { 5323 llvm::BasicBlock *MatchEnd = CGF.createBasicBlock("match.end"); 5324 llvm::BasicBlock *MatchHandler = CGF.createBasicBlock("match.handler"); 5325 5326 // Cleanups must call objc_end_catch. 5327 // 5328 // FIXME: It seems incorrect for objc_begin_catch to be inside 5329 // this context, but this matches gcc. 5330 CGF.PushCleanupBlock(MatchEnd); 5331 CGF.setInvokeDest(MatchHandler); 5332 5333 llvm::Value *ExcObject = 5334 CGF.Builder.CreateCall(ObjCTypes.ObjCBeginCatchFn, Exc); 5335 5336 // Bind the catch parameter if it exists. 5337 if (CatchParam) { 5338 ExcObject = 5339 CGF.Builder.CreateBitCast(ExcObject, 5340 CGF.ConvertType(CatchParam->getType())); 5341 // CatchParam is a ParmVarDecl because of the grammar 5342 // construction used to handle this, but for codegen purposes 5343 // we treat this as a local decl. 5344 CGF.EmitLocalBlockVarDecl(*CatchParam); 5345 CGF.Builder.CreateStore(ExcObject, CGF.GetAddrOfLocalVar(CatchParam)); 5346 } 5347 5348 CGF.ObjCEHValueStack.push_back(ExcObject); 5349 CGF.EmitStmt(CatchBody); 5350 CGF.ObjCEHValueStack.pop_back(); 5351 5352 CGF.EmitBranchThroughCleanup(FinallyEnd); 5353 5354 CGF.EmitBlock(MatchHandler); 5355 5356 llvm::Value *Exc = CGF.Builder.CreateCall(llvm_eh_exception, "exc"); 5357 // We are required to emit this call to satisfy LLVM, even 5358 // though we don't use the result. 5359 llvm::SmallVector<llvm::Value*, 8> Args; 5360 Args.push_back(Exc); 5361 Args.push_back(ObjCTypes.EHPersonalityPtr); 5362 Args.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, 5363 0)); 5364 CGF.Builder.CreateCall(llvm_eh_selector_i64, Args.begin(), Args.end()); 5365 CGF.Builder.CreateStore(Exc, RethrowPtr); 5366 CGF.EmitBranchThroughCleanup(FinallyRethrow); 5367 5368 CodeGenFunction::CleanupBlockInfo Info = CGF.PopCleanupBlock(); 5369 5370 CGF.EmitBlock(MatchEnd); 5371 5372 // Unfortunately, we also have to generate another EH frame here 5373 // in case this throws. 5374 llvm::BasicBlock *MatchEndHandler = 5375 CGF.createBasicBlock("match.end.handler"); 5376 llvm::BasicBlock *Cont = CGF.createBasicBlock("invoke.cont"); 5377 CGF.Builder.CreateInvoke(ObjCTypes.ObjCEndCatchFn, 5378 Cont, MatchEndHandler, 5379 Args.begin(), Args.begin()); 5380 5381 CGF.EmitBlock(Cont); 5382 if (Info.SwitchBlock) 5383 CGF.EmitBlock(Info.SwitchBlock); 5384 if (Info.EndBlock) 5385 CGF.EmitBlock(Info.EndBlock); 5386 5387 CGF.EmitBlock(MatchEndHandler); 5388 Exc = CGF.Builder.CreateCall(llvm_eh_exception, "exc"); 5389 // We are required to emit this call to satisfy LLVM, even 5390 // though we don't use the result. 5391 Args.clear(); 5392 Args.push_back(Exc); 5393 Args.push_back(ObjCTypes.EHPersonalityPtr); 5394 Args.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, 5395 0)); 5396 CGF.Builder.CreateCall(llvm_eh_selector_i64, Args.begin(), Args.end()); 5397 CGF.Builder.CreateStore(Exc, RethrowPtr); 5398 CGF.EmitBranchThroughCleanup(FinallyRethrow); 5399 5400 if (Next) 5401 CGF.EmitBlock(Next); 5402 } else { 5403 assert(!Next && "catchup should be last handler."); 5404 5405 CGF.Builder.CreateStore(Exc, RethrowPtr); 5406 CGF.EmitBranchThroughCleanup(FinallyRethrow); 5407 } 5408 } 5409 5410 // Pop the cleanup entry, the @finally is outside this cleanup 5411 // scope. 5412 CodeGenFunction::CleanupBlockInfo Info = CGF.PopCleanupBlock(); 5413 CGF.setInvokeDest(PrevLandingPad); 5414 5415 CGF.EmitBlock(FinallyBlock); 5416 5417 if (isTry) { 5418 if (const ObjCAtFinallyStmt* FinallyStmt = 5419 cast<ObjCAtTryStmt>(S).getFinallyStmt()) 5420 CGF.EmitStmt(FinallyStmt->getFinallyBody()); 5421 } else { 5422 // Emit 'objc_sync_exit(expr)' as finally's sole statement for 5423 // @synchronized. 5424 CGF.Builder.CreateCall(ObjCTypes.SyncExitFn, SyncArg); 5425 } 5426 5427 if (Info.SwitchBlock) 5428 CGF.EmitBlock(Info.SwitchBlock); 5429 if (Info.EndBlock) 5430 CGF.EmitBlock(Info.EndBlock); 5431 5432 // Branch around the rethrow code. 5433 CGF.EmitBranch(FinallyEnd); 5434 5435 CGF.EmitBlock(FinallyRethrow); 5436 CGF.Builder.CreateCall(ObjCTypes.UnwindResumeOrRethrowFn, 5437 CGF.Builder.CreateLoad(RethrowPtr)); 5438 CGF.Builder.CreateUnreachable(); 5439 5440 CGF.EmitBlock(FinallyEnd); 5441} 5442 5443/// EmitThrowStmt - Generate code for a throw statement. 5444void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF, 5445 const ObjCAtThrowStmt &S) { 5446 llvm::Value *Exception; 5447 if (const Expr *ThrowExpr = S.getThrowExpr()) { 5448 Exception = CGF.EmitScalarExpr(ThrowExpr); 5449 } else { 5450 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) && 5451 "Unexpected rethrow outside @catch block."); 5452 Exception = CGF.ObjCEHValueStack.back(); 5453 } 5454 5455 llvm::Value *ExceptionAsObject = 5456 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy, "tmp"); 5457 llvm::BasicBlock *InvokeDest = CGF.getInvokeDest(); 5458 if (InvokeDest) { 5459 llvm::BasicBlock *Cont = CGF.createBasicBlock("invoke.cont"); 5460 CGF.Builder.CreateInvoke(ObjCTypes.ExceptionThrowFn, 5461 Cont, InvokeDest, 5462 &ExceptionAsObject, &ExceptionAsObject + 1); 5463 CGF.EmitBlock(Cont); 5464 } else 5465 CGF.Builder.CreateCall(ObjCTypes.ExceptionThrowFn, ExceptionAsObject); 5466 CGF.Builder.CreateUnreachable(); 5467 5468 // Clear the insertion point to indicate we are in unreachable code. 5469 CGF.Builder.ClearInsertionPoint(); 5470} 5471 5472llvm::Value * 5473CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceType *IT) { 5474 const ObjCInterfaceDecl *ID = IT->getDecl(); 5475 llvm::GlobalVariable * &Entry = EHTypeReferences[ID->getIdentifier()]; 5476 if (Entry) 5477 return Entry; 5478 5479 std::string ClassName("\01_OBJC_CLASS_$_" + ID->getNameAsString()); 5480 std::string VTableName = "objc_ehtype_vtable"; 5481 llvm::GlobalVariable *VTableGV = 5482 CGM.getModule().getGlobalVariable(VTableName); 5483 if (!VTableGV) 5484 VTableGV = new llvm::GlobalVariable(ObjCTypes.Int8PtrTy, false, 5485 llvm::GlobalValue::ExternalLinkage, 5486 0, VTableName, &CGM.getModule()); 5487 5488 llvm::Value *VTableIdx = llvm::ConstantInt::get(llvm::Type::Int32Ty, 2); 5489 5490 std::vector<llvm::Constant*> Values(3); 5491 Values[0] = llvm::ConstantExpr::getGetElementPtr(VTableGV, &VTableIdx, 1); 5492 Values[1] = GetClassName(ID->getIdentifier()); 5493 Values[2] = GetClassGlobal(ClassName); 5494 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.EHTypeTy, Values); 5495 5496 Entry = 5497 new llvm::GlobalVariable(ObjCTypes.EHTypeTy, false, 5498 llvm::GlobalValue::WeakAnyLinkage, 5499 Init, 5500 (std::string("OBJC_EHTYPE_$_") + 5501 ID->getIdentifier()->getName()), 5502 &CGM.getModule()); 5503 5504 return Entry; 5505} 5506 5507/* *** */ 5508 5509CodeGen::CGObjCRuntime * 5510CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) { 5511 return new CGObjCMac(CGM); 5512} 5513 5514CodeGen::CGObjCRuntime * 5515CodeGen::CreateMacNonFragileABIObjCRuntime(CodeGen::CodeGenModule &CGM) { 5516 return new CGObjCNonFragileABIMac(CGM); 5517} 5518