2008-08-11 10:45:11 +08:00
|
|
|
//===------- CGObjCMac.cpp - Interface to Apple Objective-C Runtime -------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This provides Objective-C code generation targetting the Apple runtime.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "CGObjCRuntime.h"
|
2008-08-12 05:35:06 +08:00
|
|
|
|
|
|
|
#include "CodeGenModule.h"
|
2008-08-16 11:19:19 +08:00
|
|
|
#include "CodeGenFunction.h"
|
2008-08-12 08:12:39 +08:00
|
|
|
#include "clang/AST/ASTContext.h"
|
2008-08-11 12:54:23 +08:00
|
|
|
#include "clang/AST/Decl.h"
|
2008-08-13 11:21:16 +08:00
|
|
|
#include "clang/AST/DeclObjC.h"
|
2008-08-12 05:35:06 +08:00
|
|
|
#include "clang/Basic/LangOptions.h"
|
|
|
|
|
2009-02-24 15:47:38 +08:00
|
|
|
#include "llvm/Intrinsics.h"
|
2008-08-12 08:12:39 +08:00
|
|
|
#include "llvm/Module.h"
|
2008-10-30 06:36:39 +08:00
|
|
|
#include "llvm/ADT/DenseSet.h"
|
2008-08-12 14:48:42 +08:00
|
|
|
#include "llvm/Target/TargetData.h"
|
2008-08-16 11:19:19 +08:00
|
|
|
#include <sstream>
|
2008-08-11 10:45:11 +08:00
|
|
|
|
|
|
|
using namespace clang;
|
2008-09-09 09:06:48 +08:00
|
|
|
using namespace CodeGen;
|
2008-08-11 10:45:11 +08:00
|
|
|
|
|
|
|
namespace {
|
2008-08-12 08:12:39 +08:00
|
|
|
|
2008-08-27 10:31:56 +08:00
|
|
|
typedef std::vector<llvm::Constant*> ConstantVector;
|
|
|
|
|
2008-08-13 11:21:16 +08:00
|
|
|
// FIXME: We should find a nicer way to make the labels for
|
|
|
|
// metadata, string concatenation is lame.
|
|
|
|
|
2009-01-22 06:04:16 +08:00
|
|
|
class ObjCCommonTypesHelper {
|
|
|
|
protected:
|
|
|
|
CodeGen::CodeGenModule &CGM;
|
2008-08-12 08:12:39 +08:00
|
|
|
|
|
|
|
public:
|
2009-03-24 03:10:40 +08:00
|
|
|
const llvm::Type *ShortTy, *IntTy, *LongTy, *LongLongTy;
|
2008-08-21 12:36:09 +08:00
|
|
|
const llvm::Type *Int8PtrTy;
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2008-08-12 13:28:47 +08:00
|
|
|
/// ObjectPtrTy - LLVM type for object handles (typeof(id))
|
|
|
|
const llvm::Type *ObjectPtrTy;
|
2008-11-19 04:18:11 +08:00
|
|
|
|
|
|
|
/// PtrObjectPtrTy - LLVM type for id *
|
|
|
|
const llvm::Type *PtrObjectPtrTy;
|
|
|
|
|
2008-08-12 14:48:42 +08:00
|
|
|
/// SelectorPtrTy - LLVM type for selector handles (typeof(SEL))
|
2008-08-12 13:28:47 +08:00
|
|
|
const llvm::Type *SelectorPtrTy;
|
2008-08-13 11:21:16 +08:00
|
|
|
/// ProtocolPtrTy - LLVM type for external protocol handles
|
|
|
|
/// (typeof(Protocol))
|
|
|
|
const llvm::Type *ExternalProtocolPtrTy;
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2008-08-30 11:02:31 +08:00
|
|
|
// SuperCTy - clang type for struct objc_super.
|
|
|
|
QualType SuperCTy;
|
|
|
|
// SuperPtrCTy - clang type for struct objc_super *.
|
|
|
|
QualType SuperPtrCTy;
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2008-08-23 12:28:29 +08:00
|
|
|
/// SuperTy - LLVM type for struct objc_super.
|
|
|
|
const llvm::StructType *SuperTy;
|
2008-08-23 17:25:55 +08:00
|
|
|
/// SuperPtrTy - LLVM type for struct objc_super *.
|
|
|
|
const llvm::Type *SuperPtrTy;
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2009-01-23 07:02:58 +08:00
|
|
|
/// PropertyTy - LLVM type for struct objc_property (struct _prop_t
|
|
|
|
/// in GCC parlance).
|
|
|
|
const llvm::StructType *PropertyTy;
|
|
|
|
|
|
|
|
/// PropertyListTy - LLVM type for struct objc_property_list
|
|
|
|
/// (_prop_list_t in GCC parlance).
|
|
|
|
const llvm::StructType *PropertyListTy;
|
|
|
|
/// PropertyListPtrTy - LLVM type for struct objc_property_list*.
|
|
|
|
const llvm::Type *PropertyListPtrTy;
|
|
|
|
|
|
|
|
// MethodTy - LLVM type for struct objc_method.
|
|
|
|
const llvm::StructType *MethodTy;
|
|
|
|
|
2009-01-23 09:46:23 +08:00
|
|
|
/// CacheTy - LLVM type for struct objc_cache.
|
|
|
|
const llvm::Type *CacheTy;
|
|
|
|
/// CachePtrTy - LLVM type for struct objc_cache *.
|
|
|
|
const llvm::Type *CachePtrTy;
|
|
|
|
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *GetPropertyFn, *SetPropertyFn;
|
2009-01-22 08:37:21 +08:00
|
|
|
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *EnumerationMutationFn;
|
2009-01-22 08:37:21 +08:00
|
|
|
|
|
|
|
/// GcReadWeakFn -- LLVM objc_read_weak (id *src) function.
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *GcReadWeakFn;
|
2009-01-22 08:37:21 +08:00
|
|
|
|
|
|
|
/// GcAssignWeakFn -- LLVM objc_assign_weak function.
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *GcAssignWeakFn;
|
2009-01-22 08:37:21 +08:00
|
|
|
|
|
|
|
/// GcAssignGlobalFn -- LLVM objc_assign_global function.
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *GcAssignGlobalFn;
|
2009-01-22 08:37:21 +08:00
|
|
|
|
|
|
|
/// GcAssignIvarFn -- LLVM objc_assign_ivar function.
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *GcAssignIvarFn;
|
2009-01-22 08:37:21 +08:00
|
|
|
|
|
|
|
/// GcAssignStrongCastFn -- LLVM objc_assign_strongCast function.
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *GcAssignStrongCastFn;
|
2009-02-17 06:59:18 +08:00
|
|
|
|
|
|
|
/// ExceptionThrowFn - LLVM objc_exception_throw function.
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *ExceptionThrowFn;
|
2009-02-17 06:59:18 +08:00
|
|
|
|
2009-02-24 09:43:46 +08:00
|
|
|
/// SyncEnterFn - LLVM object_sync_enter function.
|
2009-04-07 00:53:45 +08:00
|
|
|
llvm::Constant *getSyncEnterFn() {
|
|
|
|
// void objc_sync_enter (id)
|
|
|
|
std::vector<const llvm::Type*> Args(1, ObjectPtrTy);
|
|
|
|
llvm::FunctionType *FTy =
|
|
|
|
llvm::FunctionType::get(llvm::Type::VoidTy, Args, false);
|
|
|
|
return CGM.CreateRuntimeFunction(FTy, "objc_sync_enter");
|
|
|
|
}
|
2009-02-24 09:43:46 +08:00
|
|
|
|
|
|
|
/// SyncExitFn - LLVM object_sync_exit function.
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *SyncExitFn;
|
2009-02-24 09:43:46 +08:00
|
|
|
|
2009-01-22 06:04:16 +08:00
|
|
|
ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm);
|
|
|
|
~ObjCCommonTypesHelper(){}
|
|
|
|
};
|
2008-08-23 12:28:29 +08:00
|
|
|
|
2009-01-22 06:04:16 +08:00
|
|
|
/// ObjCTypesHelper - Helper class that encapsulates lazy
|
|
|
|
/// construction of varies types used during ObjC generation.
|
|
|
|
class ObjCTypesHelper : public ObjCCommonTypesHelper {
|
|
|
|
private:
|
|
|
|
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *MessageSendFn, *MessageSendStretFn, *MessageSendFpretFn;
|
|
|
|
llvm::Constant *MessageSendSuperFn, *MessageSendSuperStretFn,
|
2009-01-22 06:04:16 +08:00
|
|
|
*MessageSendSuperFpretFn;
|
|
|
|
|
|
|
|
public:
|
2008-08-12 14:48:42 +08:00
|
|
|
/// SymtabTy - LLVM type for struct objc_symtab.
|
|
|
|
const llvm::StructType *SymtabTy;
|
2008-08-21 12:36:09 +08:00
|
|
|
/// SymtabPtrTy - LLVM type for struct objc_symtab *.
|
|
|
|
const llvm::Type *SymtabPtrTy;
|
2008-08-12 14:48:42 +08:00
|
|
|
/// ModuleTy - LLVM type for struct objc_module.
|
|
|
|
const llvm::StructType *ModuleTy;
|
2008-08-12 11:39:23 +08:00
|
|
|
|
2008-08-13 11:21:16 +08:00
|
|
|
/// ProtocolTy - LLVM type for struct objc_protocol.
|
|
|
|
const llvm::StructType *ProtocolTy;
|
|
|
|
/// ProtocolPtrTy - LLVM type for struct objc_protocol *.
|
|
|
|
const llvm::Type *ProtocolPtrTy;
|
|
|
|
/// ProtocolExtensionTy - LLVM type for struct
|
|
|
|
/// objc_protocol_extension.
|
|
|
|
const llvm::StructType *ProtocolExtensionTy;
|
|
|
|
/// ProtocolExtensionTy - LLVM type for struct
|
|
|
|
/// objc_protocol_extension *.
|
|
|
|
const llvm::Type *ProtocolExtensionPtrTy;
|
|
|
|
/// MethodDescriptionTy - LLVM type for struct
|
|
|
|
/// objc_method_description.
|
|
|
|
const llvm::StructType *MethodDescriptionTy;
|
|
|
|
/// MethodDescriptionListTy - LLVM type for struct
|
|
|
|
/// objc_method_description_list.
|
|
|
|
const llvm::StructType *MethodDescriptionListTy;
|
|
|
|
/// MethodDescriptionListPtrTy - LLVM type for struct
|
|
|
|
/// objc_method_description_list *.
|
|
|
|
const llvm::Type *MethodDescriptionListPtrTy;
|
|
|
|
/// ProtocolListTy - LLVM type for struct objc_property_list.
|
|
|
|
const llvm::Type *ProtocolListTy;
|
|
|
|
/// ProtocolListPtrTy - LLVM type for struct objc_property_list*.
|
|
|
|
const llvm::Type *ProtocolListPtrTy;
|
2008-08-23 04:34:54 +08:00
|
|
|
/// CategoryTy - LLVM type for struct objc_category.
|
|
|
|
const llvm::StructType *CategoryTy;
|
2008-08-21 12:36:09 +08:00
|
|
|
/// ClassTy - LLVM type for struct objc_class.
|
|
|
|
const llvm::StructType *ClassTy;
|
|
|
|
/// ClassPtrTy - LLVM type for struct objc_class *.
|
|
|
|
const llvm::Type *ClassPtrTy;
|
|
|
|
/// ClassExtensionTy - LLVM type for struct objc_class_ext.
|
|
|
|
const llvm::StructType *ClassExtensionTy;
|
|
|
|
/// ClassExtensionPtrTy - LLVM type for struct objc_class_ext *.
|
|
|
|
const llvm::Type *ClassExtensionPtrTy;
|
|
|
|
// IvarTy - LLVM type for struct objc_ivar.
|
|
|
|
const llvm::StructType *IvarTy;
|
|
|
|
/// IvarListTy - LLVM type for struct objc_ivar_list.
|
|
|
|
const llvm::Type *IvarListTy;
|
|
|
|
/// IvarListPtrTy - LLVM type for struct objc_ivar_list *.
|
|
|
|
const llvm::Type *IvarListPtrTy;
|
|
|
|
/// MethodListTy - LLVM type for struct objc_method_list.
|
|
|
|
const llvm::Type *MethodListTy;
|
|
|
|
/// MethodListPtrTy - LLVM type for struct objc_method_list *.
|
|
|
|
const llvm::Type *MethodListPtrTy;
|
2008-09-09 18:10:21 +08:00
|
|
|
|
|
|
|
/// ExceptionDataTy - LLVM type for struct _objc_exception_data.
|
|
|
|
const llvm::Type *ExceptionDataTy;
|
|
|
|
|
|
|
|
/// ExceptionTryEnterFn - LLVM objc_exception_try_enter function.
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *ExceptionTryEnterFn;
|
2008-09-09 18:10:21 +08:00
|
|
|
|
|
|
|
/// ExceptionTryExitFn - LLVM objc_exception_try_exit function.
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *ExceptionTryExitFn;
|
2008-09-09 18:10:21 +08:00
|
|
|
|
|
|
|
/// ExceptionExtractFn - LLVM objc_exception_extract function.
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *ExceptionExtractFn;
|
2008-09-09 18:10:21 +08:00
|
|
|
|
|
|
|
/// ExceptionMatchFn - LLVM objc_exception_match function.
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *ExceptionMatchFn;
|
2008-09-09 18:10:21 +08:00
|
|
|
|
|
|
|
/// SetJmpFn - LLVM _setjmp function.
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *SetJmpFn;
|
2008-11-16 05:26:17 +08:00
|
|
|
|
2008-08-12 08:12:39 +08:00
|
|
|
public:
|
|
|
|
ObjCTypesHelper(CodeGen::CodeGenModule &cgm);
|
2009-01-22 06:04:16 +08:00
|
|
|
~ObjCTypesHelper() {}
|
2008-10-17 11:24:53 +08:00
|
|
|
|
|
|
|
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *getSendFn(bool IsSuper) {
|
2008-10-17 11:24:53 +08:00
|
|
|
return IsSuper ? MessageSendSuperFn : MessageSendFn;
|
|
|
|
}
|
|
|
|
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *getSendStretFn(bool IsSuper) {
|
2008-10-17 11:24:53 +08:00
|
|
|
return IsSuper ? MessageSendSuperStretFn : MessageSendStretFn;
|
|
|
|
}
|
|
|
|
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *getSendFpretFn(bool IsSuper) {
|
2008-10-17 11:24:53 +08:00
|
|
|
return IsSuper ? MessageSendSuperFpretFn : MessageSendFpretFn;
|
|
|
|
}
|
2008-08-12 08:12:39 +08:00
|
|
|
};
|
|
|
|
|
2009-01-23 07:02:58 +08:00
|
|
|
/// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's
|
2009-01-22 06:04:16 +08:00
|
|
|
/// modern abi
|
2009-01-23 07:02:58 +08:00
|
|
|
class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper {
|
2009-02-05 04:42:28 +08:00
|
|
|
public:
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *MessageSendFixupFn, *MessageSendFpretFixupFn,
|
2009-02-04 07:49:23 +08:00
|
|
|
*MessageSendStretFixupFn, *MessageSendIdFixupFn,
|
|
|
|
*MessageSendIdStretFixupFn, *MessageSendSuper2FixupFn,
|
|
|
|
*MessageSendSuper2StretFixupFn;
|
|
|
|
|
2009-01-23 09:46:23 +08:00
|
|
|
// MethodListnfABITy - LLVM for struct _method_list_t
|
|
|
|
const llvm::StructType *MethodListnfABITy;
|
|
|
|
|
|
|
|
// MethodListnfABIPtrTy - LLVM for struct _method_list_t*
|
|
|
|
const llvm::Type *MethodListnfABIPtrTy;
|
|
|
|
|
|
|
|
// ProtocolnfABITy = LLVM for struct _protocol_t
|
|
|
|
const llvm::StructType *ProtocolnfABITy;
|
|
|
|
|
2009-02-15 15:36:20 +08:00
|
|
|
// ProtocolnfABIPtrTy = LLVM for struct _protocol_t*
|
|
|
|
const llvm::Type *ProtocolnfABIPtrTy;
|
|
|
|
|
2009-01-23 09:46:23 +08:00
|
|
|
// ProtocolListnfABITy - LLVM for struct _objc_protocol_list
|
|
|
|
const llvm::StructType *ProtocolListnfABITy;
|
|
|
|
|
|
|
|
// ProtocolListnfABIPtrTy - LLVM for struct _objc_protocol_list*
|
|
|
|
const llvm::Type *ProtocolListnfABIPtrTy;
|
|
|
|
|
|
|
|
// ClassnfABITy - LLVM for struct _class_t
|
|
|
|
const llvm::StructType *ClassnfABITy;
|
|
|
|
|
2009-01-24 07:53:38 +08:00
|
|
|
// ClassnfABIPtrTy - LLVM for struct _class_t*
|
|
|
|
const llvm::Type *ClassnfABIPtrTy;
|
|
|
|
|
2009-01-23 09:46:23 +08:00
|
|
|
// IvarnfABITy - LLVM for struct _ivar_t
|
|
|
|
const llvm::StructType *IvarnfABITy;
|
|
|
|
|
|
|
|
// IvarListnfABITy - LLVM for struct _ivar_list_t
|
|
|
|
const llvm::StructType *IvarListnfABITy;
|
|
|
|
|
|
|
|
// IvarListnfABIPtrTy = LLVM for struct _ivar_list_t*
|
|
|
|
const llvm::Type *IvarListnfABIPtrTy;
|
|
|
|
|
|
|
|
// ClassRonfABITy - LLVM for struct _class_ro_t
|
|
|
|
const llvm::StructType *ClassRonfABITy;
|
|
|
|
|
|
|
|
// ImpnfABITy - LLVM for id (*)(id, SEL, ...)
|
|
|
|
const llvm::Type *ImpnfABITy;
|
|
|
|
|
|
|
|
// CategorynfABITy - LLVM for struct _category_t
|
|
|
|
const llvm::StructType *CategorynfABITy;
|
|
|
|
|
2009-02-04 07:49:23 +08:00
|
|
|
// New types for nonfragile abi messaging.
|
|
|
|
|
|
|
|
// MessageRefTy - LLVM for:
|
|
|
|
// struct _message_ref_t {
|
|
|
|
// IMP messenger;
|
|
|
|
// SEL name;
|
|
|
|
// };
|
|
|
|
const llvm::StructType *MessageRefTy;
|
2009-02-05 04:42:28 +08:00
|
|
|
// MessageRefCTy - clang type for struct _message_ref_t
|
|
|
|
QualType MessageRefCTy;
|
2009-02-04 07:49:23 +08:00
|
|
|
|
|
|
|
// MessageRefPtrTy - LLVM for struct _message_ref_t*
|
|
|
|
const llvm::Type *MessageRefPtrTy;
|
2009-02-05 04:42:28 +08:00
|
|
|
// MessageRefCPtrTy - clang type for struct _message_ref_t*
|
|
|
|
QualType MessageRefCPtrTy;
|
2009-02-04 07:49:23 +08:00
|
|
|
|
2009-02-05 09:13:09 +08:00
|
|
|
// MessengerTy - Type of the messenger (shown as IMP above)
|
|
|
|
const llvm::FunctionType *MessengerTy;
|
|
|
|
|
2009-02-04 07:49:23 +08:00
|
|
|
// SuperMessageRefTy - LLVM for:
|
|
|
|
// struct _super_message_ref_t {
|
|
|
|
// SUPER_IMP messenger;
|
|
|
|
// SEL name;
|
|
|
|
// };
|
|
|
|
const llvm::StructType *SuperMessageRefTy;
|
|
|
|
|
|
|
|
// SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
|
|
|
|
const llvm::Type *SuperMessageRefPtrTy;
|
2009-02-24 15:47:38 +08:00
|
|
|
|
|
|
|
/// EHPersonalityPtr - LLVM value for an i8* to the Objective-C
|
|
|
|
/// exception personality function.
|
2009-04-07 00:53:45 +08:00
|
|
|
llvm::Value *getEHPersonalityPtr() {
|
|
|
|
llvm::Constant *Personality =
|
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::Int32Ty,
|
|
|
|
std::vector<const llvm::Type*>(),
|
|
|
|
true),
|
|
|
|
"__objc_personality_v0");
|
|
|
|
return llvm::ConstantExpr::getBitCast(Personality, Int8PtrTy);
|
|
|
|
}
|
2009-02-24 15:47:38 +08:00
|
|
|
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *UnwindResumeOrRethrowFn, *ObjCBeginCatchFn, *ObjCEndCatchFn;
|
2009-03-01 12:46:24 +08:00
|
|
|
|
|
|
|
const llvm::StructType *EHTypeTy;
|
|
|
|
const llvm::Type *EHTypePtrTy;
|
2009-02-24 15:47:38 +08:00
|
|
|
|
2009-01-23 07:02:58 +08:00
|
|
|
ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm);
|
|
|
|
~ObjCNonFragileABITypesHelper(){}
|
2009-01-22 06:04:16 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
class CGObjCCommonMac : public CodeGen::CGObjCRuntime {
|
2009-03-12 04:59:05 +08:00
|
|
|
public:
|
|
|
|
// FIXME - accessibility
|
2009-03-11 00:22:08 +08:00
|
|
|
class GC_IVAR {
|
2009-03-11 08:07:04 +08:00
|
|
|
public:
|
2009-03-11 00:22:08 +08:00
|
|
|
unsigned int ivar_bytepos;
|
|
|
|
unsigned int ivar_size;
|
|
|
|
GC_IVAR() : ivar_bytepos(0), ivar_size(0) {}
|
|
|
|
};
|
|
|
|
|
2009-03-12 04:59:05 +08:00
|
|
|
class SKIP_SCAN {
|
|
|
|
public:
|
|
|
|
unsigned int skip;
|
|
|
|
unsigned int scan;
|
|
|
|
SKIP_SCAN() : skip(0), scan(0) {}
|
|
|
|
};
|
|
|
|
|
2009-01-22 06:04:16 +08:00
|
|
|
protected:
|
|
|
|
CodeGen::CodeGenModule &CGM;
|
|
|
|
// FIXME! May not be needing this after all.
|
2008-08-12 08:12:39 +08:00
|
|
|
unsigned ObjCABI;
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2009-03-12 04:59:05 +08:00
|
|
|
// gc ivar layout bitmap calculation helper caches.
|
|
|
|
llvm::SmallVector<GC_IVAR, 16> SkipIvars;
|
|
|
|
llvm::SmallVector<GC_IVAR, 16> IvarsInfo;
|
|
|
|
llvm::SmallVector<SKIP_SCAN, 32> SkipScanIvars;
|
2009-03-11 00:22:08 +08:00
|
|
|
|
2008-08-25 14:02:07 +08:00
|
|
|
/// LazySymbols - Symbols to generate a lazy reference for. See
|
|
|
|
/// DefinedSymbols and FinishModule().
|
|
|
|
std::set<IdentifierInfo*> LazySymbols;
|
|
|
|
|
|
|
|
/// DefinedSymbols - External symbols which are defined by this
|
|
|
|
/// module. The symbols in this list and LazySymbols are used to add
|
|
|
|
/// special linker symbols which ensure that Objective-C modules are
|
|
|
|
/// linked properly.
|
|
|
|
std::set<IdentifierInfo*> DefinedSymbols;
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2008-08-12 14:48:42 +08:00
|
|
|
/// ClassNames - uniqued class names.
|
2008-08-13 11:21:16 +08:00
|
|
|
llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassNames;
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2008-08-12 11:39:23 +08:00
|
|
|
/// MethodVarNames - uniqued method variable names.
|
|
|
|
llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames;
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2008-08-13 11:21:16 +08:00
|
|
|
/// MethodVarTypes - uniqued method type signatures. We have to use
|
|
|
|
/// a StringMap here because have no other unique reference.
|
|
|
|
llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes;
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2008-08-27 05:51:14 +08:00
|
|
|
/// MethodDefinitions - map of methods which have been defined in
|
|
|
|
/// this translation unit.
|
|
|
|
llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2008-08-23 08:19:03 +08:00
|
|
|
/// PropertyNames - uniqued method variable names.
|
|
|
|
llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames;
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
/// ClassReferences - uniqued class references.
|
|
|
|
llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences;
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2008-08-12 11:39:23 +08:00
|
|
|
/// SelectorReferences - uniqued selector references.
|
|
|
|
llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences;
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2008-08-13 11:21:16 +08:00
|
|
|
/// Protocols - Protocols for which an objc_protocol structure has
|
|
|
|
/// been emitted. Forward declarations are handled by creating an
|
|
|
|
/// empty structure whose initializer is filled in when/if defined.
|
|
|
|
llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols;
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2008-10-30 06:36:39 +08:00
|
|
|
/// DefinedProtocols - Protocols which have actually been
|
|
|
|
/// defined. We should not need this, see FIXME in GenerateProtocol.
|
|
|
|
llvm::DenseSet<IdentifierInfo*> DefinedProtocols;
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
/// DefinedClasses - List of defined classes.
|
|
|
|
std::vector<llvm::GlobalValue*> DefinedClasses;
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
/// DefinedCategories - List of defined categories.
|
|
|
|
std::vector<llvm::GlobalValue*> DefinedCategories;
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2008-08-13 11:21:16 +08:00
|
|
|
/// UsedGlobals - List of globals to pack into the llvm.used metadata
|
2008-08-12 05:35:06 +08:00
|
|
|
/// to prevent them from being clobbered.
|
2008-08-12 14:48:42 +08:00
|
|
|
std::vector<llvm::GlobalVariable*> UsedGlobals;
|
2008-08-12 05:35:06 +08:00
|
|
|
|
2009-01-22 07:34:32 +08:00
|
|
|
/// GetNameForMethod - Return a name for the given method.
|
|
|
|
/// \param[out] NameOut - The return value.
|
|
|
|
void GetNameForMethod(const ObjCMethodDecl *OMD,
|
|
|
|
const ObjCContainerDecl *CD,
|
|
|
|
std::string &NameOut);
|
|
|
|
|
|
|
|
/// GetMethodVarName - Return a unique constant for the given
|
|
|
|
/// selector's name. The return value has type char *.
|
|
|
|
llvm::Constant *GetMethodVarName(Selector Sel);
|
|
|
|
llvm::Constant *GetMethodVarName(IdentifierInfo *Ident);
|
|
|
|
llvm::Constant *GetMethodVarName(const std::string &Name);
|
|
|
|
|
|
|
|
/// GetMethodVarType - Return a unique constant for the given
|
|
|
|
/// selector's name. The return value has type char *.
|
|
|
|
|
|
|
|
// FIXME: This is a horrible name.
|
|
|
|
llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D);
|
2009-03-05 02:21:39 +08:00
|
|
|
llvm::Constant *GetMethodVarType(FieldDecl *D);
|
2009-01-22 07:34:32 +08:00
|
|
|
|
|
|
|
/// GetPropertyName - Return a unique constant for the given
|
|
|
|
/// name. The return value has type char *.
|
|
|
|
llvm::Constant *GetPropertyName(IdentifierInfo *Ident);
|
|
|
|
|
|
|
|
// FIXME: This can be dropped once string functions are unified.
|
|
|
|
llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD,
|
|
|
|
const Decl *Container);
|
|
|
|
|
2009-01-25 04:21:50 +08:00
|
|
|
/// GetClassName - Return a unique constant for the given selector's
|
|
|
|
/// name. The return value has type char *.
|
|
|
|
llvm::Constant *GetClassName(IdentifierInfo *Ident);
|
|
|
|
|
2009-03-12 05:42:00 +08:00
|
|
|
/// GetInterfaceDeclStructLayout - Get layout for ivars of given
|
|
|
|
/// interface declaration.
|
|
|
|
const llvm::StructLayout *GetInterfaceDeclStructLayout(
|
|
|
|
const ObjCInterfaceDecl *ID) const;
|
|
|
|
|
2009-03-06 06:39:55 +08:00
|
|
|
/// BuildIvarLayout - Builds ivar layout bitmap for the class
|
|
|
|
/// implementation for the __strong or __weak case.
|
|
|
|
///
|
2009-03-13 06:50:49 +08:00
|
|
|
llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI,
|
|
|
|
bool ForStrongLayout);
|
2009-03-06 06:39:55 +08:00
|
|
|
|
2009-04-08 04:26:30 +08:00
|
|
|
bool IsClassHidden(const ObjCInterfaceDecl *ID);
|
|
|
|
|
2009-03-13 06:50:49 +08:00
|
|
|
void BuildAggrIvarLayout(const ObjCInterfaceDecl *OI,
|
|
|
|
const llvm::StructLayout *Layout,
|
2009-03-11 00:22:08 +08:00
|
|
|
const RecordDecl *RD,
|
2009-03-31 16:48:01 +08:00
|
|
|
const llvm::SmallVectorImpl<FieldDecl*> &RecFields,
|
2009-03-06 06:39:55 +08:00
|
|
|
unsigned int BytePos, bool ForStrongLayout,
|
|
|
|
int &Index, int &SkIndex, bool &HasUnion);
|
2009-03-13 06:50:49 +08:00
|
|
|
|
2009-03-06 03:17:31 +08:00
|
|
|
/// GetIvarLayoutName - Returns a unique constant for the given
|
|
|
|
/// ivar layout bitmap.
|
|
|
|
llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident,
|
|
|
|
const ObjCCommonTypesHelper &ObjCTypes);
|
|
|
|
|
2009-01-29 03:12:34 +08:00
|
|
|
const RecordDecl *GetFirstIvarInRecord(const ObjCInterfaceDecl *OID,
|
|
|
|
RecordDecl::field_iterator &FIV,
|
|
|
|
RecordDecl::field_iterator &PIV);
|
2009-01-29 06:18:42 +08:00
|
|
|
/// EmitPropertyList - Emit the given property list. The return
|
|
|
|
/// value has type PropertyListPtrTy.
|
|
|
|
llvm::Constant *EmitPropertyList(const std::string &Name,
|
|
|
|
const Decl *Container,
|
|
|
|
const ObjCContainerDecl *OCD,
|
|
|
|
const ObjCCommonTypesHelper &ObjCTypes);
|
|
|
|
|
2009-01-30 03:24:30 +08:00
|
|
|
/// GetProtocolRef - Return a reference to the internal protocol
|
|
|
|
/// description, creating an empty one if it has not been
|
|
|
|
/// defined. The return value has type ProtocolPtrTy.
|
|
|
|
llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD);
|
2009-03-09 04:18:37 +08:00
|
|
|
|
|
|
|
/// GetIvarBaseOffset - returns ivars byte offset.
|
|
|
|
uint64_t GetIvarBaseOffset(const llvm::StructLayout *Layout,
|
2009-03-31 16:33:16 +08:00
|
|
|
const FieldDecl *Field);
|
2009-01-30 03:24:30 +08:00
|
|
|
|
2009-03-31 16:33:16 +08:00
|
|
|
/// GetFieldBaseOffset - return's field byte offset.
|
2009-03-13 06:50:49 +08:00
|
|
|
uint64_t GetFieldBaseOffset(const ObjCInterfaceDecl *OI,
|
|
|
|
const llvm::StructLayout *Layout,
|
2009-03-31 16:33:16 +08:00
|
|
|
const FieldDecl *Field);
|
2009-03-13 06:50:49 +08:00
|
|
|
|
2009-03-10 04:09:19 +08:00
|
|
|
/// CreateMetadataVar - Create a global variable with internal
|
|
|
|
/// linkage for use by the Objective-C runtime.
|
|
|
|
///
|
|
|
|
/// This is a convenience wrapper which not only creates the
|
|
|
|
/// variable, but also sets the section and alignment and adds the
|
|
|
|
/// global to the UsedGlobals list.
|
2009-03-10 04:50:13 +08:00
|
|
|
///
|
|
|
|
/// \param Name - The variable name.
|
|
|
|
/// \param Init - The variable initializer; this is also used to
|
|
|
|
/// define the type of the variable.
|
|
|
|
/// \param Section - The section the variable should go into, or 0.
|
|
|
|
/// \param Align - The alignment for the variable, or 0.
|
|
|
|
/// \param AddToUsed - Whether the variable should be added to
|
|
|
|
/// llvm.
|
2009-03-10 04:09:19 +08:00
|
|
|
llvm::GlobalVariable *CreateMetadataVar(const std::string &Name,
|
|
|
|
llvm::Constant *Init,
|
|
|
|
const char *Section,
|
2009-03-10 04:50:13 +08:00
|
|
|
unsigned Align,
|
|
|
|
bool AddToUsed);
|
2009-03-10 04:09:19 +08:00
|
|
|
|
2009-01-22 06:04:16 +08:00
|
|
|
public:
|
|
|
|
CGObjCCommonMac(CodeGen::CodeGenModule &cgm) : CGM(cgm)
|
|
|
|
{ }
|
2009-01-24 07:53:38 +08:00
|
|
|
|
2009-04-01 00:53:37 +08:00
|
|
|
virtual llvm::Constant *GenerateConstantString(const ObjCStringLiteral *SL);
|
2009-01-27 05:38:32 +08:00
|
|
|
|
|
|
|
virtual llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
|
|
|
|
const ObjCContainerDecl *CD=0);
|
2009-01-30 03:24:30 +08:00
|
|
|
|
|
|
|
virtual void GenerateProtocol(const ObjCProtocolDecl *PD);
|
|
|
|
|
|
|
|
/// GetOrEmitProtocol - Get the protocol object for the given
|
|
|
|
/// declaration, emitting it if necessary. The return value has type
|
|
|
|
/// ProtocolPtrTy.
|
|
|
|
virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD)=0;
|
|
|
|
|
|
|
|
/// GetOrEmitProtocolRef - Get a forward reference to the protocol
|
|
|
|
/// object for the given declaration, emitting it if needed. These
|
|
|
|
/// forward references will be filled in with empty bodies if no
|
|
|
|
/// definition is seen. The return value has type ProtocolPtrTy.
|
|
|
|
virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0;
|
2009-01-22 06:04:16 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
class CGObjCMac : public CGObjCCommonMac {
|
|
|
|
private:
|
|
|
|
ObjCTypesHelper ObjCTypes;
|
2008-08-12 05:35:06 +08:00
|
|
|
/// EmitImageInfo - Emit the image info marker used to encode some module
|
|
|
|
/// level information.
|
|
|
|
void EmitImageInfo();
|
|
|
|
|
2008-08-12 14:48:42 +08:00
|
|
|
/// EmitModuleInfo - Another marker encoding module level
|
|
|
|
/// information.
|
|
|
|
void EmitModuleInfo();
|
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
/// EmitModuleSymols - Emit module symbols, the list of defined
|
|
|
|
/// classes and categories. The result has type SymtabPtrTy.
|
2008-08-12 14:48:42 +08:00
|
|
|
llvm::Constant *EmitModuleSymbols();
|
|
|
|
|
2008-08-12 05:35:06 +08:00
|
|
|
/// FinishModule - Write out global data structures at the end of
|
|
|
|
/// processing a translation unit.
|
|
|
|
void FinishModule();
|
2008-08-13 11:21:16 +08:00
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
/// EmitClassExtension - Generate the class extension structure used
|
|
|
|
/// to store the weak ivar layout and properties. The return value
|
|
|
|
/// has type ClassExtensionPtrTy.
|
|
|
|
llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID);
|
|
|
|
|
|
|
|
/// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
|
|
|
|
/// for the given class.
|
2008-11-01 09:53:16 +08:00
|
|
|
llvm::Value *EmitClassRef(CGBuilderTy &Builder,
|
2008-08-21 12:36:09 +08:00
|
|
|
const ObjCInterfaceDecl *ID);
|
|
|
|
|
2008-08-23 17:25:55 +08:00
|
|
|
CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
|
2008-08-30 13:35:15 +08:00
|
|
|
QualType ResultType,
|
|
|
|
Selector Sel,
|
2008-08-23 17:25:55 +08:00
|
|
|
llvm::Value *Arg0,
|
2008-08-30 11:02:31 +08:00
|
|
|
QualType Arg0Ty,
|
|
|
|
bool IsSuper,
|
|
|
|
const CallArgList &CallArgs);
|
2008-08-23 17:25:55 +08:00
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
/// EmitIvarList - Emit the ivar list for the given
|
|
|
|
/// implementation. If ForClass is true the list of class ivars
|
|
|
|
/// (i.e. metaclass ivars) is emitted, otherwise the list of
|
|
|
|
/// interface ivars will be emitted. The return value has type
|
|
|
|
/// IvarListPtrTy.
|
|
|
|
llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID,
|
2009-01-29 03:12:34 +08:00
|
|
|
bool ForClass);
|
|
|
|
|
2008-08-25 16:19:24 +08:00
|
|
|
/// EmitMetaClass - Emit a forward reference to the class structure
|
|
|
|
/// for the metaclass of the given interface. The return value has
|
|
|
|
/// type ClassPtrTy.
|
|
|
|
llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID);
|
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
/// EmitMetaClass - Emit a class structure for the metaclass of the
|
2008-08-25 16:19:24 +08:00
|
|
|
/// given implementation. The return value has type ClassPtrTy.
|
2008-08-21 12:36:09 +08:00
|
|
|
llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID,
|
|
|
|
llvm::Constant *Protocols,
|
2008-08-27 05:51:14 +08:00
|
|
|
const llvm::Type *InterfaceTy,
|
2008-08-27 10:31:56 +08:00
|
|
|
const ConstantVector &Methods);
|
2009-01-27 05:38:32 +08:00
|
|
|
|
2008-08-27 10:31:56 +08:00
|
|
|
llvm::Constant *GetMethodConstant(const ObjCMethodDecl *MD);
|
2009-01-27 05:38:32 +08:00
|
|
|
|
2008-08-27 10:31:56 +08:00
|
|
|
llvm::Constant *GetMethodDescriptionConstant(const ObjCMethodDecl *MD);
|
2008-08-21 12:36:09 +08:00
|
|
|
|
|
|
|
/// EmitMethodList - Emit the method list for the given
|
2008-08-26 16:29:31 +08:00
|
|
|
/// implementation. The return value has type MethodListPtrTy.
|
2008-08-23 04:34:54 +08:00
|
|
|
llvm::Constant *EmitMethodList(const std::string &Name,
|
|
|
|
const char *Section,
|
2008-08-27 10:31:56 +08:00
|
|
|
const ConstantVector &Methods);
|
2008-08-21 12:36:09 +08:00
|
|
|
|
|
|
|
/// EmitMethodDescList - Emit a method description list for a list of
|
2008-08-13 11:21:16 +08:00
|
|
|
/// method declarations.
|
|
|
|
/// - TypeName: The name for the type containing the methods.
|
|
|
|
/// - IsProtocol: True iff these methods are for a protocol.
|
|
|
|
/// - ClassMethds: True iff these are class methods.
|
|
|
|
/// - Required: When true, only "required" methods are
|
|
|
|
/// listed. Similarly, when false only "optional" methods are
|
|
|
|
/// listed. For classes this should always be true.
|
|
|
|
/// - begin, end: The method list to output.
|
|
|
|
///
|
|
|
|
/// The return value has type MethodDescriptionListPtrTy.
|
2008-08-27 10:31:56 +08:00
|
|
|
llvm::Constant *EmitMethodDescList(const std::string &Name,
|
|
|
|
const char *Section,
|
|
|
|
const ConstantVector &Methods);
|
2008-08-13 11:21:16 +08:00
|
|
|
|
2008-10-30 06:36:39 +08:00
|
|
|
/// GetOrEmitProtocol - Get the protocol object for the given
|
|
|
|
/// declaration, emitting it if necessary. The return value has type
|
|
|
|
/// ProtocolPtrTy.
|
2009-01-30 03:24:30 +08:00
|
|
|
virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD);
|
2008-10-30 06:36:39 +08:00
|
|
|
|
|
|
|
/// GetOrEmitProtocolRef - Get a forward reference to the protocol
|
|
|
|
/// object for the given declaration, emitting it if needed. These
|
|
|
|
/// forward references will be filled in with empty bodies if no
|
|
|
|
/// definition is seen. The return value has type ProtocolPtrTy.
|
2009-01-30 03:24:30 +08:00
|
|
|
virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD);
|
2008-10-30 06:36:39 +08:00
|
|
|
|
2008-08-13 11:21:16 +08:00
|
|
|
/// EmitProtocolExtension - Generate the protocol extension
|
|
|
|
/// structure used to store optional instance and class methods, and
|
|
|
|
/// protocol properties. The return value has type
|
|
|
|
/// ProtocolExtensionPtrTy.
|
2008-08-27 10:31:56 +08:00
|
|
|
llvm::Constant *
|
|
|
|
EmitProtocolExtension(const ObjCProtocolDecl *PD,
|
|
|
|
const ConstantVector &OptInstanceMethods,
|
|
|
|
const ConstantVector &OptClassMethods);
|
2008-08-13 11:21:16 +08:00
|
|
|
|
|
|
|
/// EmitProtocolList - Generate the list of referenced
|
|
|
|
/// protocols. The return value has type ProtocolListPtrTy.
|
2008-08-22 05:57:41 +08:00
|
|
|
llvm::Constant *EmitProtocolList(const std::string &Name,
|
|
|
|
ObjCProtocolDecl::protocol_iterator begin,
|
|
|
|
ObjCProtocolDecl::protocol_iterator end);
|
2008-08-13 11:21:16 +08:00
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
/// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
|
|
|
|
/// for the given selector.
|
2008-11-01 09:53:16 +08:00
|
|
|
llvm::Value *EmitSelector(CGBuilderTy &Builder, Selector Sel);
|
2009-01-27 05:38:32 +08:00
|
|
|
|
2009-01-30 03:24:30 +08:00
|
|
|
public:
|
2008-08-11 10:45:11 +08:00
|
|
|
CGObjCMac(CodeGen::CodeGenModule &cgm);
|
|
|
|
|
2009-01-24 07:53:38 +08:00
|
|
|
virtual llvm::Function *ModuleInitFunction();
|
|
|
|
|
2008-08-23 11:46:30 +08:00
|
|
|
virtual CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
|
2008-08-30 13:35:15 +08:00
|
|
|
QualType ResultType,
|
|
|
|
Selector Sel,
|
2008-08-25 16:19:24 +08:00
|
|
|
llvm::Value *Receiver,
|
2008-08-30 11:02:31 +08:00
|
|
|
bool IsClassMessage,
|
|
|
|
const CallArgList &CallArgs);
|
2008-08-23 11:46:30 +08:00
|
|
|
|
|
|
|
virtual CodeGen::RValue
|
|
|
|
GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
|
2008-08-30 13:35:15 +08:00
|
|
|
QualType ResultType,
|
|
|
|
Selector Sel,
|
2008-08-25 16:19:24 +08:00
|
|
|
const ObjCInterfaceDecl *Class,
|
2009-03-01 04:07:56 +08:00
|
|
|
bool isCategoryImpl,
|
2008-08-25 16:19:24 +08:00
|
|
|
llvm::Value *Receiver,
|
2008-08-30 11:02:31 +08:00
|
|
|
bool IsClassMessage,
|
|
|
|
const CallArgList &CallArgs);
|
2008-08-16 08:25:02 +08:00
|
|
|
|
2008-11-01 09:53:16 +08:00
|
|
|
virtual llvm::Value *GetClass(CGBuilderTy &Builder,
|
2008-08-21 12:36:09 +08:00
|
|
|
const ObjCInterfaceDecl *ID);
|
2008-08-11 10:45:11 +08:00
|
|
|
|
2008-11-01 09:53:16 +08:00
|
|
|
virtual llvm::Value *GetSelector(CGBuilderTy &Builder, Selector Sel);
|
2008-08-11 10:45:11 +08:00
|
|
|
|
2008-08-16 06:20:32 +08:00
|
|
|
virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD);
|
|
|
|
|
|
|
|
virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl);
|
2008-08-11 10:45:11 +08:00
|
|
|
|
2008-11-01 09:53:16 +08:00
|
|
|
virtual llvm::Value *GenerateProtocolRef(CGBuilderTy &Builder,
|
2008-08-13 08:59:25 +08:00
|
|
|
const ObjCProtocolDecl *PD);
|
2009-01-30 03:24:30 +08:00
|
|
|
|
2009-03-23 05:03:39 +08:00
|
|
|
virtual llvm::Constant *GetPropertyGetFunction();
|
|
|
|
virtual llvm::Constant *GetPropertySetFunction();
|
|
|
|
virtual llvm::Constant *EnumerationMutationFunction();
|
2008-09-09 18:04:29 +08:00
|
|
|
|
2008-11-21 08:49:24 +08:00
|
|
|
virtual void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
|
|
|
|
const Stmt &S);
|
2008-09-09 18:04:29 +08:00
|
|
|
virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
|
|
|
|
const ObjCAtThrowStmt &S);
|
2008-11-19 06:37:34 +08:00
|
|
|
virtual llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
|
2008-11-19 05:45:40 +08:00
|
|
|
llvm::Value *AddrWeakObj);
|
2008-11-19 06:37:34 +08:00
|
|
|
virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
|
|
|
|
llvm::Value *src, llvm::Value *dst);
|
2008-11-19 08:59:10 +08:00
|
|
|
virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
|
|
|
|
llvm::Value *src, llvm::Value *dest);
|
2008-11-21 03:23:36 +08:00
|
|
|
virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
|
|
|
|
llvm::Value *src, llvm::Value *dest);
|
2008-11-19 08:59:10 +08:00
|
|
|
virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
|
|
|
|
llvm::Value *src, llvm::Value *dest);
|
2009-02-03 04:02:29 +08:00
|
|
|
|
2009-02-04 03:03:09 +08:00
|
|
|
virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
|
|
|
|
QualType ObjectTy,
|
|
|
|
llvm::Value *BaseValue,
|
|
|
|
const ObjCIvarDecl *Ivar,
|
|
|
|
const FieldDecl *Field,
|
|
|
|
unsigned CVRQualifiers);
|
2009-02-11 03:02:04 +08:00
|
|
|
virtual llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
|
|
|
|
ObjCInterfaceDecl *Interface,
|
|
|
|
const ObjCIvarDecl *Ivar);
|
2008-08-11 10:45:11 +08:00
|
|
|
};
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2009-01-23 07:02:58 +08:00
|
|
|
class CGObjCNonFragileABIMac : public CGObjCCommonMac {
|
2009-01-22 06:04:16 +08:00
|
|
|
private:
|
2009-01-23 07:02:58 +08:00
|
|
|
ObjCNonFragileABITypesHelper ObjCTypes;
|
2009-01-24 07:53:38 +08:00
|
|
|
llvm::GlobalVariable* ObjCEmptyCacheVar;
|
|
|
|
llvm::GlobalVariable* ObjCEmptyVtableVar;
|
2009-03-02 14:08:11 +08:00
|
|
|
|
2009-02-07 04:09:23 +08:00
|
|
|
/// MetaClassReferences - uniqued meta class references.
|
|
|
|
llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences;
|
2009-03-01 12:46:24 +08:00
|
|
|
|
|
|
|
/// EHTypeReferences - uniqued class ehtype references.
|
|
|
|
llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences;
|
2009-03-02 14:08:11 +08:00
|
|
|
|
2009-01-24 07:53:38 +08:00
|
|
|
/// FinishNonFragileABIModule - Write out global data structures at the end of
|
|
|
|
/// processing a translation unit.
|
|
|
|
void FinishNonFragileABIModule();
|
2009-04-08 12:21:03 +08:00
|
|
|
|
2009-01-25 04:21:50 +08:00
|
|
|
llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags,
|
|
|
|
unsigned InstanceStart,
|
|
|
|
unsigned InstanceSize,
|
|
|
|
const ObjCImplementationDecl *ID);
|
2009-01-25 05:21:53 +08:00
|
|
|
llvm::GlobalVariable * BuildClassMetaData(std::string &ClassName,
|
|
|
|
llvm::Constant *IsAGV,
|
|
|
|
llvm::Constant *SuperClassGV,
|
2009-01-31 08:59:10 +08:00
|
|
|
llvm::Constant *ClassRoGV,
|
|
|
|
bool HiddenVisibility);
|
2009-01-27 05:38:32 +08:00
|
|
|
|
|
|
|
llvm::Constant *GetMethodConstant(const ObjCMethodDecl *MD);
|
|
|
|
|
2009-01-30 08:46:37 +08:00
|
|
|
llvm::Constant *GetMethodDescriptionConstant(const ObjCMethodDecl *MD);
|
|
|
|
|
2009-01-27 05:38:32 +08:00
|
|
|
/// EmitMethodList - Emit the method list for the given
|
|
|
|
/// implementation. The return value has type MethodListnfABITy.
|
|
|
|
llvm::Constant *EmitMethodList(const std::string &Name,
|
|
|
|
const char *Section,
|
2009-01-28 03:38:51 +08:00
|
|
|
const ConstantVector &Methods);
|
|
|
|
/// EmitIvarList - Emit the ivar list for the given
|
|
|
|
/// implementation. If ForClass is true the list of class ivars
|
|
|
|
/// (i.e. metaclass ivars) is emitted, otherwise the list of
|
|
|
|
/// interface ivars will be emitted. The return value has type
|
|
|
|
/// IvarListnfABIPtrTy.
|
|
|
|
llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID);
|
2009-01-25 04:21:50 +08:00
|
|
|
|
2009-02-11 04:21:06 +08:00
|
|
|
llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
|
2009-01-28 09:36:42 +08:00
|
|
|
const ObjCIvarDecl *Ivar,
|
2009-01-28 09:05:23 +08:00
|
|
|
unsigned long int offset);
|
|
|
|
|
2009-01-30 03:24:30 +08:00
|
|
|
/// GetOrEmitProtocol - Get the protocol object for the given
|
|
|
|
/// declaration, emitting it if necessary. The return value has type
|
|
|
|
/// ProtocolPtrTy.
|
|
|
|
virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD);
|
|
|
|
|
|
|
|
/// GetOrEmitProtocolRef - Get a forward reference to the protocol
|
|
|
|
/// object for the given declaration, emitting it if needed. These
|
|
|
|
/// forward references will be filled in with empty bodies if no
|
|
|
|
/// definition is seen. The return value has type ProtocolPtrTy.
|
|
|
|
virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD);
|
|
|
|
|
|
|
|
/// EmitProtocolList - Generate the list of referenced
|
|
|
|
/// protocols. The return value has type ProtocolListPtrTy.
|
|
|
|
llvm::Constant *EmitProtocolList(const std::string &Name,
|
|
|
|
ObjCProtocolDecl::protocol_iterator begin,
|
2009-02-04 08:22:57 +08:00
|
|
|
ObjCProtocolDecl::protocol_iterator end);
|
|
|
|
|
|
|
|
CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
|
|
|
|
QualType ResultType,
|
|
|
|
Selector Sel,
|
2009-02-05 04:42:28 +08:00
|
|
|
llvm::Value *Receiver,
|
2009-02-04 08:22:57 +08:00
|
|
|
QualType Arg0Ty,
|
|
|
|
bool IsSuper,
|
|
|
|
const CallArgList &CallArgs);
|
2009-03-01 12:40:10 +08:00
|
|
|
|
|
|
|
/// GetClassGlobal - Return the global variable for the Objective-C
|
|
|
|
/// class of the given name.
|
2009-04-07 13:48:37 +08:00
|
|
|
llvm::GlobalVariable *GetClassGlobal(const std::string &Name,
|
|
|
|
bool AddToUsed = true);
|
2009-01-30 03:24:30 +08:00
|
|
|
|
2009-02-06 04:41:40 +08:00
|
|
|
/// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
|
|
|
|
/// for the given class.
|
|
|
|
llvm::Value *EmitClassRef(CGBuilderTy &Builder,
|
2009-02-07 04:09:23 +08:00
|
|
|
const ObjCInterfaceDecl *ID,
|
|
|
|
bool IsSuper = false);
|
|
|
|
|
|
|
|
/// EmitMetaClassRef - Return a Value * of the address of _class_t
|
|
|
|
/// meta-data
|
|
|
|
llvm::Value *EmitMetaClassRef(CGBuilderTy &Builder,
|
|
|
|
const ObjCInterfaceDecl *ID);
|
|
|
|
|
2009-02-11 04:21:06 +08:00
|
|
|
/// ObjCIvarOffsetVariable - Returns the ivar offset variable for
|
|
|
|
/// the given ivar.
|
|
|
|
///
|
|
|
|
llvm::GlobalVariable * ObjCIvarOffsetVariable(std::string &Name,
|
2009-02-13 02:51:23 +08:00
|
|
|
const ObjCInterfaceDecl *ID,
|
2009-02-11 04:21:06 +08:00
|
|
|
const ObjCIvarDecl *Ivar);
|
2009-02-06 04:41:40 +08:00
|
|
|
|
2009-02-12 04:51:17 +08:00
|
|
|
/// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
|
|
|
|
/// for the given selector.
|
|
|
|
llvm::Value *EmitSelector(CGBuilderTy &Builder, Selector Sel);
|
2009-03-01 12:46:24 +08:00
|
|
|
|
2009-04-08 12:21:03 +08:00
|
|
|
/// GetInterfaceEHType - Get the cached ehtype for the given Objective-C
|
2009-03-01 12:46:24 +08:00
|
|
|
/// interface. The return value has type EHTypePtrTy.
|
2009-04-08 12:21:03 +08:00
|
|
|
llvm::Value *GetInterfaceEHType(const ObjCInterfaceDecl *ID,
|
|
|
|
bool ForDefinition);
|
2009-04-07 13:48:37 +08:00
|
|
|
|
|
|
|
const char *getMetaclassSymbolPrefix() const {
|
|
|
|
return "OBJC_METACLASS_$_";
|
|
|
|
}
|
2009-03-02 14:08:11 +08:00
|
|
|
|
2009-04-07 13:48:37 +08:00
|
|
|
const char *getClassSymbolPrefix() const {
|
|
|
|
return "OBJC_CLASS_$_";
|
|
|
|
}
|
|
|
|
|
2009-01-22 06:04:16 +08:00
|
|
|
public:
|
2009-01-23 07:02:58 +08:00
|
|
|
CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm);
|
2009-01-24 07:53:38 +08:00
|
|
|
// FIXME. All stubs for now!
|
|
|
|
virtual llvm::Function *ModuleInitFunction();
|
|
|
|
|
|
|
|
virtual CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
|
|
|
|
QualType ResultType,
|
|
|
|
Selector Sel,
|
|
|
|
llvm::Value *Receiver,
|
|
|
|
bool IsClassMessage,
|
2009-02-04 08:22:57 +08:00
|
|
|
const CallArgList &CallArgs);
|
2009-01-24 07:53:38 +08:00
|
|
|
|
|
|
|
virtual CodeGen::RValue
|
|
|
|
GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
|
|
|
|
QualType ResultType,
|
|
|
|
Selector Sel,
|
|
|
|
const ObjCInterfaceDecl *Class,
|
2009-03-01 04:07:56 +08:00
|
|
|
bool isCategoryImpl,
|
2009-01-24 07:53:38 +08:00
|
|
|
llvm::Value *Receiver,
|
|
|
|
bool IsClassMessage,
|
2009-02-07 04:09:23 +08:00
|
|
|
const CallArgList &CallArgs);
|
2009-01-24 07:53:38 +08:00
|
|
|
|
|
|
|
virtual llvm::Value *GetClass(CGBuilderTy &Builder,
|
2009-02-06 04:41:40 +08:00
|
|
|
const ObjCInterfaceDecl *ID);
|
2009-01-24 07:53:38 +08:00
|
|
|
|
|
|
|
virtual llvm::Value *GetSelector(CGBuilderTy &Builder, Selector Sel)
|
2009-02-12 04:51:17 +08:00
|
|
|
{ return EmitSelector(Builder, Sel); }
|
2009-01-24 07:53:38 +08:00
|
|
|
|
2009-01-27 02:32:24 +08:00
|
|
|
virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD);
|
2009-01-24 07:53:38 +08:00
|
|
|
|
|
|
|
virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl);
|
|
|
|
virtual llvm::Value *GenerateProtocolRef(CGBuilderTy &Builder,
|
2009-01-31 02:58:59 +08:00
|
|
|
const ObjCProtocolDecl *PD);
|
2009-01-24 07:53:38 +08:00
|
|
|
|
2009-03-23 05:03:39 +08:00
|
|
|
virtual llvm::Constant *GetPropertyGetFunction() {
|
2009-02-11 03:02:04 +08:00
|
|
|
return ObjCTypes.GetPropertyFn;
|
|
|
|
}
|
2009-03-23 05:03:39 +08:00
|
|
|
virtual llvm::Constant *GetPropertySetFunction() {
|
2009-02-11 03:02:04 +08:00
|
|
|
return ObjCTypes.SetPropertyFn;
|
|
|
|
}
|
2009-03-23 05:03:39 +08:00
|
|
|
virtual llvm::Constant *EnumerationMutationFunction() {
|
2009-02-17 02:48:45 +08:00
|
|
|
return ObjCTypes.EnumerationMutationFn;
|
|
|
|
}
|
2009-01-24 07:53:38 +08:00
|
|
|
|
|
|
|
virtual void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
|
2009-02-24 15:47:38 +08:00
|
|
|
const Stmt &S);
|
2009-01-24 07:53:38 +08:00
|
|
|
virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
|
2009-02-17 06:59:18 +08:00
|
|
|
const ObjCAtThrowStmt &S);
|
2009-01-24 07:53:38 +08:00
|
|
|
virtual llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
|
2009-02-17 06:52:32 +08:00
|
|
|
llvm::Value *AddrWeakObj);
|
2009-01-24 07:53:38 +08:00
|
|
|
virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
|
2009-02-17 06:52:32 +08:00
|
|
|
llvm::Value *src, llvm::Value *dst);
|
2009-01-24 07:53:38 +08:00
|
|
|
virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
|
2009-02-17 06:52:32 +08:00
|
|
|
llvm::Value *src, llvm::Value *dest);
|
2009-01-24 07:53:38 +08:00
|
|
|
virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
|
2009-02-17 06:52:32 +08:00
|
|
|
llvm::Value *src, llvm::Value *dest);
|
2009-01-24 07:53:38 +08:00
|
|
|
virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
|
2009-02-17 06:52:32 +08:00
|
|
|
llvm::Value *src, llvm::Value *dest);
|
2009-02-04 03:03:09 +08:00
|
|
|
virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
|
|
|
|
QualType ObjectTy,
|
|
|
|
llvm::Value *BaseValue,
|
|
|
|
const ObjCIvarDecl *Ivar,
|
|
|
|
const FieldDecl *Field,
|
|
|
|
unsigned CVRQualifiers);
|
2009-02-11 03:02:04 +08:00
|
|
|
virtual llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
|
|
|
|
ObjCInterfaceDecl *Interface,
|
|
|
|
const ObjCIvarDecl *Ivar);
|
2009-01-22 06:04:16 +08:00
|
|
|
};
|
|
|
|
|
2008-08-11 10:45:11 +08:00
|
|
|
} // end anonymous namespace
|
2008-08-12 08:12:39 +08:00
|
|
|
|
|
|
|
/* *** Helper Functions *** */
|
|
|
|
|
|
|
|
/// getConstantGEP() - Help routine to construct simple GEPs.
|
|
|
|
static llvm::Constant *getConstantGEP(llvm::Constant *C,
|
|
|
|
unsigned idx0,
|
|
|
|
unsigned idx1) {
|
|
|
|
llvm::Value *Idxs[] = {
|
|
|
|
llvm::ConstantInt::get(llvm::Type::Int32Ty, idx0),
|
|
|
|
llvm::ConstantInt::get(llvm::Type::Int32Ty, idx1)
|
|
|
|
};
|
|
|
|
return llvm::ConstantExpr::getGetElementPtr(C, Idxs, 2);
|
|
|
|
}
|
|
|
|
|
2009-04-08 12:21:03 +08:00
|
|
|
/// hasObjCExceptionAttribute - Return true if this class or any super
|
|
|
|
/// class has the __objc_exception__ attribute.
|
|
|
|
static bool hasObjCExceptionAttribute(const ObjCInterfaceDecl *OID) {
|
2009-04-14 05:08:27 +08:00
|
|
|
if (OID->hasAttr<ObjCExceptionAttr>())
|
2009-04-08 12:21:03 +08:00
|
|
|
return true;
|
|
|
|
if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
|
|
|
|
return hasObjCExceptionAttribute(Super);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-08-12 08:12:39 +08:00
|
|
|
/* *** CGObjCMac Public Interface *** */
|
2008-08-11 10:45:11 +08:00
|
|
|
|
2009-01-22 06:04:16 +08:00
|
|
|
CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm),
|
|
|
|
ObjCTypes(cgm)
|
2008-08-12 08:12:39 +08:00
|
|
|
{
|
2009-01-22 06:04:16 +08:00
|
|
|
ObjCABI = 1;
|
2008-08-12 08:12:39 +08:00
|
|
|
EmitImageInfo();
|
2008-08-11 10:45:11 +08:00
|
|
|
}
|
|
|
|
|
2008-08-16 08:25:02 +08:00
|
|
|
/// GetClass - Return a reference to the class for the given interface
|
|
|
|
/// decl.
|
2008-11-01 09:53:16 +08:00
|
|
|
llvm::Value *CGObjCMac::GetClass(CGBuilderTy &Builder,
|
2008-08-21 12:36:09 +08:00
|
|
|
const ObjCInterfaceDecl *ID) {
|
|
|
|
return EmitClassRef(Builder, ID);
|
2008-08-11 10:45:11 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// GetSelector - Return the pointer to the unique'd string for this selector.
|
2008-11-01 09:53:16 +08:00
|
|
|
llvm::Value *CGObjCMac::GetSelector(CGBuilderTy &Builder, Selector Sel) {
|
2008-08-12 11:39:23 +08:00
|
|
|
return EmitSelector(Builder, Sel);
|
2008-08-11 10:45:11 +08:00
|
|
|
}
|
|
|
|
|
2008-08-12 08:12:39 +08:00
|
|
|
/// Generate a constant CFString object.
|
|
|
|
/*
|
|
|
|
struct __builtin_CFString {
|
|
|
|
const int *isa; // point to __CFConstantStringClassReference
|
|
|
|
int flags;
|
|
|
|
const char *str;
|
|
|
|
long length;
|
|
|
|
};
|
|
|
|
*/
|
|
|
|
|
2009-01-24 07:53:38 +08:00
|
|
|
llvm::Constant *CGObjCCommonMac::GenerateConstantString(
|
2009-04-01 00:53:37 +08:00
|
|
|
const ObjCStringLiteral *SL) {
|
2009-04-01 21:55:36 +08:00
|
|
|
return CGM.GetAddrOfConstantCFString(SL->getString());
|
2008-08-11 10:45:11 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Generates a message send where the super is the receiver. This is
|
|
|
|
/// a message send to self with special delivery semantics indicating
|
|
|
|
/// which class's method should be called.
|
2008-08-23 11:46:30 +08:00
|
|
|
CodeGen::RValue
|
|
|
|
CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
|
2008-08-30 13:35:15 +08:00
|
|
|
QualType ResultType,
|
|
|
|
Selector Sel,
|
2008-08-25 16:19:24 +08:00
|
|
|
const ObjCInterfaceDecl *Class,
|
2009-03-01 04:07:56 +08:00
|
|
|
bool isCategoryImpl,
|
2008-08-25 16:19:24 +08:00
|
|
|
llvm::Value *Receiver,
|
2008-08-30 11:02:31 +08:00
|
|
|
bool IsClassMessage,
|
2008-09-09 09:06:48 +08:00
|
|
|
const CodeGen::CallArgList &CallArgs) {
|
2008-08-23 12:28:29 +08:00
|
|
|
// Create and init a super structure; this is a (receiver, class)
|
|
|
|
// pair we will pass to objc_msgSendSuper.
|
|
|
|
llvm::Value *ObjCSuper =
|
|
|
|
CGF.Builder.CreateAlloca(ObjCTypes.SuperTy, 0, "objc_super");
|
|
|
|
llvm::Value *ReceiverAsObject =
|
|
|
|
CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
|
|
|
|
CGF.Builder.CreateStore(ReceiverAsObject,
|
|
|
|
CGF.Builder.CreateStructGEP(ObjCSuper, 0));
|
|
|
|
|
2008-08-25 16:19:24 +08:00
|
|
|
// If this is a class message the metaclass is passed as the target.
|
|
|
|
llvm::Value *Target;
|
|
|
|
if (IsClassMessage) {
|
2009-03-01 04:07:56 +08:00
|
|
|
if (isCategoryImpl) {
|
|
|
|
// Message sent to 'super' in a class method defined in a category
|
|
|
|
// implementation requires an odd treatment.
|
|
|
|
// If we are in a class method, we must retrieve the
|
|
|
|
// _metaclass_ for the current class, pointed at by
|
|
|
|
// the class's "isa" pointer. The following assumes that
|
|
|
|
// isa" is the first ivar in a class (which it must be).
|
|
|
|
Target = EmitClassRef(CGF.Builder, Class->getSuperClass());
|
|
|
|
Target = CGF.Builder.CreateStructGEP(Target, 0);
|
|
|
|
Target = CGF.Builder.CreateLoad(Target);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
llvm::Value *MetaClassPtr = EmitMetaClassRef(Class);
|
|
|
|
llvm::Value *SuperPtr = CGF.Builder.CreateStructGEP(MetaClassPtr, 1);
|
|
|
|
llvm::Value *Super = CGF.Builder.CreateLoad(SuperPtr);
|
|
|
|
Target = Super;
|
|
|
|
}
|
2008-08-25 16:19:24 +08:00
|
|
|
} else {
|
|
|
|
Target = EmitClassRef(CGF.Builder, Class->getSuperClass());
|
|
|
|
}
|
2008-08-30 11:02:31 +08:00
|
|
|
// FIXME: We shouldn't need to do this cast, rectify the ASTContext
|
|
|
|
// and ObjCTypes types.
|
|
|
|
const llvm::Type *ClassTy =
|
|
|
|
CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
|
2008-10-30 06:36:39 +08:00
|
|
|
Target = CGF.Builder.CreateBitCast(Target, ClassTy);
|
2008-08-25 16:19:24 +08:00
|
|
|
CGF.Builder.CreateStore(Target,
|
|
|
|
CGF.Builder.CreateStructGEP(ObjCSuper, 1));
|
|
|
|
|
2008-08-30 13:35:15 +08:00
|
|
|
return EmitMessageSend(CGF, ResultType, Sel,
|
2008-08-30 11:02:31 +08:00
|
|
|
ObjCSuper, ObjCTypes.SuperPtrCTy,
|
|
|
|
true, CallArgs);
|
2008-08-11 10:45:11 +08:00
|
|
|
}
|
2008-08-23 17:25:55 +08:00
|
|
|
|
2008-08-11 10:45:11 +08:00
|
|
|
/// Generate code for a message send expression.
|
2008-08-23 11:46:30 +08:00
|
|
|
CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
|
2008-08-30 13:35:15 +08:00
|
|
|
QualType ResultType,
|
|
|
|
Selector Sel,
|
2008-08-25 16:19:24 +08:00
|
|
|
llvm::Value *Receiver,
|
2008-08-30 11:02:31 +08:00
|
|
|
bool IsClassMessage,
|
|
|
|
const CallArgList &CallArgs) {
|
2008-08-23 17:25:55 +08:00
|
|
|
llvm::Value *Arg0 =
|
|
|
|
CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy, "tmp");
|
2008-08-30 13:35:15 +08:00
|
|
|
return EmitMessageSend(CGF, ResultType, Sel,
|
2008-08-30 11:02:31 +08:00
|
|
|
Arg0, CGF.getContext().getObjCIdType(),
|
|
|
|
false, CallArgs);
|
2008-08-23 17:25:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
CodeGen::RValue CGObjCMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF,
|
2008-08-30 13:35:15 +08:00
|
|
|
QualType ResultType,
|
|
|
|
Selector Sel,
|
2008-08-23 17:25:55 +08:00
|
|
|
llvm::Value *Arg0,
|
2008-08-30 11:02:31 +08:00
|
|
|
QualType Arg0Ty,
|
|
|
|
bool IsSuper,
|
|
|
|
const CallArgList &CallArgs) {
|
|
|
|
CallArgList ActualArgs;
|
2008-09-09 09:06:48 +08:00
|
|
|
ActualArgs.push_back(std::make_pair(RValue::get(Arg0), Arg0Ty));
|
|
|
|
ActualArgs.push_back(std::make_pair(RValue::get(EmitSelector(CGF.Builder,
|
|
|
|
Sel)),
|
2008-08-30 11:02:31 +08:00
|
|
|
CGF.getContext().getObjCSelType()));
|
|
|
|
ActualArgs.insert(ActualArgs.end(), CallArgs.begin(), CallArgs.end());
|
2008-08-16 06:20:32 +08:00
|
|
|
|
2009-02-03 07:23:47 +08:00
|
|
|
CodeGenTypes &Types = CGM.getTypes();
|
|
|
|
const CGFunctionInfo &FnInfo = Types.getFunctionInfo(ResultType, ActualArgs);
|
|
|
|
const llvm::FunctionType *FTy = Types.GetFunctionType(FnInfo, false);
|
2008-10-17 11:24:53 +08:00
|
|
|
|
|
|
|
llvm::Constant *Fn;
|
2009-02-03 06:03:45 +08:00
|
|
|
if (CGM.ReturnTypeUsesSret(FnInfo)) {
|
2008-10-17 11:24:53 +08:00
|
|
|
Fn = ObjCTypes.getSendStretFn(IsSuper);
|
|
|
|
} else if (ResultType->isFloatingType()) {
|
|
|
|
// FIXME: Sadly, this is wrong. This actually depends on the
|
|
|
|
// architecture. This happens to be right for x86-32 though.
|
|
|
|
Fn = ObjCTypes.getSendFpretFn(IsSuper);
|
|
|
|
} else {
|
|
|
|
Fn = ObjCTypes.getSendFn(IsSuper);
|
|
|
|
}
|
2008-09-10 15:00:50 +08:00
|
|
|
Fn = llvm::ConstantExpr::getBitCast(Fn, llvm::PointerType::getUnqual(FTy));
|
2009-02-03 06:03:45 +08:00
|
|
|
return CGF.EmitCall(FnInfo, Fn, ActualArgs);
|
2008-08-11 10:45:11 +08:00
|
|
|
}
|
|
|
|
|
2008-11-01 09:53:16 +08:00
|
|
|
llvm::Value *CGObjCMac::GenerateProtocolRef(CGBuilderTy &Builder,
|
2008-08-13 08:59:25 +08:00
|
|
|
const ObjCProtocolDecl *PD) {
|
2008-09-04 12:33:15 +08:00
|
|
|
// FIXME: I don't understand why gcc generates this, or where it is
|
|
|
|
// resolved. Investigate. Its also wasteful to look this up over and
|
|
|
|
// over.
|
|
|
|
LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
|
|
|
|
|
2008-08-13 11:21:16 +08:00
|
|
|
return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD),
|
|
|
|
ObjCTypes.ExternalProtocolPtrTy);
|
|
|
|
}
|
|
|
|
|
2009-01-30 03:24:30 +08:00
|
|
|
void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) {
|
2008-10-30 06:36:39 +08:00
|
|
|
// FIXME: We shouldn't need this, the protocol decl should contain
|
|
|
|
// enough information to tell us whether this was a declaration or a
|
|
|
|
// definition.
|
|
|
|
DefinedProtocols.insert(PD->getIdentifier());
|
|
|
|
|
|
|
|
// If we have generated a forward reference to this protocol, emit
|
|
|
|
// it now. Otherwise do nothing, the protocol objects are lazily
|
|
|
|
// emitted.
|
|
|
|
if (Protocols.count(PD->getIdentifier()))
|
|
|
|
GetOrEmitProtocol(PD);
|
|
|
|
}
|
|
|
|
|
2009-01-30 03:24:30 +08:00
|
|
|
llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
|
2008-10-30 06:36:39 +08:00
|
|
|
if (DefinedProtocols.count(PD->getIdentifier()))
|
|
|
|
return GetOrEmitProtocol(PD);
|
|
|
|
return GetOrEmitProtocolRef(PD);
|
|
|
|
}
|
|
|
|
|
2008-08-13 11:21:16 +08:00
|
|
|
/*
|
|
|
|
// APPLE LOCAL radar 4585769 - Objective-C 1.0 extensions
|
|
|
|
struct _objc_protocol {
|
|
|
|
struct _objc_protocol_extension *isa;
|
|
|
|
char *protocol_name;
|
|
|
|
struct _objc_protocol_list *protocol_list;
|
|
|
|
struct _objc__method_prototype_list *instance_methods;
|
|
|
|
struct _objc__method_prototype_list *class_methods
|
|
|
|
};
|
|
|
|
|
|
|
|
See EmitProtocolExtension().
|
|
|
|
*/
|
2008-10-30 06:36:39 +08:00
|
|
|
llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
|
|
|
|
llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
|
|
|
|
|
|
|
|
// Early exit if a defining object has already been generated.
|
|
|
|
if (Entry && Entry->hasInitializer())
|
|
|
|
return Entry;
|
|
|
|
|
2008-08-25 14:02:07 +08:00
|
|
|
// FIXME: I don't understand why gcc generates this, or where it is
|
|
|
|
// resolved. Investigate. Its also wasteful to look this up over and
|
|
|
|
// over.
|
|
|
|
LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
|
|
|
|
|
2008-11-24 11:54:41 +08:00
|
|
|
const char *ProtocolName = PD->getNameAsCString();
|
2008-08-27 10:31:56 +08:00
|
|
|
|
|
|
|
// Construct method lists.
|
|
|
|
std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
|
|
|
|
std::vector<llvm::Constant*> OptInstanceMethods, OptClassMethods;
|
2009-04-10 05:40:53 +08:00
|
|
|
for (ObjCProtocolDecl::instmeth_iterator
|
|
|
|
i = PD->instmeth_begin(CGM.getContext()),
|
|
|
|
e = PD->instmeth_end(CGM.getContext()); i != e; ++i) {
|
2008-08-27 10:31:56 +08:00
|
|
|
ObjCMethodDecl *MD = *i;
|
|
|
|
llvm::Constant *C = GetMethodDescriptionConstant(MD);
|
|
|
|
if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
|
|
|
|
OptInstanceMethods.push_back(C);
|
|
|
|
} else {
|
|
|
|
InstanceMethods.push_back(C);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-10 05:40:53 +08:00
|
|
|
for (ObjCProtocolDecl::classmeth_iterator
|
|
|
|
i = PD->classmeth_begin(CGM.getContext()),
|
|
|
|
e = PD->classmeth_end(CGM.getContext()); i != e; ++i) {
|
2008-08-27 10:31:56 +08:00
|
|
|
ObjCMethodDecl *MD = *i;
|
|
|
|
llvm::Constant *C = GetMethodDescriptionConstant(MD);
|
|
|
|
if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
|
|
|
|
OptClassMethods.push_back(C);
|
|
|
|
} else {
|
|
|
|
ClassMethods.push_back(C);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-13 11:21:16 +08:00
|
|
|
std::vector<llvm::Constant*> Values(5);
|
2008-08-27 10:31:56 +08:00
|
|
|
Values[0] = EmitProtocolExtension(PD, OptInstanceMethods, OptClassMethods);
|
2008-08-13 11:21:16 +08:00
|
|
|
Values[1] = GetClassName(PD->getIdentifier());
|
2008-08-22 05:57:41 +08:00
|
|
|
Values[2] =
|
2008-11-24 13:29:24 +08:00
|
|
|
EmitProtocolList("\01L_OBJC_PROTOCOL_REFS_" + PD->getNameAsString(),
|
2008-08-22 05:57:41 +08:00
|
|
|
PD->protocol_begin(),
|
|
|
|
PD->protocol_end());
|
2008-08-27 10:31:56 +08:00
|
|
|
Values[3] =
|
2008-11-24 13:29:24 +08:00
|
|
|
EmitMethodDescList("\01L_OBJC_PROTOCOL_INSTANCE_METHODS_"
|
|
|
|
+ PD->getNameAsString(),
|
2008-08-27 10:31:56 +08:00
|
|
|
"__OBJC,__cat_inst_meth,regular,no_dead_strip",
|
|
|
|
InstanceMethods);
|
|
|
|
Values[4] =
|
2008-11-24 13:29:24 +08:00
|
|
|
EmitMethodDescList("\01L_OBJC_PROTOCOL_CLASS_METHODS_"
|
|
|
|
+ PD->getNameAsString(),
|
2008-08-27 10:31:56 +08:00
|
|
|
"__OBJC,__cat_cls_meth,regular,no_dead_strip",
|
|
|
|
ClassMethods);
|
2008-08-13 11:21:16 +08:00
|
|
|
llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ProtocolTy,
|
|
|
|
Values);
|
|
|
|
|
|
|
|
if (Entry) {
|
2008-10-30 06:36:39 +08:00
|
|
|
// Already created, fix the linkage and update the initializer.
|
|
|
|
Entry->setLinkage(llvm::GlobalValue::InternalLinkage);
|
2008-08-13 11:21:16 +08:00
|
|
|
Entry->setInitializer(Init);
|
|
|
|
} else {
|
|
|
|
Entry =
|
|
|
|
new llvm::GlobalVariable(ObjCTypes.ProtocolTy, false,
|
|
|
|
llvm::GlobalValue::InternalLinkage,
|
|
|
|
Init,
|
|
|
|
std::string("\01L_OBJC_PROTOCOL_")+ProtocolName,
|
|
|
|
&CGM.getModule());
|
|
|
|
Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
|
2009-03-10 06:18:41 +08:00
|
|
|
Entry->setAlignment(4);
|
2008-08-13 11:21:16 +08:00
|
|
|
UsedGlobals.push_back(Entry);
|
|
|
|
// FIXME: Is this necessary? Why only for protocol?
|
|
|
|
Entry->setAlignment(4);
|
|
|
|
}
|
2008-10-30 06:36:39 +08:00
|
|
|
|
|
|
|
return Entry;
|
2008-08-13 11:21:16 +08:00
|
|
|
}
|
|
|
|
|
2008-10-30 06:36:39 +08:00
|
|
|
llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) {
|
2008-08-13 11:21:16 +08:00
|
|
|
llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
|
|
|
|
|
|
|
|
if (!Entry) {
|
2008-10-30 06:36:39 +08:00
|
|
|
// We use the initializer as a marker of whether this is a forward
|
|
|
|
// reference or not. At module finalization we add the empty
|
|
|
|
// contents for protocols which were referenced but never defined.
|
2008-08-13 11:21:16 +08:00
|
|
|
Entry =
|
|
|
|
new llvm::GlobalVariable(ObjCTypes.ProtocolTy, false,
|
2008-10-30 06:36:39 +08:00
|
|
|
llvm::GlobalValue::ExternalLinkage,
|
|
|
|
0,
|
2008-11-24 13:29:24 +08:00
|
|
|
"\01L_OBJC_PROTOCOL_" + PD->getNameAsString(),
|
2008-08-13 11:21:16 +08:00
|
|
|
&CGM.getModule());
|
|
|
|
Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
|
2009-03-10 06:18:41 +08:00
|
|
|
Entry->setAlignment(4);
|
2008-08-13 11:21:16 +08:00
|
|
|
UsedGlobals.push_back(Entry);
|
|
|
|
// FIXME: Is this necessary? Why only for protocol?
|
|
|
|
Entry->setAlignment(4);
|
|
|
|
}
|
|
|
|
|
|
|
|
return Entry;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
struct _objc_protocol_extension {
|
|
|
|
uint32_t size;
|
|
|
|
struct objc_method_description_list *optional_instance_methods;
|
|
|
|
struct objc_method_description_list *optional_class_methods;
|
|
|
|
struct objc_property_list *instance_properties;
|
|
|
|
};
|
|
|
|
*/
|
2008-08-27 10:31:56 +08:00
|
|
|
llvm::Constant *
|
|
|
|
CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
|
|
|
|
const ConstantVector &OptInstanceMethods,
|
|
|
|
const ConstantVector &OptClassMethods) {
|
2008-08-13 11:21:16 +08:00
|
|
|
uint64_t Size =
|
2009-01-13 05:08:18 +08:00
|
|
|
CGM.getTargetData().getTypePaddedSize(ObjCTypes.ProtocolExtensionTy);
|
2008-08-13 11:21:16 +08:00
|
|
|
std::vector<llvm::Constant*> Values(4);
|
|
|
|
Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
|
2008-08-27 10:31:56 +08:00
|
|
|
Values[1] =
|
2008-11-24 13:29:24 +08:00
|
|
|
EmitMethodDescList("\01L_OBJC_PROTOCOL_INSTANCE_METHODS_OPT_"
|
|
|
|
+ PD->getNameAsString(),
|
2008-08-27 10:31:56 +08:00
|
|
|
"__OBJC,__cat_inst_meth,regular,no_dead_strip",
|
|
|
|
OptInstanceMethods);
|
|
|
|
Values[2] =
|
2008-11-24 13:29:24 +08:00
|
|
|
EmitMethodDescList("\01L_OBJC_PROTOCOL_CLASS_METHODS_OPT_"
|
|
|
|
+ PD->getNameAsString(),
|
2008-08-27 10:31:56 +08:00
|
|
|
"__OBJC,__cat_cls_meth,regular,no_dead_strip",
|
|
|
|
OptClassMethods);
|
2008-11-24 13:29:24 +08:00
|
|
|
Values[3] = EmitPropertyList("\01L_OBJC_$_PROP_PROTO_LIST_" +
|
|
|
|
PD->getNameAsString(),
|
2009-01-29 06:18:42 +08:00
|
|
|
0, PD, ObjCTypes);
|
2008-08-13 11:21:16 +08:00
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
// Return null if no extension bits are used.
|
2008-08-13 11:21:16 +08:00
|
|
|
if (Values[1]->isNullValue() && Values[2]->isNullValue() &&
|
|
|
|
Values[3]->isNullValue())
|
|
|
|
return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
|
|
|
|
|
|
|
|
llvm::Constant *Init =
|
|
|
|
llvm::ConstantStruct::get(ObjCTypes.ProtocolExtensionTy, Values);
|
|
|
|
|
2009-03-10 05:49:58 +08:00
|
|
|
// No special section, but goes in llvm.used
|
|
|
|
return CreateMetadataVar("\01L_OBJC_PROTOCOLEXT_" + PD->getNameAsString(),
|
|
|
|
Init,
|
|
|
|
0, 0, true);
|
2008-08-13 11:21:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
struct objc_protocol_list {
|
|
|
|
struct objc_protocol_list *next;
|
|
|
|
long count;
|
|
|
|
Protocol *list[];
|
|
|
|
};
|
|
|
|
*/
|
2008-08-22 05:57:41 +08:00
|
|
|
llvm::Constant *
|
|
|
|
CGObjCMac::EmitProtocolList(const std::string &Name,
|
|
|
|
ObjCProtocolDecl::protocol_iterator begin,
|
|
|
|
ObjCProtocolDecl::protocol_iterator end) {
|
2008-08-13 11:21:16 +08:00
|
|
|
std::vector<llvm::Constant*> ProtocolRefs;
|
|
|
|
|
2008-08-22 05:57:41 +08:00
|
|
|
for (; begin != end; ++begin)
|
|
|
|
ProtocolRefs.push_back(GetProtocolRef(*begin));
|
2008-08-13 11:21:16 +08:00
|
|
|
|
|
|
|
// Just return null for empty protocol lists
|
|
|
|
if (ProtocolRefs.empty())
|
|
|
|
return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
|
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
// This list is null terminated.
|
2008-08-13 11:21:16 +08:00
|
|
|
ProtocolRefs.push_back(llvm::Constant::getNullValue(ObjCTypes.ProtocolPtrTy));
|
|
|
|
|
|
|
|
std::vector<llvm::Constant*> Values(3);
|
2008-08-21 12:36:09 +08:00
|
|
|
// This field is only used by the runtime.
|
2008-08-13 11:21:16 +08:00
|
|
|
Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
|
|
|
|
Values[1] = llvm::ConstantInt::get(ObjCTypes.LongTy, ProtocolRefs.size() - 1);
|
|
|
|
Values[2] =
|
|
|
|
llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.ProtocolPtrTy,
|
|
|
|
ProtocolRefs.size()),
|
|
|
|
ProtocolRefs);
|
|
|
|
|
|
|
|
llvm::Constant *Init = llvm::ConstantStruct::get(Values);
|
|
|
|
llvm::GlobalVariable *GV =
|
2009-03-10 05:49:58 +08:00
|
|
|
CreateMetadataVar(Name, Init, "__OBJC,__cat_cls_meth,regular,no_dead_strip",
|
2009-03-10 06:18:41 +08:00
|
|
|
4, false);
|
2008-08-13 11:21:16 +08:00
|
|
|
return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
|
2008-08-11 10:45:11 +08:00
|
|
|
}
|
|
|
|
|
2008-08-23 08:19:03 +08:00
|
|
|
/*
|
|
|
|
struct _objc_property {
|
|
|
|
const char * const name;
|
|
|
|
const char * const attributes;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct _objc_property_list {
|
|
|
|
uint32_t entsize; // sizeof (struct _objc_property)
|
|
|
|
uint32_t prop_count;
|
|
|
|
struct _objc_property[prop_count];
|
|
|
|
};
|
|
|
|
*/
|
2009-01-29 06:18:42 +08:00
|
|
|
llvm::Constant *CGObjCCommonMac::EmitPropertyList(const std::string &Name,
|
|
|
|
const Decl *Container,
|
|
|
|
const ObjCContainerDecl *OCD,
|
|
|
|
const ObjCCommonTypesHelper &ObjCTypes) {
|
2008-08-23 08:19:03 +08:00
|
|
|
std::vector<llvm::Constant*> Properties, Prop(2);
|
2009-04-10 05:40:53 +08:00
|
|
|
for (ObjCContainerDecl::prop_iterator I = OCD->prop_begin(CGM.getContext()),
|
|
|
|
E = OCD->prop_end(CGM.getContext()); I != E; ++I) {
|
2009-01-11 20:47:58 +08:00
|
|
|
const ObjCPropertyDecl *PD = *I;
|
2008-08-23 08:19:03 +08:00
|
|
|
Prop[0] = GetPropertyName(PD->getIdentifier());
|
2008-08-28 12:38:10 +08:00
|
|
|
Prop[1] = GetPropertyTypeString(PD, Container);
|
2008-08-23 08:19:03 +08:00
|
|
|
Properties.push_back(llvm::ConstantStruct::get(ObjCTypes.PropertyTy,
|
|
|
|
Prop));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return null for empty list.
|
|
|
|
if (Properties.empty())
|
|
|
|
return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
|
|
|
|
|
|
|
|
unsigned PropertySize =
|
2009-01-13 05:08:18 +08:00
|
|
|
CGM.getTargetData().getTypePaddedSize(ObjCTypes.PropertyTy);
|
2008-08-23 08:19:03 +08:00
|
|
|
std::vector<llvm::Constant*> Values(3);
|
|
|
|
Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, PropertySize);
|
|
|
|
Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Properties.size());
|
|
|
|
llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.PropertyTy,
|
|
|
|
Properties.size());
|
|
|
|
Values[2] = llvm::ConstantArray::get(AT, Properties);
|
|
|
|
llvm::Constant *Init = llvm::ConstantStruct::get(Values);
|
|
|
|
|
|
|
|
// No special section on property lists?
|
2009-03-10 05:49:58 +08:00
|
|
|
llvm::GlobalVariable *GV =
|
|
|
|
CreateMetadataVar(Name, Init, (ObjCABI == 2) ? "__DATA, __objc_const" : 0,
|
|
|
|
0, true);
|
|
|
|
return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy);
|
2008-08-23 08:19:03 +08:00
|
|
|
}
|
|
|
|
|
2008-08-13 11:21:16 +08:00
|
|
|
/*
|
|
|
|
struct objc_method_description_list {
|
|
|
|
int count;
|
|
|
|
struct objc_method_description list[];
|
|
|
|
};
|
|
|
|
*/
|
2008-08-27 10:31:56 +08:00
|
|
|
llvm::Constant *
|
|
|
|
CGObjCMac::GetMethodDescriptionConstant(const ObjCMethodDecl *MD) {
|
|
|
|
std::vector<llvm::Constant*> Desc(2);
|
|
|
|
Desc[0] = llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
|
|
|
|
ObjCTypes.SelectorPtrTy);
|
|
|
|
Desc[1] = GetMethodVarType(MD);
|
|
|
|
return llvm::ConstantStruct::get(ObjCTypes.MethodDescriptionTy,
|
|
|
|
Desc);
|
|
|
|
}
|
2008-08-13 11:21:16 +08:00
|
|
|
|
2008-08-27 10:31:56 +08:00
|
|
|
llvm::Constant *CGObjCMac::EmitMethodDescList(const std::string &Name,
|
|
|
|
const char *Section,
|
|
|
|
const ConstantVector &Methods) {
|
2008-08-13 11:21:16 +08:00
|
|
|
// Return null for empty list.
|
|
|
|
if (Methods.empty())
|
|
|
|
return llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy);
|
|
|
|
|
|
|
|
std::vector<llvm::Constant*> Values(2);
|
|
|
|
Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
|
|
|
|
llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodDescriptionTy,
|
|
|
|
Methods.size());
|
|
|
|
Values[1] = llvm::ConstantArray::get(AT, Methods);
|
|
|
|
llvm::Constant *Init = llvm::ConstantStruct::get(Values);
|
|
|
|
|
2009-03-10 05:49:58 +08:00
|
|
|
llvm::GlobalVariable *GV = CreateMetadataVar(Name, Init, Section, 0, true);
|
2008-08-13 11:21:16 +08:00
|
|
|
return llvm::ConstantExpr::getBitCast(GV,
|
|
|
|
ObjCTypes.MethodDescriptionListPtrTy);
|
2008-08-11 10:45:11 +08:00
|
|
|
}
|
|
|
|
|
2008-08-23 04:34:54 +08:00
|
|
|
/*
|
|
|
|
struct _objc_category {
|
|
|
|
char *category_name;
|
|
|
|
char *class_name;
|
|
|
|
struct _objc_method_list *instance_methods;
|
|
|
|
struct _objc_method_list *class_methods;
|
|
|
|
struct _objc_protocol_list *protocols;
|
|
|
|
uint32_t size; // <rdar://4585769>
|
|
|
|
struct _objc_property_list *instance_properties;
|
|
|
|
};
|
|
|
|
*/
|
2008-08-16 06:20:32 +08:00
|
|
|
void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
|
2009-01-13 05:08:18 +08:00
|
|
|
unsigned Size = CGM.getTargetData().getTypePaddedSize(ObjCTypes.CategoryTy);
|
2008-08-23 04:34:54 +08:00
|
|
|
|
2008-08-27 07:03:11 +08:00
|
|
|
// FIXME: This is poor design, the OCD should have a pointer to the
|
|
|
|
// category decl. Additionally, note that Category can be null for
|
|
|
|
// the @implementation w/o an @interface case. Sema should just
|
|
|
|
// create one for us as it does for @implementation so everyone else
|
|
|
|
// can live life under a clear blue sky.
|
2008-08-23 04:34:54 +08:00
|
|
|
const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
|
2008-08-27 07:03:11 +08:00
|
|
|
const ObjCCategoryDecl *Category =
|
|
|
|
Interface->FindCategoryDeclaration(OCD->getIdentifier());
|
2008-11-24 13:29:24 +08:00
|
|
|
std::string ExtName(Interface->getNameAsString() + "_" +
|
|
|
|
OCD->getNameAsString());
|
2008-08-23 04:34:54 +08:00
|
|
|
|
2008-08-27 05:51:14 +08:00
|
|
|
std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
|
|
|
|
for (ObjCCategoryImplDecl::instmeth_iterator i = OCD->instmeth_begin(),
|
|
|
|
e = OCD->instmeth_end(); i != e; ++i) {
|
|
|
|
// Instance methods should always be defined.
|
|
|
|
InstanceMethods.push_back(GetMethodConstant(*i));
|
|
|
|
}
|
|
|
|
for (ObjCCategoryImplDecl::classmeth_iterator i = OCD->classmeth_begin(),
|
|
|
|
e = OCD->classmeth_end(); i != e; ++i) {
|
|
|
|
// Class methods should always be defined.
|
|
|
|
ClassMethods.push_back(GetMethodConstant(*i));
|
|
|
|
}
|
|
|
|
|
2008-08-23 04:34:54 +08:00
|
|
|
std::vector<llvm::Constant*> Values(7);
|
|
|
|
Values[0] = GetClassName(OCD->getIdentifier());
|
|
|
|
Values[1] = GetClassName(Interface->getIdentifier());
|
2008-08-23 08:19:03 +08:00
|
|
|
Values[2] =
|
|
|
|
EmitMethodList(std::string("\01L_OBJC_CATEGORY_INSTANCE_METHODS_") +
|
|
|
|
ExtName,
|
|
|
|
"__OBJC,__cat_inst_meth,regular,no_dead_strip",
|
2008-08-27 05:51:14 +08:00
|
|
|
InstanceMethods);
|
2008-08-23 08:19:03 +08:00
|
|
|
Values[3] =
|
|
|
|
EmitMethodList(std::string("\01L_OBJC_CATEGORY_CLASS_METHODS_") + ExtName,
|
|
|
|
"__OBJC,__cat_class_meth,regular,no_dead_strip",
|
2008-08-27 05:51:14 +08:00
|
|
|
ClassMethods);
|
2008-08-27 10:31:56 +08:00
|
|
|
if (Category) {
|
|
|
|
Values[4] =
|
|
|
|
EmitProtocolList(std::string("\01L_OBJC_CATEGORY_PROTOCOLS_") + ExtName,
|
|
|
|
Category->protocol_begin(),
|
|
|
|
Category->protocol_end());
|
|
|
|
} else {
|
|
|
|
Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
|
|
|
|
}
|
2008-08-23 04:34:54 +08:00
|
|
|
Values[5] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
|
2008-08-27 07:03:11 +08:00
|
|
|
|
|
|
|
// If there is no category @interface then there can be no properties.
|
|
|
|
if (Category) {
|
|
|
|
Values[6] = EmitPropertyList(std::string("\01L_OBJC_$_PROP_LIST_") + ExtName,
|
2009-01-29 06:18:42 +08:00
|
|
|
OCD, Category, ObjCTypes);
|
2008-08-27 07:03:11 +08:00
|
|
|
} else {
|
|
|
|
Values[6] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
|
|
|
|
}
|
2008-08-23 04:34:54 +08:00
|
|
|
|
|
|
|
llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.CategoryTy,
|
|
|
|
Values);
|
|
|
|
|
|
|
|
llvm::GlobalVariable *GV =
|
2009-03-10 05:49:58 +08:00
|
|
|
CreateMetadataVar(std::string("\01L_OBJC_CATEGORY_")+ExtName, Init,
|
|
|
|
"__OBJC,__category,regular,no_dead_strip",
|
2009-03-10 06:18:41 +08:00
|
|
|
4, true);
|
2008-08-23 04:34:54 +08:00
|
|
|
DefinedCategories.push_back(GV);
|
2008-08-11 10:45:11 +08:00
|
|
|
}
|
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
// FIXME: Get from somewhere?
|
|
|
|
enum ClassFlags {
|
|
|
|
eClassFlags_Factory = 0x00001,
|
|
|
|
eClassFlags_Meta = 0x00002,
|
|
|
|
// <rdr://5142207>
|
|
|
|
eClassFlags_HasCXXStructors = 0x02000,
|
|
|
|
eClassFlags_Hidden = 0x20000,
|
|
|
|
eClassFlags_ABI2_Hidden = 0x00010,
|
|
|
|
eClassFlags_ABI2_HasCXXStructors = 0x00004 // <rdr://4923634>
|
|
|
|
};
|
|
|
|
|
2009-04-08 04:26:30 +08:00
|
|
|
bool CGObjCCommonMac::IsClassHidden(const ObjCInterfaceDecl *ID) {
|
2008-08-21 12:36:09 +08:00
|
|
|
if (const VisibilityAttr *attr = ID->getAttr<VisibilityAttr>()) {
|
|
|
|
switch (attr->getVisibility()) {
|
|
|
|
default:
|
|
|
|
assert(0 && "Unknown visibility");
|
|
|
|
return false;
|
|
|
|
case VisibilityAttr::DefaultVisibility:
|
|
|
|
case VisibilityAttr::ProtectedVisibility: // FIXME: What do we do here?
|
|
|
|
return false;
|
|
|
|
case VisibilityAttr::HiddenVisibility:
|
|
|
|
return true;
|
|
|
|
}
|
2009-04-08 04:26:30 +08:00
|
|
|
} else
|
|
|
|
return (CGM.getLangOptions().getVisibilityMode() ==
|
|
|
|
LangOptions::HiddenVisibility);
|
2008-08-21 12:36:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
struct _objc_class {
|
|
|
|
Class isa;
|
|
|
|
Class super_class;
|
|
|
|
const char *name;
|
|
|
|
long version;
|
|
|
|
long info;
|
|
|
|
long instance_size;
|
|
|
|
struct _objc_ivar_list *ivars;
|
|
|
|
struct _objc_method_list *methods;
|
|
|
|
struct _objc_cache *cache;
|
|
|
|
struct _objc_protocol_list *protocols;
|
|
|
|
// Objective-C 1.0 extensions (<rdr://4585769>)
|
|
|
|
const char *ivar_layout;
|
|
|
|
struct _objc_class_ext *ext;
|
|
|
|
};
|
|
|
|
|
|
|
|
See EmitClassExtension();
|
|
|
|
*/
|
|
|
|
void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
|
2008-08-25 14:02:07 +08:00
|
|
|
DefinedSymbols.insert(ID->getIdentifier());
|
|
|
|
|
2008-11-24 11:54:41 +08:00
|
|
|
std::string ClassName = ID->getNameAsString();
|
2008-08-21 12:36:09 +08:00
|
|
|
// FIXME: Gross
|
|
|
|
ObjCInterfaceDecl *Interface =
|
|
|
|
const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
|
2008-08-22 05:57:41 +08:00
|
|
|
llvm::Constant *Protocols =
|
2008-11-24 13:29:24 +08:00
|
|
|
EmitProtocolList("\01L_OBJC_CLASS_PROTOCOLS_" + ID->getNameAsString(),
|
2008-08-22 05:57:41 +08:00
|
|
|
Interface->protocol_begin(),
|
|
|
|
Interface->protocol_end());
|
2008-08-21 12:36:09 +08:00
|
|
|
const llvm::Type *InterfaceTy =
|
2009-04-01 14:23:52 +08:00
|
|
|
CGM.getTypes().ConvertType(CGM.getContext().getObjCInterfaceType(Interface));
|
2008-08-21 12:36:09 +08:00
|
|
|
unsigned Flags = eClassFlags_Factory;
|
2009-01-13 05:08:18 +08:00
|
|
|
unsigned Size = CGM.getTargetData().getTypePaddedSize(InterfaceTy);
|
2008-08-21 12:36:09 +08:00
|
|
|
|
|
|
|
// FIXME: Set CXX-structors flag.
|
|
|
|
if (IsClassHidden(ID->getClassInterface()))
|
|
|
|
Flags |= eClassFlags_Hidden;
|
|
|
|
|
2008-08-27 05:51:14 +08:00
|
|
|
std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
|
|
|
|
for (ObjCImplementationDecl::instmeth_iterator i = ID->instmeth_begin(),
|
|
|
|
e = ID->instmeth_end(); i != e; ++i) {
|
|
|
|
// Instance methods should always be defined.
|
|
|
|
InstanceMethods.push_back(GetMethodConstant(*i));
|
|
|
|
}
|
|
|
|
for (ObjCImplementationDecl::classmeth_iterator i = ID->classmeth_begin(),
|
|
|
|
e = ID->classmeth_end(); i != e; ++i) {
|
|
|
|
// Class methods should always be defined.
|
|
|
|
ClassMethods.push_back(GetMethodConstant(*i));
|
|
|
|
}
|
|
|
|
|
|
|
|
for (ObjCImplementationDecl::propimpl_iterator i = ID->propimpl_begin(),
|
|
|
|
e = ID->propimpl_end(); i != e; ++i) {
|
|
|
|
ObjCPropertyImplDecl *PID = *i;
|
|
|
|
|
|
|
|
if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
|
|
|
|
ObjCPropertyDecl *PD = PID->getPropertyDecl();
|
|
|
|
|
|
|
|
if (ObjCMethodDecl *MD = PD->getGetterMethodDecl())
|
|
|
|
if (llvm::Constant *C = GetMethodConstant(MD))
|
|
|
|
InstanceMethods.push_back(C);
|
|
|
|
if (ObjCMethodDecl *MD = PD->getSetterMethodDecl())
|
|
|
|
if (llvm::Constant *C = GetMethodConstant(MD))
|
|
|
|
InstanceMethods.push_back(C);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
std::vector<llvm::Constant*> Values(12);
|
2008-08-27 05:51:14 +08:00
|
|
|
Values[ 0] = EmitMetaClass(ID, Protocols, InterfaceTy, ClassMethods);
|
2008-08-21 12:36:09 +08:00
|
|
|
if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
|
2008-08-25 14:02:07 +08:00
|
|
|
// Record a reference to the super class.
|
|
|
|
LazySymbols.insert(Super->getIdentifier());
|
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
Values[ 1] =
|
|
|
|
llvm::ConstantExpr::getBitCast(GetClassName(Super->getIdentifier()),
|
|
|
|
ObjCTypes.ClassPtrTy);
|
|
|
|
} else {
|
|
|
|
Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy);
|
|
|
|
}
|
|
|
|
Values[ 2] = GetClassName(ID->getIdentifier());
|
|
|
|
// Version is always 0.
|
|
|
|
Values[ 3] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
|
|
|
|
Values[ 4] = llvm::ConstantInt::get(ObjCTypes.LongTy, Flags);
|
|
|
|
Values[ 5] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size);
|
2009-01-29 03:12:34 +08:00
|
|
|
Values[ 6] = EmitIvarList(ID, false);
|
2008-08-23 08:19:03 +08:00
|
|
|
Values[ 7] =
|
2008-11-24 13:29:24 +08:00
|
|
|
EmitMethodList("\01L_OBJC_INSTANCE_METHODS_" + ID->getNameAsString(),
|
2008-08-23 08:19:03 +08:00
|
|
|
"__OBJC,__inst_meth,regular,no_dead_strip",
|
2008-08-27 05:51:14 +08:00
|
|
|
InstanceMethods);
|
2008-08-21 12:36:09 +08:00
|
|
|
// cache is always NULL.
|
|
|
|
Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy);
|
|
|
|
Values[ 9] = Protocols;
|
2008-08-23 04:34:54 +08:00
|
|
|
// FIXME: Set ivar_layout
|
2009-03-26 06:36:49 +08:00
|
|
|
// Values[10] = BuildIvarLayout(ID, true);
|
|
|
|
Values[10] = GetIvarLayoutName(0, ObjCTypes);
|
2008-08-21 12:36:09 +08:00
|
|
|
Values[11] = EmitClassExtension(ID);
|
|
|
|
llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy,
|
|
|
|
Values);
|
|
|
|
|
|
|
|
llvm::GlobalVariable *GV =
|
2009-03-10 05:49:58 +08:00
|
|
|
CreateMetadataVar(std::string("\01L_OBJC_CLASS_")+ClassName, Init,
|
|
|
|
"__OBJC,__class,regular,no_dead_strip",
|
2009-03-10 06:18:41 +08:00
|
|
|
4, true);
|
2008-08-21 12:36:09 +08:00
|
|
|
DefinedClasses.push_back(GV);
|
|
|
|
}
|
|
|
|
|
|
|
|
llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
|
|
|
|
llvm::Constant *Protocols,
|
2008-08-27 05:51:14 +08:00
|
|
|
const llvm::Type *InterfaceTy,
|
2008-08-27 10:31:56 +08:00
|
|
|
const ConstantVector &Methods) {
|
2008-08-21 12:36:09 +08:00
|
|
|
unsigned Flags = eClassFlags_Meta;
|
2009-01-13 05:08:18 +08:00
|
|
|
unsigned Size = CGM.getTargetData().getTypePaddedSize(ObjCTypes.ClassTy);
|
2008-08-21 12:36:09 +08:00
|
|
|
|
|
|
|
if (IsClassHidden(ID->getClassInterface()))
|
|
|
|
Flags |= eClassFlags_Hidden;
|
|
|
|
|
|
|
|
std::vector<llvm::Constant*> Values(12);
|
|
|
|
// The isa for the metaclass is the root of the hierarchy.
|
|
|
|
const ObjCInterfaceDecl *Root = ID->getClassInterface();
|
|
|
|
while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
|
|
|
|
Root = Super;
|
|
|
|
Values[ 0] =
|
|
|
|
llvm::ConstantExpr::getBitCast(GetClassName(Root->getIdentifier()),
|
|
|
|
ObjCTypes.ClassPtrTy);
|
2008-08-23 04:34:54 +08:00
|
|
|
// The super class for the metaclass is emitted as the name of the
|
|
|
|
// super class. The runtime fixes this up to point to the
|
|
|
|
// *metaclass* for the super class.
|
2008-08-21 12:36:09 +08:00
|
|
|
if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
|
|
|
|
Values[ 1] =
|
|
|
|
llvm::ConstantExpr::getBitCast(GetClassName(Super->getIdentifier()),
|
|
|
|
ObjCTypes.ClassPtrTy);
|
|
|
|
} else {
|
|
|
|
Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy);
|
|
|
|
}
|
|
|
|
Values[ 2] = GetClassName(ID->getIdentifier());
|
|
|
|
// Version is always 0.
|
|
|
|
Values[ 3] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
|
|
|
|
Values[ 4] = llvm::ConstantInt::get(ObjCTypes.LongTy, Flags);
|
|
|
|
Values[ 5] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size);
|
2009-01-29 03:12:34 +08:00
|
|
|
Values[ 6] = EmitIvarList(ID, true);
|
2008-08-23 08:19:03 +08:00
|
|
|
Values[ 7] =
|
2008-11-24 13:29:24 +08:00
|
|
|
EmitMethodList("\01L_OBJC_CLASS_METHODS_" + ID->getNameAsString(),
|
2008-08-23 08:19:03 +08:00
|
|
|
"__OBJC,__inst_meth,regular,no_dead_strip",
|
2008-08-27 05:51:14 +08:00
|
|
|
Methods);
|
2008-08-21 12:36:09 +08:00
|
|
|
// cache is always NULL.
|
|
|
|
Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy);
|
|
|
|
Values[ 9] = Protocols;
|
|
|
|
// ivar_layout for metaclass is always NULL.
|
|
|
|
Values[10] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
|
|
|
|
// The class extension is always unused for metaclasses.
|
|
|
|
Values[11] = llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
|
|
|
|
llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy,
|
|
|
|
Values);
|
|
|
|
|
2008-08-25 16:19:24 +08:00
|
|
|
std::string Name("\01L_OBJC_METACLASS_");
|
2008-11-24 11:54:41 +08:00
|
|
|
Name += ID->getNameAsCString();
|
2008-08-25 16:19:24 +08:00
|
|
|
|
|
|
|
// Check for a forward reference.
|
|
|
|
llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
|
|
|
|
if (GV) {
|
|
|
|
assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
|
|
|
|
"Forward metaclass reference has incorrect type.");
|
|
|
|
GV->setLinkage(llvm::GlobalValue::InternalLinkage);
|
|
|
|
GV->setInitializer(Init);
|
|
|
|
} else {
|
|
|
|
GV = new llvm::GlobalVariable(ObjCTypes.ClassTy, false,
|
|
|
|
llvm::GlobalValue::InternalLinkage,
|
|
|
|
Init, Name,
|
|
|
|
&CGM.getModule());
|
|
|
|
}
|
2008-08-21 12:36:09 +08:00
|
|
|
GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
|
2009-03-10 06:18:41 +08:00
|
|
|
GV->setAlignment(4);
|
2008-08-21 12:36:09 +08:00
|
|
|
UsedGlobals.push_back(GV);
|
|
|
|
|
|
|
|
return GV;
|
|
|
|
}
|
|
|
|
|
2008-08-25 16:19:24 +08:00
|
|
|
llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
|
2008-11-24 13:29:24 +08:00
|
|
|
std::string Name = "\01L_OBJC_METACLASS_" + ID->getNameAsString();
|
2008-08-25 16:19:24 +08:00
|
|
|
|
|
|
|
// FIXME: Should we look these up somewhere other than the
|
|
|
|
// module. Its a bit silly since we only generate these while
|
|
|
|
// processing an implementation, so exactly one pointer would work
|
|
|
|
// if know when we entered/exitted an implementation block.
|
|
|
|
|
|
|
|
// Check for an existing forward reference.
|
2009-01-08 04:11:22 +08:00
|
|
|
// Previously, metaclass with internal linkage may have been defined.
|
|
|
|
// pass 'true' as 2nd argument so it is returned.
|
|
|
|
if (llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true)) {
|
2008-08-25 16:19:24 +08:00
|
|
|
assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
|
|
|
|
"Forward metaclass reference has incorrect type.");
|
|
|
|
return GV;
|
|
|
|
} else {
|
|
|
|
// Generate as an external reference to keep a consistent
|
|
|
|
// module. This will be patched up when we emit the metaclass.
|
|
|
|
return new llvm::GlobalVariable(ObjCTypes.ClassTy, false,
|
|
|
|
llvm::GlobalValue::ExternalLinkage,
|
|
|
|
0,
|
|
|
|
Name,
|
|
|
|
&CGM.getModule());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
/*
|
|
|
|
struct objc_class_ext {
|
|
|
|
uint32_t size;
|
|
|
|
const char *weak_ivar_layout;
|
|
|
|
struct _objc_property_list *properties;
|
|
|
|
};
|
|
|
|
*/
|
|
|
|
llvm::Constant *
|
|
|
|
CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID) {
|
|
|
|
uint64_t Size =
|
2009-01-13 05:08:18 +08:00
|
|
|
CGM.getTargetData().getTypePaddedSize(ObjCTypes.ClassExtensionTy);
|
2008-08-21 12:36:09 +08:00
|
|
|
|
|
|
|
std::vector<llvm::Constant*> Values(3);
|
|
|
|
Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
|
2008-08-23 04:34:54 +08:00
|
|
|
// FIXME: Output weak_ivar_layout string.
|
2009-03-26 06:36:49 +08:00
|
|
|
// Values[1] = BuildIvarLayout(ID, false);
|
2009-03-06 03:17:31 +08:00
|
|
|
Values[1] = GetIvarLayoutName(0, ObjCTypes);
|
2008-11-24 13:29:24 +08:00
|
|
|
Values[2] = EmitPropertyList("\01L_OBJC_$_PROP_LIST_" + ID->getNameAsString(),
|
2009-01-29 06:18:42 +08:00
|
|
|
ID, ID->getClassInterface(), ObjCTypes);
|
2008-08-21 12:36:09 +08:00
|
|
|
|
|
|
|
// Return null if no extension bits are used.
|
|
|
|
if (Values[1]->isNullValue() && Values[2]->isNullValue())
|
|
|
|
return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
|
|
|
|
|
|
|
|
llvm::Constant *Init =
|
|
|
|
llvm::ConstantStruct::get(ObjCTypes.ClassExtensionTy, Values);
|
2009-03-10 05:49:58 +08:00
|
|
|
return CreateMetadataVar("\01L_OBJC_CLASSEXT_" + ID->getNameAsString(),
|
|
|
|
Init, 0, 0, true);
|
2008-08-21 12:36:09 +08:00
|
|
|
}
|
|
|
|
|
2009-01-18 03:36:33 +08:00
|
|
|
/// countInheritedIvars - count number of ivars in class and its super class(s)
|
|
|
|
///
|
2009-04-10 05:40:53 +08:00
|
|
|
static int countInheritedIvars(const ObjCInterfaceDecl *OI,
|
|
|
|
ASTContext &Context) {
|
2009-01-18 03:36:33 +08:00
|
|
|
int count = 0;
|
|
|
|
if (!OI)
|
|
|
|
return 0;
|
|
|
|
const ObjCInterfaceDecl *SuperClass = OI->getSuperClass();
|
|
|
|
if (SuperClass)
|
2009-04-10 05:40:53 +08:00
|
|
|
count += countInheritedIvars(SuperClass, Context);
|
2009-01-18 03:36:33 +08:00
|
|
|
for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(),
|
|
|
|
E = OI->ivar_end(); I != E; ++I)
|
|
|
|
++count;
|
2009-04-01 02:11:23 +08:00
|
|
|
// look into properties.
|
2009-04-10 05:40:53 +08:00
|
|
|
for (ObjCInterfaceDecl::prop_iterator I = OI->prop_begin(Context),
|
|
|
|
E = OI->prop_end(Context); I != E; ++I) {
|
2009-04-01 02:11:23 +08:00
|
|
|
if ((*I)->getPropertyIvarDecl())
|
|
|
|
++count;
|
|
|
|
}
|
2009-01-18 03:36:33 +08:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2009-02-13 02:51:23 +08:00
|
|
|
/// getInterfaceDeclForIvar - Get the interface declaration node where
|
|
|
|
/// this ivar is declared in.
|
|
|
|
/// FIXME. Ideally, this info should be in the ivar node. But currently
|
|
|
|
/// it is not and prevailing wisdom is that ASTs should not have more
|
|
|
|
/// info than is absolutely needed, even though this info reflects the
|
|
|
|
/// source language.
|
|
|
|
///
|
|
|
|
static const ObjCInterfaceDecl *getInterfaceDeclForIvar(
|
|
|
|
const ObjCInterfaceDecl *OI,
|
2009-04-10 05:40:53 +08:00
|
|
|
const ObjCIvarDecl *IVD,
|
|
|
|
ASTContext &Context) {
|
2009-02-13 02:51:23 +08:00
|
|
|
if (!OI)
|
|
|
|
return 0;
|
|
|
|
assert(isa<ObjCInterfaceDecl>(OI) && "OI is not an interface");
|
|
|
|
for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(),
|
|
|
|
E = OI->ivar_end(); I != E; ++I)
|
|
|
|
if ((*I)->getIdentifier() == IVD->getIdentifier())
|
|
|
|
return OI;
|
2009-04-01 01:00:52 +08:00
|
|
|
// look into properties.
|
2009-04-10 05:40:53 +08:00
|
|
|
for (ObjCInterfaceDecl::prop_iterator I = OI->prop_begin(Context),
|
|
|
|
E = OI->prop_end(Context); I != E; ++I) {
|
2009-04-01 01:00:52 +08:00
|
|
|
ObjCPropertyDecl *PDecl = (*I);
|
|
|
|
if (ObjCIvarDecl *IV = PDecl->getPropertyIvarDecl())
|
|
|
|
if (IV->getIdentifier() == IVD->getIdentifier())
|
|
|
|
return OI;
|
|
|
|
}
|
2009-04-10 05:40:53 +08:00
|
|
|
return getInterfaceDeclForIvar(OI->getSuperClass(), IVD, Context);
|
2009-02-13 02:51:23 +08:00
|
|
|
}
|
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
/*
|
|
|
|
struct objc_ivar {
|
|
|
|
char *ivar_name;
|
|
|
|
char *ivar_type;
|
|
|
|
int ivar_offset;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct objc_ivar_list {
|
|
|
|
int ivar_count;
|
|
|
|
struct objc_ivar list[count];
|
|
|
|
};
|
|
|
|
*/
|
|
|
|
llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
|
2009-01-29 03:12:34 +08:00
|
|
|
bool ForClass) {
|
2008-08-21 12:36:09 +08:00
|
|
|
std::vector<llvm::Constant*> Ivars, Ivar(3);
|
|
|
|
|
|
|
|
// When emitting the root class GCC emits ivar entries for the
|
|
|
|
// actual class structure. It is not clear if we need to follow this
|
|
|
|
// behavior; for now lets try and get away with not doing it. If so,
|
|
|
|
// the cleanest solution would be to make up an ObjCInterfaceDecl
|
|
|
|
// for the class.
|
|
|
|
if (ForClass)
|
|
|
|
return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
|
2009-01-29 03:12:34 +08:00
|
|
|
|
|
|
|
ObjCInterfaceDecl *OID =
|
|
|
|
const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
|
2009-03-12 05:42:00 +08:00
|
|
|
const llvm::StructLayout *Layout = GetInterfaceDeclStructLayout(OID);
|
2009-01-29 03:12:34 +08:00
|
|
|
|
|
|
|
RecordDecl::field_iterator ifield, pfield;
|
|
|
|
const RecordDecl *RD = GetFirstIvarInRecord(OID, ifield, pfield);
|
2009-04-10 05:40:53 +08:00
|
|
|
for (RecordDecl::field_iterator e = RD->field_end(CGM.getContext());
|
|
|
|
ifield != e; ++ifield) {
|
2009-01-18 03:36:33 +08:00
|
|
|
FieldDecl *Field = *ifield;
|
2009-03-09 04:18:37 +08:00
|
|
|
uint64_t Offset = GetIvarBaseOffset(Layout, Field);
|
2009-01-18 03:36:33 +08:00
|
|
|
if (Field->getIdentifier())
|
|
|
|
Ivar[0] = GetMethodVarName(Field->getIdentifier());
|
|
|
|
else
|
|
|
|
Ivar[0] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
|
2009-03-05 02:21:39 +08:00
|
|
|
Ivar[1] = GetMethodVarType(Field);
|
2008-08-21 12:36:09 +08:00
|
|
|
Ivar[2] = llvm::ConstantInt::get(ObjCTypes.IntTy, Offset);
|
2008-10-18 04:21:44 +08:00
|
|
|
Ivars.push_back(llvm::ConstantStruct::get(ObjCTypes.IvarTy, Ivar));
|
2008-08-21 12:36:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Return null for empty list.
|
|
|
|
if (Ivars.empty())
|
|
|
|
return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
|
|
|
|
|
|
|
|
std::vector<llvm::Constant*> Values(2);
|
|
|
|
Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Ivars.size());
|
|
|
|
llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.IvarTy,
|
|
|
|
Ivars.size());
|
|
|
|
Values[1] = llvm::ConstantArray::get(AT, Ivars);
|
|
|
|
llvm::Constant *Init = llvm::ConstantStruct::get(Values);
|
|
|
|
|
2009-03-10 05:49:58 +08:00
|
|
|
llvm::GlobalVariable *GV;
|
|
|
|
if (ForClass)
|
|
|
|
GV = CreateMetadataVar("\01L_OBJC_CLASS_VARIABLES_" + ID->getNameAsString(),
|
2009-03-10 06:18:41 +08:00
|
|
|
Init, "__OBJC,__class_vars,regular,no_dead_strip",
|
|
|
|
4, true);
|
2009-03-10 05:49:58 +08:00
|
|
|
else
|
|
|
|
GV = CreateMetadataVar("\01L_OBJC_INSTANCE_VARIABLES_"
|
|
|
|
+ ID->getNameAsString(),
|
|
|
|
Init, "__OBJC,__instance_vars,regular,no_dead_strip",
|
|
|
|
0, true);
|
2008-08-21 12:36:09 +08:00
|
|
|
return llvm::ConstantExpr::getBitCast(GV,
|
|
|
|
ObjCTypes.IvarListPtrTy);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
struct objc_method {
|
|
|
|
SEL method_name;
|
|
|
|
char *method_types;
|
|
|
|
void *method;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct objc_method_list {
|
|
|
|
struct objc_method_list *obsolete;
|
|
|
|
int count;
|
|
|
|
struct objc_method methods_list[count];
|
|
|
|
};
|
|
|
|
*/
|
|
|
|
|
2008-08-27 05:51:14 +08:00
|
|
|
/// GetMethodConstant - Return a struct objc_method constant for the
|
|
|
|
/// given method if it has been defined. The result is null if the
|
|
|
|
/// method has not been defined. The return value has type MethodPtrTy.
|
2008-08-27 10:31:56 +08:00
|
|
|
llvm::Constant *CGObjCMac::GetMethodConstant(const ObjCMethodDecl *MD) {
|
2008-08-27 05:51:14 +08:00
|
|
|
// FIXME: Use DenseMap::lookup
|
|
|
|
llvm::Function *Fn = MethodDefinitions[MD];
|
|
|
|
if (!Fn)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
std::vector<llvm::Constant*> Method(3);
|
|
|
|
Method[0] =
|
|
|
|
llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
|
|
|
|
ObjCTypes.SelectorPtrTy);
|
|
|
|
Method[1] = GetMethodVarType(MD);
|
|
|
|
Method[2] = llvm::ConstantExpr::getBitCast(Fn, ObjCTypes.Int8PtrTy);
|
|
|
|
return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Method);
|
|
|
|
}
|
2008-08-21 12:36:09 +08:00
|
|
|
|
2008-08-27 05:51:14 +08:00
|
|
|
llvm::Constant *CGObjCMac::EmitMethodList(const std::string &Name,
|
|
|
|
const char *Section,
|
2008-08-27 10:31:56 +08:00
|
|
|
const ConstantVector &Methods) {
|
2008-08-21 12:36:09 +08:00
|
|
|
// Return null for empty list.
|
|
|
|
if (Methods.empty())
|
|
|
|
return llvm::Constant::getNullValue(ObjCTypes.MethodListPtrTy);
|
|
|
|
|
|
|
|
std::vector<llvm::Constant*> Values(3);
|
|
|
|
Values[0] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
|
|
|
|
Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
|
|
|
|
llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodTy,
|
|
|
|
Methods.size());
|
|
|
|
Values[2] = llvm::ConstantArray::get(AT, Methods);
|
|
|
|
llvm::Constant *Init = llvm::ConstantStruct::get(Values);
|
|
|
|
|
2009-03-10 05:49:58 +08:00
|
|
|
llvm::GlobalVariable *GV = CreateMetadataVar(Name, Init, Section, 0, true);
|
2008-08-21 12:36:09 +08:00
|
|
|
return llvm::ConstantExpr::getBitCast(GV,
|
|
|
|
ObjCTypes.MethodListPtrTy);
|
2008-08-16 11:19:19 +08:00
|
|
|
}
|
|
|
|
|
2009-01-27 05:38:32 +08:00
|
|
|
llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
|
2009-02-03 05:43:58 +08:00
|
|
|
const ObjCContainerDecl *CD) {
|
2008-08-16 11:19:19 +08:00
|
|
|
std::string Name;
|
2009-01-11 05:06:09 +08:00
|
|
|
GetNameForMethod(OMD, CD, Name);
|
2008-08-16 11:19:19 +08:00
|
|
|
|
2009-02-03 07:23:47 +08:00
|
|
|
CodeGenTypes &Types = CGM.getTypes();
|
2008-09-10 12:01:49 +08:00
|
|
|
const llvm::FunctionType *MethodTy =
|
2009-02-03 07:23:47 +08:00
|
|
|
Types.GetFunctionType(Types.getFunctionInfo(OMD), OMD->isVariadic());
|
2008-08-16 11:19:19 +08:00
|
|
|
llvm::Function *Method =
|
2008-09-10 12:01:49 +08:00
|
|
|
llvm::Function::Create(MethodTy,
|
2008-08-16 11:19:19 +08:00
|
|
|
llvm::GlobalValue::InternalLinkage,
|
|
|
|
Name,
|
|
|
|
&CGM.getModule());
|
2008-08-27 05:51:14 +08:00
|
|
|
MethodDefinitions.insert(std::make_pair(OMD, Method));
|
2008-08-16 11:19:19 +08:00
|
|
|
|
|
|
|
return Method;
|
2008-08-11 10:45:11 +08:00
|
|
|
}
|
|
|
|
|
2009-03-09 04:18:37 +08:00
|
|
|
uint64_t CGObjCCommonMac::GetIvarBaseOffset(const llvm::StructLayout *Layout,
|
2009-03-31 16:33:16 +08:00
|
|
|
const FieldDecl *Field) {
|
2009-03-10 04:44:22 +08:00
|
|
|
if (!Field->isBitField())
|
|
|
|
return Layout->getElementOffset(
|
|
|
|
CGM.getTypes().getLLVMFieldNo(Field));
|
|
|
|
// FIXME. Must be a better way of getting a bitfield base offset.
|
|
|
|
uint64_t offset = CGM.getTypes().getLLVMFieldNo(Field);
|
|
|
|
const llvm::Type *Ty = CGM.getTypes().ConvertTypeForMemRecursive(Field->getType());
|
|
|
|
uint64_t size = CGM.getTypes().getTargetData().getTypePaddedSizeInBits(Ty);
|
|
|
|
offset = (offset*size)/8;
|
|
|
|
return offset;
|
2009-03-09 04:18:37 +08:00
|
|
|
}
|
|
|
|
|
2009-03-13 06:50:49 +08:00
|
|
|
/// GetFieldBaseOffset - return's field byt offset.
|
|
|
|
uint64_t CGObjCCommonMac::GetFieldBaseOffset(const ObjCInterfaceDecl *OI,
|
|
|
|
const llvm::StructLayout *Layout,
|
2009-03-31 16:33:16 +08:00
|
|
|
const FieldDecl *Field) {
|
2009-03-13 06:50:49 +08:00
|
|
|
const ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(Field);
|
2009-03-31 16:33:16 +08:00
|
|
|
const FieldDecl *FD = OI->lookupFieldDeclForIvar(CGM.getContext(), Ivar);
|
|
|
|
return GetIvarBaseOffset(Layout, FD);
|
2009-03-13 06:50:49 +08:00
|
|
|
}
|
|
|
|
|
2009-03-10 04:09:19 +08:00
|
|
|
llvm::GlobalVariable *
|
|
|
|
CGObjCCommonMac::CreateMetadataVar(const std::string &Name,
|
|
|
|
llvm::Constant *Init,
|
|
|
|
const char *Section,
|
2009-03-10 04:50:13 +08:00
|
|
|
unsigned Align,
|
|
|
|
bool AddToUsed) {
|
2009-03-10 04:09:19 +08:00
|
|
|
const llvm::Type *Ty = Init->getType();
|
|
|
|
llvm::GlobalVariable *GV =
|
|
|
|
new llvm::GlobalVariable(Ty, false,
|
|
|
|
llvm::GlobalValue::InternalLinkage,
|
|
|
|
Init,
|
|
|
|
Name,
|
|
|
|
&CGM.getModule());
|
|
|
|
if (Section)
|
|
|
|
GV->setSection(Section);
|
2009-03-10 04:50:13 +08:00
|
|
|
if (Align)
|
|
|
|
GV->setAlignment(Align);
|
|
|
|
if (AddToUsed)
|
2009-03-10 04:09:19 +08:00
|
|
|
UsedGlobals.push_back(GV);
|
|
|
|
return GV;
|
|
|
|
}
|
|
|
|
|
2008-08-11 10:45:11 +08:00
|
|
|
llvm::Function *CGObjCMac::ModuleInitFunction() {
|
2008-08-12 05:35:06 +08:00
|
|
|
// Abuse this interface function as a place to finalize.
|
|
|
|
FinishModule();
|
|
|
|
|
2008-08-11 10:45:11 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *CGObjCMac::GetPropertyGetFunction() {
|
2008-09-24 11:38:44 +08:00
|
|
|
return ObjCTypes.GetPropertyFn;
|
|
|
|
}
|
|
|
|
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *CGObjCMac::GetPropertySetFunction() {
|
2008-09-24 11:38:44 +08:00
|
|
|
return ObjCTypes.SetPropertyFn;
|
|
|
|
}
|
|
|
|
|
2009-03-23 05:03:39 +08:00
|
|
|
llvm::Constant *CGObjCMac::EnumerationMutationFunction() {
|
2008-08-31 12:05:03 +08:00
|
|
|
return ObjCTypes.EnumerationMutationFn;
|
|
|
|
}
|
|
|
|
|
2008-09-28 09:03:14 +08:00
|
|
|
/*
|
|
|
|
|
|
|
|
Objective-C setjmp-longjmp (sjlj) Exception Handling
|
|
|
|
--
|
|
|
|
|
|
|
|
The basic framework for a @try-catch-finally is as follows:
|
|
|
|
{
|
|
|
|
objc_exception_data d;
|
|
|
|
id _rethrow = null;
|
2009-02-08 05:26:04 +08:00
|
|
|
bool _call_try_exit = true;
|
|
|
|
|
2008-09-28 09:03:14 +08:00
|
|
|
objc_exception_try_enter(&d);
|
|
|
|
if (!setjmp(d.jmp_buf)) {
|
|
|
|
... try body ...
|
|
|
|
} else {
|
|
|
|
// exception path
|
|
|
|
id _caught = objc_exception_extract(&d);
|
|
|
|
|
|
|
|
// enter new try scope for handlers
|
|
|
|
if (!setjmp(d.jmp_buf)) {
|
|
|
|
... match exception and execute catch blocks ...
|
|
|
|
|
|
|
|
// fell off end, rethrow.
|
|
|
|
_rethrow = _caught;
|
2008-09-30 09:06:03 +08:00
|
|
|
... jump-through-finally to finally_rethrow ...
|
2008-09-28 09:03:14 +08:00
|
|
|
} else {
|
|
|
|
// exception in catch block
|
|
|
|
_rethrow = objc_exception_extract(&d);
|
2009-02-08 05:26:04 +08:00
|
|
|
_call_try_exit = false;
|
|
|
|
... jump-through-finally to finally_rethrow ...
|
2008-09-28 09:03:14 +08:00
|
|
|
}
|
|
|
|
}
|
2008-09-30 09:06:03 +08:00
|
|
|
... jump-through-finally to finally_end ...
|
2008-09-28 09:03:14 +08:00
|
|
|
|
|
|
|
finally:
|
2009-02-08 05:26:04 +08:00
|
|
|
if (_call_try_exit)
|
|
|
|
objc_exception_try_exit(&d);
|
|
|
|
|
2008-09-28 09:03:14 +08:00
|
|
|
... finally block ....
|
2008-09-30 09:06:03 +08:00
|
|
|
... dispatch to finally destination ...
|
|
|
|
|
|
|
|
finally_rethrow:
|
|
|
|
objc_exception_throw(_rethrow);
|
|
|
|
|
|
|
|
finally_end:
|
2008-09-28 09:03:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
This framework differs slightly from the one gcc uses, in that gcc
|
2008-09-30 09:06:03 +08:00
|
|
|
uses _rethrow to determine if objc_exception_try_exit should be called
|
|
|
|
and if the object should be rethrown. This breaks in the face of
|
|
|
|
throwing nil and introduces unnecessary branches.
|
2008-09-28 09:03:14 +08:00
|
|
|
|
|
|
|
We specialize this framework for a few particular circumstances:
|
|
|
|
|
|
|
|
- If there are no catch blocks, then we avoid emitting the second
|
|
|
|
exception handling context.
|
|
|
|
|
|
|
|
- If there is a catch-all catch block (i.e. @catch(...) or @catch(id
|
|
|
|
e)) we avoid emitting the code to rethrow an uncaught exception.
|
|
|
|
|
|
|
|
- FIXME: If there is no @finally block we can do a few more
|
|
|
|
simplifications.
|
|
|
|
|
|
|
|
Rethrows and Jumps-Through-Finally
|
|
|
|
--
|
|
|
|
|
|
|
|
Support for implicit rethrows and jumping through the finally block is
|
|
|
|
handled by storing the current exception-handling context in
|
|
|
|
ObjCEHStack.
|
|
|
|
|
2008-09-30 09:06:03 +08:00
|
|
|
In order to implement proper @finally semantics, we support one basic
|
|
|
|
mechanism for jumping through the finally block to an arbitrary
|
|
|
|
destination. Constructs which generate exits from a @try or @catch
|
|
|
|
block use this mechanism to implement the proper semantics by chaining
|
|
|
|
jumps, as necessary.
|
|
|
|
|
|
|
|
This mechanism works like the one used for indirect goto: we
|
|
|
|
arbitrarily assign an ID to each destination and store the ID for the
|
|
|
|
destination in a variable prior to entering the finally block. At the
|
|
|
|
end of the finally block we simply create a switch to the proper
|
|
|
|
destination.
|
2008-11-21 08:49:24 +08:00
|
|
|
|
|
|
|
Code gen for @synchronized(expr) stmt;
|
|
|
|
Effectively generating code for:
|
|
|
|
objc_sync_enter(expr);
|
|
|
|
@try stmt @finally { objc_sync_exit(expr); }
|
2008-09-28 09:03:14 +08:00
|
|
|
*/
|
|
|
|
|
2008-11-21 08:49:24 +08:00
|
|
|
void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
|
|
|
|
const Stmt &S) {
|
|
|
|
bool isTry = isa<ObjCAtTryStmt>(S);
|
2008-09-30 09:06:03 +08:00
|
|
|
// Create various blocks we refer to for handling @finally.
|
2008-11-11 10:29:29 +08:00
|
|
|
llvm::BasicBlock *FinallyBlock = CGF.createBasicBlock("finally");
|
2009-02-08 05:26:04 +08:00
|
|
|
llvm::BasicBlock *FinallyExit = CGF.createBasicBlock("finally.exit");
|
2008-11-11 10:29:29 +08:00
|
|
|
llvm::BasicBlock *FinallyNoExit = CGF.createBasicBlock("finally.noexit");
|
|
|
|
llvm::BasicBlock *FinallyRethrow = CGF.createBasicBlock("finally.throw");
|
|
|
|
llvm::BasicBlock *FinallyEnd = CGF.createBasicBlock("finally.end");
|
2009-02-24 09:43:46 +08:00
|
|
|
|
|
|
|
// For @synchronized, call objc_sync_enter(sync.expr). The
|
|
|
|
// evaluation of the expression must occur before we enter the
|
|
|
|
// @synchronized. We can safely avoid a temp here because jumps into
|
|
|
|
// @synchronized are illegal & this will dominate uses.
|
|
|
|
llvm::Value *SyncArg = 0;
|
|
|
|
if (!isTry) {
|
|
|
|
SyncArg =
|
|
|
|
CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
|
|
|
|
SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
|
2009-04-07 00:53:45 +08:00
|
|
|
CGF.Builder.CreateCall(ObjCTypes.getSyncEnterFn(), SyncArg);
|
2009-02-24 09:43:46 +08:00
|
|
|
}
|
2008-09-30 09:06:03 +08:00
|
|
|
|
|
|
|
// Push an EH context entry, used for handling rethrows and jumps
|
|
|
|
// through finally.
|
2009-02-10 04:38:58 +08:00
|
|
|
CGF.PushCleanupBlock(FinallyBlock);
|
|
|
|
|
2009-02-08 05:37:21 +08:00
|
|
|
CGF.ObjCEHValueStack.push_back(0);
|
|
|
|
|
2008-09-30 09:06:03 +08:00
|
|
|
// Allocate memory for the exception data and rethrow pointer.
|
2008-09-10 01:59:25 +08:00
|
|
|
llvm::Value *ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
|
|
|
|
"exceptiondata.ptr");
|
2008-10-30 06:36:39 +08:00
|
|
|
llvm::Value *RethrowPtr = CGF.CreateTempAlloca(ObjCTypes.ObjectPtrTy,
|
|
|
|
"_rethrow");
|
2009-02-08 05:26:04 +08:00
|
|
|
llvm::Value *CallTryExitPtr = CGF.CreateTempAlloca(llvm::Type::Int1Ty,
|
|
|
|
"_call_try_exit");
|
|
|
|
CGF.Builder.CreateStore(llvm::ConstantInt::getTrue(), CallTryExitPtr);
|
|
|
|
|
2008-09-10 01:59:25 +08:00
|
|
|
// Enter a new try block and call setjmp.
|
|
|
|
CGF.Builder.CreateCall(ObjCTypes.ExceptionTryEnterFn, ExceptionData);
|
|
|
|
llvm::Value *JmpBufPtr = CGF.Builder.CreateStructGEP(ExceptionData, 0,
|
|
|
|
"jmpbufarray");
|
|
|
|
JmpBufPtr = CGF.Builder.CreateStructGEP(JmpBufPtr, 0, "tmp");
|
|
|
|
llvm::Value *SetJmpResult = CGF.Builder.CreateCall(ObjCTypes.SetJmpFn,
|
|
|
|
JmpBufPtr, "result");
|
2008-09-30 09:06:03 +08:00
|
|
|
|
2008-11-11 10:29:29 +08:00
|
|
|
llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
|
|
|
|
llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
|
2008-10-03 01:05:36 +08:00
|
|
|
CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(SetJmpResult, "threw"),
|
2008-09-28 07:30:04 +08:00
|
|
|
TryHandler, TryBlock);
|
2008-09-10 01:59:25 +08:00
|
|
|
|
|
|
|
// Emit the @try block.
|
|
|
|
CGF.EmitBlock(TryBlock);
|
2008-11-21 08:49:24 +08:00
|
|
|
CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
|
|
|
|
: cast<ObjCAtSynchronizedStmt>(S).getSynchBody());
|
2009-02-10 04:38:58 +08:00
|
|
|
CGF.EmitBranchThroughCleanup(FinallyEnd);
|
2008-09-10 01:59:25 +08:00
|
|
|
|
|
|
|
// Emit the "exception in @try" block.
|
2008-09-28 07:30:04 +08:00
|
|
|
CGF.EmitBlock(TryHandler);
|
2008-09-27 15:03:52 +08:00
|
|
|
|
|
|
|
// Retrieve the exception object. We may emit multiple blocks but
|
|
|
|
// nothing can cross this so the value is already in SSA form.
|
|
|
|
llvm::Value *Caught = CGF.Builder.CreateCall(ObjCTypes.ExceptionExtractFn,
|
|
|
|
ExceptionData,
|
|
|
|
"caught");
|
2009-02-08 05:37:21 +08:00
|
|
|
CGF.ObjCEHValueStack.back() = Caught;
|
2008-11-21 08:49:24 +08:00
|
|
|
if (!isTry)
|
|
|
|
{
|
|
|
|
CGF.Builder.CreateStore(Caught, RethrowPtr);
|
2009-02-08 05:26:04 +08:00
|
|
|
CGF.Builder.CreateStore(llvm::ConstantInt::getFalse(), CallTryExitPtr);
|
2009-02-10 04:38:58 +08:00
|
|
|
CGF.EmitBranchThroughCleanup(FinallyRethrow);
|
2008-11-21 08:49:24 +08:00
|
|
|
}
|
|
|
|
else if (const ObjCAtCatchStmt* CatchStmt =
|
|
|
|
cast<ObjCAtTryStmt>(S).getCatchStmts())
|
|
|
|
{
|
2008-09-27 15:03:52 +08:00
|
|
|
// Enter a new exception try block (in case a @catch block throws
|
|
|
|
// an exception).
|
2008-09-10 01:59:25 +08:00
|
|
|
CGF.Builder.CreateCall(ObjCTypes.ExceptionTryEnterFn, ExceptionData);
|
2008-09-27 15:03:52 +08:00
|
|
|
|
2008-09-10 01:59:25 +08:00
|
|
|
llvm::Value *SetJmpResult = CGF.Builder.CreateCall(ObjCTypes.SetJmpFn,
|
|
|
|
JmpBufPtr, "result");
|
2008-10-03 01:05:36 +08:00
|
|
|
llvm::Value *Threw = CGF.Builder.CreateIsNotNull(SetJmpResult, "threw");
|
2008-09-10 01:59:25 +08:00
|
|
|
|
2008-11-11 10:29:29 +08:00
|
|
|
llvm::BasicBlock *CatchBlock = CGF.createBasicBlock("catch");
|
|
|
|
llvm::BasicBlock *CatchHandler = CGF.createBasicBlock("catch.handler");
|
2008-09-28 07:30:04 +08:00
|
|
|
CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
|
2008-09-10 01:59:25 +08:00
|
|
|
|
|
|
|
CGF.EmitBlock(CatchBlock);
|
|
|
|
|
2008-09-27 15:03:52 +08:00
|
|
|
// Handle catch list. As a special case we check if everything is
|
|
|
|
// matched and avoid generating code for falling off the end if
|
|
|
|
// so.
|
|
|
|
bool AllMatched = false;
|
2008-09-10 01:59:25 +08:00
|
|
|
for (; CatchStmt; CatchStmt = CatchStmt->getNextCatchStmt()) {
|
2008-11-11 10:29:29 +08:00
|
|
|
llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch");
|
2008-09-10 01:59:25 +08:00
|
|
|
|
2009-03-04 03:52:17 +08:00
|
|
|
const ParmVarDecl *CatchParam = CatchStmt->getCatchParamDecl();
|
2008-09-27 15:36:24 +08:00
|
|
|
const PointerType *PT = 0;
|
|
|
|
|
2008-09-10 01:59:25 +08:00
|
|
|
// catch(...) always matches.
|
2008-09-27 15:03:52 +08:00
|
|
|
if (!CatchParam) {
|
|
|
|
AllMatched = true;
|
|
|
|
} else {
|
2009-03-04 03:52:17 +08:00
|
|
|
PT = CatchParam->getType()->getAsPointerType();
|
2008-09-10 01:59:25 +08:00
|
|
|
|
2008-09-28 06:21:14 +08:00
|
|
|
// catch(id e) always matches.
|
|
|
|
// FIXME: For the time being we also match id<X>; this should
|
|
|
|
// be rejected by Sema instead.
|
2009-02-13 01:52:19 +08:00
|
|
|
if ((PT && CGF.getContext().isObjCIdStructType(PT->getPointeeType())) ||
|
2009-03-04 03:52:17 +08:00
|
|
|
CatchParam->getType()->isObjCQualifiedIdType())
|
2008-09-27 15:03:52 +08:00
|
|
|
AllMatched = true;
|
2008-09-10 01:59:25 +08:00
|
|
|
}
|
|
|
|
|
2008-09-27 15:03:52 +08:00
|
|
|
if (AllMatched) {
|
2008-09-11 17:15:33 +08:00
|
|
|
if (CatchParam) {
|
2009-03-04 03:52:17 +08:00
|
|
|
CGF.EmitLocalBlockVarDecl(*CatchParam);
|
2008-11-12 07:11:34 +08:00
|
|
|
assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
|
2009-03-04 03:52:17 +08:00
|
|
|
CGF.Builder.CreateStore(Caught, CGF.GetAddrOfLocalVar(CatchParam));
|
2008-09-11 17:15:33 +08:00
|
|
|
}
|
2008-09-11 16:21:54 +08:00
|
|
|
|
2008-09-11 17:15:33 +08:00
|
|
|
CGF.EmitStmt(CatchStmt->getCatchBody());
|
2009-02-10 04:38:58 +08:00
|
|
|
CGF.EmitBranchThroughCleanup(FinallyEnd);
|
2008-09-10 01:59:25 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-09-27 15:36:24 +08:00
|
|
|
assert(PT && "Unexpected non-pointer type in @catch");
|
|
|
|
QualType T = PT->getPointeeType();
|
2008-09-11 14:35:14 +08:00
|
|
|
const ObjCInterfaceType *ObjCType = T->getAsObjCInterfaceType();
|
2008-09-10 01:59:25 +08:00
|
|
|
assert(ObjCType && "Catch parameter must have Objective-C type!");
|
|
|
|
|
|
|
|
// Check if the @catch block matches the exception object.
|
|
|
|
llvm::Value *Class = EmitClassRef(CGF.Builder, ObjCType->getDecl());
|
|
|
|
|
|
|
|
llvm::Value *Match = CGF.Builder.CreateCall2(ObjCTypes.ExceptionMatchFn,
|
|
|
|
Class, Caught, "match");
|
|
|
|
|
2008-11-11 10:29:29 +08:00
|
|
|
llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("matched");
|
2008-09-10 01:59:25 +08:00
|
|
|
|
2008-10-03 01:05:36 +08:00
|
|
|
CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
|
2008-09-28 07:30:04 +08:00
|
|
|
MatchedBlock, NextCatchBlock);
|
2008-09-10 01:59:25 +08:00
|
|
|
|
|
|
|
// Emit the @catch block.
|
|
|
|
CGF.EmitBlock(MatchedBlock);
|
2009-03-04 03:52:17 +08:00
|
|
|
CGF.EmitLocalBlockVarDecl(*CatchParam);
|
2008-11-12 07:11:34 +08:00
|
|
|
assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
|
2008-09-28 09:03:14 +08:00
|
|
|
|
|
|
|
llvm::Value *Tmp =
|
2009-03-04 03:52:17 +08:00
|
|
|
CGF.Builder.CreateBitCast(Caught, CGF.ConvertType(CatchParam->getType()),
|
2008-09-28 09:03:14 +08:00
|
|
|
"tmp");
|
2009-03-04 03:52:17 +08:00
|
|
|
CGF.Builder.CreateStore(Tmp, CGF.GetAddrOfLocalVar(CatchParam));
|
2008-09-11 17:15:33 +08:00
|
|
|
|
|
|
|
CGF.EmitStmt(CatchStmt->getCatchBody());
|
2009-02-10 04:38:58 +08:00
|
|
|
CGF.EmitBranchThroughCleanup(FinallyEnd);
|
2008-09-10 01:59:25 +08:00
|
|
|
|
|
|
|
CGF.EmitBlock(NextCatchBlock);
|
|
|
|
}
|
|
|
|
|
2008-09-27 15:03:52 +08:00
|
|
|
if (!AllMatched) {
|
|
|
|
// None of the handlers caught the exception, so store it to be
|
|
|
|
// rethrown at the end of the @finally block.
|
|
|
|
CGF.Builder.CreateStore(Caught, RethrowPtr);
|
2009-02-10 04:38:58 +08:00
|
|
|
CGF.EmitBranchThroughCleanup(FinallyRethrow);
|
2008-09-27 15:03:52 +08:00
|
|
|
}
|
2008-09-10 01:59:25 +08:00
|
|
|
|
2008-09-27 15:03:52 +08:00
|
|
|
// Emit the exception handler for the @catch blocks.
|
2008-09-28 07:30:04 +08:00
|
|
|
CGF.EmitBlock(CatchHandler);
|
2008-09-27 15:03:52 +08:00
|
|
|
CGF.Builder.CreateStore(CGF.Builder.CreateCall(ObjCTypes.ExceptionExtractFn,
|
|
|
|
ExceptionData),
|
|
|
|
RethrowPtr);
|
2009-02-08 05:26:04 +08:00
|
|
|
CGF.Builder.CreateStore(llvm::ConstantInt::getFalse(), CallTryExitPtr);
|
2009-02-10 04:38:58 +08:00
|
|
|
CGF.EmitBranchThroughCleanup(FinallyRethrow);
|
2008-09-27 15:03:52 +08:00
|
|
|
} else {
|
|
|
|
CGF.Builder.CreateStore(Caught, RethrowPtr);
|
2009-02-08 05:26:04 +08:00
|
|
|
CGF.Builder.CreateStore(llvm::ConstantInt::getFalse(), CallTryExitPtr);
|
2009-02-10 04:38:58 +08:00
|
|
|
CGF.EmitBranchThroughCleanup(FinallyRethrow);
|
2008-09-10 01:59:25 +08:00
|
|
|
}
|
|
|
|
|
2008-09-30 09:06:03 +08:00
|
|
|
// Pop the exception-handling stack entry. It is important to do
|
|
|
|
// this now, because the code in the @finally block is not in this
|
|
|
|
// context.
|
2009-02-10 04:38:58 +08:00
|
|
|
CodeGenFunction::CleanupBlockInfo Info = CGF.PopCleanupBlock();
|
|
|
|
|
2009-02-08 05:37:21 +08:00
|
|
|
CGF.ObjCEHValueStack.pop_back();
|
|
|
|
|
2008-09-10 01:59:25 +08:00
|
|
|
// Emit the @finally block.
|
|
|
|
CGF.EmitBlock(FinallyBlock);
|
2009-02-08 05:26:04 +08:00
|
|
|
llvm::Value* CallTryExit = CGF.Builder.CreateLoad(CallTryExitPtr, "tmp");
|
|
|
|
|
|
|
|
CGF.Builder.CreateCondBr(CallTryExit, FinallyExit, FinallyNoExit);
|
|
|
|
|
|
|
|
CGF.EmitBlock(FinallyExit);
|
2008-09-27 15:36:24 +08:00
|
|
|
CGF.Builder.CreateCall(ObjCTypes.ExceptionTryExitFn, ExceptionData);
|
2008-09-10 01:59:25 +08:00
|
|
|
|
2008-09-27 15:36:24 +08:00
|
|
|
CGF.EmitBlock(FinallyNoExit);
|
2008-11-21 08:49:24 +08:00
|
|
|
if (isTry) {
|
|
|
|
if (const ObjCAtFinallyStmt* FinallyStmt =
|
|
|
|
cast<ObjCAtTryStmt>(S).getFinallyStmt())
|
|
|
|
CGF.EmitStmt(FinallyStmt->getFinallyBody());
|
2009-02-24 09:43:46 +08:00
|
|
|
} else {
|
|
|
|
// Emit objc_sync_exit(expr); as finally's sole statement for
|
|
|
|
// @synchronized.
|
|
|
|
CGF.Builder.CreateCall(ObjCTypes.SyncExitFn, SyncArg);
|
2008-11-22 03:21:53 +08:00
|
|
|
}
|
2008-09-10 01:59:25 +08:00
|
|
|
|
2009-02-10 04:38:58 +08:00
|
|
|
// Emit the switch block
|
|
|
|
if (Info.SwitchBlock)
|
|
|
|
CGF.EmitBlock(Info.SwitchBlock);
|
|
|
|
if (Info.EndBlock)
|
|
|
|
CGF.EmitBlock(Info.EndBlock);
|
|
|
|
|
2008-09-30 09:06:03 +08:00
|
|
|
CGF.EmitBlock(FinallyRethrow);
|
|
|
|
CGF.Builder.CreateCall(ObjCTypes.ExceptionThrowFn,
|
|
|
|
CGF.Builder.CreateLoad(RethrowPtr));
|
2008-09-28 07:30:04 +08:00
|
|
|
CGF.Builder.CreateUnreachable();
|
2008-09-30 09:06:03 +08:00
|
|
|
|
|
|
|
CGF.EmitBlock(FinallyEnd);
|
2008-09-09 18:04:29 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
|
2008-09-30 09:06:03 +08:00
|
|
|
const ObjCAtThrowStmt &S) {
|
2008-09-10 00:16:55 +08:00
|
|
|
llvm::Value *ExceptionAsObject;
|
|
|
|
|
|
|
|
if (const Expr *ThrowExpr = S.getThrowExpr()) {
|
|
|
|
llvm::Value *Exception = CGF.EmitScalarExpr(ThrowExpr);
|
|
|
|
ExceptionAsObject =
|
|
|
|
CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy, "tmp");
|
|
|
|
} else {
|
2009-02-08 05:37:21 +08:00
|
|
|
assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
|
2008-09-28 09:03:14 +08:00
|
|
|
"Unexpected rethrow outside @catch block.");
|
2009-02-08 05:37:21 +08:00
|
|
|
ExceptionAsObject = CGF.ObjCEHValueStack.back();
|
2008-09-10 00:16:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
CGF.Builder.CreateCall(ObjCTypes.ExceptionThrowFn, ExceptionAsObject);
|
2008-09-10 01:59:25 +08:00
|
|
|
CGF.Builder.CreateUnreachable();
|
2008-11-12 07:11:34 +08:00
|
|
|
|
|
|
|
// Clear the insertion point to indicate we are in unreachable code.
|
|
|
|
CGF.Builder.ClearInsertionPoint();
|
2008-09-09 18:04:29 +08:00
|
|
|
}
|
|
|
|
|
2008-11-19 06:37:34 +08:00
|
|
|
/// EmitObjCWeakRead - Code gen for loading value of a __weak
|
2008-11-19 05:45:40 +08:00
|
|
|
/// object: objc_read_weak (id *src)
|
|
|
|
///
|
2008-11-19 06:37:34 +08:00
|
|
|
llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
|
2008-11-19 05:45:40 +08:00
|
|
|
llvm::Value *AddrWeakObj)
|
|
|
|
{
|
2009-03-07 11:57:15 +08:00
|
|
|
const llvm::Type* DestTy =
|
|
|
|
cast<llvm::PointerType>(AddrWeakObj->getType())->getElementType();
|
2008-11-20 01:34:06 +08:00
|
|
|
AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy);
|
2008-11-19 05:45:40 +08:00
|
|
|
llvm::Value *read_weak = CGF.Builder.CreateCall(ObjCTypes.GcReadWeakFn,
|
2008-11-19 06:37:34 +08:00
|
|
|
AddrWeakObj, "weakread");
|
2009-03-07 11:57:15 +08:00
|
|
|
read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
|
2008-11-19 05:45:40 +08:00
|
|
|
return read_weak;
|
|
|
|
}
|
|
|
|
|
2008-11-19 06:37:34 +08:00
|
|
|
/// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
|
|
|
|
/// objc_assign_weak (id src, id *dst)
|
|
|
|
///
|
|
|
|
void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
|
|
|
|
llvm::Value *src, llvm::Value *dst)
|
|
|
|
{
|
2009-03-24 03:10:40 +08:00
|
|
|
const llvm::Type * SrcTy = src->getType();
|
|
|
|
if (!isa<llvm::PointerType>(SrcTy)) {
|
|
|
|
unsigned Size = CGM.getTargetData().getTypePaddedSize(SrcTy);
|
|
|
|
assert(Size <= 8 && "does not support size > 8");
|
|
|
|
src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
|
|
|
|
: CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
|
2009-03-13 08:42:52 +08:00
|
|
|
src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
|
|
|
|
}
|
2008-11-20 01:34:06 +08:00
|
|
|
src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
|
|
|
|
dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
|
2008-11-19 06:37:34 +08:00
|
|
|
CGF.Builder.CreateCall2(ObjCTypes.GcAssignWeakFn,
|
|
|
|
src, dst, "weakassign");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-11-19 08:59:10 +08:00
|
|
|
/// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
|
|
|
|
/// objc_assign_global (id src, id *dst)
|
|
|
|
///
|
|
|
|
void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
|
|
|
|
llvm::Value *src, llvm::Value *dst)
|
|
|
|
{
|
2009-03-24 03:10:40 +08:00
|
|
|
const llvm::Type * SrcTy = src->getType();
|
|
|
|
if (!isa<llvm::PointerType>(SrcTy)) {
|
|
|
|
unsigned Size = CGM.getTargetData().getTypePaddedSize(SrcTy);
|
|
|
|
assert(Size <= 8 && "does not support size > 8");
|
|
|
|
src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
|
|
|
|
: CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
|
2009-03-13 08:42:52 +08:00
|
|
|
src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
|
|
|
|
}
|
2008-11-20 01:34:06 +08:00
|
|
|
src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
|
|
|
|
dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
|
2008-11-19 08:59:10 +08:00
|
|
|
CGF.Builder.CreateCall2(ObjCTypes.GcAssignGlobalFn,
|
|
|
|
src, dst, "globalassign");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-11-21 03:23:36 +08:00
|
|
|
/// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
|
|
|
|
/// objc_assign_ivar (id src, id *dst)
|
|
|
|
///
|
|
|
|
void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
|
|
|
|
llvm::Value *src, llvm::Value *dst)
|
|
|
|
{
|
2009-03-24 03:10:40 +08:00
|
|
|
const llvm::Type * SrcTy = src->getType();
|
|
|
|
if (!isa<llvm::PointerType>(SrcTy)) {
|
|
|
|
unsigned Size = CGM.getTargetData().getTypePaddedSize(SrcTy);
|
|
|
|
assert(Size <= 8 && "does not support size > 8");
|
|
|
|
src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
|
|
|
|
: CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
|
2009-03-13 08:42:52 +08:00
|
|
|
src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
|
|
|
|
}
|
2008-11-21 03:23:36 +08:00
|
|
|
src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
|
|
|
|
dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
|
|
|
|
CGF.Builder.CreateCall2(ObjCTypes.GcAssignIvarFn,
|
|
|
|
src, dst, "assignivar");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-11-19 08:59:10 +08:00
|
|
|
/// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
|
|
|
|
/// objc_assign_strongCast (id src, id *dst)
|
|
|
|
///
|
|
|
|
void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
|
|
|
|
llvm::Value *src, llvm::Value *dst)
|
|
|
|
{
|
2009-03-24 03:10:40 +08:00
|
|
|
const llvm::Type * SrcTy = src->getType();
|
|
|
|
if (!isa<llvm::PointerType>(SrcTy)) {
|
|
|
|
unsigned Size = CGM.getTargetData().getTypePaddedSize(SrcTy);
|
|
|
|
assert(Size <= 8 && "does not support size > 8");
|
|
|
|
src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
|
|
|
|
: CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
|
2009-03-13 08:42:52 +08:00
|
|
|
src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
|
|
|
|
}
|
2008-11-20 01:34:06 +08:00
|
|
|
src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
|
|
|
|
dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
|
2008-11-19 08:59:10 +08:00
|
|
|
CGF.Builder.CreateCall2(ObjCTypes.GcAssignStrongCastFn,
|
|
|
|
src, dst, "weakassign");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-02-03 04:02:29 +08:00
|
|
|
/// EmitObjCValueForIvar - Code Gen for ivar reference.
|
|
|
|
///
|
2009-02-04 03:03:09 +08:00
|
|
|
LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
|
|
|
|
QualType ObjectTy,
|
|
|
|
llvm::Value *BaseValue,
|
|
|
|
const ObjCIvarDecl *Ivar,
|
|
|
|
const FieldDecl *Field,
|
|
|
|
unsigned CVRQualifiers) {
|
|
|
|
if (Ivar->isBitField())
|
|
|
|
return CGF.EmitLValueForBitfield(BaseValue, const_cast<FieldDecl *>(Field),
|
|
|
|
CVRQualifiers);
|
2009-02-03 04:02:29 +08:00
|
|
|
// TODO: Add a special case for isa (index 0)
|
|
|
|
unsigned Index = CGM.getTypes().getLLVMFieldNo(Field);
|
|
|
|
llvm::Value *V = CGF.Builder.CreateStructGEP(BaseValue, Index, "tmp");
|
2009-02-04 03:03:09 +08:00
|
|
|
LValue LV = LValue::MakeAddr(V,
|
2009-02-20 07:36:06 +08:00
|
|
|
Ivar->getType().getCVRQualifiers()|CVRQualifiers,
|
|
|
|
CGM.getContext().getObjCGCAttrKind(Ivar->getType()));
|
2009-02-04 03:03:09 +08:00
|
|
|
LValue::SetObjCIvar(LV, true);
|
|
|
|
return LV;
|
2009-02-03 04:02:29 +08:00
|
|
|
}
|
|
|
|
|
2009-02-11 03:02:04 +08:00
|
|
|
llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
|
|
|
|
ObjCInterfaceDecl *Interface,
|
|
|
|
const ObjCIvarDecl *Ivar) {
|
2009-03-12 05:42:00 +08:00
|
|
|
const llvm::StructLayout *Layout = GetInterfaceDeclStructLayout(Interface);
|
2009-02-11 03:02:04 +08:00
|
|
|
FieldDecl *Field = Interface->lookupFieldDeclForIvar(CGM.getContext(), Ivar);
|
2009-03-09 04:18:37 +08:00
|
|
|
uint64_t Offset = GetIvarBaseOffset(Layout, Field);
|
2009-02-11 03:02:04 +08:00
|
|
|
return llvm::ConstantInt::get(
|
|
|
|
CGM.getTypes().ConvertType(CGM.getContext().LongTy),
|
|
|
|
Offset);
|
|
|
|
}
|
|
|
|
|
2008-08-12 05:35:06 +08:00
|
|
|
/* *** Private Interface *** */
|
|
|
|
|
|
|
|
/// EmitImageInfo - Emit the image info marker used to encode some module
|
|
|
|
/// level information.
|
|
|
|
///
|
|
|
|
/// See: <rdr://4810609&4810587&4810587>
|
|
|
|
/// struct IMAGE_INFO {
|
|
|
|
/// unsigned version;
|
|
|
|
/// unsigned flags;
|
|
|
|
/// };
|
|
|
|
enum ImageInfoFlags {
|
|
|
|
eImageInfo_FixAndContinue = (1 << 0), // FIXME: Not sure what this implies
|
|
|
|
eImageInfo_GarbageCollected = (1 << 1),
|
|
|
|
eImageInfo_GCOnly = (1 << 2)
|
|
|
|
};
|
|
|
|
|
|
|
|
void CGObjCMac::EmitImageInfo() {
|
|
|
|
unsigned version = 0; // Version is unused?
|
|
|
|
unsigned flags = 0;
|
|
|
|
|
|
|
|
// FIXME: Fix and continue?
|
|
|
|
if (CGM.getLangOptions().getGCMode() != LangOptions::NonGC)
|
|
|
|
flags |= eImageInfo_GarbageCollected;
|
|
|
|
if (CGM.getLangOptions().getGCMode() == LangOptions::GCOnly)
|
|
|
|
flags |= eImageInfo_GCOnly;
|
|
|
|
|
|
|
|
// Emitted as int[2];
|
|
|
|
llvm::Constant *values[2] = {
|
|
|
|
llvm::ConstantInt::get(llvm::Type::Int32Ty, version),
|
|
|
|
llvm::ConstantInt::get(llvm::Type::Int32Ty, flags)
|
|
|
|
};
|
|
|
|
llvm::ArrayType *AT = llvm::ArrayType::get(llvm::Type::Int32Ty, 2);
|
|
|
|
|
2009-03-10 05:49:58 +08:00
|
|
|
const char *Section;
|
|
|
|
if (ObjCABI == 1)
|
|
|
|
Section = "__OBJC, __image_info,regular";
|
|
|
|
else
|
|
|
|
Section = "__DATA, __objc_imageinfo, regular, no_dead_strip";
|
|
|
|
llvm::GlobalVariable *GV =
|
|
|
|
CreateMetadataVar("\01L_OBJC_IMAGE_INFO",
|
|
|
|
llvm::ConstantArray::get(AT, values, 2),
|
|
|
|
Section,
|
|
|
|
0,
|
|
|
|
true);
|
|
|
|
GV->setConstant(true);
|
2008-08-12 05:35:06 +08:00
|
|
|
}
|
|
|
|
|
2008-08-12 14:48:42 +08:00
|
|
|
|
|
|
|
// struct objc_module {
|
|
|
|
// unsigned long version;
|
|
|
|
// unsigned long size;
|
|
|
|
// const char *name;
|
|
|
|
// Symtab symtab;
|
|
|
|
// };
|
|
|
|
|
|
|
|
// FIXME: Get from somewhere
|
|
|
|
static const int ModuleVersion = 7;
|
|
|
|
|
|
|
|
void CGObjCMac::EmitModuleInfo() {
|
2009-01-13 05:08:18 +08:00
|
|
|
uint64_t Size = CGM.getTargetData().getTypePaddedSize(ObjCTypes.ModuleTy);
|
2008-08-12 14:48:42 +08:00
|
|
|
|
|
|
|
std::vector<llvm::Constant*> Values(4);
|
|
|
|
Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, ModuleVersion);
|
|
|
|
Values[1] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size);
|
2008-08-16 06:20:32 +08:00
|
|
|
// This used to be the filename, now it is unused. <rdr://4327263>
|
2008-08-13 11:21:16 +08:00
|
|
|
Values[2] = GetClassName(&CGM.getContext().Idents.get(""));
|
2008-08-12 14:48:42 +08:00
|
|
|
Values[3] = EmitModuleSymbols();
|
2009-03-10 05:49:58 +08:00
|
|
|
CreateMetadataVar("\01L_OBJC_MODULES",
|
|
|
|
llvm::ConstantStruct::get(ObjCTypes.ModuleTy, Values),
|
|
|
|
"__OBJC,__module_info,regular,no_dead_strip",
|
2009-03-10 06:18:41 +08:00
|
|
|
4, true);
|
2008-08-12 14:48:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
llvm::Constant *CGObjCMac::EmitModuleSymbols() {
|
2008-08-21 12:36:09 +08:00
|
|
|
unsigned NumClasses = DefinedClasses.size();
|
|
|
|
unsigned NumCategories = DefinedCategories.size();
|
|
|
|
|
2008-08-25 14:02:07 +08:00
|
|
|
// Return null if no symbols were defined.
|
|
|
|
if (!NumClasses && !NumCategories)
|
|
|
|
return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy);
|
|
|
|
|
|
|
|
std::vector<llvm::Constant*> Values(5);
|
2008-08-21 12:36:09 +08:00
|
|
|
Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
|
|
|
|
Values[1] = llvm::Constant::getNullValue(ObjCTypes.SelectorPtrTy);
|
|
|
|
Values[2] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumClasses);
|
|
|
|
Values[3] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumCategories);
|
|
|
|
|
2008-08-23 04:34:54 +08:00
|
|
|
// The runtime expects exactly the list of defined classes followed
|
|
|
|
// by the list of defined categories, in a single array.
|
2008-08-21 12:36:09 +08:00
|
|
|
std::vector<llvm::Constant*> Symbols(NumClasses + NumCategories);
|
2008-08-23 04:34:54 +08:00
|
|
|
for (unsigned i=0; i<NumClasses; i++)
|
|
|
|
Symbols[i] = llvm::ConstantExpr::getBitCast(DefinedClasses[i],
|
|
|
|
ObjCTypes.Int8PtrTy);
|
|
|
|
for (unsigned i=0; i<NumCategories; i++)
|
|
|
|
Symbols[NumClasses + i] =
|
|
|
|
llvm::ConstantExpr::getBitCast(DefinedCategories[i],
|
|
|
|
ObjCTypes.Int8PtrTy);
|
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
Values[4] =
|
2008-08-23 04:34:54 +08:00
|
|
|
llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
|
2008-08-21 12:36:09 +08:00
|
|
|
NumClasses + NumCategories),
|
|
|
|
Symbols);
|
|
|
|
|
|
|
|
llvm::Constant *Init = llvm::ConstantStruct::get(Values);
|
|
|
|
|
2008-08-12 14:48:42 +08:00
|
|
|
llvm::GlobalVariable *GV =
|
2009-03-10 05:49:58 +08:00
|
|
|
CreateMetadataVar("\01L_OBJC_SYMBOLS", Init,
|
|
|
|
"__OBJC,__symbols,regular,no_dead_strip",
|
|
|
|
0, true);
|
2008-08-21 12:36:09 +08:00
|
|
|
return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy);
|
|
|
|
}
|
|
|
|
|
2008-11-01 09:53:16 +08:00
|
|
|
llvm::Value *CGObjCMac::EmitClassRef(CGBuilderTy &Builder,
|
2008-08-21 12:36:09 +08:00
|
|
|
const ObjCInterfaceDecl *ID) {
|
2008-08-25 14:02:07 +08:00
|
|
|
LazySymbols.insert(ID->getIdentifier());
|
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
llvm::GlobalVariable *&Entry = ClassReferences[ID->getIdentifier()];
|
|
|
|
|
|
|
|
if (!Entry) {
|
|
|
|
llvm::Constant *Casted =
|
|
|
|
llvm::ConstantExpr::getBitCast(GetClassName(ID->getIdentifier()),
|
|
|
|
ObjCTypes.ClassPtrTy);
|
|
|
|
Entry =
|
2009-03-10 05:49:58 +08:00
|
|
|
CreateMetadataVar("\01L_OBJC_CLASS_REFERENCES_", Casted,
|
|
|
|
"__OBJC,__cls_refs,literal_pointers,no_dead_strip",
|
|
|
|
0, true);
|
2008-08-21 12:36:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return Builder.CreateLoad(Entry, false, "tmp");
|
2008-08-12 14:48:42 +08:00
|
|
|
}
|
|
|
|
|
2008-11-01 09:53:16 +08:00
|
|
|
llvm::Value *CGObjCMac::EmitSelector(CGBuilderTy &Builder, Selector Sel) {
|
2008-08-12 11:39:23 +08:00
|
|
|
llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
|
|
|
|
|
|
|
|
if (!Entry) {
|
|
|
|
llvm::Constant *Casted =
|
|
|
|
llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
|
|
|
|
ObjCTypes.SelectorPtrTy);
|
|
|
|
Entry =
|
2009-03-10 05:49:58 +08:00
|
|
|
CreateMetadataVar("\01L_OBJC_SELECTOR_REFERENCES_", Casted,
|
|
|
|
"__OBJC,__message_refs,literal_pointers,no_dead_strip",
|
|
|
|
0, true);
|
2008-08-12 11:39:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return Builder.CreateLoad(Entry, false, "tmp");
|
|
|
|
}
|
|
|
|
|
2009-01-25 04:21:50 +08:00
|
|
|
llvm::Constant *CGObjCCommonMac::GetClassName(IdentifierInfo *Ident) {
|
2008-08-13 11:21:16 +08:00
|
|
|
llvm::GlobalVariable *&Entry = ClassNames[Ident];
|
2008-08-12 14:48:42 +08:00
|
|
|
|
2009-03-10 05:49:58 +08:00
|
|
|
if (!Entry)
|
|
|
|
Entry = CreateMetadataVar("\01L_OBJC_CLASS_NAME_",
|
|
|
|
llvm::ConstantArray::get(Ident->getName()),
|
|
|
|
"__TEXT,__cstring,cstring_literals",
|
|
|
|
0, true);
|
2008-08-12 14:48:42 +08:00
|
|
|
|
2008-08-13 11:21:16 +08:00
|
|
|
return getConstantGEP(Entry, 0, 0);
|
2008-08-12 14:48:42 +08:00
|
|
|
}
|
|
|
|
|
2009-03-12 05:42:00 +08:00
|
|
|
/// GetInterfaceDeclStructLayout - Get layout for ivars of given
|
|
|
|
/// interface declaration.
|
|
|
|
const llvm::StructLayout *CGObjCCommonMac::GetInterfaceDeclStructLayout(
|
|
|
|
const ObjCInterfaceDecl *OID) const {
|
|
|
|
const llvm::Type *InterfaceTy =
|
|
|
|
CGM.getTypes().ConvertType(
|
|
|
|
CGM.getContext().getObjCInterfaceType(
|
|
|
|
const_cast<ObjCInterfaceDecl*>(OID)));
|
|
|
|
const llvm::StructLayout *Layout =
|
|
|
|
CGM.getTargetData().getStructLayout(cast<llvm::StructType>(InterfaceTy));
|
|
|
|
return Layout;
|
|
|
|
}
|
|
|
|
|
2009-03-06 03:17:31 +08:00
|
|
|
/// GetIvarLayoutName - Returns a unique constant for the given
|
|
|
|
/// ivar layout bitmap.
|
|
|
|
llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident,
|
|
|
|
const ObjCCommonTypesHelper &ObjCTypes) {
|
|
|
|
return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
|
|
|
|
}
|
|
|
|
|
2009-03-13 06:50:49 +08:00
|
|
|
void CGObjCCommonMac::BuildAggrIvarLayout(const ObjCInterfaceDecl *OI,
|
|
|
|
const llvm::StructLayout *Layout,
|
2009-03-11 00:22:08 +08:00
|
|
|
const RecordDecl *RD,
|
2009-03-31 16:48:01 +08:00
|
|
|
const llvm::SmallVectorImpl<FieldDecl*> &RecFields,
|
2009-03-06 06:39:55 +08:00
|
|
|
unsigned int BytePos, bool ForStrongLayout,
|
|
|
|
int &Index, int &SkIndex, bool &HasUnion) {
|
2009-03-11 08:07:04 +08:00
|
|
|
bool IsUnion = (RD && RD->isUnion());
|
|
|
|
uint64_t MaxUnionIvarSize = 0;
|
|
|
|
uint64_t MaxSkippedUnionIvarSize = 0;
|
|
|
|
FieldDecl *MaxField = 0;
|
|
|
|
FieldDecl *MaxSkippedField = 0;
|
2009-03-31 16:48:01 +08:00
|
|
|
unsigned base = 0;
|
2009-03-11 00:22:08 +08:00
|
|
|
if (RecFields.empty())
|
|
|
|
return;
|
2009-03-11 08:07:04 +08:00
|
|
|
if (IsUnion)
|
2009-03-13 06:50:49 +08:00
|
|
|
base = BytePos + GetFieldBaseOffset(OI, Layout, RecFields[0]);
|
2009-03-31 16:48:01 +08:00
|
|
|
unsigned WordSizeInBits = CGM.getContext().Target.getPointerWidth(0);
|
|
|
|
unsigned ByteSizeInBits = CGM.getContext().Target.getCharWidth();
|
|
|
|
|
|
|
|
llvm::SmallVector<FieldDecl*, 16> TmpRecFields;
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
|
2009-03-11 00:22:08 +08:00
|
|
|
FieldDecl *Field = RecFields[i];
|
|
|
|
// Skip over unnamed or bitfields
|
|
|
|
if (!Field->getIdentifier() || Field->isBitField())
|
|
|
|
continue;
|
|
|
|
QualType FQT = Field->getType();
|
2009-03-26 06:36:49 +08:00
|
|
|
if (FQT->isRecordType() || FQT->isUnionType()) {
|
2009-03-11 00:22:08 +08:00
|
|
|
if (FQT->isUnionType())
|
|
|
|
HasUnion = true;
|
2009-03-11 08:07:04 +08:00
|
|
|
else
|
|
|
|
assert(FQT->isRecordType() &&
|
|
|
|
"only union/record is supported for ivar layout bitmap");
|
|
|
|
|
2009-03-11 00:22:08 +08:00
|
|
|
const RecordType *RT = FQT->getAsRecordType();
|
|
|
|
const RecordDecl *RD = RT->getDecl();
|
|
|
|
// FIXME - Find a more efficiant way of passing records down.
|
2009-04-10 05:40:53 +08:00
|
|
|
TmpRecFields.append(RD->field_begin(CGM.getContext()),
|
|
|
|
RD->field_end(CGM.getContext()));
|
2009-03-11 00:22:08 +08:00
|
|
|
// FIXME - Is Layout correct?
|
2009-03-31 16:48:01 +08:00
|
|
|
BuildAggrIvarLayout(OI, Layout, RD, TmpRecFields,
|
2009-03-13 06:50:49 +08:00
|
|
|
BytePos + GetFieldBaseOffset(OI, Layout, Field),
|
2009-03-11 00:22:08 +08:00
|
|
|
ForStrongLayout, Index, SkIndex,
|
|
|
|
HasUnion);
|
2009-03-31 16:48:01 +08:00
|
|
|
TmpRecFields.clear();
|
2009-03-11 00:22:08 +08:00
|
|
|
continue;
|
|
|
|
}
|
2009-03-31 16:48:01 +08:00
|
|
|
|
|
|
|
if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
|
2009-03-11 08:07:04 +08:00
|
|
|
const ConstantArrayType *CArray =
|
|
|
|
dyn_cast_or_null<ConstantArrayType>(Array);
|
|
|
|
assert(CArray && "only array with know element size is supported");
|
|
|
|
FQT = CArray->getElementType();
|
2009-03-26 06:36:49 +08:00
|
|
|
while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
|
|
|
|
const ConstantArrayType *CArray =
|
|
|
|
dyn_cast_or_null<ConstantArrayType>(Array);
|
|
|
|
FQT = CArray->getElementType();
|
|
|
|
}
|
|
|
|
|
2009-03-11 08:07:04 +08:00
|
|
|
assert(!FQT->isUnionType() &&
|
|
|
|
"layout for array of unions not supported");
|
|
|
|
if (FQT->isRecordType()) {
|
|
|
|
uint64_t ElCount = CArray->getSize().getZExtValue();
|
|
|
|
int OldIndex = Index;
|
|
|
|
int OldSkIndex = SkIndex;
|
|
|
|
|
|
|
|
// FIXME - Use a common routine with the above!
|
|
|
|
const RecordType *RT = FQT->getAsRecordType();
|
|
|
|
const RecordDecl *RD = RT->getDecl();
|
|
|
|
// FIXME - Find a more efficiant way of passing records down.
|
2009-04-10 05:40:53 +08:00
|
|
|
TmpRecFields.append(RD->field_begin(CGM.getContext()),
|
|
|
|
RD->field_end(CGM.getContext()));
|
2009-03-31 16:48:01 +08:00
|
|
|
|
2009-03-13 06:50:49 +08:00
|
|
|
BuildAggrIvarLayout(OI, Layout, RD,
|
2009-03-31 16:48:01 +08:00
|
|
|
TmpRecFields,
|
2009-03-13 06:50:49 +08:00
|
|
|
BytePos + GetFieldBaseOffset(OI, Layout, Field),
|
2009-03-11 08:07:04 +08:00
|
|
|
ForStrongLayout, Index, SkIndex,
|
|
|
|
HasUnion);
|
2009-03-31 16:48:01 +08:00
|
|
|
TmpRecFields.clear();
|
|
|
|
|
2009-03-11 08:07:04 +08:00
|
|
|
// Replicate layout information for each array element. Note that
|
|
|
|
// one element is already done.
|
|
|
|
uint64_t ElIx = 1;
|
|
|
|
for (int FirstIndex = Index, FirstSkIndex = SkIndex;
|
|
|
|
ElIx < ElCount; ElIx++) {
|
2009-03-13 06:50:49 +08:00
|
|
|
uint64_t Size = CGM.getContext().getTypeSize(RT)/ByteSizeInBits;
|
2009-03-11 08:07:04 +08:00
|
|
|
for (int i = OldIndex+1; i <= FirstIndex; ++i)
|
|
|
|
{
|
2009-03-13 06:50:49 +08:00
|
|
|
GC_IVAR gcivar;
|
|
|
|
gcivar.ivar_bytepos = IvarsInfo[i].ivar_bytepos + Size*ElIx;
|
|
|
|
gcivar.ivar_size = IvarsInfo[i].ivar_size;
|
|
|
|
IvarsInfo.push_back(gcivar); ++Index;
|
2009-03-11 08:07:04 +08:00
|
|
|
}
|
|
|
|
|
2009-03-31 16:48:01 +08:00
|
|
|
for (int i = OldSkIndex+1; i <= FirstSkIndex; ++i) {
|
2009-03-13 06:50:49 +08:00
|
|
|
GC_IVAR skivar;
|
|
|
|
skivar.ivar_bytepos = SkipIvars[i].ivar_bytepos + Size*ElIx;
|
|
|
|
skivar.ivar_size = SkipIvars[i].ivar_size;
|
|
|
|
SkipIvars.push_back(skivar); ++SkIndex;
|
2009-03-11 08:07:04 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
2009-03-11 00:22:08 +08:00
|
|
|
}
|
2009-03-11 08:07:04 +08:00
|
|
|
// At this point, we are done with Record/Union and array there of.
|
|
|
|
// For other arrays we are down to its element type.
|
|
|
|
QualType::GCAttrTypes GCAttr = QualType::GCNone;
|
|
|
|
do {
|
|
|
|
if (FQT.isObjCGCStrong() || FQT.isObjCGCWeak()) {
|
|
|
|
GCAttr = FQT.isObjCGCStrong() ? QualType::Strong : QualType::Weak;
|
|
|
|
break;
|
|
|
|
}
|
2009-03-13 06:50:49 +08:00
|
|
|
else if (CGM.getContext().isObjCObjectPointerType(FQT)) {
|
2009-03-11 08:07:04 +08:00
|
|
|
GCAttr = QualType::Strong;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else if (const PointerType *PT = FQT->getAsPointerType()) {
|
|
|
|
FQT = PT->getPointeeType();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} while (true);
|
2009-03-31 16:48:01 +08:00
|
|
|
|
2009-03-11 08:07:04 +08:00
|
|
|
if ((ForStrongLayout && GCAttr == QualType::Strong)
|
|
|
|
|| (!ForStrongLayout && GCAttr == QualType::Weak)) {
|
|
|
|
if (IsUnion)
|
|
|
|
{
|
2009-03-13 06:50:49 +08:00
|
|
|
uint64_t UnionIvarSize = CGM.getContext().getTypeSize(Field->getType())
|
|
|
|
/ WordSizeInBits;
|
2009-03-11 08:07:04 +08:00
|
|
|
if (UnionIvarSize > MaxUnionIvarSize)
|
|
|
|
{
|
|
|
|
MaxUnionIvarSize = UnionIvarSize;
|
|
|
|
MaxField = Field;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2009-03-13 06:50:49 +08:00
|
|
|
GC_IVAR gcivar;
|
|
|
|
gcivar.ivar_bytepos = BytePos + GetFieldBaseOffset(OI, Layout, Field);
|
|
|
|
gcivar.ivar_size = CGM.getContext().getTypeSize(Field->getType()) /
|
|
|
|
WordSizeInBits;
|
|
|
|
IvarsInfo.push_back(gcivar); ++Index;
|
2009-03-11 08:07:04 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if ((ForStrongLayout &&
|
|
|
|
(GCAttr == QualType::GCNone || GCAttr == QualType::Weak))
|
|
|
|
|| (!ForStrongLayout && GCAttr != QualType::Weak)) {
|
|
|
|
if (IsUnion)
|
|
|
|
{
|
|
|
|
uint64_t UnionIvarSize = CGM.getContext().getTypeSize(Field->getType());
|
|
|
|
if (UnionIvarSize > MaxSkippedUnionIvarSize)
|
|
|
|
{
|
|
|
|
MaxSkippedUnionIvarSize = UnionIvarSize;
|
|
|
|
MaxSkippedField = Field;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2009-03-13 06:50:49 +08:00
|
|
|
GC_IVAR skivar;
|
|
|
|
skivar.ivar_bytepos = BytePos + GetFieldBaseOffset(OI, Layout, Field);
|
|
|
|
skivar.ivar_size = CGM.getContext().getTypeSize(Field->getType()) /
|
|
|
|
WordSizeInBits;
|
|
|
|
SkipIvars.push_back(skivar); ++SkIndex;
|
2009-03-11 08:07:04 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-03-31 16:48:01 +08:00
|
|
|
if (MaxField) {
|
2009-03-13 06:50:49 +08:00
|
|
|
GC_IVAR gcivar;
|
|
|
|
gcivar.ivar_bytepos = BytePos + GetFieldBaseOffset(OI, Layout, MaxField);
|
|
|
|
gcivar.ivar_size = MaxUnionIvarSize;
|
|
|
|
IvarsInfo.push_back(gcivar); ++Index;
|
2009-03-11 08:07:04 +08:00
|
|
|
}
|
2009-03-31 16:48:01 +08:00
|
|
|
|
|
|
|
if (MaxSkippedField) {
|
2009-03-13 06:50:49 +08:00
|
|
|
GC_IVAR skivar;
|
|
|
|
skivar.ivar_bytepos = BytePos +
|
|
|
|
GetFieldBaseOffset(OI, Layout, MaxSkippedField);
|
|
|
|
skivar.ivar_size = MaxSkippedUnionIvarSize;
|
|
|
|
SkipIvars.push_back(skivar); ++SkIndex;
|
2009-03-11 00:22:08 +08:00
|
|
|
}
|
2009-03-06 06:39:55 +08:00
|
|
|
}
|
|
|
|
|
2009-03-12 04:59:05 +08:00
|
|
|
static int
|
2009-03-31 16:48:01 +08:00
|
|
|
IvarBytePosCompare(const void *a, const void *b)
|
2009-03-12 04:59:05 +08:00
|
|
|
{
|
|
|
|
unsigned int sa = ((CGObjCCommonMac::GC_IVAR *)a)->ivar_bytepos;
|
|
|
|
unsigned int sb = ((CGObjCCommonMac::GC_IVAR *)b)->ivar_bytepos;
|
|
|
|
|
|
|
|
if (sa < sb)
|
|
|
|
return -1;
|
|
|
|
if (sa > sb)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-03-06 06:39:55 +08:00
|
|
|
/// BuildIvarLayout - Builds ivar layout bitmap for the class
|
|
|
|
/// implementation for the __strong or __weak case.
|
|
|
|
/// The layout map displays which words in ivar list must be skipped
|
|
|
|
/// and which must be scanned by GC (see below). String is built of bytes.
|
|
|
|
/// Each byte is divided up in two nibbles (4-bit each). Left nibble is count
|
|
|
|
/// of words to skip and right nibble is count of words to scan. So, each
|
|
|
|
/// nibble represents up to 15 workds to skip or scan. Skipping the rest is
|
|
|
|
/// represented by a 0x00 byte which also ends the string.
|
|
|
|
/// 1. when ForStrongLayout is true, following ivars are scanned:
|
|
|
|
/// - id, Class
|
|
|
|
/// - object *
|
|
|
|
/// - __strong anything
|
|
|
|
///
|
|
|
|
/// 2. When ForStrongLayout is false, following ivars are scanned:
|
|
|
|
/// - __weak anything
|
|
|
|
///
|
2009-03-11 00:22:08 +08:00
|
|
|
llvm::Constant *CGObjCCommonMac::BuildIvarLayout(
|
2009-03-13 06:50:49 +08:00
|
|
|
const ObjCImplementationDecl *OMD,
|
|
|
|
bool ForStrongLayout) {
|
2009-03-12 04:59:05 +08:00
|
|
|
int Index = -1;
|
|
|
|
int SkIndex = -1;
|
2009-03-06 06:39:55 +08:00
|
|
|
bool hasUnion = false;
|
2009-03-12 04:59:05 +08:00
|
|
|
int SkipScan;
|
|
|
|
unsigned int WordsToScan, WordsToSkip;
|
2009-03-13 06:50:49 +08:00
|
|
|
const llvm::Type *PtrTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
|
|
|
|
if (CGM.getLangOptions().getGCMode() == LangOptions::NonGC)
|
|
|
|
return llvm::Constant::getNullValue(PtrTy);
|
2009-03-06 06:39:55 +08:00
|
|
|
|
2009-03-31 16:48:01 +08:00
|
|
|
llvm::SmallVector<FieldDecl*, 32> RecFields;
|
2009-03-13 06:50:49 +08:00
|
|
|
const ObjCInterfaceDecl *OI = OMD->getClassInterface();
|
2009-03-06 06:39:55 +08:00
|
|
|
CGM.getContext().CollectObjCIvars(OI, RecFields);
|
|
|
|
if (RecFields.empty())
|
2009-03-13 06:50:49 +08:00
|
|
|
return llvm::Constant::getNullValue(PtrTy);
|
2009-03-31 16:48:01 +08:00
|
|
|
|
2009-03-13 06:50:49 +08:00
|
|
|
SkipIvars.clear();
|
|
|
|
IvarsInfo.clear();
|
2009-03-12 05:42:00 +08:00
|
|
|
|
|
|
|
const llvm::StructLayout *Layout = GetInterfaceDeclStructLayout(OI);
|
2009-03-31 16:48:01 +08:00
|
|
|
BuildAggrIvarLayout(OI, Layout, 0, RecFields, 0, ForStrongLayout,
|
|
|
|
Index, SkIndex, hasUnion);
|
2009-03-12 04:59:05 +08:00
|
|
|
if (Index == -1)
|
2009-03-13 06:50:49 +08:00
|
|
|
return llvm::Constant::getNullValue(PtrTy);
|
2009-03-12 04:59:05 +08:00
|
|
|
|
|
|
|
// Sort on byte position in case we encounterred a union nested in
|
|
|
|
// the ivar list.
|
2009-03-13 06:50:49 +08:00
|
|
|
if (hasUnion && !IvarsInfo.empty())
|
|
|
|
qsort(&IvarsInfo[0], Index+1, sizeof(GC_IVAR), IvarBytePosCompare);
|
|
|
|
if (hasUnion && !SkipIvars.empty())
|
2009-03-12 04:59:05 +08:00
|
|
|
qsort(&SkipIvars[0], Index+1, sizeof(GC_IVAR), IvarBytePosCompare);
|
|
|
|
|
|
|
|
// Build the string of skip/scan nibbles
|
|
|
|
SkipScan = -1;
|
2009-03-13 06:50:49 +08:00
|
|
|
SkipScanIvars.clear();
|
2009-03-12 04:59:05 +08:00
|
|
|
unsigned int WordSize =
|
2009-03-13 06:50:49 +08:00
|
|
|
CGM.getTypes().getTargetData().getTypePaddedSize(PtrTy);
|
2009-03-12 04:59:05 +08:00
|
|
|
if (IvarsInfo[0].ivar_bytepos == 0) {
|
|
|
|
WordsToSkip = 0;
|
|
|
|
WordsToScan = IvarsInfo[0].ivar_size;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
WordsToSkip = IvarsInfo[0].ivar_bytepos/WordSize;
|
|
|
|
WordsToScan = IvarsInfo[0].ivar_size;
|
|
|
|
}
|
2009-03-13 06:50:49 +08:00
|
|
|
for (unsigned int i=1, Last=IvarsInfo.size(); i != Last; i++)
|
2009-03-12 04:59:05 +08:00
|
|
|
{
|
|
|
|
unsigned int TailPrevGCObjC =
|
|
|
|
IvarsInfo[i-1].ivar_bytepos + IvarsInfo[i-1].ivar_size * WordSize;
|
|
|
|
if (IvarsInfo[i].ivar_bytepos == TailPrevGCObjC)
|
|
|
|
{
|
|
|
|
// consecutive 'scanned' object pointers.
|
|
|
|
WordsToScan += IvarsInfo[i].ivar_size;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Skip over 'gc'able object pointer which lay over each other.
|
|
|
|
if (TailPrevGCObjC > IvarsInfo[i].ivar_bytepos)
|
|
|
|
continue;
|
|
|
|
// Must skip over 1 or more words. We save current skip/scan values
|
|
|
|
// and start a new pair.
|
2009-03-13 06:50:49 +08:00
|
|
|
SKIP_SCAN SkScan;
|
|
|
|
SkScan.skip = WordsToSkip;
|
|
|
|
SkScan.scan = WordsToScan;
|
|
|
|
SkipScanIvars.push_back(SkScan); ++SkipScan;
|
|
|
|
|
2009-03-12 04:59:05 +08:00
|
|
|
// Skip the hole.
|
2009-03-13 06:50:49 +08:00
|
|
|
SkScan.skip = (IvarsInfo[i].ivar_bytepos - TailPrevGCObjC) / WordSize;
|
|
|
|
SkScan.scan = 0;
|
|
|
|
SkipScanIvars.push_back(SkScan); ++SkipScan;
|
2009-03-12 04:59:05 +08:00
|
|
|
WordsToSkip = 0;
|
|
|
|
WordsToScan = IvarsInfo[i].ivar_size;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (WordsToScan > 0)
|
|
|
|
{
|
2009-03-13 06:50:49 +08:00
|
|
|
SKIP_SCAN SkScan;
|
|
|
|
SkScan.skip = WordsToSkip;
|
|
|
|
SkScan.scan = WordsToScan;
|
|
|
|
SkipScanIvars.push_back(SkScan); ++SkipScan;
|
2009-03-12 04:59:05 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool BytesSkipped = false;
|
2009-03-13 06:50:49 +08:00
|
|
|
if (!SkipIvars.empty())
|
2009-03-12 04:59:05 +08:00
|
|
|
{
|
|
|
|
int LastByteSkipped =
|
|
|
|
SkipIvars[SkIndex].ivar_bytepos + SkipIvars[SkIndex].ivar_size;
|
|
|
|
int LastByteScanned =
|
|
|
|
IvarsInfo[Index].ivar_bytepos + IvarsInfo[Index].ivar_size * WordSize;
|
|
|
|
BytesSkipped = (LastByteSkipped > LastByteScanned);
|
|
|
|
// Compute number of bytes to skip at the tail end of the last ivar scanned.
|
|
|
|
if (BytesSkipped)
|
|
|
|
{
|
|
|
|
unsigned int TotalWords = (LastByteSkipped + (WordSize -1)) / WordSize;
|
2009-03-13 06:50:49 +08:00
|
|
|
SKIP_SCAN SkScan;
|
|
|
|
SkScan.skip = TotalWords - (LastByteScanned/WordSize);
|
|
|
|
SkScan.scan = 0;
|
|
|
|
SkipScanIvars.push_back(SkScan); ++SkipScan;
|
2009-03-12 04:59:05 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// Mini optimization of nibbles such that an 0xM0 followed by 0x0N is produced
|
|
|
|
// as 0xMN.
|
|
|
|
for (int i = 0; i <= SkipScan; i++)
|
|
|
|
{
|
|
|
|
if ((i < SkipScan) && SkipScanIvars[i].skip && SkipScanIvars[i].scan == 0
|
|
|
|
&& SkipScanIvars[i+1].skip == 0 && SkipScanIvars[i+1].scan) {
|
|
|
|
// 0xM0 followed by 0x0N detected.
|
|
|
|
SkipScanIvars[i].scan = SkipScanIvars[i+1].scan;
|
|
|
|
for (int j = i+1; j < SkipScan; j++)
|
|
|
|
SkipScanIvars[j] = SkipScanIvars[j+1];
|
|
|
|
--SkipScan;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Generate the string.
|
|
|
|
std::string BitMap;
|
|
|
|
for (int i = 0; i <= SkipScan; i++)
|
|
|
|
{
|
|
|
|
unsigned char byte;
|
|
|
|
unsigned int skip_small = SkipScanIvars[i].skip % 0xf;
|
|
|
|
unsigned int scan_small = SkipScanIvars[i].scan % 0xf;
|
|
|
|
unsigned int skip_big = SkipScanIvars[i].skip / 0xf;
|
|
|
|
unsigned int scan_big = SkipScanIvars[i].scan / 0xf;
|
|
|
|
|
|
|
|
if (skip_small > 0 || skip_big > 0)
|
|
|
|
BytesSkipped = true;
|
|
|
|
// first skip big.
|
|
|
|
for (unsigned int ix = 0; ix < skip_big; ix++)
|
|
|
|
BitMap += (unsigned char)(0xf0);
|
|
|
|
|
|
|
|
// next (skip small, scan)
|
|
|
|
if (skip_small)
|
|
|
|
{
|
|
|
|
byte = skip_small << 4;
|
|
|
|
if (scan_big > 0)
|
|
|
|
{
|
|
|
|
byte |= 0xf;
|
|
|
|
--scan_big;
|
|
|
|
}
|
|
|
|
else if (scan_small)
|
|
|
|
{
|
|
|
|
byte |= scan_small;
|
|
|
|
scan_small = 0;
|
|
|
|
}
|
|
|
|
BitMap += byte;
|
|
|
|
}
|
|
|
|
// next scan big
|
|
|
|
for (unsigned int ix = 0; ix < scan_big; ix++)
|
|
|
|
BitMap += (unsigned char)(0x0f);
|
|
|
|
// last scan small
|
|
|
|
if (scan_small)
|
|
|
|
{
|
|
|
|
byte = scan_small;
|
|
|
|
BitMap += byte;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// null terminate string.
|
2009-03-26 06:36:49 +08:00
|
|
|
unsigned char zero = 0;
|
|
|
|
BitMap += zero;
|
2009-03-12 04:59:05 +08:00
|
|
|
// if ivar_layout bitmap is all 1 bits (nothing skipped) then use NULL as
|
|
|
|
// final layout.
|
|
|
|
if (ForStrongLayout && !BytesSkipped)
|
2009-03-13 06:50:49 +08:00
|
|
|
return llvm::Constant::getNullValue(PtrTy);
|
|
|
|
llvm::GlobalVariable * Entry = CreateMetadataVar("\01L_OBJC_CLASS_NAME_",
|
|
|
|
llvm::ConstantArray::get(BitMap.c_str()),
|
|
|
|
"__TEXT,__cstring,cstring_literals",
|
|
|
|
0, true);
|
2009-03-26 06:36:49 +08:00
|
|
|
// FIXME. Need a commomand-line option for this eventually.
|
|
|
|
if (ForStrongLayout)
|
|
|
|
printf("\nstrong ivar layout: ");
|
|
|
|
else
|
|
|
|
printf("\nweak ivar layout: ");
|
|
|
|
const unsigned char *s = (unsigned char*)BitMap.c_str();
|
|
|
|
for (unsigned i = 0; i < BitMap.size(); i++)
|
2009-03-27 03:10:36 +08:00
|
|
|
if (!(s[i] & 0xf0))
|
|
|
|
printf("0x0%x%s", s[i], s[i] != 0 ? ", " : "");
|
|
|
|
else
|
|
|
|
printf("0x%x%s", s[i], s[i] != 0 ? ", " : "");
|
2009-03-26 06:36:49 +08:00
|
|
|
printf("\n");
|
|
|
|
|
2009-03-13 06:50:49 +08:00
|
|
|
return getConstantGEP(Entry, 0, 0);
|
2009-03-06 06:39:55 +08:00
|
|
|
}
|
|
|
|
|
2009-01-22 07:34:32 +08:00
|
|
|
llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) {
|
2008-08-12 11:39:23 +08:00
|
|
|
llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
|
|
|
|
|
2009-03-10 05:49:58 +08:00
|
|
|
// FIXME: Avoid std::string copying.
|
|
|
|
if (!Entry)
|
|
|
|
Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_NAME_",
|
|
|
|
llvm::ConstantArray::get(Sel.getAsString()),
|
|
|
|
"__TEXT,__cstring,cstring_literals",
|
|
|
|
0, true);
|
2008-08-12 11:39:23 +08:00
|
|
|
|
2008-08-13 11:21:16 +08:00
|
|
|
return getConstantGEP(Entry, 0, 0);
|
|
|
|
}
|
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
// FIXME: Merge into a single cstring creation function.
|
2009-01-22 07:34:32 +08:00
|
|
|
llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) {
|
2008-08-21 12:36:09 +08:00
|
|
|
return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
|
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: Merge into a single cstring creation function.
|
2009-01-22 07:34:32 +08:00
|
|
|
llvm::Constant *CGObjCCommonMac::GetMethodVarName(const std::string &Name) {
|
2008-08-21 12:36:09 +08:00
|
|
|
return GetMethodVarName(&CGM.getContext().Idents.get(Name));
|
|
|
|
}
|
|
|
|
|
2009-03-05 02:21:39 +08:00
|
|
|
llvm::Constant *CGObjCCommonMac::GetMethodVarType(FieldDecl *Field) {
|
|
|
|
std::string TypeStr;
|
|
|
|
CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field);
|
|
|
|
|
|
|
|
llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
|
2008-08-13 11:21:16 +08:00
|
|
|
|
2009-03-10 05:49:58 +08:00
|
|
|
if (!Entry)
|
|
|
|
Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_TYPE_",
|
|
|
|
llvm::ConstantArray::get(TypeStr),
|
|
|
|
"__TEXT,__cstring,cstring_literals",
|
|
|
|
0, true);
|
|
|
|
|
2008-08-13 11:21:16 +08:00
|
|
|
return getConstantGEP(Entry, 0, 0);
|
2008-08-12 11:39:23 +08:00
|
|
|
}
|
|
|
|
|
2009-01-22 07:34:32 +08:00
|
|
|
llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D) {
|
2008-08-21 12:36:09 +08:00
|
|
|
std::string TypeStr;
|
2008-08-27 05:51:14 +08:00
|
|
|
CGM.getContext().getObjCEncodingForMethodDecl(const_cast<ObjCMethodDecl*>(D),
|
|
|
|
TypeStr);
|
2009-03-05 02:21:39 +08:00
|
|
|
|
|
|
|
llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
|
|
|
|
|
|
|
|
if (!Entry) {
|
|
|
|
llvm::Constant *C = llvm::ConstantArray::get(TypeStr);
|
|
|
|
Entry =
|
|
|
|
new llvm::GlobalVariable(C->getType(), false,
|
|
|
|
llvm::GlobalValue::InternalLinkage,
|
|
|
|
C, "\01L_OBJC_METH_VAR_TYPE_",
|
|
|
|
&CGM.getModule());
|
|
|
|
Entry->setSection("__TEXT,__cstring,cstring_literals");
|
|
|
|
UsedGlobals.push_back(Entry);
|
|
|
|
}
|
|
|
|
|
|
|
|
return getConstantGEP(Entry, 0, 0);
|
2008-08-21 12:36:09 +08:00
|
|
|
}
|
|
|
|
|
2008-08-23 08:19:03 +08:00
|
|
|
// FIXME: Merge into a single cstring creation function.
|
2009-01-22 07:34:32 +08:00
|
|
|
llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) {
|
2008-08-23 08:19:03 +08:00
|
|
|
llvm::GlobalVariable *&Entry = PropertyNames[Ident];
|
|
|
|
|
2009-03-10 05:49:58 +08:00
|
|
|
if (!Entry)
|
|
|
|
Entry = CreateMetadataVar("\01L_OBJC_PROP_NAME_ATTR_",
|
|
|
|
llvm::ConstantArray::get(Ident->getName()),
|
|
|
|
"__TEXT,__cstring,cstring_literals",
|
|
|
|
0, true);
|
2008-08-23 08:19:03 +08:00
|
|
|
|
|
|
|
return getConstantGEP(Entry, 0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: Merge into a single cstring creation function.
|
2008-08-28 12:38:10 +08:00
|
|
|
// FIXME: This Decl should be more precise.
|
2009-03-10 05:49:58 +08:00
|
|
|
llvm::Constant *
|
|
|
|
CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
|
|
|
|
const Decl *Container) {
|
2008-08-28 12:38:10 +08:00
|
|
|
std::string TypeStr;
|
|
|
|
CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container, TypeStr);
|
2008-08-23 08:19:03 +08:00
|
|
|
return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
|
|
|
|
}
|
|
|
|
|
2009-01-22 07:34:32 +08:00
|
|
|
void CGObjCCommonMac::GetNameForMethod(const ObjCMethodDecl *D,
|
|
|
|
const ObjCContainerDecl *CD,
|
|
|
|
std::string &NameOut) {
|
2009-04-07 13:48:37 +08:00
|
|
|
NameOut = '\01';
|
|
|
|
NameOut += (D->isInstanceMethod() ? '-' : '+');
|
2008-11-24 11:33:13 +08:00
|
|
|
NameOut += '[';
|
2009-01-11 05:06:09 +08:00
|
|
|
assert (CD && "Missing container decl in GetNameForMethod");
|
|
|
|
NameOut += CD->getNameAsString();
|
2009-01-27 07:49:05 +08:00
|
|
|
// FIXME. For a method in a category, (CAT_NAME) is inserted here.
|
|
|
|
// Right now! there is not enough info. to do this.
|
2008-11-24 11:33:13 +08:00
|
|
|
NameOut += ' ';
|
|
|
|
NameOut += D->getSelector().getAsString();
|
|
|
|
NameOut += ']';
|
2008-08-16 11:19:19 +08:00
|
|
|
}
|
|
|
|
|
2009-01-29 03:12:34 +08:00
|
|
|
/// GetFirstIvarInRecord - This routine returns the record for the
|
|
|
|
/// implementation of the fiven class OID. It also returns field
|
|
|
|
/// corresponding to the first ivar in the class in FIV. It also
|
|
|
|
/// returns the one before the first ivar.
|
|
|
|
///
|
|
|
|
const RecordDecl *CGObjCCommonMac::GetFirstIvarInRecord(
|
|
|
|
const ObjCInterfaceDecl *OID,
|
|
|
|
RecordDecl::field_iterator &FIV,
|
|
|
|
RecordDecl::field_iterator &PIV) {
|
2009-04-10 05:40:53 +08:00
|
|
|
int countSuperClassIvars = countInheritedIvars(OID->getSuperClass(),
|
|
|
|
CGM.getContext());
|
2009-01-29 03:12:34 +08:00
|
|
|
const RecordDecl *RD = CGM.getContext().addRecordToClass(OID);
|
2009-04-10 05:40:53 +08:00
|
|
|
RecordDecl::field_iterator ifield = RD->field_begin(CGM.getContext());
|
|
|
|
RecordDecl::field_iterator pfield = RD->field_end(CGM.getContext());
|
2009-01-29 03:12:34 +08:00
|
|
|
while (countSuperClassIvars-- > 0) {
|
|
|
|
pfield = ifield;
|
|
|
|
++ifield;
|
|
|
|
}
|
|
|
|
FIV = ifield;
|
|
|
|
PIV = pfield;
|
|
|
|
return RD;
|
|
|
|
}
|
|
|
|
|
2008-08-12 05:35:06 +08:00
|
|
|
void CGObjCMac::FinishModule() {
|
2008-08-12 14:48:42 +08:00
|
|
|
EmitModuleInfo();
|
|
|
|
|
2008-10-30 06:36:39 +08:00
|
|
|
// Emit the dummy bodies for any protocols which were referenced but
|
|
|
|
// never defined.
|
|
|
|
for (llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*>::iterator
|
|
|
|
i = Protocols.begin(), e = Protocols.end(); i != e; ++i) {
|
|
|
|
if (i->second->hasInitializer())
|
|
|
|
continue;
|
2008-08-12 14:48:42 +08:00
|
|
|
|
2008-10-30 06:36:39 +08:00
|
|
|
std::vector<llvm::Constant*> Values(5);
|
|
|
|
Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
|
|
|
|
Values[1] = GetClassName(i->first);
|
|
|
|
Values[2] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
|
|
|
|
Values[3] = Values[4] =
|
|
|
|
llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy);
|
|
|
|
i->second->setLinkage(llvm::GlobalValue::InternalLinkage);
|
|
|
|
i->second->setInitializer(llvm::ConstantStruct::get(ObjCTypes.ProtocolTy,
|
|
|
|
Values));
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<llvm::Constant*> Used;
|
2008-08-12 14:48:42 +08:00
|
|
|
for (std::vector<llvm::GlobalVariable*>::iterator i = UsedGlobals.begin(),
|
2008-08-12 05:35:06 +08:00
|
|
|
e = UsedGlobals.end(); i != e; ++i) {
|
2008-08-21 12:36:09 +08:00
|
|
|
Used.push_back(llvm::ConstantExpr::getBitCast(*i, ObjCTypes.Int8PtrTy));
|
2008-08-12 05:35:06 +08:00
|
|
|
}
|
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy, Used.size());
|
2008-08-12 05:35:06 +08:00
|
|
|
llvm::GlobalValue *GV =
|
|
|
|
new llvm::GlobalVariable(AT, false,
|
|
|
|
llvm::GlobalValue::AppendingLinkage,
|
|
|
|
llvm::ConstantArray::get(AT, Used),
|
|
|
|
"llvm.used",
|
|
|
|
&CGM.getModule());
|
|
|
|
|
|
|
|
GV->setSection("llvm.metadata");
|
2008-08-25 14:02:07 +08:00
|
|
|
|
|
|
|
// Add assembler directives to add lazy undefined symbol references
|
|
|
|
// for classes which are referenced but not defined. This is
|
|
|
|
// important for correct linker interaction.
|
|
|
|
|
|
|
|
// FIXME: Uh, this isn't particularly portable.
|
|
|
|
std::stringstream s;
|
2008-12-10 10:21:04 +08:00
|
|
|
|
|
|
|
if (!CGM.getModule().getModuleInlineAsm().empty())
|
|
|
|
s << "\n";
|
|
|
|
|
2008-08-25 14:02:07 +08:00
|
|
|
for (std::set<IdentifierInfo*>::iterator i = LazySymbols.begin(),
|
|
|
|
e = LazySymbols.end(); i != e; ++i) {
|
|
|
|
s << "\t.lazy_reference .objc_class_name_" << (*i)->getName() << "\n";
|
|
|
|
}
|
|
|
|
for (std::set<IdentifierInfo*>::iterator i = DefinedSymbols.begin(),
|
|
|
|
e = DefinedSymbols.end(); i != e; ++i) {
|
2008-08-28 12:38:10 +08:00
|
|
|
s << "\t.objc_class_name_" << (*i)->getName() << "=0\n"
|
2008-08-25 14:02:07 +08:00
|
|
|
<< "\t.globl .objc_class_name_" << (*i)->getName() << "\n";
|
|
|
|
}
|
2008-12-10 10:21:04 +08:00
|
|
|
|
2008-08-25 14:02:07 +08:00
|
|
|
CGM.getModule().appendModuleInlineAsm(s.str());
|
2008-08-12 05:35:06 +08:00
|
|
|
}
|
|
|
|
|
2009-01-23 07:02:58 +08:00
|
|
|
CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm)
|
2009-01-22 06:04:16 +08:00
|
|
|
: CGObjCCommonMac(cgm),
|
|
|
|
ObjCTypes(cgm)
|
|
|
|
{
|
2009-01-24 07:53:38 +08:00
|
|
|
ObjCEmptyCacheVar = ObjCEmptyVtableVar = NULL;
|
2009-01-22 06:04:16 +08:00
|
|
|
ObjCABI = 2;
|
|
|
|
}
|
|
|
|
|
2008-08-12 05:35:06 +08:00
|
|
|
/* *** */
|
|
|
|
|
2009-01-22 06:04:16 +08:00
|
|
|
ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
|
|
|
|
: CGM(cgm)
|
2008-08-12 08:12:39 +08:00
|
|
|
{
|
2008-08-12 14:48:42 +08:00
|
|
|
CodeGen::CodeGenTypes &Types = CGM.getTypes();
|
|
|
|
ASTContext &Ctx = CGM.getContext();
|
2009-01-22 06:04:16 +08:00
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
ShortTy = Types.ConvertType(Ctx.ShortTy);
|
2008-08-13 11:21:16 +08:00
|
|
|
IntTy = Types.ConvertType(Ctx.IntTy);
|
2008-08-12 14:48:42 +08:00
|
|
|
LongTy = Types.ConvertType(Ctx.LongTy);
|
2009-03-24 03:10:40 +08:00
|
|
|
LongLongTy = Types.ConvertType(Ctx.LongLongTy);
|
2008-08-21 12:36:09 +08:00
|
|
|
Int8PtrTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
|
|
|
|
|
2008-08-12 14:48:42 +08:00
|
|
|
ObjectPtrTy = Types.ConvertType(Ctx.getObjCIdType());
|
2008-11-19 04:18:11 +08:00
|
|
|
PtrObjectPtrTy = llvm::PointerType::getUnqual(ObjectPtrTy);
|
2008-08-12 14:48:42 +08:00
|
|
|
SelectorPtrTy = Types.ConvertType(Ctx.getObjCSelType());
|
2008-08-13 11:21:16 +08:00
|
|
|
|
|
|
|
// FIXME: It would be nice to unify this with the opaque type, so
|
|
|
|
// that the IR comes out a bit cleaner.
|
|
|
|
const llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType());
|
|
|
|
ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T);
|
2009-01-22 06:04:16 +08:00
|
|
|
|
|
|
|
// I'm not sure I like this. The implicit coordination is a bit
|
|
|
|
// gross. We should solve this in a reasonable fashion because this
|
|
|
|
// is a pretty common task (match some runtime data structure with
|
|
|
|
// an LLVM data structure).
|
|
|
|
|
|
|
|
// FIXME: This is leaked.
|
|
|
|
// FIXME: Merge with rewriter code?
|
|
|
|
|
|
|
|
// struct _objc_super {
|
|
|
|
// id self;
|
|
|
|
// Class cls;
|
|
|
|
// }
|
|
|
|
RecordDecl *RD = RecordDecl::Create(Ctx, TagDecl::TK_struct, 0,
|
|
|
|
SourceLocation(),
|
|
|
|
&Ctx.Idents.get("_objc_super"));
|
2009-04-10 05:40:53 +08:00
|
|
|
RD->addDecl(Ctx, FieldDecl::Create(Ctx, RD, SourceLocation(), 0,
|
|
|
|
Ctx.getObjCIdType(), 0, false));
|
|
|
|
RD->addDecl(Ctx, FieldDecl::Create(Ctx, RD, SourceLocation(), 0,
|
|
|
|
Ctx.getObjCClassType(), 0, false));
|
2009-01-22 06:04:16 +08:00
|
|
|
RD->completeDefinition(Ctx);
|
|
|
|
|
|
|
|
SuperCTy = Ctx.getTagDeclType(RD);
|
|
|
|
SuperPtrCTy = Ctx.getPointerType(SuperCTy);
|
|
|
|
|
|
|
|
SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy));
|
2009-01-22 08:37:21 +08:00
|
|
|
SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);
|
|
|
|
|
2009-01-23 07:02:58 +08:00
|
|
|
// struct _prop_t {
|
|
|
|
// char *name;
|
|
|
|
// char *attributes;
|
|
|
|
// }
|
|
|
|
PropertyTy = llvm::StructType::get(Int8PtrTy,
|
|
|
|
Int8PtrTy,
|
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._prop_t",
|
|
|
|
PropertyTy);
|
|
|
|
|
|
|
|
// struct _prop_list_t {
|
2009-01-23 09:46:23 +08:00
|
|
|
// uint32_t entsize; // sizeof(struct _prop_t)
|
2009-01-23 07:02:58 +08:00
|
|
|
// uint32_t count_of_properties;
|
2009-01-23 09:46:23 +08:00
|
|
|
// struct _prop_t prop_list[count_of_properties];
|
2009-01-23 07:02:58 +08:00
|
|
|
// }
|
|
|
|
PropertyListTy = llvm::StructType::get(IntTy,
|
|
|
|
IntTy,
|
|
|
|
llvm::ArrayType::get(PropertyTy, 0),
|
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._prop_list_t",
|
|
|
|
PropertyListTy);
|
|
|
|
// struct _prop_list_t *
|
|
|
|
PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
|
|
|
|
|
|
|
|
// struct _objc_method {
|
|
|
|
// SEL _cmd;
|
|
|
|
// char *method_type;
|
|
|
|
// char *_imp;
|
|
|
|
// }
|
|
|
|
MethodTy = llvm::StructType::get(SelectorPtrTy,
|
|
|
|
Int8PtrTy,
|
|
|
|
Int8PtrTy,
|
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._objc_method", MethodTy);
|
2009-01-23 09:46:23 +08:00
|
|
|
|
|
|
|
// struct _objc_cache *
|
|
|
|
CacheTy = llvm::OpaqueType::get();
|
|
|
|
CGM.getModule().addTypeName("struct._objc_cache", CacheTy);
|
|
|
|
CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
|
2009-01-23 07:02:58 +08:00
|
|
|
|
2009-01-22 08:37:21 +08:00
|
|
|
// Property manipulation functions.
|
2009-02-04 08:44:42 +08:00
|
|
|
|
|
|
|
QualType IdType = Ctx.getObjCIdType();
|
|
|
|
QualType SelType = Ctx.getObjCSelType();
|
|
|
|
llvm::SmallVector<QualType,16> Params;
|
|
|
|
const llvm::FunctionType *FTy;
|
2009-01-22 08:37:21 +08:00
|
|
|
|
|
|
|
// id objc_getProperty (id, SEL, ptrdiff_t, bool)
|
2009-02-04 08:44:42 +08:00
|
|
|
Params.push_back(IdType);
|
|
|
|
Params.push_back(SelType);
|
|
|
|
Params.push_back(Ctx.LongTy);
|
|
|
|
Params.push_back(Ctx.BoolTy);
|
|
|
|
FTy = Types.GetFunctionType(Types.getFunctionInfo(IdType, Params),
|
|
|
|
false);
|
|
|
|
GetPropertyFn = CGM.CreateRuntimeFunction(FTy, "objc_getProperty");
|
2009-01-22 08:37:21 +08:00
|
|
|
|
|
|
|
// void objc_setProperty (id, SEL, ptrdiff_t, id, bool, bool)
|
|
|
|
Params.clear();
|
2009-02-04 08:44:42 +08:00
|
|
|
Params.push_back(IdType);
|
|
|
|
Params.push_back(SelType);
|
|
|
|
Params.push_back(Ctx.LongTy);
|
|
|
|
Params.push_back(IdType);
|
|
|
|
Params.push_back(Ctx.BoolTy);
|
|
|
|
Params.push_back(Ctx.BoolTy);
|
|
|
|
FTy = Types.GetFunctionType(Types.getFunctionInfo(Ctx.VoidTy, Params), false);
|
|
|
|
SetPropertyFn = CGM.CreateRuntimeFunction(FTy, "objc_setProperty");
|
|
|
|
|
2009-01-22 08:37:21 +08:00
|
|
|
// Enumeration mutation.
|
2009-02-04 08:44:42 +08:00
|
|
|
|
|
|
|
// void objc_enumerationMutation (id)
|
2009-01-22 08:37:21 +08:00
|
|
|
Params.clear();
|
2009-02-04 08:44:42 +08:00
|
|
|
Params.push_back(IdType);
|
|
|
|
FTy = Types.GetFunctionType(Types.getFunctionInfo(Ctx.VoidTy, Params), false);
|
|
|
|
EnumerationMutationFn = CGM.CreateRuntimeFunction(FTy,
|
|
|
|
"objc_enumerationMutation");
|
2009-01-22 08:37:21 +08:00
|
|
|
|
|
|
|
// gc's API
|
|
|
|
// id objc_read_weak (id *)
|
|
|
|
Params.clear();
|
2009-02-04 08:44:42 +08:00
|
|
|
Params.push_back(Ctx.getPointerType(IdType));
|
|
|
|
FTy = Types.GetFunctionType(Types.getFunctionInfo(IdType, Params), false);
|
|
|
|
GcReadWeakFn = CGM.CreateRuntimeFunction(FTy, "objc_read_weak");
|
|
|
|
|
|
|
|
// id objc_assign_weak (id, id *)
|
2009-01-22 08:37:21 +08:00
|
|
|
Params.clear();
|
2009-02-04 08:44:42 +08:00
|
|
|
Params.push_back(IdType);
|
|
|
|
Params.push_back(Ctx.getPointerType(IdType));
|
|
|
|
|
|
|
|
FTy = Types.GetFunctionType(Types.getFunctionInfo(IdType, Params), false);
|
|
|
|
GcAssignWeakFn = CGM.CreateRuntimeFunction(FTy, "objc_assign_weak");
|
|
|
|
GcAssignGlobalFn = CGM.CreateRuntimeFunction(FTy, "objc_assign_global");
|
|
|
|
GcAssignIvarFn = CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar");
|
|
|
|
GcAssignStrongCastFn =
|
|
|
|
CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast");
|
2009-02-17 06:59:18 +08:00
|
|
|
|
|
|
|
// void objc_exception_throw(id)
|
|
|
|
Params.clear();
|
|
|
|
Params.push_back(IdType);
|
|
|
|
|
|
|
|
FTy = Types.GetFunctionType(Types.getFunctionInfo(Ctx.VoidTy, Params), false);
|
|
|
|
ExceptionThrowFn =
|
|
|
|
CGM.CreateRuntimeFunction(FTy, "objc_exception_throw");
|
2009-02-24 09:43:46 +08:00
|
|
|
|
|
|
|
// synchronized APIs
|
|
|
|
// void objc_sync_exit (id)
|
|
|
|
Params.clear();
|
|
|
|
Params.push_back(IdType);
|
|
|
|
|
|
|
|
FTy = Types.GetFunctionType(Types.getFunctionInfo(Ctx.VoidTy, Params), false);
|
|
|
|
SyncExitFn = CGM.CreateRuntimeFunction(FTy, "objc_sync_exit");
|
2009-01-22 06:04:16 +08:00
|
|
|
}
|
2008-08-12 14:48:42 +08:00
|
|
|
|
2009-01-22 06:04:16 +08:00
|
|
|
ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
|
|
|
|
: ObjCCommonTypesHelper(cgm)
|
|
|
|
{
|
2009-01-21 08:39:53 +08:00
|
|
|
// struct _objc_method_description {
|
|
|
|
// SEL name;
|
|
|
|
// char *types;
|
|
|
|
// }
|
2008-08-13 11:21:16 +08:00
|
|
|
MethodDescriptionTy =
|
|
|
|
llvm::StructType::get(SelectorPtrTy,
|
2008-08-21 12:36:09 +08:00
|
|
|
Int8PtrTy,
|
2008-08-13 11:21:16 +08:00
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._objc_method_description",
|
|
|
|
MethodDescriptionTy);
|
|
|
|
|
2009-01-21 08:39:53 +08:00
|
|
|
// struct _objc_method_description_list {
|
|
|
|
// int count;
|
|
|
|
// struct _objc_method_description[1];
|
|
|
|
// }
|
2008-08-13 11:21:16 +08:00
|
|
|
MethodDescriptionListTy =
|
|
|
|
llvm::StructType::get(IntTy,
|
|
|
|
llvm::ArrayType::get(MethodDescriptionTy, 0),
|
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._objc_method_description_list",
|
|
|
|
MethodDescriptionListTy);
|
2009-01-21 08:39:53 +08:00
|
|
|
|
|
|
|
// struct _objc_method_description_list *
|
2008-08-13 11:21:16 +08:00
|
|
|
MethodDescriptionListPtrTy =
|
|
|
|
llvm::PointerType::getUnqual(MethodDescriptionListTy);
|
|
|
|
|
|
|
|
// Protocol description structures
|
|
|
|
|
2009-01-21 08:39:53 +08:00
|
|
|
// struct _objc_protocol_extension {
|
|
|
|
// uint32_t size; // sizeof(struct _objc_protocol_extension)
|
|
|
|
// struct _objc_method_description_list *optional_instance_methods;
|
|
|
|
// struct _objc_method_description_list *optional_class_methods;
|
|
|
|
// struct _objc_property_list *instance_properties;
|
|
|
|
// }
|
2008-08-13 11:21:16 +08:00
|
|
|
ProtocolExtensionTy =
|
2009-01-21 08:39:53 +08:00
|
|
|
llvm::StructType::get(IntTy,
|
|
|
|
MethodDescriptionListPtrTy,
|
|
|
|
MethodDescriptionListPtrTy,
|
2008-08-13 11:21:16 +08:00
|
|
|
PropertyListPtrTy,
|
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._objc_protocol_extension",
|
|
|
|
ProtocolExtensionTy);
|
2009-01-21 08:39:53 +08:00
|
|
|
|
|
|
|
// struct _objc_protocol_extension *
|
2008-08-13 11:21:16 +08:00
|
|
|
ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);
|
|
|
|
|
2008-10-30 06:36:39 +08:00
|
|
|
// Handle recursive construction of Protocol and ProtocolList types
|
2008-08-13 11:21:16 +08:00
|
|
|
|
|
|
|
llvm::PATypeHolder ProtocolTyHolder = llvm::OpaqueType::get();
|
|
|
|
llvm::PATypeHolder ProtocolListTyHolder = llvm::OpaqueType::get();
|
|
|
|
|
2009-01-22 06:04:16 +08:00
|
|
|
const llvm::Type *T =
|
|
|
|
llvm::StructType::get(llvm::PointerType::getUnqual(ProtocolListTyHolder),
|
|
|
|
LongTy,
|
|
|
|
llvm::ArrayType::get(ProtocolTyHolder, 0),
|
|
|
|
NULL);
|
2008-08-13 11:21:16 +08:00
|
|
|
cast<llvm::OpaqueType>(ProtocolListTyHolder.get())->refineAbstractTypeTo(T);
|
|
|
|
|
2009-01-21 08:39:53 +08:00
|
|
|
// struct _objc_protocol {
|
|
|
|
// struct _objc_protocol_extension *isa;
|
|
|
|
// char *protocol_name;
|
|
|
|
// struct _objc_protocol **_objc_protocol_list;
|
|
|
|
// struct _objc_method_description_list *instance_methods;
|
|
|
|
// struct _objc_method_description_list *class_methods;
|
|
|
|
// }
|
|
|
|
T = llvm::StructType::get(ProtocolExtensionPtrTy,
|
2008-08-21 12:36:09 +08:00
|
|
|
Int8PtrTy,
|
2008-08-13 11:21:16 +08:00
|
|
|
llvm::PointerType::getUnqual(ProtocolListTyHolder),
|
|
|
|
MethodDescriptionListPtrTy,
|
|
|
|
MethodDescriptionListPtrTy,
|
|
|
|
NULL);
|
|
|
|
cast<llvm::OpaqueType>(ProtocolTyHolder.get())->refineAbstractTypeTo(T);
|
|
|
|
|
|
|
|
ProtocolListTy = cast<llvm::StructType>(ProtocolListTyHolder.get());
|
|
|
|
CGM.getModule().addTypeName("struct._objc_protocol_list",
|
|
|
|
ProtocolListTy);
|
2009-01-21 08:39:53 +08:00
|
|
|
// struct _objc_protocol_list *
|
2008-08-13 11:21:16 +08:00
|
|
|
ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);
|
|
|
|
|
|
|
|
ProtocolTy = cast<llvm::StructType>(ProtocolTyHolder.get());
|
2009-01-21 08:39:53 +08:00
|
|
|
CGM.getModule().addTypeName("struct._objc_protocol", ProtocolTy);
|
2008-08-13 11:21:16 +08:00
|
|
|
ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);
|
2008-08-21 12:36:09 +08:00
|
|
|
|
|
|
|
// Class description structures
|
|
|
|
|
2009-01-21 08:39:53 +08:00
|
|
|
// struct _objc_ivar {
|
|
|
|
// char *ivar_name;
|
|
|
|
// char *ivar_type;
|
|
|
|
// int ivar_offset;
|
|
|
|
// }
|
2008-08-21 12:36:09 +08:00
|
|
|
IvarTy = llvm::StructType::get(Int8PtrTy,
|
|
|
|
Int8PtrTy,
|
|
|
|
IntTy,
|
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._objc_ivar", IvarTy);
|
|
|
|
|
2009-01-21 08:39:53 +08:00
|
|
|
// struct _objc_ivar_list *
|
2008-08-21 12:36:09 +08:00
|
|
|
IvarListTy = llvm::OpaqueType::get();
|
|
|
|
CGM.getModule().addTypeName("struct._objc_ivar_list", IvarListTy);
|
|
|
|
IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);
|
|
|
|
|
2009-01-21 08:39:53 +08:00
|
|
|
// struct _objc_method_list *
|
2008-08-21 12:36:09 +08:00
|
|
|
MethodListTy = llvm::OpaqueType::get();
|
|
|
|
CGM.getModule().addTypeName("struct._objc_method_list", MethodListTy);
|
|
|
|
MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);
|
|
|
|
|
2009-01-21 08:39:53 +08:00
|
|
|
// struct _objc_class_extension *
|
2008-08-21 12:36:09 +08:00
|
|
|
ClassExtensionTy =
|
|
|
|
llvm::StructType::get(IntTy,
|
|
|
|
Int8PtrTy,
|
|
|
|
PropertyListPtrTy,
|
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._objc_class_extension", ClassExtensionTy);
|
|
|
|
ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);
|
|
|
|
|
|
|
|
llvm::PATypeHolder ClassTyHolder = llvm::OpaqueType::get();
|
|
|
|
|
2009-01-21 08:39:53 +08:00
|
|
|
// struct _objc_class {
|
|
|
|
// Class isa;
|
|
|
|
// Class super_class;
|
|
|
|
// char *name;
|
|
|
|
// long version;
|
|
|
|
// long info;
|
|
|
|
// long instance_size;
|
|
|
|
// struct _objc_ivar_list *ivars;
|
|
|
|
// struct _objc_method_list *methods;
|
|
|
|
// struct _objc_cache *cache;
|
|
|
|
// struct _objc_protocol_list *protocols;
|
|
|
|
// char *ivar_layout;
|
|
|
|
// struct _objc_class_ext *ext;
|
|
|
|
// };
|
2008-08-21 12:36:09 +08:00
|
|
|
T = llvm::StructType::get(llvm::PointerType::getUnqual(ClassTyHolder),
|
|
|
|
llvm::PointerType::getUnqual(ClassTyHolder),
|
|
|
|
Int8PtrTy,
|
|
|
|
LongTy,
|
|
|
|
LongTy,
|
|
|
|
LongTy,
|
|
|
|
IvarListPtrTy,
|
|
|
|
MethodListPtrTy,
|
|
|
|
CachePtrTy,
|
|
|
|
ProtocolListPtrTy,
|
|
|
|
Int8PtrTy,
|
|
|
|
ClassExtensionPtrTy,
|
|
|
|
NULL);
|
|
|
|
cast<llvm::OpaqueType>(ClassTyHolder.get())->refineAbstractTypeTo(T);
|
|
|
|
|
|
|
|
ClassTy = cast<llvm::StructType>(ClassTyHolder.get());
|
|
|
|
CGM.getModule().addTypeName("struct._objc_class", ClassTy);
|
|
|
|
ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);
|
|
|
|
|
2009-01-21 08:39:53 +08:00
|
|
|
// struct _objc_category {
|
|
|
|
// char *category_name;
|
|
|
|
// char *class_name;
|
|
|
|
// struct _objc_method_list *instance_method;
|
|
|
|
// struct _objc_method_list *class_method;
|
|
|
|
// uint32_t size; // sizeof(struct _objc_category)
|
|
|
|
// struct _objc_property_list *instance_properties;// category's @property
|
|
|
|
// }
|
2008-08-23 04:34:54 +08:00
|
|
|
CategoryTy = llvm::StructType::get(Int8PtrTy,
|
|
|
|
Int8PtrTy,
|
|
|
|
MethodListPtrTy,
|
|
|
|
MethodListPtrTy,
|
|
|
|
ProtocolListPtrTy,
|
|
|
|
IntTy,
|
|
|
|
PropertyListPtrTy,
|
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._objc_category", CategoryTy);
|
|
|
|
|
2008-08-21 12:36:09 +08:00
|
|
|
// Global metadata structures
|
|
|
|
|
2009-01-21 08:39:53 +08:00
|
|
|
// struct _objc_symtab {
|
|
|
|
// long sel_ref_cnt;
|
|
|
|
// SEL *refs;
|
|
|
|
// short cls_def_cnt;
|
|
|
|
// short cat_def_cnt;
|
|
|
|
// char *defs[cls_def_cnt + cat_def_cnt];
|
|
|
|
// }
|
2008-08-21 12:36:09 +08:00
|
|
|
SymtabTy = llvm::StructType::get(LongTy,
|
|
|
|
SelectorPtrTy,
|
|
|
|
ShortTy,
|
|
|
|
ShortTy,
|
2008-08-23 04:34:54 +08:00
|
|
|
llvm::ArrayType::get(Int8PtrTy, 0),
|
2008-08-21 12:36:09 +08:00
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._objc_symtab", SymtabTy);
|
|
|
|
SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);
|
|
|
|
|
2009-01-22 08:37:21 +08:00
|
|
|
// struct _objc_module {
|
|
|
|
// long version;
|
|
|
|
// long size; // sizeof(struct _objc_module)
|
|
|
|
// char *name;
|
|
|
|
// struct _objc_symtab* symtab;
|
|
|
|
// }
|
2008-08-21 12:36:09 +08:00
|
|
|
ModuleTy =
|
|
|
|
llvm::StructType::get(LongTy,
|
|
|
|
LongTy,
|
|
|
|
Int8PtrTy,
|
|
|
|
SymtabPtrTy,
|
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._objc_module", ModuleTy);
|
2008-08-23 17:25:55 +08:00
|
|
|
|
2008-09-24 11:38:44 +08:00
|
|
|
// Message send functions.
|
2008-08-23 17:25:55 +08:00
|
|
|
|
2009-01-22 08:37:21 +08:00
|
|
|
// id objc_msgSend (id, SEL, ...)
|
2008-08-23 17:25:55 +08:00
|
|
|
std::vector<const llvm::Type*> Params;
|
|
|
|
Params.push_back(ObjectPtrTy);
|
|
|
|
Params.push_back(SelectorPtrTy);
|
2008-10-01 09:06:06 +08:00
|
|
|
MessageSendFn =
|
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
|
|
|
|
Params,
|
|
|
|
true),
|
|
|
|
"objc_msgSend");
|
2008-08-23 17:25:55 +08:00
|
|
|
|
2009-01-22 08:37:21 +08:00
|
|
|
// id objc_msgSend_stret (id, SEL, ...)
|
2008-08-23 17:25:55 +08:00
|
|
|
Params.clear();
|
|
|
|
Params.push_back(ObjectPtrTy);
|
|
|
|
Params.push_back(SelectorPtrTy);
|
|
|
|
MessageSendStretFn =
|
2008-10-01 09:06:06 +08:00
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::VoidTy,
|
|
|
|
Params,
|
|
|
|
true),
|
|
|
|
"objc_msgSend_stret");
|
2008-10-17 11:24:53 +08:00
|
|
|
|
2009-01-22 08:37:21 +08:00
|
|
|
//
|
2008-10-17 11:24:53 +08:00
|
|
|
Params.clear();
|
|
|
|
Params.push_back(ObjectPtrTy);
|
|
|
|
Params.push_back(SelectorPtrTy);
|
|
|
|
// FIXME: This should be long double on x86_64?
|
2009-01-22 08:37:21 +08:00
|
|
|
// [double | long double] objc_msgSend_fpret(id self, SEL op, ...)
|
2008-10-17 11:24:53 +08:00
|
|
|
MessageSendFpretFn =
|
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::DoubleTy,
|
|
|
|
Params,
|
|
|
|
true),
|
|
|
|
"objc_msgSend_fpret");
|
2008-08-23 17:25:55 +08:00
|
|
|
|
2009-01-22 08:37:21 +08:00
|
|
|
// id objc_msgSendSuper(struct objc_super *super, SEL op, ...)
|
2008-08-23 17:25:55 +08:00
|
|
|
Params.clear();
|
|
|
|
Params.push_back(SuperPtrTy);
|
|
|
|
Params.push_back(SelectorPtrTy);
|
|
|
|
MessageSendSuperFn =
|
2008-10-01 09:06:06 +08:00
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
|
|
|
|
Params,
|
|
|
|
true),
|
|
|
|
"objc_msgSendSuper");
|
2008-08-23 17:25:55 +08:00
|
|
|
|
2009-01-22 08:37:21 +08:00
|
|
|
// void objc_msgSendSuper_stret(void * stretAddr, struct objc_super *super,
|
|
|
|
// SEL op, ...)
|
2008-08-23 17:25:55 +08:00
|
|
|
Params.clear();
|
|
|
|
Params.push_back(Int8PtrTy);
|
|
|
|
Params.push_back(SuperPtrTy);
|
|
|
|
Params.push_back(SelectorPtrTy);
|
|
|
|
MessageSendSuperStretFn =
|
2008-10-01 09:06:06 +08:00
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::VoidTy,
|
|
|
|
Params,
|
|
|
|
true),
|
|
|
|
"objc_msgSendSuper_stret");
|
2008-10-17 11:24:53 +08:00
|
|
|
|
|
|
|
// There is no objc_msgSendSuper_fpret? How can that work?
|
|
|
|
MessageSendSuperFpretFn = MessageSendSuperFn;
|
2008-08-31 12:05:03 +08:00
|
|
|
|
2008-09-09 18:10:21 +08:00
|
|
|
// FIXME: This is the size of the setjmp buffer and should be
|
|
|
|
// target specific. 18 is what's used on 32-bit X86.
|
|
|
|
uint64_t SetJmpBufferSize = 18;
|
|
|
|
|
|
|
|
// Exceptions
|
|
|
|
const llvm::Type *StackPtrTy =
|
2008-09-27 14:32:25 +08:00
|
|
|
llvm::ArrayType::get(llvm::PointerType::getUnqual(llvm::Type::Int8Ty), 4);
|
2008-09-09 18:10:21 +08:00
|
|
|
|
|
|
|
ExceptionDataTy =
|
|
|
|
llvm::StructType::get(llvm::ArrayType::get(llvm::Type::Int32Ty,
|
|
|
|
SetJmpBufferSize),
|
|
|
|
StackPtrTy, NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._objc_exception_data",
|
|
|
|
ExceptionDataTy);
|
|
|
|
|
|
|
|
Params.clear();
|
|
|
|
Params.push_back(llvm::PointerType::getUnqual(ExceptionDataTy));
|
|
|
|
ExceptionTryEnterFn =
|
2008-10-01 09:06:06 +08:00
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::VoidTy,
|
|
|
|
Params,
|
|
|
|
false),
|
|
|
|
"objc_exception_try_enter");
|
2008-09-09 18:10:21 +08:00
|
|
|
ExceptionTryExitFn =
|
2008-10-01 09:06:06 +08:00
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::VoidTy,
|
|
|
|
Params,
|
|
|
|
false),
|
|
|
|
"objc_exception_try_exit");
|
2008-09-09 18:10:21 +08:00
|
|
|
ExceptionExtractFn =
|
2008-10-01 09:06:06 +08:00
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
|
|
|
|
Params,
|
|
|
|
false),
|
|
|
|
"objc_exception_extract");
|
2008-09-09 18:10:21 +08:00
|
|
|
|
|
|
|
Params.clear();
|
|
|
|
Params.push_back(ClassPtrTy);
|
|
|
|
Params.push_back(ObjectPtrTy);
|
|
|
|
ExceptionMatchFn =
|
2008-10-01 09:06:06 +08:00
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::Int32Ty,
|
|
|
|
Params,
|
|
|
|
false),
|
|
|
|
"objc_exception_match");
|
2008-11-16 05:26:17 +08:00
|
|
|
|
2008-09-09 18:10:21 +08:00
|
|
|
Params.clear();
|
|
|
|
Params.push_back(llvm::PointerType::getUnqual(llvm::Type::Int32Ty));
|
|
|
|
SetJmpFn =
|
2008-10-01 09:06:06 +08:00
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::Int32Ty,
|
|
|
|
Params,
|
|
|
|
false),
|
|
|
|
"_setjmp");
|
2008-11-19 04:18:11 +08:00
|
|
|
|
2008-08-12 08:12:39 +08:00
|
|
|
}
|
|
|
|
|
2009-01-23 07:02:58 +08:00
|
|
|
ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm)
|
2009-01-22 06:04:16 +08:00
|
|
|
: ObjCCommonTypesHelper(cgm)
|
|
|
|
{
|
2009-01-23 07:02:58 +08:00
|
|
|
// struct _method_list_t {
|
|
|
|
// uint32_t entsize; // sizeof(struct _objc_method)
|
|
|
|
// uint32_t method_count;
|
|
|
|
// struct _objc_method method_list[method_count];
|
|
|
|
// }
|
2009-01-23 09:46:23 +08:00
|
|
|
MethodListnfABITy = llvm::StructType::get(IntTy,
|
|
|
|
IntTy,
|
|
|
|
llvm::ArrayType::get(MethodTy, 0),
|
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct.__method_list_t",
|
|
|
|
MethodListnfABITy);
|
|
|
|
// struct method_list_t *
|
|
|
|
MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy);
|
2009-01-23 07:02:58 +08:00
|
|
|
|
|
|
|
// struct _protocol_t {
|
|
|
|
// id isa; // NULL
|
|
|
|
// const char * const protocol_name;
|
2009-01-23 09:46:23 +08:00
|
|
|
// const struct _protocol_list_t * protocol_list; // super protocols
|
2009-01-23 07:02:58 +08:00
|
|
|
// const struct method_list_t * const instance_methods;
|
|
|
|
// const struct method_list_t * const class_methods;
|
|
|
|
// const struct method_list_t *optionalInstanceMethods;
|
|
|
|
// const struct method_list_t *optionalClassMethods;
|
2009-01-23 09:46:23 +08:00
|
|
|
// const struct _prop_list_t * properties;
|
2009-01-23 07:02:58 +08:00
|
|
|
// const uint32_t size; // sizeof(struct _protocol_t)
|
|
|
|
// const uint32_t flags; // = 0
|
|
|
|
// }
|
|
|
|
|
2009-01-23 09:46:23 +08:00
|
|
|
// Holder for struct _protocol_list_t *
|
|
|
|
llvm::PATypeHolder ProtocolListTyHolder = llvm::OpaqueType::get();
|
|
|
|
|
|
|
|
ProtocolnfABITy = llvm::StructType::get(ObjectPtrTy,
|
|
|
|
Int8PtrTy,
|
|
|
|
llvm::PointerType::getUnqual(
|
|
|
|
ProtocolListTyHolder),
|
|
|
|
MethodListnfABIPtrTy,
|
|
|
|
MethodListnfABIPtrTy,
|
|
|
|
MethodListnfABIPtrTy,
|
|
|
|
MethodListnfABIPtrTy,
|
|
|
|
PropertyListPtrTy,
|
|
|
|
IntTy,
|
|
|
|
IntTy,
|
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._protocol_t",
|
|
|
|
ProtocolnfABITy);
|
2009-02-15 15:36:20 +08:00
|
|
|
|
|
|
|
// struct _protocol_t*
|
|
|
|
ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy);
|
2009-01-23 09:46:23 +08:00
|
|
|
|
2009-01-30 03:24:30 +08:00
|
|
|
// struct _protocol_list_t {
|
2009-01-23 09:46:23 +08:00
|
|
|
// long protocol_count; // Note, this is 32/64 bit
|
2009-02-15 15:36:20 +08:00
|
|
|
// struct _protocol_t *[protocol_count];
|
2009-01-23 07:02:58 +08:00
|
|
|
// }
|
2009-01-23 09:46:23 +08:00
|
|
|
ProtocolListnfABITy = llvm::StructType::get(LongTy,
|
|
|
|
llvm::ArrayType::get(
|
2009-02-15 15:36:20 +08:00
|
|
|
ProtocolnfABIPtrTy, 0),
|
2009-01-23 09:46:23 +08:00
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._objc_protocol_list",
|
|
|
|
ProtocolListnfABITy);
|
2009-02-15 15:36:20 +08:00
|
|
|
cast<llvm::OpaqueType>(ProtocolListTyHolder.get())->refineAbstractTypeTo(
|
|
|
|
ProtocolListnfABITy);
|
2009-01-23 09:46:23 +08:00
|
|
|
|
|
|
|
// struct _objc_protocol_list*
|
|
|
|
ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy);
|
2009-01-23 07:02:58 +08:00
|
|
|
|
|
|
|
// struct _ivar_t {
|
|
|
|
// unsigned long int *offset; // pointer to ivar offset location
|
|
|
|
// char *name;
|
|
|
|
// char *type;
|
|
|
|
// uint32_t alignment;
|
|
|
|
// uint32_t size;
|
|
|
|
// }
|
2009-01-23 09:46:23 +08:00
|
|
|
IvarnfABITy = llvm::StructType::get(llvm::PointerType::getUnqual(LongTy),
|
|
|
|
Int8PtrTy,
|
|
|
|
Int8PtrTy,
|
|
|
|
IntTy,
|
|
|
|
IntTy,
|
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._ivar_t", IvarnfABITy);
|
|
|
|
|
2009-01-23 07:02:58 +08:00
|
|
|
// struct _ivar_list_t {
|
|
|
|
// uint32 entsize; // sizeof(struct _ivar_t)
|
|
|
|
// uint32 count;
|
|
|
|
// struct _iver_t list[count];
|
|
|
|
// }
|
2009-01-25 04:21:50 +08:00
|
|
|
IvarListnfABITy = llvm::StructType::get(IntTy,
|
|
|
|
IntTy,
|
|
|
|
llvm::ArrayType::get(
|
|
|
|
IvarnfABITy, 0),
|
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._ivar_list_t", IvarListnfABITy);
|
|
|
|
|
|
|
|
IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy);
|
2009-01-23 09:46:23 +08:00
|
|
|
|
|
|
|
// struct _class_ro_t {
|
2009-01-23 07:02:58 +08:00
|
|
|
// uint32_t const flags;
|
|
|
|
// uint32_t const instanceStart;
|
|
|
|
// uint32_t const instanceSize;
|
|
|
|
// uint32_t const reserved; // only when building for 64bit targets
|
|
|
|
// const uint8_t * const ivarLayout;
|
|
|
|
// const char *const name;
|
|
|
|
// const struct _method_list_t * const baseMethods;
|
|
|
|
// const struct _objc_protocol_list *const baseProtocols;
|
|
|
|
// const struct _ivar_list_t *const ivars;
|
|
|
|
// const uint8_t * const weakIvarLayout;
|
|
|
|
// const struct _prop_list_t * const properties;
|
|
|
|
// }
|
2009-01-23 09:46:23 +08:00
|
|
|
|
|
|
|
// FIXME. Add 'reserved' field in 64bit abi mode!
|
|
|
|
ClassRonfABITy = llvm::StructType::get(IntTy,
|
|
|
|
IntTy,
|
|
|
|
IntTy,
|
|
|
|
Int8PtrTy,
|
|
|
|
Int8PtrTy,
|
|
|
|
MethodListnfABIPtrTy,
|
|
|
|
ProtocolListnfABIPtrTy,
|
|
|
|
IvarListnfABIPtrTy,
|
|
|
|
Int8PtrTy,
|
|
|
|
PropertyListPtrTy,
|
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._class_ro_t",
|
|
|
|
ClassRonfABITy);
|
|
|
|
|
|
|
|
// ImpnfABITy - LLVM for id (*)(id, SEL, ...)
|
|
|
|
std::vector<const llvm::Type*> Params;
|
|
|
|
Params.push_back(ObjectPtrTy);
|
|
|
|
Params.push_back(SelectorPtrTy);
|
|
|
|
ImpnfABITy = llvm::PointerType::getUnqual(
|
|
|
|
llvm::FunctionType::get(ObjectPtrTy, Params, false));
|
|
|
|
|
|
|
|
// struct _class_t {
|
|
|
|
// struct _class_t *isa;
|
|
|
|
// struct _class_t * const superclass;
|
|
|
|
// void *cache;
|
|
|
|
// IMP *vtable;
|
|
|
|
// struct class_ro_t *ro;
|
|
|
|
// }
|
|
|
|
|
|
|
|
llvm::PATypeHolder ClassTyHolder = llvm::OpaqueType::get();
|
|
|
|
ClassnfABITy = llvm::StructType::get(llvm::PointerType::getUnqual(ClassTyHolder),
|
|
|
|
llvm::PointerType::getUnqual(ClassTyHolder),
|
|
|
|
CachePtrTy,
|
|
|
|
llvm::PointerType::getUnqual(ImpnfABITy),
|
|
|
|
llvm::PointerType::getUnqual(
|
|
|
|
ClassRonfABITy),
|
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._class_t", ClassnfABITy);
|
|
|
|
|
|
|
|
cast<llvm::OpaqueType>(ClassTyHolder.get())->refineAbstractTypeTo(
|
|
|
|
ClassnfABITy);
|
|
|
|
|
2009-01-24 07:53:38 +08:00
|
|
|
// LLVM for struct _class_t *
|
|
|
|
ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy);
|
|
|
|
|
2009-01-23 09:46:23 +08:00
|
|
|
// struct _category_t {
|
|
|
|
// const char * const name;
|
|
|
|
// struct _class_t *const cls;
|
|
|
|
// const struct _method_list_t * const instance_methods;
|
|
|
|
// const struct _method_list_t * const class_methods;
|
|
|
|
// const struct _protocol_list_t * const protocols;
|
|
|
|
// const struct _prop_list_t * const properties;
|
2009-01-24 01:41:22 +08:00
|
|
|
// }
|
|
|
|
CategorynfABITy = llvm::StructType::get(Int8PtrTy,
|
2009-01-24 07:53:38 +08:00
|
|
|
ClassnfABIPtrTy,
|
2009-01-24 01:41:22 +08:00
|
|
|
MethodListnfABIPtrTy,
|
|
|
|
MethodListnfABIPtrTy,
|
|
|
|
ProtocolListnfABIPtrTy,
|
|
|
|
PropertyListPtrTy,
|
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._category_t", CategorynfABITy);
|
2009-02-04 07:49:23 +08:00
|
|
|
|
|
|
|
// New types for nonfragile abi messaging.
|
2009-02-05 04:42:28 +08:00
|
|
|
CodeGen::CodeGenTypes &Types = CGM.getTypes();
|
|
|
|
ASTContext &Ctx = CGM.getContext();
|
2009-02-04 07:49:23 +08:00
|
|
|
|
|
|
|
// MessageRefTy - LLVM for:
|
|
|
|
// struct _message_ref_t {
|
|
|
|
// IMP messenger;
|
|
|
|
// SEL name;
|
|
|
|
// };
|
2009-02-05 04:42:28 +08:00
|
|
|
|
|
|
|
// First the clang type for struct _message_ref_t
|
|
|
|
RecordDecl *RD = RecordDecl::Create(Ctx, TagDecl::TK_struct, 0,
|
|
|
|
SourceLocation(),
|
|
|
|
&Ctx.Idents.get("_message_ref_t"));
|
2009-04-10 05:40:53 +08:00
|
|
|
RD->addDecl(Ctx, FieldDecl::Create(Ctx, RD, SourceLocation(), 0,
|
|
|
|
Ctx.VoidPtrTy, 0, false));
|
|
|
|
RD->addDecl(Ctx, FieldDecl::Create(Ctx, RD, SourceLocation(), 0,
|
|
|
|
Ctx.getObjCSelType(), 0, false));
|
2009-02-05 04:42:28 +08:00
|
|
|
RD->completeDefinition(Ctx);
|
|
|
|
|
|
|
|
MessageRefCTy = Ctx.getTagDeclType(RD);
|
|
|
|
MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy);
|
|
|
|
MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy));
|
2009-02-04 07:49:23 +08:00
|
|
|
|
|
|
|
// MessageRefPtrTy - LLVM for struct _message_ref_t*
|
|
|
|
MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy);
|
|
|
|
|
|
|
|
// SuperMessageRefTy - LLVM for:
|
|
|
|
// struct _super_message_ref_t {
|
|
|
|
// SUPER_IMP messenger;
|
|
|
|
// SEL name;
|
|
|
|
// };
|
|
|
|
SuperMessageRefTy = llvm::StructType::get(ImpnfABITy,
|
|
|
|
SelectorPtrTy,
|
|
|
|
NULL);
|
|
|
|
CGM.getModule().addTypeName("struct._super_message_ref_t", SuperMessageRefTy);
|
|
|
|
|
|
|
|
// SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
|
|
|
|
SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy);
|
|
|
|
|
|
|
|
// id objc_msgSend_fixup (id, struct message_ref_t*, ...)
|
|
|
|
Params.clear();
|
|
|
|
Params.push_back(ObjectPtrTy);
|
|
|
|
Params.push_back(MessageRefPtrTy);
|
2009-02-05 09:13:09 +08:00
|
|
|
MessengerTy = llvm::FunctionType::get(ObjectPtrTy,
|
|
|
|
Params,
|
|
|
|
true);
|
2009-02-04 07:49:23 +08:00
|
|
|
MessageSendFixupFn =
|
2009-02-05 09:13:09 +08:00
|
|
|
CGM.CreateRuntimeFunction(MessengerTy,
|
2009-02-04 07:49:23 +08:00
|
|
|
"objc_msgSend_fixup");
|
|
|
|
|
|
|
|
// id objc_msgSend_fpret_fixup (id, struct message_ref_t*, ...)
|
|
|
|
MessageSendFpretFixupFn =
|
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
|
|
|
|
Params,
|
|
|
|
true),
|
|
|
|
"objc_msgSend_fpret_fixup");
|
|
|
|
|
|
|
|
// id objc_msgSend_stret_fixup (id, struct message_ref_t*, ...)
|
|
|
|
MessageSendStretFixupFn =
|
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
|
|
|
|
Params,
|
|
|
|
true),
|
|
|
|
"objc_msgSend_stret_fixup");
|
|
|
|
|
|
|
|
// id objc_msgSendId_fixup (id, struct message_ref_t*, ...)
|
|
|
|
MessageSendIdFixupFn =
|
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
|
|
|
|
Params,
|
|
|
|
true),
|
|
|
|
"objc_msgSendId_fixup");
|
|
|
|
|
|
|
|
|
|
|
|
// id objc_msgSendId_stret_fixup (id, struct message_ref_t*, ...)
|
|
|
|
MessageSendIdStretFixupFn =
|
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
|
|
|
|
Params,
|
|
|
|
true),
|
2009-02-05 04:42:28 +08:00
|
|
|
"objc_msgSendId_stret_fixup");
|
2009-02-04 07:49:23 +08:00
|
|
|
|
|
|
|
// id objc_msgSendSuper2_fixup (struct objc_super *,
|
|
|
|
// struct _super_message_ref_t*, ...)
|
|
|
|
Params.clear();
|
|
|
|
Params.push_back(SuperPtrTy);
|
|
|
|
Params.push_back(SuperMessageRefPtrTy);
|
|
|
|
MessageSendSuper2FixupFn =
|
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
|
|
|
|
Params,
|
|
|
|
true),
|
|
|
|
"objc_msgSendSuper2_fixup");
|
|
|
|
|
|
|
|
|
|
|
|
// id objc_msgSendSuper2_stret_fixup (struct objc_super *,
|
|
|
|
// struct _super_message_ref_t*, ...)
|
|
|
|
MessageSendSuper2StretFixupFn =
|
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
|
|
|
|
Params,
|
|
|
|
true),
|
|
|
|
"objc_msgSendSuper2_stret_fixup");
|
2009-02-24 15:47:38 +08:00
|
|
|
|
|
|
|
Params.clear();
|
|
|
|
Params.push_back(Int8PtrTy);
|
|
|
|
UnwindResumeOrRethrowFn =
|
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::VoidTy,
|
|
|
|
Params,
|
|
|
|
false),
|
|
|
|
"_Unwind_Resume_or_Rethrow");
|
2009-03-01 12:46:24 +08:00
|
|
|
ObjCBeginCatchFn =
|
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy,
|
|
|
|
Params,
|
|
|
|
false),
|
|
|
|
"objc_begin_catch");
|
|
|
|
|
|
|
|
Params.clear();
|
|
|
|
ObjCEndCatchFn =
|
|
|
|
CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::VoidTy,
|
|
|
|
Params,
|
|
|
|
false),
|
|
|
|
"objc_end_catch");
|
|
|
|
|
|
|
|
// struct objc_typeinfo {
|
|
|
|
// const void** vtable; // objc_ehtype_vtable + 2
|
|
|
|
// const char* name; // c++ typeinfo string
|
|
|
|
// Class cls;
|
|
|
|
// };
|
|
|
|
EHTypeTy = llvm::StructType::get(llvm::PointerType::getUnqual(Int8PtrTy),
|
|
|
|
Int8PtrTy,
|
|
|
|
ClassnfABIPtrTy,
|
|
|
|
NULL);
|
2009-03-02 14:08:11 +08:00
|
|
|
CGM.getModule().addTypeName("struct._objc_typeinfo", EHTypeTy);
|
2009-03-01 12:46:24 +08:00
|
|
|
EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy);
|
2008-08-12 08:12:39 +08:00
|
|
|
}
|
|
|
|
|
2009-01-24 07:53:38 +08:00
|
|
|
llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() {
|
|
|
|
FinishNonFragileABIModule();
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CGObjCNonFragileABIMac::FinishNonFragileABIModule() {
|
|
|
|
// nonfragile abi has no module definition.
|
2009-01-31 04:55:31 +08:00
|
|
|
|
|
|
|
// Build list of all implemented classe addresses in array
|
|
|
|
// L_OBJC_LABEL_CLASS_$.
|
|
|
|
// FIXME. Also generate in L_OBJC_LABEL_NONLAZY_CLASS_$
|
|
|
|
// list of 'nonlazy' implementations (defined as those with a +load{}
|
|
|
|
// method!!).
|
|
|
|
unsigned NumClasses = DefinedClasses.size();
|
|
|
|
if (NumClasses) {
|
|
|
|
std::vector<llvm::Constant*> Symbols(NumClasses);
|
|
|
|
for (unsigned i=0; i<NumClasses; i++)
|
|
|
|
Symbols[i] = llvm::ConstantExpr::getBitCast(DefinedClasses[i],
|
|
|
|
ObjCTypes.Int8PtrTy);
|
|
|
|
llvm::Constant* Init =
|
|
|
|
llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
|
|
|
|
NumClasses),
|
|
|
|
Symbols);
|
|
|
|
|
|
|
|
llvm::GlobalVariable *GV =
|
|
|
|
new llvm::GlobalVariable(Init->getType(), false,
|
|
|
|
llvm::GlobalValue::InternalLinkage,
|
|
|
|
Init,
|
|
|
|
"\01L_OBJC_LABEL_CLASS_$",
|
|
|
|
&CGM.getModule());
|
2009-03-10 06:18:41 +08:00
|
|
|
GV->setAlignment(8);
|
2009-01-31 04:55:31 +08:00
|
|
|
GV->setSection("__DATA, __objc_classlist, regular, no_dead_strip");
|
|
|
|
UsedGlobals.push_back(GV);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Build list of all implemented category addresses in array
|
|
|
|
// L_OBJC_LABEL_CATEGORY_$.
|
|
|
|
// FIXME. Also generate in L_OBJC_LABEL_NONLAZY_CATEGORY_$
|
|
|
|
// list of 'nonlazy' category implementations (defined as those with a +load{}
|
|
|
|
// method!!).
|
|
|
|
unsigned NumCategory = DefinedCategories.size();
|
|
|
|
if (NumCategory) {
|
|
|
|
std::vector<llvm::Constant*> Symbols(NumCategory);
|
|
|
|
for (unsigned i=0; i<NumCategory; i++)
|
|
|
|
Symbols[i] = llvm::ConstantExpr::getBitCast(DefinedCategories[i],
|
|
|
|
ObjCTypes.Int8PtrTy);
|
|
|
|
llvm::Constant* Init =
|
|
|
|
llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
|
|
|
|
NumCategory),
|
|
|
|
Symbols);
|
|
|
|
|
|
|
|
llvm::GlobalVariable *GV =
|
|
|
|
new llvm::GlobalVariable(Init->getType(), false,
|
|
|
|
llvm::GlobalValue::InternalLinkage,
|
|
|
|
Init,
|
|
|
|
"\01L_OBJC_LABEL_CATEGORY_$",
|
|
|
|
&CGM.getModule());
|
2009-03-10 06:18:41 +08:00
|
|
|
GV->setAlignment(8);
|
2009-01-31 04:55:31 +08:00
|
|
|
GV->setSection("__DATA, __objc_catlist, regular, no_dead_strip");
|
|
|
|
UsedGlobals.push_back(GV);
|
|
|
|
}
|
|
|
|
|
2009-01-31 06:07:48 +08:00
|
|
|
// static int L_OBJC_IMAGE_INFO[2] = { 0, flags };
|
|
|
|
// FIXME. flags can be 0 | 1 | 2 | 6. For now just use 0
|
|
|
|
std::vector<llvm::Constant*> Values(2);
|
|
|
|
Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, 0);
|
2009-02-25 05:08:09 +08:00
|
|
|
unsigned int flags = 0;
|
2009-02-25 07:34:44 +08:00
|
|
|
// FIXME: Fix and continue?
|
|
|
|
if (CGM.getLangOptions().getGCMode() != LangOptions::NonGC)
|
|
|
|
flags |= eImageInfo_GarbageCollected;
|
|
|
|
if (CGM.getLangOptions().getGCMode() == LangOptions::GCOnly)
|
|
|
|
flags |= eImageInfo_GCOnly;
|
2009-02-25 05:08:09 +08:00
|
|
|
Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, flags);
|
2009-01-31 06:07:48 +08:00
|
|
|
llvm::Constant* Init = llvm::ConstantArray::get(
|
|
|
|
llvm::ArrayType::get(ObjCTypes.IntTy, 2),
|
|
|
|
Values);
|
|
|
|
llvm::GlobalVariable *IMGV =
|
|
|
|
new llvm::GlobalVariable(Init->getType(), false,
|
|
|
|
llvm::GlobalValue::InternalLinkage,
|
|
|
|
Init,
|
|
|
|
"\01L_OBJC_IMAGE_INFO",
|
|
|
|
&CGM.getModule());
|
|
|
|
IMGV->setSection("__DATA, __objc_imageinfo, regular, no_dead_strip");
|
|
|
|
UsedGlobals.push_back(IMGV);
|
|
|
|
|
2009-01-24 07:53:38 +08:00
|
|
|
std::vector<llvm::Constant*> Used;
|
|
|
|
for (std::vector<llvm::GlobalVariable*>::iterator i = UsedGlobals.begin(),
|
|
|
|
e = UsedGlobals.end(); i != e; ++i) {
|
|
|
|
Used.push_back(llvm::ConstantExpr::getBitCast(*i, ObjCTypes.Int8PtrTy));
|
|
|
|
}
|
|
|
|
|
|
|
|
llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy, Used.size());
|
|
|
|
llvm::GlobalValue *GV =
|
|
|
|
new llvm::GlobalVariable(AT, false,
|
|
|
|
llvm::GlobalValue::AppendingLinkage,
|
|
|
|
llvm::ConstantArray::get(AT, Used),
|
|
|
|
"llvm.used",
|
|
|
|
&CGM.getModule());
|
|
|
|
|
|
|
|
GV->setSection("llvm.metadata");
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2009-01-25 04:21:50 +08:00
|
|
|
// Metadata flags
|
|
|
|
enum MetaDataDlags {
|
|
|
|
CLS = 0x0,
|
|
|
|
CLS_META = 0x1,
|
|
|
|
CLS_ROOT = 0x2,
|
2009-01-27 05:38:32 +08:00
|
|
|
OBJC2_CLS_HIDDEN = 0x10,
|
2009-01-25 04:21:50 +08:00
|
|
|
CLS_EXCEPTION = 0x20
|
|
|
|
};
|
|
|
|
/// BuildClassRoTInitializer - generate meta-data for:
|
|
|
|
/// struct _class_ro_t {
|
|
|
|
/// uint32_t const flags;
|
|
|
|
/// uint32_t const instanceStart;
|
|
|
|
/// uint32_t const instanceSize;
|
|
|
|
/// uint32_t const reserved; // only when building for 64bit targets
|
|
|
|
/// const uint8_t * const ivarLayout;
|
|
|
|
/// const char *const name;
|
|
|
|
/// const struct _method_list_t * const baseMethods;
|
2009-01-30 03:24:30 +08:00
|
|
|
/// const struct _protocol_list_t *const baseProtocols;
|
2009-01-25 04:21:50 +08:00
|
|
|
/// const struct _ivar_list_t *const ivars;
|
|
|
|
/// const uint8_t * const weakIvarLayout;
|
|
|
|
/// const struct _prop_list_t * const properties;
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer(
|
|
|
|
unsigned flags,
|
|
|
|
unsigned InstanceStart,
|
|
|
|
unsigned InstanceSize,
|
|
|
|
const ObjCImplementationDecl *ID) {
|
|
|
|
std::string ClassName = ID->getNameAsString();
|
|
|
|
std::vector<llvm::Constant*> Values(10); // 11 for 64bit targets!
|
|
|
|
Values[ 0] = llvm::ConstantInt::get(ObjCTypes.IntTy, flags);
|
|
|
|
Values[ 1] = llvm::ConstantInt::get(ObjCTypes.IntTy, InstanceStart);
|
|
|
|
Values[ 2] = llvm::ConstantInt::get(ObjCTypes.IntTy, InstanceSize);
|
|
|
|
// FIXME. For 64bit targets add 0 here.
|
2009-01-30 03:24:30 +08:00
|
|
|
// FIXME. ivarLayout is currently null!
|
2009-03-06 03:17:31 +08:00
|
|
|
Values[ 3] = GetIvarLayoutName(0, ObjCTypes);
|
2009-01-25 04:21:50 +08:00
|
|
|
Values[ 4] = GetClassName(ID->getIdentifier());
|
2009-01-27 05:38:32 +08:00
|
|
|
// const struct _method_list_t * const baseMethods;
|
|
|
|
std::vector<llvm::Constant*> Methods;
|
|
|
|
std::string MethodListName("\01l_OBJC_$_");
|
|
|
|
if (flags & CLS_META) {
|
|
|
|
MethodListName += "CLASS_METHODS_" + ID->getNameAsString();
|
|
|
|
for (ObjCImplementationDecl::classmeth_iterator i = ID->classmeth_begin(),
|
|
|
|
e = ID->classmeth_end(); i != e; ++i) {
|
|
|
|
// Class methods should always be defined.
|
|
|
|
Methods.push_back(GetMethodConstant(*i));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
MethodListName += "INSTANCE_METHODS_" + ID->getNameAsString();
|
|
|
|
for (ObjCImplementationDecl::instmeth_iterator i = ID->instmeth_begin(),
|
|
|
|
e = ID->instmeth_end(); i != e; ++i) {
|
|
|
|
// Instance methods should always be defined.
|
|
|
|
Methods.push_back(GetMethodConstant(*i));
|
|
|
|
}
|
2009-01-29 06:46:49 +08:00
|
|
|
for (ObjCImplementationDecl::propimpl_iterator i = ID->propimpl_begin(),
|
|
|
|
e = ID->propimpl_end(); i != e; ++i) {
|
|
|
|
ObjCPropertyImplDecl *PID = *i;
|
|
|
|
|
|
|
|
if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize){
|
|
|
|
ObjCPropertyDecl *PD = PID->getPropertyDecl();
|
|
|
|
|
|
|
|
if (ObjCMethodDecl *MD = PD->getGetterMethodDecl())
|
|
|
|
if (llvm::Constant *C = GetMethodConstant(MD))
|
|
|
|
Methods.push_back(C);
|
|
|
|
if (ObjCMethodDecl *MD = PD->getSetterMethodDecl())
|
|
|
|
if (llvm::Constant *C = GetMethodConstant(MD))
|
|
|
|
Methods.push_back(C);
|
|
|
|
}
|
|
|
|
}
|
2009-01-27 05:38:32 +08:00
|
|
|
}
|
|
|
|
Values[ 5] = EmitMethodList(MethodListName,
|
2009-01-28 09:05:23 +08:00
|
|
|
"__DATA, __objc_const", Methods);
|
2009-01-30 03:24:30 +08:00
|
|
|
|
|
|
|
const ObjCInterfaceDecl *OID = ID->getClassInterface();
|
|
|
|
assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer");
|
|
|
|
Values[ 6] = EmitProtocolList("\01l_OBJC_CLASS_PROTOCOLS_$_"
|
|
|
|
+ OID->getNameAsString(),
|
|
|
|
OID->protocol_begin(),
|
|
|
|
OID->protocol_end());
|
|
|
|
|
2009-01-28 03:38:51 +08:00
|
|
|
if (flags & CLS_META)
|
|
|
|
Values[ 7] = llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
|
|
|
|
else
|
|
|
|
Values[ 7] = EmitIvarList(ID);
|
2009-01-30 03:24:30 +08:00
|
|
|
// FIXME. weakIvarLayout is currently null.
|
2009-03-13 06:50:49 +08:00
|
|
|
Values[ 8] = GetIvarLayoutName(0, ObjCTypes);
|
2009-01-29 06:18:42 +08:00
|
|
|
if (flags & CLS_META)
|
|
|
|
Values[ 9] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
|
|
|
|
else
|
|
|
|
Values[ 9] =
|
|
|
|
EmitPropertyList(
|
|
|
|
"\01l_OBJC_$_PROP_LIST_" + ID->getNameAsString(),
|
|
|
|
ID, ID->getClassInterface(), ObjCTypes);
|
2009-01-25 04:21:50 +08:00
|
|
|
llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassRonfABITy,
|
|
|
|
Values);
|
|
|
|
llvm::GlobalVariable *CLASS_RO_GV =
|
|
|
|
new llvm::GlobalVariable(ObjCTypes.ClassRonfABITy, false,
|
|
|
|
llvm::GlobalValue::InternalLinkage,
|
|
|
|
Init,
|
|
|
|
(flags & CLS_META) ?
|
|
|
|
std::string("\01l_OBJC_METACLASS_RO_$_")+ClassName :
|
|
|
|
std::string("\01l_OBJC_CLASS_RO_$_")+ClassName,
|
|
|
|
&CGM.getModule());
|
2009-01-31 10:43:27 +08:00
|
|
|
CLASS_RO_GV->setAlignment(
|
|
|
|
CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.ClassRonfABITy));
|
2009-01-28 09:05:23 +08:00
|
|
|
CLASS_RO_GV->setSection("__DATA, __objc_const");
|
2009-01-25 04:21:50 +08:00
|
|
|
return CLASS_RO_GV;
|
2009-01-27 06:58:07 +08:00
|
|
|
|
2009-01-25 04:21:50 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// BuildClassMetaData - This routine defines that to-level meta-data
|
|
|
|
/// for the given ClassName for:
|
|
|
|
/// struct _class_t {
|
|
|
|
/// struct _class_t *isa;
|
|
|
|
/// struct _class_t * const superclass;
|
|
|
|
/// void *cache;
|
|
|
|
/// IMP *vtable;
|
|
|
|
/// struct class_ro_t *ro;
|
|
|
|
/// }
|
|
|
|
///
|
2009-01-25 05:21:53 +08:00
|
|
|
llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassMetaData(
|
|
|
|
std::string &ClassName,
|
2009-01-25 04:21:50 +08:00
|
|
|
llvm::Constant *IsAGV,
|
|
|
|
llvm::Constant *SuperClassGV,
|
2009-01-31 08:59:10 +08:00
|
|
|
llvm::Constant *ClassRoGV,
|
|
|
|
bool HiddenVisibility) {
|
2009-01-25 04:21:50 +08:00
|
|
|
std::vector<llvm::Constant*> Values(5);
|
|
|
|
Values[0] = IsAGV;
|
2009-01-25 05:21:53 +08:00
|
|
|
Values[1] = SuperClassGV
|
|
|
|
? SuperClassGV
|
|
|
|
: llvm::Constant::getNullValue(ObjCTypes.ClassnfABIPtrTy);
|
2009-01-25 04:21:50 +08:00
|
|
|
Values[2] = ObjCEmptyCacheVar; // &ObjCEmptyCacheVar
|
|
|
|
Values[3] = ObjCEmptyVtableVar; // &ObjCEmptyVtableVar
|
|
|
|
Values[4] = ClassRoGV; // &CLASS_RO_GV
|
|
|
|
llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassnfABITy,
|
|
|
|
Values);
|
2009-03-01 12:40:10 +08:00
|
|
|
llvm::GlobalVariable *GV = GetClassGlobal(ClassName);
|
|
|
|
GV->setInitializer(Init);
|
2009-01-31 09:07:39 +08:00
|
|
|
GV->setSection("__DATA, __objc_data");
|
2009-01-31 10:43:27 +08:00
|
|
|
GV->setAlignment(
|
|
|
|
CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.ClassnfABITy));
|
2009-01-31 08:59:10 +08:00
|
|
|
if (HiddenVisibility)
|
|
|
|
GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
|
2009-01-25 05:21:53 +08:00
|
|
|
return GV;
|
2009-01-25 04:21:50 +08:00
|
|
|
}
|
|
|
|
|
2009-01-24 07:53:38 +08:00
|
|
|
void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
|
|
|
|
std::string ClassName = ID->getNameAsString();
|
|
|
|
if (!ObjCEmptyCacheVar) {
|
|
|
|
ObjCEmptyCacheVar = new llvm::GlobalVariable(
|
2009-02-15 15:36:20 +08:00
|
|
|
ObjCTypes.CacheTy,
|
2009-01-24 07:53:38 +08:00
|
|
|
false,
|
|
|
|
llvm::GlobalValue::ExternalLinkage,
|
|
|
|
0,
|
2009-04-07 13:48:37 +08:00
|
|
|
"_objc_empty_cache",
|
2009-01-24 07:53:38 +08:00
|
|
|
&CGM.getModule());
|
|
|
|
|
|
|
|
ObjCEmptyVtableVar = new llvm::GlobalVariable(
|
2009-02-15 15:36:20 +08:00
|
|
|
ObjCTypes.ImpnfABITy,
|
2009-01-24 07:53:38 +08:00
|
|
|
false,
|
|
|
|
llvm::GlobalValue::ExternalLinkage,
|
|
|
|
0,
|
2009-04-07 13:48:37 +08:00
|
|
|
"_objc_empty_vtable",
|
2009-01-24 07:53:38 +08:00
|
|
|
&CGM.getModule());
|
|
|
|
}
|
2009-01-27 05:38:32 +08:00
|
|
|
assert(ID->getClassInterface() &&
|
|
|
|
"CGObjCNonFragileABIMac::GenerateClass - class is 0");
|
2009-01-25 04:21:50 +08:00
|
|
|
uint32_t InstanceStart =
|
|
|
|
CGM.getTargetData().getTypePaddedSize(ObjCTypes.ClassnfABITy);
|
|
|
|
uint32_t InstanceSize = InstanceStart;
|
|
|
|
uint32_t flags = CLS_META;
|
2009-04-07 13:48:37 +08:00
|
|
|
std::string ObjCMetaClassName(getMetaclassSymbolPrefix());
|
|
|
|
std::string ObjCClassName(getClassSymbolPrefix());
|
2009-01-25 04:21:50 +08:00
|
|
|
|
|
|
|
llvm::GlobalVariable *SuperClassGV, *IsAGV;
|
|
|
|
|
2009-01-31 08:59:10 +08:00
|
|
|
bool classIsHidden = IsClassHidden(ID->getClassInterface());
|
|
|
|
if (classIsHidden)
|
2009-01-27 05:38:32 +08:00
|
|
|
flags |= OBJC2_CLS_HIDDEN;
|
|
|
|
if (!ID->getClassInterface()->getSuperClass()) {
|
2009-01-25 04:21:50 +08:00
|
|
|
// class is root
|
|
|
|
flags |= CLS_ROOT;
|
2009-03-01 12:40:10 +08:00
|
|
|
SuperClassGV = GetClassGlobal(ObjCClassName + ClassName);
|
2009-04-07 13:48:37 +08:00
|
|
|
IsAGV = GetClassGlobal(ObjCMetaClassName + ClassName, false);
|
2009-01-25 04:21:50 +08:00
|
|
|
} else {
|
2009-01-25 05:21:53 +08:00
|
|
|
// Has a root. Current class is not a root.
|
2009-02-27 02:23:47 +08:00
|
|
|
const ObjCInterfaceDecl *Root = ID->getClassInterface();
|
|
|
|
while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
|
|
|
|
Root = Super;
|
2009-04-07 13:48:37 +08:00
|
|
|
IsAGV = GetClassGlobal(ObjCMetaClassName + Root->getNameAsString(), false);
|
2009-02-27 02:23:47 +08:00
|
|
|
// work on super class metadata symbol.
|
|
|
|
std::string SuperClassName =
|
|
|
|
ObjCMetaClassName + ID->getClassInterface()->getSuperClass()->getNameAsString();
|
2009-04-07 13:48:37 +08:00
|
|
|
SuperClassGV = GetClassGlobal(SuperClassName, false);
|
2009-01-25 04:21:50 +08:00
|
|
|
}
|
|
|
|
llvm::GlobalVariable *CLASS_RO_GV = BuildClassRoTInitializer(flags,
|
|
|
|
InstanceStart,
|
|
|
|
InstanceSize,ID);
|
2009-01-25 05:21:53 +08:00
|
|
|
std::string TClassName = ObjCMetaClassName + ClassName;
|
|
|
|
llvm::GlobalVariable *MetaTClass =
|
2009-01-31 08:59:10 +08:00
|
|
|
BuildClassMetaData(TClassName, IsAGV, SuperClassGV, CLASS_RO_GV,
|
|
|
|
classIsHidden);
|
2009-04-07 13:48:37 +08:00
|
|
|
|
2009-01-25 05:21:53 +08:00
|
|
|
// Metadata for the class
|
|
|
|
flags = CLS;
|
2009-01-31 08:59:10 +08:00
|
|
|
if (classIsHidden)
|
2009-01-27 05:38:32 +08:00
|
|
|
flags |= OBJC2_CLS_HIDDEN;
|
2009-04-08 12:21:03 +08:00
|
|
|
|
|
|
|
if (hasObjCExceptionAttribute(ID->getClassInterface()))
|
|
|
|
flags |= CLS_EXCEPTION;
|
|
|
|
|
2009-01-27 05:38:32 +08:00
|
|
|
if (!ID->getClassInterface()->getSuperClass()) {
|
2009-01-25 05:21:53 +08:00
|
|
|
flags |= CLS_ROOT;
|
|
|
|
SuperClassGV = 0;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// Has a root. Current class is not a root.
|
2009-02-27 02:23:47 +08:00
|
|
|
std::string RootClassName =
|
2009-01-25 05:21:53 +08:00
|
|
|
ID->getClassInterface()->getSuperClass()->getNameAsString();
|
2009-03-01 12:40:10 +08:00
|
|
|
SuperClassGV = GetClassGlobal(ObjCClassName + RootClassName);
|
2009-01-25 05:21:53 +08:00
|
|
|
}
|
2009-03-21 04:48:19 +08:00
|
|
|
// FIXME: Gross
|
2009-01-25 07:43:01 +08:00
|
|
|
InstanceStart = InstanceSize = 0;
|
|
|
|
if (ObjCInterfaceDecl *OID =
|
|
|
|
const_cast<ObjCInterfaceDecl*>(ID->getClassInterface())) {
|
|
|
|
// FIXME. Share this with the one in EmitIvarList.
|
2009-03-12 05:42:00 +08:00
|
|
|
const llvm::StructLayout *Layout = GetInterfaceDeclStructLayout(OID);
|
2009-01-25 07:43:01 +08:00
|
|
|
|
2009-01-29 03:12:34 +08:00
|
|
|
RecordDecl::field_iterator firstField, lastField;
|
|
|
|
const RecordDecl *RD = GetFirstIvarInRecord(OID, firstField, lastField);
|
2009-01-25 07:43:01 +08:00
|
|
|
|
2009-04-10 05:40:53 +08:00
|
|
|
for (RecordDecl::field_iterator e = RD->field_end(CGM.getContext()),
|
2009-01-25 07:43:01 +08:00
|
|
|
ifield = firstField; ifield != e; ++ifield)
|
|
|
|
lastField = ifield;
|
|
|
|
|
2009-04-10 05:40:53 +08:00
|
|
|
if (lastField != RD->field_end(CGM.getContext())) {
|
2009-01-25 07:43:01 +08:00
|
|
|
FieldDecl *Field = *lastField;
|
|
|
|
const llvm::Type *FieldTy =
|
|
|
|
CGM.getTypes().ConvertTypeForMem(Field->getType());
|
|
|
|
unsigned Size = CGM.getTargetData().getTypePaddedSize(FieldTy);
|
2009-03-09 04:18:37 +08:00
|
|
|
InstanceSize = GetIvarBaseOffset(Layout, Field) + Size;
|
2009-04-10 05:40:53 +08:00
|
|
|
if (firstField == RD->field_end(CGM.getContext()))
|
2009-01-25 07:43:01 +08:00
|
|
|
InstanceStart = InstanceSize;
|
2009-03-08 03:43:20 +08:00
|
|
|
else {
|
|
|
|
Field = *firstField;
|
2009-03-09 04:18:37 +08:00
|
|
|
InstanceStart = GetIvarBaseOffset(Layout, Field);
|
2009-03-08 03:43:20 +08:00
|
|
|
}
|
2009-01-25 07:43:01 +08:00
|
|
|
}
|
|
|
|
}
|
2009-01-25 05:21:53 +08:00
|
|
|
CLASS_RO_GV = BuildClassRoTInitializer(flags,
|
2009-01-25 07:43:01 +08:00
|
|
|
InstanceStart,
|
|
|
|
InstanceSize,
|
|
|
|
ID);
|
2009-01-25 05:21:53 +08:00
|
|
|
|
|
|
|
TClassName = ObjCClassName + ClassName;
|
2009-01-31 04:55:31 +08:00
|
|
|
llvm::GlobalVariable *ClassMD =
|
2009-01-31 08:59:10 +08:00
|
|
|
BuildClassMetaData(TClassName, MetaTClass, SuperClassGV, CLASS_RO_GV,
|
|
|
|
classIsHidden);
|
2009-04-07 13:48:37 +08:00
|
|
|
UsedGlobals.push_back(ClassMD);
|
2009-01-31 04:55:31 +08:00
|
|
|
DefinedClasses.push_back(ClassMD);
|
2009-04-08 12:21:03 +08:00
|
|
|
|
|
|
|
// Force the definition of the EHType if necessary.
|
|
|
|
if (flags & CLS_EXCEPTION)
|
|
|
|
GetInterfaceEHType(ID->getClassInterface(), true);
|
2009-01-24 07:53:38 +08:00
|
|
|
}
|
|
|
|
|
2009-01-31 02:58:59 +08:00
|
|
|
/// GenerateProtocolRef - This routine is called to generate code for
|
|
|
|
/// a protocol reference expression; as in:
|
|
|
|
/// @code
|
|
|
|
/// @protocol(Proto1);
|
|
|
|
/// @endcode
|
|
|
|
/// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1
|
|
|
|
/// which will hold address of the protocol meta-data.
|
|
|
|
///
|
|
|
|
llvm::Value *CGObjCNonFragileABIMac::GenerateProtocolRef(CGBuilderTy &Builder,
|
|
|
|
const ObjCProtocolDecl *PD) {
|
|
|
|
|
2009-04-11 02:47:34 +08:00
|
|
|
// This routine is called for @protocol only. So, we must build definition
|
|
|
|
// of protocol's meta-data (not a reference to it!)
|
|
|
|
//
|
|
|
|
llvm::Constant *Init = llvm::ConstantExpr::getBitCast(GetOrEmitProtocol(PD),
|
2009-01-31 02:58:59 +08:00
|
|
|
ObjCTypes.ExternalProtocolPtrTy);
|
|
|
|
|
|
|
|
std::string ProtocolName("\01l_OBJC_PROTOCOL_REFERENCE_$_");
|
|
|
|
ProtocolName += PD->getNameAsCString();
|
|
|
|
|
|
|
|
llvm::GlobalVariable *PTGV = CGM.getModule().getGlobalVariable(ProtocolName);
|
|
|
|
if (PTGV)
|
|
|
|
return Builder.CreateLoad(PTGV, false, "tmp");
|
|
|
|
PTGV = new llvm::GlobalVariable(
|
|
|
|
Init->getType(), false,
|
2009-03-08 00:33:28 +08:00
|
|
|
llvm::GlobalValue::WeakAnyLinkage,
|
2009-01-31 02:58:59 +08:00
|
|
|
Init,
|
|
|
|
ProtocolName,
|
|
|
|
&CGM.getModule());
|
|
|
|
PTGV->setSection("__DATA, __objc_protorefs, coalesced, no_dead_strip");
|
|
|
|
PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
|
|
|
|
UsedGlobals.push_back(PTGV);
|
|
|
|
return Builder.CreateLoad(PTGV, false, "tmp");
|
|
|
|
}
|
|
|
|
|
2009-01-27 02:32:24 +08:00
|
|
|
/// GenerateCategory - Build metadata for a category implementation.
|
|
|
|
/// struct _category_t {
|
|
|
|
/// const char * const name;
|
|
|
|
/// struct _class_t *const cls;
|
|
|
|
/// const struct _method_list_t * const instance_methods;
|
|
|
|
/// const struct _method_list_t * const class_methods;
|
|
|
|
/// const struct _protocol_list_t * const protocols;
|
|
|
|
/// const struct _prop_list_t * const properties;
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD)
|
|
|
|
{
|
|
|
|
const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
|
2009-01-27 06:58:07 +08:00
|
|
|
const char *Prefix = "\01l_OBJC_$_CATEGORY_";
|
|
|
|
std::string ExtCatName(Prefix + Interface->getNameAsString()+
|
2009-01-27 02:32:24 +08:00
|
|
|
"_$_" + OCD->getNameAsString());
|
2009-04-07 13:48:37 +08:00
|
|
|
std::string ExtClassName(getClassSymbolPrefix() +
|
|
|
|
Interface->getNameAsString());
|
2009-01-27 02:32:24 +08:00
|
|
|
|
|
|
|
std::vector<llvm::Constant*> Values(6);
|
|
|
|
Values[0] = GetClassName(OCD->getIdentifier());
|
|
|
|
// meta-class entry symbol
|
2009-03-01 12:40:10 +08:00
|
|
|
llvm::GlobalVariable *ClassGV = GetClassGlobal(ExtClassName);
|
2009-01-27 02:32:24 +08:00
|
|
|
Values[1] = ClassGV;
|
2009-01-27 06:58:07 +08:00
|
|
|
std::vector<llvm::Constant*> Methods;
|
|
|
|
std::string MethodListName(Prefix);
|
|
|
|
MethodListName += "INSTANCE_METHODS_" + Interface->getNameAsString() +
|
|
|
|
"_$_" + OCD->getNameAsString();
|
|
|
|
|
|
|
|
for (ObjCCategoryImplDecl::instmeth_iterator i = OCD->instmeth_begin(),
|
|
|
|
e = OCD->instmeth_end(); i != e; ++i) {
|
|
|
|
// Instance methods should always be defined.
|
|
|
|
Methods.push_back(GetMethodConstant(*i));
|
|
|
|
}
|
|
|
|
|
|
|
|
Values[2] = EmitMethodList(MethodListName,
|
2009-01-28 09:05:23 +08:00
|
|
|
"__DATA, __objc_const",
|
2009-01-27 06:58:07 +08:00
|
|
|
Methods);
|
|
|
|
|
|
|
|
MethodListName = Prefix;
|
|
|
|
MethodListName += "CLASS_METHODS_" + Interface->getNameAsString() + "_$_" +
|
|
|
|
OCD->getNameAsString();
|
|
|
|
Methods.clear();
|
|
|
|
for (ObjCCategoryImplDecl::classmeth_iterator i = OCD->classmeth_begin(),
|
|
|
|
e = OCD->classmeth_end(); i != e; ++i) {
|
|
|
|
// Class methods should always be defined.
|
|
|
|
Methods.push_back(GetMethodConstant(*i));
|
|
|
|
}
|
|
|
|
|
|
|
|
Values[3] = EmitMethodList(MethodListName,
|
2009-01-28 09:05:23 +08:00
|
|
|
"__DATA, __objc_const",
|
2009-01-27 06:58:07 +08:00
|
|
|
Methods);
|
2009-01-29 06:18:42 +08:00
|
|
|
const ObjCCategoryDecl *Category =
|
|
|
|
Interface->FindCategoryDeclaration(OCD->getIdentifier());
|
2009-02-14 01:52:22 +08:00
|
|
|
if (Category) {
|
|
|
|
std::string ExtName(Interface->getNameAsString() + "_$_" +
|
|
|
|
OCD->getNameAsString());
|
|
|
|
Values[4] = EmitProtocolList("\01l_OBJC_CATEGORY_PROTOCOLS_$_"
|
|
|
|
+ Interface->getNameAsString() + "_$_"
|
|
|
|
+ Category->getNameAsString(),
|
|
|
|
Category->protocol_begin(),
|
|
|
|
Category->protocol_end());
|
|
|
|
Values[5] =
|
|
|
|
EmitPropertyList(std::string("\01l_OBJC_$_PROP_LIST_") + ExtName,
|
|
|
|
OCD, Category, ObjCTypes);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
|
|
|
|
Values[5] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
|
|
|
|
}
|
|
|
|
|
2009-01-27 02:32:24 +08:00
|
|
|
llvm::Constant *Init =
|
|
|
|
llvm::ConstantStruct::get(ObjCTypes.CategorynfABITy,
|
|
|
|
Values);
|
|
|
|
llvm::GlobalVariable *GCATV
|
|
|
|
= new llvm::GlobalVariable(ObjCTypes.CategorynfABITy,
|
|
|
|
false,
|
|
|
|
llvm::GlobalValue::InternalLinkage,
|
|
|
|
Init,
|
|
|
|
ExtCatName,
|
|
|
|
&CGM.getModule());
|
2009-01-31 10:43:27 +08:00
|
|
|
GCATV->setAlignment(
|
|
|
|
CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.CategorynfABITy));
|
2009-01-28 09:05:23 +08:00
|
|
|
GCATV->setSection("__DATA, __objc_const");
|
2009-01-27 02:32:24 +08:00
|
|
|
UsedGlobals.push_back(GCATV);
|
|
|
|
DefinedCategories.push_back(GCATV);
|
|
|
|
}
|
2009-01-27 05:38:32 +08:00
|
|
|
|
|
|
|
/// GetMethodConstant - Return a struct objc_method constant for the
|
|
|
|
/// given method if it has been defined. The result is null if the
|
|
|
|
/// method has not been defined. The return value has type MethodPtrTy.
|
|
|
|
llvm::Constant *CGObjCNonFragileABIMac::GetMethodConstant(
|
|
|
|
const ObjCMethodDecl *MD) {
|
|
|
|
// FIXME: Use DenseMap::lookup
|
|
|
|
llvm::Function *Fn = MethodDefinitions[MD];
|
|
|
|
if (!Fn)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
std::vector<llvm::Constant*> Method(3);
|
|
|
|
Method[0] =
|
|
|
|
llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
|
|
|
|
ObjCTypes.SelectorPtrTy);
|
|
|
|
Method[1] = GetMethodVarType(MD);
|
|
|
|
Method[2] = llvm::ConstantExpr::getBitCast(Fn, ObjCTypes.Int8PtrTy);
|
|
|
|
return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Method);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// EmitMethodList - Build meta-data for method declarations
|
|
|
|
/// struct _method_list_t {
|
|
|
|
/// uint32_t entsize; // sizeof(struct _objc_method)
|
|
|
|
/// uint32_t method_count;
|
|
|
|
/// struct _objc_method method_list[method_count];
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
llvm::Constant *CGObjCNonFragileABIMac::EmitMethodList(
|
|
|
|
const std::string &Name,
|
|
|
|
const char *Section,
|
|
|
|
const ConstantVector &Methods) {
|
|
|
|
// Return null for empty list.
|
|
|
|
if (Methods.empty())
|
|
|
|
return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy);
|
|
|
|
|
|
|
|
std::vector<llvm::Constant*> Values(3);
|
|
|
|
// sizeof(struct _objc_method)
|
|
|
|
unsigned Size = CGM.getTargetData().getTypePaddedSize(ObjCTypes.MethodTy);
|
|
|
|
Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
|
|
|
|
// method_count
|
|
|
|
Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
|
|
|
|
llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodTy,
|
|
|
|
Methods.size());
|
|
|
|
Values[2] = llvm::ConstantArray::get(AT, Methods);
|
|
|
|
llvm::Constant *Init = llvm::ConstantStruct::get(Values);
|
|
|
|
|
|
|
|
llvm::GlobalVariable *GV =
|
|
|
|
new llvm::GlobalVariable(Init->getType(), false,
|
|
|
|
llvm::GlobalValue::InternalLinkage,
|
|
|
|
Init,
|
|
|
|
Name,
|
|
|
|
&CGM.getModule());
|
2009-01-31 10:43:27 +08:00
|
|
|
GV->setAlignment(
|
|
|
|
CGM.getTargetData().getPrefTypeAlignment(Init->getType()));
|
2009-01-27 05:38:32 +08:00
|
|
|
GV->setSection(Section);
|
|
|
|
UsedGlobals.push_back(GV);
|
|
|
|
return llvm::ConstantExpr::getBitCast(GV,
|
|
|
|
ObjCTypes.MethodListnfABIPtrTy);
|
|
|
|
}
|
2009-01-28 03:38:51 +08:00
|
|
|
|
2009-02-11 04:21:06 +08:00
|
|
|
/// ObjCIvarOffsetVariable - Returns the ivar offset variable for
|
|
|
|
/// the given ivar.
|
|
|
|
///
|
|
|
|
llvm::GlobalVariable * CGObjCNonFragileABIMac::ObjCIvarOffsetVariable(
|
|
|
|
std::string &Name,
|
2009-02-13 02:51:23 +08:00
|
|
|
const ObjCInterfaceDecl *ID,
|
2009-02-11 04:21:06 +08:00
|
|
|
const ObjCIvarDecl *Ivar) {
|
2009-02-13 02:51:23 +08:00
|
|
|
Name += "\01_OBJC_IVAR_$_" +
|
2009-04-10 05:40:53 +08:00
|
|
|
getInterfaceDeclForIvar(ID, Ivar, CGM.getContext())->getNameAsString() +
|
|
|
|
'.' + Ivar->getNameAsString();
|
2009-02-11 04:21:06 +08:00
|
|
|
llvm::GlobalVariable *IvarOffsetGV =
|
|
|
|
CGM.getModule().getGlobalVariable(Name);
|
|
|
|
if (!IvarOffsetGV)
|
|
|
|
IvarOffsetGV =
|
|
|
|
new llvm::GlobalVariable(ObjCTypes.LongTy,
|
|
|
|
false,
|
|
|
|
llvm::GlobalValue::ExternalLinkage,
|
|
|
|
0,
|
|
|
|
Name,
|
|
|
|
&CGM.getModule());
|
|
|
|
return IvarOffsetGV;
|
|
|
|
}
|
|
|
|
|
2009-01-28 09:05:23 +08:00
|
|
|
llvm::Constant * CGObjCNonFragileABIMac::EmitIvarOffsetVar(
|
2009-02-11 04:21:06 +08:00
|
|
|
const ObjCInterfaceDecl *ID,
|
2009-01-28 09:36:42 +08:00
|
|
|
const ObjCIvarDecl *Ivar,
|
2009-01-28 09:05:23 +08:00
|
|
|
unsigned long int Offset) {
|
|
|
|
|
2009-02-11 04:21:06 +08:00
|
|
|
assert(ID && "EmitIvarOffsetVar - null interface decl.");
|
2009-01-28 09:05:23 +08:00
|
|
|
std::string ExternalName("\01_OBJC_IVAR_$_" + ID->getNameAsString() + '.'
|
2009-01-28 09:36:42 +08:00
|
|
|
+ Ivar->getNameAsString());
|
2009-02-03 08:09:52 +08:00
|
|
|
llvm::Constant *Init = llvm::ConstantInt::get(ObjCTypes.LongTy, Offset);
|
2009-01-28 09:05:23 +08:00
|
|
|
llvm::GlobalVariable *IvarOffsetGV =
|
|
|
|
CGM.getModule().getGlobalVariable(ExternalName);
|
2009-04-07 02:30:00 +08:00
|
|
|
if (IvarOffsetGV)
|
2009-01-28 09:05:23 +08:00
|
|
|
// ivar offset symbol already built due to user code referencing it.
|
|
|
|
IvarOffsetGV->setInitializer(Init);
|
2009-04-07 02:30:00 +08:00
|
|
|
else
|
|
|
|
IvarOffsetGV =
|
|
|
|
new llvm::GlobalVariable(Init->getType(),
|
|
|
|
false,
|
|
|
|
llvm::GlobalValue::ExternalLinkage,
|
|
|
|
Init,
|
|
|
|
ExternalName,
|
|
|
|
&CGM.getModule());
|
2009-01-31 10:43:27 +08:00
|
|
|
IvarOffsetGV->setAlignment(
|
2009-02-03 08:09:52 +08:00
|
|
|
CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.LongTy));
|
2009-01-28 09:36:42 +08:00
|
|
|
// @private and @package have hidden visibility.
|
|
|
|
bool globalVisibility = (Ivar->getAccessControl() == ObjCIvarDecl::Public ||
|
2009-04-07 02:30:00 +08:00
|
|
|
Ivar->getAccessControl() == ObjCIvarDecl::Protected);
|
2009-01-28 09:36:42 +08:00
|
|
|
if (!globalVisibility)
|
|
|
|
IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
|
2009-04-07 02:30:00 +08:00
|
|
|
else if (IsClassHidden(ID))
|
2009-02-11 04:21:06 +08:00
|
|
|
IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
|
2009-04-07 02:30:00 +08:00
|
|
|
else if (CGM.getLangOptions().getVisibilityMode() ==
|
|
|
|
LangOptions::DefaultVisibility)
|
|
|
|
IvarOffsetGV->setVisibility(llvm::GlobalValue::DefaultVisibility);
|
2009-01-28 09:05:23 +08:00
|
|
|
IvarOffsetGV->setSection("__DATA, __objc_const");
|
|
|
|
UsedGlobals.push_back(IvarOffsetGV);
|
2009-02-03 08:09:52 +08:00
|
|
|
return IvarOffsetGV;
|
2009-01-28 09:05:23 +08:00
|
|
|
}
|
|
|
|
|
2009-01-28 03:38:51 +08:00
|
|
|
/// EmitIvarList - Emit the ivar list for the given
|
|
|
|
/// implementation. If ForClass is true the list of class ivars
|
|
|
|
/// (i.e. metaclass ivars) is emitted, otherwise the list of
|
|
|
|
/// interface ivars will be emitted. The return value has type
|
|
|
|
/// IvarListnfABIPtrTy.
|
|
|
|
/// struct _ivar_t {
|
|
|
|
/// unsigned long int *offset; // pointer to ivar offset location
|
|
|
|
/// char *name;
|
|
|
|
/// char *type;
|
|
|
|
/// uint32_t alignment;
|
|
|
|
/// uint32_t size;
|
|
|
|
/// }
|
|
|
|
/// struct _ivar_list_t {
|
|
|
|
/// uint32 entsize; // sizeof(struct _ivar_t)
|
|
|
|
/// uint32 count;
|
|
|
|
/// struct _iver_t list[count];
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList(
|
|
|
|
const ObjCImplementationDecl *ID) {
|
|
|
|
|
|
|
|
std::vector<llvm::Constant*> Ivars, Ivar(5);
|
|
|
|
|
|
|
|
const ObjCInterfaceDecl *OID = ID->getClassInterface();
|
|
|
|
assert(OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface");
|
|
|
|
|
2009-01-28 09:05:23 +08:00
|
|
|
// FIXME. Consolidate this with similar code in GenerateClass.
|
2009-03-12 05:42:00 +08:00
|
|
|
const llvm::StructLayout *Layout = GetInterfaceDeclStructLayout(OID);
|
2009-01-29 03:12:34 +08:00
|
|
|
|
|
|
|
RecordDecl::field_iterator i,p;
|
|
|
|
const RecordDecl *RD = GetFirstIvarInRecord(OID, i,p);
|
2009-04-01 02:11:23 +08:00
|
|
|
// collect declared and synthesized ivars in a small vector.
|
|
|
|
llvm::SmallVector<ObjCIvarDecl*, 16> OIvars;
|
|
|
|
for (ObjCInterfaceDecl::ivar_iterator I = OID->ivar_begin(),
|
|
|
|
E = OID->ivar_end(); I != E; ++I)
|
|
|
|
OIvars.push_back(*I);
|
2009-04-10 05:40:53 +08:00
|
|
|
for (ObjCInterfaceDecl::prop_iterator I = OID->prop_begin(CGM.getContext()),
|
|
|
|
E = OID->prop_end(CGM.getContext()); I != E; ++I)
|
2009-04-01 02:11:23 +08:00
|
|
|
if (ObjCIvarDecl *IV = (*I)->getPropertyIvarDecl())
|
|
|
|
OIvars.push_back(IV);
|
2009-04-02 03:37:34 +08:00
|
|
|
|
2009-04-01 02:11:23 +08:00
|
|
|
unsigned iv = 0;
|
2009-04-10 05:40:53 +08:00
|
|
|
for (RecordDecl::field_iterator e = RD->field_end(CGM.getContext());
|
|
|
|
i != e; ++i) {
|
2009-01-28 03:38:51 +08:00
|
|
|
FieldDecl *Field = *i;
|
2009-03-09 04:18:37 +08:00
|
|
|
uint64_t offset = GetIvarBaseOffset(Layout, Field);
|
2009-04-01 02:11:23 +08:00
|
|
|
Ivar[0] = EmitIvarOffsetVar(ID->getClassInterface(), OIvars[iv++], offset);
|
2009-01-28 03:38:51 +08:00
|
|
|
if (Field->getIdentifier())
|
|
|
|
Ivar[1] = GetMethodVarName(Field->getIdentifier());
|
|
|
|
else
|
|
|
|
Ivar[1] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
|
2009-03-05 02:21:39 +08:00
|
|
|
Ivar[2] = GetMethodVarType(Field);
|
2009-01-28 03:38:51 +08:00
|
|
|
const llvm::Type *FieldTy =
|
|
|
|
CGM.getTypes().ConvertTypeForMem(Field->getType());
|
|
|
|
unsigned Size = CGM.getTargetData().getTypePaddedSize(FieldTy);
|
|
|
|
unsigned Align = CGM.getContext().getPreferredTypeAlign(
|
|
|
|
Field->getType().getTypePtr()) >> 3;
|
|
|
|
Align = llvm::Log2_32(Align);
|
|
|
|
Ivar[3] = llvm::ConstantInt::get(ObjCTypes.IntTy, Align);
|
2009-01-28 06:27:56 +08:00
|
|
|
// NOTE. Size of a bitfield does not match gcc's, because of the way
|
|
|
|
// bitfields are treated special in each. But I am told that 'size'
|
|
|
|
// for bitfield ivars is ignored by the runtime so it does not matter.
|
|
|
|
// (even if it matters, some day, there is enough info. to get the bitfield
|
|
|
|
// right!
|
2009-01-28 03:38:51 +08:00
|
|
|
Ivar[4] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
|
|
|
|
Ivars.push_back(llvm::ConstantStruct::get(ObjCTypes.IvarnfABITy, Ivar));
|
|
|
|
}
|
|
|
|
// Return null for empty list.
|
|
|
|
if (Ivars.empty())
|
|
|
|
return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
|
|
|
|
std::vector<llvm::Constant*> Values(3);
|
|
|
|
unsigned Size = CGM.getTargetData().getTypePaddedSize(ObjCTypes.IvarnfABITy);
|
|
|
|
Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
|
|
|
|
Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Ivars.size());
|
|
|
|
llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.IvarnfABITy,
|
|
|
|
Ivars.size());
|
|
|
|
Values[2] = llvm::ConstantArray::get(AT, Ivars);
|
|
|
|
llvm::Constant *Init = llvm::ConstantStruct::get(Values);
|
|
|
|
const char *Prefix = "\01l_OBJC_$_INSTANCE_VARIABLES_";
|
|
|
|
llvm::GlobalVariable *GV =
|
|
|
|
new llvm::GlobalVariable(Init->getType(), false,
|
|
|
|
llvm::GlobalValue::InternalLinkage,
|
|
|
|
Init,
|
|
|
|
Prefix + OID->getNameAsString(),
|
|
|
|
&CGM.getModule());
|
2009-01-31 10:43:27 +08:00
|
|
|
GV->setAlignment(
|
|
|
|
CGM.getTargetData().getPrefTypeAlignment(Init->getType()));
|
2009-01-28 09:05:23 +08:00
|
|
|
GV->setSection("__DATA, __objc_const");
|
2009-01-28 03:38:51 +08:00
|
|
|
|
|
|
|
UsedGlobals.push_back(GV);
|
|
|
|
return llvm::ConstantExpr::getBitCast(GV,
|
|
|
|
ObjCTypes.IvarListnfABIPtrTy);
|
2009-01-30 03:24:30 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocolRef(
|
|
|
|
const ObjCProtocolDecl *PD) {
|
|
|
|
llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
|
|
|
|
|
|
|
|
if (!Entry) {
|
|
|
|
// We use the initializer as a marker of whether this is a forward
|
|
|
|
// reference or not. At module finalization we add the empty
|
|
|
|
// contents for protocols which were referenced but never defined.
|
|
|
|
Entry =
|
|
|
|
new llvm::GlobalVariable(ObjCTypes.ProtocolnfABITy, false,
|
|
|
|
llvm::GlobalValue::ExternalLinkage,
|
|
|
|
0,
|
|
|
|
"\01l_OBJC_PROTOCOL_$_" + PD->getNameAsString(),
|
|
|
|
&CGM.getModule());
|
|
|
|
Entry->setSection("__DATA,__datacoal_nt,coalesced");
|
|
|
|
UsedGlobals.push_back(Entry);
|
|
|
|
}
|
|
|
|
|
|
|
|
return Entry;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// GetOrEmitProtocol - Generate the protocol meta-data:
|
|
|
|
/// @code
|
|
|
|
/// struct _protocol_t {
|
|
|
|
/// id isa; // NULL
|
|
|
|
/// const char * const protocol_name;
|
|
|
|
/// const struct _protocol_list_t * protocol_list; // super protocols
|
|
|
|
/// const struct method_list_t * const instance_methods;
|
|
|
|
/// const struct method_list_t * const class_methods;
|
|
|
|
/// const struct method_list_t *optionalInstanceMethods;
|
|
|
|
/// const struct method_list_t *optionalClassMethods;
|
|
|
|
/// const struct _prop_list_t * properties;
|
|
|
|
/// const uint32_t size; // sizeof(struct _protocol_t)
|
|
|
|
/// const uint32_t flags; // = 0
|
|
|
|
/// }
|
|
|
|
/// @endcode
|
|
|
|
///
|
|
|
|
|
|
|
|
llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol(
|
|
|
|
const ObjCProtocolDecl *PD) {
|
|
|
|
llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
|
|
|
|
|
|
|
|
// Early exit if a defining object has already been generated.
|
|
|
|
if (Entry && Entry->hasInitializer())
|
|
|
|
return Entry;
|
|
|
|
|
|
|
|
const char *ProtocolName = PD->getNameAsCString();
|
|
|
|
|
|
|
|
// Construct method lists.
|
|
|
|
std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
|
|
|
|
std::vector<llvm::Constant*> OptInstanceMethods, OptClassMethods;
|
2009-04-10 05:40:53 +08:00
|
|
|
for (ObjCProtocolDecl::instmeth_iterator
|
|
|
|
i = PD->instmeth_begin(CGM.getContext()),
|
|
|
|
e = PD->instmeth_end(CGM.getContext());
|
|
|
|
i != e; ++i) {
|
2009-01-30 03:24:30 +08:00
|
|
|
ObjCMethodDecl *MD = *i;
|
2009-01-30 08:46:37 +08:00
|
|
|
llvm::Constant *C = GetMethodDescriptionConstant(MD);
|
2009-01-30 03:24:30 +08:00
|
|
|
if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
|
|
|
|
OptInstanceMethods.push_back(C);
|
|
|
|
} else {
|
|
|
|
InstanceMethods.push_back(C);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-10 05:40:53 +08:00
|
|
|
for (ObjCProtocolDecl::classmeth_iterator
|
|
|
|
i = PD->classmeth_begin(CGM.getContext()),
|
|
|
|
e = PD->classmeth_end(CGM.getContext());
|
|
|
|
i != e; ++i) {
|
2009-01-30 03:24:30 +08:00
|
|
|
ObjCMethodDecl *MD = *i;
|
2009-01-30 08:46:37 +08:00
|
|
|
llvm::Constant *C = GetMethodDescriptionConstant(MD);
|
2009-01-30 03:24:30 +08:00
|
|
|
if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
|
|
|
|
OptClassMethods.push_back(C);
|
|
|
|
} else {
|
|
|
|
ClassMethods.push_back(C);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<llvm::Constant*> Values(10);
|
|
|
|
// isa is NULL
|
|
|
|
Values[0] = llvm::Constant::getNullValue(ObjCTypes.ObjectPtrTy);
|
|
|
|
Values[1] = GetClassName(PD->getIdentifier());
|
|
|
|
Values[2] = EmitProtocolList(
|
|
|
|
"\01l_OBJC_$_PROTOCOL_REFS_" + PD->getNameAsString(),
|
|
|
|
PD->protocol_begin(),
|
|
|
|
PD->protocol_end());
|
|
|
|
|
2009-01-30 08:46:37 +08:00
|
|
|
Values[3] = EmitMethodList("\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_"
|
2009-01-30 03:24:30 +08:00
|
|
|
+ PD->getNameAsString(),
|
|
|
|
"__DATA, __objc_const",
|
|
|
|
InstanceMethods);
|
2009-01-30 08:46:37 +08:00
|
|
|
Values[4] = EmitMethodList("\01l_OBJC_$_PROTOCOL_CLASS_METHODS_"
|
2009-01-30 03:24:30 +08:00
|
|
|
+ PD->getNameAsString(),
|
|
|
|
"__DATA, __objc_const",
|
|
|
|
ClassMethods);
|
2009-01-30 08:46:37 +08:00
|
|
|
Values[5] = EmitMethodList("\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_"
|
2009-01-30 03:24:30 +08:00
|
|
|
+ PD->getNameAsString(),
|
|
|
|
"__DATA, __objc_const",
|
|
|
|
OptInstanceMethods);
|
2009-01-30 08:46:37 +08:00
|
|
|
Values[6] = EmitMethodList("\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_"
|
2009-01-30 03:24:30 +08:00
|
|
|
+ PD->getNameAsString(),
|
|
|
|
"__DATA, __objc_const",
|
|
|
|
OptClassMethods);
|
|
|
|
Values[7] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + PD->getNameAsString(),
|
|
|
|
0, PD, ObjCTypes);
|
|
|
|
uint32_t Size =
|
|
|
|
CGM.getTargetData().getTypePaddedSize(ObjCTypes.ProtocolnfABITy);
|
|
|
|
Values[8] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
|
|
|
|
Values[9] = llvm::Constant::getNullValue(ObjCTypes.IntTy);
|
|
|
|
llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ProtocolnfABITy,
|
|
|
|
Values);
|
|
|
|
|
|
|
|
if (Entry) {
|
|
|
|
// Already created, fix the linkage and update the initializer.
|
2009-03-08 00:33:28 +08:00
|
|
|
Entry->setLinkage(llvm::GlobalValue::WeakAnyLinkage);
|
2009-01-30 03:24:30 +08:00
|
|
|
Entry->setInitializer(Init);
|
|
|
|
} else {
|
|
|
|
Entry =
|
|
|
|
new llvm::GlobalVariable(ObjCTypes.ProtocolnfABITy, false,
|
2009-03-08 00:33:28 +08:00
|
|
|
llvm::GlobalValue::WeakAnyLinkage,
|
2009-01-30 03:24:30 +08:00
|
|
|
Init,
|
|
|
|
std::string("\01l_OBJC_PROTOCOL_$_")+ProtocolName,
|
|
|
|
&CGM.getModule());
|
2009-01-31 10:43:27 +08:00
|
|
|
Entry->setAlignment(
|
|
|
|
CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.ProtocolnfABITy));
|
2009-01-30 03:24:30 +08:00
|
|
|
Entry->setSection("__DATA,__datacoal_nt,coalesced");
|
|
|
|
}
|
2009-01-30 04:10:59 +08:00
|
|
|
Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
|
|
|
|
|
|
|
|
// Use this protocol meta-data to build protocol list table in section
|
|
|
|
// __DATA, __objc_protolist
|
|
|
|
llvm::GlobalVariable *PTGV = new llvm::GlobalVariable(
|
2009-02-15 15:36:20 +08:00
|
|
|
ObjCTypes.ProtocolnfABIPtrTy, false,
|
2009-03-08 00:33:28 +08:00
|
|
|
llvm::GlobalValue::WeakAnyLinkage,
|
2009-01-30 04:10:59 +08:00
|
|
|
Entry,
|
|
|
|
std::string("\01l_OBJC_LABEL_PROTOCOL_$_")
|
|
|
|
+ProtocolName,
|
|
|
|
&CGM.getModule());
|
2009-01-31 10:43:27 +08:00
|
|
|
PTGV->setAlignment(
|
2009-02-15 15:36:20 +08:00
|
|
|
CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.ProtocolnfABIPtrTy));
|
2009-01-30 04:10:59 +08:00
|
|
|
PTGV->setSection("__DATA, __objc_protolist");
|
|
|
|
PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
|
|
|
|
UsedGlobals.push_back(PTGV);
|
2009-01-30 03:24:30 +08:00
|
|
|
return Entry;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// EmitProtocolList - Generate protocol list meta-data:
|
|
|
|
/// @code
|
|
|
|
/// struct _protocol_list_t {
|
|
|
|
/// long protocol_count; // Note, this is 32/64 bit
|
|
|
|
/// struct _protocol_t[protocol_count];
|
|
|
|
/// }
|
|
|
|
/// @endcode
|
|
|
|
///
|
|
|
|
llvm::Constant *
|
|
|
|
CGObjCNonFragileABIMac::EmitProtocolList(const std::string &Name,
|
|
|
|
ObjCProtocolDecl::protocol_iterator begin,
|
|
|
|
ObjCProtocolDecl::protocol_iterator end) {
|
|
|
|
std::vector<llvm::Constant*> ProtocolRefs;
|
|
|
|
|
|
|
|
// Just return null for empty protocol lists
|
2009-02-15 15:36:20 +08:00
|
|
|
if (begin == end)
|
2009-01-30 03:24:30 +08:00
|
|
|
return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
|
|
|
|
|
2009-02-15 15:36:20 +08:00
|
|
|
// FIXME: We shouldn't need to do this lookup here, should we?
|
2009-01-30 03:24:30 +08:00
|
|
|
llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
|
|
|
|
if (GV)
|
2009-02-15 15:36:20 +08:00
|
|
|
return llvm::ConstantExpr::getBitCast(GV,
|
|
|
|
ObjCTypes.ProtocolListnfABIPtrTy);
|
|
|
|
|
|
|
|
for (; begin != end; ++begin)
|
|
|
|
ProtocolRefs.push_back(GetProtocolRef(*begin)); // Implemented???
|
|
|
|
|
2009-01-30 03:24:30 +08:00
|
|
|
// This list is null terminated.
|
|
|
|
ProtocolRefs.push_back(llvm::Constant::getNullValue(
|
2009-02-15 15:36:20 +08:00
|
|
|
ObjCTypes.ProtocolnfABIPtrTy));
|
2009-01-30 03:24:30 +08:00
|
|
|
|
|
|
|
std::vector<llvm::Constant*> Values(2);
|
|
|
|
Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, ProtocolRefs.size() - 1);
|
|
|
|
Values[1] =
|
2009-02-15 15:36:20 +08:00
|
|
|
llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.ProtocolnfABIPtrTy,
|
2009-01-30 03:24:30 +08:00
|
|
|
ProtocolRefs.size()),
|
|
|
|
ProtocolRefs);
|
|
|
|
|
|
|
|
llvm::Constant *Init = llvm::ConstantStruct::get(Values);
|
|
|
|
GV = new llvm::GlobalVariable(Init->getType(), false,
|
|
|
|
llvm::GlobalValue::InternalLinkage,
|
|
|
|
Init,
|
|
|
|
Name,
|
|
|
|
&CGM.getModule());
|
|
|
|
GV->setSection("__DATA, __objc_const");
|
2009-01-31 10:43:27 +08:00
|
|
|
GV->setAlignment(
|
|
|
|
CGM.getTargetData().getPrefTypeAlignment(Init->getType()));
|
2009-01-30 03:24:30 +08:00
|
|
|
UsedGlobals.push_back(GV);
|
2009-02-15 15:36:20 +08:00
|
|
|
return llvm::ConstantExpr::getBitCast(GV,
|
|
|
|
ObjCTypes.ProtocolListnfABIPtrTy);
|
2009-01-30 03:24:30 +08:00
|
|
|
}
|
|
|
|
|
2009-01-30 08:46:37 +08:00
|
|
|
/// GetMethodDescriptionConstant - This routine build following meta-data:
|
|
|
|
/// struct _objc_method {
|
|
|
|
/// SEL _cmd;
|
|
|
|
/// char *method_type;
|
|
|
|
/// char *_imp;
|
|
|
|
/// }
|
|
|
|
|
|
|
|
llvm::Constant *
|
|
|
|
CGObjCNonFragileABIMac::GetMethodDescriptionConstant(const ObjCMethodDecl *MD) {
|
|
|
|
std::vector<llvm::Constant*> Desc(3);
|
|
|
|
Desc[0] = llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
|
|
|
|
ObjCTypes.SelectorPtrTy);
|
|
|
|
Desc[1] = GetMethodVarType(MD);
|
2009-01-31 02:58:59 +08:00
|
|
|
// Protocol methods have no implementation. So, this entry is always NULL.
|
2009-01-30 08:46:37 +08:00
|
|
|
Desc[2] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
|
|
|
|
return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Desc);
|
|
|
|
}
|
2009-02-03 08:09:52 +08:00
|
|
|
|
|
|
|
/// EmitObjCValueForIvar - Code Gen for nonfragile ivar reference.
|
|
|
|
/// This code gen. amounts to generating code for:
|
|
|
|
/// @code
|
|
|
|
/// (type *)((char *)base + _OBJC_IVAR_$_.ivar;
|
|
|
|
/// @encode
|
|
|
|
///
|
2009-02-04 03:03:09 +08:00
|
|
|
LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar(
|
2009-02-03 08:09:52 +08:00
|
|
|
CodeGen::CodeGenFunction &CGF,
|
|
|
|
QualType ObjectTy,
|
|
|
|
llvm::Value *BaseValue,
|
|
|
|
const ObjCIvarDecl *Ivar,
|
|
|
|
const FieldDecl *Field,
|
|
|
|
unsigned CVRQualifiers) {
|
|
|
|
assert(ObjectTy->isObjCInterfaceType() &&
|
|
|
|
"CGObjCNonFragileABIMac::EmitObjCValueForIvar");
|
2009-02-13 02:51:23 +08:00
|
|
|
ObjCInterfaceDecl *ID = ObjectTy->getAsObjCInterfaceType()->getDecl();
|
2009-02-11 04:21:06 +08:00
|
|
|
std::string ExternalName;
|
|
|
|
llvm::GlobalVariable *IvarOffsetGV =
|
|
|
|
ObjCIvarOffsetVariable(ExternalName, ID, Ivar);
|
2009-02-04 03:03:09 +08:00
|
|
|
|
2009-02-03 08:09:52 +08:00
|
|
|
// (char *) BaseValue
|
|
|
|
llvm::Value *V = CGF.Builder.CreateBitCast(BaseValue,
|
|
|
|
ObjCTypes.Int8PtrTy);
|
|
|
|
llvm::Value *Offset = CGF.Builder.CreateLoad(IvarOffsetGV);
|
|
|
|
// (char*)BaseValue + Offset_symbol
|
|
|
|
V = CGF.Builder.CreateGEP(V, Offset, "add.ptr");
|
|
|
|
// (type *)((char*)BaseValue + Offset_symbol)
|
|
|
|
const llvm::Type *IvarTy =
|
|
|
|
CGM.getTypes().ConvertType(Ivar->getType());
|
|
|
|
llvm::Type *ptrIvarTy = llvm::PointerType::getUnqual(IvarTy);
|
|
|
|
V = CGF.Builder.CreateBitCast(V, ptrIvarTy);
|
2009-02-04 03:03:09 +08:00
|
|
|
|
2009-03-10 04:44:22 +08:00
|
|
|
if (Ivar->isBitField()) {
|
|
|
|
CodeGenTypes::BitFieldInfo bitFieldInfo =
|
|
|
|
CGM.getTypes().getBitFieldInfo(Field);
|
|
|
|
return LValue::MakeBitfield(V, bitFieldInfo.Begin, bitFieldInfo.Size,
|
|
|
|
Field->getType()->isSignedIntegerType(),
|
|
|
|
Field->getType().getCVRQualifiers()|CVRQualifiers);
|
|
|
|
}
|
|
|
|
|
2009-02-04 03:03:09 +08:00
|
|
|
LValue LV = LValue::MakeAddr(V,
|
2009-02-20 07:36:06 +08:00
|
|
|
Ivar->getType().getCVRQualifiers()|CVRQualifiers,
|
|
|
|
CGM.getContext().getObjCGCAttrKind(Ivar->getType()));
|
2009-02-04 03:03:09 +08:00
|
|
|
LValue::SetObjCIvar(LV, true);
|
|
|
|
return LV;
|
2009-02-03 08:09:52 +08:00
|
|
|
}
|
|
|
|
|
2009-02-11 03:02:04 +08:00
|
|
|
llvm::Value *CGObjCNonFragileABIMac::EmitIvarOffset(
|
|
|
|
CodeGen::CodeGenFunction &CGF,
|
|
|
|
ObjCInterfaceDecl *Interface,
|
|
|
|
const ObjCIvarDecl *Ivar) {
|
2009-02-11 04:21:06 +08:00
|
|
|
std::string ExternalName;
|
|
|
|
llvm::GlobalVariable *IvarOffsetGV =
|
|
|
|
ObjCIvarOffsetVariable(ExternalName, Interface, Ivar);
|
|
|
|
|
|
|
|
return CGF.Builder.CreateLoad(IvarOffsetGV, false, "ivar");
|
2009-02-11 03:02:04 +08:00
|
|
|
}
|
|
|
|
|
2009-02-04 08:22:57 +08:00
|
|
|
CodeGen::RValue CGObjCNonFragileABIMac::EmitMessageSend(
|
|
|
|
CodeGen::CodeGenFunction &CGF,
|
|
|
|
QualType ResultType,
|
|
|
|
Selector Sel,
|
2009-02-05 04:42:28 +08:00
|
|
|
llvm::Value *Receiver,
|
2009-02-04 08:22:57 +08:00
|
|
|
QualType Arg0Ty,
|
|
|
|
bool IsSuper,
|
|
|
|
const CallArgList &CallArgs) {
|
2009-02-05 04:42:28 +08:00
|
|
|
// FIXME. Even though IsSuper is passes. This function doese not
|
|
|
|
// handle calls to 'super' receivers.
|
|
|
|
CodeGenTypes &Types = CGM.getTypes();
|
2009-02-07 04:09:23 +08:00
|
|
|
llvm::Value *Arg0 = Receiver;
|
|
|
|
if (!IsSuper)
|
|
|
|
Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy, "tmp");
|
2009-02-05 04:42:28 +08:00
|
|
|
|
|
|
|
// Find the message function name.
|
2009-02-05 09:13:09 +08:00
|
|
|
// FIXME. This is too much work to get the ABI-specific result type
|
|
|
|
// needed to find the message name.
|
2009-02-05 04:42:28 +08:00
|
|
|
const CGFunctionInfo &FnInfo = Types.getFunctionInfo(ResultType,
|
|
|
|
llvm::SmallVector<QualType, 16>());
|
|
|
|
llvm::Constant *Fn;
|
|
|
|
std::string Name("\01l_");
|
|
|
|
if (CGM.ReturnTypeUsesSret(FnInfo)) {
|
2009-02-06 02:00:27 +08:00
|
|
|
#if 0
|
|
|
|
// unlike what is documented. gcc never generates this API!!
|
2009-02-05 04:42:28 +08:00
|
|
|
if (Receiver->getType() == ObjCTypes.ObjectPtrTy) {
|
|
|
|
Fn = ObjCTypes.MessageSendIdStretFixupFn;
|
|
|
|
// FIXME. Is there a better way of getting these names.
|
|
|
|
// They are available in RuntimeFunctions vector pair.
|
|
|
|
Name += "objc_msgSendId_stret_fixup";
|
|
|
|
}
|
2009-02-06 02:00:27 +08:00
|
|
|
else
|
|
|
|
#endif
|
2009-02-07 04:09:23 +08:00
|
|
|
if (IsSuper) {
|
|
|
|
Fn = ObjCTypes.MessageSendSuper2StretFixupFn;
|
|
|
|
Name += "objc_msgSendSuper2_stret_fixup";
|
|
|
|
}
|
|
|
|
else
|
2009-02-06 02:00:27 +08:00
|
|
|
{
|
2009-02-05 04:42:28 +08:00
|
|
|
Fn = ObjCTypes.MessageSendStretFixupFn;
|
|
|
|
Name += "objc_msgSend_stret_fixup";
|
|
|
|
}
|
|
|
|
}
|
2009-02-06 03:35:43 +08:00
|
|
|
else if (ResultType->isFloatingType() &&
|
|
|
|
// Selection of frret API only happens in 32bit nonfragile ABI.
|
|
|
|
CGM.getTargetData().getTypePaddedSize(ObjCTypes.LongTy) == 4) {
|
2009-02-05 04:42:28 +08:00
|
|
|
Fn = ObjCTypes.MessageSendFpretFixupFn;
|
|
|
|
Name += "objc_msgSend_fpret_fixup";
|
|
|
|
}
|
|
|
|
else {
|
2009-02-06 02:00:27 +08:00
|
|
|
#if 0
|
|
|
|
// unlike what is documented. gcc never generates this API!!
|
2009-02-05 04:42:28 +08:00
|
|
|
if (Receiver->getType() == ObjCTypes.ObjectPtrTy) {
|
|
|
|
Fn = ObjCTypes.MessageSendIdFixupFn;
|
|
|
|
Name += "objc_msgSendId_fixup";
|
|
|
|
}
|
2009-02-06 02:00:27 +08:00
|
|
|
else
|
|
|
|
#endif
|
2009-02-07 04:09:23 +08:00
|
|
|
if (IsSuper) {
|
|
|
|
Fn = ObjCTypes.MessageSendSuper2FixupFn;
|
|
|
|
Name += "objc_msgSendSuper2_fixup";
|
|
|
|
}
|
|
|
|
else
|
2009-02-06 02:00:27 +08:00
|
|
|
{
|
2009-02-05 04:42:28 +08:00
|
|
|
Fn = ObjCTypes.MessageSendFixupFn;
|
|
|
|
Name += "objc_msgSend_fixup";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Name += '_';
|
|
|
|
std::string SelName(Sel.getAsString());
|
|
|
|
// Replace all ':' in selector name with '_' ouch!
|
|
|
|
for(unsigned i = 0; i < SelName.size(); i++)
|
|
|
|
if (SelName[i] == ':')
|
|
|
|
SelName[i] = '_';
|
|
|
|
Name += SelName;
|
|
|
|
llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
|
|
|
|
if (!GV) {
|
|
|
|
// Build messafe ref table entry.
|
|
|
|
std::vector<llvm::Constant*> Values(2);
|
|
|
|
Values[0] = Fn;
|
|
|
|
Values[1] = GetMethodVarName(Sel);
|
|
|
|
llvm::Constant *Init = llvm::ConstantStruct::get(Values);
|
|
|
|
GV = new llvm::GlobalVariable(Init->getType(), false,
|
2009-03-08 00:33:28 +08:00
|
|
|
llvm::GlobalValue::WeakAnyLinkage,
|
2009-02-05 04:42:28 +08:00
|
|
|
Init,
|
|
|
|
Name,
|
|
|
|
&CGM.getModule());
|
|
|
|
GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
|
|
|
|
GV->setAlignment(
|
|
|
|
CGM.getTargetData().getPrefTypeAlignment(ObjCTypes.MessageRefTy));
|
|
|
|
GV->setSection("__DATA, __objc_msgrefs, coalesced");
|
|
|
|
UsedGlobals.push_back(GV);
|
|
|
|
}
|
|
|
|
llvm::Value *Arg1 = CGF.Builder.CreateBitCast(GV, ObjCTypes.MessageRefPtrTy);
|
2009-02-05 09:13:09 +08:00
|
|
|
|
2009-02-05 04:42:28 +08:00
|
|
|
CallArgList ActualArgs;
|
|
|
|
ActualArgs.push_back(std::make_pair(RValue::get(Arg0), Arg0Ty));
|
|
|
|
ActualArgs.push_back(std::make_pair(RValue::get(Arg1),
|
|
|
|
ObjCTypes.MessageRefCPtrTy));
|
|
|
|
ActualArgs.insert(ActualArgs.end(), CallArgs.begin(), CallArgs.end());
|
2009-02-05 09:13:09 +08:00
|
|
|
const CGFunctionInfo &FnInfo1 = Types.getFunctionInfo(ResultType, ActualArgs);
|
|
|
|
llvm::Value *Callee = CGF.Builder.CreateStructGEP(Arg1, 0);
|
|
|
|
Callee = CGF.Builder.CreateLoad(Callee);
|
2009-02-15 05:25:36 +08:00
|
|
|
const llvm::FunctionType *FTy = Types.GetFunctionType(FnInfo1, true);
|
2009-02-05 09:13:09 +08:00
|
|
|
Callee = CGF.Builder.CreateBitCast(Callee,
|
|
|
|
llvm::PointerType::getUnqual(FTy));
|
|
|
|
return CGF.EmitCall(FnInfo1, Callee, ActualArgs);
|
2009-02-04 08:22:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Generate code for a message send expression in the nonfragile abi.
|
|
|
|
CodeGen::RValue CGObjCNonFragileABIMac::GenerateMessageSend(
|
|
|
|
CodeGen::CodeGenFunction &CGF,
|
|
|
|
QualType ResultType,
|
|
|
|
Selector Sel,
|
|
|
|
llvm::Value *Receiver,
|
|
|
|
bool IsClassMessage,
|
|
|
|
const CallArgList &CallArgs) {
|
|
|
|
return EmitMessageSend(CGF, ResultType, Sel,
|
2009-02-05 04:42:28 +08:00
|
|
|
Receiver, CGF.getContext().getObjCIdType(),
|
2009-02-04 08:22:57 +08:00
|
|
|
false, CallArgs);
|
|
|
|
}
|
|
|
|
|
2009-03-01 12:40:10 +08:00
|
|
|
llvm::GlobalVariable *
|
2009-04-07 13:48:37 +08:00
|
|
|
CGObjCNonFragileABIMac::GetClassGlobal(const std::string &Name,
|
|
|
|
bool AddToUsed) {
|
2009-03-01 12:40:10 +08:00
|
|
|
llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
|
|
|
|
|
2009-03-02 13:18:14 +08:00
|
|
|
if (!GV) {
|
2009-03-01 12:40:10 +08:00
|
|
|
GV = new llvm::GlobalVariable(ObjCTypes.ClassnfABITy, false,
|
|
|
|
llvm::GlobalValue::ExternalLinkage,
|
|
|
|
0, Name, &CGM.getModule());
|
2009-04-07 13:48:37 +08:00
|
|
|
if (AddToUsed)
|
|
|
|
UsedGlobals.push_back(GV);
|
2009-03-01 12:40:10 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return GV;
|
|
|
|
}
|
|
|
|
|
2009-02-06 04:41:40 +08:00
|
|
|
llvm::Value *CGObjCNonFragileABIMac::EmitClassRef(CGBuilderTy &Builder,
|
2009-02-07 04:09:23 +08:00
|
|
|
const ObjCInterfaceDecl *ID,
|
|
|
|
bool IsSuper) {
|
2009-02-06 04:41:40 +08:00
|
|
|
|
|
|
|
llvm::GlobalVariable *&Entry = ClassReferences[ID->getIdentifier()];
|
|
|
|
|
|
|
|
if (!Entry) {
|
2009-04-07 13:48:37 +08:00
|
|
|
std::string ClassName(getClassSymbolPrefix() + ID->getNameAsString());
|
2009-03-01 12:40:10 +08:00
|
|
|
llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName);
|
2009-02-06 04:41:40 +08:00
|
|
|
Entry =
|
|
|
|
new llvm::GlobalVariable(ObjCTypes.ClassnfABIPtrTy, false,
|
|
|
|
llvm::GlobalValue::InternalLinkage,
|
2009-02-07 04:09:23 +08:00
|
|
|
ClassGV,
|
|
|
|
IsSuper ? "\01L_OBJC_CLASSLIST_SUP_REFS_$_"
|
|
|
|
: "\01L_OBJC_CLASSLIST_REFERENCES_$_",
|
2009-02-06 04:41:40 +08:00
|
|
|
&CGM.getModule());
|
|
|
|
Entry->setAlignment(
|
|
|
|
CGM.getTargetData().getPrefTypeAlignment(
|
|
|
|
ObjCTypes.ClassnfABIPtrTy));
|
|
|
|
|
2009-02-07 04:09:23 +08:00
|
|
|
if (IsSuper)
|
2009-02-27 06:30:39 +08:00
|
|
|
Entry->setSection("__DATA,__objc_superrefs,regular,no_dead_strip");
|
2009-02-07 04:09:23 +08:00
|
|
|
else
|
2009-02-27 06:30:39 +08:00
|
|
|
Entry->setSection("__DATA,__objc_classrefs,regular,no_dead_strip");
|
2009-02-06 04:41:40 +08:00
|
|
|
UsedGlobals.push_back(Entry);
|
|
|
|
}
|
|
|
|
|
|
|
|
return Builder.CreateLoad(Entry, false, "tmp");
|
|
|
|
}
|
|
|
|
|
2009-02-07 04:09:23 +08:00
|
|
|
/// EmitMetaClassRef - Return a Value * of the address of _class_t
|
|
|
|
/// meta-data
|
|
|
|
///
|
|
|
|
llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef(CGBuilderTy &Builder,
|
|
|
|
const ObjCInterfaceDecl *ID) {
|
|
|
|
llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()];
|
|
|
|
if (Entry)
|
|
|
|
return Builder.CreateLoad(Entry, false, "tmp");
|
|
|
|
|
2009-04-07 13:48:37 +08:00
|
|
|
std::string MetaClassName(getMetaclassSymbolPrefix() + ID->getNameAsString());
|
|
|
|
llvm::GlobalVariable *MetaClassGV = GetClassGlobal(MetaClassName, false);
|
2009-02-07 04:09:23 +08:00
|
|
|
Entry =
|
|
|
|
new llvm::GlobalVariable(ObjCTypes.ClassnfABIPtrTy, false,
|
|
|
|
llvm::GlobalValue::InternalLinkage,
|
|
|
|
MetaClassGV,
|
|
|
|
"\01L_OBJC_CLASSLIST_SUP_REFS_$_",
|
|
|
|
&CGM.getModule());
|
|
|
|
Entry->setAlignment(
|
|
|
|
CGM.getTargetData().getPrefTypeAlignment(
|
|
|
|
ObjCTypes.ClassnfABIPtrTy));
|
|
|
|
|
|
|
|
Entry->setSection("__OBJC,__objc_superrefs,regular,no_dead_strip");
|
|
|
|
UsedGlobals.push_back(Entry);
|
|
|
|
|
|
|
|
return Builder.CreateLoad(Entry, false, "tmp");
|
|
|
|
}
|
|
|
|
|
2009-02-06 04:41:40 +08:00
|
|
|
/// GetClass - Return a reference to the class for the given interface
|
|
|
|
/// decl.
|
|
|
|
llvm::Value *CGObjCNonFragileABIMac::GetClass(CGBuilderTy &Builder,
|
|
|
|
const ObjCInterfaceDecl *ID) {
|
|
|
|
return EmitClassRef(Builder, ID);
|
|
|
|
}
|
|
|
|
|
2009-02-07 04:09:23 +08:00
|
|
|
/// Generates a message send where the super is the receiver. This is
|
|
|
|
/// a message send to self with special delivery semantics indicating
|
|
|
|
/// which class's method should be called.
|
|
|
|
CodeGen::RValue
|
|
|
|
CGObjCNonFragileABIMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
|
|
|
|
QualType ResultType,
|
|
|
|
Selector Sel,
|
|
|
|
const ObjCInterfaceDecl *Class,
|
2009-03-01 04:07:56 +08:00
|
|
|
bool isCategoryImpl,
|
2009-02-07 04:09:23 +08:00
|
|
|
llvm::Value *Receiver,
|
|
|
|
bool IsClassMessage,
|
|
|
|
const CodeGen::CallArgList &CallArgs) {
|
|
|
|
// ...
|
|
|
|
// Create and init a super structure; this is a (receiver, class)
|
|
|
|
// pair we will pass to objc_msgSendSuper.
|
|
|
|
llvm::Value *ObjCSuper =
|
|
|
|
CGF.Builder.CreateAlloca(ObjCTypes.SuperTy, 0, "objc_super");
|
|
|
|
|
|
|
|
llvm::Value *ReceiverAsObject =
|
|
|
|
CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
|
|
|
|
CGF.Builder.CreateStore(ReceiverAsObject,
|
|
|
|
CGF.Builder.CreateStructGEP(ObjCSuper, 0));
|
|
|
|
|
|
|
|
// If this is a class message the metaclass is passed as the target.
|
2009-03-01 04:07:56 +08:00
|
|
|
llvm::Value *Target;
|
|
|
|
if (IsClassMessage) {
|
|
|
|
if (isCategoryImpl) {
|
|
|
|
// Message sent to "super' in a class method defined in
|
|
|
|
// a category implementation.
|
|
|
|
Target = EmitClassRef(CGF.Builder, Class, false);
|
|
|
|
Target = CGF.Builder.CreateStructGEP(Target, 0);
|
|
|
|
Target = CGF.Builder.CreateLoad(Target);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
Target = EmitMetaClassRef(CGF.Builder, Class);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
Target = EmitClassRef(CGF.Builder, Class, true);
|
2009-02-07 04:09:23 +08:00
|
|
|
|
|
|
|
// FIXME: We shouldn't need to do this cast, rectify the ASTContext
|
|
|
|
// and ObjCTypes types.
|
|
|
|
const llvm::Type *ClassTy =
|
|
|
|
CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
|
|
|
|
Target = CGF.Builder.CreateBitCast(Target, ClassTy);
|
|
|
|
CGF.Builder.CreateStore(Target,
|
|
|
|
CGF.Builder.CreateStructGEP(ObjCSuper, 1));
|
|
|
|
|
|
|
|
return EmitMessageSend(CGF, ResultType, Sel,
|
|
|
|
ObjCSuper, ObjCTypes.SuperPtrCTy,
|
|
|
|
true, CallArgs);
|
|
|
|
}
|
2009-02-12 04:51:17 +08:00
|
|
|
|
|
|
|
llvm::Value *CGObjCNonFragileABIMac::EmitSelector(CGBuilderTy &Builder,
|
|
|
|
Selector Sel) {
|
|
|
|
llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
|
|
|
|
|
|
|
|
if (!Entry) {
|
|
|
|
llvm::Constant *Casted =
|
|
|
|
llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
|
|
|
|
ObjCTypes.SelectorPtrTy);
|
|
|
|
Entry =
|
|
|
|
new llvm::GlobalVariable(ObjCTypes.SelectorPtrTy, false,
|
|
|
|
llvm::GlobalValue::InternalLinkage,
|
|
|
|
Casted, "\01L_OBJC_SELECTOR_REFERENCES_",
|
|
|
|
&CGM.getModule());
|
|
|
|
Entry->setSection("__DATA,__objc_selrefs,literal_pointers,no_dead_strip");
|
|
|
|
UsedGlobals.push_back(Entry);
|
|
|
|
}
|
|
|
|
|
|
|
|
return Builder.CreateLoad(Entry, false, "tmp");
|
|
|
|
}
|
2009-02-17 06:52:32 +08:00
|
|
|
/// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
|
|
|
|
/// objc_assign_ivar (id src, id *dst)
|
|
|
|
///
|
|
|
|
void CGObjCNonFragileABIMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
|
|
|
|
llvm::Value *src, llvm::Value *dst)
|
|
|
|
{
|
2009-03-24 03:10:40 +08:00
|
|
|
const llvm::Type * SrcTy = src->getType();
|
|
|
|
if (!isa<llvm::PointerType>(SrcTy)) {
|
|
|
|
unsigned Size = CGM.getTargetData().getTypePaddedSize(SrcTy);
|
|
|
|
assert(Size <= 8 && "does not support size > 8");
|
|
|
|
src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
|
|
|
|
: CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
|
2009-03-13 08:42:52 +08:00
|
|
|
src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
|
|
|
|
}
|
2009-02-17 06:52:32 +08:00
|
|
|
src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
|
|
|
|
dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
|
|
|
|
CGF.Builder.CreateCall2(ObjCTypes.GcAssignIvarFn,
|
|
|
|
src, dst, "assignivar");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
|
|
|
|
/// objc_assign_strongCast (id src, id *dst)
|
|
|
|
///
|
|
|
|
void CGObjCNonFragileABIMac::EmitObjCStrongCastAssign(
|
|
|
|
CodeGen::CodeGenFunction &CGF,
|
|
|
|
llvm::Value *src, llvm::Value *dst)
|
|
|
|
{
|
2009-03-24 03:10:40 +08:00
|
|
|
const llvm::Type * SrcTy = src->getType();
|
|
|
|
if (!isa<llvm::PointerType>(SrcTy)) {
|
|
|
|
unsigned Size = CGM.getTargetData().getTypePaddedSize(SrcTy);
|
|
|
|
assert(Size <= 8 && "does not support size > 8");
|
|
|
|
src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
|
|
|
|
: CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
|
2009-03-13 08:42:52 +08:00
|
|
|
src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
|
|
|
|
}
|
2009-02-17 06:52:32 +08:00
|
|
|
src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
|
|
|
|
dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
|
|
|
|
CGF.Builder.CreateCall2(ObjCTypes.GcAssignStrongCastFn,
|
|
|
|
src, dst, "weakassign");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// EmitObjCWeakRead - Code gen for loading value of a __weak
|
|
|
|
/// object: objc_read_weak (id *src)
|
|
|
|
///
|
|
|
|
llvm::Value * CGObjCNonFragileABIMac::EmitObjCWeakRead(
|
|
|
|
CodeGen::CodeGenFunction &CGF,
|
|
|
|
llvm::Value *AddrWeakObj)
|
|
|
|
{
|
2009-03-07 11:57:15 +08:00
|
|
|
const llvm::Type* DestTy =
|
|
|
|
cast<llvm::PointerType>(AddrWeakObj->getType())->getElementType();
|
2009-02-17 06:52:32 +08:00
|
|
|
AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy);
|
|
|
|
llvm::Value *read_weak = CGF.Builder.CreateCall(ObjCTypes.GcReadWeakFn,
|
|
|
|
AddrWeakObj, "weakread");
|
2009-03-07 11:57:15 +08:00
|
|
|
read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
|
2009-02-17 06:52:32 +08:00
|
|
|
return read_weak;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
|
|
|
|
/// objc_assign_weak (id src, id *dst)
|
|
|
|
///
|
|
|
|
void CGObjCNonFragileABIMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
|
|
|
|
llvm::Value *src, llvm::Value *dst)
|
|
|
|
{
|
2009-03-24 03:10:40 +08:00
|
|
|
const llvm::Type * SrcTy = src->getType();
|
|
|
|
if (!isa<llvm::PointerType>(SrcTy)) {
|
|
|
|
unsigned Size = CGM.getTargetData().getTypePaddedSize(SrcTy);
|
|
|
|
assert(Size <= 8 && "does not support size > 8");
|
|
|
|
src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
|
|
|
|
: CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
|
2009-03-13 08:42:52 +08:00
|
|
|
src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
|
|
|
|
}
|
2009-02-17 06:52:32 +08:00
|
|
|
src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
|
|
|
|
dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
|
|
|
|
CGF.Builder.CreateCall2(ObjCTypes.GcAssignWeakFn,
|
|
|
|
src, dst, "weakassign");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
|
|
|
|
/// objc_assign_global (id src, id *dst)
|
|
|
|
///
|
|
|
|
void CGObjCNonFragileABIMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
|
|
|
|
llvm::Value *src, llvm::Value *dst)
|
|
|
|
{
|
2009-03-24 03:10:40 +08:00
|
|
|
const llvm::Type * SrcTy = src->getType();
|
|
|
|
if (!isa<llvm::PointerType>(SrcTy)) {
|
|
|
|
unsigned Size = CGM.getTargetData().getTypePaddedSize(SrcTy);
|
|
|
|
assert(Size <= 8 && "does not support size > 8");
|
|
|
|
src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
|
|
|
|
: CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
|
2009-03-13 08:42:52 +08:00
|
|
|
src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
|
|
|
|
}
|
2009-02-17 06:52:32 +08:00
|
|
|
src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
|
|
|
|
dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
|
|
|
|
CGF.Builder.CreateCall2(ObjCTypes.GcAssignGlobalFn,
|
|
|
|
src, dst, "globalassign");
|
|
|
|
return;
|
|
|
|
}
|
2009-02-12 04:51:17 +08:00
|
|
|
|
2009-02-24 15:47:38 +08:00
|
|
|
void
|
|
|
|
CGObjCNonFragileABIMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
|
|
|
|
const Stmt &S) {
|
|
|
|
bool isTry = isa<ObjCAtTryStmt>(S);
|
|
|
|
llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
|
|
|
|
llvm::BasicBlock *PrevLandingPad = CGF.getInvokeDest();
|
2009-03-02 14:08:11 +08:00
|
|
|
llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
|
2009-02-24 15:47:38 +08:00
|
|
|
llvm::BasicBlock *FinallyBlock = CGF.createBasicBlock("finally");
|
2009-03-02 14:08:11 +08:00
|
|
|
llvm::BasicBlock *FinallyRethrow = CGF.createBasicBlock("finally.throw");
|
2009-02-24 15:47:38 +08:00
|
|
|
llvm::BasicBlock *FinallyEnd = CGF.createBasicBlock("finally.end");
|
|
|
|
|
|
|
|
// For @synchronized, call objc_sync_enter(sync.expr). The
|
|
|
|
// evaluation of the expression must occur before we enter the
|
|
|
|
// @synchronized. We can safely avoid a temp here because jumps into
|
|
|
|
// @synchronized are illegal & this will dominate uses.
|
|
|
|
llvm::Value *SyncArg = 0;
|
|
|
|
if (!isTry) {
|
|
|
|
SyncArg =
|
|
|
|
CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
|
|
|
|
SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
|
2009-04-07 00:53:45 +08:00
|
|
|
CGF.Builder.CreateCall(ObjCTypes.getSyncEnterFn(), SyncArg);
|
2009-02-24 15:47:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Push an EH context entry, used for handling rethrows and jumps
|
|
|
|
// through finally.
|
|
|
|
CGF.PushCleanupBlock(FinallyBlock);
|
|
|
|
|
2009-03-02 14:08:11 +08:00
|
|
|
CGF.setInvokeDest(TryHandler);
|
2009-02-24 15:47:38 +08:00
|
|
|
|
|
|
|
CGF.EmitBlock(TryBlock);
|
|
|
|
CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
|
|
|
|
: cast<ObjCAtSynchronizedStmt>(S).getSynchBody());
|
|
|
|
CGF.EmitBranchThroughCleanup(FinallyEnd);
|
|
|
|
|
2009-03-02 14:08:11 +08:00
|
|
|
// Emit the exception handler.
|
|
|
|
|
|
|
|
CGF.EmitBlock(TryHandler);
|
|
|
|
|
|
|
|
llvm::Value *llvm_eh_exception =
|
|
|
|
CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_exception);
|
|
|
|
llvm::Value *llvm_eh_selector_i64 =
|
|
|
|
CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_selector_i64);
|
|
|
|
llvm::Value *llvm_eh_typeid_for_i64 =
|
|
|
|
CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for_i64);
|
|
|
|
llvm::Value *Exc = CGF.Builder.CreateCall(llvm_eh_exception, "exc");
|
|
|
|
llvm::Value *RethrowPtr = CGF.CreateTempAlloca(Exc->getType(), "_rethrow");
|
|
|
|
|
|
|
|
llvm::SmallVector<llvm::Value*, 8> SelectorArgs;
|
|
|
|
SelectorArgs.push_back(Exc);
|
2009-04-07 00:53:45 +08:00
|
|
|
SelectorArgs.push_back(ObjCTypes.getEHPersonalityPtr());
|
2009-03-02 14:08:11 +08:00
|
|
|
|
|
|
|
// Construct the lists of (type, catch body) to handle.
|
2009-03-06 08:01:21 +08:00
|
|
|
llvm::SmallVector<std::pair<const ParmVarDecl*, const Stmt*>, 8> Handlers;
|
2009-03-02 14:08:11 +08:00
|
|
|
bool HasCatchAll = false;
|
|
|
|
if (isTry) {
|
|
|
|
if (const ObjCAtCatchStmt* CatchStmt =
|
|
|
|
cast<ObjCAtTryStmt>(S).getCatchStmts()) {
|
|
|
|
for (; CatchStmt; CatchStmt = CatchStmt->getNextCatchStmt()) {
|
2009-03-06 08:01:21 +08:00
|
|
|
const ParmVarDecl *CatchDecl = CatchStmt->getCatchParamDecl();
|
2009-03-04 03:52:17 +08:00
|
|
|
Handlers.push_back(std::make_pair(CatchDecl, CatchStmt->getCatchBody()));
|
2009-03-02 14:08:11 +08:00
|
|
|
|
|
|
|
// catch(...) always matches.
|
2009-03-04 03:52:17 +08:00
|
|
|
if (!CatchDecl) {
|
2009-03-02 14:08:11 +08:00
|
|
|
// Use i8* null here to signal this is a catch all, not a cleanup.
|
|
|
|
llvm::Value *Null = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
|
|
|
|
SelectorArgs.push_back(Null);
|
|
|
|
HasCatchAll = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-03-06 08:01:21 +08:00
|
|
|
if (CGF.getContext().isObjCIdType(CatchDecl->getType()) ||
|
|
|
|
CatchDecl->getType()->isObjCQualifiedIdType()) {
|
2009-03-02 14:08:11 +08:00
|
|
|
llvm::Value *IDEHType =
|
|
|
|
CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id");
|
|
|
|
if (!IDEHType)
|
|
|
|
IDEHType =
|
|
|
|
new llvm::GlobalVariable(ObjCTypes.EHTypeTy, false,
|
|
|
|
llvm::GlobalValue::ExternalLinkage,
|
|
|
|
0, "OBJC_EHTYPE_id", &CGM.getModule());
|
|
|
|
SelectorArgs.push_back(IDEHType);
|
|
|
|
HasCatchAll = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// All other types should be Objective-C interface pointer types.
|
2009-03-06 08:01:21 +08:00
|
|
|
const PointerType *PT = CatchDecl->getType()->getAsPointerType();
|
2009-03-02 14:08:11 +08:00
|
|
|
assert(PT && "Invalid @catch type.");
|
|
|
|
const ObjCInterfaceType *IT =
|
|
|
|
PT->getPointeeType()->getAsObjCInterfaceType();
|
|
|
|
assert(IT && "Invalid @catch type.");
|
2009-04-08 12:21:03 +08:00
|
|
|
llvm::Value *EHType = GetInterfaceEHType(IT->getDecl(), false);
|
2009-03-02 14:08:11 +08:00
|
|
|
SelectorArgs.push_back(EHType);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// We use a cleanup unless there was already a catch all.
|
|
|
|
if (!HasCatchAll) {
|
|
|
|
SelectorArgs.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, 0));
|
2009-03-06 08:01:21 +08:00
|
|
|
Handlers.push_back(std::make_pair((const ParmVarDecl*) 0, (const Stmt*) 0));
|
2009-03-02 14:08:11 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
llvm::Value *Selector =
|
|
|
|
CGF.Builder.CreateCall(llvm_eh_selector_i64,
|
|
|
|
SelectorArgs.begin(), SelectorArgs.end(),
|
|
|
|
"selector");
|
|
|
|
for (unsigned i = 0, e = Handlers.size(); i != e; ++i) {
|
2009-03-06 08:01:21 +08:00
|
|
|
const ParmVarDecl *CatchParam = Handlers[i].first;
|
2009-03-02 14:08:11 +08:00
|
|
|
const Stmt *CatchBody = Handlers[i].second;
|
|
|
|
|
|
|
|
llvm::BasicBlock *Next = 0;
|
|
|
|
|
|
|
|
// The last handler always matches.
|
|
|
|
if (i + 1 != e) {
|
|
|
|
assert(CatchParam && "Only last handler can be a catch all.");
|
|
|
|
|
|
|
|
llvm::BasicBlock *Match = CGF.createBasicBlock("match");
|
|
|
|
Next = CGF.createBasicBlock("catch.next");
|
|
|
|
llvm::Value *Id =
|
|
|
|
CGF.Builder.CreateCall(llvm_eh_typeid_for_i64,
|
|
|
|
CGF.Builder.CreateBitCast(SelectorArgs[i+2],
|
|
|
|
ObjCTypes.Int8PtrTy));
|
|
|
|
CGF.Builder.CreateCondBr(CGF.Builder.CreateICmpEQ(Selector, Id),
|
|
|
|
Match, Next);
|
|
|
|
|
|
|
|
CGF.EmitBlock(Match);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (CatchBody) {
|
|
|
|
llvm::BasicBlock *MatchEnd = CGF.createBasicBlock("match.end");
|
|
|
|
llvm::BasicBlock *MatchHandler = CGF.createBasicBlock("match.handler");
|
|
|
|
|
|
|
|
// Cleanups must call objc_end_catch.
|
|
|
|
//
|
|
|
|
// FIXME: It seems incorrect for objc_begin_catch to be inside
|
|
|
|
// this context, but this matches gcc.
|
|
|
|
CGF.PushCleanupBlock(MatchEnd);
|
|
|
|
CGF.setInvokeDest(MatchHandler);
|
|
|
|
|
|
|
|
llvm::Value *ExcObject =
|
|
|
|
CGF.Builder.CreateCall(ObjCTypes.ObjCBeginCatchFn, Exc);
|
|
|
|
|
|
|
|
// Bind the catch parameter if it exists.
|
|
|
|
if (CatchParam) {
|
2009-03-06 08:01:21 +08:00
|
|
|
ExcObject =
|
|
|
|
CGF.Builder.CreateBitCast(ExcObject,
|
|
|
|
CGF.ConvertType(CatchParam->getType()));
|
|
|
|
// CatchParam is a ParmVarDecl because of the grammar
|
|
|
|
// construction used to handle this, but for codegen purposes
|
|
|
|
// we treat this as a local decl.
|
|
|
|
CGF.EmitLocalBlockVarDecl(*CatchParam);
|
|
|
|
CGF.Builder.CreateStore(ExcObject, CGF.GetAddrOfLocalVar(CatchParam));
|
2009-03-02 14:08:11 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
CGF.ObjCEHValueStack.push_back(ExcObject);
|
|
|
|
CGF.EmitStmt(CatchBody);
|
|
|
|
CGF.ObjCEHValueStack.pop_back();
|
|
|
|
|
|
|
|
CGF.EmitBranchThroughCleanup(FinallyEnd);
|
|
|
|
|
|
|
|
CGF.EmitBlock(MatchHandler);
|
|
|
|
|
|
|
|
llvm::Value *Exc = CGF.Builder.CreateCall(llvm_eh_exception, "exc");
|
|
|
|
// We are required to emit this call to satisfy LLVM, even
|
|
|
|
// though we don't use the result.
|
|
|
|
llvm::SmallVector<llvm::Value*, 8> Args;
|
|
|
|
Args.push_back(Exc);
|
2009-04-07 00:53:45 +08:00
|
|
|
Args.push_back(ObjCTypes.getEHPersonalityPtr());
|
2009-03-02 14:08:11 +08:00
|
|
|
Args.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty,
|
|
|
|
0));
|
|
|
|
CGF.Builder.CreateCall(llvm_eh_selector_i64, Args.begin(), Args.end());
|
|
|
|
CGF.Builder.CreateStore(Exc, RethrowPtr);
|
|
|
|
CGF.EmitBranchThroughCleanup(FinallyRethrow);
|
|
|
|
|
|
|
|
CodeGenFunction::CleanupBlockInfo Info = CGF.PopCleanupBlock();
|
|
|
|
|
|
|
|
CGF.EmitBlock(MatchEnd);
|
|
|
|
|
|
|
|
// Unfortunately, we also have to generate another EH frame here
|
|
|
|
// in case this throws.
|
|
|
|
llvm::BasicBlock *MatchEndHandler =
|
|
|
|
CGF.createBasicBlock("match.end.handler");
|
|
|
|
llvm::BasicBlock *Cont = CGF.createBasicBlock("invoke.cont");
|
|
|
|
CGF.Builder.CreateInvoke(ObjCTypes.ObjCEndCatchFn,
|
|
|
|
Cont, MatchEndHandler,
|
|
|
|
Args.begin(), Args.begin());
|
|
|
|
|
|
|
|
CGF.EmitBlock(Cont);
|
|
|
|
if (Info.SwitchBlock)
|
|
|
|
CGF.EmitBlock(Info.SwitchBlock);
|
|
|
|
if (Info.EndBlock)
|
|
|
|
CGF.EmitBlock(Info.EndBlock);
|
|
|
|
|
|
|
|
CGF.EmitBlock(MatchEndHandler);
|
|
|
|
Exc = CGF.Builder.CreateCall(llvm_eh_exception, "exc");
|
|
|
|
// We are required to emit this call to satisfy LLVM, even
|
|
|
|
// though we don't use the result.
|
|
|
|
Args.clear();
|
|
|
|
Args.push_back(Exc);
|
2009-04-07 00:53:45 +08:00
|
|
|
Args.push_back(ObjCTypes.getEHPersonalityPtr());
|
2009-03-02 14:08:11 +08:00
|
|
|
Args.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty,
|
|
|
|
0));
|
|
|
|
CGF.Builder.CreateCall(llvm_eh_selector_i64, Args.begin(), Args.end());
|
|
|
|
CGF.Builder.CreateStore(Exc, RethrowPtr);
|
|
|
|
CGF.EmitBranchThroughCleanup(FinallyRethrow);
|
|
|
|
|
|
|
|
if (Next)
|
|
|
|
CGF.EmitBlock(Next);
|
|
|
|
} else {
|
|
|
|
assert(!Next && "catchup should be last handler.");
|
|
|
|
|
|
|
|
CGF.Builder.CreateStore(Exc, RethrowPtr);
|
|
|
|
CGF.EmitBranchThroughCleanup(FinallyRethrow);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-24 15:47:38 +08:00
|
|
|
// Pop the cleanup entry, the @finally is outside this cleanup
|
|
|
|
// scope.
|
|
|
|
CodeGenFunction::CleanupBlockInfo Info = CGF.PopCleanupBlock();
|
|
|
|
CGF.setInvokeDest(PrevLandingPad);
|
|
|
|
|
|
|
|
CGF.EmitBlock(FinallyBlock);
|
|
|
|
|
|
|
|
if (isTry) {
|
|
|
|
if (const ObjCAtFinallyStmt* FinallyStmt =
|
|
|
|
cast<ObjCAtTryStmt>(S).getFinallyStmt())
|
|
|
|
CGF.EmitStmt(FinallyStmt->getFinallyBody());
|
|
|
|
} else {
|
|
|
|
// Emit 'objc_sync_exit(expr)' as finally's sole statement for
|
|
|
|
// @synchronized.
|
|
|
|
CGF.Builder.CreateCall(ObjCTypes.SyncExitFn, SyncArg);
|
2009-03-02 14:08:11 +08:00
|
|
|
}
|
2009-02-24 15:47:38 +08:00
|
|
|
|
|
|
|
if (Info.SwitchBlock)
|
|
|
|
CGF.EmitBlock(Info.SwitchBlock);
|
|
|
|
if (Info.EndBlock)
|
|
|
|
CGF.EmitBlock(Info.EndBlock);
|
|
|
|
|
2009-03-02 14:08:11 +08:00
|
|
|
// Branch around the rethrow code.
|
2009-02-24 15:47:38 +08:00
|
|
|
CGF.EmitBranch(FinallyEnd);
|
|
|
|
|
2009-03-02 14:08:11 +08:00
|
|
|
CGF.EmitBlock(FinallyRethrow);
|
|
|
|
CGF.Builder.CreateCall(ObjCTypes.UnwindResumeOrRethrowFn,
|
|
|
|
CGF.Builder.CreateLoad(RethrowPtr));
|
2009-02-24 15:47:38 +08:00
|
|
|
CGF.Builder.CreateUnreachable();
|
|
|
|
|
|
|
|
CGF.EmitBlock(FinallyEnd);
|
|
|
|
}
|
|
|
|
|
2009-02-17 06:59:18 +08:00
|
|
|
/// EmitThrowStmt - Generate code for a throw statement.
|
|
|
|
void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
|
|
|
|
const ObjCAtThrowStmt &S) {
|
2009-03-02 14:08:11 +08:00
|
|
|
llvm::Value *Exception;
|
2009-02-17 06:59:18 +08:00
|
|
|
if (const Expr *ThrowExpr = S.getThrowExpr()) {
|
2009-03-02 14:08:11 +08:00
|
|
|
Exception = CGF.EmitScalarExpr(ThrowExpr);
|
2009-02-17 06:59:18 +08:00
|
|
|
} else {
|
2009-03-02 14:08:11 +08:00
|
|
|
assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
|
|
|
|
"Unexpected rethrow outside @catch block.");
|
|
|
|
Exception = CGF.ObjCEHValueStack.back();
|
2009-02-17 06:59:18 +08:00
|
|
|
}
|
|
|
|
|
2009-03-02 14:08:11 +08:00
|
|
|
llvm::Value *ExceptionAsObject =
|
|
|
|
CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy, "tmp");
|
|
|
|
llvm::BasicBlock *InvokeDest = CGF.getInvokeDest();
|
|
|
|
if (InvokeDest) {
|
|
|
|
llvm::BasicBlock *Cont = CGF.createBasicBlock("invoke.cont");
|
|
|
|
CGF.Builder.CreateInvoke(ObjCTypes.ExceptionThrowFn,
|
|
|
|
Cont, InvokeDest,
|
|
|
|
&ExceptionAsObject, &ExceptionAsObject + 1);
|
|
|
|
CGF.EmitBlock(Cont);
|
|
|
|
} else
|
|
|
|
CGF.Builder.CreateCall(ObjCTypes.ExceptionThrowFn, ExceptionAsObject);
|
|
|
|
CGF.Builder.CreateUnreachable();
|
|
|
|
|
2009-02-17 06:59:18 +08:00
|
|
|
// Clear the insertion point to indicate we are in unreachable code.
|
|
|
|
CGF.Builder.ClearInsertionPoint();
|
|
|
|
}
|
2009-03-01 12:46:24 +08:00
|
|
|
|
|
|
|
llvm::Value *
|
2009-04-08 12:21:03 +08:00
|
|
|
CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceDecl *ID,
|
|
|
|
bool ForDefinition) {
|
2009-03-01 12:46:24 +08:00
|
|
|
llvm::GlobalVariable * &Entry = EHTypeReferences[ID->getIdentifier()];
|
2009-04-07 14:43:45 +08:00
|
|
|
|
2009-04-08 12:21:03 +08:00
|
|
|
// If we don't need a definition, return the entry if found or check
|
|
|
|
// if we use an external reference.
|
|
|
|
if (!ForDefinition) {
|
|
|
|
if (Entry)
|
|
|
|
return Entry;
|
|
|
|
|
|
|
|
// If this type (or a super class) has the __objc_exception__
|
|
|
|
// attribute, emit an external reference.
|
|
|
|
if (hasObjCExceptionAttribute(ID))
|
|
|
|
return Entry =
|
|
|
|
new llvm::GlobalVariable(ObjCTypes.EHTypeTy, false,
|
|
|
|
llvm::GlobalValue::ExternalLinkage,
|
|
|
|
0,
|
|
|
|
(std::string("OBJC_EHTYPE_$_") +
|
|
|
|
ID->getIdentifier()->getName()),
|
|
|
|
&CGM.getModule());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise we need to either make a new entry or fill in the
|
|
|
|
// initializer.
|
|
|
|
assert((!Entry || !Entry->hasInitializer()) && "Duplicate EHType definition");
|
2009-04-07 13:48:37 +08:00
|
|
|
std::string ClassName(getClassSymbolPrefix() + ID->getNameAsString());
|
2009-03-01 12:46:24 +08:00
|
|
|
std::string VTableName = "objc_ehtype_vtable";
|
|
|
|
llvm::GlobalVariable *VTableGV =
|
|
|
|
CGM.getModule().getGlobalVariable(VTableName);
|
|
|
|
if (!VTableGV)
|
|
|
|
VTableGV = new llvm::GlobalVariable(ObjCTypes.Int8PtrTy, false,
|
|
|
|
llvm::GlobalValue::ExternalLinkage,
|
|
|
|
0, VTableName, &CGM.getModule());
|
|
|
|
|
|
|
|
llvm::Value *VTableIdx = llvm::ConstantInt::get(llvm::Type::Int32Ty, 2);
|
|
|
|
|
|
|
|
std::vector<llvm::Constant*> Values(3);
|
|
|
|
Values[0] = llvm::ConstantExpr::getGetElementPtr(VTableGV, &VTableIdx, 1);
|
|
|
|
Values[1] = GetClassName(ID->getIdentifier());
|
2009-04-07 13:48:37 +08:00
|
|
|
Values[2] = GetClassGlobal(ClassName, false);
|
2009-03-01 12:46:24 +08:00
|
|
|
llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.EHTypeTy, Values);
|
|
|
|
|
2009-04-08 12:21:03 +08:00
|
|
|
if (Entry) {
|
|
|
|
Entry->setInitializer(Init);
|
|
|
|
} else {
|
|
|
|
Entry = new llvm::GlobalVariable(ObjCTypes.EHTypeTy, false,
|
|
|
|
llvm::GlobalValue::WeakAnyLinkage,
|
|
|
|
Init,
|
|
|
|
(std::string("OBJC_EHTYPE_$_") +
|
|
|
|
ID->getIdentifier()->getName()),
|
|
|
|
&CGM.getModule());
|
|
|
|
}
|
|
|
|
|
2009-04-07 13:48:37 +08:00
|
|
|
if (CGM.getLangOptions().getVisibilityMode() ==
|
|
|
|
LangOptions::HiddenVisibility)
|
|
|
|
Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
|
2009-04-08 12:21:03 +08:00
|
|
|
Entry->setAlignment(8);
|
|
|
|
|
|
|
|
if (ForDefinition) {
|
|
|
|
Entry->setSection("__DATA,__objc_const");
|
|
|
|
Entry->setLinkage(llvm::GlobalValue::ExternalLinkage);
|
|
|
|
} else {
|
|
|
|
Entry->setSection("__DATA,__datacoal_nt,coalesced");
|
|
|
|
}
|
2009-03-01 12:46:24 +08:00
|
|
|
|
|
|
|
return Entry;
|
|
|
|
}
|
2009-02-17 06:59:18 +08:00
|
|
|
|
2008-08-12 08:12:39 +08:00
|
|
|
/* *** */
|
|
|
|
|
2008-08-13 11:21:16 +08:00
|
|
|
CodeGen::CGObjCRuntime *
|
|
|
|
CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) {
|
2008-08-11 10:45:11 +08:00
|
|
|
return new CGObjCMac(CGM);
|
|
|
|
}
|
2009-01-22 06:04:16 +08:00
|
|
|
|
|
|
|
CodeGen::CGObjCRuntime *
|
2009-01-23 07:02:58 +08:00
|
|
|
CodeGen::CreateMacNonFragileABIObjCRuntime(CodeGen::CodeGenModule &CGM) {
|
2009-01-24 07:53:38 +08:00
|
|
|
return new CGObjCNonFragileABIMac(CGM);
|
2009-01-22 06:04:16 +08:00
|
|
|
}
|