Coverage Report

Created: 2019-07-24 05:18

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