|
111
|
1 /* Next Runtime (ABI-2) private.
|
|
|
2 Copyright (C) 2011-2017 Free Software Foundation, Inc.
|
|
|
3
|
|
|
4 Contributed by Iain Sandoe and based, in part, on an implementation in
|
|
|
5 'branches/apple/trunk' contributed by Apple Computer Inc.
|
|
|
6
|
|
|
7 This file is part of GCC.
|
|
|
8
|
|
|
9 GCC is free software; you can redistribute it and/or modify
|
|
|
10 it under the terms of the GNU General Public License as published by
|
|
|
11 the Free Software Foundation; either version 3, or (at your option)
|
|
|
12 any later version.
|
|
|
13
|
|
|
14 GCC is distributed in the hope that it will be useful,
|
|
|
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
17 GNU General Public License for more details.
|
|
|
18
|
|
|
19 You should have received a copy of the GNU General Public License
|
|
|
20 along with GCC; see the file COPYING3. If not see
|
|
|
21 <http://www.gnu.org/licenses/>. */
|
|
|
22
|
|
|
23 /* The NeXT ABI2 is used for m64 implementations on Darwin/OSX machines.
|
|
|
24
|
|
|
25 This version is intended to match (logically) the output of Apple's
|
|
|
26 4.2.1 compiler. */
|
|
|
27
|
|
|
28 #include "config.h"
|
|
|
29 #include "system.h"
|
|
|
30 #include "coretypes.h"
|
|
|
31 #include "tree.h"
|
|
|
32 #include "stringpool.h"
|
|
|
33 #include "attribs.h"
|
|
|
34
|
|
|
35 #ifdef OBJCPLUS
|
|
|
36 #include "cp/cp-tree.h"
|
|
|
37 #else
|
|
|
38 #include "c/c-tree.h"
|
|
|
39 #include "c/c-lang.h"
|
|
|
40 #endif
|
|
|
41 #include "langhooks.h"
|
|
|
42 #include "c-family/c-objc.h"
|
|
|
43 #include "objc-act.h"
|
|
|
44
|
|
|
45 /* When building Objective-C++, we are not linking against the C front-end
|
|
|
46 and so need to replicate the C tree-construction functions in some way. */
|
|
|
47 #ifdef OBJCPLUS
|
|
|
48 #define OBJCP_REMAP_FUNCTIONS
|
|
|
49 #include "objcp-decl.h"
|
|
|
50 #endif /* OBJCPLUS */
|
|
|
51
|
|
|
52 #include "target.h"
|
|
|
53 #include "tree-iterator.h"
|
|
|
54
|
|
|
55 #include "objc-runtime-hooks.h"
|
|
|
56 #include "objc-runtime-shared-support.h"
|
|
|
57 #include "objc-encoding.h"
|
|
|
58
|
|
|
59 /* ABI 2 Private definitions. */
|
|
|
60 #define DEF_CONSTANT_STRING_CLASS_NAME "NSConstantString"
|
|
|
61
|
|
|
62 #define TAG_GETCLASS "objc_getClass"
|
|
|
63 #define TAG_GETMETACLASS "objc_getMetaClass"
|
|
|
64
|
|
|
65 #define TAG_MSGSEND "objc_msgSend"
|
|
|
66 #define TAG_MSGSENDSUPER "objc_msgSendSuper"
|
|
|
67 #define TAG_MSGSEND_STRET "objc_msgSend_stret"
|
|
|
68 #define TAG_MSGSENDSUPER_STRET "objc_msgSendSuper_stret"
|
|
|
69
|
|
|
70 #define TAG_NEXT_EHVTABLE_NAME "objc_ehtype_vtable"
|
|
|
71 #define TAG_V2_EH_TYPE "objc_ehtype_t"
|
|
|
72
|
|
|
73 #define UTAG_V2_CLASS "_class_t"
|
|
|
74 #define UTAG_V2_CLASS_RO "_class_ro_t"
|
|
|
75 #define UTAG_V2_PROTOCOL "_protocol_t"
|
|
|
76 #define UTAG_V2_PROTOCOL_LIST "_protocol_list_t"
|
|
|
77
|
|
|
78 #define UTAG_V2_EH_TYPE "_objc_ehtype_t"
|
|
|
79
|
|
|
80 #define OBJC2_CLS_HAS_CXX_STRUCTORS 0x0004L
|
|
|
81
|
|
|
82 enum objc_v2_tree_index
|
|
|
83 {
|
|
|
84 /* Templates. */
|
|
|
85 OCTI_V2_CLS_TEMPL,
|
|
|
86 OCTI_V2_CAT_TEMPL,
|
|
|
87 OCTI_V2_CLS_RO_TEMPL,
|
|
|
88 OCTI_V2_PROTO_TEMPL,
|
|
|
89 OCTI_V2_IVAR_TEMPL,
|
|
|
90 OCTI_V2_IVAR_LIST_TEMPL,
|
|
|
91 OCTI_V2_MESSAGE_REF_TEMPL,
|
|
|
92 OCTI_V2_SUPER_MESSAGE_REF_TEMPL,
|
|
|
93
|
|
|
94 OCTI_V2_MESSAGE_SELECTOR_TYPE,
|
|
|
95 OCTI_V2_SUPER_MESSAGE_SELECTOR_TYPE,
|
|
|
96 OCTI_V2_IMP_TYPE,
|
|
|
97 OCTI_V2_SUPER_IMP_TYPE,
|
|
|
98
|
|
|
99 OCTI_V2_CACHE_DECL,
|
|
|
100 OCTI_V2_VTABLE_DECL,
|
|
|
101
|
|
|
102 OCTI_V2_PROPERTY_TEMPL,
|
|
|
103
|
|
|
104 /* V2 messaging. */
|
|
|
105 OCTI_V2_UMSG_FIXUP_DECL,
|
|
|
106 OCTI_V2_UMSG_STRET_FIXUP_DECL,
|
|
|
107 OCTI_V2_UMSG_ID_FIXUP_DECL,
|
|
|
108 OCTI_V2_UMSG_ID_STRET_FIXUP_DECL,
|
|
|
109 OCTI_V2_UMSG_SUPER2_FIXUP_DECL,
|
|
|
110 OCTI_V2_UMSG_SUPER2_STRET_FIXUP_DECL,
|
|
|
111
|
|
|
112 /* Exceptions - related. */
|
|
|
113 OCTI_V2_BEGIN_CATCH_DECL,
|
|
|
114 OCTI_V2_END_CATCH_DECL,
|
|
|
115 OCTI_V2_RETHROW_DECL,
|
|
|
116
|
|
|
117 OCTI_V2_MAX
|
|
|
118 };
|
|
|
119
|
|
|
120 #define objc_v2_class_template objc_v2_global_trees[OCTI_V2_CLS_TEMPL]
|
|
|
121 #define objc_v2_class_ro_template \
|
|
|
122 objc_v2_global_trees[OCTI_V2_CLS_RO_TEMPL]
|
|
|
123 #define objc_v2_category_template \
|
|
|
124 objc_v2_global_trees[OCTI_V2_CAT_TEMPL]
|
|
|
125 #define objc_v2_protocol_template \
|
|
|
126 objc_v2_global_trees[OCTI_V2_PROTO_TEMPL]
|
|
|
127
|
|
|
128 /* struct message_ref_t */
|
|
|
129 #define objc_v2_message_ref_template \
|
|
|
130 objc_v2_global_trees[OCTI_V2_MESSAGE_REF_TEMPL]
|
|
|
131
|
|
|
132 #define objc_v2_ivar_list_ptr objc_v2_global_trees[OCTI_V2_IVAR_LIST_TEMPL]
|
|
|
133
|
|
|
134 /* struct super_message_ref_t */
|
|
|
135 #define objc_v2_super_message_ref_template \
|
|
|
136 objc_v2_global_trees[OCTI_V2_SUPER_MESSAGE_REF_TEMPL]
|
|
|
137
|
|
|
138 /* struct message_ref_t* */
|
|
|
139 #define objc_v2_selector_type objc_v2_global_trees[OCTI_V2_MESSAGE_SELECTOR_TYPE]
|
|
|
140 /* struct super_super_message_ref_t */
|
|
|
141 #define objc_v2_super_selector_type \
|
|
|
142 objc_v2_global_trees[OCTI_V2_SUPER_MESSAGE_SELECTOR_TYPE]
|
|
|
143 #define objc_v2_imp_type objc_v2_global_trees[OCTI_V2_IMP_TYPE]
|
|
|
144 #define objc_v2_super_imp_type objc_v2_global_trees[OCTI_V2_SUPER_IMP_TYPE]
|
|
|
145
|
|
|
146 #define UOBJC_V2_CACHE_decl objc_v2_global_trees[OCTI_V2_CACHE_DECL]
|
|
|
147 #define UOBJC_V2_VTABLE_decl objc_v2_global_trees[OCTI_V2_VTABLE_DECL]
|
|
|
148
|
|
|
149 #define objc_v2_ivar_template objc_v2_global_trees[OCTI_V2_IVAR_TEMPL]
|
|
|
150 #define objc_v2_property_template \
|
|
|
151 objc_v2_global_trees[OCTI_V2_PROPERTY_TEMPL]
|
|
|
152
|
|
|
153 /* V2 Messaging */
|
|
|
154
|
|
|
155 /* objc_msgSend_fixup_rtp */
|
|
|
156 #define umsg_fixup_decl objc_v2_global_trees[OCTI_V2_UMSG_FIXUP_DECL]
|
|
|
157 /* objc_msgSend_stret_fixup_rtp */
|
|
|
158 #define umsg_stret_fixup_decl objc_v2_global_trees[OCTI_V2_UMSG_STRET_FIXUP_DECL]
|
|
|
159 /* objc_msgSendId_fixup_rtp */
|
|
|
160 #define umsg_id_fixup_decl objc_v2_global_trees[OCTI_V2_UMSG_ID_FIXUP_DECL]
|
|
|
161 /* objc_msgSendId_stret_fixup_rtp */
|
|
|
162 #define umsg_id_stret_fixup_decl \
|
|
|
163 objc_v2_global_trees[OCTI_V2_UMSG_ID_STRET_FIXUP_DECL]
|
|
|
164 /* objc_msgSendSuper2_fixup_rtp */
|
|
|
165 #define umsg_id_super2_fixup_decl \
|
|
|
166 objc_v2_global_trees[OCTI_V2_UMSG_SUPER2_FIXUP_DECL]
|
|
|
167 /* objc_msgSendSuper2_stret_fixup_rtp */
|
|
|
168 #define umsg_id_super2_stret_fixup_decl \
|
|
|
169 objc_v2_global_trees[OCTI_V2_UMSG_SUPER2_STRET_FIXUP_DECL]
|
|
|
170
|
|
|
171 #define objc2_begin_catch_decl objc_v2_global_trees[OCTI_V2_BEGIN_CATCH_DECL]
|
|
|
172 #define objc2_end_catch_decl objc_v2_global_trees[OCTI_V2_END_CATCH_DECL]
|
|
|
173 #define objc_rethrow_exception_decl \
|
|
|
174 objc_v2_global_trees[OCTI_V2_RETHROW_DECL]
|
|
|
175
|
|
|
176 /* rt_trees identifiers - shared between NeXT implementations. These allow
|
|
|
177 the FE to tag meta-data in a manner that survives LTO and can be used when
|
|
|
178 the runtime requires that certain meta-data items appear in particular
|
|
|
179 named sections. */
|
|
|
180
|
|
|
181 #include "objc-next-metadata-tags.h"
|
|
|
182 extern GTY(()) tree objc_rt_trees[OCTI_RT_META_MAX];
|
|
|
183
|
|
|
184 /* The OCTI_V2_... enumeration itself is in above. */
|
|
|
185 static GTY(()) tree objc_v2_global_trees[OCTI_V2_MAX];
|
|
|
186
|
|
|
187 static void next_runtime_02_initialize (void);
|
|
|
188
|
|
|
189 static void build_v2_message_ref_templates (void);
|
|
|
190 static void build_v2_class_templates (void);
|
|
|
191 static void build_v2_super_template (void);
|
|
|
192 static void build_v2_category_template (void);
|
|
|
193 static void build_v2_protocol_template (void);
|
|
|
194
|
|
|
195 static tree next_runtime_abi_02_super_superclassfield_id (void);
|
|
|
196
|
|
|
197 static tree next_runtime_abi_02_class_decl (tree);
|
|
|
198 static tree next_runtime_abi_02_metaclass_decl (tree);
|
|
|
199 static tree next_runtime_abi_02_category_decl (tree);
|
|
|
200 static tree next_runtime_abi_02_protocol_decl (tree);
|
|
|
201 static tree next_runtime_abi_02_string_decl (tree, const char *, string_section);
|
|
|
202
|
|
|
203 static tree next_runtime_abi_02_get_class_reference (tree);
|
|
|
204 static tree next_runtime_abi_02_build_selector_reference (location_t, tree, tree);
|
|
|
205 static tree next_runtime_abi_02_get_protocol_reference (location_t, tree);
|
|
|
206 static tree next_runtime_abi_02_build_ivar_ref (location_t, tree, tree);
|
|
|
207 static tree next_runtime_abi_02_get_class_super_ref (location_t, struct imp_entry *, bool);
|
|
|
208 static tree next_runtime_abi_02_get_category_super_ref (location_t, struct imp_entry *, bool);
|
|
|
209
|
|
|
210 static tree next_runtime_abi_02_receiver_is_class_object (tree);
|
|
|
211 static void next_runtime_abi_02_get_arg_type_list_base (vec<tree, va_gc> **,
|
|
|
212 tree, int, int);
|
|
|
213 static tree next_runtime_abi_02_build_objc_method_call (location_t, tree, tree,
|
|
|
214 tree, tree, tree, int);
|
|
|
215 static bool next_runtime_abi_02_setup_const_string_class_decl (void);
|
|
|
216 static tree next_runtime_abi_02_build_const_string_constructor (location_t, tree, int);
|
|
|
217
|
|
|
218 static tree create_extern_decl (tree, const char *);
|
|
|
219
|
|
|
220 static void objc_generate_v2_next_metadata (void);
|
|
|
221 static bool objc2_objc_exception_attr (tree);
|
|
|
222
|
|
|
223 /* void build_v2_protocol_reference (tree);*/
|
|
|
224 static void build_v2_ehtype_template (void);
|
|
|
225 static void build_v2_eh_catch_objects (void);
|
|
|
226 static tree next_runtime_02_eh_type (tree);
|
|
|
227 static tree objc_eh_personality (void);
|
|
|
228 static tree build_throw_stmt (location_t, tree, bool);
|
|
|
229 static tree objc_build_exc_ptr (struct objc_try_context **);
|
|
|
230 static tree begin_catch (struct objc_try_context **, tree, tree, tree, bool);
|
|
|
231 static void finish_catch (struct objc_try_context **, tree);
|
|
|
232 static tree finish_try_stmt (struct objc_try_context **);
|
|
|
233
|
|
|
234 /* TODO: Use an objc-map. */
|
|
|
235 static GTY ((length ("SIZEHASHTABLE"))) hash *extern_names;
|
|
|
236
|
|
|
237 bool
|
|
|
238 objc_next_runtime_abi_02_init (objc_runtime_hooks *rthooks)
|
|
|
239 {
|
|
|
240 extern_names = ggc_cleared_vec_alloc<hash> (SIZEHASHTABLE);
|
|
|
241
|
|
|
242 if (flag_objc_exceptions && flag_objc_sjlj_exceptions)
|
|
|
243 {
|
|
|
244 inform (UNKNOWN_LOCATION, "%<-fobjc-sjlj-exceptions%> is ignored for "
|
|
|
245 "%<-fnext-runtime%> when %<-fobjc-abi-version%> >= 2");
|
|
|
246 flag_objc_sjlj_exceptions = 0;
|
|
|
247 }
|
|
|
248
|
|
|
249 rthooks->initialize = next_runtime_02_initialize;
|
|
|
250 rthooks->default_constant_string_class_name = DEF_CONSTANT_STRING_CLASS_NAME;
|
|
|
251 rthooks->tag_getclass = TAG_GETCLASS;
|
|
|
252 rthooks->super_superclassfield_ident = next_runtime_abi_02_super_superclassfield_id;
|
|
|
253
|
|
|
254 rthooks->class_decl = next_runtime_abi_02_class_decl;
|
|
|
255 rthooks->metaclass_decl = next_runtime_abi_02_metaclass_decl;
|
|
|
256 rthooks->category_decl = next_runtime_abi_02_category_decl;
|
|
|
257 rthooks->protocol_decl = next_runtime_abi_02_protocol_decl;
|
|
|
258 rthooks->string_decl = next_runtime_abi_02_string_decl;
|
|
|
259
|
|
|
260 rthooks->get_class_reference = next_runtime_abi_02_get_class_reference;
|
|
|
261 rthooks->build_selector_reference = next_runtime_abi_02_build_selector_reference;
|
|
|
262 rthooks->get_protocol_reference = next_runtime_abi_02_get_protocol_reference;
|
|
|
263 rthooks->build_ivar_reference = next_runtime_abi_02_build_ivar_ref;
|
|
|
264 rthooks->get_class_super_ref = next_runtime_abi_02_get_class_super_ref;
|
|
|
265 rthooks->get_category_super_ref = next_runtime_abi_02_get_category_super_ref;
|
|
|
266
|
|
|
267 rthooks->receiver_is_class_object = next_runtime_abi_02_receiver_is_class_object;
|
|
|
268 rthooks->get_arg_type_list_base = next_runtime_abi_02_get_arg_type_list_base;
|
|
|
269 rthooks->build_objc_method_call = next_runtime_abi_02_build_objc_method_call;
|
|
|
270
|
|
|
271 rthooks->setup_const_string_class_decl =
|
|
|
272 next_runtime_abi_02_setup_const_string_class_decl;
|
|
|
273 rthooks->build_const_string_constructor =
|
|
|
274 next_runtime_abi_02_build_const_string_constructor;
|
|
|
275
|
|
|
276 rthooks->build_throw_stmt = build_throw_stmt;
|
|
|
277 rthooks->build_exc_ptr = objc_build_exc_ptr;
|
|
|
278 rthooks->begin_catch = begin_catch;
|
|
|
279 rthooks->finish_catch = finish_catch;
|
|
|
280 rthooks->finish_try_stmt = finish_try_stmt;
|
|
|
281
|
|
|
282 rthooks->generate_metadata = objc_generate_v2_next_metadata;
|
|
|
283 return true;
|
|
|
284 }
|
|
|
285
|
|
|
286 /* We need a way to convey what kind of meta-data are represented by a given
|
|
|
287 variable, since each type is expected (by the runtime) to be found in a
|
|
|
288 specific named section. The solution must be usable with LTO.
|
|
|
289
|
|
|
290 The scheme used for NeXT ABI 0/1 (partial matching of variable names) is not
|
|
|
291 satisfactory when LTO is used with ABI-2. We now tag ObjC meta-data with
|
|
|
292 identification attributes in the front end. The back-end may choose to act
|
|
|
293 on these as it requires. */
|
|
|
294
|
|
|
295 static void
|
|
|
296 next_runtime_abi_02_init_metadata_attributes (void)
|
|
|
297 {
|
|
|
298 if (!objc_meta)
|
|
|
299 objc_meta = get_identifier ("OBJC2META");
|
|
|
300
|
|
|
301 if (!meta_base)
|
|
|
302 meta_base = get_identifier ("V2_BASE");
|
|
|
303
|
|
|
304 meta_class = get_identifier ("G2_CLAS");
|
|
|
305 meta_metaclass = get_identifier ("G2_META");
|
|
|
306 meta_category =
|
|
|
307 meta_protocol = meta_base;
|
|
|
308
|
|
|
309 meta_clac_vars =
|
|
|
310 meta_clai_vars = meta_base;
|
|
|
311
|
|
|
312 meta_clac_meth =
|
|
|
313 meta_clai_meth =
|
|
|
314 meta_catc_meth =
|
|
|
315 meta_cati_meth =
|
|
|
316 meta_proto_cls_meth =
|
|
|
317 meta_proto_nst_meth = meta_base;
|
|
|
318
|
|
|
319 meta_clas_prot =
|
|
|
320 meta_catg_prot = meta_base;
|
|
|
321
|
|
|
322 meta_sel_refs = get_identifier ("V2_SRFS");
|
|
|
323
|
|
|
324 meta_class_name =
|
|
|
325 meta_meth_name =
|
|
|
326 meta_meth_type =
|
|
|
327 meta_prop_name_attr = get_identifier ("V2_STRG");
|
|
|
328
|
|
|
329 meta_mref = get_identifier ("V2_MREF");
|
|
|
330 meta_class_ref = get_identifier ("V2_CLRF");
|
|
|
331 meta_superclass_ref = get_identifier ("V2_SURF");
|
|
|
332
|
|
|
333 meta_label_classlist = get_identifier ("V2_CLAB");
|
|
|
334 meta_label_nonlazy_classlist = get_identifier ("V2_NLCL");
|
|
|
335 meta_label_categorylist = get_identifier ("V2_CALA");
|
|
|
336 meta_label_nonlazy_categorylist = get_identifier ("V2_NLCA");
|
|
|
337
|
|
|
338 meta_label_protocollist = get_identifier ("V2_PLST");
|
|
|
339 meta_proto_ref = get_identifier ("V2_PRFS");
|
|
|
340
|
|
|
341 meta_info = get_identifier ("V2_INFO");
|
|
|
342
|
|
|
343 meta_ehtype = get_identifier ("V2_EHTY");
|
|
|
344
|
|
|
345 meta_const_str = get_identifier ("V2_CSTR");
|
|
|
346 }
|
|
|
347
|
|
|
348 static void next_runtime_02_initialize (void)
|
|
|
349 {
|
|
|
350 tree type;
|
|
|
351 #ifdef OBJCPLUS
|
|
|
352 /* For all NeXT objc ABIs -fobjc-call-cxx-cdtors is on by
|
|
|
353 default. */
|
|
|
354 if (!global_options_set.x_flag_objc_call_cxx_cdtors)
|
|
|
355 global_options.x_flag_objc_call_cxx_cdtors = 1;
|
|
|
356 #endif
|
|
|
357
|
|
|
358 /* Set up attributes to be attached to the meta-data so that they
|
|
|
359 will be placed in the correct sections. */
|
|
|
360 next_runtime_abi_02_init_metadata_attributes ();
|
|
|
361
|
|
|
362 /* `struct objc_selector *' */
|
|
|
363 objc_selector_type = build_pointer_type (xref_tag (RECORD_TYPE,
|
|
|
364 get_identifier (TAG_SELECTOR)));
|
|
|
365
|
|
|
366 /* IMP : id (*) (id, _message_ref_t*, ...)
|
|
|
367 SUPER_IMP : id (*) ( super_t*, _super_message_ref_t*, ...)
|
|
|
368 objc_v2_selector_type. */
|
|
|
369 build_v2_message_ref_templates ();
|
|
|
370
|
|
|
371 objc_v2_ivar_list_ptr =
|
|
|
372 build_pointer_type (xref_tag (RECORD_TYPE,
|
|
|
373 get_identifier ("_ivar_list_t")));
|
|
|
374
|
|
|
375 objc_prop_list_ptr =
|
|
|
376 build_pointer_type (xref_tag (RECORD_TYPE,
|
|
|
377 get_identifier ("_prop_list_t")));
|
|
|
378
|
|
|
379 build_v2_class_templates ();
|
|
|
380 build_v2_super_template ();
|
|
|
381 build_v2_protocol_template ();
|
|
|
382 build_v2_category_template ();
|
|
|
383
|
|
|
384 /* id objc_msgSend_fixup_rtp (id, struct message_ref_t*, ...); */
|
|
|
385 type = build_varargs_function_type_list (objc_object_type,
|
|
|
386 objc_object_type,
|
|
|
387 objc_v2_selector_type,
|
|
|
388 NULL_TREE);
|
|
|
389 umsg_fixup_decl = add_builtin_function ("objc_msgSend_fixup",
|
|
|
390 type, 0, NOT_BUILT_IN,
|
|
|
391 NULL, NULL_TREE);
|
|
|
392 TREE_NOTHROW (umsg_fixup_decl) = 0;
|
|
|
393
|
|
|
394 /* id objc_msgSend_stret_fixup_rtp (id, struct message_ref_t*, ...); */
|
|
|
395 umsg_stret_fixup_decl = add_builtin_function ("objc_msgSend_stret_fixup",
|
|
|
396 type, 0, NOT_BUILT_IN,
|
|
|
397 NULL, NULL_TREE);
|
|
|
398 TREE_NOTHROW (umsg_stret_fixup_decl) = 0;
|
|
|
399
|
|
|
400 /* id objc_msgSendId_fixup_rtp (id, struct message_ref_t*, ...); */
|
|
|
401 umsg_id_fixup_decl = add_builtin_function ("objc_msgSendId_fixup",
|
|
|
402 type, 0, NOT_BUILT_IN,
|
|
|
403 NULL, NULL_TREE);
|
|
|
404 TREE_NOTHROW (umsg_id_fixup_decl) = 0;
|
|
|
405
|
|
|
406 /* id objc_msgSendId_stret_fixup_rtp
|
|
|
407 (id, struct message_ref_t*, ...); */
|
|
|
408 umsg_id_stret_fixup_decl = add_builtin_function ("objc_msgSendId_stret_fixup",
|
|
|
409 type, 0, NOT_BUILT_IN,
|
|
|
410 NULL, NULL_TREE);
|
|
|
411 TREE_NOTHROW (umsg_id_stret_fixup_decl) = 0;
|
|
|
412
|
|
|
413 /* id objc_msgSendSuper2_fixup_rtp
|
|
|
414 (struct objc_super *, struct message_ref_t*, ...); */
|
|
|
415 type = build_varargs_function_type_list (objc_object_type,
|
|
|
416 objc_super_type,
|
|
|
417 objc_v2_super_selector_type,
|
|
|
418 NULL_TREE);
|
|
|
419 umsg_id_super2_fixup_decl = add_builtin_function ("objc_msgSendSuper2_fixup",
|
|
|
420 type, 0, NOT_BUILT_IN,
|
|
|
421 NULL, NULL_TREE);
|
|
|
422 TREE_NOTHROW (umsg_id_super2_fixup_decl) = 0;
|
|
|
423
|
|
|
424 /* id objc_msgSendSuper2_stret_fixup_rtp
|
|
|
425 (struct objc_super *, struct message_ref_t*, ...); */
|
|
|
426 umsg_id_super2_stret_fixup_decl =
|
|
|
427 add_builtin_function ("objc_msgSendSuper2_stret_fixup",
|
|
|
428 type, 0, NOT_BUILT_IN,
|
|
|
429 NULL, NULL_TREE);
|
|
|
430 TREE_NOTHROW (umsg_id_super2_stret_fixup_decl) = 0;
|
|
|
431
|
|
|
432 /* Present in the library, but unused by the FE. */
|
|
|
433 /* Protocol *objc_getProtocol (const char *)
|
|
|
434 type = build_function_type_list (objc_protocol_type,
|
|
|
435 const_string_type_node,
|
|
|
436 NULL_TREE);
|
|
|
437 objc_v2_getprotocol_decl = add_builtin_function ("objc_getProtocol",
|
|
|
438 type, 0, NOT_BUILT_IN,
|
|
|
439 NULL, NULL_TREE);
|
|
|
440 TREE_NOTHROW (objc_v2_getprotocol_decl) = 0;*/
|
|
|
441
|
|
|
442 UOBJC_V2_CACHE_decl = create_extern_decl (ptr_type_node,
|
|
|
443 "_objc_empty_cache");
|
|
|
444
|
|
|
445 UOBJC_V2_VTABLE_decl = create_extern_decl (objc_v2_imp_type,
|
|
|
446 "_objc_empty_vtable");
|
|
|
447
|
|
|
448 /* id objc_getClass (const char *); */
|
|
|
449 type = build_function_type_list (objc_object_type,
|
|
|
450 const_string_type_node,
|
|
|
451 NULL_TREE);
|
|
|
452 objc_get_class_decl = add_builtin_function (TAG_GETCLASS,
|
|
|
453 type, 0, NOT_BUILT_IN,
|
|
|
454 NULL, NULL_TREE);
|
|
|
455
|
|
|
456 /* id objc_getMetaClass (const char *); */
|
|
|
457 objc_get_meta_class_decl = add_builtin_function (TAG_GETMETACLASS,
|
|
|
458 type, 0, NOT_BUILT_IN,
|
|
|
459 NULL, NULL_TREE);
|
|
|
460
|
|
|
461 /* This is the type of all of the following functions
|
|
|
462 objc_copyStruct(). */
|
|
|
463 type = build_function_type_list (void_type_node,
|
|
|
464 ptr_type_node,
|
|
|
465 const_ptr_type_node,
|
|
|
466 ptrdiff_type_node,
|
|
|
467 boolean_type_node,
|
|
|
468 boolean_type_node,
|
|
|
469 NULL_TREE);
|
|
|
470 /* Declare the following function:
|
|
|
471 void
|
|
|
472 objc_copyStruct (void *destination, const void *source,
|
|
|
473 ptrdiff_t size, BOOL is_atomic, BOOL has_strong); */
|
|
|
474 objc_copyStruct_decl = add_builtin_function ("objc_copyStruct",
|
|
|
475 type, 0, NOT_BUILT_IN,
|
|
|
476 NULL, NULL_TREE);
|
|
|
477 TREE_NOTHROW (objc_copyStruct_decl) = 0;
|
|
|
478 objc_getPropertyStruct_decl = NULL_TREE;
|
|
|
479 objc_setPropertyStruct_decl = NULL_TREE;
|
|
|
480
|
|
|
481 gcc_assert (!flag_objc_sjlj_exceptions);
|
|
|
482
|
|
|
483 /* Although we warn that fobjc-exceptions is required for exceptions
|
|
|
484 code, we carry on and create it anyway. */
|
|
|
485
|
|
|
486 /* This can be required, even when exceptions code is not present,
|
|
|
487 when an __attribute__((objc_exception)) is applied to a
|
|
|
488 class. */
|
|
|
489 build_v2_ehtype_template ();
|
|
|
490
|
|
|
491 /* void * objc_begin_catch (void *) */
|
|
|
492 type = build_function_type_list (ptr_type_node,
|
|
|
493 ptr_type_node, NULL_TREE);
|
|
|
494
|
|
|
495 objc2_begin_catch_decl = add_builtin_function ("objc_begin_catch",
|
|
|
496 type, 0, NOT_BUILT_IN,
|
|
|
497 NULL, NULL_TREE);
|
|
|
498 TREE_NOTHROW (objc2_begin_catch_decl) = 0;
|
|
|
499
|
|
|
500 /* void objc_end_catch () */
|
|
|
501 type = build_function_type_list (void_type_node, NULL_TREE);
|
|
|
502 objc2_end_catch_decl = add_builtin_function ("objc_end_catch",
|
|
|
503 type, 0, NOT_BUILT_IN,
|
|
|
504 NULL, NULL_TREE);
|
|
|
505 TREE_NOTHROW (objc2_end_catch_decl) = 0;
|
|
|
506
|
|
|
507 /* void objc_exception_rethrow (void) */
|
|
|
508 objc_rethrow_exception_decl =
|
|
|
509 add_builtin_function ("objc_exception_rethrow",
|
|
|
510 type, 0, NOT_BUILT_IN,
|
|
|
511 NULL, NULL_TREE);
|
|
|
512 TREE_NOTHROW (objc_rethrow_exception_decl) = 0;
|
|
|
513 using_eh_for_cleanups ();
|
|
|
514 lang_hooks.eh_runtime_type = next_runtime_02_eh_type;
|
|
|
515 lang_hooks.eh_personality = objc_eh_personality;
|
|
|
516 }
|
|
|
517
|
|
|
518 /* NOTE --- templates --- */
|
|
|
519
|
|
|
520 /* Set 'objc_v2_message_ref_template' to the data type node for
|
|
|
521 'struct _message_ref_t'. This needs to be done just once per
|
|
|
522 compilation. Also Set 'objc_v2_super_message_ref_template' to data
|
|
|
523 type node for 'struct _super_message_ref_t'. */
|
|
|
524
|
|
|
525 /* struct _message_ref_t
|
|
|
526 {
|
|
|
527 IMP messenger;
|
|
|
528 SEL name;
|
|
|
529 };
|
|
|
530 where IMP is: id (*) (id, _message_ref_t*, ...)
|
|
|
531 */
|
|
|
532
|
|
|
533 /* struct _super_message_ref_t
|
|
|
534 {
|
|
|
535 SUPER_IMP messenger;
|
|
|
536 SEL name;
|
|
|
537 };
|
|
|
538 where SUPER_IMP is: id (*) ( super_t*, _super_message_ref_t*, ...)
|
|
|
539 */
|
|
|
540
|
|
|
541 static void
|
|
|
542 build_v2_message_ref_templates (void)
|
|
|
543 {
|
|
|
544 tree ptr_message_ref_t;
|
|
|
545 tree decls, *chain = NULL;
|
|
|
546
|
|
|
547 /* struct _message_ref_t {...} */
|
|
|
548 objc_v2_message_ref_template =
|
|
|
549 objc_start_struct (get_identifier ("_message_ref_t"));
|
|
|
550
|
|
|
551 /* IMP messenger; */
|
|
|
552 ptr_message_ref_t =
|
|
|
553 build_pointer_type (xref_tag (RECORD_TYPE,
|
|
|
554 get_identifier ("_message_ref_t")));
|
|
|
555
|
|
|
556 objc_v2_imp_type =
|
|
|
557 build_pointer_type (build_function_type_list
|
|
|
558 (objc_object_type,
|
|
|
559 objc_object_type,
|
|
|
560 ptr_message_ref_t,
|
|
|
561 NULL_TREE));
|
|
|
562
|
|
|
563 decls = add_field_decl (objc_v2_imp_type, "messenger", &chain);
|
|
|
564
|
|
|
565 /* SEL name; */
|
|
|
566 add_field_decl (objc_selector_type, "name", &chain);
|
|
|
567
|
|
|
568 objc_finish_struct (objc_v2_message_ref_template, decls);
|
|
|
569
|
|
|
570 objc_v2_selector_type = build_pointer_type (objc_v2_message_ref_template);
|
|
|
571
|
|
|
572 chain = NULL;
|
|
|
573 /* struct _super_message_ref_t {...} */
|
|
|
574 objc_v2_super_message_ref_template =
|
|
|
575 objc_start_struct (get_identifier ("_super_message_ref_t"));
|
|
|
576
|
|
|
577 /* SUPER_IMP messenger; */
|
|
|
578 ptr_message_ref_t = build_pointer_type
|
|
|
579 (xref_tag (RECORD_TYPE,
|
|
|
580 get_identifier ("_super_message_ref_t")));
|
|
|
581
|
|
|
582 objc_v2_super_imp_type =
|
|
|
583 build_pointer_type (build_function_type_list
|
|
|
584 (objc_object_type,
|
|
|
585 objc_super_type,
|
|
|
586 ptr_message_ref_t,
|
|
|
587 NULL_TREE));
|
|
|
588
|
|
|
589 add_field_decl (objc_v2_super_imp_type, "messenger", &chain);
|
|
|
590
|
|
|
591 /* SEL name; */
|
|
|
592 add_field_decl (objc_selector_type, "name", &chain);
|
|
|
593
|
|
|
594 objc_finish_struct (objc_v2_super_message_ref_template, decls);
|
|
|
595 objc_v2_super_selector_type =
|
|
|
596 build_pointer_type (objc_v2_super_message_ref_template);
|
|
|
597 }
|
|
|
598
|
|
|
599 /* Build following types which represent each class implementation.
|
|
|
600
|
|
|
601 struct class_ro_t
|
|
|
602 {
|
|
|
603 uint32_t const flags;
|
|
|
604 uint32_t const instanceStart;
|
|
|
605 uint32_t const instanceSize;
|
|
|
606 #ifdef __LP64__
|
|
|
607 uint32_t const reserved;
|
|
|
608 #endif
|
|
|
609 const uint8_t * const ivarLayout;
|
|
|
610 const char *const name;
|
|
|
611 const struct method_list_t * const baseMethods;
|
|
|
612 const struct objc_protocol_list *const baseProtocols;
|
|
|
613 const struct ivar_list_t *const ivars;
|
|
|
614 const uint8_t * const weakIvarLayout;
|
|
|
615 const struct _prop_list_t * const properties;
|
|
|
616 };
|
|
|
617
|
|
|
618 struct class_t
|
|
|
619 {
|
|
|
620 struct class_t *isa;
|
|
|
621 struct class_t *superclass;
|
|
|
622 void *cache;
|
|
|
623 IMP *vtable;
|
|
|
624
|
|
|
625 ...When this is active - it will point to a rw version, but
|
|
|
626 when we build the meta-data we point it to the ro...
|
|
|
627 struct class_ro_t *data;
|
|
|
628 };
|
|
|
629
|
|
|
630 */
|
|
|
631
|
|
|
632 static void
|
|
|
633 build_v2_class_templates (void)
|
|
|
634 {
|
|
|
635 tree cnst_strg_type;
|
|
|
636 tree decls, *chain = NULL;
|
|
|
637
|
|
|
638 /* struct class_ro_t {...} */
|
|
|
639 objc_v2_class_ro_template =
|
|
|
640 objc_start_struct (get_identifier (UTAG_V2_CLASS_RO));
|
|
|
641
|
|
|
642 /* uint32_t const flags; */
|
|
|
643 decls = add_field_decl (integer_type_node, "flags", &chain);
|
|
|
644
|
|
|
645 /* uint32_t const instanceStart; */
|
|
|
646 add_field_decl (integer_type_node, "instanceStart", &chain);
|
|
|
647
|
|
|
648 /* uint32_t const instanceSize; */
|
|
|
649 add_field_decl (integer_type_node, "instanceSize", &chain);
|
|
|
650
|
|
|
651 /* This ABI is currently only used on m64 NeXT. We always
|
|
|
652 explicitly declare the alignment padding. */
|
|
|
653 /* uint32_t const reserved; */
|
|
|
654 add_field_decl (integer_type_node, "reserved", &chain);
|
|
|
655
|
|
|
656 /* const uint8_t * const ivarLayout; */
|
|
|
657 cnst_strg_type = build_pointer_type (unsigned_char_type_node);
|
|
|
658 add_field_decl (cnst_strg_type, "ivarLayout", &chain);
|
|
|
659
|
|
|
660 /* const char *const name; */
|
|
|
661 add_field_decl (string_type_node, "name", &chain);
|
|
|
662
|
|
|
663 /* const struct method_list_t * const baseMethods; */
|
|
|
664 add_field_decl (objc_method_list_ptr, "baseMethods", &chain);
|
|
|
665
|
|
|
666 /* const struct objc_protocol_list *const baseProtocols; */
|
|
|
667 add_field_decl (build_pointer_type
|
|
|
668 (xref_tag (RECORD_TYPE,
|
|
|
669 get_identifier (UTAG_V2_PROTOCOL_LIST))),
|
|
|
670 "baseProtocols", &chain);
|
|
|
671
|
|
|
672 /* const struct ivar_list_t *const ivars; */
|
|
|
673 add_field_decl (objc_v2_ivar_list_ptr, "ivars", &chain);
|
|
|
674
|
|
|
675 /* const uint8_t * const weakIvarLayout; */
|
|
|
676 add_field_decl (cnst_strg_type, "weakIvarLayout", &chain);
|
|
|
677
|
|
|
678 /* struct _prop_list_t * baseProperties; */
|
|
|
679 add_field_decl (objc_prop_list_ptr, "baseProperties", &chain);
|
|
|
680
|
|
|
681 objc_finish_struct (objc_v2_class_ro_template, decls);
|
|
|
682
|
|
|
683 chain = NULL;
|
|
|
684 /* struct class_t {...} */
|
|
|
685 objc_v2_class_template =
|
|
|
686 objc_start_struct (get_identifier (UTAG_V2_CLASS));
|
|
|
687
|
|
|
688 /* struct class_t *isa; */
|
|
|
689 decls = add_field_decl (build_pointer_type (objc_v2_class_template),
|
|
|
690 "isa", &chain);
|
|
|
691
|
|
|
692 /* struct class_t * const superclass; */
|
|
|
693 add_field_decl (build_pointer_type (objc_v2_class_template),
|
|
|
694 "superclass", &chain);
|
|
|
695
|
|
|
696 /* void *cache; */
|
|
|
697 add_field_decl (build_pointer_type (void_type_node), "cache", &chain);
|
|
|
698
|
|
|
699 /* IMP *vtable; */
|
|
|
700 add_field_decl (build_pointer_type (objc_v2_imp_type), "vtable", &chain);
|
|
|
701
|
|
|
702 /* struct class_ro_t *ro; */
|
|
|
703 add_field_decl (build_pointer_type (objc_v2_class_ro_template), "ro", &chain);
|
|
|
704
|
|
|
705 objc_finish_struct (objc_v2_class_template, decls);
|
|
|
706 }
|
|
|
707
|
|
|
708 /* struct _objc_super
|
|
|
709 {
|
|
|
710 struct _objc_object *self;
|
|
|
711 Class cls;
|
|
|
712 }; */
|
|
|
713 void
|
|
|
714 build_v2_super_template (void)
|
|
|
715 {
|
|
|
716 tree decls, *chain = NULL;
|
|
|
717
|
|
|
718 objc_super_template = objc_start_struct (get_identifier (UTAG_SUPER));
|
|
|
719
|
|
|
720 /* struct _objc_object *self; */
|
|
|
721 decls = add_field_decl (objc_object_type, "self", &chain);
|
|
|
722
|
|
|
723 /* Class cls; */
|
|
|
724 add_field_decl (objc_class_type, "cls", &chain);
|
|
|
725
|
|
|
726 objc_finish_struct (objc_super_template, decls);
|
|
|
727 }
|
|
|
728
|
|
|
729 /* struct protocol_t
|
|
|
730 {
|
|
|
731 Class isa;
|
|
|
732 const char * const protocol_name;
|
|
|
733 const struct protocol_list_t * const protocol_list;
|
|
|
734 const struct method_list_t * const instance_methods;
|
|
|
735 const struct method_list_t * const class_methods;
|
|
|
736 const struct method_list_t * optionalInstanceMethods;
|
|
|
737 const struct method_list_t * optionalClassMethod
|
|
|
738 const struct _prop_list_t * const properties;
|
|
|
739 const uint32_t size;
|
|
|
740 const uint32_t flags;
|
|
|
741 }
|
|
|
742 */
|
|
|
743 static void
|
|
|
744 build_v2_protocol_template (void)
|
|
|
745 {
|
|
|
746 tree decls, *chain = NULL;
|
|
|
747
|
|
|
748 objc_v2_protocol_template =
|
|
|
749 objc_start_struct (get_identifier (UTAG_V2_PROTOCOL));
|
|
|
750
|
|
|
751 /* Class isa; */
|
|
|
752 decls = add_field_decl (objc_object_type, "isa", &chain);
|
|
|
753
|
|
|
754 /* char *protocol_name; */
|
|
|
755 add_field_decl (string_type_node, "protocol_name", &chain);
|
|
|
756
|
|
|
757 /* const struct protocol_list_t * const protocol_list; */
|
|
|
758 add_field_decl (build_pointer_type (objc_v2_protocol_template),
|
|
|
759 "protocol_list", &chain);
|
|
|
760
|
|
|
761 /* const struct method_list_t * const instance_methods; */
|
|
|
762 add_field_decl (objc_method_proto_list_ptr, "instance_methods", &chain);
|
|
|
763
|
|
|
764 /* const struct method_list_t * const class_methods; */
|
|
|
765 add_field_decl (objc_method_proto_list_ptr, "class_methods", &chain);
|
|
|
766
|
|
|
767 /* const struct method_list_t * optionalInstanceMethods; */
|
|
|
768 add_field_decl (objc_method_proto_list_ptr, "optionalInstanceMethods", &chain);
|
|
|
769
|
|
|
770 /* const struct method_list_t * optionalClassMethods; */
|
|
|
771 add_field_decl (objc_method_proto_list_ptr, "optionalClassMethods", &chain);
|
|
|
772
|
|
|
773 /* struct _prop_list_t * properties; */
|
|
|
774 add_field_decl (objc_prop_list_ptr, "properties", &chain);
|
|
|
775
|
|
|
776 /* const uint32_t size; */
|
|
|
777 add_field_decl (integer_type_node, "size", &chain);
|
|
|
778
|
|
|
779 /* const uint32_t flags; */
|
|
|
780 add_field_decl (integer_type_node, "flags", &chain);
|
|
|
781
|
|
|
782 objc_finish_struct (objc_v2_protocol_template, decls);
|
|
|
783 }
|
|
|
784
|
|
|
785 /* Build type for a category:
|
|
|
786 struct category_t
|
|
|
787 {
|
|
|
788 const char * const name;
|
|
|
789 struct class_t *const cls;
|
|
|
790 const struct method_list_t * const instance_methods;
|
|
|
791 const struct method_list_t * const class_methods;
|
|
|
792 const struct protocol_list_t * const protocols;
|
|
|
793 const struct _prop_list_t * const properties;
|
|
|
794 }
|
|
|
795 */
|
|
|
796
|
|
|
797 static void
|
|
|
798 build_v2_category_template (void)
|
|
|
799 {
|
|
|
800 tree decls, *chain = NULL;
|
|
|
801
|
|
|
802 objc_v2_category_template =
|
|
|
803 objc_start_struct (get_identifier ("_category_t"));
|
|
|
804
|
|
|
805 /* char *name; */
|
|
|
806 decls = add_field_decl (string_type_node, "name", &chain);
|
|
|
807
|
|
|
808 /* struct class_t *const cls; */
|
|
|
809 add_field_decl (build_pointer_type (objc_v2_class_template), "cls", &chain);
|
|
|
810
|
|
|
811 /* struct method_list_t *instance_methods; */
|
|
|
812 add_field_decl (objc_method_list_ptr, "instance_methods", &chain);
|
|
|
813
|
|
|
814 /* struct method_list_t *class_methods; */
|
|
|
815 add_field_decl (objc_method_list_ptr, "class_methods", &chain);
|
|
|
816
|
|
|
817 /* struct protocol_list_t *protocol_list; */
|
|
|
818 add_field_decl (build_pointer_type (objc_v2_protocol_template),
|
|
|
819 "protocol_list", &chain );
|
|
|
820
|
|
|
821 /* struct _prop_list_t * properties; */
|
|
|
822 add_field_decl (objc_prop_list_ptr, "properties", &chain);
|
|
|
823
|
|
|
824 objc_finish_struct (objc_v2_category_template, decls);
|
|
|
825 }
|
|
|
826
|
|
|
827 /* NOTE --- Decls, Identifiers, Names etc. --- */
|
|
|
828
|
|
|
829 /* This routine is given a name and returns a matching extern variable
|
|
|
830 if one is found. */
|
|
|
831
|
|
|
832 static tree
|
|
|
833 hash_name_lookup (hash *hashlist, tree name)
|
|
|
834 {
|
|
|
835 hash target;
|
|
|
836
|
|
|
837 target = hashlist[IDENTIFIER_HASH_VALUE (name) % SIZEHASHTABLE];
|
|
|
838
|
|
|
839 while (target)
|
|
|
840 {
|
|
|
841 if (name == DECL_NAME (target->key))
|
|
|
842 return target->key;
|
|
|
843
|
|
|
844 target = target->next;
|
|
|
845 }
|
|
|
846 return 0;
|
|
|
847 }
|
|
|
848
|
|
|
849 /* This routine is given an extern variable and enters it in its hash
|
|
|
850 table. Note that hashing is done on its inner IDENTIFIER_NODE
|
|
|
851 node. */
|
|
|
852
|
|
|
853 static void
|
|
|
854 hash_name_enter (hash *hashlist, tree id)
|
|
|
855 {
|
|
|
856 hash obj;
|
|
|
857 int slot = IDENTIFIER_HASH_VALUE (DECL_NAME (id)) % SIZEHASHTABLE;
|
|
|
858
|
|
|
859 obj = ggc_alloc<hashed_entry> ();
|
|
|
860 obj->list = 0;
|
|
|
861 obj->next = hashlist[slot];
|
|
|
862 obj->key = id;
|
|
|
863
|
|
|
864 hashlist[slot] = obj; /* append to front */
|
|
|
865 }
|
|
|
866
|
|
|
867 /* Create a declaration "extern <type> <name>;"
|
|
|
868 The var will need to be finalized (e.g. by calling finish_var_decl()). */
|
|
|
869
|
|
|
870 static tree
|
|
|
871 create_extern_decl (tree type, const char *name)
|
|
|
872 {
|
|
|
873 tree id = get_identifier (name);
|
|
|
874 tree var = hash_name_lookup (extern_names, id);
|
|
|
875 if (var)
|
|
|
876 return var;
|
|
|
877 /* New name. */
|
|
|
878 var = start_var_decl (type, name);
|
|
|
879 TREE_STATIC (var) = 0;
|
|
|
880 DECL_EXTERNAL (var) = 1;
|
|
|
881 TREE_PUBLIC (var) = 1;
|
|
|
882 hash_name_enter (extern_names, var);
|
|
|
883 return var;
|
|
|
884 }
|
|
|
885
|
|
|
886 /* Create a globally visible definition for variable NAME of a given TYPE. The
|
|
|
887 finish_var_decl() routine will need to be called on it afterwards. */
|
|
|
888
|
|
|
889 static tree
|
|
|
890 create_global_decl (tree type, const char *name)
|
|
|
891 {
|
|
|
892 tree id = get_identifier (name);
|
|
|
893 tree var = hash_name_lookup (extern_names, id);
|
|
|
894 if (var)
|
|
|
895 {
|
|
|
896 DECL_EXTERNAL (var) = 0;
|
|
|
897 TREE_STATIC (var) = 1;
|
|
|
898 }
|
|
|
899 else
|
|
|
900 {
|
|
|
901 var = start_var_decl (type, name);
|
|
|
902 hash_name_enter (extern_names, var);
|
|
|
903 }
|
|
|
904 TREE_PUBLIC (var) = 1;
|
|
|
905 return var;
|
|
|
906 }
|
|
|
907
|
|
|
908 /* Create a symbol with __attribute__ ((visibility ("hidden")))
|
|
|
909 attribute (private extern). */
|
|
|
910
|
|
|
911 static tree
|
|
|
912 create_hidden_decl (tree type, const char *name)
|
|
|
913 {
|
|
|
914 tree decl = create_global_decl (type, name);
|
|
|
915 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
|
|
|
916 DECL_VISIBILITY_SPECIFIED (decl) = 1;
|
|
|
917 return decl;
|
|
|
918 }
|
|
|
919
|
|
|
920 /* Irritatingly, we have a different superclass field name for ABI=2. */
|
|
|
921 /* PS/TODO: The field name does not matter, it is only used internally
|
|
|
922 by the compiler. We can rename it to whatever we want. ;-) */
|
|
|
923
|
|
|
924 static tree
|
|
|
925 next_runtime_abi_02_super_superclassfield_id (void)
|
|
|
926 {
|
|
|
927 /* TODO: Simplify. Just always return get_identifier ("cls"), or at
|
|
|
928 most look it once at startup then always return it. */
|
|
|
929 if (!super_superclassfield_id)
|
|
|
930 super_superclassfield_id = get_identifier ("cls");
|
|
|
931 return super_superclassfield_id;
|
|
|
932 }
|
|
|
933
|
|
|
934 static tree
|
|
|
935 next_runtime_abi_02_class_decl (tree klass)
|
|
|
936 {
|
|
|
937 tree decl;
|
|
|
938 char buf[BUFSIZE];
|
|
|
939 snprintf (buf, BUFSIZE, "OBJC_CLASS_$_%s",
|
|
|
940 IDENTIFIER_POINTER (CLASS_NAME (klass)));
|
|
|
941 /* ObjC2 classes are extern visible. */
|
|
|
942 decl = create_global_decl (objc_v2_class_template, buf);
|
|
|
943 OBJCMETA (decl, objc_meta, meta_class);
|
|
|
944 return decl;
|
|
|
945 }
|
|
|
946
|
|
|
947 static tree
|
|
|
948 next_runtime_abi_02_metaclass_decl (tree klass)
|
|
|
949 {
|
|
|
950 tree decl;
|
|
|
951 char buf[BUFSIZE];
|
|
|
952 snprintf (buf, BUFSIZE, "OBJC_METACLASS_$_%s",
|
|
|
953 IDENTIFIER_POINTER (CLASS_NAME (klass)));
|
|
|
954 /* ObjC2 classes are extern visible. */
|
|
|
955 decl = create_global_decl (objc_v2_class_template, buf);
|
|
|
956 OBJCMETA (decl, objc_meta, meta_metaclass);
|
|
|
957 return decl;
|
|
|
958 }
|
|
|
959
|
|
|
960 static tree
|
|
|
961 next_runtime_abi_02_category_decl (tree klass)
|
|
|
962 {
|
|
|
963 tree decl;
|
|
|
964 char buf[BUFSIZE];
|
|
|
965 snprintf (buf, BUFSIZE, "_OBJC_Category_%s_on_%s",
|
|
|
966 IDENTIFIER_POINTER (CLASS_SUPER_NAME (klass)),
|
|
|
967 IDENTIFIER_POINTER (CLASS_NAME (klass)));
|
|
|
968 decl = start_var_decl (objc_v2_category_template, buf);
|
|
|
969 OBJCMETA (decl, objc_meta, meta_category);
|
|
|
970 return decl;
|
|
|
971 }
|
|
|
972
|
|
|
973 static tree
|
|
|
974 next_runtime_abi_02_protocol_decl (tree p)
|
|
|
975 {
|
|
|
976 tree decl;
|
|
|
977 char buf[BUFSIZE];
|
|
|
978
|
|
|
979 /* static struct _objc_protocol _OBJC_Protocol_<mumble>; */
|
|
|
980 snprintf (buf, BUFSIZE, "_OBJC_Protocol_%s",
|
|
|
981 IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
|
|
|
982 decl = start_var_decl (objc_v2_protocol_template, buf);
|
|
|
983 OBJCMETA (decl, objc_meta, meta_protocol);
|
|
|
984 return decl;
|
|
|
985 }
|
|
|
986
|
|
|
987 static tree
|
|
|
988 next_runtime_abi_02_string_decl (tree type, const char *name, string_section where)
|
|
|
989 {
|
|
|
990 tree var = start_var_decl (type, name);
|
|
|
991 switch (where)
|
|
|
992 {
|
|
|
993 case class_names:
|
|
|
994 OBJCMETA (var, objc_meta, meta_class_name);
|
|
|
995 break;
|
|
|
996 case meth_var_names:
|
|
|
997 OBJCMETA (var, objc_meta, meta_meth_name);
|
|
|
998 break;
|
|
|
999 case meth_var_types:
|
|
|
1000 OBJCMETA (var, objc_meta, meta_meth_type);
|
|
|
1001 break;
|
|
|
1002 case prop_names_attr:
|
|
|
1003 OBJCMETA (var, objc_meta, meta_prop_name_attr);
|
|
|
1004 break;
|
|
|
1005 default:
|
|
|
1006 OBJCMETA (var, objc_meta, meta_base);
|
|
|
1007 break;
|
|
|
1008 }
|
|
|
1009 return var;
|
|
|
1010 }
|
|
|
1011
|
|
|
1012 /* NOTE --- entry --- */
|
|
|
1013
|
|
|
1014 struct GTY(()) ident_data_tuple {
|
|
|
1015 tree ident;
|
|
|
1016 tree data;
|
|
|
1017 };
|
|
|
1018
|
|
|
1019 /* This routine creates a file scope static variable of type 'Class'
|
|
|
1020 to hold the address of a class. */
|
|
|
1021
|
|
|
1022 static tree
|
|
|
1023 build_v2_class_reference_decl (tree ident)
|
|
|
1024 {
|
|
|
1025 tree decl;
|
|
|
1026 char buf[BUFSIZE];
|
|
|
1027
|
|
|
1028 snprintf (buf, BUFSIZE, "_OBJC_ClassRef_%s", IDENTIFIER_POINTER (ident));
|
|
|
1029 decl = start_var_decl (objc_class_type, buf);
|
|
|
1030 OBJCMETA (decl, objc_meta, meta_class_ref);
|
|
|
1031 return decl;
|
|
|
1032 }
|
|
|
1033
|
|
|
1034 /* This routine builds a class refs entry for each class name used.
|
|
|
1035 Initially, a (static-ref, IDENT) tuple is added to the list. The
|
|
|
1036 ident is replaced with address of the class metadata (of type
|
|
|
1037 'Class') in the output routine. */
|
|
|
1038
|
|
|
1039 static GTY (()) vec<ident_data_tuple, va_gc> *classrefs;
|
|
|
1040
|
|
|
1041 static tree
|
|
|
1042 objc_v2_get_class_reference (tree ident)
|
|
|
1043 {
|
|
|
1044 tree decl;
|
|
|
1045 ident_data_tuple e;
|
|
|
1046 if (classrefs)
|
|
|
1047 {
|
|
|
1048 int count;
|
|
|
1049 ident_data_tuple *ref;
|
|
|
1050 FOR_EACH_VEC_ELT (*classrefs, count, ref)
|
|
|
1051 {
|
|
|
1052 if (ref->ident == ident)
|
|
|
1053 {
|
|
|
1054 if (!ref->data)
|
|
|
1055 ref->data = build_v2_class_reference_decl (ident);
|
|
|
1056 return ref->data;
|
|
|
1057 }
|
|
|
1058 }
|
|
|
1059 }
|
|
|
1060 else
|
|
|
1061 /* Somewhat arbitrary initial provision. */
|
|
|
1062 vec_alloc (classrefs, 16);
|
|
|
1063
|
|
|
1064 /* We come here if we don't find the entry - or if the table was yet
|
|
|
1065 to be created. */
|
|
|
1066 decl = build_v2_class_reference_decl (ident);
|
|
|
1067 e.ident = ident;
|
|
|
1068 e.data = decl;
|
|
|
1069 vec_safe_push (classrefs, e);
|
|
|
1070 return decl;
|
|
|
1071 }
|
|
|
1072
|
|
|
1073 static tree
|
|
|
1074 next_runtime_abi_02_get_class_reference (tree ident)
|
|
|
1075 {
|
|
|
1076 if (!flag_zero_link)
|
|
|
1077 return objc_v2_get_class_reference (ident);
|
|
|
1078 else
|
|
|
1079 {
|
|
|
1080 /* We fall back to using objc_getClass (). */
|
|
|
1081 vec<tree, va_gc> *v;
|
|
|
1082 vec_alloc (v, 1);
|
|
|
1083 tree t;
|
|
|
1084 /* ??? add_class_reference (ident); - is pointless, since the
|
|
|
1085 system lib does not export the equivalent symbols. Maybe we
|
|
|
1086 need to build a class ref anyway. */
|
|
|
1087 t = my_build_string_pointer (IDENTIFIER_LENGTH (ident) + 1,
|
|
|
1088 IDENTIFIER_POINTER (ident));
|
|
|
1089 v->quick_push (t);
|
|
|
1090 t = build_function_call_vec (input_location, vNULL, objc_get_class_decl,
|
|
|
1091 v, 0);
|
|
|
1092 vec_free (v);
|
|
|
1093 return t;
|
|
|
1094 }
|
|
|
1095 }
|
|
|
1096
|
|
|
1097 /* Used by build_function_type_for_method. Append the types for
|
|
|
1098 receiver & _cmd at the start of a method argument list to ARGTYPES.
|
|
|
1099 CONTEXT is either METHOD_DEF or METHOD_REF, saying whether we are
|
|
|
1100 trying to define a method or call one. SUPERFLAG says this is for a
|
|
|
1101 send to super. METH may be NULL, in the case that there is no
|
|
|
1102 prototype. */
|
|
|
1103
|
|
|
1104 static void
|
|
|
1105 next_runtime_abi_02_get_arg_type_list_base (vec<tree, va_gc> **argtypes,
|
|
|
1106 tree meth, int context,
|
|
|
1107 int superflag)
|
|
|
1108 {
|
|
|
1109 tree receiver_type;
|
|
|
1110
|
|
|
1111 if (superflag)
|
|
|
1112 receiver_type = objc_super_type;
|
|
|
1113 else if (context == METHOD_DEF && TREE_CODE (meth) == INSTANCE_METHOD_DECL)
|
|
|
1114 receiver_type = objc_instance_type;
|
|
|
1115 else
|
|
|
1116 receiver_type = objc_object_type;
|
|
|
1117
|
|
|
1118 vec_safe_push (*argtypes, receiver_type);
|
|
|
1119 /* Selector type - will eventually change to `int'. */
|
|
|
1120 vec_safe_push (*argtypes,
|
|
|
1121 superflag ? objc_v2_super_selector_type
|
|
|
1122 : objc_v2_selector_type);
|
|
|
1123 }
|
|
|
1124
|
|
|
1125 /* TODO: Merge this with the message refs. */
|
|
|
1126 static tree
|
|
|
1127 build_selector_reference_decl (tree ident)
|
|
|
1128 {
|
|
|
1129 tree decl;
|
|
|
1130 char *t, buf[BUFSIZE];
|
|
|
1131
|
|
|
1132 snprintf (buf, BUFSIZE, "_OBJC_SelRef_%s", IDENTIFIER_POINTER (ident));
|
|
|
1133 t = buf;
|
|
|
1134 while (*t)
|
|
|
1135 {
|
|
|
1136 if (*t==':')
|
|
|
1137 *t = '$'; /* Underscore would clash between foo:bar and foo_bar. */
|
|
|
1138 t++;
|
|
|
1139 }
|
|
|
1140 decl = start_var_decl (objc_selector_type, buf);
|
|
|
1141 OBJCMETA (decl, objc_meta, meta_sel_refs);
|
|
|
1142 return decl;
|
|
|
1143 }
|
|
|
1144
|
|
|
1145 static tree
|
|
|
1146 next_runtime_abi_02_build_selector_reference (location_t loc ATTRIBUTE_UNUSED,
|
|
|
1147 tree ident,
|
|
|
1148 tree proto ATTRIBUTE_UNUSED)
|
|
|
1149 {
|
|
|
1150 tree *chain = &sel_ref_chain;
|
|
|
1151 tree expr;
|
|
|
1152
|
|
|
1153 while (*chain)
|
|
|
1154 {
|
|
|
1155 if (TREE_VALUE (*chain) == ident)
|
|
|
1156 return TREE_PURPOSE (*chain);
|
|
|
1157
|
|
|
1158 chain = &TREE_CHAIN (*chain);
|
|
|
1159 }
|
|
|
1160
|
|
|
1161 expr = build_selector_reference_decl (ident);
|
|
|
1162 *chain = tree_cons (expr, ident, NULL_TREE);
|
|
|
1163
|
|
|
1164 return expr;
|
|
|
1165 }
|
|
|
1166
|
|
|
1167 /* Declare a variable of type 'struct message_ref_t'. */
|
|
|
1168 /* This will be finished in build_v2_message_ref_translation_table ().
|
|
|
1169 We take an idea from LLVM in making the names a bit more connected
|
|
|
1170 and thus the asm more readable. */
|
|
|
1171
|
|
|
1172 static tree
|
|
|
1173 build_v2_message_reference_decl (tree sel_name, tree message_func_ident)
|
|
|
1174 {
|
|
|
1175 tree decl;
|
|
|
1176 char buf[BUFSIZE], *t;
|
|
|
1177 int offset = 12;
|
|
|
1178
|
|
|
1179 /* Skip past the objc_msgSend it's the same for all... */
|
|
|
1180 if (IDENTIFIER_POINTER (message_func_ident)[offset] == '_')
|
|
|
1181 offset++;
|
|
|
1182
|
|
|
1183 snprintf (buf, BUFSIZE, "_OBJC_MsgRef_%s_%s",
|
|
|
1184 &(IDENTIFIER_POINTER (message_func_ident)[offset]),
|
|
|
1185 IDENTIFIER_POINTER (sel_name));
|
|
|
1186 t = buf;
|
|
|
1187 while (*t)
|
|
|
1188 {
|
|
|
1189 if (*t==':')
|
|
|
1190 *t = '$'; /* Underscore would clash between foo:bar and foo_bar. */
|
|
|
1191 t++;
|
|
|
1192 }
|
|
|
1193 decl = start_var_decl (objc_v2_message_ref_template, buf);
|
|
|
1194 OBJCMETA (decl, objc_meta, meta_mref);
|
|
|
1195 return decl;
|
|
|
1196 }
|
|
|
1197
|
|
|
1198 struct GTY(()) msgref_entry {
|
|
|
1199 tree func;
|
|
|
1200 tree selname;
|
|
|
1201 tree refdecl;
|
|
|
1202 };
|
|
|
1203
|
|
|
1204 static GTY (()) vec<msgref_entry, va_gc> *msgrefs;
|
|
|
1205
|
|
|
1206 /* Build the list of (objc_msgSend_fixup_xxx, selector name), used
|
|
|
1207 later on to initialize the table of 'struct message_ref_t'
|
|
|
1208 elements. */
|
|
|
1209
|
|
|
1210 static tree
|
|
|
1211 build_v2_selector_messenger_reference (tree sel_name, tree message_func_decl)
|
|
|
1212 {
|
|
|
1213 tree decl;
|
|
|
1214 msgref_entry e;
|
|
|
1215 if (msgrefs)
|
|
|
1216 {
|
|
|
1217 int count;
|
|
|
1218 msgref_entry *ref;
|
|
|
1219 FOR_EACH_VEC_ELT (*msgrefs, count, ref)
|
|
|
1220 if (ref->func == message_func_decl && ref->selname == sel_name)
|
|
|
1221 return ref->refdecl;
|
|
|
1222 }
|
|
|
1223 else
|
|
|
1224 /* Somewhat arbitrary initial provision. */
|
|
|
1225 vec_alloc (msgrefs, 32);
|
|
|
1226
|
|
|
1227 /* We come here if we don't find a match or at the start. */
|
|
|
1228 decl = build_v2_message_reference_decl (sel_name,
|
|
|
1229 DECL_NAME (message_func_decl));
|
|
|
1230 e.func = message_func_decl;
|
|
|
1231 e.selname = sel_name;
|
|
|
1232 e.refdecl = decl;
|
|
|
1233 vec_safe_push (msgrefs, e);
|
|
|
1234 return decl;
|
|
|
1235 }
|
|
|
1236
|
|
|
1237 static tree
|
|
|
1238 build_v2_protocollist_ref_decl (tree protocol)
|
|
|
1239 {
|
|
|
1240 tree decl;
|
|
|
1241 tree protocol_ident = PROTOCOL_NAME (protocol);
|
|
|
1242 char buf[BUFSIZE];
|
|
|
1243
|
|
|
1244 snprintf (buf, BUFSIZE, "_OBJC_ProtocolRef_%s",
|
|
|
1245 IDENTIFIER_POINTER (protocol_ident));
|
|
|
1246 /* TODO: other compiler versions make these hidden & weak. */
|
|
|
1247 decl = create_global_decl (objc_protocol_type, buf);
|
|
|
1248 /* Let optimizer know that this decl is not removable. */
|
|
|
1249 DECL_PRESERVE_P (decl) = 1;
|
|
|
1250 OBJCMETA (decl, objc_meta, meta_proto_ref);
|
|
|
1251 return decl;
|
|
|
1252 }
|
|
|
1253
|
|
|
1254 struct GTY(()) prot_list_entry {
|
|
|
1255 tree id;
|
|
|
1256 tree refdecl;
|
|
|
1257 };
|
|
|
1258 static GTY (()) vec<prot_list_entry, va_gc> *protrefs;
|
|
|
1259
|
|
|
1260 static tree
|
|
|
1261 objc_v2_get_protocol_reference (tree ident)
|
|
|
1262 {
|
|
|
1263 tree decl;
|
|
|
1264 prot_list_entry e;
|
|
|
1265 if (protrefs)
|
|
|
1266 {
|
|
|
1267 int count;
|
|
|
1268 prot_list_entry *ref;
|
|
|
1269 FOR_EACH_VEC_ELT (*protrefs, count, ref)
|
|
|
1270 {
|
|
|
1271 if (ref->id == ident)
|
|
|
1272 {
|
|
|
1273 if (!ref->refdecl)
|
|
|
1274 ref->refdecl = build_v2_protocollist_ref_decl (ident);
|
|
|
1275 return ref->refdecl;
|
|
|
1276 }
|
|
|
1277 }
|
|
|
1278 }
|
|
|
1279 else
|
|
|
1280 /* Somewhat arbitrary initial provision. */
|
|
|
1281 vec_alloc (protrefs, 32);
|
|
|
1282
|
|
|
1283 /* We come here if we don't find the entry - or if the table was yet
|
|
|
1284 to be created. */
|
|
|
1285 decl = build_v2_protocollist_ref_decl (ident);
|
|
|
1286 e.id = ident;
|
|
|
1287 e.refdecl = decl;
|
|
|
1288 vec_safe_push (protrefs, e);
|
|
|
1289 return decl;
|
|
|
1290 }
|
|
|
1291
|
|
|
1292 static tree
|
|
|
1293 next_runtime_abi_02_get_protocol_reference (location_t loc ATTRIBUTE_UNUSED,
|
|
|
1294 tree p)
|
|
|
1295 {
|
|
|
1296 if (!PROTOCOL_FORWARD_DECL (p))
|
|
|
1297 PROTOCOL_FORWARD_DECL (p) = next_runtime_abi_02_protocol_decl (p);
|
|
|
1298
|
|
|
1299 return objc_v2_get_protocol_reference (p);
|
|
|
1300 }
|
|
|
1301
|
|
|
1302 /* This routine returns the ivar declaration, if component is a valid
|
|
|
1303 ivar field; NULL_TREE otherwise. On finding an ivar, it also
|
|
|
1304 returns the class name in CLASS. */
|
|
|
1305
|
|
|
1306 static tree
|
|
|
1307 objc_is_ivar (tree expr, tree component, tree *klass)
|
|
|
1308 {
|
|
|
1309 tree field = NULL_TREE;
|
|
|
1310 tree basetype = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
|
|
|
1311
|
|
|
1312 if (TREE_CODE (basetype) == RECORD_TYPE
|
|
|
1313 && TYPE_HAS_OBJC_INFO (basetype) && TYPE_OBJC_INTERFACE (basetype))
|
|
|
1314 {
|
|
|
1315 *klass = lookup_interface (OBJC_TYPE_NAME (basetype));
|
|
|
1316 if (*klass)
|
|
|
1317 {
|
|
|
1318 do
|
|
|
1319 {
|
|
|
1320 tree ivar_chain = CLASS_RAW_IVARS (*klass);
|
|
|
1321 if (ivar_chain)
|
|
|
1322 {
|
|
|
1323 field = is_ivar (ivar_chain, component);
|
|
|
1324 if (field != NULL_TREE)
|
|
|
1325 break;
|
|
|
1326 }
|
|
|
1327 *klass = lookup_interface (CLASS_SUPER_NAME (*klass));
|
|
|
1328 }
|
|
|
1329 while (*klass);
|
|
|
1330 }
|
|
|
1331 }
|
|
|
1332 return field;
|
|
|
1333 }
|
|
|
1334
|
|
|
1335 static void
|
|
|
1336 create_ivar_offset_name (char *buf, tree class_name, tree field_decl)
|
|
|
1337 {
|
|
|
1338 tree fname = DECL_NAME (field_decl);
|
|
|
1339
|
|
|
1340 sprintf (buf, "OBJC_IVAR_$_%s.%s", IDENTIFIER_POINTER (class_name),
|
|
|
1341 IDENTIFIER_POINTER (fname));
|
|
|
1342 return;
|
|
|
1343 }
|
|
|
1344
|
|
|
1345 /* This routine generates new abi's ivar reference tree. It amounts
|
|
|
1346 to generating *(TYPE*)((char*)pObj + OFFSET_IVAR) when we normally
|
|
|
1347 generate pObj->IVAR. OFFSET_IVAR is an 'extern' variable holding
|
|
|
1348 the offset for 'IVAR' field. TYPE is type of IVAR field. */
|
|
|
1349
|
|
|
1350 static tree
|
|
|
1351 objc_v2_build_ivar_ref (tree datum, tree component)
|
|
|
1352 {
|
|
|
1353 tree field, ref, class_name, offset, ftype, expr;
|
|
|
1354 char var_offset_name[512];
|
|
|
1355
|
|
|
1356 field = objc_is_ivar (datum, component, &class_name);
|
|
|
1357 if (!field)
|
|
|
1358 return NULL_TREE;
|
|
|
1359
|
|
|
1360 /* This routine only handles non-bitfield fields */
|
|
|
1361 /* DECL_INITIAL macro is set to width of bitfield and can be relied
|
|
|
1362 on to check for bitfield ivars. Note that I cannot rely on
|
|
|
1363 DECL_BIT_FIELD macro because it is only set when the whole struct
|
|
|
1364 is seen (at finish_struct) and not when the ivar chain is
|
|
|
1365 built. */
|
|
|
1366 if (DECL_INITIAL (field))
|
|
|
1367 return NULL_TREE;
|
|
|
1368
|
|
|
1369 create_ivar_offset_name (var_offset_name, CLASS_NAME (class_name), field);
|
|
|
1370
|
|
|
1371 offset = create_extern_decl (TREE_TYPE (size_zero_node), var_offset_name);
|
|
|
1372
|
|
|
1373 ftype = TREE_TYPE (field);
|
|
|
1374
|
|
|
1375 /* (char*)datum */
|
|
|
1376 expr = build_c_cast (input_location,
|
|
|
1377 string_type_node, build_fold_addr_expr (datum));
|
|
|
1378
|
|
|
1379 /* (char*)datum + offset */
|
|
|
1380 expr = fold_build_pointer_plus_loc (input_location, expr, offset);
|
|
|
1381
|
|
|
1382 /* (ftype*)((char*)datum + offset) */
|
|
|
1383 expr = build_c_cast (input_location, build_pointer_type (ftype), expr);
|
|
|
1384
|
|
|
1385 /* Finally: *(ftype*)((char*)datum + offset) */
|
|
|
1386 ref = build_indirect_ref (input_location, expr, RO_UNARY_STAR);
|
|
|
1387
|
|
|
1388 /* We must set type of the resulting expression to be the same as
|
|
|
1389 the field type. This is because, build_indirect_ref (...)
|
|
|
1390 rebuilds the type which may result in lost information; as in the
|
|
|
1391 case of protocol-qualified types (id <protocol> ). */
|
|
|
1392 TREE_TYPE (ref) = ftype;
|
|
|
1393
|
|
|
1394 if (TREE_READONLY (datum) || TREE_READONLY (field))
|
|
|
1395 TREE_READONLY (ref) = 1;
|
|
|
1396
|
|
|
1397 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (field))
|
|
|
1398 TREE_THIS_VOLATILE (ref) = 1;
|
|
|
1399
|
|
|
1400 if (TREE_DEPRECATED (field))
|
|
|
1401 warn_deprecated_use (field, NULL_TREE);
|
|
|
1402
|
|
|
1403 return ref;
|
|
|
1404 }
|
|
|
1405
|
|
|
1406 /* IVAR refs are made via an externally referenceable offset and built
|
|
|
1407 on the fly. That is, unless they refer to (private) fields in the
|
|
|
1408 class structure. */
|
|
|
1409 static tree
|
|
|
1410 next_runtime_abi_02_build_ivar_ref (location_t loc ATTRIBUTE_UNUSED,
|
|
|
1411 tree base, tree id)
|
|
|
1412 {
|
|
|
1413 tree ivar;
|
|
|
1414 if ((ivar = objc_v2_build_ivar_ref (base, id)))
|
|
|
1415 return ivar;
|
|
|
1416 return objc_build_component_ref (base, id);
|
|
|
1417 }
|
|
|
1418
|
|
|
1419 /* [super ...] references are listed here (and built into a table at
|
|
|
1420 meta -data emit time). */
|
|
|
1421 static tree
|
|
|
1422 build_v2_superclass_ref_decl (tree ident, bool inst)
|
|
|
1423 {
|
|
|
1424 tree decl;
|
|
|
1425 char buf[BUFSIZE];
|
|
|
1426
|
|
|
1427 snprintf (buf, BUFSIZE, "_OBJC_%sSuperRef_%s", (inst?"":"Meta"),
|
|
|
1428 IDENTIFIER_POINTER (ident));
|
|
|
1429 decl = start_var_decl (objc_class_type, buf);
|
|
|
1430 OBJCMETA (decl, objc_meta, meta_superclass_ref);
|
|
|
1431 return decl;
|
|
|
1432 }
|
|
|
1433
|
|
|
1434 static GTY (()) vec<ident_data_tuple, va_gc> *class_super_refs;
|
|
|
1435 static GTY (()) vec<ident_data_tuple, va_gc> *metaclass_super_refs;
|
|
|
1436
|
|
|
1437 static tree
|
|
|
1438 next_runtime_abi_02_get_class_super_ref (location_t loc ATTRIBUTE_UNUSED,
|
|
|
1439 struct imp_entry *imp, bool inst_meth)
|
|
|
1440 {
|
|
|
1441 tree decl;
|
|
|
1442 ident_data_tuple e;
|
|
|
1443 tree id = CLASS_NAME (imp->imp_context);
|
|
|
1444 vec<ident_data_tuple, va_gc> *list = inst_meth ? class_super_refs
|
|
|
1445 : metaclass_super_refs;
|
|
|
1446
|
|
|
1447 if (list)
|
|
|
1448 {
|
|
|
1449 int count;
|
|
|
1450 ident_data_tuple *ref;
|
|
|
1451 FOR_EACH_VEC_ELT (*list, count, ref)
|
|
|
1452 {
|
|
|
1453 if (ref->ident == id)
|
|
|
1454 {
|
|
|
1455 if (!ref->data)
|
|
|
1456 ref->data = build_v2_superclass_ref_decl (id, inst_meth);
|
|
|
1457 return ref->data;
|
|
|
1458 }
|
|
|
1459 }
|
|
|
1460 }
|
|
|
1461 else
|
|
|
1462 {
|
|
|
1463 /* Somewhat arbitrary initial provision. */
|
|
|
1464 if (inst_meth)
|
|
|
1465 {
|
|
|
1466 vec_alloc (class_super_refs, 16);
|
|
|
1467 list = class_super_refs;
|
|
|
1468 }
|
|
|
1469 else
|
|
|
1470 {
|
|
|
1471 vec_alloc (metaclass_super_refs, 16);
|
|
|
1472 list = metaclass_super_refs;
|
|
|
1473 }
|
|
|
1474 }
|
|
|
1475 /* We come here if we don't find the entry - or if the table was yet
|
|
|
1476 to be created. */
|
|
|
1477 decl = build_v2_superclass_ref_decl (id, inst_meth);
|
|
|
1478 e.ident = id;
|
|
|
1479 e.data = decl;
|
|
|
1480 vec_safe_push (list, e);
|
|
|
1481 return decl;
|
|
|
1482 }
|
|
|
1483
|
|
|
1484 static tree
|
|
|
1485 next_runtime_abi_02_get_category_super_ref (location_t loc ATTRIBUTE_UNUSED,
|
|
|
1486 struct imp_entry *imp, bool inst_meth)
|
|
|
1487 {
|
|
|
1488 /* ??? is this OK when zero-link = true? */
|
|
|
1489 tree super_name = CLASS_SUPER_NAME (imp->imp_template);
|
|
|
1490 tree super_class;
|
|
|
1491
|
|
|
1492 if (!flag_zero_link)
|
|
|
1493 {
|
|
|
1494 super_class = objc_get_class_reference (CLASS_NAME (imp->imp_template));
|
|
|
1495
|
|
|
1496 if (!inst_meth)
|
|
|
1497
|
|
|
1498 /* If we are in a class method, we must retrieve the
|
|
|
1499 _metaclass_ for the current class, pointed at by the
|
|
|
1500 class's "isa" pointer. The following assumes that "isa" is
|
|
|
1501 the first ivar in a class (which it must be). */
|
|
|
1502 super_class =
|
|
|
1503 build_indirect_ref (input_location,
|
|
|
1504 build_c_cast (input_location,
|
|
|
1505 build_pointer_type (objc_class_type),
|
|
|
1506 super_class),
|
|
|
1507 RO_UNARY_STAR);
|
|
|
1508 return super_class;
|
|
|
1509 }
|
|
|
1510 /* ??? Do we need to add the class ref anway for zero-link? */
|
|
|
1511 /* else do it the slow way. */
|
|
|
1512 super_class = (inst_meth ? objc_get_class_decl : objc_get_meta_class_decl);
|
|
|
1513 super_name = my_build_string_pointer (IDENTIFIER_LENGTH (super_name) + 1,
|
|
|
1514 IDENTIFIER_POINTER (super_name));
|
|
|
1515 /* super_class = objc_get{Meta}Class("CLASS_SUPER_NAME"); */
|
|
|
1516 return build_function_call (input_location,
|
|
|
1517 super_class,
|
|
|
1518 build_tree_list (NULL_TREE, super_name));
|
|
|
1519 }
|
|
|
1520
|
|
|
1521 static tree
|
|
|
1522 next_runtime_abi_02_receiver_is_class_object (tree receiver)
|
|
|
1523 {
|
|
|
1524 if (TREE_CODE (receiver) == VAR_DECL
|
|
|
1525 && IS_CLASS (TREE_TYPE (receiver))
|
|
|
1526 && vec_safe_length (classrefs))
|
|
|
1527 {
|
|
|
1528 int count;
|
|
|
1529 ident_data_tuple *ref;
|
|
|
1530 /* The receiver is a variable created by build_class_reference_decl. */
|
|
|
1531 FOR_EACH_VEC_ELT (*classrefs, count, ref)
|
|
|
1532 if (ref->data == receiver)
|
|
|
1533 return ref->ident;
|
|
|
1534 }
|
|
|
1535 return NULL_TREE;
|
|
|
1536 }
|
|
|
1537
|
|
|
1538 /* Assign all arguments in VALUES which have side-effect to a temporary
|
|
|
1539 and replaced that argument in VALUES list with the temporary. The
|
|
|
1540 arguments will be passed to a function with FNTYPE. */
|
|
|
1541
|
|
|
1542 static tree
|
|
|
1543 objc_copy_to_temp_side_effect_params (tree fntype, tree values)
|
|
|
1544 {
|
|
|
1545 tree valtail;
|
|
|
1546 function_args_iterator iter;
|
|
|
1547
|
|
|
1548 /* Skip over receiver and the &_msf_ref types. */
|
|
|
1549 function_args_iter_init (&iter, fntype);
|
|
|
1550 function_args_iter_next (&iter);
|
|
|
1551 function_args_iter_next (&iter);
|
|
|
1552
|
|
|
1553 for (valtail = values; valtail;
|
|
|
1554 valtail = TREE_CHAIN (valtail), function_args_iter_next (&iter))
|
|
|
1555 {
|
|
|
1556 tree value = TREE_VALUE (valtail);
|
|
|
1557 tree type = function_args_iter_cond (&iter);
|
|
|
1558 if (type == NULL_TREE)
|
|
|
1559 break;
|
|
|
1560 if (!TREE_SIDE_EFFECTS (value))
|
|
|
1561 continue;
|
|
|
1562 /* To prevent re-evaluation. */
|
|
|
1563 value = save_expr (value);
|
|
|
1564 add_stmt (value);
|
|
|
1565 TREE_VALUE (valtail) = value;
|
|
|
1566 }
|
|
|
1567 return values;
|
|
|
1568 }
|
|
|
1569
|
|
|
1570 /* Build the new abi's messaging library call. It looks like:
|
|
|
1571 (*_msg.messenger) (receiver, &_msg, ...) */
|
|
|
1572
|
|
|
1573 static tree
|
|
|
1574 build_v2_build_objc_method_call (int super_flag, tree method_prototype,
|
|
|
1575 tree lookup_object, tree selector,
|
|
|
1576 tree method_params,
|
|
|
1577 bool check_for_nil)
|
|
|
1578 {
|
|
|
1579 tree ret_val;
|
|
|
1580 tree sender, rcv_p, t;
|
|
|
1581 tree ret_type
|
|
|
1582 = (method_prototype
|
|
|
1583 ? TREE_VALUE (TREE_TYPE (method_prototype))
|
|
|
1584 : objc_object_type);
|
|
|
1585 tree ftype = build_function_type_for_method (ret_type, method_prototype,
|
|
|
1586 METHOD_REF, super_flag);
|
|
|
1587 tree sender_cast;
|
|
|
1588
|
|
|
1589 if (method_prototype && METHOD_TYPE_ATTRIBUTES (method_prototype))
|
|
|
1590 ftype = build_type_attribute_variant (
|
|
|
1591 ftype, METHOD_TYPE_ATTRIBUTES (method_prototype));
|
|
|
1592
|
|
|
1593 sender_cast = build_pointer_type (ftype);
|
|
|
1594
|
|
|
1595 if (check_for_nil)
|
|
|
1596 method_params = objc_copy_to_temp_side_effect_params (ftype,
|
|
|
1597 method_params);
|
|
|
1598
|
|
|
1599 /* Get &message_ref_t.messenger. */
|
|
|
1600 sender = build_c_cast (input_location,
|
|
|
1601 build_pointer_type (super_flag
|
|
|
1602 ? objc_v2_super_imp_type
|
|
|
1603 : objc_v2_imp_type),
|
|
|
1604 selector);
|
|
|
1605
|
|
|
1606 sender = build_indirect_ref (input_location, sender, RO_UNARY_STAR);
|
|
|
1607
|
|
|
1608 rcv_p = (super_flag ? objc_super_type : objc_object_type);
|
|
|
1609
|
|
|
1610 lookup_object = build_c_cast (input_location, rcv_p, lookup_object);
|
|
|
1611
|
|
|
1612 /* Use SAVE_EXPR to avoid evaluating the receiver twice. */
|
|
|
1613 lookup_object = save_expr (lookup_object);
|
|
|
1614
|
|
|
1615 method_params = tree_cons (NULL_TREE, lookup_object,
|
|
|
1616 tree_cons (NULL_TREE, selector,
|
|
|
1617 method_params));
|
|
|
1618 t = build3 (OBJ_TYPE_REF, sender_cast, sender, lookup_object, size_zero_node);
|
|
|
1619 ret_val = build_function_call (input_location, t, method_params);
|
|
|
1620 if (check_for_nil)
|
|
|
1621 {
|
|
|
1622 /* receiver != nil ? ret_val : 0 */
|
|
|
1623 tree ftree;
|
|
|
1624 tree ifexp;
|
|
|
1625
|
|
|
1626 if (TREE_CODE (ret_type) == RECORD_TYPE
|
|
|
1627 || TREE_CODE (ret_type) == UNION_TYPE)
|
|
|
1628 {
|
|
|
1629 vec<constructor_elt, va_gc> *rtt = NULL;
|
|
|
1630 /* ??? CHECKME. hmmm..... think we need something more
|
|
|
1631 here. */
|
|
|
1632 CONSTRUCTOR_APPEND_ELT (rtt, NULL_TREE, NULL_TREE);
|
|
|
1633 ftree = objc_build_constructor (ret_type, rtt);
|
|
|
1634 }
|
|
|
1635 else
|
|
|
1636 ftree = fold_convert (ret_type, integer_zero_node);
|
|
|
1637
|
|
|
1638 ifexp = build_binary_op (input_location, NE_EXPR,
|
|
|
1639 lookup_object,
|
|
|
1640 fold_convert (rcv_p, integer_zero_node), 1);
|
|
|
1641
|
|
|
1642 #ifdef OBJCPLUS
|
|
|
1643 ret_val = build_conditional_expr (input_location,
|
|
|
1644 ifexp, ret_val, ftree,
|
|
|
1645 tf_warning_or_error);
|
|
|
1646 #else
|
|
|
1647 /* ??? CHECKME. */
|
|
|
1648 ret_val = build_conditional_expr (input_location,
|
|
|
1649 ifexp, 1,
|
|
|
1650 ret_val, NULL_TREE, input_location,
|
|
|
1651 ftree, NULL_TREE, input_location);
|
|
|
1652 #endif
|
|
|
1653 }
|
|
|
1654 return ret_val;
|
|
|
1655 }
|
|
|
1656
|
|
|
1657 static tree
|
|
|
1658 next_runtime_abi_02_build_objc_method_call (location_t loc,
|
|
|
1659 tree method_prototype,
|
|
|
1660 tree receiver,
|
|
|
1661 tree rtype,
|
|
|
1662 tree sel_name,
|
|
|
1663 tree method_params,
|
|
|
1664 int super)
|
|
|
1665 {
|
|
|
1666 tree ret_type, selector;
|
|
|
1667 tree message_func_decl;
|
|
|
1668 bool check_for_nil = flag_objc_nilcheck;
|
|
|
1669
|
|
|
1670 ret_type = method_prototype
|
|
|
1671 ? TREE_VALUE (TREE_TYPE (method_prototype))
|
|
|
1672 : objc_object_type;
|
|
|
1673
|
|
|
1674 /* Do we need to check for nil receivers ? */
|
|
|
1675 /* For now, message sent to classes need no nil check. In the
|
|
|
1676 future, class declaration marked as weak_import must be nil
|
|
|
1677 checked. */
|
|
|
1678 if (super
|
|
|
1679 || (TREE_CODE (receiver) == VAR_DECL
|
|
|
1680 && TREE_TYPE (receiver) == objc_class_type))
|
|
|
1681 check_for_nil = false;
|
|
|
1682
|
|
|
1683 if (!targetm.calls.struct_value_rtx (0, 0)
|
|
|
1684 && (TREE_CODE (ret_type) == RECORD_TYPE
|
|
|
1685 || TREE_CODE (ret_type) == UNION_TYPE)
|
|
|
1686 && targetm.calls.return_in_memory (ret_type, 0))
|
|
|
1687 {
|
|
|
1688 if (super)
|
|
|
1689 message_func_decl = umsg_id_super2_stret_fixup_decl;
|
|
|
1690 else
|
|
|
1691 message_func_decl = objc_is_id (rtype)
|
|
|
1692 ? umsg_id_stret_fixup_decl
|
|
|
1693 : umsg_stret_fixup_decl;
|
|
|
1694 }
|
|
|
1695 else
|
|
|
1696 {
|
|
|
1697 if (super)
|
|
|
1698 message_func_decl = umsg_id_super2_fixup_decl;
|
|
|
1699 else
|
|
|
1700 message_func_decl = objc_is_id (rtype)
|
|
|
1701 ? umsg_id_fixup_decl
|
|
|
1702 : umsg_fixup_decl;
|
|
|
1703 }
|
|
|
1704
|
|
|
1705 selector = build_v2_selector_messenger_reference (sel_name,
|
|
|
1706 message_func_decl);
|
|
|
1707
|
|
|
1708 /* selector = &_msg; */
|
|
|
1709 selector = build_unary_op (loc, ADDR_EXPR, selector, 0);
|
|
|
1710
|
|
|
1711 selector = build_c_cast (loc, (super ? objc_v2_super_selector_type
|
|
|
1712 : objc_v2_selector_type),
|
|
|
1713 selector);
|
|
|
1714
|
|
|
1715 /* (*_msg.messenger) (receiver, &_msg, ...); */
|
|
|
1716 return build_v2_build_objc_method_call (super, method_prototype,
|
|
|
1717 receiver, selector,
|
|
|
1718 method_params, check_for_nil);
|
|
|
1719 }
|
|
|
1720
|
|
|
1721 /* NOTE --- Constant String Class Stuff --- */
|
|
|
1722
|
|
|
1723 static bool
|
|
|
1724 next_runtime_abi_02_setup_const_string_class_decl (void)
|
|
|
1725 {
|
|
|
1726 if (!constant_string_global_id)
|
|
|
1727 {
|
|
|
1728 /* Hopefully, this should not represent a serious limitation. */
|
|
|
1729 char buf[BUFSIZE];
|
|
|
1730 snprintf (buf, BUFSIZE, "OBJC_CLASS_$_%s", constant_string_class_name);
|
|
|
1731 constant_string_global_id = get_identifier (buf);
|
|
|
1732 }
|
|
|
1733
|
|
|
1734 string_class_decl = lookup_name (constant_string_global_id);
|
|
|
1735
|
|
|
1736 /* In OBJC2 abi, constant string class reference refers to class
|
|
|
1737 name for NSConstantString class. This declaration may not be
|
|
|
1738 available yet (in fact it is not in most cases). So, declare an
|
|
|
1739 extern OBJC_CLASS_$_NSConstantString in its place. */
|
|
|
1740 if (!string_class_decl)
|
|
|
1741 string_class_decl =
|
|
|
1742 create_extern_decl (objc_v2_class_template,
|
|
|
1743 IDENTIFIER_POINTER (constant_string_global_id));
|
|
|
1744
|
|
|
1745 return (string_class_decl != NULL_TREE);
|
|
|
1746 }
|
|
|
1747
|
|
|
1748 static tree
|
|
|
1749 next_runtime_abi_02_build_const_string_constructor (location_t loc, tree string,
|
|
|
1750 int length)
|
|
|
1751 {
|
|
|
1752 tree constructor, fields, var;
|
|
|
1753 vec<constructor_elt, va_gc> *v = NULL;
|
|
|
1754
|
|
|
1755 /* NeXT: (NSConstantString *) & ((__builtin_ObjCString) { isa, string, length }) */
|
|
|
1756 fields = TYPE_FIELDS (internal_const_str_type);
|
|
|
1757 CONSTRUCTOR_APPEND_ELT (v, fields,
|
|
|
1758 build_unary_op (loc, ADDR_EXPR, string_class_decl, 0));
|
|
|
1759
|
|
|
1760 fields = DECL_CHAIN (fields);
|
|
|
1761 CONSTRUCTOR_APPEND_ELT (v, fields,
|
|
|
1762 build_unary_op (loc, ADDR_EXPR, string, 1));
|
|
|
1763
|
|
|
1764 /* ??? check if this should be long. */
|
|
|
1765 fields = DECL_CHAIN (fields);
|
|
|
1766 CONSTRUCTOR_APPEND_ELT (v, fields, build_int_cst (NULL_TREE, length));
|
|
|
1767 constructor = objc_build_constructor (internal_const_str_type, v);
|
|
|
1768
|
|
|
1769 var = build_decl (input_location, CONST_DECL, NULL, TREE_TYPE (constructor));
|
|
|
1770 DECL_INITIAL (var) = constructor;
|
|
|
1771 TREE_STATIC (var) = 1;
|
|
|
1772 DECL_CONTEXT (var) = NULL;
|
|
|
1773 OBJCMETA (var, objc_meta, meta_const_str);
|
|
|
1774 return var;
|
|
|
1775 }
|
|
|
1776
|
|
|
1777 /* NOTE --- NeXT V2 Metadata templates --- */
|
|
|
1778
|
|
|
1779 /* This routine builds the following type:
|
|
|
1780 struct _prop_t
|
|
|
1781 {
|
|
|
1782 const char * const name; // property name
|
|
|
1783 const char * const attributes; // comma-delimited, encoded,
|
|
|
1784 // property attributes
|
|
|
1785 };
|
|
|
1786 */
|
|
|
1787
|
|
|
1788 static tree
|
|
|
1789 build_v2_property_template (void)
|
|
|
1790 {
|
|
|
1791 tree prop_record;
|
|
|
1792 tree decls, *chain = NULL;
|
|
|
1793
|
|
|
1794 prop_record = objc_start_struct (get_identifier ("_prop_t"));
|
|
|
1795 /* const char * name */
|
|
|
1796 decls = add_field_decl (string_type_node, "name", &chain);
|
|
|
1797
|
|
|
1798 /* const char * attribute */
|
|
|
1799 add_field_decl (string_type_node, "attribute", &chain);
|
|
|
1800
|
|
|
1801 objc_finish_struct (prop_record, decls);
|
|
|
1802 return prop_record;
|
|
|
1803 }
|
|
|
1804
|
|
|
1805 /* struct ivar_t
|
|
|
1806 {
|
|
|
1807 unsigned long int *offset;
|
|
|
1808 char *name;
|
|
|
1809 char *type;
|
|
|
1810 uint32_t alignment;
|
|
|
1811 uint32_t size;
|
|
|
1812 };
|
|
|
1813 */
|
|
|
1814
|
|
|
1815 static tree
|
|
|
1816 build_v2_ivar_t_template (void)
|
|
|
1817 {
|
|
|
1818 tree objc_ivar_id, objc_ivar_record;
|
|
|
1819 tree decls, *chain = NULL;
|
|
|
1820
|
|
|
1821 objc_ivar_id = get_identifier ("_ivar_t");
|
|
|
1822 objc_ivar_record = objc_start_struct (objc_ivar_id);
|
|
|
1823
|
|
|
1824 /* unsigned long int *offset; */
|
|
|
1825 decls = add_field_decl (build_pointer_type
|
|
|
1826 (TREE_TYPE (size_zero_node)), "offset", &chain);
|
|
|
1827
|
|
|
1828 /* char *name; */
|
|
|
1829 add_field_decl (string_type_node, "name", &chain);
|
|
|
1830
|
|
|
1831 /* char *type; */
|
|
|
1832 add_field_decl (string_type_node, "type", &chain);
|
|
|
1833
|
|
|
1834 /* uint32_t alignment; */
|
|
|
1835 add_field_decl (integer_type_node, "alignment", &chain);
|
|
|
1836
|
|
|
1837 /* uint32_t size; */
|
|
|
1838 add_field_decl (integer_type_node, "size", &chain);
|
|
|
1839
|
|
|
1840 objc_finish_struct (objc_ivar_record, decls);
|
|
|
1841 return objc_ivar_record;
|
|
|
1842 }
|
|
|
1843
|
|
|
1844 static void
|
|
|
1845 build_metadata_templates (void)
|
|
|
1846 {
|
|
|
1847
|
|
|
1848 if (!objc_method_template)
|
|
|
1849 objc_method_template = build_method_template ();
|
|
|
1850
|
|
|
1851 if (!objc_v2_property_template)
|
|
|
1852 objc_v2_property_template = build_v2_property_template ();
|
|
|
1853
|
|
|
1854 if (!objc_v2_ivar_template)
|
|
|
1855 objc_v2_ivar_template = build_v2_ivar_t_template ();
|
|
|
1856
|
|
|
1857 }
|
|
|
1858
|
|
|
1859 /* NOTE --- Output NeXT V2 Metadata --- */
|
|
|
1860
|
|
|
1861 /* Routine builds name of Interface's main meta-data of type class_t. */
|
|
|
1862
|
|
|
1863 static char *
|
|
|
1864 objc_build_internal_classname (tree ident, bool metaclass)
|
|
|
1865 {
|
|
|
1866 static char string[512];
|
|
|
1867 snprintf (string, 512, "%s_%s", metaclass ? "OBJC_METACLASS_$"
|
|
|
1868 : "OBJC_CLASS_$",
|
|
|
1869 IDENTIFIER_POINTER (ident));
|
|
|
1870 return string;
|
|
|
1871 }
|
|
|
1872
|
|
|
1873 /* Build the name for object of type struct class_ro_t */
|
|
|
1874
|
|
|
1875 static const char *
|
|
|
1876 newabi_append_ro (const char *name)
|
|
|
1877 {
|
|
|
1878 const char *dollar;
|
|
|
1879 char *p;
|
|
|
1880 static char string[BUFSIZE];
|
|
|
1881 dollar = strchr (name, '$');
|
|
|
1882 gcc_assert (dollar);
|
|
|
1883 p = string;
|
|
|
1884 *p = '_'; p++;
|
|
|
1885 strncpy (p, name, (int)(dollar - name));
|
|
|
1886 p += (int)(dollar - name);
|
|
|
1887 sprintf (p, "RO_%s", dollar);
|
|
|
1888 return string;
|
|
|
1889 }
|
|
|
1890
|
|
|
1891 /* Build the struct message_ref_t msg =
|
|
|
1892 {objc_msgSend_fixup_xxx, @selector(func)}
|
|
|
1893 table. */
|
|
|
1894
|
|
|
1895 static
|
|
|
1896 void build_v2_message_ref_translation_table (void)
|
|
|
1897 {
|
|
|
1898 int count;
|
|
|
1899 msgref_entry *ref;
|
|
|
1900
|
|
|
1901 if (!vec_safe_length (msgrefs))
|
|
|
1902 return;
|
|
|
1903
|
|
|
1904 FOR_EACH_VEC_ELT (*msgrefs, count, ref)
|
|
|
1905 {
|
|
|
1906 vec<constructor_elt, va_gc> *initializer;
|
|
|
1907 tree expr, constructor;
|
|
|
1908 tree struct_type = TREE_TYPE (ref->refdecl);
|
|
|
1909 location_t loc = DECL_SOURCE_LOCATION (ref->refdecl);
|
|
|
1910
|
|
|
1911 initializer = NULL;
|
|
|
1912 /* First 'IMP messenger' field... */
|
|
|
1913 expr = build_unary_op (loc, ADDR_EXPR, ref->func, 0);
|
|
|
1914 expr = convert (objc_v2_imp_type, expr);
|
|
|
1915 CONSTRUCTOR_APPEND_ELT (initializer, NULL_TREE, expr);
|
|
|
1916
|
|
|
1917 /* ... then 'SEL name' field. */
|
|
|
1918 expr = build_selector (ref->selname);
|
|
|
1919 CONSTRUCTOR_APPEND_ELT (initializer, NULL_TREE, expr);
|
|
|
1920 constructor = objc_build_constructor (struct_type, initializer);
|
|
|
1921 finish_var_decl (ref->refdecl, constructor);
|
|
|
1922 }
|
|
|
1923 }
|
|
|
1924
|
|
|
1925 /* Build decl = initializer; for each externally visible class
|
|
|
1926 reference. */
|
|
|
1927
|
|
|
1928 static void
|
|
|
1929 build_v2_classrefs_table (void)
|
|
|
1930 {
|
|
|
1931 int count;
|
|
|
1932 ident_data_tuple *ref;
|
|
|
1933
|
|
|
1934 if (!vec_safe_length (classrefs))
|
|
|
1935 return;
|
|
|
1936
|
|
|
1937 FOR_EACH_VEC_ELT (*classrefs, count, ref)
|
|
|
1938 {
|
|
|
1939 tree expr = ref->ident;
|
|
|
1940 tree decl = ref->data;
|
|
|
1941 /* Interface with no implementation and yet one of its messages
|
|
|
1942 has been used. Need to generate a full address-of tree for it
|
|
|
1943 here. */
|
|
|
1944 if (TREE_CODE (expr) == IDENTIFIER_NODE)
|
|
|
1945 {
|
|
|
1946 const char *name = objc_build_internal_classname (expr, false);
|
|
|
1947 expr = create_extern_decl (objc_v2_class_template, name);
|
|
|
1948 expr = convert (objc_class_type, build_fold_addr_expr (expr));
|
|
|
1949 }
|
|
|
1950 /* The runtime wants this, even if it appears unused, so we must force the
|
|
|
1951 output.
|
|
|
1952 DECL_PRESERVE_P (decl) = 1; */
|
|
|
1953 finish_var_decl (decl, expr);
|
|
|
1954 }
|
|
|
1955 }
|
|
|
1956
|
|
|
1957 /* Build decl = initializer; for each externally visible super class
|
|
|
1958 reference. */
|
|
|
1959
|
|
|
1960 static void
|
|
|
1961 build_v2_super_classrefs_table (bool metaclass)
|
|
|
1962 {
|
|
|
1963 int count;
|
|
|
1964 ident_data_tuple *ref;
|
|
|
1965 vec<ident_data_tuple, va_gc> *list = metaclass ? metaclass_super_refs
|
|
|
1966 : class_super_refs;
|
|
|
1967
|
|
|
1968 if (!vec_safe_length (list))
|
|
|
1969 return;
|
|
|
1970
|
|
|
1971 FOR_EACH_VEC_ELT (*list, count, ref)
|
|
|
1972 {
|
|
|
1973 tree expr = ref->ident;
|
|
|
1974 tree decl = ref->data;
|
|
|
1975 /* Interface with no implementation and yet one of its messages
|
|
|
1976 has been used. Need to generate a full address-of tree for it
|
|
|
1977 here. */
|
|
|
1978 if (TREE_CODE (expr) == IDENTIFIER_NODE)
|
|
|
1979 {
|
|
|
1980 const char * name = objc_build_internal_classname (expr, metaclass);
|
|
|
1981 expr = create_extern_decl (objc_v2_class_template, name);
|
|
|
1982 expr = convert (objc_class_type, build_fold_addr_expr (expr));
|
|
|
1983 }
|
|
|
1984 finish_var_decl (decl, expr);
|
|
|
1985 }
|
|
|
1986 }
|
|
|
1987
|
|
|
1988 /* Add the global class meta-data declaration to the list which later
|
|
|
1989 on ends up in the __class_list section. */
|
|
|
1990
|
|
|
1991 static GTY(()) vec<tree, va_gc> *class_list;
|
|
|
1992
|
|
|
1993 static void
|
|
|
1994 objc_v2_add_to_class_list (tree global_class_decl)
|
|
|
1995 {
|
|
|
1996 vec_safe_push (class_list, global_class_decl);
|
|
|
1997 }
|
|
|
1998
|
|
|
1999 static GTY(()) vec<tree, va_gc> *nonlazy_class_list;
|
|
|
2000
|
|
|
2001 /* Add the global class meta-data declaration to the list which later
|
|
|
2002 on ends up in the __nonlazy_class section. */
|
|
|
2003
|
|
|
2004 static void
|
|
|
2005 objc_v2_add_to_nonlazy_class_list (tree global_class_decl)
|
|
|
2006 {
|
|
|
2007 vec_safe_push (nonlazy_class_list, global_class_decl);
|
|
|
2008 }
|
|
|
2009
|
|
|
2010 static GTY(()) vec<tree, va_gc> *category_list;
|
|
|
2011
|
|
|
2012 /* Add the category meta-data declaration to the list which later on
|
|
|
2013 ends up in the __nonlazy_category section. */
|
|
|
2014
|
|
|
2015 static void
|
|
|
2016 objc_v2_add_to_category_list (tree decl)
|
|
|
2017 {
|
|
|
2018 vec_safe_push (category_list, decl);
|
|
|
2019 }
|
|
|
2020
|
|
|
2021 static GTY(()) vec<tree, va_gc> *nonlazy_category_list;
|
|
|
2022
|
|
|
2023 /* Add the category meta-data declaration to the list which later on
|
|
|
2024 ends up in the __category_list section. */
|
|
|
2025
|
|
|
2026 static void
|
|
|
2027 objc_v2_add_to_nonlazy_category_list (tree decl)
|
|
|
2028 {
|
|
|
2029 vec_safe_push (nonlazy_category_list, decl);
|
|
|
2030 }
|
|
|
2031
|
|
|
2032 static bool
|
|
|
2033 has_load_impl (tree clsmeth)
|
|
|
2034 {
|
|
|
2035 while (clsmeth)
|
|
|
2036 {
|
|
|
2037 tree id = METHOD_SEL_NAME (clsmeth);
|
|
|
2038 if (IDENTIFIER_LENGTH (id) == 4
|
|
|
2039 && strncmp (IDENTIFIER_POINTER (id), "load", 4) == 0)
|
|
|
2040 return true;
|
|
|
2041 clsmeth = DECL_CHAIN (clsmeth);
|
|
|
2042 }
|
|
|
2043
|
|
|
2044 return false;
|
|
|
2045 }
|
|
|
2046
|
|
|
2047 /* Build a __{class,category}_list section table containing address of
|
|
|
2048 all @implemented {class,category} meta-data. */
|
|
|
2049
|
|
|
2050 static void
|
|
|
2051 build_v2_address_table (vec<tree, va_gc> *src, const char *nam, tree attr)
|
|
|
2052 {
|
|
|
2053 int count=0;
|
|
|
2054 tree type, decl, expr;
|
|
|
2055 vec<constructor_elt, va_gc> *initlist = NULL;
|
|
|
2056
|
|
|
2057 if (!vec_safe_length (src))
|
|
|
2058 return;
|
|
|
2059
|
|
|
2060 FOR_EACH_VEC_ELT (*src, count, decl)
|
|
|
2061 {
|
|
|
2062 #ifndef OBJCPLUS
|
|
|
2063 tree purpose = build_int_cst (NULL_TREE, count);
|
|
|
2064 #else
|
|
|
2065 tree purpose = NULL_TREE;
|
|
|
2066 #endif
|
|
|
2067 expr = convert (objc_class_type, build_fold_addr_expr (decl));
|
|
|
2068 CONSTRUCTOR_APPEND_ELT (initlist, purpose, expr);
|
|
|
2069 }
|
|
|
2070 gcc_assert (count > 0);
|
|
|
2071 type = build_array_type (objc_class_type,
|
|
|
2072 build_index_type (build_int_cst (NULL_TREE, count - 1)));
|
|
|
2073 decl = start_var_decl (type, nam);
|
|
|
2074 /* The runtime wants this, even if it appears unused, so we must
|
|
|
2075 force the output. */
|
|
|
2076 DECL_PRESERVE_P (decl) = 1;
|
|
|
2077 expr = objc_build_constructor (type, initlist);
|
|
|
2078 OBJCMETA (decl, objc_meta, attr);
|
|
|
2079 finish_var_decl (decl, expr);
|
|
|
2080 }
|
|
|
2081
|
|
|
2082 /* Build decl = initializer; for each protocol referenced in
|
|
|
2083 @protocol(MyProt) expression. Refs as built in the entry section
|
|
|
2084 above. */
|
|
|
2085
|
|
|
2086 static void
|
|
|
2087 build_v2_protocol_list_translation_table (void)
|
|
|
2088 {
|
|
|
2089 int count;
|
|
|
2090 prot_list_entry *ref;
|
|
|
2091
|
|
|
2092 if (!protrefs)
|
|
|
2093 return;
|
|
|
2094
|
|
|
2095 FOR_EACH_VEC_ELT (*protrefs, count, ref)
|
|
|
2096 {
|
|
|
2097 char buf[BUFSIZE];
|
|
|
2098 tree expr;
|
|
|
2099 gcc_assert (TREE_CODE (ref->id) == PROTOCOL_INTERFACE_TYPE);
|
|
|
2100 snprintf (buf, BUFSIZE, "_OBJC_Protocol_%s",
|
|
|
2101 IDENTIFIER_POINTER (PROTOCOL_NAME (ref->id)));
|
|
|
2102 expr = start_var_decl (objc_v2_protocol_template, buf);
|
|
|
2103 expr = convert (objc_protocol_type, build_fold_addr_expr (expr));
|
|
|
2104 finish_var_decl (ref->refdecl, expr);
|
|
|
2105 }
|
|
|
2106 /* TODO: Maybe we could explicitly delete the vec. now? */
|
|
|
2107 }
|
|
|
2108
|
|
|
2109 static GTY (()) vec<prot_list_entry, va_gc> *protlist;
|
|
|
2110
|
|
|
2111 /* Add the local protocol meta-data declaration to the list which
|
|
|
2112 later on ends up in the __protocol_list section. */
|
|
|
2113
|
|
|
2114 static void
|
|
|
2115 objc_add_to_protocol_list (tree protocol_interface_decl, tree protocol_decl)
|
|
|
2116 {
|
|
|
2117 prot_list_entry e;
|
|
|
2118 if (!protlist)
|
|
|
2119 /* Arbitrary init count. */
|
|
|
2120 vec_alloc (protlist, 32);
|
|
|
2121 e.id = protocol_interface_decl;
|
|
|
2122 e.refdecl = protocol_decl;
|
|
|
2123 vec_safe_push (protlist, e);
|
|
|
2124 }
|
|
|
2125
|
|
|
2126 /* Build the __protocol_list section table containing address of all
|
|
|
2127 generate protocol_t meta-data. */
|
|
|
2128
|
|
|
2129 static void
|
|
|
2130 build_v2_protocol_list_address_table (void)
|
|
|
2131 {
|
|
|
2132 int count;
|
|
|
2133 prot_list_entry *ref;
|
|
|
2134 if (!vec_safe_length (protlist))
|
|
|
2135 return;
|
|
|
2136
|
|
|
2137 FOR_EACH_VEC_ELT (*protlist, count, ref)
|
|
|
2138 {
|
|
|
2139 tree decl, expr;
|
|
|
2140 char buf[BUFSIZE];
|
|
|
2141 gcc_assert (ref->id && TREE_CODE (ref->id) == PROTOCOL_INTERFACE_TYPE);
|
|
|
2142 snprintf (buf, BUFSIZE, "_OBJC_LabelProtocol_%s",
|
|
|
2143 IDENTIFIER_POINTER (PROTOCOL_NAME (ref->id)));
|
|
|
2144 decl = create_global_decl (objc_protocol_type, buf);
|
|
|
2145 expr = convert (objc_protocol_type, build_fold_addr_expr (ref->refdecl));
|
|
|
2146 OBJCMETA (decl, objc_meta, meta_label_protocollist);
|
|
|
2147 finish_var_decl (decl, expr);
|
|
|
2148 }
|
|
|
2149
|
|
|
2150 /* TODO: delete the vec. */
|
|
|
2151 /* TODO: upgrade to the clang/llvm hidden version. */
|
|
|
2152 }
|
|
|
2153
|
|
|
2154 /* This routine declares a variable to hold meta data for 'struct
|
|
|
2155 protocol_list_t'. */
|
|
|
2156
|
|
|
2157 static tree
|
|
|
2158 generate_v2_protocol_list (tree i_or_p, tree klass_ctxt)
|
|
|
2159 {
|
|
|
2160 tree refs_decl, lproto, e, plist, ptempl_p_t;
|
|
|
2161 int size = 0;
|
|
|
2162 vec<constructor_elt, va_gc> *initlist = NULL;
|
|
|
2163 char buf[BUFSIZE];
|
|
|
2164
|
|
|
2165 if (TREE_CODE (i_or_p) == CLASS_INTERFACE_TYPE
|
|
|
2166 || TREE_CODE (i_or_p) == CATEGORY_INTERFACE_TYPE)
|
|
|
2167 plist = CLASS_PROTOCOL_LIST (i_or_p);
|
|
|
2168 else if (TREE_CODE (i_or_p) == PROTOCOL_INTERFACE_TYPE)
|
|
|
2169 plist = PROTOCOL_LIST (i_or_p);
|
|
|
2170 else
|
|
|
2171 gcc_unreachable ();
|
|
|
2172
|
|
|
2173 /* Compute size. */
|
|
|
2174 for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
|
|
|
2175 if (TREE_CODE (TREE_VALUE (lproto)) == PROTOCOL_INTERFACE_TYPE
|
|
|
2176 && PROTOCOL_FORWARD_DECL (TREE_VALUE (lproto)))
|
|
|
2177 size++;
|
|
|
2178
|
|
|
2179 /* Build initializer. */
|
|
|
2180
|
|
|
2181 ptempl_p_t = build_pointer_type (objc_v2_protocol_template);
|
|
|
2182 e = build_int_cst (ptempl_p_t, size);
|
|
|
2183 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, e);
|
|
|
2184
|
|
|
2185 for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
|
|
|
2186 {
|
|
|
2187 tree pval = TREE_VALUE (lproto);
|
|
|
2188
|
|
|
2189 if (TREE_CODE (pval) == PROTOCOL_INTERFACE_TYPE
|
|
|
2190 && PROTOCOL_FORWARD_DECL (pval))
|
|
|
2191 {
|
|
|
2192 tree fwref = PROTOCOL_FORWARD_DECL (pval);
|
|
|
2193 location_t loc = DECL_SOURCE_LOCATION (fwref) ;
|
|
|
2194 e = build_unary_op (loc, ADDR_EXPR, fwref, 0);
|
|
|
2195 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, e);
|
|
|
2196 }
|
|
|
2197 }
|
|
|
2198
|
|
|
2199 /* static struct protocol_list_t *list[size]; */
|
|
|
2200
|
|
|
2201 switch (TREE_CODE (i_or_p))
|
|
|
2202 {
|
|
|
2203 case PROTOCOL_INTERFACE_TYPE:
|
|
|
2204 snprintf (buf, BUFSIZE, "_OBJC_ProtocolRefs_%s",
|
|
|
2205 IDENTIFIER_POINTER (PROTOCOL_NAME (i_or_p)));
|
|
|
2206 break;
|
|
|
2207 case CLASS_INTERFACE_TYPE:
|
|
|
2208 snprintf (buf, BUFSIZE, "_OBJC_ClassProtocols_%s",
|
|
|
2209 IDENTIFIER_POINTER (CLASS_NAME (i_or_p)));
|
|
|
2210 break;
|
|
|
2211 case CATEGORY_INTERFACE_TYPE:
|
|
|
2212 snprintf (buf, BUFSIZE, "_OBJC_CategoryProtocols_%s_%s",
|
|
|
2213 IDENTIFIER_POINTER (CLASS_NAME (klass_ctxt)),
|
|
|
2214 IDENTIFIER_POINTER (CLASS_SUPER_NAME (klass_ctxt)));
|
|
|
2215 break;
|
|
|
2216 default:
|
|
|
2217 gcc_unreachable ();
|
|
|
2218 }
|
|
|
2219
|
|
|
2220 refs_decl = start_var_decl (build_sized_array_type (ptempl_p_t, size+1),
|
|
|
2221 buf);
|
|
|
2222 /* ObjC2 puts all these in the base section. */
|
|
|
2223 OBJCMETA (refs_decl, objc_meta, meta_base);
|
|
|
2224 DECL_PRESERVE_P (refs_decl) = 1;
|
|
|
2225 finish_var_decl (refs_decl,
|
|
|
2226 objc_build_constructor (TREE_TYPE (refs_decl),initlist));
|
|
|
2227 return refs_decl;
|
|
|
2228 }
|
|
|
2229
|
|
|
2230 /* This routine builds one 'struct method_t' initializer list. Note
|
|
|
2231 that the old ABI is supposed to build 'struct objc_method' which
|
|
|
2232 has 3 fields, but it does not build the initialization expression
|
|
|
2233 for 'method_imp' which for protocols is NULL any way. To be
|
|
|
2234 consistent with declaration of 'struct method_t', in the new ABI we
|
|
|
2235 set the method_t.imp to NULL. */
|
|
|
2236
|
|
|
2237 static tree
|
|
|
2238 build_v2_descriptor_table_initializer (tree type, tree entries)
|
|
|
2239 {
|
|
|
2240 vec<constructor_elt, va_gc> *initlist = NULL;
|
|
|
2241 do
|
|
|
2242 {
|
|
|
2243 vec<constructor_elt, va_gc> *eltlist = NULL;
|
|
|
2244 CONSTRUCTOR_APPEND_ELT (eltlist, NULL_TREE,
|
|
|
2245 build_selector (METHOD_SEL_NAME (entries)));
|
|
|
2246 CONSTRUCTOR_APPEND_ELT (eltlist, NULL_TREE,
|
|
|
2247 add_objc_string (METHOD_ENCODING (entries),
|
|
|
2248 meth_var_types));
|
|
|
2249 CONSTRUCTOR_APPEND_ELT (eltlist, NULL_TREE, null_pointer_node);
|
|
|
2250
|
|
|
2251 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE,
|
|
|
2252 objc_build_constructor (type, eltlist));
|
|
|
2253 entries = TREE_CHAIN (entries);
|
|
|
2254 }
|
|
|
2255 while (entries);
|
|
|
2256
|
|
|
2257 return objc_build_constructor (build_array_type (type, 0), initlist);
|
|
|
2258 }
|
|
|
2259
|
|
|
2260 /* struct method_list_t
|
|
|
2261 {
|
|
|
2262 uint32_t entsize;
|
|
|
2263 uint32_t method_count;
|
|
|
2264 struct objc_method method_list[method_count];
|
|
|
2265 }; */
|
|
|
2266
|
|
|
2267 static tree
|
|
|
2268 build_v2_method_list_template (tree list_type, int size)
|
|
|
2269 {
|
|
|
2270 tree method_list_t_record;
|
|
|
2271 tree array_type, decls, *chain = NULL;
|
|
|
2272
|
|
|
2273 method_list_t_record = objc_start_struct (NULL_TREE);
|
|
|
2274
|
|
|
2275 /* uint32_t const entsize; */
|
|
|
2276 decls = add_field_decl (integer_type_node, "entsize", &chain);
|
|
|
2277
|
|
|
2278 /* int method_count; */
|
|
|
2279 add_field_decl (integer_type_node, "method_count", &chain);
|
|
|
2280
|
|
|
2281 /* struct objc_method method_list[]; */
|
|
|
2282 array_type = build_sized_array_type (list_type, size);
|
|
|
2283 add_field_decl (array_type, "method_list", &chain);
|
|
|
2284
|
|
|
2285 objc_finish_struct (method_list_t_record, decls);
|
|
|
2286 return method_list_t_record;
|
|
|
2287 }
|
|
|
2288
|
|
|
2289 /* Note, as above that we are building to the objc_method_template
|
|
|
2290 which has the *imp field. ABI0/1 build with
|
|
|
2291 objc_method_prototype_template which is missing this field. */
|
|
|
2292 static tree
|
|
|
2293 generate_v2_meth_descriptor_table (tree chain, tree protocol,
|
|
|
2294 const char *prefix, tree attr)
|
|
|
2295 {
|
|
|
2296 tree method_list_template, initlist, decl, methods;
|
|
|
2297 int size, entsize;
|
|
|
2298 vec<constructor_elt, va_gc> *v = NULL;
|
|
|
2299 char buf[BUFSIZE];
|
|
|
2300
|
|
|
2301 if (!chain || !prefix)
|
|
|
2302 return NULL_TREE;
|
|
|
2303
|
|
|
2304 methods = chain;
|
|
|
2305 size = 0;
|
|
|
2306 while (methods)
|
|
|
2307 {
|
|
|
2308 if (! METHOD_ENCODING (methods))
|
|
|
2309 METHOD_ENCODING (methods) = encode_method_prototype (methods);
|
|
|
2310 methods = TREE_CHAIN (methods);
|
|
|
2311 size++;
|
|
|
2312 }
|
|
|
2313
|
|
|
2314 gcc_assert (size);
|
|
|
2315 method_list_template = build_v2_method_list_template (objc_method_template,
|
|
|
2316 size);
|
|
|
2317 snprintf (buf, BUFSIZE, "%s_%s", prefix,
|
|
|
2318 IDENTIFIER_POINTER (PROTOCOL_NAME (protocol)));
|
|
|
2319
|
|
|
2320 decl = start_var_decl (method_list_template, buf);
|
|
|
2321
|
|
|
2322 entsize = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_method_template));
|
|
|
2323 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, entsize));
|
|
|
2324 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, size));
|
|
|
2325 initlist =
|
|
|
2326 build_v2_descriptor_table_initializer (objc_method_template,
|
|
|
2327 chain);
|
|
|
2328 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, initlist);
|
|
|
2329 /* Get into the right section. */
|
|
|
2330 OBJCMETA (decl, objc_meta, attr);
|
|
|
2331 finish_var_decl (decl, objc_build_constructor (method_list_template, v));
|
|
|
2332 return decl;
|
|
|
2333 }
|
|
|
2334
|
|
|
2335 /* This routine builds the initializer list to initialize the 'struct
|
|
|
2336 _prop_t prop_list[]' field of 'struct _prop_list_t' meta-data. */
|
|
|
2337
|
|
|
2338 static tree
|
|
|
2339 build_v2_property_table_initializer (tree type, tree context)
|
|
|
2340 {
|
|
|
2341 tree x;
|
|
|
2342 vec<constructor_elt, va_gc> *inits = NULL;
|
|
|
2343 if (TREE_CODE (context) == PROTOCOL_INTERFACE_TYPE)
|
|
|
2344 x = CLASS_PROPERTY_DECL (context);
|
|
|
2345 else
|
|
|
2346 x = IMPL_PROPERTY_DECL (context);
|
|
|
2347
|
|
|
2348 for (; x; x = TREE_CHAIN (x))
|
|
|
2349 {
|
|
|
2350 vec<constructor_elt, va_gc> *elemlist = NULL;
|
|
|
2351 /* NOTE! sections where property name/attribute go MUST change
|
|
|
2352 later. */
|
|
|
2353 tree attribute, name_ident = PROPERTY_NAME (x);
|
|
|
2354
|
|
|
2355 CONSTRUCTOR_APPEND_ELT (elemlist, NULL_TREE,
|
|
|
2356 add_objc_string (name_ident, prop_names_attr));
|
|
|
2357
|
|
|
2358 attribute = objc_v2_encode_prop_attr (x);
|
|
|
2359 CONSTRUCTOR_APPEND_ELT (elemlist, NULL_TREE,
|
|
|
2360 add_objc_string (attribute, prop_names_attr));
|
|
|
2361
|
|
|
2362 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
|
|
|
2363 objc_build_constructor (type, elemlist));
|
|
|
2364 }
|
|
|
2365
|
|
|
2366 return objc_build_constructor (build_array_type (type, 0),inits);
|
|
|
2367 }
|
|
|
2368
|
|
|
2369 /* This routine builds the following type:
|
|
|
2370 struct _prop_list_t
|
|
|
2371 {
|
|
|
2372 uint32_t entsize; // sizeof (struct _prop_t)
|
|
|
2373 uint32_t prop_count;
|
|
|
2374 struct _prop_t prop_list [prop_count];
|
|
|
2375 }
|
|
|
2376 */
|
|
|
2377
|
|
|
2378 static tree
|
|
|
2379 build_v2_property_list_template (tree list_type, int size)
|
|
|
2380 {
|
|
|
2381 tree property_list_t_record;
|
|
|
2382 tree array_type, decls, *chain = NULL;
|
|
|
2383
|
|
|
2384 /* anonymous. */
|
|
|
2385 property_list_t_record = objc_start_struct (NULL_TREE);
|
|
|
2386
|
|
|
2387 /* uint32_t const entsize; */
|
|
|
2388 decls = add_field_decl (integer_type_node, "entsize", &chain);
|
|
|
2389
|
|
|
2390 /* int prop_count; */
|
|
|
2391 add_field_decl (integer_type_node, "prop_count", &chain);
|
|
|
2392
|
|
|
2393 /* struct _prop_t prop_list[]; */
|
|
|
2394 array_type = build_sized_array_type (list_type, size);
|
|
|
2395 add_field_decl (array_type, "prop_list", &chain);
|
|
|
2396
|
|
|
2397 objc_finish_struct (property_list_t_record, decls);
|
|
|
2398 return property_list_t_record;
|
|
|
2399 }
|
|
|
2400
|
|
|
2401 /* Top-level routine to generate property tables for each
|
|
|
2402 implementation. */
|
|
|
2403
|
|
|
2404 static tree
|
|
|
2405 generate_v2_property_table (tree context, tree klass_ctxt)
|
|
|
2406 {
|
|
|
2407 tree x, decl, initlist, property_list_template;
|
|
|
2408 bool is_proto = false;
|
|
|
2409 vec<constructor_elt, va_gc> *inits = NULL;
|
|
|
2410 int init_val, size = 0;
|
|
|
2411 char buf[BUFSIZE];
|
|
|
2412
|
|
|
2413 if (context)
|
|
|
2414 {
|
|
|
2415 gcc_assert (TREE_CODE (context) == PROTOCOL_INTERFACE_TYPE);
|
|
|
2416 x = CLASS_PROPERTY_DECL (context);
|
|
|
2417 is_proto = true;
|
|
|
2418 }
|
|
|
2419 else
|
|
|
2420 x = IMPL_PROPERTY_DECL (klass_ctxt);
|
|
|
2421
|
|
|
2422 for (; x; x = TREE_CHAIN (x))
|
|
|
2423 size++;
|
|
|
2424
|
|
|
2425 if (size == 0)
|
|
|
2426 return NULL_TREE;
|
|
|
2427
|
|
|
2428 property_list_template =
|
|
|
2429 build_v2_property_list_template (objc_v2_property_template,
|
|
|
2430 size);
|
|
|
2431
|
|
|
2432 initlist = build_v2_property_table_initializer (objc_v2_property_template,
|
|
|
2433 is_proto ? context
|
|
|
2434 : klass_ctxt);
|
|
|
2435
|
|
|
2436 init_val = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_property_template));
|
|
|
2437 if (is_proto)
|
|
|
2438 snprintf (buf, BUFSIZE, "_OBJC_ProtocolPropList_%s",
|
|
|
2439 IDENTIFIER_POINTER (PROTOCOL_NAME (context)));
|
|
|
2440 else
|
|
|
2441 snprintf (buf, BUFSIZE, "_OBJC_ClassPropList_%s",
|
|
|
2442 IDENTIFIER_POINTER (CLASS_NAME (klass_ctxt)));
|
|
|
2443
|
|
|
2444 decl = start_var_decl (property_list_template, buf);
|
|
|
2445
|
|
|
2446 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
|
|
|
2447 build_int_cst (NULL_TREE, init_val));
|
|
|
2448 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
|
|
|
2449 build_int_cst (NULL_TREE, size));
|
|
|
2450 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, initlist);
|
|
|
2451
|
|
|
2452 OBJCMETA (decl, objc_meta, meta_base);
|
|
|
2453 finish_var_decl (decl, objc_build_constructor (TREE_TYPE (decl), inits));
|
|
|
2454 return decl;
|
|
|
2455 }
|
|
|
2456
|
|
|
2457 static tree
|
|
|
2458 build_v2_protocol_initializer (tree type, tree protocol_name, tree protocol_list,
|
|
|
2459 tree inst_methods, tree class_methods,
|
|
|
2460 tree opt_ins_meth, tree opt_cls_meth,
|
|
|
2461 tree property_list)
|
|
|
2462 {
|
|
|
2463 tree expr, ttyp;
|
|
|
2464 location_t loc;
|
|
|
2465 vec<constructor_elt, va_gc> *inits = NULL;
|
|
|
2466
|
|
|
2467 /* TODO: find a better representation of location from the inputs. */
|
|
|
2468 loc = UNKNOWN_LOCATION;
|
|
|
2469
|
|
|
2470 /* This is NULL for the new ABI. */
|
|
|
2471 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
|
|
|
2472 convert (objc_object_type, null_pointer_node));
|
|
|
2473
|
|
|
2474 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, protocol_name);
|
|
|
2475 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, protocol_list);
|
|
|
2476
|
|
|
2477 ttyp = objc_method_proto_list_ptr;
|
|
|
2478 if (inst_methods)
|
|
|
2479 expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, inst_methods, 0));
|
|
|
2480 else
|
|
|
2481 expr = convert (ttyp, null_pointer_node);
|
|
|
2482 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
|
|
|
2483
|
|
|
2484 if (class_methods)
|
|
|
2485 expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, class_methods, 0));
|
|
|
2486 else
|
|
|
2487 expr = convert (ttyp, null_pointer_node);
|
|
|
2488 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
|
|
|
2489
|
|
|
2490 if (opt_ins_meth)
|
|
|
2491 expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, opt_ins_meth, 0));
|
|
|
2492 else
|
|
|
2493 expr = convert (ttyp, null_pointer_node);
|
|
|
2494 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
|
|
|
2495
|
|
|
2496 if (opt_cls_meth)
|
|
|
2497 expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, opt_cls_meth, 0));
|
|
|
2498 else
|
|
|
2499 expr = convert (ttyp, null_pointer_node);
|
|
|
2500 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
|
|
|
2501
|
|
|
2502 ttyp = objc_prop_list_ptr;
|
|
|
2503 if (property_list)
|
|
|
2504 expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, property_list, 0));
|
|
|
2505 else
|
|
|
2506 expr = convert (ttyp, null_pointer_node);
|
|
|
2507 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
|
|
|
2508
|
|
|
2509 /* const uint32_t size; = sizeof(struct protocol_t) */
|
|
|
2510 expr = build_int_cst (integer_type_node,
|
|
|
2511 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_protocol_template)));
|
|
|
2512 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
|
|
|
2513 /* const uint32_t flags; = 0 */
|
|
|
2514 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, integer_zero_node);
|
|
|
2515
|
|
|
2516 return objc_build_constructor (type, inits);
|
|
|
2517 }
|
|
|
2518
|
|
|
2519 /* Main routine to build all meta data for all protocols used in a
|
|
|
2520 translation unit. */
|
|
|
2521
|
|
|
2522 static void
|
|
|
2523 generate_v2_protocols (void)
|
|
|
2524 {
|
|
|
2525 tree p ;
|
|
|
2526 bool some = false;
|
|
|
2527
|
|
|
2528 if (!protocol_chain)
|
|
|
2529 return ;
|
|
|
2530
|
|
|
2531 /* If a protocol was directly referenced, pull in indirect
|
|
|
2532 references. */
|
|
|
2533 for (p = protocol_chain; p; p = TREE_CHAIN (p))
|
|
|
2534 if (PROTOCOL_FORWARD_DECL (p) && PROTOCOL_LIST (p))
|
|
|
2535 generate_protocol_references (PROTOCOL_LIST (p));
|
|
|
2536
|
|
|
2537 for (p = protocol_chain; p; p = TREE_CHAIN (p))
|
|
|
2538 {
|
|
|
2539 location_t loc;
|
|
|
2540 tree inst_meth, class_meth, opt_inst_meth, opt_class_meth, props;
|
|
|
2541 tree decl, initlist, protocol_name_expr, refs_decl, refs_expr;
|
|
|
2542
|
|
|
2543 /* If protocol wasn't referenced, don't generate any code. */
|
|
|
2544 decl = PROTOCOL_FORWARD_DECL (p);
|
|
|
2545
|
|
|
2546 if (!decl)
|
|
|
2547 continue;
|
|
|
2548
|
|
|
2549 loc = DECL_SOURCE_LOCATION (decl);
|
|
|
2550 some = true;
|
|
|
2551
|
|
|
2552 inst_meth =
|
|
|
2553 generate_v2_meth_descriptor_table (PROTOCOL_NST_METHODS (p), p,
|
|
|
2554 "_OBJC_ProtocolInstanceMethods",
|
|
|
2555 meta_proto_nst_meth);
|
|
|
2556
|
|
|
2557 class_meth =
|
|
|
2558 generate_v2_meth_descriptor_table (PROTOCOL_CLS_METHODS (p), p,
|
|
|
2559 "_OBJC_ProtocolClassMethods",
|
|
|
2560 meta_proto_cls_meth);
|
|
|
2561
|
|
|
2562 opt_inst_meth =
|
|
|
2563 generate_v2_meth_descriptor_table (PROTOCOL_OPTIONAL_NST_METHODS (p), p,
|
|
|
2564 "_OBJC_OptProtocolInstMethods",
|
|
|
2565 meta_proto_nst_meth);
|
|
|
2566
|
|
|
2567 opt_class_meth =
|
|
|
2568 generate_v2_meth_descriptor_table (PROTOCOL_OPTIONAL_CLS_METHODS (p), p,
|
|
|
2569 "_OBJC_OptProtocolClassMethods",
|
|
|
2570 meta_proto_cls_meth);
|
|
|
2571
|
|
|
2572 if (PROTOCOL_LIST (p))
|
|
|
2573 refs_decl = generate_v2_protocol_list (p, NULL_TREE);
|
|
|
2574 else
|
|
|
2575 refs_decl = 0;
|
|
|
2576
|
|
|
2577 /* static struct objc_protocol _OBJC_Protocol_<mumble>; */
|
|
|
2578 protocol_name_expr = add_objc_string (PROTOCOL_NAME (p), class_names);
|
|
|
2579
|
|
|
2580 if (refs_decl)
|
|
|
2581 refs_expr = convert (build_pointer_type (objc_v2_protocol_template),
|
|
|
2582 build_unary_op (loc, ADDR_EXPR, refs_decl, 0));
|
|
|
2583 else
|
|
|
2584 refs_expr = build_int_cst (NULL_TREE, 0);
|
|
|
2585
|
|
|
2586 props = generate_v2_property_table (p, NULL_TREE);
|
|
|
2587
|
|
|
2588 initlist = build_v2_protocol_initializer (TREE_TYPE (decl),
|
|
|
2589 protocol_name_expr, refs_expr,
|
|
|
2590 inst_meth, class_meth,
|
|
|
2591 opt_inst_meth, opt_class_meth,
|
|
|
2592 props);
|
|
|
2593 finish_var_decl (decl, initlist);
|
|
|
2594 objc_add_to_protocol_list (p, decl);
|
|
|
2595 }
|
|
|
2596
|
|
|
2597 if (some)
|
|
|
2598 {
|
|
|
2599 /* Make sure we get the Protocol class linked in - reference
|
|
|
2600 it... */
|
|
|
2601 p = objc_v2_get_class_reference (get_identifier (PROTOCOL_OBJECT_CLASS_NAME));
|
|
|
2602 /* ... but since we don't specifically use the reference... we
|
|
|
2603 need to force it. */
|
|
|
2604 DECL_PRESERVE_P (p) = 1;
|
|
|
2605 }
|
|
|
2606 }
|
|
|
2607
|
|
|
2608 static tree
|
|
|
2609 generate_v2_dispatch_table (tree chain, const char *name, tree attr)
|
|
|
2610 {
|
|
|
2611 tree decl, method_list_template, initlist;
|
|
|
2612 vec<constructor_elt, va_gc> *v = NULL;
|
|
|
2613 int size, init_val;
|
|
|
2614
|
|
|
2615 if (!chain || !name || !(size = list_length (chain)))
|
|
|
2616 return NULL_TREE;
|
|
|
2617
|
|
|
2618 method_list_template
|
|
|
2619 = build_v2_method_list_template (objc_method_template, size);
|
|
|
2620 initlist
|
|
|
2621 = build_dispatch_table_initializer (objc_method_template, chain);
|
|
|
2622
|
|
|
2623 decl = start_var_decl (method_list_template, name);
|
|
|
2624
|
|
|
2625 init_val = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_method_template));
|
|
|
2626 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
|
|
|
2627 build_int_cst (integer_type_node, init_val));
|
|
|
2628 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
|
|
|
2629 build_int_cst (integer_type_node, size));
|
|
|
2630 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, initlist);
|
|
|
2631
|
|
|
2632 OBJCMETA (decl, objc_meta, attr);
|
|
|
2633 finish_var_decl (decl,
|
|
|
2634 objc_build_constructor (TREE_TYPE (decl), v));
|
|
|
2635 return decl;
|
|
|
2636 }
|
|
|
2637
|
|
|
2638 /* Init a category. */
|
|
|
2639 static tree
|
|
|
2640 build_v2_category_initializer (tree type, tree cat_name, tree class_name,
|
|
|
2641 tree inst_methods, tree class_methods,
|
|
|
2642 tree protocol_list, tree property_list,
|
|
|
2643 location_t loc)
|
|
|
2644 {
|
|
|
2645 tree expr, ltyp;
|
|
|
2646 vec<constructor_elt, va_gc> *v = NULL;
|
|
|
2647
|
|
|
2648 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, cat_name);
|
|
|
2649 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, class_name);
|
|
|
2650
|
|
|
2651 ltyp = objc_method_list_ptr;
|
|
|
2652 if (inst_methods)
|
|
|
2653 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, inst_methods, 0));
|
|
|
2654 else
|
|
|
2655 expr = convert (ltyp, null_pointer_node);
|
|
|
2656 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
|
|
|
2657
|
|
|
2658 if (class_methods)
|
|
|
2659 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, class_methods, 0));
|
|
|
2660 else
|
|
|
2661 expr = convert (ltyp, null_pointer_node);
|
|
|
2662 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
|
|
|
2663
|
|
|
2664 /* protocol_list = */
|
|
|
2665 ltyp = build_pointer_type (objc_v2_protocol_template);
|
|
|
2666 if (protocol_list)
|
|
|
2667 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, protocol_list, 0));
|
|
|
2668 else
|
|
|
2669 expr = convert (ltyp, null_pointer_node);
|
|
|
2670 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
|
|
|
2671
|
|
|
2672 ltyp = objc_prop_list_ptr;
|
|
|
2673 if (property_list)
|
|
|
2674 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, property_list, 0));
|
|
|
2675 else
|
|
|
2676 expr = convert (ltyp, null_pointer_node);
|
|
|
2677 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
|
|
|
2678
|
|
|
2679 return objc_build_constructor (type, v);
|
|
|
2680 }
|
|
|
2681
|
|
|
2682 /* static struct category_t _OBJC_CATEGORY_$_<name> = { ... }; */
|
|
|
2683
|
|
|
2684 static void
|
|
|
2685 generate_v2_category (struct imp_entry *impent)
|
|
|
2686 {
|
|
|
2687 tree initlist, cat_name_expr, class_name_expr;
|
|
|
2688 tree protocol_decl, category, props, t;
|
|
|
2689 tree inst_methods = NULL_TREE, class_methods = NULL_TREE;
|
|
|
2690 tree cat = impent->imp_context;
|
|
|
2691 tree cat_decl = impent->class_decl;
|
|
|
2692 location_t loc;
|
|
|
2693 char buf[BUFSIZE];
|
|
|
2694
|
|
|
2695 loc = DECL_SOURCE_LOCATION (cat_decl);
|
|
|
2696
|
|
|
2697 /* ??? not sure this is really necessary, the following references should
|
|
|
2698 force appropriate linkage linkage...
|
|
|
2699 -- but ... ensure a reference to the class... */
|
|
|
2700 t = objc_v2_get_class_reference (CLASS_NAME (cat));
|
|
|
2701 /* ... which we ignore so force it out.. */
|
|
|
2702 DECL_PRESERVE_P (t) = 1;
|
|
|
2703
|
|
|
2704 snprintf (buf, BUFSIZE, "OBJC_CLASS_$_%s", IDENTIFIER_POINTER (CLASS_NAME (cat)));
|
|
|
2705 class_name_expr = create_extern_decl (objc_v2_class_template, buf);
|
|
|
2706 class_name_expr = build_fold_addr_expr (class_name_expr);
|
|
|
2707
|
|
|
2708 cat_name_expr = add_objc_string (CLASS_SUPER_NAME (cat), class_names);
|
|
|
2709 category = lookup_category (impent->imp_template, CLASS_SUPER_NAME (cat));
|
|
|
2710
|
|
|
2711 if (category && CLASS_PROTOCOL_LIST (category))
|
|
|
2712 {
|
|
|
2713 generate_protocol_references (CLASS_PROTOCOL_LIST (category));
|
|
|
2714 protocol_decl = generate_v2_protocol_list (category, cat);
|
|
|
2715 }
|
|
|
2716 else
|
|
|
2717 protocol_decl = NULL_TREE;
|
|
|
2718
|
|
|
2719 /* decl = update_var_decl(impent->class_decl); */
|
|
|
2720
|
|
|
2721 props = generate_v2_property_table (NULL_TREE, cat);
|
|
|
2722
|
|
|
2723 if (CLASS_NST_METHODS (cat))
|
|
|
2724 {
|
|
|
2725 snprintf (buf, BUFSIZE, "_OBJC_CategoryInstanceMethods_%s_%s",
|
|
|
2726 IDENTIFIER_POINTER (CLASS_NAME (cat)),
|
|
|
2727 IDENTIFIER_POINTER (CLASS_SUPER_NAME (cat)));
|
|
|
2728 inst_methods = generate_v2_dispatch_table (CLASS_NST_METHODS (cat), buf,
|
|
|
2729 meta_cati_meth);
|
|
|
2730 }
|
|
|
2731
|
|
|
2732 if (CLASS_CLS_METHODS (cat))
|
|
|
2733 {
|
|
|
2734 snprintf (buf, BUFSIZE, "_OBJC_CategoryClassMethods_%s_%s",
|
|
|
2735 IDENTIFIER_POINTER (CLASS_NAME (cat)),
|
|
|
2736 IDENTIFIER_POINTER (CLASS_SUPER_NAME (cat)));
|
|
|
2737 class_methods = generate_v2_dispatch_table (CLASS_CLS_METHODS (cat), buf,
|
|
|
2738 meta_catc_meth);
|
|
|
2739 }
|
|
|
2740
|
|
|
2741 initlist = build_v2_category_initializer (TREE_TYPE (cat_decl),
|
|
|
2742 cat_name_expr, class_name_expr,
|
|
|
2743 inst_methods, class_methods,
|
|
|
2744 protocol_decl, props, loc);
|
|
|
2745
|
|
|
2746 finish_var_decl (cat_decl, initlist);
|
|
|
2747 impent->class_decl = cat_decl;
|
|
|
2748
|
|
|
2749 /* Add to list of pointers in __category_list section. */
|
|
|
2750 objc_v2_add_to_category_list (cat_decl);
|
|
|
2751 if (has_load_impl (CLASS_CLS_METHODS (impent->imp_context)))
|
|
|
2752 objc_v2_add_to_nonlazy_category_list (cat_decl);
|
|
|
2753 }
|
|
|
2754
|
|
|
2755 /* This routine declares a variable to hold the offset for ivar
|
|
|
2756 FIELD_DECL. Variable name is .objc_ivar.ClassName.IvarName. */
|
|
|
2757
|
|
|
2758 struct GTY(()) ivarref_entry
|
|
|
2759 {
|
|
|
2760 tree decl;
|
|
|
2761 tree offset;
|
|
|
2762 };
|
|
|
2763
|
|
|
2764 static GTY (()) vec<ivarref_entry, va_gc> *ivar_offset_refs;
|
|
|
2765
|
|
|
2766 static tree
|
|
|
2767 ivar_offset_ref (tree class_name, tree field_decl)
|
|
|
2768 {
|
|
|
2769 tree decl, field_decl_id;
|
|
|
2770 ivarref_entry e;
|
|
|
2771 bool global_var;
|
|
|
2772 char buf[512];
|
|
|
2773
|
|
|
2774 create_ivar_offset_name (buf, class_name, field_decl);
|
|
|
2775 field_decl_id = get_identifier (buf);
|
|
|
2776
|
|
|
2777 if (ivar_offset_refs)
|
|
|
2778 {
|
|
|
2779 int count;
|
|
|
2780 ivarref_entry *ref;
|
|
|
2781 FOR_EACH_VEC_ELT (*ivar_offset_refs, count, ref)
|
|
|
2782 if (DECL_NAME (ref->decl) == field_decl_id)
|
|
|
2783 return ref->decl;
|
|
|
2784 }
|
|
|
2785 else
|
|
|
2786 /* Somewhat arbitrary initial provision. */
|
|
|
2787 vec_alloc (ivar_offset_refs, 32);
|
|
|
2788
|
|
|
2789 /* We come here if we don't find a match or at the start. */
|
|
|
2790 global_var = (TREE_PUBLIC (field_decl) || TREE_PROTECTED (field_decl));
|
|
|
2791 if (global_var)
|
|
|
2792 decl = create_global_decl (TREE_TYPE (size_zero_node), buf);
|
|
|
2793 else
|
|
|
2794 decl = create_hidden_decl (TREE_TYPE (size_zero_node), buf);
|
|
|
2795
|
|
|
2796 /* Make sure it ends up in an ObjC section. */
|
|
|
2797 OBJCMETA (decl, objc_meta, meta_base);
|
|
|
2798
|
|
|
2799 e.decl = decl;
|
|
|
2800 e.offset = byte_position (field_decl);
|
|
|
2801 vec_safe_push (ivar_offset_refs, e);
|
|
|
2802 return decl;
|
|
|
2803 }
|
|
|
2804
|
|
|
2805 /* This routine builds initializer-list needed to initialize 'struct
|
|
|
2806 ivar_t list[count] of 'struct ivar_list_t' meta data. TYPE is
|
|
|
2807 'struct ivar_t' and FIELD_DECL is list of ivars for the target
|
|
|
2808 class. */
|
|
|
2809
|
|
|
2810 static tree
|
|
|
2811 build_v2_ivar_list_initializer (tree class_name, tree type, tree field_decl)
|
|
|
2812 {
|
|
|
2813 vec<constructor_elt, va_gc> *inits = NULL;
|
|
|
2814
|
|
|
2815 do
|
|
|
2816 {
|
|
|
2817 vec<constructor_elt, va_gc> *ivar = NULL;
|
|
|
2818 int val;
|
|
|
2819 tree id;
|
|
|
2820
|
|
|
2821 /* Unnamed bitfields are ignored. */
|
|
|
2822 if (!DECL_NAME (field_decl))
|
|
|
2823 {
|
|
|
2824 field_decl = DECL_CHAIN (field_decl);
|
|
|
2825 continue;
|
|
|
2826 }
|
|
|
2827
|
|
|
2828 /* Set offset. */
|
|
|
2829 CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE,
|
|
|
2830 build_unary_op (input_location,
|
|
|
2831 ADDR_EXPR,
|
|
|
2832 ivar_offset_ref (class_name,
|
|
|
2833 field_decl), 0));
|
|
|
2834
|
|
|
2835 /* Set name. */
|
|
|
2836 CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE,
|
|
|
2837 add_objc_string (DECL_NAME (field_decl),
|
|
|
2838 meth_var_names));
|
|
|
2839
|
|
|
2840 /* Set type. */
|
|
|
2841 id = add_objc_string (encode_field_decl (field_decl),
|
|
|
2842 meth_var_types);
|
|
|
2843 CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, id);
|
|
|
2844
|
|
|
2845 /* Set alignment. */
|
|
|
2846 val = DECL_ALIGN_UNIT (field_decl);
|
|
|
2847 val = exact_log2 (val);
|
|
|
2848 CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE,
|
|
|
2849 build_int_cst (integer_type_node, val));
|
|
|
2850
|
|
|
2851 /* Set size. */
|
|
|
2852 val = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field_decl));
|
|
|
2853 CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE,
|
|
|
2854 build_int_cst (integer_type_node, val));
|
|
|
2855
|
|
|
2856 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
|
|
|
2857 objc_build_constructor (type, ivar));
|
|
|
2858
|
|
|
2859 do
|
|
|
2860 field_decl = DECL_CHAIN (field_decl);
|
|
|
2861 while (field_decl && TREE_CODE (field_decl) != FIELD_DECL);
|
|
|
2862 }
|
|
|
2863 while (field_decl);
|
|
|
2864
|
|
|
2865 return objc_build_constructor (build_array_type (type, 0), inits);
|
|
|
2866 }
|
|
|
2867
|
|
|
2868 /*
|
|
|
2869 struct ivar_list_t
|
|
|
2870 {
|
|
|
2871 uint32 entsize;
|
|
|
2872 uint32 count;
|
|
|
2873 struct iver_t list[count];
|
|
|
2874 };
|
|
|
2875 */
|
|
|
2876
|
|
|
2877 static tree
|
|
|
2878 build_v2_ivar_list_t_template (tree list_type, int size)
|
|
|
2879 {
|
|
|
2880 tree objc_ivar_list_record;
|
|
|
2881 tree decls, *chain = NULL;
|
|
|
2882
|
|
|
2883 /* Anonymous. */
|
|
|
2884 objc_ivar_list_record = objc_start_struct (NULL_TREE);
|
|
|
2885
|
|
|
2886 /* uint32 entsize; */
|
|
|
2887 decls = add_field_decl (integer_type_node, "entsize", &chain);
|
|
|
2888
|
|
|
2889 /* uint32 count; */
|
|
|
2890 add_field_decl (integer_type_node, "count", &chain);
|
|
|
2891
|
|
|
2892 /* struct objc_ivar ivar_list[]; */
|
|
|
2893 add_field_decl (build_sized_array_type (list_type, size),
|
|
|
2894 "list", &chain);
|
|
|
2895
|
|
|
2896 objc_finish_struct (objc_ivar_list_record, decls);
|
|
|
2897 return objc_ivar_list_record;
|
|
|
2898 }
|
|
|
2899
|
|
|
2900 /* This routine declares a static variable of type 'struct
|
|
|
2901 ivar_list_t' and initializes it. chain is the source of the data,
|
|
|
2902 name is the name for the var. attr is the meta-data section tag
|
|
|
2903 attribute. templ is the implementation template for the class. */
|
|
|
2904
|
|
|
2905 static tree
|
|
|
2906 generate_v2_ivars_list (tree chain, const char *name, tree attr, tree templ)
|
|
|
2907 {
|
|
|
2908 tree decl, initlist, ivar_list_template;
|
|
|
2909 vec<constructor_elt, va_gc> *inits = NULL;
|
|
|
2910 int size, ivar_t_size;
|
|
|
2911
|
|
|
2912 if (!chain || !name || !(size = ivar_list_length (chain)))
|
|
|
2913 return NULL_TREE;
|
|
|
2914
|
|
|
2915 generating_instance_variables = 1;
|
|
|
2916 ivar_list_template = build_v2_ivar_list_t_template (objc_v2_ivar_template,
|
|
|
2917 size);
|
|
|
2918
|
|
|
2919 initlist = build_v2_ivar_list_initializer (CLASS_NAME (templ),
|
|
|
2920 objc_v2_ivar_template, chain);
|
|
|
2921 ivar_t_size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_ivar_template));
|
|
|
2922
|
|
|
2923 decl = start_var_decl (ivar_list_template, name);
|
|
|
2924 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
|
|
|
2925 build_int_cst (integer_type_node, ivar_t_size));
|
|
|
2926 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
|
|
|
2927 build_int_cst (integer_type_node, size));
|
|
|
2928 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, initlist);
|
|
|
2929 OBJCMETA (decl, objc_meta, attr);
|
|
|
2930 finish_var_decl (decl, objc_build_constructor (TREE_TYPE (decl), inits));
|
|
|
2931 generating_instance_variables = 0;
|
|
|
2932 return decl;
|
|
|
2933 }
|
|
|
2934
|
|
|
2935 /* Routine to build initializer list to initialize objects of type
|
|
|
2936 struct class_t; */
|
|
|
2937
|
|
|
2938 static tree
|
|
|
2939 build_v2_class_t_initializer (tree type, tree isa, tree superclass,
|
|
|
2940 tree ro, tree cache, tree vtable)
|
|
|
2941 {
|
|
|
2942 vec<constructor_elt, va_gc> *initlist = NULL;
|
|
|
2943
|
|
|
2944 /* isa */
|
|
|
2945 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, isa);
|
|
|
2946
|
|
|
2947 /* superclass */
|
|
|
2948 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, superclass);
|
|
|
2949
|
|
|
2950 /* cache */
|
|
|
2951 if (cache)
|
|
|
2952 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, cache);
|
|
|
2953 else
|
|
|
2954 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, null_pointer_node);
|
|
|
2955
|
|
|
2956 /* vtable */
|
|
|
2957 if (vtable)
|
|
|
2958 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, vtable);
|
|
|
2959 else
|
|
|
2960 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, null_pointer_node);
|
|
|
2961
|
|
|
2962 /* ro */
|
|
|
2963 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, ro);
|
|
|
2964
|
|
|
2965 return objc_build_constructor (type, initlist);
|
|
|
2966 }
|
|
|
2967
|
|
|
2968 /* Routine to build object of struct class_ro_t { ... }; */
|
|
|
2969
|
|
|
2970 static tree
|
|
|
2971 build_v2_class_ro_t_initializer (tree type, tree name,
|
|
|
2972 unsigned int flags, unsigned int instanceStart,
|
|
|
2973 unsigned int instanceSize,
|
|
|
2974 tree ivarLayout,
|
|
|
2975 tree baseMethods, tree baseProtocols,
|
|
|
2976 tree ivars, tree property_list)
|
|
|
2977 {
|
|
|
2978 tree expr, unsigned_char_star, ltyp;
|
|
|
2979 location_t loc;
|
|
|
2980 vec<constructor_elt, va_gc> *initlist = NULL;
|
|
|
2981
|
|
|
2982 /* TODO: fish out the real location from somewhere. */
|
|
|
2983 loc = UNKNOWN_LOCATION;
|
|
|
2984
|
|
|
2985 /* flags */
|
|
|
2986 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE,
|
|
|
2987 build_int_cst (integer_type_node, flags));
|
|
|
2988
|
|
|
2989 /* instanceStart */
|
|
|
2990 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE,
|
|
|
2991 build_int_cst (integer_type_node, instanceStart));
|
|
|
2992
|
|
|
2993 /* instanceSize */
|
|
|
2994 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE,
|
|
|
2995 build_int_cst (integer_type_node, instanceSize));
|
|
|
2996
|
|
|
2997 /* This ABI is currently only used on m64 NeXT. We always
|
|
|
2998 explicitly declare the alignment padding. */
|
|
|
2999 /* reserved, pads alignment. */
|
|
|
3000 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE,
|
|
|
3001 build_int_cst (integer_type_node, 0));
|
|
|
3002
|
|
|
3003 /* ivarLayout */
|
|
|
3004 unsigned_char_star = build_pointer_type (unsigned_char_type_node);
|
|
|
3005 if (ivarLayout)
|
|
|
3006 expr = ivarLayout;
|
|
|
3007 else
|
|
|
3008 expr = convert (unsigned_char_star, null_pointer_node);
|
|
|
3009 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, expr);
|
|
|
3010
|
|
|
3011 /* name */
|
|
|
3012 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, default_conversion (name));
|
|
|
3013
|
|
|
3014 /* baseMethods */
|
|
|
3015 ltyp = objc_method_list_ptr;
|
|
|
3016 if (baseMethods)
|
|
|
3017 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, baseMethods, 0));
|
|
|
3018 else
|
|
|
3019 expr = convert (ltyp, null_pointer_node);
|
|
|
3020 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, expr);
|
|
|
3021
|
|
|
3022 /* baseProtocols */
|
|
|
3023 ltyp = build_pointer_type (xref_tag (RECORD_TYPE,
|
|
|
3024 get_identifier (UTAG_V2_PROTOCOL_LIST)));
|
|
|
3025 if (baseProtocols)
|
|
|
3026 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, baseProtocols, 0));
|
|
|
3027 else
|
|
|
3028 expr = convert (ltyp, null_pointer_node);
|
|
|
3029 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, expr);
|
|
|
3030
|
|
|
3031 /* ivars */
|
|
|
3032 ltyp = objc_v2_ivar_list_ptr;
|
|
|
3033 if (ivars)
|
|
|
3034 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, ivars, 0));
|
|
|
3035 else
|
|
|
3036 expr = convert (ltyp, null_pointer_node);
|
|
|
3037 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, expr);
|
|
|
3038
|
|
|
3039 /* TODO: We don't yet have the weak/strong stuff... */
|
|
|
3040 /* weakIvarLayout */
|
|
|
3041 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE,
|
|
|
3042 convert (unsigned_char_star, null_pointer_node));
|
|
|
3043
|
|
|
3044 /* property list */
|
|
|
3045 ltyp = objc_prop_list_ptr;
|
|
|
3046 if (property_list)
|
|
|
3047 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, property_list, 0));
|
|
|
3048 else
|
|
|
3049 expr = convert (ltyp, null_pointer_node);
|
|
|
3050 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, expr);
|
|
|
3051 return objc_build_constructor (type, initlist);
|
|
|
3052 }
|
|
|
3053
|
|
|
3054 static GTY (()) vec<ident_data_tuple, va_gc> *ehtype_list;
|
|
|
3055
|
|
|
3056 /* Record a name as needing a catcher. */
|
|
|
3057 static void
|
|
|
3058 objc_v2_add_to_ehtype_list (tree name)
|
|
|
3059 {
|
|
|
3060 ident_data_tuple e;
|
|
|
3061 if (ehtype_list)
|
|
|
3062 {
|
|
|
3063 int count = 0;
|
|
|
3064 ident_data_tuple *ref;
|
|
|
3065
|
|
|
3066 FOR_EACH_VEC_ELT (*ehtype_list, count, ref)
|
|
|
3067 if (ref->ident == name)
|
|
|
3068 return; /* Already entered. */
|
|
|
3069 }
|
|
|
3070 else
|
|
|
3071 /* Arbitrary initial count. */
|
|
|
3072 vec_alloc (ehtype_list, 8);
|
|
|
3073
|
|
|
3074 /* Not found, or new list. */
|
|
|
3075 e.ident = name;
|
|
|
3076 e.data = NULL_TREE;
|
|
|
3077 vec_safe_push (ehtype_list, e);
|
|
|
3078 }
|
|
|
3079
|
|
|
3080 static void
|
|
|
3081 generate_v2_class_structs (struct imp_entry *impent)
|
|
|
3082 {
|
|
|
3083 tree decl, name_expr, initlist, protocol_decl, metaclass_decl, class_decl;
|
|
|
3084 tree field, firstIvar, chain;
|
|
|
3085 tree class_superclass_expr, metaclass_superclass_expr, props;
|
|
|
3086 /* TODO: figure out how to compute this. */
|
|
|
3087 tree ivarLayout = NULL_TREE;
|
|
|
3088 tree my_super_id = NULL_TREE, root_expr = NULL_TREE;
|
|
|
3089 tree inst_methods = NULL_TREE, class_methods = NULL_TREE;
|
|
|
3090 tree inst_ivars = NULL_TREE, class_ivars = NULL_TREE;
|
|
|
3091 location_t loc;
|
|
|
3092 char buf[BUFSIZE];
|
|
|
3093 unsigned int instanceStart, instanceSize;
|
|
|
3094 unsigned int flags = 0x01; /* RO_META */
|
|
|
3095 int cls_flags = impent->has_cxx_cdtors ? OBJC2_CLS_HAS_CXX_STRUCTORS
|
|
|
3096 : 0 ;
|
|
|
3097
|
|
|
3098 class_decl = impent->class_decl;
|
|
|
3099 metaclass_decl = impent->meta_decl;
|
|
|
3100 loc = DECL_SOURCE_LOCATION (class_decl);
|
|
|
3101
|
|
|
3102 DECL_EXTERNAL (class_decl) = DECL_EXTERNAL (metaclass_decl) = 0;
|
|
|
3103 TREE_PUBLIC (class_decl) = TREE_PUBLIC (metaclass_decl) = 1;
|
|
|
3104 #ifdef OBJCPLUS
|
|
|
3105 gcc_assert (!CP_DECL_CONTEXT (class_decl) || CP_DECL_CONTEXT (class_decl) == global_namespace);
|
|
|
3106 gcc_assert (!CP_DECL_CONTEXT (metaclass_decl) || CP_DECL_CONTEXT (metaclass_decl) == global_namespace);
|
|
|
3107 #endif
|
|
|
3108
|
|
|
3109 /* Generation of data for meta class. */
|
|
|
3110 my_super_id = CLASS_SUPER_NAME (impent->imp_template);
|
|
|
3111 if (my_super_id)
|
|
|
3112 {
|
|
|
3113 /* Compute reference to root's name. For a meta class, "isa" is
|
|
|
3114 a reference to the root class name. */
|
|
|
3115 tree my_root_id = my_super_id;
|
|
|
3116 tree my_root_int, interface;
|
|
|
3117 do
|
|
|
3118 {
|
|
|
3119 my_root_int = lookup_interface (my_root_id);
|
|
|
3120
|
|
|
3121 if (my_root_int && CLASS_SUPER_NAME (my_root_int))
|
|
|
3122 my_root_id = CLASS_SUPER_NAME (my_root_int);
|
|
|
3123 else
|
|
|
3124 break;
|
|
|
3125 }
|
|
|
3126 while (1);
|
|
|
3127
|
|
|
3128 /* {extern} struct class_t OBJC_METACLASS_$_<my_root_int>
|
|
|
3129 create extern if not already declared. */
|
|
|
3130 snprintf (buf, BUFSIZE, "OBJC_METACLASS_$_%s",
|
|
|
3131 IDENTIFIER_POINTER (CLASS_NAME (my_root_int)));
|
|
|
3132 root_expr = create_extern_decl (objc_v2_class_template, buf);
|
|
|
3133 root_expr = build_fold_addr_expr (root_expr);
|
|
|
3134
|
|
|
3135 /* Install class `isa' and `super' pointers at runtime. */
|
|
|
3136 interface = lookup_interface (my_super_id);
|
|
|
3137 gcc_assert (interface);
|
|
|
3138 /* Similarly, for OBJC_CLASS_$_<interface>... */
|
|
|
3139 snprintf (buf, BUFSIZE, "OBJC_CLASS_$_%s",
|
|
|
3140 IDENTIFIER_POINTER (CLASS_NAME (interface)));
|
|
|
3141 class_superclass_expr = create_extern_decl (objc_v2_class_template, buf);
|
|
|
3142 class_superclass_expr = build_fold_addr_expr (class_superclass_expr);
|
|
|
3143 /* ... and for OBJC_METACLASS_$_<interface>. */
|
|
|
3144 snprintf (buf, BUFSIZE, "OBJC_METACLASS_$_%s",
|
|
|
3145 IDENTIFIER_POINTER (CLASS_NAME (interface)));
|
|
|
3146 metaclass_superclass_expr = create_extern_decl (objc_v2_class_template, buf);
|
|
|
3147 metaclass_superclass_expr = build_fold_addr_expr (metaclass_superclass_expr);
|
|
|
3148 }
|
|
|
3149 else
|
|
|
3150 {
|
|
|
3151 /* Root class. */
|
|
|
3152 root_expr = build_unary_op (loc, ADDR_EXPR, metaclass_decl, 0);
|
|
|
3153 metaclass_superclass_expr = build_unary_op (loc, ADDR_EXPR, class_decl, 0);
|
|
|
3154 class_superclass_expr = build_int_cst (NULL_TREE, 0);
|
|
|
3155 flags |= 0x02; /* RO_ROOT: it is also a root meta class. */
|
|
|
3156 }
|
|
|
3157
|
|
|
3158 if (CLASS_PROTOCOL_LIST (impent->imp_template))
|
|
|
3159 {
|
|
|
3160 generate_protocol_references (CLASS_PROTOCOL_LIST (impent->imp_template));
|
|
|
3161 protocol_decl = generate_v2_protocol_list (impent->imp_template,
|
|
|
3162 impent->imp_context);
|
|
|
3163 }
|
|
|
3164 else
|
|
|
3165 protocol_decl = 0;
|
|
|
3166
|
|
|
3167 name_expr = add_objc_string (CLASS_NAME (impent->imp_template),
|
|
|
3168 class_names);
|
|
|
3169
|
|
|
3170 if (CLASS_CLS_METHODS (impent->imp_context))
|
|
|
3171 {
|
|
|
3172 snprintf (buf, BUFSIZE, "_OBJC_ClassMethods_%s",
|
|
|
3173 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context)));
|
|
|
3174 class_methods =
|
|
|
3175 generate_v2_dispatch_table (CLASS_CLS_METHODS (impent->imp_context),
|
|
|
3176 buf, meta_clac_meth);
|
|
|
3177 }
|
|
|
3178
|
|
|
3179 instanceStart = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_class_template));
|
|
|
3180
|
|
|
3181 /* Currently there are no class ivars and generation of class
|
|
|
3182 variables for the root of the inheritance has been removed. It
|
|
|
3183 causes multiple defines if there are two root classes in the
|
|
|
3184 link, because each will define its own identically-named offset
|
|
|
3185 variable. */
|
|
|
3186
|
|
|
3187 class_ivars = NULL_TREE;
|
|
|
3188 /* TODO: Add total size of class variables when implemented. */
|
|
|
3189 instanceSize = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_class_template));
|
|
|
3190
|
|
|
3191 /* So now build the META CLASS structs. */
|
|
|
3192 /* static struct class_ro_t _OBJC_METACLASS_Foo = { ... }; */
|
|
|
3193
|
|
|
3194 decl = start_var_decl (objc_v2_class_ro_template,
|
|
|
3195 newabi_append_ro (IDENTIFIER_POINTER
|
|
|
3196 (DECL_NAME (metaclass_decl))));
|
|
|
3197
|
|
|
3198 /* TODO: ivarLayout needs t be built. */
|
|
|
3199 initlist =
|
|
|
3200 build_v2_class_ro_t_initializer (TREE_TYPE (decl), name_expr,
|
|
|
3201 (flags | cls_flags), instanceStart,
|
|
|
3202 instanceSize, ivarLayout,
|
|
|
3203 class_methods, protocol_decl,
|
|
|
3204 class_ivars, NULL_TREE);
|
|
|
3205 /* The ROs sit in the default const section. */
|
|
|
3206 OBJCMETA (decl, objc_meta, meta_base);
|
|
|
3207 finish_var_decl (decl, initlist);
|
|
|
3208
|
|
|
3209 /* static struct class_t _OBJC_METACLASS_Foo = { ... }; */
|
|
|
3210 initlist =
|
|
|
3211 build_v2_class_t_initializer (TREE_TYPE (metaclass_decl),
|
|
|
3212 root_expr,
|
|
|
3213 metaclass_superclass_expr,
|
|
|
3214 build_fold_addr_expr (decl),
|
|
|
3215 build_fold_addr_expr (UOBJC_V2_CACHE_decl),
|
|
|
3216 build_fold_addr_expr (UOBJC_V2_VTABLE_decl));
|
|
|
3217 /* The class section attributes are set when they are created. */
|
|
|
3218 finish_var_decl (metaclass_decl, initlist);
|
|
|
3219 impent->meta_decl = metaclass_decl;
|
|
|
3220
|
|
|
3221 /* So now build the CLASS structs. */
|
|
|
3222
|
|
|
3223 flags = 0x0; /* ... */
|
|
|
3224 if (!my_super_id)
|
|
|
3225 flags |= 0x02; /* RO_ROOT: this is a root class */
|
|
|
3226
|
|
|
3227 if (DECL_VISIBILITY (class_decl) == VISIBILITY_HIDDEN)
|
|
|
3228 flags |= 0x10; /* RO_HIDDEN, OBJC2_CLS_HIDDEN; */
|
|
|
3229
|
|
|
3230 if (objc2_objc_exception_attr (impent->imp_template))
|
|
|
3231 flags |= 0x20; /* RO_EXCEPTION */
|
|
|
3232
|
|
|
3233 if (CLASS_NST_METHODS (impent->imp_context))
|
|
|
3234 {
|
|
|
3235 snprintf (buf, BUFSIZE, "_OBJC_InstanceMethods_%s",
|
|
|
3236 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context)));
|
|
|
3237 inst_methods =
|
|
|
3238 generate_v2_dispatch_table (CLASS_NST_METHODS (impent->imp_context),
|
|
|
3239 buf, meta_clai_meth);
|
|
|
3240 }
|
|
|
3241
|
|
|
3242 /* Sort out the ivars before we try to compute the class sizes. */
|
|
|
3243 if ((chain = CLASS_IVARS (impent->imp_template)))
|
|
|
3244 {
|
|
|
3245 snprintf (buf, BUFSIZE, "_OBJC_InstanceIvars_%s",
|
|
|
3246 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context)));
|
|
|
3247 inst_ivars = generate_v2_ivars_list (chain, buf, meta_clai_vars,
|
|
|
3248 impent->imp_template);
|
|
|
3249 }
|
|
|
3250
|
|
|
3251 /* Compute instanceStart. */
|
|
|
3252 gcc_assert (CLASS_STATIC_TEMPLATE (impent->imp_template));
|
|
|
3253 field = TYPE_FIELDS (CLASS_STATIC_TEMPLATE (impent->imp_template));
|
|
|
3254 if (my_super_id && field && TREE_CHAIN (field))
|
|
|
3255 field = TREE_CHAIN (field);
|
|
|
3256
|
|
|
3257 firstIvar = field;
|
|
|
3258
|
|
|
3259 while (firstIvar && TREE_CODE (firstIvar) != FIELD_DECL)
|
|
|
3260 firstIvar = TREE_CHAIN (firstIvar);
|
|
|
3261
|
|
|
3262 gcc_assert (inst_ivars? (firstIvar != NULL_TREE): true);
|
|
|
3263
|
|
|
3264 /* Compute instanceSize. */
|
|
|
3265 while (field && TREE_CHAIN (field)
|
|
|
3266 && TREE_CODE (TREE_CHAIN (field)) == FIELD_DECL)
|
|
|
3267 field = TREE_CHAIN (field);
|
|
|
3268
|
|
|
3269 if (field && TREE_CODE (field) == FIELD_DECL)
|
|
|
3270 instanceSize = int_byte_position (field) * BITS_PER_UNIT
|
|
|
3271 + tree_to_shwi (DECL_SIZE (field));
|
|
|
3272 else
|
|
|
3273 instanceSize = 0;
|
|
|
3274 instanceSize /= BITS_PER_UNIT;
|
|
|
3275
|
|
|
3276 props = generate_v2_property_table (NULL_TREE, impent->imp_context);
|
|
|
3277
|
|
|
3278 /* If the class has no ivars, instanceStart should be set to the
|
|
|
3279 superclass's instanceSize. */
|
|
|
3280 instanceStart =
|
|
|
3281 (inst_ivars != NULL_TREE) ? (unsigned) int_byte_position (firstIvar)
|
|
|
3282 : instanceSize;
|
|
|
3283
|
|
|
3284 /* static struct class_ro_t _OBJC_CLASS_Foo = { ... }; */
|
|
|
3285 decl = start_var_decl (objc_v2_class_ro_template,
|
|
|
3286 newabi_append_ro (IDENTIFIER_POINTER
|
|
|
3287 (DECL_NAME (class_decl))));
|
|
|
3288
|
|
|
3289 initlist =
|
|
|
3290 build_v2_class_ro_t_initializer (TREE_TYPE (decl), name_expr,
|
|
|
3291 (flags | cls_flags), instanceStart,
|
|
|
3292 instanceSize, ivarLayout,
|
|
|
3293 inst_methods, protocol_decl,
|
|
|
3294 inst_ivars, props);
|
|
|
3295 /* The ROs sit in the default const section. */
|
|
|
3296 OBJCMETA (decl, objc_meta, meta_base);
|
|
|
3297 finish_var_decl (decl, initlist);
|
|
|
3298
|
|
|
3299 /* static struct class_t _OBJC_CLASS_Foo = { ... }; */
|
|
|
3300 initlist = build_v2_class_t_initializer (TREE_TYPE (class_decl),
|
|
|
3301 build_fold_addr_expr (metaclass_decl),
|
|
|
3302 class_superclass_expr,
|
|
|
3303 build_fold_addr_expr (decl),
|
|
|
3304 build_fold_addr_expr (UOBJC_V2_CACHE_decl),
|
|
|
3305 build_fold_addr_expr (UOBJC_V2_VTABLE_decl));
|
|
|
3306
|
|
|
3307 /* The class section attributes are set when they are created. */
|
|
|
3308 finish_var_decl (class_decl, initlist);
|
|
|
3309 impent->class_decl = class_decl;
|
|
|
3310
|
|
|
3311 objc_v2_add_to_class_list (class_decl);
|
|
|
3312 if (has_load_impl (CLASS_CLS_METHODS (impent->imp_context)))
|
|
|
3313 objc_v2_add_to_nonlazy_class_list (class_decl);
|
|
|
3314
|
|
|
3315 if (flags & 0x20) /* RO_EXCEPTION */
|
|
|
3316 objc_v2_add_to_ehtype_list (CLASS_NAME (impent->imp_template));
|
|
|
3317 }
|
|
|
3318
|
|
|
3319 /* This routine outputs the (ivar_reference_offset, offset)
|
|
|
3320 tuples. */
|
|
|
3321
|
|
|
3322 static void
|
|
|
3323 build_v2_ivar_offset_ref_table (void)
|
|
|
3324 {
|
|
|
3325 int count;
|
|
|
3326 ivarref_entry *ref;
|
|
|
3327
|
|
|
3328 if (!vec_safe_length (ivar_offset_refs))
|
|
|
3329 return;
|
|
|
3330
|
|
|
3331 FOR_EACH_VEC_ELT (*ivar_offset_refs, count, ref)
|
|
|
3332 finish_var_decl (ref->decl, ref->offset);
|
|
|
3333 }
|
|
|
3334
|
|
|
3335 static void
|
|
|
3336 objc_generate_v2_next_metadata (void)
|
|
|
3337 {
|
|
|
3338 struct imp_entry *impent;
|
|
|
3339
|
|
|
3340 /* FIXME: Make sure that we generate no metadata if there is nothing
|
|
|
3341 to put into it. */
|
|
|
3342
|
|
|
3343 gcc_assert (!objc_static_instances); /* Not for NeXT */
|
|
|
3344
|
|
|
3345 build_metadata_templates ();
|
|
|
3346
|
|
|
3347 for (impent = imp_list; impent; impent = impent->next)
|
|
|
3348 {
|
|
|
3349 /* If -gen-decls is present, Dump the @interface of each class.
|
|
|
3350 TODO: Dump the classes in the order they were found, rather
|
|
|
3351 than in reverse order as we are doing now. */
|
|
|
3352 if (flag_gen_declaration)
|
|
|
3353 dump_interface (gen_declaration_file, impent->imp_context);
|
|
|
3354
|
|
|
3355 /* all of the following reference the string pool... */
|
|
|
3356 if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
|
|
|
3357 generate_v2_class_structs (impent);
|
|
|
3358 else
|
|
|
3359 generate_v2_category (impent);
|
|
|
3360 }
|
|
|
3361
|
|
|
3362 build_next_selector_translation_table ();
|
|
|
3363 build_v2_message_ref_translation_table ();
|
|
|
3364
|
|
|
3365 /* This will add "Protocol" to the class refs. */
|
|
|
3366 generate_v2_protocols ();
|
|
|
3367
|
|
|
3368 build_v2_classrefs_table ();
|
|
|
3369 build_v2_super_classrefs_table (/*metaclass= */false);
|
|
|
3370 build_v2_super_classrefs_table (/*metaclass= */true);
|
|
|
3371
|
|
|
3372 build_v2_ivar_offset_ref_table ();
|
|
|
3373
|
|
|
3374 build_v2_protocol_list_translation_table ();
|
|
|
3375 build_v2_protocol_list_address_table ();
|
|
|
3376
|
|
|
3377 build_v2_address_table (class_list, "_OBJC_ClassList$",
|
|
|
3378 meta_label_classlist);
|
|
|
3379 build_v2_address_table (category_list, "_OBJC_CategoryList$",
|
|
|
3380 meta_label_categorylist);
|
|
|
3381 build_v2_address_table (nonlazy_class_list, "_OBJC_NonLazyClassList$",
|
|
|
3382 meta_label_nonlazy_classlist);
|
|
|
3383 build_v2_address_table (nonlazy_category_list, "_OBJC_NonLazyCategoryList$",
|
|
|
3384 meta_label_nonlazy_categorylist);
|
|
|
3385
|
|
|
3386 /* Generate catch objects for eh, if any are needed. */
|
|
|
3387 build_v2_eh_catch_objects ();
|
|
|
3388
|
|
|
3389 /* Emit the string table last. */
|
|
|
3390 generate_strings ();
|
|
|
3391 }
|
|
|
3392
|
|
|
3393 /* NOTE --- Output NeXT V2 Exceptions --- */
|
|
|
3394
|
|
|
3395 static GTY(()) tree objc_v2_ehtype_template;
|
|
|
3396 static GTY(()) tree next_v2_ehvtable_decl;
|
|
|
3397 static GTY(()) tree next_v2_EHTYPE_id_decl;
|
|
|
3398
|
|
|
3399 static void
|
|
|
3400 build_v2_ehtype_template (void)
|
|
|
3401 {
|
|
|
3402 tree decls, *chain = NULL;
|
|
|
3403 objc_v2_ehtype_template = objc_start_struct (get_identifier (UTAG_V2_EH_TYPE));
|
|
|
3404
|
|
|
3405 /* void *_objc_ehtype_vtable; */
|
|
|
3406 decls = add_field_decl (ptr_type_node, "_objc_ehtype_vtable_ptr", &chain);
|
|
|
3407
|
|
|
3408 /* const char *className; */
|
|
|
3409 add_field_decl (string_type_node, "className", &chain);
|
|
|
3410
|
|
|
3411 /* struct class_t *const cls; */
|
|
|
3412 add_field_decl (build_pointer_type (objc_v2_class_template), "cls", &chain);
|
|
|
3413
|
|
|
3414 objc_finish_struct (objc_v2_ehtype_template, decls);
|
|
|
3415 }
|
|
|
3416
|
|
|
3417 /* Template for the Objective-C family typeinfo type for ABI=2. This
|
|
|
3418 starts off the same as the gxx/cxx eh typeinfo.
|
|
|
3419
|
|
|
3420 struct _objc_ehtype_t
|
|
|
3421 {
|
|
|
3422 void *_objc_ehtype_vtable_ptr; - as per c++
|
|
|
3423 const char *className; - as per c++
|
|
|
3424 struct class_t *const cls;
|
|
|
3425 }
|
|
|
3426 */
|
|
|
3427
|
|
|
3428 /* This routine builds initializer list for object of type struct _objc_ehtype_t.
|
|
|
3429 */
|
|
|
3430
|
|
|
3431 static tree
|
|
|
3432 objc2_build_ehtype_initializer (tree name, tree cls)
|
|
|
3433 {
|
|
|
3434 vec<constructor_elt, va_gc> *initlist = NULL;
|
|
|
3435 tree addr, offs;
|
|
|
3436
|
|
|
3437 /* This is done the same way as c++, missing the two first entries
|
|
|
3438 in the parent vtable. NOTE: there is a fix-me in the Apple/NeXT
|
|
|
3439 runtime source about this so, perhaps, this will change at some
|
|
|
3440 point. */
|
|
|
3441 /* _objc_ehtype_vtable + 2*sizeof(void*) */
|
|
|
3442 if (!next_v2_ehvtable_decl)
|
|
|
3443 {
|
|
|
3444 next_v2_ehvtable_decl =
|
|
|
3445 start_var_decl (ptr_type_node, TAG_NEXT_EHVTABLE_NAME);
|
|
|
3446 TREE_STATIC (next_v2_ehvtable_decl) = 0;
|
|
|
3447 DECL_EXTERNAL (next_v2_ehvtable_decl) = 1;
|
|
|
3448 TREE_PUBLIC (next_v2_ehvtable_decl) = 1;
|
|
|
3449 }
|
|
|
3450 addr = build_fold_addr_expr_with_type (next_v2_ehvtable_decl, ptr_type_node);
|
|
|
3451 offs = size_int (2 * int_cst_value (TYPE_SIZE_UNIT (ptr_type_node)));
|
|
|
3452 addr = fold_build_pointer_plus (addr, offs);
|
|
|
3453
|
|
|
3454 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, addr);
|
|
|
3455
|
|
|
3456 /* className */
|
|
|
3457 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, name);
|
|
|
3458
|
|
|
3459 /* cls */
|
|
|
3460 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, cls);
|
|
|
3461
|
|
|
3462 return objc_build_constructor (objc_v2_ehtype_template, initlist);
|
|
|
3463 }
|
|
|
3464
|
|
|
3465 static tree
|
|
|
3466 build_ehtype (tree name, const char *eh_name, bool weak)
|
|
|
3467 {
|
|
|
3468 tree name_expr, class_name_expr, ehtype_decl, inits;
|
|
|
3469
|
|
|
3470 name_expr = add_objc_string (name, class_names);
|
|
|
3471 /* Extern ref. for the class. ??? Maybe we can look this up
|
|
|
3472 somewhere. */
|
|
|
3473 class_name_expr =
|
|
|
3474 create_extern_decl (objc_v2_class_template,
|
|
|
3475 objc_build_internal_classname (name, false));
|
|
|
3476 class_name_expr = build_fold_addr_expr (class_name_expr);
|
|
|
3477 ehtype_decl = create_global_decl (objc_v2_ehtype_template, eh_name);
|
|
|
3478 if (weak)
|
|
|
3479 DECL_WEAK (ehtype_decl) = 1;
|
|
|
3480 inits = objc2_build_ehtype_initializer (name_expr, class_name_expr);
|
|
|
3481 OBJCMETA (ehtype_decl, objc_meta, meta_ehtype);
|
|
|
3482 finish_var_decl (ehtype_decl, inits);
|
|
|
3483 return ehtype_decl;
|
|
|
3484 }
|
|
|
3485
|
|
|
3486 /* This routine returns TRUE if CLS or any of its super classes has
|
|
|
3487 __attribute__ ((objc_exception)). */
|
|
|
3488
|
|
|
3489 static bool
|
|
|
3490 objc2_objc_exception_attr (tree cls)
|
|
|
3491 {
|
|
|
3492 while (cls)
|
|
|
3493 {
|
|
|
3494 if (CLASS_HAS_EXCEPTION_ATTR (cls))
|
|
|
3495 return true;
|
|
|
3496 cls = lookup_interface (CLASS_SUPER_NAME (cls));
|
|
|
3497 }
|
|
|
3498
|
|
|
3499 return false;
|
|
|
3500 }
|
|
|
3501
|
|
|
3502 static bool
|
|
|
3503 is_implemented (tree name)
|
|
|
3504 {
|
|
|
3505 struct imp_entry *t;
|
|
|
3506 for (t = imp_list; t; t = t->next)
|
|
|
3507 if (TREE_CODE (t->imp_context) == CLASS_IMPLEMENTATION_TYPE
|
|
|
3508 && CLASS_NAME (t->imp_template) == name)
|
|
|
3509 return true;
|
|
|
3510
|
|
|
3511 return false;
|
|
|
3512 }
|
|
|
3513
|
|
|
3514 /* We will build catch objects:
|
|
|
3515 for any type implemented here.
|
|
|
3516 for any type used in a catch that has no exception attribute. */
|
|
|
3517 static void build_v2_eh_catch_objects (void)
|
|
|
3518 {
|
|
|
3519 int count=0;
|
|
|
3520 ident_data_tuple *ref;
|
|
|
3521
|
|
|
3522 if (!vec_safe_length (ehtype_list))
|
|
|
3523 return;
|
|
|
3524
|
|
|
3525 FOR_EACH_VEC_ELT (*ehtype_list, count, ref)
|
|
|
3526 {
|
|
|
3527 char buf[BUFSIZE];
|
|
|
3528 bool impl = is_implemented (ref->ident);
|
|
|
3529 bool excpt = objc2_objc_exception_attr (lookup_interface (ref->ident));
|
|
|
3530 snprintf (buf, BUFSIZE, "OBJC_EHTYPE_$_%s", IDENTIFIER_POINTER (ref->ident));
|
|
|
3531 if (!impl && excpt)
|
|
|
3532 /* The User says this class has a catcher already. */
|
|
|
3533 ref->data = create_extern_decl (objc_v2_ehtype_template, buf);
|
|
|
3534 else
|
|
|
3535 /* Create a catcher, weak if it wasn't marked. */
|
|
|
3536 ref->data = build_ehtype (ref->ident, buf, !excpt);
|
|
|
3537 }
|
|
|
3538 }
|
|
|
3539
|
|
|
3540 static tree
|
|
|
3541 lookup_ehtype_ref (tree id)
|
|
|
3542 {
|
|
|
3543 int count=0;
|
|
|
3544 ident_data_tuple *ref;
|
|
|
3545
|
|
|
3546 if (!vec_safe_length (ehtype_list))
|
|
|
3547 return NULL_TREE;
|
|
|
3548
|
|
|
3549 FOR_EACH_VEC_ELT (*ehtype_list, count, ref)
|
|
|
3550 if (ref->ident == id)
|
|
|
3551 return ref->data;
|
|
|
3552 return NULL_TREE;
|
|
|
3553 }
|
|
|
3554
|
|
|
3555 /* This hook, called via lang_eh_runtime_type, generates a runtime
|
|
|
3556 object which is either the address of the 'OBJC_EHTYPE_$_class'
|
|
|
3557 object or address of external OBJC_EHTYPE_id object. */
|
|
|
3558 static tree
|
|
|
3559 next_runtime_02_eh_type (tree type)
|
|
|
3560 {
|
|
|
3561 tree t;
|
|
|
3562
|
|
|
3563 if (type == error_mark_node
|
|
|
3564 /*|| errorcount || sorrycount*/)
|
|
|
3565 goto err_mark_in;
|
|
|
3566
|
|
|
3567 if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type)))
|
|
|
3568 {
|
|
|
3569 if (!next_v2_EHTYPE_id_decl)
|
|
|
3570 {
|
|
|
3571 /* This is provided by the Apple/NeXT libobjc.dylib so we
|
|
|
3572 need only to reference it. */
|
|
|
3573 next_v2_EHTYPE_id_decl =
|
|
|
3574 start_var_decl (objc_v2_ehtype_template, "OBJC_EHTYPE_id");
|
|
|
3575 DECL_EXTERNAL (next_v2_EHTYPE_id_decl) = 1;
|
|
|
3576 TREE_PUBLIC (next_v2_EHTYPE_id_decl) = 1;
|
|
|
3577 TREE_STATIC (next_v2_EHTYPE_id_decl) = 0;
|
|
|
3578 }
|
|
|
3579 return build_fold_addr_expr (next_v2_EHTYPE_id_decl);
|
|
|
3580 }
|
|
|
3581
|
|
|
3582 if (!POINTER_TYPE_P (type) || !TYPED_OBJECT (TREE_TYPE (type)))
|
|
|
3583 {
|
|
|
3584 #ifdef OBJCPLUS
|
|
|
3585 /* This routine is also called for c++'s catch clause; in which
|
|
|
3586 case, we use c++'s typeinfo decl. */
|
|
|
3587 return build_eh_type_type (type);
|
|
|
3588 #else
|
|
|
3589 error ("non-objective-c type %qT cannot be caught", type);
|
|
|
3590 goto err_mark_in;
|
|
|
3591 #endif
|
|
|
3592 }
|
|
|
3593 else
|
|
|
3594 t = OBJC_TYPE_NAME (TREE_TYPE (type));
|
|
|
3595
|
|
|
3596 /* We have to build a reference to the OBJC_EHTYPE_<Class>. */
|
|
|
3597 t = lookup_ehtype_ref (t);
|
|
|
3598 if (!t)
|
|
|
3599 goto err_mark_in;
|
|
|
3600
|
|
|
3601 return build_fold_addr_expr (t);
|
|
|
3602
|
|
|
3603 err_mark_in:
|
|
|
3604 return error_mark_node;
|
|
|
3605 }
|
|
|
3606
|
|
|
3607 static GTY(()) tree objc_eh_personality_decl;
|
|
|
3608
|
|
|
3609 static tree
|
|
|
3610 objc_eh_personality (void)
|
|
|
3611 {
|
|
|
3612 if (!objc_eh_personality_decl)
|
|
|
3613 objc_eh_personality_decl = build_personality_function ("objc");
|
|
|
3614 return objc_eh_personality_decl;
|
|
|
3615 }
|
|
|
3616
|
|
|
3617 /* NOTE --- interfaces --- */
|
|
|
3618
|
|
|
3619 static tree
|
|
|
3620 build_throw_stmt (location_t loc, tree throw_expr, bool rethrown)
|
|
|
3621 {
|
|
|
3622 tree t;
|
|
|
3623 if (rethrown)
|
|
|
3624 /* We have a separate re-throw entry. */
|
|
|
3625 t = build_function_call_vec (loc, vNULL, objc_rethrow_exception_decl,
|
|
|
3626 NULL, NULL);
|
|
|
3627 else
|
|
|
3628 {
|
|
|
3629 /* Throw like the others... */
|
|
|
3630 vec<tree, va_gc> *parms;
|
|
|
3631 vec_alloc (parms, 1);
|
|
|
3632 parms->quick_push (throw_expr);
|
|
|
3633 t = build_function_call_vec (loc, vNULL, objc_exception_throw_decl,
|
|
|
3634 parms, 0);
|
|
|
3635 vec_free (parms);
|
|
|
3636 }
|
|
|
3637 return add_stmt (t);
|
|
|
3638 }
|
|
|
3639
|
|
|
3640 /* Build __builtin_eh_pointer. */
|
|
|
3641
|
|
|
3642 static tree
|
|
|
3643 objc_build_exc_ptr (struct objc_try_context **x ATTRIBUTE_UNUSED)
|
|
|
3644 {
|
|
|
3645 tree t;
|
|
|
3646 t = builtin_decl_explicit (BUILT_IN_EH_POINTER);
|
|
|
3647 t = build_call_expr (t, 1, integer_zero_node);
|
|
|
3648 return fold_convert (objc_object_type, t);
|
|
|
3649 }
|
|
|
3650
|
|
|
3651 static tree begin_catch (struct objc_try_context **cur_try_context, tree type,
|
|
|
3652 tree decl, tree compound, bool ellipsis ATTRIBUTE_UNUSED)
|
|
|
3653 {
|
|
|
3654 tree t;
|
|
|
3655
|
|
|
3656 /* Record the data for the catch in the try context so that we can
|
|
|
3657 finalize it later. Ellipsis is signalled by a NULL entry. */
|
|
|
3658 if (ellipsis)
|
|
|
3659 t = build_stmt (input_location, CATCH_EXPR, NULL_TREE, compound);
|
|
|
3660 else
|
|
|
3661 t = build_stmt (input_location, CATCH_EXPR, type, compound);
|
|
|
3662 (*cur_try_context)->current_catch = t;
|
|
|
3663
|
|
|
3664 /* Initialize the decl from the EXC_PTR_EXPR we get from the runtime. */
|
|
|
3665 t = objc_build_exc_ptr (cur_try_context);
|
|
|
3666 t = convert (TREE_TYPE (decl), t);
|
|
|
3667 /* FIXME: location. */
|
|
|
3668 if (type && type != error_mark_node)
|
|
|
3669 {
|
|
|
3670 t = build1(NOP_EXPR, ptr_type_node, t);
|
|
|
3671 t = build_function_call (input_location, objc2_begin_catch_decl,
|
|
|
3672 tree_cons (NULL_TREE, t, NULL_TREE));
|
|
|
3673
|
|
|
3674 /* We might want to build a catch object for this (if it's not
|
|
|
3675 id). */
|
|
|
3676 if (POINTER_TYPE_P (type)
|
|
|
3677 && !objc_is_object_id (TREE_TYPE (type))
|
|
|
3678 && TYPED_OBJECT (TREE_TYPE (type)))
|
|
|
3679 objc_v2_add_to_ehtype_list (OBJC_TYPE_NAME (TREE_TYPE (type)));
|
|
|
3680 }
|
|
|
3681 return build2 (MODIFY_EXPR, void_type_node, decl, t);
|
|
|
3682 }
|
|
|
3683
|
|
|
3684 /* try { catch-body } finally { objc_end_catch (); } */
|
|
|
3685 static void
|
|
|
3686 finish_catch (struct objc_try_context **cur_try_context, tree curr_catch)
|
|
|
3687 {
|
|
|
3688 struct objc_try_context *ct;
|
|
|
3689 tree try_exp, func, *l, t ;
|
|
|
3690 location_t loc = (*cur_try_context)->try_locus;
|
|
|
3691
|
|
|
3692 if (!curr_catch || curr_catch == error_mark_node)
|
|
|
3693 return;
|
|
|
3694
|
|
|
3695 t = CATCH_BODY (curr_catch);
|
|
|
3696 if (TREE_CODE (t) == BIND_EXPR)
|
|
|
3697 {
|
|
|
3698 /* Usual case of @catch (objc-expr). */
|
|
|
3699 objc_begin_try_stmt (loc, BIND_EXPR_BODY (t));
|
|
|
3700 BIND_EXPR_BODY (t) = NULL_TREE;
|
|
|
3701 l = &BIND_EXPR_BODY (t);
|
|
|
3702 }
|
|
|
3703 else
|
|
|
3704 {
|
|
|
3705 /* NULL entry, meaning @catch (...). */
|
|
|
3706 objc_begin_try_stmt (loc, t);
|
|
|
3707 CATCH_BODY (curr_catch) = NULL_TREE;
|
|
|
3708 l = &CATCH_BODY (curr_catch);
|
|
|
3709 }
|
|
|
3710
|
|
|
3711 /* Pick up the new context we made in begin_try above... */
|
|
|
3712 ct = *cur_try_context;
|
|
|
3713 func = build_function_call_vec (loc, vNULL, objc2_end_catch_decl, NULL,
|
|
|
3714 NULL);
|
|
|
3715 append_to_statement_list (func, &ct->finally_body);
|
|
|
3716 try_exp = build_stmt (loc, TRY_FINALLY_EXPR, ct->try_body, ct->finally_body);
|
|
|
3717 *cur_try_context = ct->outer;
|
|
|
3718 free (ct);
|
|
|
3719 append_to_statement_list (try_exp, l);
|
|
|
3720 append_to_statement_list (curr_catch, &((*cur_try_context)->catch_list));
|
|
|
3721 }
|
|
|
3722
|
|
|
3723 static tree
|
|
|
3724 finish_try_stmt (struct objc_try_context **cur_try_context)
|
|
|
3725 {
|
|
|
3726 struct objc_try_context *c = *cur_try_context;
|
|
|
3727 tree stmt = c->try_body;
|
|
|
3728 if (c->catch_list)
|
|
|
3729 stmt = build_stmt (c->try_locus, TRY_CATCH_EXPR, stmt, c->catch_list);
|
|
|
3730 if (c->finally_body)
|
|
|
3731 stmt = build_stmt (c->try_locus, TRY_FINALLY_EXPR, stmt, c->finally_body);
|
|
|
3732 return stmt;
|
|
|
3733 }
|
|
|
3734
|
|
|
3735 #include "gt-objc-objc-next-runtime-abi-02.h"
|
