CGObjCRuntime.h revision e3173021fa3bfdf7e6759d67838e385a83b2d57e
1//===----- CGObjCRuntime.h - Interface to ObjC Runtimes ---------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This provides an abstract class for Objective-C code generation. Concrete 11// subclasses of this implement code generation for specific Objective-C 12// runtime libraries. 13// 14//===----------------------------------------------------------------------===// 15 16#ifndef CLANG_CODEGEN_OBCJRUNTIME_H 17#define CLANG_CODEGEN_OBCJRUNTIME_H 18#include "clang/Basic/IdentifierTable.h" // Selector 19#include "clang/AST/DeclObjC.h" 20 21#include "CGBuilder.h" 22#include "CGCall.h" 23#include "CGValue.h" 24 25namespace llvm { 26 class Constant; 27 class Function; 28 class Module; 29 class StructLayout; 30 class StructType; 31 class Type; 32 class Value; 33} 34 35namespace clang { 36namespace CodeGen { 37 class CodeGenFunction; 38} 39 40 class FieldDecl; 41 class ObjCAtTryStmt; 42 class ObjCAtThrowStmt; 43 class ObjCAtSynchronizedStmt; 44 class ObjCContainerDecl; 45 class ObjCCategoryImplDecl; 46 class ObjCImplementationDecl; 47 class ObjCInterfaceDecl; 48 class ObjCMessageExpr; 49 class ObjCMethodDecl; 50 class ObjCProtocolDecl; 51 class Selector; 52 class ObjCIvarDecl; 53 class ObjCStringLiteral; 54 class BlockDeclRefExpr; 55 56namespace CodeGen { 57 class CodeGenModule; 58 class CGBlockInfo; 59 60// FIXME: Several methods should be pure virtual but aren't to avoid the 61// partially-implemented subclass breaking. 62 63/// Implements runtime-specific code generation functions. 64class CGObjCRuntime { 65protected: 66 // Utility functions for unified ivar access. These need to 67 // eventually be folded into other places (the structure layout 68 // code). 69 70 /// Compute an offset to the given ivar, suitable for passing to 71 /// EmitValueForIvarAtOffset. Note that the correct handling of 72 /// bit-fields is carefully coordinated by these two, use caution! 73 /// 74 /// The latter overload is suitable for computing the offset of a 75 /// sythesized ivar. 76 uint64_t ComputeIvarBaseOffset(CodeGen::CodeGenModule &CGM, 77 const ObjCInterfaceDecl *OID, 78 const ObjCIvarDecl *Ivar); 79 uint64_t ComputeIvarBaseOffset(CodeGen::CodeGenModule &CGM, 80 const ObjCImplementationDecl *OID, 81 const ObjCIvarDecl *Ivar); 82 83 LValue EmitValueForIvarAtOffset(CodeGen::CodeGenFunction &CGF, 84 const ObjCInterfaceDecl *OID, 85 llvm::Value *BaseValue, 86 const ObjCIvarDecl *Ivar, 87 unsigned CVRQualifiers, 88 llvm::Value *Offset); 89 /// Emits a try / catch statement. This function is intended to be called by 90 /// subclasses, and provides a generic mechanism for generating these, which 91 /// should be usable by all runtimes. The caller must provide the functions to 92 /// call when entering and exiting a @catch() block, and the function used to 93 /// rethrow exceptions. If the begin and end catch functions are NULL, then 94 /// the function assumes that the EH personality function provides the 95 /// thrown object directly. 96 void EmitTryCatchStmt(CodeGenFunction &CGF, 97 const ObjCAtTryStmt &S, 98 llvm::Constant *beginCatchFn, 99 llvm::Constant *endCatchFn, 100 llvm::Constant *exceptionRethrowFn); 101 /// Emits an @synchronize() statement, using the syncEnterFn and syncExitFn 102 /// arguments as the functions called to lock and unlock the object. This 103 /// function can be called by subclasses that use zero-cost exception 104 /// handling. 105 void EmitAtSynchronizedStmt(CodeGenFunction &CGF, 106 const ObjCAtSynchronizedStmt &S, 107 llvm::Function *syncEnterFn, 108 llvm::Function *syncExitFn); 109 110public: 111 virtual ~CGObjCRuntime(); 112 113 /// Generate the function required to register all Objective-C components in 114 /// this compilation unit with the runtime library. 115 virtual llvm::Function *ModuleInitFunction() = 0; 116 117 /// Get a selector for the specified name and type values. The 118 /// return value should have the LLVM type for pointer-to 119 /// ASTContext::getObjCSelType(). 120 virtual llvm::Value *GetSelector(CGBuilderTy &Builder, 121 Selector Sel, bool lval=false) = 0; 122 123 /// Get a typed selector. 124 virtual llvm::Value *GetSelector(CGBuilderTy &Builder, 125 const ObjCMethodDecl *Method) = 0; 126 127 /// Get the type constant to catch for the given ObjC pointer type. 128 /// This is used externally to implement catching ObjC types in C++. 129 /// Runtimes which don't support this should add the appropriate 130 /// error to Sema. 131 virtual llvm::Constant *GetEHType(QualType T) = 0; 132 133 /// Generate a constant string object. 134 virtual llvm::Constant *GenerateConstantString(const StringLiteral *) = 0; 135 136 /// Generate a category. A category contains a list of methods (and 137 /// accompanying metadata) and a list of protocols. 138 virtual void GenerateCategory(const ObjCCategoryImplDecl *OCD) = 0; 139 140 /// Generate a class structure for this class. 141 virtual void GenerateClass(const ObjCImplementationDecl *OID) = 0; 142 143 /// Generate an Objective-C message send operation. 144 /// 145 /// \param Method - The method being called, this may be null if synthesizing 146 /// a property setter or getter. 147 virtual CodeGen::RValue 148 GenerateMessageSend(CodeGen::CodeGenFunction &CGF, 149 ReturnValueSlot ReturnSlot, 150 QualType ResultType, 151 Selector Sel, 152 llvm::Value *Receiver, 153 const CallArgList &CallArgs, 154 const ObjCInterfaceDecl *Class = 0, 155 const ObjCMethodDecl *Method = 0) = 0; 156 157 /// Generate an Objective-C message send operation to the super 158 /// class initiated in a method for Class and with the given Self 159 /// object. 160 /// 161 /// \param Method - The method being called, this may be null if synthesizing 162 /// a property setter or getter. 163 virtual CodeGen::RValue 164 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, 165 ReturnValueSlot ReturnSlot, 166 QualType ResultType, 167 Selector Sel, 168 const ObjCInterfaceDecl *Class, 169 bool isCategoryImpl, 170 llvm::Value *Self, 171 bool IsClassMessage, 172 const CallArgList &CallArgs, 173 const ObjCMethodDecl *Method = 0) = 0; 174 175 /// Emit the code to return the named protocol as an object, as in a 176 /// @protocol expression. 177 virtual llvm::Value *GenerateProtocolRef(CGBuilderTy &Builder, 178 const ObjCProtocolDecl *OPD) = 0; 179 180 /// Generate the named protocol. Protocols contain method metadata but no 181 /// implementations. 182 virtual void GenerateProtocol(const ObjCProtocolDecl *OPD) = 0; 183 184 /// Generate a function preamble for a method with the specified 185 /// types. 186 187 // FIXME: Current this just generates the Function definition, but really this 188 // should also be generating the loads of the parameters, as the runtime 189 // should have full control over how parameters are passed. 190 virtual llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD, 191 const ObjCContainerDecl *CD) = 0; 192 193 /// Return the runtime function for getting properties. 194 virtual llvm::Constant *GetPropertyGetFunction() = 0; 195 196 /// Return the runtime function for setting properties. 197 virtual llvm::Constant *GetPropertySetFunction() = 0; 198 199 // API for atomic copying of qualified aggregates in getter. 200 virtual llvm::Constant *GetGetStructFunction() = 0; 201 // API for atomic copying of qualified aggregates in setter. 202 virtual llvm::Constant *GetSetStructFunction() = 0; 203 // API for atomic copying of qualified aggregates with non-trivial copy 204 // assignment (c++) in setter/getter. 205 virtual llvm::Constant *GetCppAtomicObjectFunction() = 0; 206 207 /// GetClass - Return a reference to the class for the given 208 /// interface decl. 209 virtual llvm::Value *GetClass(CGBuilderTy &Builder, 210 const ObjCInterfaceDecl *OID) = 0; 211 212 213 virtual llvm::Value *EmitNSAutoreleasePoolClassRef(CGBuilderTy &Builder) { 214 llvm_unreachable("autoreleasepool unsupported in this ABI"); 215 } 216 217 /// EnumerationMutationFunction - Return the function that's called by the 218 /// compiler when a mutation is detected during foreach iteration. 219 virtual llvm::Constant *EnumerationMutationFunction() = 0; 220 221 virtual void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF, 222 const ObjCAtSynchronizedStmt &S) = 0; 223 virtual void EmitTryStmt(CodeGen::CodeGenFunction &CGF, 224 const ObjCAtTryStmt &S) = 0; 225 virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, 226 const ObjCAtThrowStmt &S) = 0; 227 virtual llvm::Value *EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, 228 llvm::Value *AddrWeakObj) = 0; 229 virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, 230 llvm::Value *src, llvm::Value *dest) = 0; 231 virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, 232 llvm::Value *src, llvm::Value *dest, 233 bool threadlocal=false) = 0; 234 virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, 235 llvm::Value *src, llvm::Value *dest, 236 llvm::Value *ivarOffset) = 0; 237 virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, 238 llvm::Value *src, llvm::Value *dest) = 0; 239 240 virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, 241 QualType ObjectTy, 242 llvm::Value *BaseValue, 243 const ObjCIvarDecl *Ivar, 244 unsigned CVRQualifiers) = 0; 245 virtual llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF, 246 const ObjCInterfaceDecl *Interface, 247 const ObjCIvarDecl *Ivar) = 0; 248 virtual void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, 249 llvm::Value *DestPtr, 250 llvm::Value *SrcPtr, 251 llvm::Value *Size) = 0; 252 virtual llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM, 253 const CodeGen::CGBlockInfo &blockInfo) = 0; 254 virtual llvm::GlobalVariable *GetClassGlobal(const std::string &Name) = 0; 255}; 256 257/// Creates an instance of an Objective-C runtime class. 258//TODO: This should include some way of selecting which runtime to target. 259CGObjCRuntime *CreateGNUObjCRuntime(CodeGenModule &CGM); 260CGObjCRuntime *CreateMacObjCRuntime(CodeGenModule &CGM); 261} 262} 263#endif 264