]>
Commit | Line | Data |
---|---|---|
3fd5abcf | 1 | /* Process declarations and variables for C++ compiler. |
d6a8bdff | 2 | Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, |
521cc508 | 3 | 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. |
8d08fdba MS |
4 | Hacked by Michael Tiemann (tiemann@cygnus.com) |
5 | ||
1c313945 | 6 | This file is part of GCC. |
8d08fdba | 7 | |
1c313945 | 8 | GCC is free software; you can redistribute it and/or modify |
8d08fdba MS |
9 | it under the terms of the GNU General Public License as published by |
10 | the Free Software Foundation; either version 2, or (at your option) | |
11 | any later version. | |
12 | ||
1c313945 | 13 | GCC is distributed in the hope that it will be useful, |
8d08fdba MS |
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | GNU General Public License for more details. | |
17 | ||
18 | You should have received a copy of the GNU General Public License | |
1c313945 | 19 | along with GCC; see the file COPYING. If not, write to |
e9fa0c7c RK |
20 | the Free Software Foundation, 59 Temple Place - Suite 330, |
21 | Boston, MA 02111-1307, USA. */ | |
8d08fdba MS |
22 | |
23 | ||
1c313945 | 24 | /* Process declarations and symbol lookup for C++ front end. |
8d08fdba MS |
25 | Also constructs types; the standard scalar types at initialization, |
26 | and structure, union, array and enum types when they are declared. */ | |
27 | ||
28 | /* ??? not all decl nodes are given the most useful possible | |
29 | line numbers. For example, the CONST_DECLs for enum values. */ | |
30 | ||
31 | #include "config.h" | |
8d052bc7 | 32 | #include "system.h" |
4977bab6 ZW |
33 | #include "coretypes.h" |
34 | #include "tm.h" | |
8d08fdba MS |
35 | #include "tree.h" |
36 | #include "rtl.h" | |
8f17b5c5 | 37 | #include "expr.h" |
8d08fdba MS |
38 | #include "flags.h" |
39 | #include "cp-tree.h" | |
40 | #include "decl.h" | |
e8abc66f | 41 | #include "output.h" |
49c249e1 | 42 | #include "except.h" |
54f92bfb | 43 | #include "toplev.h" |
2a9a326b | 44 | #include "timevar.h" |
297441fd | 45 | #include "cpplib.h" |
672a6f42 | 46 | #include "target.h" |
a5a49440 | 47 | #include "c-common.h" |
6de9cd9a | 48 | #include "tree-mudflap.h" |
8cd2462c JH |
49 | #include "cgraph.h" |
50 | #include "tree-inline.h" | |
6de9cd9a | 51 | |
cf44ea52 | 52 | extern cpp_reader *parse_in; |
297441fd | 53 | |
0aafb128 MM |
54 | /* This structure contains information about the initializations |
55 | and/or destructions required for a particular priority level. */ | |
56 | typedef struct priority_info_s { | |
838dfd8a | 57 | /* Nonzero if there have been any initializations at this priority |
0352cfc8 MM |
58 | throughout the translation unit. */ |
59 | int initializations_p; | |
838dfd8a | 60 | /* Nonzero if there have been any destructions at this priority |
0352cfc8 MM |
61 | throughout the translation unit. */ |
62 | int destructions_p; | |
0aafb128 MM |
63 | } *priority_info; |
64 | ||
848eed92 GDR |
65 | static void mark_vtable_entries (tree); |
66 | static void grok_function_init (tree, tree); | |
67 | static bool maybe_emit_vtables (tree); | |
848eed92 GDR |
68 | static tree build_anon_union_vars (tree); |
69 | static bool acceptable_java_type (tree); | |
848eed92 GDR |
70 | static tree start_objects (int, int); |
71 | static void finish_objects (int, int, tree); | |
299f79b5 | 72 | static tree start_static_storage_duration_function (unsigned); |
848eed92 GDR |
73 | static void finish_static_storage_duration_function (tree); |
74 | static priority_info get_priority_info (int); | |
75 | static void do_static_initialization (tree, tree); | |
76 | static void do_static_destruction (tree); | |
77 | static tree start_static_initialization_or_destruction (tree, int); | |
78 | static void finish_static_initialization_or_destruction (tree); | |
299f79b5 | 79 | static void generate_ctor_or_dtor_function (bool, int, location_t *); |
848eed92 GDR |
80 | static int generate_ctor_and_dtor_functions_for_priority (splay_tree_node, |
81 | void *); | |
cec24319 | 82 | static tree prune_vars_needing_no_initialization (tree *); |
848eed92 GDR |
83 | static void write_out_vars (tree); |
84 | static void import_export_class (tree); | |
848eed92 | 85 | static tree get_guard_bits (tree); |
313bc2c2 | 86 | |
8d08fdba MS |
87 | /* A list of static class variables. This is needed, because a |
88 | static class variable can be declared inside the class without | |
306ef644 | 89 | an initializer, and then initialized, statically, outside the class. */ |
e2500fed | 90 | static GTY(()) varray_type pending_statics; |
2c0f17dc MM |
91 | #define pending_statics_used \ |
92 | (pending_statics ? pending_statics->elements_used : 0) | |
8d08fdba | 93 | |
8926095f | 94 | /* A list of functions which were declared inline, but which we |
e92cc029 | 95 | may need to emit outline anyway. */ |
e2500fed | 96 | static GTY(()) varray_type deferred_fns; |
56e770bf MM |
97 | #define deferred_fns_used \ |
98 | (deferred_fns ? deferred_fns->elements_used : 0) | |
8d08fdba | 99 | |
51c184be | 100 | /* Flag used when debugging spew.c */ |
8d08fdba MS |
101 | |
102 | extern int spew_debug; | |
e1cd6e56 | 103 | |
5566b478 MS |
104 | /* Nonzero if we're done parsing and into end-of-file activities. */ |
105 | ||
106 | int at_eof; | |
107 | ||
e1cd6e56 MS |
108 | /* Functions called along with real static constructors and destructors. */ |
109 | ||
f444e36b MM |
110 | tree static_ctors; |
111 | tree static_dtors; | |
30394414 | 112 | |
8d08fdba | 113 | \f |
8d08fdba MS |
114 | /* Incorporate `const' and `volatile' qualifiers for member functions. |
115 | FUNCTION is a TYPE_DECL or a FUNCTION_DECL. | |
535233a8 NS |
116 | QUALS is a list of qualifiers. Returns any explicit |
117 | top-level qualifiers of the method's this pointer, anything other than | |
118 | TYPE_UNQUALIFIED will be an extension. */ | |
e92cc029 | 119 | |
535233a8 | 120 | int |
3c01e5df | 121 | grok_method_quals (tree ctype, tree function, cp_cv_quals quals) |
8d08fdba MS |
122 | { |
123 | tree fntype = TREE_TYPE (function); | |
124 | tree raises = TYPE_RAISES_EXCEPTIONS (fntype); | |
91063b51 | 125 | int type_quals = TYPE_UNQUALIFIED; |
535233a8 | 126 | int this_quals = TYPE_UNQUALIFIED; |
8d08fdba | 127 | |
3c01e5df MM |
128 | type_quals = quals & ~TYPE_QUAL_RESTRICT; |
129 | this_quals = quals & TYPE_QUAL_RESTRICT; | |
91063b51 MM |
130 | |
131 | ctype = cp_build_qualified_type (ctype, type_quals); | |
43dc123f MM |
132 | fntype = build_method_type_directly (ctype, TREE_TYPE (fntype), |
133 | (TREE_CODE (fntype) == METHOD_TYPE | |
134 | ? TREE_CHAIN (TYPE_ARG_TYPES (fntype)) | |
135 | : TYPE_ARG_TYPES (fntype))); | |
8d08fdba | 136 | if (raises) |
f30432d7 | 137 | fntype = build_exception_variant (fntype, raises); |
8d08fdba MS |
138 | |
139 | TREE_TYPE (function) = fntype; | |
535233a8 | 140 | return this_quals; |
8d08fdba MS |
141 | } |
142 | ||
8e51619a JM |
143 | /* Build a PARM_DECL with NAME and TYPE, and set DECL_ARG_TYPE |
144 | appropriately. */ | |
145 | ||
146 | tree | |
848eed92 | 147 | cp_build_parm_decl (tree name, tree type) |
8e51619a JM |
148 | { |
149 | tree parm = build_decl (PARM_DECL, name, type); | |
560ad596 MM |
150 | /* DECL_ARG_TYPE is only used by the back end and the back end never |
151 | sees templates. */ | |
152 | if (!processing_template_decl) | |
153 | DECL_ARG_TYPE (parm) = type_passed_as (type); | |
8e51619a JM |
154 | return parm; |
155 | } | |
156 | ||
3ec6bad3 MM |
157 | /* Returns a PARM_DECL for a parameter of the indicated TYPE, with the |
158 | indicated NAME. */ | |
159 | ||
160 | tree | |
848eed92 | 161 | build_artificial_parm (tree name, tree type) |
3ec6bad3 | 162 | { |
8e51619a | 163 | tree parm = cp_build_parm_decl (name, type); |
c727aa5e | 164 | DECL_ARTIFICIAL (parm) = 1; |
a714e5c5 JM |
165 | /* All our artificial parms are implicitly `const'; they cannot be |
166 | assigned to. */ | |
167 | TREE_READONLY (parm) = 1; | |
3ec6bad3 MM |
168 | return parm; |
169 | } | |
170 | ||
711734a9 JM |
171 | /* Constructors for types with virtual baseclasses need an "in-charge" flag |
172 | saying whether this constructor is responsible for initialization of | |
173 | virtual baseclasses or not. All destructors also need this "in-charge" | |
174 | flag, which additionally determines whether or not the destructor should | |
175 | free the memory for the object. | |
176 | ||
177 | This function adds the "in-charge" flag to member function FN if | |
178 | appropriate. It is called from grokclassfn and tsubst. | |
e0fff4b3 JM |
179 | FN must be either a constructor or destructor. |
180 | ||
181 | The in-charge flag follows the 'this' parameter, and is followed by the | |
182 | VTT parm (if any), then the user-written parms. */ | |
711734a9 JM |
183 | |
184 | void | |
848eed92 | 185 | maybe_retrofit_in_chrg (tree fn) |
711734a9 JM |
186 | { |
187 | tree basetype, arg_types, parms, parm, fntype; | |
188 | ||
454fa7a7 MM |
189 | /* If we've already add the in-charge parameter don't do it again. */ |
190 | if (DECL_HAS_IN_CHARGE_PARM_P (fn)) | |
711734a9 JM |
191 | return; |
192 | ||
212e7048 MM |
193 | /* When processing templates we can't know, in general, whether or |
194 | not we're going to have virtual baseclasses. */ | |
c353b8e3 | 195 | if (processing_template_decl) |
212e7048 MM |
196 | return; |
197 | ||
454fa7a7 MM |
198 | /* We don't need an in-charge parameter for constructors that don't |
199 | have virtual bases. */ | |
200 | if (DECL_CONSTRUCTOR_P (fn) | |
201 | && !TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn))) | |
202 | return; | |
711734a9 | 203 | |
711734a9 JM |
204 | arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn)); |
205 | basetype = TREE_TYPE (TREE_VALUE (arg_types)); | |
e0fff4b3 JM |
206 | arg_types = TREE_CHAIN (arg_types); |
207 | ||
208 | parms = TREE_CHAIN (DECL_ARGUMENTS (fn)); | |
209 | ||
210 | /* If this is a subobject constructor or destructor, our caller will | |
211 | pass us a pointer to our VTT. */ | |
212 | if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn))) | |
213 | { | |
214 | parm = build_artificial_parm (vtt_parm_identifier, vtt_parm_type); | |
215 | ||
216 | /* First add it to DECL_ARGUMENTS between 'this' and the real args... */ | |
217 | TREE_CHAIN (parm) = parms; | |
218 | parms = parm; | |
219 | ||
220 | /* ...and then to TYPE_ARG_TYPES. */ | |
221 | arg_types = hash_tree_chain (vtt_parm_type, arg_types); | |
222 | ||
223 | DECL_HAS_VTT_PARM_P (fn) = 1; | |
224 | } | |
225 | ||
226 | /* Then add the in-charge parm (before the VTT parm). */ | |
227 | parm = build_artificial_parm (in_charge_identifier, integer_type_node); | |
228 | TREE_CHAIN (parm) = parms; | |
229 | parms = parm; | |
230 | arg_types = hash_tree_chain (integer_type_node, arg_types); | |
231 | ||
232 | /* Insert our new parameter(s) into the list. */ | |
233 | TREE_CHAIN (DECL_ARGUMENTS (fn)) = parms; | |
234 | ||
235 | /* And rebuild the function type. */ | |
43dc123f MM |
236 | fntype = build_method_type_directly (basetype, TREE_TYPE (TREE_TYPE (fn)), |
237 | arg_types); | |
711734a9 JM |
238 | if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))) |
239 | fntype = build_exception_variant (fntype, | |
240 | TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))); | |
241 | TREE_TYPE (fn) = fntype; | |
454fa7a7 MM |
242 | |
243 | /* Now we've got the in-charge parameter. */ | |
244 | DECL_HAS_IN_CHARGE_PARM_P (fn) = 1; | |
711734a9 JM |
245 | } |
246 | ||
8d08fdba MS |
247 | /* Classes overload their constituent function names automatically. |
248 | When a function name is declared in a record structure, | |
249 | its name is changed to it overloaded name. Since names for | |
250 | constructors and destructors can conflict, we place a leading | |
251 | '$' for destructors. | |
252 | ||
253 | CNAME is the name of the class we are grokking for. | |
254 | ||
255 | FUNCTION is a FUNCTION_DECL. It was created by `grokdeclarator'. | |
256 | ||
257 | FLAGS contains bits saying what's special about today's | |
258 | arguments. 1 == DESTRUCTOR. 2 == OPERATOR. | |
259 | ||
260 | If FUNCTION is a destructor, then we must add the `auto-delete' field | |
261 | as a second parameter. There is some hair associated with the fact | |
262 | that we must "declare" this variable in the manner consistent with the | |
263 | way the rest of the arguments were declared. | |
264 | ||
265 | QUALS are the qualifiers for the this pointer. */ | |
266 | ||
267 | void | |
3c01e5df MM |
268 | grokclassfn (tree ctype, tree function, enum overload_flags flags, |
269 | cp_cv_quals quals) | |
8d08fdba MS |
270 | { |
271 | tree fn_name = DECL_NAME (function); | |
3c01e5df | 272 | cp_cv_quals this_quals = TYPE_UNQUALIFIED; |
8d08fdba | 273 | |
cab8bde9 MM |
274 | /* Even within an `extern "C"' block, members get C++ linkage. See |
275 | [dcl.link] for details. */ | |
5d2ed28c | 276 | SET_DECL_LANGUAGE (function, lang_cplusplus); |
cab8bde9 | 277 | |
8d08fdba MS |
278 | if (fn_name == NULL_TREE) |
279 | { | |
8251199e | 280 | error ("name missing for member function"); |
8d08fdba MS |
281 | fn_name = get_identifier ("<anonymous>"); |
282 | DECL_NAME (function) = fn_name; | |
283 | } | |
284 | ||
285 | if (quals) | |
535233a8 | 286 | this_quals = grok_method_quals (ctype, function, quals); |
8d08fdba | 287 | |
8d08fdba MS |
288 | if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE) |
289 | { | |
290 | /* Must add the class instance variable up front. */ | |
291 | /* Right now we just make this a pointer. But later | |
292 | we may wish to make it special. */ | |
535233a8 | 293 | tree type = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (function))); |
bedda2da MM |
294 | tree qual_type; |
295 | tree parm; | |
296 | ||
297 | /* The `this' parameter is implicitly `const'; it cannot be | |
298 | assigned to. */ | |
299 | this_quals |= TYPE_QUAL_CONST; | |
300 | qual_type = cp_build_qualified_type (type, this_quals); | |
3ec6bad3 | 301 | parm = build_artificial_parm (this_identifier, qual_type); |
bedda2da | 302 | c_apply_type_quals_to_decl (this_quals, parm); |
4546865e MM |
303 | TREE_CHAIN (parm) = DECL_ARGUMENTS (function); |
304 | DECL_ARGUMENTS (function) = parm; | |
8d08fdba MS |
305 | } |
306 | ||
711734a9 | 307 | DECL_CONTEXT (function) = ctype; |
711734a9 | 308 | |
92643fea MM |
309 | if (flags == DTOR_FLAG) |
310 | DECL_DESTRUCTOR_P (function) = 1; | |
311 | ||
711734a9 | 312 | if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function)) |
535233a8 | 313 | maybe_retrofit_in_chrg (function); |
8d08fdba MS |
314 | } |
315 | ||
8d08fdba MS |
316 | /* Create an ARRAY_REF, checking for the user doing things backwards |
317 | along the way. */ | |
e92cc029 | 318 | |
8d08fdba | 319 | tree |
848eed92 | 320 | grok_array_decl (tree array_expr, tree index_exp) |
8d08fdba | 321 | { |
d17811fd MM |
322 | tree type; |
323 | tree expr; | |
324 | tree orig_array_expr = array_expr; | |
325 | tree orig_index_exp = index_exp; | |
8d08fdba | 326 | |
d17811fd | 327 | if (error_operand_p (array_expr) || error_operand_p (index_exp)) |
8d08fdba | 328 | return error_mark_node; |
d17811fd | 329 | |
5156628f | 330 | if (processing_template_decl) |
d17811fd MM |
331 | { |
332 | if (type_dependent_expression_p (array_expr) | |
333 | || type_dependent_expression_p (index_exp)) | |
44de5aeb RK |
334 | return build_min_nt (ARRAY_REF, array_expr, index_exp, |
335 | NULL_TREE, NULL_TREE); | |
d17811fd MM |
336 | array_expr = build_non_dependent_expr (array_expr); |
337 | index_exp = build_non_dependent_expr (index_exp); | |
338 | } | |
5566b478 | 339 | |
d17811fd | 340 | type = TREE_TYPE (array_expr); |
8d245821 | 341 | my_friendly_assert (type, 20030626); |
ee76b931 | 342 | type = non_reference (type); |
8d08fdba MS |
343 | |
344 | /* If they have an `operator[]', use that. */ | |
3c215895 | 345 | if (IS_AGGR_TYPE (type) || IS_AGGR_TYPE (TREE_TYPE (index_exp))) |
d17811fd | 346 | expr = build_new_op (ARRAY_REF, LOOKUP_NORMAL, |
ec835fb2 MM |
347 | array_expr, index_exp, NULL_TREE, |
348 | /*overloaded_p=*/NULL); | |
b7484fbe | 349 | else |
d17811fd MM |
350 | { |
351 | tree p1, p2, i1, i2; | |
8d08fdba | 352 | |
d17811fd MM |
353 | /* Otherwise, create an ARRAY_REF for a pointer or array type. |
354 | It is a little-known fact that, if `a' is an array and `i' is | |
355 | an int, you can write `i[a]', which means the same thing as | |
356 | `a[i]'. */ | |
357 | if (TREE_CODE (type) == ARRAY_TYPE) | |
358 | p1 = array_expr; | |
359 | else | |
360 | p1 = build_expr_type_conversion (WANT_POINTER, array_expr, false); | |
361 | ||
362 | if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE) | |
363 | p2 = index_exp; | |
364 | else | |
365 | p2 = build_expr_type_conversion (WANT_POINTER, index_exp, false); | |
8d08fdba | 366 | |
d17811fd MM |
367 | i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr, |
368 | false); | |
369 | i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp, | |
370 | false); | |
8d08fdba | 371 | |
d17811fd MM |
372 | if ((p1 && i2) && (i1 && p2)) |
373 | error ("ambiguous conversion for array subscript"); | |
8d08fdba | 374 | |
d17811fd MM |
375 | if (p1 && i2) |
376 | array_expr = p1, index_exp = i2; | |
377 | else if (i1 && p2) | |
378 | array_expr = p2, index_exp = i1; | |
379 | else | |
380 | { | |
381 | error ("invalid types `%T[%T]' for array subscript", | |
382 | type, TREE_TYPE (index_exp)); | |
383 | return error_mark_node; | |
384 | } | |
b7484fbe | 385 | |
d17811fd MM |
386 | if (array_expr == error_mark_node || index_exp == error_mark_node) |
387 | error ("ambiguous conversion for array subscript"); | |
b7484fbe | 388 | |
d17811fd MM |
389 | expr = build_array_ref (array_expr, index_exp); |
390 | } | |
391 | if (processing_template_decl && expr != error_mark_node) | |
44de5aeb RK |
392 | return build_min_non_dep (ARRAY_REF, expr, orig_array_expr, orig_index_exp, |
393 | NULL_TREE, NULL_TREE); | |
d17811fd | 394 | return expr; |
8d08fdba MS |
395 | } |
396 | ||
397 | /* Given the cast expression EXP, checking out its validity. Either return | |
398 | an error_mark_node if there was an unavoidable error, return a cast to | |
399 | void for trying to delete a pointer w/ the value 0, or return the | |
0e8c9b28 MM |
400 | call to delete. If DOING_VEC is true, we handle things differently |
401 | for doing an array delete. | |
8d08fdba | 402 | Implements ARM $5.3.4. This is called from the parser. */ |
e92cc029 | 403 | |
8d08fdba | 404 | tree |
0e8c9b28 | 405 | delete_sanity (tree exp, tree size, bool doing_vec, int use_global_delete) |
8d08fdba | 406 | { |
02020185 | 407 | tree t, type; |
5566b478 | 408 | |
909e536a MS |
409 | if (exp == error_mark_node) |
410 | return exp; | |
411 | ||
5156628f | 412 | if (processing_template_decl) |
5566b478 MS |
413 | { |
414 | t = build_min (DELETE_EXPR, void_type_node, exp, size); | |
415 | DELETE_EXPR_USE_GLOBAL (t) = use_global_delete; | |
416 | DELETE_EXPR_USE_VEC (t) = doing_vec; | |
c1cca8d4 | 417 | TREE_SIDE_EFFECTS (t) = 1; |
5566b478 MS |
418 | return t; |
419 | } | |
420 | ||
02020185 | 421 | exp = convert_from_reference (exp); |
0e8c9b28 MM |
422 | |
423 | /* An array can't have been allocated by new, so complain. */ | |
424 | if (TREE_CODE (exp) == VAR_DECL | |
425 | && TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE) | |
426 | warning ("deleting array `%#D'", exp); | |
427 | ||
49b7aacb | 428 | t = build_expr_type_conversion (WANT_POINTER, exp, true); |
8d08fdba | 429 | |
02020185 | 430 | if (t == NULL_TREE || t == error_mark_node) |
8d08fdba | 431 | { |
33bd39a2 | 432 | error ("type `%#T' argument given to `delete', expected pointer", |
02020185 JM |
433 | TREE_TYPE (exp)); |
434 | return error_mark_node; | |
8d08fdba MS |
435 | } |
436 | ||
02020185 JM |
437 | type = TREE_TYPE (t); |
438 | ||
439 | /* As of Valley Forge, you can delete a pointer to const. */ | |
440 | ||
441 | /* You can't delete functions. */ | |
442 | if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE) | |
8926095f | 443 | { |
cb9a3ff8 | 444 | error ("cannot delete a function. Only pointer-to-objects are valid arguments to `delete'"); |
02020185 | 445 | return error_mark_node; |
8926095f | 446 | } |
02020185 | 447 | |
838dfd8a | 448 | /* Deleting ptr to void is undefined behavior [expr.delete/3]. */ |
7f477e81 | 449 | if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE) |
655dc6ee | 450 | { |
33bd39a2 | 451 | warning ("deleting `%T' is undefined", type); |
655dc6ee JM |
452 | doing_vec = 0; |
453 | } | |
454 | ||
02020185 JM |
455 | /* Deleting a pointer with the value zero is valid and has no effect. */ |
456 | if (integer_zerop (t)) | |
457 | return build1 (NOP_EXPR, void_type_node, t); | |
8d08fdba MS |
458 | |
459 | if (doing_vec) | |
0e8c9b28 MM |
460 | return build_vec_delete (t, /*maxindex=*/NULL_TREE, |
461 | sfk_deleting_destructor, | |
86f45d2c | 462 | use_global_delete); |
8d08fdba | 463 | else |
e3fe84e5 JM |
464 | return build_delete (type, t, sfk_deleting_destructor, |
465 | LOOKUP_NORMAL, use_global_delete); | |
8d08fdba MS |
466 | } |
467 | ||
98c1c668 JM |
468 | /* Report an error if the indicated template declaration is not the |
469 | sort of thing that should be a member template. */ | |
470 | ||
471 | void | |
848eed92 | 472 | check_member_template (tree tmpl) |
98c1c668 JM |
473 | { |
474 | tree decl; | |
475 | ||
476 | my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0); | |
477 | decl = DECL_TEMPLATE_RESULT (tmpl); | |
478 | ||
1701f21e MM |
479 | if (TREE_CODE (decl) == FUNCTION_DECL |
480 | || (TREE_CODE (decl) == TYPE_DECL | |
481 | && IS_AGGR_TYPE (TREE_TYPE (decl)))) | |
98c1c668 JM |
482 | { |
483 | if (current_function_decl) | |
484 | /* 14.5.2.2 [temp.mem] | |
485 | ||
a1c65f9f | 486 | A local class shall not have member templates. */ |
33bd39a2 | 487 | error ("invalid declaration of member template `%#D' in local class", |
98c1c668 JM |
488 | decl); |
489 | ||
1701f21e | 490 | if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl)) |
98c1c668 JM |
491 | { |
492 | /* 14.5.2.3 [temp.mem] | |
493 | ||
494 | A member function template shall not be virtual. */ | |
33bd39a2 | 495 | error |
8251199e | 496 | ("invalid use of `virtual' in template declaration of `%#D'", |
98c1c668 JM |
497 | decl); |
498 | DECL_VIRTUAL_P (decl) = 0; | |
499 | } | |
500 | ||
501 | /* The debug-information generating code doesn't know what to do | |
502 | with member templates. */ | |
503 | DECL_IGNORED_P (tmpl) = 1; | |
504 | } | |
98c1c668 | 505 | else |
33bd39a2 | 506 | error ("template declaration of `%#D'", decl); |
98c1c668 JM |
507 | } |
508 | ||
a1c65f9f | 509 | /* Return true iff TYPE is a valid Java parameter or return type. */ |
eff71ab0 | 510 | |
848eed92 GDR |
511 | static bool |
512 | acceptable_java_type (tree type) | |
eff71ab0 PB |
513 | { |
514 | if (TREE_CODE (type) == VOID_TYPE || TYPE_FOR_JAVA (type)) | |
515 | return 1; | |
23d4e4cc | 516 | if (TREE_CODE (type) == POINTER_TYPE || TREE_CODE (type) == REFERENCE_TYPE) |
eff71ab0 PB |
517 | { |
518 | type = TREE_TYPE (type); | |
519 | if (TREE_CODE (type) == RECORD_TYPE) | |
520 | { | |
824f42ab PB |
521 | tree args; int i; |
522 | if (! TYPE_FOR_JAVA (type)) | |
848eed92 | 523 | return false; |
824f42ab | 524 | if (! CLASSTYPE_TEMPLATE_INFO (type)) |
848eed92 | 525 | return true; |
824f42ab PB |
526 | args = CLASSTYPE_TI_ARGS (type); |
527 | i = TREE_VEC_LENGTH (args); | |
528 | while (--i >= 0) | |
529 | { | |
530 | type = TREE_VEC_ELT (args, i); | |
531 | if (TREE_CODE (type) == POINTER_TYPE) | |
532 | type = TREE_TYPE (type); | |
533 | if (! TYPE_FOR_JAVA (type)) | |
848eed92 | 534 | return false; |
824f42ab | 535 | } |
848eed92 | 536 | return true; |
eff71ab0 PB |
537 | } |
538 | } | |
848eed92 | 539 | return false; |
eff71ab0 PB |
540 | } |
541 | ||
848eed92 | 542 | /* For a METHOD in a Java class CTYPE, return true if |
eff71ab0 | 543 | the parameter and return types are valid Java types. |
848eed92 | 544 | Otherwise, print appropriate error messages, and return false. */ |
eff71ab0 | 545 | |
848eed92 GDR |
546 | bool |
547 | check_java_method (tree method) | |
eff71ab0 | 548 | { |
848eed92 | 549 | bool jerr = false; |
eff71ab0 PB |
550 | tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method)); |
551 | tree ret_type = TREE_TYPE (TREE_TYPE (method)); | |
f5c28a15 | 552 | |
848eed92 | 553 | if (!acceptable_java_type (ret_type)) |
eff71ab0 | 554 | { |
33bd39a2 | 555 | error ("Java method '%D' has non-Java return type `%T'", |
eff71ab0 | 556 | method, ret_type); |
848eed92 | 557 | jerr = true; |
eff71ab0 | 558 | } |
f5c28a15 NS |
559 | |
560 | arg_types = TREE_CHAIN (arg_types); | |
561 | if (DECL_HAS_IN_CHARGE_PARM_P (method)) | |
562 | arg_types = TREE_CHAIN (arg_types); | |
563 | if (DECL_HAS_VTT_PARM_P (method)) | |
564 | arg_types = TREE_CHAIN (arg_types); | |
565 | ||
eff71ab0 PB |
566 | for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types)) |
567 | { | |
568 | tree type = TREE_VALUE (arg_types); | |
848eed92 | 569 | if (!acceptable_java_type (type)) |
eff71ab0 | 570 | { |
33bd39a2 | 571 | error ("Java method '%D' has non-Java parameter type `%T'", |
eff71ab0 | 572 | method, type); |
848eed92 | 573 | jerr = true; |
eff71ab0 PB |
574 | } |
575 | } | |
848eed92 | 576 | return !jerr; |
eff71ab0 PB |
577 | } |
578 | ||
8d08fdba MS |
579 | /* Sanity check: report error if this function FUNCTION is not |
580 | really a member of the class (CTYPE) it is supposed to belong to. | |
44021471 GB |
581 | TEMPLATE_PARMS is used to specifiy the template parameters of a member |
582 | template passed as FUNCTION_DECL. If the member template is passed as a | |
583 | TEMPLATE_DECL, it can be NULL since the parameters can be extracted | |
584 | from the declaration. If the function is not a function template, it | |
585 | must be NULL. | |
586 | It returns the original declaration for the function, or NULL_TREE | |
587 | if no declaration was found (and an error was emitted). */ | |
8d08fdba | 588 | |
f30432d7 | 589 | tree |
44021471 | 590 | check_classfn (tree ctype, tree function, tree template_parms) |
8d08fdba | 591 | { |
b9201622 | 592 | int ix; |
44021471 | 593 | bool is_template; |
03017874 MM |
594 | |
595 | if (DECL_USE_TEMPLATE (function) | |
74b846e0 MM |
596 | && !(TREE_CODE (function) == TEMPLATE_DECL |
597 | && DECL_TEMPLATE_SPECIALIZATION (function)) | |
03017874 MM |
598 | && is_member_template (DECL_TI_TEMPLATE (function))) |
599 | /* Since this is a specialization of a member template, | |
600 | we're not going to find the declaration in the class. | |
601 | For example, in: | |
602 | ||
603 | struct S { template <typename T> void f(T); }; | |
604 | template <> void S::f(int); | |
605 | ||
606 | we're not going to find `S::f(int)', but there's no | |
607 | reason we should, either. We let our callers know we didn't | |
608 | find the method, but we don't complain. */ | |
609 | return NULL_TREE; | |
b9201622 | 610 | |
44021471 GB |
611 | /* Basic sanity check: for a template function, the template parameters |
612 | either were not passed, or they are the same of DECL_TEMPLATE_PARMS. */ | |
613 | if (TREE_CODE (function) == TEMPLATE_DECL) | |
614 | { | |
615 | my_friendly_assert (!template_parms | |
616 | || comp_template_parms | |
617 | (template_parms, | |
618 | DECL_TEMPLATE_PARMS (function)), | |
619 | 20040303); | |
620 | template_parms = DECL_TEMPLATE_PARMS (function); | |
621 | } | |
622 | ||
5b8e011c | 623 | /* OK, is this a definition of a member template? */ |
44021471 | 624 | is_template = (template_parms != NULL_TREE); |
5b8e011c | 625 | |
b9201622 NS |
626 | ix = lookup_fnfields_1 (complete_type (ctype), |
627 | DECL_CONSTRUCTOR_P (function) ? ctor_identifier : | |
628 | DECL_DESTRUCTOR_P (function) ? dtor_identifier : | |
629 | DECL_NAME (function)); | |
630 | ||
631 | if (ix >= 0) | |
8d08fdba | 632 | { |
aaaa46d2 | 633 | VEC(tree) *methods = CLASSTYPE_METHOD_VEC (ctype); |
dd1b7476 | 634 | tree fndecls, fndecl = 0; |
b9201622 | 635 | bool is_conv_op; |
91b004e5 | 636 | bool pop_p; |
b9201622 NS |
637 | const char *format = NULL; |
638 | ||
91b004e5 | 639 | pop_p = push_scope (ctype); |
aaaa46d2 | 640 | for (fndecls = VEC_index (tree, methods, ix); |
b9201622 NS |
641 | fndecls; fndecls = OVL_NEXT (fndecls)) |
642 | { | |
643 | tree p1, p2; | |
644 | ||
645 | fndecl = OVL_CURRENT (fndecls); | |
646 | p1 = TYPE_ARG_TYPES (TREE_TYPE (function)); | |
647 | p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl)); | |
648 | ||
649 | /* We cannot simply call decls_match because this doesn't | |
650 | work for static member functions that are pretending to | |
651 | be methods, and because the name may have been changed by | |
652 | asm("new_name"). */ | |
653 | ||
654 | /* Get rid of the this parameter on functions that become | |
655 | static. */ | |
656 | if (DECL_STATIC_FUNCTION_P (fndecl) | |
657 | && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE) | |
658 | p1 = TREE_CHAIN (p1); | |
5b8e011c JM |
659 | |
660 | /* A member template definition only matches a member template | |
661 | declaration. */ | |
662 | if (is_template != (TREE_CODE (fndecl) == TEMPLATE_DECL)) | |
663 | continue; | |
b9201622 NS |
664 | |
665 | if (same_type_p (TREE_TYPE (TREE_TYPE (function)), | |
666 | TREE_TYPE (TREE_TYPE (fndecl))) | |
667 | && compparms (p1, p2) | |
44021471 GB |
668 | && (!is_template |
669 | || comp_template_parms (template_parms, | |
670 | DECL_TEMPLATE_PARMS (fndecl))) | |
b9201622 NS |
671 | && (DECL_TEMPLATE_SPECIALIZATION (function) |
672 | == DECL_TEMPLATE_SPECIALIZATION (fndecl)) | |
673 | && (!DECL_TEMPLATE_SPECIALIZATION (function) | |
674 | || (DECL_TI_TEMPLATE (function) | |
675 | == DECL_TI_TEMPLATE (fndecl)))) | |
14d22dd6 | 676 | break; |
b9201622 | 677 | } |
91b004e5 MM |
678 | if (pop_p) |
679 | pop_scope (ctype); | |
14d22dd6 MM |
680 | if (fndecls) |
681 | return OVL_CURRENT (fndecls); | |
b9201622 NS |
682 | error ("prototype for `%#D' does not match any in class `%T'", |
683 | function, ctype); | |
684 | is_conv_op = DECL_CONV_FN_P (fndecl); | |
685 | ||
686 | if (is_conv_op) | |
687 | ix = CLASSTYPE_FIRST_CONVERSION_SLOT; | |
aaaa46d2 | 688 | fndecls = VEC_index (tree, methods, ix); |
b9201622 | 689 | while (fndecls) |
8d08fdba | 690 | { |
b9201622 NS |
691 | fndecl = OVL_CURRENT (fndecls); |
692 | fndecls = OVL_NEXT (fndecls); | |
693 | ||
694 | if (!fndecls && is_conv_op) | |
8d08fdba | 695 | { |
508a1c9c | 696 | if (VEC_length (tree, methods) > (size_t) ++ix) |
8d08fdba | 697 | { |
aaaa46d2 | 698 | fndecls = VEC_index (tree, methods, ix); |
b9201622 | 699 | if (!DECL_CONV_FN_P (OVL_CURRENT (fndecls))) |
8145f082 | 700 | { |
b9201622 NS |
701 | fndecls = NULL_TREE; |
702 | is_conv_op = false; | |
8145f082 | 703 | } |
8d08fdba | 704 | } |
b9201622 NS |
705 | else |
706 | is_conv_op = false; | |
8d08fdba | 707 | } |
b9201622 NS |
708 | if (format) |
709 | format = " %#D"; | |
710 | else if (fndecls) | |
711 | format = "candidates are: %#D"; | |
712 | else | |
713 | format = "candidate is: %#D"; | |
714 | cp_error_at (format, fndecl); | |
8d08fdba MS |
715 | } |
716 | } | |
b9201622 NS |
717 | else if (!COMPLETE_TYPE_P (ctype)) |
718 | cxx_incomplete_type_error (function, ctype); | |
8d08fdba | 719 | else |
b9201622 NS |
720 | error ("no `%#D' member function declared in class `%T'", |
721 | function, ctype); | |
8d08fdba | 722 | |
fc378698 | 723 | /* If we did not find the method in the class, add it to avoid |
6b4b3deb MM |
724 | spurious errors (unless the CTYPE is not yet defined, in which |
725 | case we'll only confuse ourselves when the function is declared | |
726 | properly within the class. */ | |
d0f062fb | 727 | if (COMPLETE_TYPE_P (ctype)) |
aaaa46d2 | 728 | add_method (ctype, function); |
f30432d7 | 729 | return NULL_TREE; |
8d08fdba MS |
730 | } |
731 | ||
fa8d6e85 MM |
732 | /* We have just processed the DECL, which is a static data member. |
733 | Its initializer, if present, is INIT. The ASMSPEC_TREE, if | |
734 | present, is the assembly-language name for the data member. | |
cd9f6678 | 735 | FLAGS is as for cp_finish_decl. */ |
fa8d6e85 MM |
736 | |
737 | void | |
848eed92 GDR |
738 | finish_static_data_member_decl (tree decl, tree init, tree asmspec_tree, |
739 | int flags) | |
fa8d6e85 | 740 | { |
fa8d6e85 MM |
741 | my_friendly_assert (TREE_PUBLIC (decl), 0); |
742 | ||
1f6e1acc AS |
743 | DECL_CONTEXT (decl) = current_class_type; |
744 | ||
fa8d6e85 | 745 | /* We cannot call pushdecl here, because that would fill in the |
46ccf50a | 746 | TREE_CHAIN of our decl. Instead, we modify cp_finish_decl to do |
fa8d6e85 MM |
747 | the right thing, namely, to put this decl out straight away. */ |
748 | /* current_class_type can be NULL_TREE in case of error. */ | |
92643fea MM |
749 | if (!asmspec_tree && current_class_type) |
750 | DECL_INITIAL (decl) = error_mark_node; | |
751 | ||
fa8d6e85 | 752 | if (! processing_template_decl) |
0aafb128 MM |
753 | { |
754 | if (!pending_statics) | |
755 | VARRAY_TREE_INIT (pending_statics, 32, "pending_statics"); | |
2c0f17dc | 756 | VARRAY_PUSH_TREE (pending_statics, decl); |
0aafb128 MM |
757 | } |
758 | ||
65f36ac8 JM |
759 | if (LOCAL_CLASS_P (current_class_type)) |
760 | pedwarn ("local class `%#T' shall not have static data member `%#D'", | |
761 | current_class_type, decl); | |
762 | ||
fa8d6e85 MM |
763 | /* Static consts need not be initialized in the class definition. */ |
764 | if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))) | |
765 | { | |
b1ce3eb2 | 766 | static int explained = 0; |
fa8d6e85 MM |
767 | |
768 | error ("initializer invalid for static member with constructor"); | |
b1ce3eb2 NS |
769 | if (!explained) |
770 | { | |
771 | error ("(an out of class initialization is required)"); | |
772 | explained = 1; | |
773 | } | |
774 | init = NULL_TREE; | |
fa8d6e85 MM |
775 | } |
776 | /* Force the compiler to know when an uninitialized static const | |
777 | member is being used. */ | |
778 | if (CP_TYPE_CONST_P (TREE_TYPE (decl)) && init == 0) | |
779 | TREE_USED (decl) = 1; | |
780 | DECL_INITIAL (decl) = init; | |
781 | DECL_IN_AGGR_P (decl) = 1; | |
fa8d6e85 | 782 | |
cd9f6678 | 783 | cp_finish_decl (decl, init, asmspec_tree, flags); |
fa8d6e85 MM |
784 | } |
785 | ||
8d08fdba | 786 | /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted) |
5c1e5476 | 787 | of a structure component, returning a _DECL node. |
8d08fdba MS |
788 | QUALS is a list of type qualifiers for this decl (such as for declaring |
789 | const member functions). | |
790 | ||
791 | This is done during the parsing of the struct declaration. | |
5c1e5476 | 792 | The _DECL nodes are chained together and the lot of them |
8d08fdba MS |
793 | are ultimately passed to `build_struct' to make the RECORD_TYPE node. |
794 | ||
8d08fdba MS |
795 | If class A defines that certain functions in class B are friends, then |
796 | the way I have set things up, it is B who is interested in permission | |
797 | granted by A. However, it is in A's context that these declarations | |
798 | are parsed. By returning a void_type_node, class A does not attempt | |
799 | to incorporate the declarations of the friends within its structure. | |
800 | ||
801 | DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING | |
802 | CHANGES TO CODE IN `start_method'. */ | |
803 | ||
804 | tree | |
62d1db17 MM |
805 | grokfield (const cp_declarator *declarator, |
806 | cp_decl_specifier_seq *declspecs, | |
058b15c1 | 807 | tree init, tree asmspec_tree, |
848eed92 | 808 | tree attrlist) |
8d08fdba | 809 | { |
59387d2e | 810 | tree value; |
9c0758dd | 811 | const char *asmspec = 0; |
6060a796 | 812 | int flags = LOOKUP_ONLYCONVERTING; |
8d08fdba | 813 | |
62d1db17 | 814 | if (!declspecs->any_specifiers_p |
058b15c1 MM |
815 | && declarator->kind == cdk_id |
816 | && TREE_CODE (declarator->u.id.name) == SCOPE_REF | |
817 | && (TREE_CODE (TREE_OPERAND (declarator->u.id.name, 1)) | |
818 | == IDENTIFIER_NODE)) | |
cffa8729 MS |
819 | { |
820 | /* Access declaration */ | |
058b15c1 MM |
821 | if (! IS_AGGR_TYPE_CODE (TREE_CODE |
822 | (TREE_OPERAND (declarator->u.id.name, 0)))) | |
5566b478 | 823 | ; |
058b15c1 | 824 | else if (TREE_COMPLEXITY (declarator->u.id.name) == current_class_depth) |
b74a0560 | 825 | pop_nested_class (); |
058b15c1 | 826 | return do_class_using_decl (declarator->u.id.name); |
cffa8729 MS |
827 | } |
828 | ||
8d08fdba MS |
829 | if (init |
830 | && TREE_CODE (init) == TREE_LIST | |
831 | && TREE_VALUE (init) == error_mark_node | |
832 | && TREE_CHAIN (init) == NULL_TREE) | |
cffa8729 | 833 | init = NULL_TREE; |
8d08fdba | 834 | |
91d231cb | 835 | value = grokdeclarator (declarator, declspecs, FIELD, init != 0, &attrlist); |
89f1a6ec | 836 | if (! value || error_operand_p (value)) |
3ddfb0e6 | 837 | /* friend or constructor went bad. */ |
04d57dd5 ZW |
838 | return error_mark_node; |
839 | ||
840 | if (TREE_CODE (value) == TYPE_DECL && init) | |
841 | { | |
842 | error ("typedef `%D' is initialized (use __typeof__ instead)", value); | |
843 | init = NULL_TREE; | |
844 | } | |
8d08fdba MS |
845 | |
846 | /* Pass friendly classes back. */ | |
8db1028e NS |
847 | if (value == void_type_node) |
848 | return value; | |
849 | ||
9bcb9aae | 850 | /* Pass friend decls back. */ |
8db1028e NS |
851 | if ((TREE_CODE (value) == FUNCTION_DECL |
852 | || TREE_CODE (value) == TEMPLATE_DECL) | |
853 | && DECL_CONTEXT (value) != current_class_type) | |
854 | return value; | |
8d08fdba MS |
855 | |
856 | if (DECL_NAME (value) != NULL_TREE | |
857 | && IDENTIFIER_POINTER (DECL_NAME (value))[0] == '_' | |
858 | && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (value)), "_vptr")) | |
33bd39a2 | 859 | error ("member `%D' conflicts with virtual function table field name", |
3c215895 | 860 | value); |
8d08fdba MS |
861 | |
862 | /* Stash away type declarations. */ | |
863 | if (TREE_CODE (value) == TYPE_DECL) | |
864 | { | |
865 | DECL_NONLOCAL (value) = 1; | |
700f8a87 | 866 | DECL_CONTEXT (value) = current_class_type; |
8145f082 | 867 | |
9188c363 MM |
868 | if (processing_template_decl) |
869 | value = push_template_decl (value); | |
870 | ||
8d08fdba MS |
871 | return value; |
872 | } | |
873 | ||
8d08fdba MS |
874 | if (DECL_IN_AGGR_P (value)) |
875 | { | |
33bd39a2 | 876 | error ("`%D' is already defined in `%T'", value, |
6b4b3deb | 877 | DECL_CONTEXT (value)); |
8d08fdba MS |
878 | return void_type_node; |
879 | } | |
880 | ||
8d08fdba MS |
881 | if (asmspec_tree) |
882 | asmspec = TREE_STRING_POINTER (asmspec_tree); | |
883 | ||
884 | if (init) | |
885 | { | |
6eabb241 | 886 | if (TREE_CODE (value) == FUNCTION_DECL) |
8d08fdba MS |
887 | { |
888 | grok_function_init (value, init); | |
889 | init = NULL_TREE; | |
890 | } | |
5b605f68 | 891 | else if (pedantic && TREE_CODE (value) != VAR_DECL) |
a0a33927 MS |
892 | /* Already complained in grokdeclarator. */ |
893 | init = NULL_TREE; | |
8d08fdba MS |
894 | else |
895 | { | |
a0a33927 MS |
896 | /* We allow initializers to become parameters to base |
897 | initializers. */ | |
8d08fdba MS |
898 | if (TREE_CODE (init) == TREE_LIST) |
899 | { | |
900 | if (TREE_CHAIN (init) == NULL_TREE) | |
901 | init = TREE_VALUE (init); | |
902 | else | |
903 | init = digest_init (TREE_TYPE (value), init, (tree *)0); | |
904 | } | |
dcba9b0f MM |
905 | |
906 | if (!processing_template_decl) | |
8d08fdba | 907 | { |
dcba9b0f MM |
908 | if (TREE_CODE (init) == CONST_DECL) |
909 | init = DECL_INITIAL (init); | |
910 | else if (TREE_READONLY_DECL_P (init)) | |
911 | init = decl_constant_value (init); | |
912 | else if (TREE_CODE (init) == CONSTRUCTOR) | |
913 | init = digest_init (TREE_TYPE (value), init, (tree *)0); | |
c9bdad35 | 914 | if (init != error_mark_node && ! TREE_CONSTANT (init)) |
8d08fdba | 915 | { |
dcba9b0f MM |
916 | /* We can allow references to things that are effectively |
917 | static, since references are initialized with the | |
918 | address. */ | |
919 | if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE | |
920 | || (TREE_STATIC (init) == 0 | |
921 | && (!DECL_P (init) || DECL_EXTERNAL (init) == 0))) | |
922 | { | |
923 | error ("field initializer is not constant"); | |
924 | init = error_mark_node; | |
925 | } | |
8d08fdba MS |
926 | } |
927 | } | |
928 | } | |
929 | } | |
930 | ||
ddb45080 | 931 | if (processing_template_decl |
5566b478 | 932 | && (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == FUNCTION_DECL)) |
89f1a6ec MM |
933 | { |
934 | value = push_template_decl (value); | |
935 | if (error_operand_p (value)) | |
936 | return error_mark_node; | |
937 | } | |
5566b478 | 938 | |
45537677 | 939 | if (attrlist) |
91d231cb | 940 | cplus_decl_attributes (&value, attrlist, 0); |
45537677 | 941 | |
8d08fdba MS |
942 | if (TREE_CODE (value) == VAR_DECL) |
943 | { | |
fa8d6e85 | 944 | finish_static_data_member_decl (value, init, asmspec_tree, |
cd9f6678 | 945 | flags); |
8d08fdba MS |
946 | return value; |
947 | } | |
948 | if (TREE_CODE (value) == FIELD_DECL) | |
949 | { | |
950 | if (asmspec) | |
33bd39a2 | 951 | error ("`asm' specifiers are not permitted on non-static data members"); |
8d08fdba MS |
952 | if (DECL_INITIAL (value) == error_mark_node) |
953 | init = error_mark_node; | |
0c58da3e | 954 | cp_finish_decl (value, init, NULL_TREE, flags); |
8d08fdba MS |
955 | DECL_INITIAL (value) = init; |
956 | DECL_IN_AGGR_P (value) = 1; | |
957 | return value; | |
958 | } | |
959 | if (TREE_CODE (value) == FUNCTION_DECL) | |
960 | { | |
6060a796 MS |
961 | if (asmspec) |
962 | { | |
963 | /* This must override the asm specifier which was placed | |
964 | by grokclassfn. Lay this out fresh. */ | |
19e7881c | 965 | SET_DECL_RTL (value, NULL_RTX); |
fccc4eb2 | 966 | change_decl_assembler_name (value, get_identifier (asmspec)); |
6060a796 | 967 | } |
271e6f02 NS |
968 | if (!DECL_FRIEND_P (value)) |
969 | grok_special_member_properties (value); | |
970 | ||
cd9f6678 | 971 | cp_finish_decl (value, init, asmspec_tree, flags); |
8d08fdba MS |
972 | |
973 | /* Pass friends back this way. */ | |
974 | if (DECL_FRIEND_P (value)) | |
975 | return void_type_node; | |
976 | ||
977 | DECL_IN_AGGR_P (value) = 1; | |
978 | return value; | |
979 | } | |
a98facb0 | 980 | abort (); |
8d08fdba MS |
981 | /* NOTREACHED */ |
982 | return NULL_TREE; | |
983 | } | |
984 | ||
985 | /* Like `grokfield', but for bitfields. | |
986 | WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node. */ | |
987 | ||
988 | tree | |
62d1db17 MM |
989 | grokbitfield (const cp_declarator *declarator, |
990 | cp_decl_specifier_seq *declspecs, tree width) | |
8d08fdba | 991 | { |
926ce8bd | 992 | tree value = grokdeclarator (declarator, declspecs, BITFIELD, 0, NULL); |
8d08fdba MS |
993 | |
994 | if (! value) return NULL_TREE; /* friends went bad. */ | |
995 | ||
996 | /* Pass friendly classes back. */ | |
997 | if (TREE_CODE (value) == VOID_TYPE) | |
998 | return void_type_node; | |
999 | ||
1000 | if (TREE_CODE (value) == TYPE_DECL) | |
1001 | { | |
3855d0d1 | 1002 | error ("cannot declare `%D' to be a bit-field type", value); |
8d08fdba MS |
1003 | return NULL_TREE; |
1004 | } | |
1005 | ||
33bd39a2 | 1006 | /* Usually, finish_struct_1 catches bitfields with invalid types. |
ae58fa02 MM |
1007 | But, in the case of bitfields with function type, we confuse |
1008 | ourselves into thinking they are member functions, so we must | |
1009 | check here. */ | |
1010 | if (TREE_CODE (value) == FUNCTION_DECL) | |
1011 | { | |
3855d0d1 | 1012 | error ("cannot declare bit-field `%D' with function type", |
33bd39a2 | 1013 | DECL_NAME (value)); |
ae58fa02 MM |
1014 | return NULL_TREE; |
1015 | } | |
1016 | ||
8d08fdba MS |
1017 | if (DECL_IN_AGGR_P (value)) |
1018 | { | |
33bd39a2 | 1019 | error ("`%D' is already defined in the class %T", value, |
8d08fdba MS |
1020 | DECL_CONTEXT (value)); |
1021 | return void_type_node; | |
1022 | } | |
1023 | ||
8d08fdba MS |
1024 | if (TREE_STATIC (value)) |
1025 | { | |
3855d0d1 | 1026 | error ("static member `%D' cannot be a bit-field", value); |
8d08fdba MS |
1027 | return NULL_TREE; |
1028 | } | |
cd9f6678 | 1029 | cp_finish_decl (value, NULL_TREE, NULL_TREE, 0); |
8d08fdba MS |
1030 | |
1031 | if (width != error_mark_node) | |
1032 | { | |
5566b478 MS |
1033 | constant_expression_warning (width); |
1034 | DECL_INITIAL (value) = width; | |
162bc98d | 1035 | SET_DECL_C_BIT_FIELD (value); |
8d08fdba MS |
1036 | } |
1037 | ||
1038 | DECL_IN_AGGR_P (value) = 1; | |
1039 | return value; | |
1040 | } | |
1041 | ||
8d08fdba MS |
1042 | /* When a function is declared with an initializer, |
1043 | do the right thing. Currently, there are two possibilities: | |
1044 | ||
1045 | class B | |
1046 | { | |
1047 | public: | |
1048 | // initialization possibility #1. | |
1049 | virtual void f () = 0; | |
1050 | int g (); | |
1051 | }; | |
1052 | ||
1053 | class D1 : B | |
1054 | { | |
1055 | public: | |
1056 | int d1; | |
1057 | // error, no f (); | |
1058 | }; | |
1059 | ||
1060 | class D2 : B | |
1061 | { | |
1062 | public: | |
1063 | int d2; | |
1064 | void f (); | |
1065 | }; | |
1066 | ||
1067 | class D3 : B | |
1068 | { | |
1069 | public: | |
1070 | int d3; | |
1071 | // initialization possibility #2 | |
1072 | void f () = B::f; | |
1073 | }; | |
1074 | ||
1075 | */ | |
1076 | ||
1077 | static void | |
848eed92 | 1078 | grok_function_init (tree decl, tree init) |
8d08fdba MS |
1079 | { |
1080 | /* An initializer for a function tells how this function should | |
1081 | be inherited. */ | |
1082 | tree type = TREE_TYPE (decl); | |
8d08fdba MS |
1083 | |
1084 | if (TREE_CODE (type) == FUNCTION_TYPE) | |
33bd39a2 | 1085 | error ("initializer specified for non-member function `%D'", decl); |
8d08fdba | 1086 | else if (integer_zerop (init)) |
271e6f02 | 1087 | DECL_PURE_VIRTUAL_P (decl) = 1; |
8d08fdba | 1088 | else |
33bd39a2 | 1089 | error ("invalid initializer for virtual method `%D'", decl); |
8d08fdba MS |
1090 | } |
1091 | \f | |
28cbf42c | 1092 | void |
848eed92 | 1093 | cplus_decl_attributes (tree *decl, tree attributes, int flags) |
8d08fdba | 1094 | { |
59387d2e | 1095 | if (*decl == NULL_TREE || *decl == void_type_node) |
e8abc66f MS |
1096 | return; |
1097 | ||
59387d2e JM |
1098 | if (TREE_CODE (*decl) == TEMPLATE_DECL) |
1099 | decl = &DECL_TEMPLATE_RESULT (*decl); | |
e8abc66f | 1100 | |
91d231cb | 1101 | decl_attributes (decl, attributes, flags); |
863adfc0 | 1102 | |
59387d2e JM |
1103 | if (TREE_CODE (*decl) == TYPE_DECL) |
1104 | SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (*decl), TREE_TYPE (*decl)); | |
8d08fdba | 1105 | } |
8d08fdba | 1106 | \f |
0ca7178c JM |
1107 | /* Walks through the namespace- or function-scope anonymous union OBJECT, |
1108 | building appropriate ALIAS_DECLs. Returns one of the fields for use in | |
1109 | the mangled name. */ | |
f237d906 | 1110 | |
0ca7178c | 1111 | static tree |
848eed92 | 1112 | build_anon_union_vars (tree object) |
ce1b9eb9 | 1113 | { |
0ca7178c | 1114 | tree type = TREE_TYPE (object); |
ce1b9eb9 | 1115 | tree main_decl = NULL_TREE; |
cb96daa2 | 1116 | tree field; |
ce1b9eb9 | 1117 | |
6bdb8141 JM |
1118 | /* Rather than write the code to handle the non-union case, |
1119 | just give an error. */ | |
1120 | if (TREE_CODE (type) != UNION_TYPE) | |
1121 | error ("anonymous struct not inside named type"); | |
1122 | ||
cb96daa2 | 1123 | for (field = TYPE_FIELDS (type); |
ce1b9eb9 MM |
1124 | field != NULL_TREE; |
1125 | field = TREE_CHAIN (field)) | |
1126 | { | |
cb96daa2 | 1127 | tree decl; |
0ca7178c | 1128 | tree ref; |
8ebeee52 JM |
1129 | |
1130 | if (DECL_ARTIFICIAL (field)) | |
ce1b9eb9 | 1131 | continue; |
8ebeee52 JM |
1132 | if (TREE_CODE (field) != FIELD_DECL) |
1133 | { | |
0ca7178c JM |
1134 | cp_pedwarn_at ("\ |
1135 | `%#D' invalid; an anonymous union can only have non-static data members", | |
8ebeee52 JM |
1136 | field); |
1137 | continue; | |
1138 | } | |
ce1b9eb9 | 1139 | |
cb96daa2 | 1140 | if (TREE_PRIVATE (field)) |
8251199e | 1141 | cp_pedwarn_at ("private member `%#D' in anonymous union", field); |
cb96daa2 | 1142 | else if (TREE_PROTECTED (field)) |
8251199e | 1143 | cp_pedwarn_at ("protected member `%#D' in anonymous union", field); |
cb96daa2 | 1144 | |
8fbc5ae7 | 1145 | if (processing_template_decl) |
44de5aeb RK |
1146 | ref = build_min_nt (COMPONENT_REF, object, |
1147 | DECL_NAME (field), NULL_TREE); | |
8fbc5ae7 MM |
1148 | else |
1149 | ref = build_class_member_access_expr (object, field, NULL_TREE, | |
1150 | false); | |
0ca7178c JM |
1151 | |
1152 | if (DECL_NAME (field)) | |
cb96daa2 | 1153 | { |
0ca7178c JM |
1154 | decl = build_decl (ALIAS_DECL, DECL_NAME (field), TREE_TYPE (field)); |
1155 | DECL_INITIAL (decl) = ref; | |
cb96daa2 | 1156 | TREE_PUBLIC (decl) = 0; |
0ca7178c JM |
1157 | TREE_STATIC (decl) = 0; |
1158 | DECL_EXTERNAL (decl) = 1; | |
cb96daa2 | 1159 | decl = pushdecl (decl); |
cb96daa2 | 1160 | } |
0ca7178c JM |
1161 | else if (ANON_AGGR_TYPE_P (TREE_TYPE (field))) |
1162 | decl = build_anon_union_vars (ref); | |
dd1b7476 KG |
1163 | else |
1164 | decl = 0; | |
cb96daa2 | 1165 | |
0ca7178c JM |
1166 | if (main_decl == NULL_TREE) |
1167 | main_decl = decl; | |
cb96daa2 | 1168 | } |
0ca7178c | 1169 | |
ce1b9eb9 MM |
1170 | return main_decl; |
1171 | } | |
1172 | ||
c050ec51 JM |
1173 | /* Finish off the processing of a UNION_TYPE structure. If the union is an |
1174 | anonymous union, then all members must be laid out together. PUBLIC_P | |
1175 | is nonzero if this union is not declared static. */ | |
e92cc029 | 1176 | |
8d08fdba | 1177 | void |
848eed92 | 1178 | finish_anon_union (tree anon_union_decl) |
8d08fdba MS |
1179 | { |
1180 | tree type = TREE_TYPE (anon_union_decl); | |
cb96daa2 | 1181 | tree main_decl; |
848eed92 | 1182 | bool public_p = TREE_PUBLIC (anon_union_decl); |
8d08fdba | 1183 | |
a1c65f9f | 1184 | /* The VAR_DECL's context is the same as the TYPE's context. */ |
e5410b32 NS |
1185 | DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type)); |
1186 | ||
cb96daa2 | 1187 | if (TYPE_FIELDS (type) == NULL_TREE) |
8d08fdba MS |
1188 | return; |
1189 | ||
1190 | if (public_p) | |
1191 | { | |
ff9f1a5d | 1192 | error ("namespace-scope anonymous aggregates must be static"); |
8d08fdba MS |
1193 | return; |
1194 | } | |
1195 | ||
8fbc5ae7 MM |
1196 | main_decl = build_anon_union_vars (anon_union_decl); |
1197 | if (main_decl == NULL_TREE) | |
01f4137f | 1198 | { |
8fbc5ae7 MM |
1199 | warning ("anonymous union with no members"); |
1200 | return; | |
1201 | } | |
bd9bb3d2 | 1202 | |
8fbc5ae7 MM |
1203 | if (!processing_template_decl) |
1204 | { | |
0ca7178c JM |
1205 | /* Use main_decl to set the mangled name. */ |
1206 | DECL_NAME (anon_union_decl) = DECL_NAME (main_decl); | |
1207 | mangle_decl (anon_union_decl); | |
1208 | DECL_NAME (anon_union_decl) = NULL_TREE; | |
01f4137f | 1209 | } |
edebf865 | 1210 | |
0ca7178c JM |
1211 | pushdecl (anon_union_decl); |
1212 | if (building_stmt_tree () | |
1213 | && at_function_scope_p ()) | |
350fae66 | 1214 | add_decl_expr (anon_union_decl); |
0ca7178c JM |
1215 | else if (!processing_template_decl) |
1216 | rest_of_decl_compilation (anon_union_decl, NULL, | |
1217 | toplevel_bindings_p (), at_eof); | |
8d08fdba | 1218 | } |
8d08fdba MS |
1219 | \f |
1220 | /* Auxiliary functions to make type signatures for | |
1221 | `operator new' and `operator delete' correspond to | |
1222 | what compiler will be expecting. */ | |
1223 | ||
8d08fdba | 1224 | tree |
848eed92 | 1225 | coerce_new_type (tree type) |
8d08fdba | 1226 | { |
36791f1e NS |
1227 | int e = 0; |
1228 | tree args = TYPE_ARG_TYPES (type); | |
1229 | ||
1230 | my_friendly_assert (TREE_CODE (type) == FUNCTION_TYPE, 20001107); | |
1231 | ||
1232 | if (!same_type_p (TREE_TYPE (type), ptr_type_node)) | |
33bd39a2 | 1233 | e = 1, error ("`operator new' must return type `%T'", ptr_type_node); |
36791f1e NS |
1234 | |
1235 | if (!args || args == void_list_node | |
c9f8536c | 1236 | || !same_type_p (TREE_VALUE (args), size_type_node)) |
36791f1e NS |
1237 | { |
1238 | e = 2; | |
1239 | if (args && args != void_list_node) | |
1240 | args = TREE_CHAIN (args); | |
c9f8536c | 1241 | pedwarn ("`operator new' takes type `size_t' (`%T') as first parameter", size_type_node); |
36791f1e NS |
1242 | } |
1243 | switch (e) | |
1244 | { | |
1245 | case 2: | |
c9f8536c | 1246 | args = tree_cons (NULL_TREE, size_type_node, args); |
f4f206f4 | 1247 | /* Fall through. */ |
36791f1e NS |
1248 | case 1: |
1249 | type = build_exception_variant | |
1250 | (build_function_type (ptr_type_node, args), | |
1251 | TYPE_RAISES_EXCEPTIONS (type)); | |
f4f206f4 | 1252 | /* Fall through. */ |
36791f1e NS |
1253 | default:; |
1254 | } | |
8d08fdba MS |
1255 | return type; |
1256 | } | |
1257 | ||
1258 | tree | |
848eed92 | 1259 | coerce_delete_type (tree type) |
8d08fdba | 1260 | { |
36791f1e NS |
1261 | int e = 0; |
1262 | tree args = TYPE_ARG_TYPES (type); | |
1263 | ||
1264 | my_friendly_assert (TREE_CODE (type) == FUNCTION_TYPE, 20001107); | |
824b9a4c | 1265 | |
36791f1e | 1266 | if (!same_type_p (TREE_TYPE (type), void_type_node)) |
33bd39a2 | 1267 | e = 1, error ("`operator delete' must return type `%T'", void_type_node); |
8d08fdba | 1268 | |
36791f1e NS |
1269 | if (!args || args == void_list_node |
1270 | || !same_type_p (TREE_VALUE (args), ptr_type_node)) | |
8d08fdba | 1271 | { |
36791f1e NS |
1272 | e = 2; |
1273 | if (args && args != void_list_node) | |
1274 | args = TREE_CHAIN (args); | |
33bd39a2 | 1275 | error ("`operator delete' takes type `%T' as first parameter", ptr_type_node); |
8d08fdba | 1276 | } |
36791f1e NS |
1277 | switch (e) |
1278 | { | |
1279 | case 2: | |
1280 | args = tree_cons (NULL_TREE, ptr_type_node, args); | |
f4f206f4 | 1281 | /* Fall through. */ |
36791f1e NS |
1282 | case 1: |
1283 | type = build_exception_variant | |
1284 | (build_function_type (void_type_node, args), | |
1285 | TYPE_RAISES_EXCEPTIONS (type)); | |
f4f206f4 | 1286 | /* Fall through. */ |
36791f1e NS |
1287 | default:; |
1288 | } | |
8d08fdba MS |
1289 | |
1290 | return type; | |
1291 | } | |
1292 | \f | |
1293 | static void | |
848eed92 | 1294 | mark_vtable_entries (tree decl) |
8d08fdba | 1295 | { |
f30432d7 MS |
1296 | tree entries = CONSTRUCTOR_ELTS (DECL_INITIAL (decl)); |
1297 | ||
8d08fdba MS |
1298 | for (; entries; entries = TREE_CHAIN (entries)) |
1299 | { | |
c4372ef4 | 1300 | tree fnaddr = TREE_VALUE (entries); |
aff08c18 | 1301 | tree fn; |
bb4f6e6b JH |
1302 | |
1303 | STRIP_NOPS (fnaddr); | |
1304 | ||
67231816 RH |
1305 | if (TREE_CODE (fnaddr) != ADDR_EXPR |
1306 | && TREE_CODE (fnaddr) != FDESC_EXPR) | |
bbd15aac | 1307 | /* This entry is an offset: a virtual base class offset, a |
46ccf50a | 1308 | virtual call offset, an RTTI offset, etc. */ |
aff08c18 JM |
1309 | continue; |
1310 | ||
aff08c18 | 1311 | fn = TREE_OPERAND (fnaddr, 0); |
8926095f | 1312 | TREE_ADDRESSABLE (fn) = 1; |
31f8e4f3 MM |
1313 | /* When we don't have vcall offsets, we output thunks whenever |
1314 | we output the vtables that contain them. With vcall offsets, | |
1315 | we know all the thunks we'll need when we emit a virtual | |
1316 | function, so we emit the thunks there instead. */ | |
1317 | if (DECL_THUNK_P (fn)) | |
d0cd8b44 | 1318 | use_thunk (fn, /*emit_p=*/0); |
5566b478 | 1319 | mark_used (fn); |
7177d104 MS |
1320 | } |
1321 | } | |
1322 | ||
d11ad92e MS |
1323 | /* Set DECL up to have the closest approximation of "initialized common" |
1324 | linkage available. */ | |
1325 | ||
1326 | void | |
848eed92 | 1327 | comdat_linkage (tree decl) |
d11ad92e | 1328 | { |
d11ad92e | 1329 | if (flag_weak) |
7fcdf4c2 | 1330 | make_decl_one_only (decl); |
97458258 MM |
1331 | else if (TREE_CODE (decl) == FUNCTION_DECL |
1332 | || (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl))) | |
1333 | /* We can just emit function and compiler-generated variables | |
1334 | statically; having multiple copies is (for the most part) only | |
1335 | a waste of space. | |
1336 | ||
1337 | There are two correctness issues, however: the address of a | |
1338 | template instantiation with external linkage should be the | |
ad50e811 MM |
1339 | same, independent of what translation unit asks for the |
1340 | address, and this will not hold when we emit multiple copies of | |
97458258 MM |
1341 | the function. However, there's little else we can do. |
1342 | ||
3461fba7 NS |
1343 | Also, by default, the typeinfo implementation assumes that |
1344 | there will be only one copy of the string used as the name for | |
1345 | each type. Therefore, if weak symbols are unavailable, the | |
1346 | run-time library should perform a more conservative check; it | |
1347 | should perform a string comparison, rather than an address | |
1348 | comparison. */ | |
7fcdf4c2 | 1349 | TREE_PUBLIC (decl) = 0; |
ea735e02 JM |
1350 | else |
1351 | { | |
2f435bed JM |
1352 | /* Static data member template instantiations, however, cannot |
1353 | have multiple copies. */ | |
ea735e02 JM |
1354 | if (DECL_INITIAL (decl) == 0 |
1355 | || DECL_INITIAL (decl) == error_mark_node) | |
1356 | DECL_COMMON (decl) = 1; | |
1357 | else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))) | |
1358 | { | |
1359 | DECL_COMMON (decl) = 1; | |
1360 | DECL_INITIAL (decl) = error_mark_node; | |
1361 | } | |
49bf4577 | 1362 | else if (!DECL_EXPLICIT_INSTANTIATION (decl)) |
ea735e02 JM |
1363 | { |
1364 | /* We can't do anything useful; leave vars for explicit | |
1365 | instantiation. */ | |
1366 | DECL_EXTERNAL (decl) = 1; | |
1367 | DECL_NOT_REALLY_EXTERN (decl) = 0; | |
1368 | } | |
1369 | } | |
ab23f787 JM |
1370 | |
1371 | if (DECL_LANG_SPECIFIC (decl)) | |
1372 | DECL_COMDAT (decl) = 1; | |
d11ad92e MS |
1373 | } |
1374 | ||
b385c841 JM |
1375 | /* For win32 we also want to put explicit instantiations in |
1376 | linkonce sections, so that they will be merged with implicit | |
4746cf84 MA |
1377 | instantiations; otherwise we get duplicate symbol errors. |
1378 | For Darwin we do not want explicit instantiations to be | |
324f9dfb | 1379 | linkonce. */ |
b385c841 JM |
1380 | |
1381 | void | |
848eed92 | 1382 | maybe_make_one_only (tree decl) |
b385c841 | 1383 | { |
b78121f6 JM |
1384 | /* We used to say that this was not necessary on targets that support weak |
1385 | symbols, because the implicit instantiations will defer to the explicit | |
1386 | one. However, that's not actually the case in SVR4; a strong definition | |
1387 | after a weak one is an error. Also, not making explicit | |
1388 | instantiations one_only means that we can end up with two copies of | |
a1c65f9f | 1389 | some template instantiations. */ |
90ecce3e | 1390 | if (! flag_weak) |
b385c841 JM |
1391 | return; |
1392 | ||
1393 | /* We can't set DECL_COMDAT on functions, or finish_file will think | |
ea735e02 JM |
1394 | we can get away with not emitting them if they aren't used. We need |
1395 | to for variables so that cp_finish_decl will update their linkage, | |
1396 | because their DECL_INITIAL may not have been set properly yet. */ | |
b385c841 | 1397 | |
0524c91d | 1398 | if (!TARGET_WEAK_NOT_IN_ARCHIVE_TOC |
4746cf84 MA |
1399 | || (! DECL_EXPLICIT_INSTANTIATION (decl) |
1400 | && ! DECL_TEMPLATE_SPECIALIZATION (decl))) | |
5cc90635 | 1401 | { |
4746cf84 MA |
1402 | make_decl_one_only (decl); |
1403 | ||
1404 | if (TREE_CODE (decl) == VAR_DECL) | |
1405 | { | |
1406 | DECL_COMDAT (decl) = 1; | |
1407 | /* Mark it needed so we don't forget to emit it. */ | |
bb9a388d | 1408 | mark_decl_referenced (decl); |
4746cf84 | 1409 | } |
5cc90635 | 1410 | } |
b385c841 JM |
1411 | } |
1412 | ||
d18c083e | 1413 | /* Set TREE_PUBLIC and/or DECL_EXTERN on the vtable DECL, |
7177d104 MS |
1414 | based on TYPE and other static flags. |
1415 | ||
1416 | Note that anything public is tagged TREE_PUBLIC, whether | |
1417 | it's public in this file or in another one. */ | |
1418 | ||
5b605f68 | 1419 | void |
848eed92 | 1420 | import_export_vtable (tree decl, tree type, int final) |
7177d104 | 1421 | { |
e3417fcd MS |
1422 | if (DECL_INTERFACE_KNOWN (decl)) |
1423 | return; | |
1424 | ||
56ae6d77 | 1425 | if (TYPE_FOR_JAVA (type)) |
7177d104 MS |
1426 | { |
1427 | TREE_PUBLIC (decl) = 1; | |
56ae6d77 | 1428 | DECL_EXTERNAL (decl) = 1; |
e3417fcd MS |
1429 | DECL_INTERFACE_KNOWN (decl) = 1; |
1430 | } | |
1431 | else if (CLASSTYPE_INTERFACE_KNOWN (type)) | |
1432 | { | |
1433 | TREE_PUBLIC (decl) = 1; | |
46ccf50a | 1434 | DECL_EXTERNAL (decl) = CLASSTYPE_INTERFACE_ONLY (type); |
e3417fcd MS |
1435 | DECL_INTERFACE_KNOWN (decl) = 1; |
1436 | } | |
1437 | else | |
1438 | { | |
b7484fbe MS |
1439 | /* We can only wait to decide if we have real non-inline virtual |
1440 | functions in our class, or if we come from a template. */ | |
e3417fcd | 1441 | |
6db20143 | 1442 | int found = (CLASSTYPE_TEMPLATE_INSTANTIATION (type) |
9aad8f83 | 1443 | || CLASSTYPE_KEY_METHOD (type) != NULL_TREE); |
e3417fcd MS |
1444 | |
1445 | if (final || ! found) | |
1446 | { | |
d11ad92e | 1447 | comdat_linkage (decl); |
e3417fcd | 1448 | DECL_EXTERNAL (decl) = 0; |
e3417fcd MS |
1449 | } |
1450 | else | |
1451 | { | |
1452 | TREE_PUBLIC (decl) = 1; | |
1453 | DECL_EXTERNAL (decl) = 1; | |
e3417fcd | 1454 | } |
8d08fdba MS |
1455 | } |
1456 | } | |
1457 | ||
7e776093 JM |
1458 | /* Determine whether or not we want to specifically import or export CTYPE, |
1459 | using various heuristics. */ | |
67f7c391 | 1460 | |
27d26ee7 | 1461 | static void |
848eed92 | 1462 | import_export_class (tree ctype) |
8d08fdba | 1463 | { |
7e776093 JM |
1464 | /* -1 for imported, 1 for exported. */ |
1465 | int import_export = 0; | |
1466 | ||
27d26ee7 MM |
1467 | /* It only makes sense to call this function at EOF. The reason is |
1468 | that this function looks at whether or not the first non-inline | |
1469 | non-abstract virtual member function has been defined in this | |
1470 | translation unit. But, we can't possibly know that until we've | |
1471 | seen the entire translation unit. */ | |
1472 | my_friendly_assert (at_eof, 20000226); | |
1473 | ||
7e776093 JM |
1474 | if (CLASSTYPE_INTERFACE_KNOWN (ctype)) |
1475 | return; | |
1476 | ||
e9659ab0 JM |
1477 | /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma interface, |
1478 | we will have CLASSTYPE_INTERFACE_ONLY set but not | |
1479 | CLASSTYPE_INTERFACE_KNOWN. In that case, we don't want to use this | |
1480 | heuristic because someone will supply a #pragma implementation | |
1481 | elsewhere, and deducing it here would produce a conflict. */ | |
1482 | if (CLASSTYPE_INTERFACE_ONLY (ctype)) | |
1483 | return; | |
1484 | ||
91d231cb | 1485 | if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype))) |
501990bb | 1486 | import_export = -1; |
91d231cb | 1487 | else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype))) |
501990bb | 1488 | import_export = 1; |
7e776093 JM |
1489 | |
1490 | /* If we got -fno-implicit-templates, we import template classes that | |
1491 | weren't explicitly instantiated. */ | |
1492 | if (import_export == 0 | |
1493 | && CLASSTYPE_IMPLICIT_INSTANTIATION (ctype) | |
1494 | && ! flag_implicit_templates) | |
1495 | import_export = -1; | |
7177d104 | 1496 | |
7e776093 | 1497 | /* Base our import/export status on that of the first non-inline, |
6db20143 | 1498 | non-pure virtual function, if any. */ |
7e776093 | 1499 | if (import_export == 0 |
6e9dcc25 | 1500 | && TYPE_POLYMORPHIC_P (ctype)) |
51c184be | 1501 | { |
9aad8f83 | 1502 | tree method = CLASSTYPE_KEY_METHOD (ctype); |
30bf22a0 MS |
1503 | |
1504 | /* If weak symbol support is not available, then we must be | |
1505 | careful not to emit the vtable when the key function is | |
1506 | inline. An inline function can be defined in multiple | |
1507 | translation units. If we were to emit the vtable in each | |
1508 | translation unit containing a definition, we would get | |
1509 | multiple definition errors at link-time. */ | |
1510 | if (method && (flag_weak || ! DECL_DECLARED_INLINE_P (method))) | |
6db20143 | 1511 | import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1); |
51c184be | 1512 | } |
ad236eab JM |
1513 | |
1514 | #ifdef MULTIPLE_SYMBOL_SPACES | |
1515 | if (import_export == -1) | |
1516 | import_export = 0; | |
c11b6f21 | 1517 | #endif |
7e776093 | 1518 | |
d59c7b4b NC |
1519 | /* Allow backends the chance to overrule the decision. */ |
1520 | if (targetm.cxx.import_export_class) | |
1521 | import_export = targetm.cxx.import_export_class (ctype, import_export); | |
1522 | ||
7e776093 JM |
1523 | if (import_export) |
1524 | { | |
1525 | SET_CLASSTYPE_INTERFACE_KNOWN (ctype); | |
7e776093 JM |
1526 | CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0); |
1527 | } | |
67f7c391 | 1528 | } |
a1dd0d36 | 1529 | |
c4d2313d JH |
1530 | /* Return true if VAR has already been provided to the back end; in that |
1531 | case VAR should not be modified further by the front end. */ | |
1532 | static bool | |
1533 | var_finalized_p (tree var) | |
1534 | { | |
1535 | if (flag_unit_at_a_time) | |
c4d2313d | 1536 | return cgraph_varpool_node (var)->finalized; |
b44a178a DE |
1537 | else |
1538 | return TREE_ASM_WRITTEN (var); | |
c4d2313d JH |
1539 | } |
1540 | ||
548502d3 | 1541 | /* If necessary, write out the vtables for the dynamic class CTYPE. |
848eed92 | 1542 | Returns true if any vtables were emitted. */ |
548502d3 | 1543 | |
848eed92 | 1544 | static bool |
548502d3 | 1545 | maybe_emit_vtables (tree ctype) |
d18c083e | 1546 | { |
548502d3 MM |
1547 | tree vtbl; |
1548 | tree primary_vtbl; | |
084c1779 | 1549 | bool needed = false; |
0524c91d | 1550 | bool weaken_vtables; |
548502d3 MM |
1551 | |
1552 | /* If the vtables for this class have already been emitted there is | |
1553 | nothing more to do. */ | |
1554 | primary_vtbl = CLASSTYPE_VTABLES (ctype); | |
c4d2313d | 1555 | if (var_finalized_p (primary_vtbl)) |
848eed92 | 1556 | return false; |
548502d3 MM |
1557 | /* Ignore dummy vtables made by get_vtable_decl. */ |
1558 | if (TREE_TYPE (primary_vtbl) == void_type_node) | |
848eed92 | 1559 | return false; |
548502d3 | 1560 | |
2455f26f | 1561 | import_export_class (ctype); |
2455f26f | 1562 | |
548502d3 MM |
1563 | /* See if any of the vtables are needed. */ |
1564 | for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl)) | |
e9e4d4ee JH |
1565 | { |
1566 | import_export_vtable (vtbl, ctype, 1); | |
1567 | if (!DECL_EXTERNAL (vtbl) && DECL_NEEDED_P (vtbl)) | |
1568 | break; | |
1569 | } | |
548502d3 MM |
1570 | if (!vtbl) |
1571 | { | |
1572 | /* If the references to this class' vtables are optimized away, | |
1573 | still emit the appropriate debugging information. See | |
1574 | dfs_debug_mark. */ | |
1575 | if (DECL_COMDAT (primary_vtbl) | |
1576 | && CLASSTYPE_DEBUG_REQUESTED (ctype)) | |
1577 | note_debug_info_needed (ctype); | |
848eed92 | 1578 | return false; |
548502d3 | 1579 | } |
084c1779 JH |
1580 | else if (TREE_PUBLIC (vtbl) && !DECL_COMDAT (vtbl)) |
1581 | needed = true; | |
1582 | ||
0524c91d MA |
1583 | /* Determine whether to make vtables weak. The ABI requires that we |
1584 | do so. There are two cases in which we have to violate the ABI | |
1585 | specification: targets where we don't have weak symbols | |
1586 | (obviously), and targets where weak symbols don't appear in | |
1587 | static archives' tables of contents. On such targets, avoiding | |
1588 | undefined symbol link errors requires that we only make a symbol | |
1589 | weak if we know that it will be emitted everywhere it's needed. | |
1590 | So on such targets we don't make vtables weak in the common case | |
1591 | where we're emitting a vtable of a nontemplate class in the | |
1592 | translation unit containing the definition of a noninline key | |
1593 | method. */ | |
1594 | if (flag_weak && !TARGET_WEAK_NOT_IN_ARCHIVE_TOC) | |
1595 | weaken_vtables = true; | |
1596 | else if (flag_weak) | |
1597 | { | |
1598 | if (CLASSTYPE_USE_TEMPLATE (ctype)) | |
1599 | weaken_vtables = CLASSTYPE_IMPLICIT_INSTANTIATION (ctype); | |
1600 | else | |
1601 | weaken_vtables = !CLASSTYPE_KEY_METHOD (ctype) | |
1602 | || DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (ctype)); | |
1603 | } | |
1604 | else | |
1605 | weaken_vtables = false; | |
548502d3 MM |
1606 | |
1607 | /* The ABI requires that we emit all of the vtables if we emit any | |
1608 | of them. */ | |
1609 | for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl)) | |
d18c083e | 1610 | { |
8d08fdba | 1611 | /* Write it out. */ |
548502d3 MM |
1612 | import_export_vtable (vtbl, ctype, 1); |
1613 | mark_vtable_entries (vtbl); | |
8cd2462c JH |
1614 | |
1615 | /* If we know that DECL is needed, mark it as such for the varpool. */ | |
084c1779 | 1616 | if (needed) |
8cd2462c JH |
1617 | cgraph_varpool_mark_needed_node (cgraph_varpool_node (vtbl)); |
1618 | ||
548502d3 | 1619 | if (TREE_TYPE (DECL_INITIAL (vtbl)) == 0) |
25ebb82a RH |
1620 | { |
1621 | /* It had better be all done at compile-time. */ | |
1622 | if (store_init_value (vtbl, DECL_INITIAL (vtbl))) | |
1623 | abort (); | |
1624 | } | |
8d08fdba | 1625 | |
faf5394a | 1626 | if (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG) |
8d08fdba MS |
1627 | { |
1628 | /* Mark the VAR_DECL node representing the vtable itself as a | |
1629 | "gratuitous" one, thereby forcing dwarfout.c to ignore it. | |
1630 | It is rather important that such things be ignored because | |
1631 | any effort to actually generate DWARF for them will run | |
1632 | into trouble when/if we encounter code like: | |
1633 | ||
1634 | #pragma interface | |
1635 | struct S { virtual void member (); }; | |
1636 | ||
1637 | because the artificial declaration of the vtable itself (as | |
1638 | manufactured by the g++ front end) will say that the vtable | |
1639 | is a static member of `S' but only *after* the debug output | |
1640 | for the definition of `S' has already been output. This causes | |
1641 | grief because the DWARF entry for the definition of the vtable | |
1642 | will try to refer back to an earlier *declaration* of the | |
1643 | vtable as a static member of `S' and there won't be one. | |
1644 | We might be able to arrange to have the "vtable static member" | |
1645 | attached to the member list for `S' before the debug info for | |
1646 | `S' get written (which would solve the problem) but that would | |
1647 | require more intrusive changes to the g++ front end. */ | |
1648 | ||
548502d3 | 1649 | DECL_IGNORED_P (vtbl) = 1; |
8d08fdba | 1650 | } |
8d08fdba | 1651 | |
0524c91d MA |
1652 | /* Always make vtables weak. Or at least almost always; see above. */ |
1653 | if (weaken_vtables) | |
548502d3 | 1654 | comdat_linkage (vtbl); |
e2213efb | 1655 | |
548502d3 | 1656 | rest_of_decl_compilation (vtbl, NULL, 1, 1); |
a1dd0d36 | 1657 | |
84df082b MM |
1658 | /* Because we're only doing syntax-checking, we'll never end up |
1659 | actually marking the variable as written. */ | |
1660 | if (flag_syntax_only) | |
548502d3 | 1661 | TREE_ASM_WRITTEN (vtbl) = 1; |
8d08fdba | 1662 | } |
6db20143 | 1663 | |
548502d3 MM |
1664 | /* Since we're writing out the vtable here, also write the debug |
1665 | info. */ | |
1666 | note_debug_info_needed (ctype); | |
b7484fbe | 1667 | |
848eed92 | 1668 | return true; |
b7484fbe MS |
1669 | } |
1670 | ||
00595019 | 1671 | /* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an |
5566b478 | 1672 | inline function or template instantiation at end-of-file. */ |
00595019 MS |
1673 | |
1674 | void | |
848eed92 | 1675 | import_export_decl (tree decl) |
00595019 | 1676 | { |
db5ae43f | 1677 | if (DECL_INTERFACE_KNOWN (decl)) |
00595019 MS |
1678 | return; |
1679 | ||
61289ca3 MM |
1680 | if (DECL_TEMPLATE_INSTANTIATION (decl) |
1681 | || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl)) | |
00595019 | 1682 | { |
5566b478 | 1683 | DECL_NOT_REALLY_EXTERN (decl) = 1; |
61289ca3 MM |
1684 | if ((DECL_IMPLICIT_INSTANTIATION (decl) |
1685 | || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl)) | |
5eea678f | 1686 | && (flag_implicit_templates |
b3c3af2f SB |
1687 | || (flag_implicit_inline_templates |
1688 | && TREE_CODE (decl) == FUNCTION_DECL | |
79065db2 | 1689 | && DECL_DECLARED_INLINE_P (decl)))) |
a9aedbc2 | 1690 | { |
75650646 MM |
1691 | if (!TREE_PUBLIC (decl)) |
1692 | /* Templates are allowed to have internal linkage. See | |
1693 | [basic.link]. */ | |
1694 | ; | |
d11ad92e | 1695 | else |
ea735e02 | 1696 | comdat_linkage (decl); |
a9aedbc2 | 1697 | } |
db5ae43f | 1698 | else |
b41d214e JM |
1699 | { |
1700 | DECL_EXTERNAL (decl) = 1; | |
1701 | DECL_NOT_REALLY_EXTERN (decl) = 0; | |
1702 | } | |
00595019 MS |
1703 | } |
1704 | else if (DECL_FUNCTION_MEMBER_P (decl)) | |
1705 | { | |
79065db2 | 1706 | if (!DECL_DECLARED_INLINE_P (decl)) |
00595019 | 1707 | { |
92788413 MM |
1708 | tree ctype = DECL_CONTEXT (decl); |
1709 | import_export_class (ctype); | |
1710 | if (CLASSTYPE_INTERFACE_KNOWN (ctype)) | |
1711 | { | |
1712 | DECL_NOT_REALLY_EXTERN (decl) | |
1713 | = ! (CLASSTYPE_INTERFACE_ONLY (ctype) | |
79065db2 MM |
1714 | || (DECL_DECLARED_INLINE_P (decl) |
1715 | && ! flag_implement_inlines | |
92788413 MM |
1716 | && !DECL_VINDEX (decl))); |
1717 | ||
b41d214e JM |
1718 | if (!DECL_NOT_REALLY_EXTERN (decl)) |
1719 | DECL_EXTERNAL (decl) = 1; | |
1720 | ||
92788413 MM |
1721 | /* Always make artificials weak. */ |
1722 | if (DECL_ARTIFICIAL (decl) && flag_weak) | |
1723 | comdat_linkage (decl); | |
1724 | else | |
1725 | maybe_make_one_only (decl); | |
1726 | } | |
00595019 | 1727 | } |
db5ae43f | 1728 | else |
d11ad92e | 1729 | comdat_linkage (decl); |
00595019 | 1730 | } |
db5ae43f | 1731 | else |
d11ad92e | 1732 | comdat_linkage (decl); |
e8abc66f MS |
1733 | |
1734 | DECL_INTERFACE_KNOWN (decl) = 1; | |
00595019 | 1735 | } |
db5ae43f | 1736 | |
d689a8f1 | 1737 | /* Here, we only decide whether or not the tinfo node should be |
838dfd8a | 1738 | emitted with the vtable. IS_IN_LIBRARY is nonzero iff the |
c6f553d1 | 1739 | typeinfo for TYPE should be in the runtime library. */ |
d689a8f1 NS |
1740 | |
1741 | void | |
848eed92 | 1742 | import_export_tinfo (tree decl, tree type, bool is_in_library) |
d689a8f1 NS |
1743 | { |
1744 | if (DECL_INTERFACE_KNOWN (decl)) | |
1745 | return; | |
1746 | ||
1747 | if (IS_AGGR_TYPE (type)) | |
1748 | import_export_class (type); | |
1749 | ||
1750 | if (IS_AGGR_TYPE (type) && CLASSTYPE_INTERFACE_KNOWN (type) | |
1751 | && TYPE_POLYMORPHIC_P (type) | |
1752 | /* If -fno-rtti, we're not necessarily emitting this stuff with | |
1753 | the class, so go ahead and emit it now. This can happen when | |
1754 | a class is used in exception handling. */ | |
1755 | && flag_rtti) | |
1756 | { | |
1757 | DECL_NOT_REALLY_EXTERN (decl) = !CLASSTYPE_INTERFACE_ONLY (type); | |
1758 | DECL_COMDAT (decl) = 0; | |
1759 | } | |
1760 | else | |
1761 | { | |
1762 | DECL_NOT_REALLY_EXTERN (decl) = 1; | |
1763 | DECL_COMDAT (decl) = 1; | |
1764 | } | |
c6f553d1 | 1765 | |
a1c65f9f | 1766 | /* Now override some cases. */ |
c6f553d1 NS |
1767 | if (flag_weak) |
1768 | DECL_COMDAT (decl) = 1; | |
1769 | else if (is_in_library) | |
1770 | DECL_COMDAT (decl) = 0; | |
1771 | ||
d689a8f1 NS |
1772 | DECL_INTERFACE_KNOWN (decl) = 1; |
1773 | } | |
1774 | ||
c10cdb3d MM |
1775 | /* Return an expression that performs the destruction of DECL, which |
1776 | must be a VAR_DECL whose type has a non-trivial destructor, or is | |
1777 | an array whose (innermost) elements have a non-trivial destructor. */ | |
1778 | ||
72b7eeff | 1779 | tree |
848eed92 | 1780 | build_cleanup (tree decl) |
72b7eeff MS |
1781 | { |
1782 | tree temp; | |
1783 | tree type = TREE_TYPE (decl); | |
1784 | ||
c10cdb3d MM |
1785 | /* This function should only be called for declarations that really |
1786 | require cleanups. */ | |
1787 | my_friendly_assert (!TYPE_HAS_TRIVIAL_DESTRUCTOR (type), 20030106); | |
1788 | ||
1789 | /* Treat all objects with destructors as used; the destructor may do | |
1790 | something substantive. */ | |
1791 | mark_used (decl); | |
1792 | ||
72b7eeff MS |
1793 | if (TREE_CODE (type) == ARRAY_TYPE) |
1794 | temp = decl; | |
1795 | else | |
1796 | { | |
dffd7eb6 | 1797 | cxx_mark_addressable (decl); |
72b7eeff MS |
1798 | temp = build1 (ADDR_EXPR, build_pointer_type (type), decl); |
1799 | } | |
1800 | temp = build_delete (TREE_TYPE (temp), temp, | |
86f45d2c | 1801 | sfk_complete_destructor, |
72b7eeff MS |
1802 | LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0); |
1803 | return temp; | |
1804 | } | |
1805 | ||
c395453c MM |
1806 | /* Returns the initialization guard variable for the variable DECL, |
1807 | which has static storage duration. */ | |
1f6e1acc | 1808 | |
c395453c | 1809 | tree |
848eed92 | 1810 | get_guard (tree decl) |
67d743fe | 1811 | { |
1f6e1acc | 1812 | tree sname; |
c395453c MM |
1813 | tree guard; |
1814 | ||
1f84ec23 | 1815 | sname = mangle_guard_variable (decl); |
c395453c MM |
1816 | guard = IDENTIFIER_GLOBAL_VALUE (sname); |
1817 | if (! guard) | |
1818 | { | |
1819 | tree guard_type; | |
1820 | ||
3461fba7 NS |
1821 | /* We use a type that is big enough to contain a mutex as well |
1822 | as an integer counter. */ | |
4185ae53 | 1823 | guard_type = targetm.cxx.guard_type (); |
c395453c | 1824 | guard = build_decl (VAR_DECL, sname, guard_type); |
844511c8 | 1825 | |
a1c65f9f | 1826 | /* The guard should have the same linkage as what it guards. */ |
844511c8 NS |
1827 | TREE_PUBLIC (guard) = TREE_PUBLIC (decl); |
1828 | TREE_STATIC (guard) = TREE_STATIC (decl); | |
1829 | DECL_COMMON (guard) = DECL_COMMON (decl); | |
1830 | DECL_ONE_ONLY (guard) = DECL_ONE_ONLY (decl); | |
1831 | if (TREE_PUBLIC (decl)) | |
1832 | DECL_WEAK (guard) = DECL_WEAK (decl); | |
1833 | ||
c395453c | 1834 | DECL_ARTIFICIAL (guard) = 1; |
c395453c | 1835 | TREE_USED (guard) = 1; |
170b020f | 1836 | pushdecl_top_level_and_finish (guard, NULL_TREE); |
c395453c MM |
1837 | } |
1838 | return guard; | |
1839 | } | |
1840 | ||
1841 | /* Return those bits of the GUARD variable that should be set when the | |
1842 | guarded entity is actually initialized. */ | |
1843 | ||
1844 | static tree | |
848eed92 | 1845 | get_guard_bits (tree guard) |
c395453c | 1846 | { |
4185ae53 PB |
1847 | if (!targetm.cxx.guard_mask_bit ()) |
1848 | { | |
1849 | /* We only set the first byte of the guard, in order to leave room | |
1850 | for a mutex in the high-order bits. */ | |
1851 | guard = build1 (ADDR_EXPR, | |
1852 | build_pointer_type (TREE_TYPE (guard)), | |
1853 | guard); | |
1854 | guard = build1 (NOP_EXPR, | |
1855 | build_pointer_type (char_type_node), | |
1856 | guard); | |
1857 | guard = build1 (INDIRECT_REF, char_type_node, guard); | |
1858 | } | |
c395453c MM |
1859 | |
1860 | return guard; | |
1861 | } | |
1862 | ||
1863 | /* Return an expression which determines whether or not the GUARD | |
1864 | variable has already been initialized. */ | |
1865 | ||
1866 | tree | |
848eed92 | 1867 | get_guard_cond (tree guard) |
c395453c MM |
1868 | { |
1869 | tree guard_value; | |
1870 | ||
1871 | /* Check to see if the GUARD is zero. */ | |
1872 | guard = get_guard_bits (guard); | |
4185ae53 PB |
1873 | |
1874 | /* Mask off all but the low bit. */ | |
1875 | if (targetm.cxx.guard_mask_bit ()) | |
1876 | { | |
1877 | guard_value = integer_one_node; | |
1878 | if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard))) | |
1879 | guard_value = convert (TREE_TYPE (guard), guard_value); | |
1880 | guard = cp_build_binary_op (BIT_AND_EXPR, guard, guard_value); | |
1881 | } | |
1882 | ||
c395453c MM |
1883 | guard_value = integer_zero_node; |
1884 | if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard))) | |
1885 | guard_value = convert (TREE_TYPE (guard), guard_value); | |
1886 | return cp_build_binary_op (EQ_EXPR, guard, guard_value); | |
1887 | } | |
1888 | ||
1889 | /* Return an expression which sets the GUARD variable, indicating that | |
1890 | the variable being guarded has been initialized. */ | |
1891 | ||
1892 | tree | |
848eed92 | 1893 | set_guard (tree guard) |
c395453c MM |
1894 | { |
1895 | tree guard_init; | |
1896 | ||
1897 | /* Set the GUARD to one. */ | |
1898 | guard = get_guard_bits (guard); | |
1899 | guard_init = integer_one_node; | |
1900 | if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard))) | |
1901 | guard_init = convert (TREE_TYPE (guard), guard_init); | |
1902 | return build_modify_expr (guard, NOP_EXPR, guard_init); | |
67d743fe MS |
1903 | } |
1904 | ||
961ec1a5 JM |
1905 | /* Start the process of running a particular set of global constructors |
1906 | or destructors. Subroutine of do_[cd]tors. */ | |
1907 | ||
914653a2 | 1908 | static tree |
848eed92 | 1909 | start_objects (int method_type, int initp) |
961ec1a5 | 1910 | { |
914653a2 | 1911 | tree body; |
058b15c1 | 1912 | tree fndecl; |
2ce3c6c6 | 1913 | char type[10]; |
961ec1a5 JM |
1914 | |
1915 | /* Make ctor or dtor function. METHOD_TYPE may be 'I' or 'D'. */ | |
1916 | ||
000ab922 | 1917 | if (initp != DEFAULT_INIT_PRIORITY) |
2ce3c6c6 | 1918 | { |
066d147c MH |
1919 | char joiner; |
1920 | ||
1921 | #ifdef JOINER | |
1922 | joiner = JOINER; | |
1923 | #else | |
1924 | joiner = '_'; | |
1925 | #endif | |
2ce3c6c6 | 1926 | |
066d147c | 1927 | sprintf (type, "%c%c%.5u", method_type, joiner, initp); |
2ce3c6c6 JM |
1928 | } |
1929 | else | |
1930 | sprintf (type, "%c", method_type); | |
1931 | ||
058b15c1 MM |
1932 | fndecl = build_lang_decl (FUNCTION_DECL, |
1933 | get_file_function_name_long (type), | |
1934 | build_function_type (void_type_node, | |
1935 | void_list_node)); | |
1936 | start_preparsed_function (fndecl, /*attrs=*/NULL_TREE, SF_PRE_PARSED); | |
961ec1a5 | 1937 | |
14686fcd JL |
1938 | /* It can be a static function as long as collect2 does not have |
1939 | to scan the object file to find its ctor/dtor routine. */ | |
2cc07db4 | 1940 | TREE_PUBLIC (current_function_decl) = ! targetm.have_ctors_dtors; |
b4bb92e5 | 1941 | |
5fdaba89 MM |
1942 | /* Mark this declaration as used to avoid spurious warnings. */ |
1943 | TREE_USED (current_function_decl) = 1; | |
1944 | ||
2b76013c MM |
1945 | /* Mark this function as a global constructor or destructor. */ |
1946 | if (method_type == 'I') | |
1947 | DECL_GLOBAL_CTOR_P (current_function_decl) = 1; | |
1948 | else | |
1949 | DECL_GLOBAL_DTOR_P (current_function_decl) = 1; | |
e2500fed | 1950 | DECL_LANG_SPECIFIC (current_function_decl)->decl_flags.u2sel = 1; |
2b76013c | 1951 | |
325c3691 | 1952 | body = begin_compound_stmt (BCS_FN_BODY); |
b3f738da MM |
1953 | |
1954 | /* We cannot allow these functions to be elided, even if they do not | |
1955 | have external linkage. And, there's no point in deferring | |
34cd5ae7 | 1956 | compilation of thes functions; they're all going to have to be |
b3f738da | 1957 | out anyhow. */ |
096f22f4 PB |
1958 | DECL_INLINE (current_function_decl) = 0; |
1959 | DECL_UNINLINABLE (current_function_decl) = 1; | |
914653a2 MM |
1960 | |
1961 | return body; | |
961ec1a5 JM |
1962 | } |
1963 | ||
1964 | /* Finish the process of running a particular set of global constructors | |
1965 | or destructors. Subroutine of do_[cd]tors. */ | |
1966 | ||
1967 | static void | |
848eed92 | 1968 | finish_objects (int method_type, int initp, tree body) |
961ec1a5 | 1969 | { |
914653a2 | 1970 | tree fn; |
961ec1a5 | 1971 | |
c7cb8979 | 1972 | /* Finish up. */ |
7a3397c7 | 1973 | finish_compound_stmt (body); |
0acf7199 | 1974 | fn = finish_function (0); |
8cd2462c | 1975 | expand_or_defer_fn (fn); |
961ec1a5 | 1976 | |
84df082b MM |
1977 | /* When only doing semantic analysis, and no RTL generation, we |
1978 | can't call functions that directly emit assembly code; there is | |
1979 | no assembly file in which to put the code. */ | |
1980 | if (flag_syntax_only) | |
1981 | return; | |
1982 | ||
2cc07db4 RH |
1983 | if (targetm.have_ctors_dtors) |
1984 | { | |
1985 | rtx fnsym = XEXP (DECL_RTL (fn), 0); | |
1986 | if (method_type == 'I') | |
1987 | (* targetm.asm_out.constructor) (fnsym, initp); | |
1988 | else | |
1989 | (* targetm.asm_out.destructor) (fnsym, initp); | |
1990 | } | |
961ec1a5 JM |
1991 | } |
1992 | ||
0aafb128 MM |
1993 | /* The names of the parameters to the function created to handle |
1994 | initializations and destructions for objects with static storage | |
1995 | duration. */ | |
1996 | #define INITIALIZE_P_IDENTIFIER "__initialize_p" | |
1997 | #define PRIORITY_IDENTIFIER "__priority" | |
1998 | ||
1999 | /* The name of the function we create to handle initializations and | |
2000 | destructions for objects with static storage duration. */ | |
2001 | #define SSDF_IDENTIFIER "__static_initialization_and_destruction" | |
2002 | ||
2003 | /* The declaration for the __INITIALIZE_P argument. */ | |
e2500fed | 2004 | static GTY(()) tree initialize_p_decl; |
0aafb128 MM |
2005 | |
2006 | /* The declaration for the __PRIORITY argument. */ | |
e2500fed | 2007 | static GTY(()) tree priority_decl; |
0aafb128 MM |
2008 | |
2009 | /* The declaration for the static storage duration function. */ | |
e2500fed | 2010 | static GTY(()) tree ssdf_decl; |
0aafb128 | 2011 | |
0352cfc8 MM |
2012 | /* All the static storage duration functions created in this |
2013 | translation unit. */ | |
e2500fed | 2014 | static GTY(()) varray_type ssdf_decls; |
0352cfc8 | 2015 | |
0aafb128 MM |
2016 | /* A map from priority levels to information about that priority |
2017 | level. There may be many such levels, so efficient lookup is | |
2018 | important. */ | |
2019 | static splay_tree priority_info_map; | |
2020 | ||
2021 | /* Begins the generation of the function that will handle all | |
2022 | initialization and destruction of objects with static storage | |
2023 | duration. The function generated takes two parameters of type | |
2024 | `int': __INITIALIZE_P and __PRIORITY. If __INITIALIZE_P is | |
838dfd8a | 2025 | nonzero, it performs initializations. Otherwise, it performs |
0aafb128 MM |
2026 | destructions. It only performs those initializations or |
2027 | destructions with the indicated __PRIORITY. The generated function | |
2028 | returns no value. | |
2029 | ||
2030 | It is assumed that this function will only be called once per | |
2031 | translation unit. */ | |
961ec1a5 | 2032 | |
313bc2c2 | 2033 | static tree |
299f79b5 | 2034 | start_static_storage_duration_function (unsigned count) |
961ec1a5 | 2035 | { |
0aafb128 MM |
2036 | tree parm_types; |
2037 | tree type; | |
313bc2c2 | 2038 | tree body; |
0352cfc8 MM |
2039 | char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32]; |
2040 | ||
2041 | /* Create the identifier for this function. It will be of the form | |
2042 | SSDF_IDENTIFIER_<number>. */ | |
299f79b5 | 2043 | sprintf (id, "%s_%u", SSDF_IDENTIFIER, count); |
0aafb128 MM |
2044 | |
2045 | /* Create the parameters. */ | |
2046 | parm_types = void_list_node; | |
e1b3e07d MM |
2047 | parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types); |
2048 | parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types); | |
0aafb128 MM |
2049 | type = build_function_type (void_type_node, parm_types); |
2050 | ||
2051 | /* Create the FUNCTION_DECL itself. */ | |
2052 | ssdf_decl = build_lang_decl (FUNCTION_DECL, | |
0352cfc8 | 2053 | get_identifier (id), |
0aafb128 MM |
2054 | type); |
2055 | TREE_PUBLIC (ssdf_decl) = 0; | |
2056 | DECL_ARTIFICIAL (ssdf_decl) = 1; | |
0352cfc8 MM |
2057 | |
2058 | /* Put this function in the list of functions to be called from the | |
2059 | static constructors and destructors. */ | |
2060 | if (!ssdf_decls) | |
2061 | { | |
2062 | VARRAY_TREE_INIT (ssdf_decls, 32, "ssdf_decls"); | |
2063 | ||
2064 | /* Take this opportunity to initialize the map from priority | |
a1c65f9f | 2065 | numbers to information about that priority level. */ |
0352cfc8 MM |
2066 | priority_info_map = splay_tree_new (splay_tree_compare_ints, |
2067 | /*delete_key_fn=*/0, | |
2068 | /*delete_value_fn=*/ | |
2069 | (splay_tree_delete_value_fn) &free); | |
2070 | ||
2071 | /* We always need to generate functions for the | |
2072 | DEFAULT_INIT_PRIORITY so enter it now. That way when we walk | |
2073 | priorities later, we'll be sure to find the | |
2074 | DEFAULT_INIT_PRIORITY. */ | |
2075 | get_priority_info (DEFAULT_INIT_PRIORITY); | |
2076 | } | |
2077 | ||
2c0f17dc | 2078 | VARRAY_PUSH_TREE (ssdf_decls, ssdf_decl); |
0aafb128 MM |
2079 | |
2080 | /* Create the argument list. */ | |
8e51619a JM |
2081 | initialize_p_decl = cp_build_parm_decl |
2082 | (get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node); | |
0aafb128 | 2083 | DECL_CONTEXT (initialize_p_decl) = ssdf_decl; |
0aafb128 | 2084 | TREE_USED (initialize_p_decl) = 1; |
8e51619a JM |
2085 | priority_decl = cp_build_parm_decl |
2086 | (get_identifier (PRIORITY_IDENTIFIER), integer_type_node); | |
0aafb128 | 2087 | DECL_CONTEXT (priority_decl) = ssdf_decl; |
0aafb128 MM |
2088 | TREE_USED (priority_decl) = 1; |
2089 | ||
2090 | TREE_CHAIN (initialize_p_decl) = priority_decl; | |
2091 | DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl; | |
2092 | ||
13ef1ec5 MM |
2093 | /* Put the function in the global scope. */ |
2094 | pushdecl (ssdf_decl); | |
2095 | ||
cd0be382 | 2096 | /* Start the function itself. This is equivalent to declaring the |
0aafb128 MM |
2097 | function as: |
2098 | ||
c472cdfd | 2099 | static void __ssdf (int __initialize_p, init __priority_p); |
0aafb128 MM |
2100 | |
2101 | It is static because we only need to call this function from the | |
2102 | various constructor and destructor functions for this module. */ | |
058b15c1 MM |
2103 | start_preparsed_function (ssdf_decl, |
2104 | /*attrs=*/NULL_TREE, | |
2105 | SF_PRE_PARSED); | |
0aafb128 MM |
2106 | |
2107 | /* Set up the scope of the outermost block in the function. */ | |
325c3691 | 2108 | body = begin_compound_stmt (BCS_FN_BODY); |
2ce3c6c6 | 2109 | |
0352cfc8 MM |
2110 | /* This function must not be deferred because we are depending on |
2111 | its compilation to tell us what is TREE_SYMBOL_REFERENCED. */ | |
096f22f4 PB |
2112 | DECL_INLINE (ssdf_decl) = 0; |
2113 | DECL_UNINLINABLE (ssdf_decl) = 1; | |
961ec1a5 | 2114 | |
313bc2c2 | 2115 | return body; |
961ec1a5 JM |
2116 | } |
2117 | ||
0aafb128 MM |
2118 | /* Finish the generation of the function which performs initialization |
2119 | and destruction of objects with static storage duration. After | |
2120 | this point, no more such objects can be created. */ | |
961ec1a5 JM |
2121 | |
2122 | static void | |
848eed92 | 2123 | finish_static_storage_duration_function (tree body) |
961ec1a5 | 2124 | { |
0aafb128 | 2125 | /* Close out the function. */ |
7a3397c7 | 2126 | finish_compound_stmt (body); |
8cd2462c | 2127 | expand_or_defer_fn (finish_function (0)); |
0aafb128 | 2128 | } |
961ec1a5 | 2129 | |
0aafb128 MM |
2130 | /* Return the information about the indicated PRIORITY level. If no |
2131 | code to handle this level has yet been generated, generate the | |
2132 | appropriate prologue. */ | |
961ec1a5 | 2133 | |
0aafb128 | 2134 | static priority_info |
848eed92 | 2135 | get_priority_info (int priority) |
0aafb128 MM |
2136 | { |
2137 | priority_info pi; | |
2138 | splay_tree_node n; | |
2139 | ||
2140 | n = splay_tree_lookup (priority_info_map, | |
2141 | (splay_tree_key) priority); | |
2142 | if (!n) | |
2143 | { | |
2144 | /* Create a new priority information structure, and insert it | |
2145 | into the map. */ | |
c68b0a84 | 2146 | pi = xmalloc (sizeof (struct priority_info_s)); |
0352cfc8 MM |
2147 | pi->initializations_p = 0; |
2148 | pi->destructions_p = 0; | |
0aafb128 MM |
2149 | splay_tree_insert (priority_info_map, |
2150 | (splay_tree_key) priority, | |
2151 | (splay_tree_value) pi); | |
2152 | } | |
2153 | else | |
2154 | pi = (priority_info) n->value; | |
961ec1a5 | 2155 | |
0aafb128 MM |
2156 | return pi; |
2157 | } | |
961ec1a5 | 2158 | |
313bc2c2 | 2159 | /* Set up to handle the initialization or destruction of DECL. If |
838dfd8a | 2160 | INITP is nonzero, we are initializing the variable. Otherwise, we |
313bc2c2 MM |
2161 | are destroying it. */ |
2162 | ||
2163 | static tree | |
848eed92 | 2164 | start_static_initialization_or_destruction (tree decl, int initp) |
313bc2c2 | 2165 | { |
c395453c | 2166 | tree guard_if_stmt = NULL_TREE; |
313bc2c2 MM |
2167 | int priority; |
2168 | tree cond; | |
c395453c | 2169 | tree guard; |
313bc2c2 MM |
2170 | tree init_cond; |
2171 | priority_info pi; | |
2172 | ||
2173 | /* Figure out the priority for this declaration. */ | |
2174 | priority = DECL_INIT_PRIORITY (decl); | |
2175 | if (!priority) | |
2176 | priority = DEFAULT_INIT_PRIORITY; | |
2177 | ||
2178 | /* Remember that we had an initialization or finalization at this | |
2179 | priority. */ | |
2180 | pi = get_priority_info (priority); | |
2181 | if (initp) | |
2182 | pi->initializations_p = 1; | |
2183 | else | |
2184 | pi->destructions_p = 1; | |
2185 | ||
2186 | /* Trick the compiler into thinking we are at the file and line | |
2187 | where DECL was declared so that error-messages make sense, and so | |
2188 | that the debugger will show somewhat sensible file and line | |
2189 | information. */ | |
f31686a3 | 2190 | input_location = DECL_SOURCE_LOCATION (decl); |
313bc2c2 MM |
2191 | |
2192 | /* Because of: | |
2193 | ||
2194 | [class.access.spec] | |
2195 | ||
2196 | Access control for implicit calls to the constructors, | |
2197 | the conversion functions, or the destructor called to | |
2198 | create and destroy a static data member is performed as | |
2199 | if these calls appeared in the scope of the member's | |
2200 | class. | |
2201 | ||
2202 | we pretend we are in a static member function of the class of | |
2203 | which the DECL is a member. */ | |
2204 | if (member_p (decl)) | |
2205 | { | |
4f1c5b7d | 2206 | DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl); |
313bc2c2 MM |
2207 | DECL_STATIC_FUNCTION_P (current_function_decl) = 1; |
2208 | } | |
2209 | ||
2210 | /* Conditionalize this initialization on being in the right priority | |
2211 | and being initializing/finalizing appropriately. */ | |
c395453c | 2212 | guard_if_stmt = begin_if_stmt (); |
ab76ca54 MM |
2213 | cond = cp_build_binary_op (EQ_EXPR, |
2214 | priority_decl, | |
2215 | build_int_2 (priority, 0)); | |
313bc2c2 | 2216 | init_cond = initp ? integer_one_node : integer_zero_node; |
ab76ca54 MM |
2217 | init_cond = cp_build_binary_op (EQ_EXPR, |
2218 | initialize_p_decl, | |
2219 | init_cond); | |
2220 | cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, init_cond); | |
313bc2c2 | 2221 | |
c395453c MM |
2222 | /* Assume we don't need a guard. */ |
2223 | guard = NULL_TREE; | |
2224 | /* We need a guard if this is an object with external linkage that | |
1f6e1acc AS |
2225 | might be initialized in more than one place. (For example, a |
2226 | static data member of a template, when the data member requires | |
2227 | construction.) */ | |
313bc2c2 MM |
2228 | if (TREE_PUBLIC (decl) && (DECL_COMMON (decl) |
2229 | || DECL_ONE_ONLY (decl) | |
2230 | || DECL_WEAK (decl))) | |
2231 | { | |
c395453c | 2232 | tree guard_cond; |
313bc2c2 | 2233 | |
c395453c | 2234 | guard = get_guard (decl); |
313bc2c2 | 2235 | |
c395453c MM |
2236 | /* When using __cxa_atexit, we just check the GUARD as we would |
2237 | for a local static. */ | |
2238 | if (flag_use_cxa_atexit) | |
2239 | { | |
2240 | /* When using __cxa_atexit, we never try to destroy | |
2241 | anything from a static destructor. */ | |
2242 | my_friendly_assert (initp, 20000629); | |
2243 | guard_cond = get_guard_cond (guard); | |
2244 | } | |
5fd893d5 MM |
2245 | /* If we don't have __cxa_atexit, then we will be running |
2246 | destructors from .fini sections, or their equivalents. So, | |
2247 | we need to know how many times we've tried to initialize this | |
2248 | object. We do initializations only if the GUARD is zero, | |
2249 | i.e., if we are the first to initialize the variable. We do | |
2250 | destructions only if the GUARD is one, i.e., if we are the | |
2251 | last to destroy the variable. */ | |
c395453c MM |
2252 | else if (initp) |
2253 | guard_cond | |
ab76ca54 MM |
2254 | = cp_build_binary_op (EQ_EXPR, |
2255 | build_unary_op (PREINCREMENT_EXPR, | |
c395453c | 2256 | guard, |
ab76ca54 MM |
2257 | /*noconvert=*/1), |
2258 | integer_one_node); | |
313bc2c2 | 2259 | else |
c395453c | 2260 | guard_cond |
ab76ca54 MM |
2261 | = cp_build_binary_op (EQ_EXPR, |
2262 | build_unary_op (PREDECREMENT_EXPR, | |
c395453c | 2263 | guard, |
ab76ca54 MM |
2264 | /*noconvert=*/1), |
2265 | integer_zero_node); | |
2266 | ||
c395453c | 2267 | cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, guard_cond); |
313bc2c2 MM |
2268 | } |
2269 | ||
c395453c MM |
2270 | finish_if_stmt_cond (cond, guard_if_stmt); |
2271 | ||
5fd893d5 MM |
2272 | /* If we're using __cxa_atexit, we have not already set the GUARD, |
2273 | so we must do so now. */ | |
2274 | if (guard && initp && flag_use_cxa_atexit) | |
c395453c | 2275 | finish_expr_stmt (set_guard (guard)); |
313bc2c2 | 2276 | |
c395453c | 2277 | return guard_if_stmt; |
313bc2c2 MM |
2278 | } |
2279 | ||
2280 | /* We've just finished generating code to do an initialization or | |
c395453c | 2281 | finalization. GUARD_IF_STMT is the if-statement we used to guard |
313bc2c2 MM |
2282 | the initialization. */ |
2283 | ||
2284 | static void | |
848eed92 | 2285 | finish_static_initialization_or_destruction (tree guard_if_stmt) |
313bc2c2 | 2286 | { |
c395453c | 2287 | finish_then_clause (guard_if_stmt); |
325c3691 | 2288 | finish_if_stmt (guard_if_stmt); |
313bc2c2 MM |
2289 | |
2290 | /* Now that we're done with DECL we don't need to pretend to be a | |
2291 | member of its class any longer. */ | |
4f1c5b7d | 2292 | DECL_CONTEXT (current_function_decl) = NULL_TREE; |
313bc2c2 MM |
2293 | DECL_STATIC_FUNCTION_P (current_function_decl) = 0; |
2294 | } | |
2295 | ||
8e3df2de MM |
2296 | /* Generate code to do the initialization of DECL, a VAR_DECL with |
2297 | static storage duration. The initialization is INIT. */ | |
961ec1a5 | 2298 | |
0aafb128 | 2299 | static void |
848eed92 | 2300 | do_static_initialization (tree decl, tree init) |
0aafb128 | 2301 | { |
c395453c | 2302 | tree guard_if_stmt; |
961ec1a5 | 2303 | |
313bc2c2 | 2304 | /* Set up for the initialization. */ |
c395453c | 2305 | guard_if_stmt |
313bc2c2 MM |
2306 | = start_static_initialization_or_destruction (decl, |
2307 | /*initp=*/1); | |
8e3df2de MM |
2308 | |
2309 | /* Perform the initialization. */ | |
2310 | if (init) | |
2311 | finish_expr_stmt (init); | |
961ec1a5 | 2312 | |
bf419747 MM |
2313 | /* If we're using __cxa_atexit, register a a function that calls the |
2314 | destructor for the object. */ | |
2315 | if (flag_use_cxa_atexit) | |
2316 | register_dtor_fn (decl); | |
2317 | ||
a692ad2e | 2318 | /* Finish up. */ |
c395453c | 2319 | finish_static_initialization_or_destruction (guard_if_stmt); |
0aafb128 | 2320 | } |
961ec1a5 | 2321 | |
0aafb128 | 2322 | /* Generate code to do the static destruction of DECL. If DECL may be |
c395453c | 2323 | initialized more than once in different object files, GUARD is the |
0aafb128 MM |
2324 | guard variable to check. PRIORITY is the priority for the |
2325 | destruction. */ | |
2326 | ||
2327 | static void | |
848eed92 | 2328 | do_static_destruction (tree decl) |
0aafb128 | 2329 | { |
c395453c | 2330 | tree guard_if_stmt; |
961ec1a5 | 2331 | |
bf419747 MM |
2332 | /* If we're using __cxa_atexit, then destructors are registered |
2333 | immediately after objects are initialized. */ | |
2334 | my_friendly_assert (!flag_use_cxa_atexit, 20000121); | |
2335 | ||
0aafb128 | 2336 | /* If we don't need a destructor, there's nothing to do. */ |
834c6dff | 2337 | if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl))) |
0aafb128 | 2338 | return; |
bf419747 | 2339 | |
f1dedc31 | 2340 | /* Actually do the destruction. */ |
c395453c | 2341 | guard_if_stmt = start_static_initialization_or_destruction (decl, |
8e3df2de | 2342 | /*initp=*/0); |
313bc2c2 | 2343 | finish_expr_stmt (build_cleanup (decl)); |
c395453c | 2344 | finish_static_initialization_or_destruction (guard_if_stmt); |
961ec1a5 JM |
2345 | } |
2346 | ||
313bc2c2 MM |
2347 | /* VARS is a list of variables with static storage duration which may |
2348 | need initialization and/or finalization. Remove those variables | |
2349 | that don't really need to be initialized or finalized, and return | |
2350 | the resulting list. The order in which the variables appear in | |
2351 | VARS is in reverse order of the order in which they should actually | |
2352 | be initialized. The list we return is in the unreversed order; | |
2353 | i.e., the first variable should be initialized first. */ | |
8d08fdba | 2354 | |
313bc2c2 | 2355 | static tree |
cec24319 | 2356 | prune_vars_needing_no_initialization (tree *vars) |
8d08fdba | 2357 | { |
cec24319 MM |
2358 | tree *var = vars; |
2359 | tree result = NULL_TREE; | |
8d08fdba | 2360 | |
cec24319 | 2361 | while (*var) |
313bc2c2 | 2362 | { |
cec24319 MM |
2363 | tree t = *var; |
2364 | tree decl = TREE_VALUE (t); | |
2365 | tree init = TREE_PURPOSE (t); | |
8d2733ca | 2366 | |
313bc2c2 MM |
2367 | /* Deal gracefully with error. */ |
2368 | if (decl == error_mark_node) | |
cec24319 MM |
2369 | { |
2370 | var = &TREE_CHAIN (t); | |
2371 | continue; | |
2372 | } | |
5566b478 | 2373 | |
313bc2c2 MM |
2374 | /* The only things that can be initialized are variables. */ |
2375 | my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 19990420); | |
8d08fdba | 2376 | |
313bc2c2 MM |
2377 | /* If this object is not defined, we don't need to do anything |
2378 | here. */ | |
2379 | if (DECL_EXTERNAL (decl)) | |
cec24319 MM |
2380 | { |
2381 | var = &TREE_CHAIN (t); | |
2382 | continue; | |
2383 | } | |
8d08fdba | 2384 | |
313bc2c2 MM |
2385 | /* Also, if the initializer already contains errors, we can bail |
2386 | out now. */ | |
2387 | if (init && TREE_CODE (init) == TREE_LIST | |
2388 | && value_member (error_mark_node, init)) | |
cec24319 MM |
2389 | { |
2390 | var = &TREE_CHAIN (t); | |
2391 | continue; | |
2392 | } | |
d18c083e | 2393 | |
313bc2c2 MM |
2394 | /* This variable is going to need initialization and/or |
2395 | finalization, so we add it to the list. */ | |
cec24319 MM |
2396 | *var = TREE_CHAIN (t); |
2397 | TREE_CHAIN (t) = result; | |
2398 | result = t; | |
313bc2c2 | 2399 | } |
1139b3d8 | 2400 | |
313bc2c2 MM |
2401 | return result; |
2402 | } | |
1139b3d8 | 2403 | |
313bc2c2 MM |
2404 | /* Make sure we have told the back end about all the variables in |
2405 | VARS. */ | |
0aafb128 | 2406 | |
313bc2c2 | 2407 | static void |
848eed92 | 2408 | write_out_vars (tree vars) |
313bc2c2 MM |
2409 | { |
2410 | tree v; | |
0aafb128 | 2411 | |
313bc2c2 | 2412 | for (v = vars; v; v = TREE_CHAIN (v)) |
c4d2313d | 2413 | if (!var_finalized_p (TREE_VALUE (v))) |
313bc2c2 | 2414 | rest_of_decl_compilation (TREE_VALUE (v), 0, 1, 1); |
0aafb128 | 2415 | } |
909e536a | 2416 | |
0aafb128 MM |
2417 | /* Generate a static constructor (if CONSTRUCTOR_P) or destructor |
2418 | (otherwise) that will initialize all gobal objects with static | |
2419 | storage duration having the indicated PRIORITY. */ | |
73aad9b9 | 2420 | |
0aafb128 | 2421 | static void |
299f79b5 NS |
2422 | generate_ctor_or_dtor_function (bool constructor_p, int priority, |
2423 | location_t *locus) | |
0aafb128 MM |
2424 | { |
2425 | char function_key; | |
2426 | tree arguments; | |
35b4a576 | 2427 | tree fndecl; |
914653a2 | 2428 | tree body; |
0352cfc8 | 2429 | size_t i; |
73aad9b9 | 2430 | |
82a98427 | 2431 | input_location = *locus; |
93409b8c PB |
2432 | #ifdef USE_MAPPED_LOCATION |
2433 | /* ??? */ | |
2434 | #else | |
82a98427 | 2435 | locus->line++; |
93409b8c | 2436 | #endif |
299f79b5 | 2437 | |
0aafb128 MM |
2438 | /* We use `I' to indicate initialization and `D' to indicate |
2439 | destruction. */ | |
35b4a576 | 2440 | function_key = constructor_p ? 'I' : 'D'; |
73aad9b9 | 2441 | |
35b4a576 RS |
2442 | /* We emit the function lazily, to avoid generating empty |
2443 | global constructors and destructors. */ | |
2444 | body = NULL_TREE; | |
2c73f9f5 | 2445 | |
0aafb128 MM |
2446 | /* Call the static storage duration function with appropriate |
2447 | arguments. */ | |
400fbc08 MM |
2448 | if (ssdf_decls) |
2449 | for (i = 0; i < ssdf_decls->elements_used; ++i) | |
2450 | { | |
35b4a576 RS |
2451 | fndecl = VARRAY_TREE (ssdf_decls, i); |
2452 | ||
2453 | /* Calls to pure or const functions will expand to nothing. */ | |
2454 | if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE))) | |
2455 | { | |
2456 | if (! body) | |
2457 | body = start_objects (function_key, priority); | |
2458 | ||
2459 | arguments = tree_cons (NULL_TREE, build_int_2 (priority, 0), | |
2460 | NULL_TREE); | |
2461 | arguments = tree_cons (NULL_TREE, build_int_2 (constructor_p, 0), | |
2462 | arguments); | |
2463 | finish_expr_stmt (build_function_call (fndecl, arguments)); | |
2464 | } | |
400fbc08 | 2465 | } |
909e536a | 2466 | |
0aafb128 MM |
2467 | /* If we're generating code for the DEFAULT_INIT_PRIORITY, throw in |
2468 | calls to any functions marked with attributes indicating that | |
2469 | they should be called at initialization- or destruction-time. */ | |
2470 | if (priority == DEFAULT_INIT_PRIORITY) | |
2471 | { | |
2472 | tree fns; | |
400fbc08 | 2473 | |
0aafb128 MM |
2474 | for (fns = constructor_p ? static_ctors : static_dtors; |
2475 | fns; | |
2476 | fns = TREE_CHAIN (fns)) | |
35b4a576 RS |
2477 | { |
2478 | fndecl = TREE_VALUE (fns); | |
2479 | ||
2480 | /* Calls to pure/const functions will expand to nothing. */ | |
2481 | if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE))) | |
2482 | { | |
2483 | if (! body) | |
2484 | body = start_objects (function_key, priority); | |
2485 | finish_expr_stmt (build_function_call (fndecl, NULL_TREE)); | |
2486 | } | |
2487 | } | |
0aafb128 | 2488 | } |
28cbf42c | 2489 | |
0aafb128 | 2490 | /* Close out the function. */ |
35b4a576 RS |
2491 | if (body) |
2492 | finish_objects (function_key, priority, body); | |
0aafb128 | 2493 | } |
44a8d0b3 | 2494 | |
0aafb128 | 2495 | /* Generate constructor and destructor functions for the priority |
0352cfc8 | 2496 | indicated by N. */ |
44a8d0b3 | 2497 | |
0aafb128 | 2498 | static int |
299f79b5 | 2499 | generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data) |
0aafb128 | 2500 | { |
299f79b5 | 2501 | location_t *locus = data; |
0aafb128 MM |
2502 | int priority = (int) n->key; |
2503 | priority_info pi = (priority_info) n->value; | |
0aafb128 MM |
2504 | |
2505 | /* Generate the functions themselves, but only if they are really | |
2506 | needed. */ | |
0352cfc8 | 2507 | if (pi->initializations_p |
0aafb128 | 2508 | || (priority == DEFAULT_INIT_PRIORITY && static_ctors)) |
299f79b5 | 2509 | generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus); |
0352cfc8 | 2510 | if (pi->destructions_p |
0aafb128 | 2511 | || (priority == DEFAULT_INIT_PRIORITY && static_dtors)) |
299f79b5 | 2512 | generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus); |
0aafb128 MM |
2513 | |
2514 | /* Keep iterating. */ | |
2515 | return 0; | |
2516 | } | |
2ce3c6c6 | 2517 | |
25c84396 RH |
2518 | /* Called via LANGHOOK_CALLGRAPH_ANALYZE_EXPR. It is supposed to mark |
2519 | decls referenced from frontend specific constructs; it will be called | |
2520 | only for language-specific tree nodes. | |
2521 | ||
2522 | Here we must deal with member pointers. */ | |
2523 | ||
2524 | tree | |
08deda2f | 2525 | cxx_callgraph_analyze_expr (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, |
25c84396 | 2526 | tree from ATTRIBUTE_UNUSED) |
8cd2462c | 2527 | { |
dd07abd7 RH |
2528 | tree t = *tp; |
2529 | ||
2344a722 JH |
2530 | if (flag_unit_at_a_time) |
2531 | switch (TREE_CODE (t)) | |
2532 | { | |
2533 | case PTRMEM_CST: | |
2534 | if (TYPE_PTRMEMFUNC_P (TREE_TYPE (t))) | |
2535 | cgraph_mark_needed_node (cgraph_node (PTRMEM_CST_MEMBER (t))); | |
2536 | break; | |
2537 | case BASELINK: | |
2538 | if (TREE_CODE (BASELINK_FUNCTIONS (t)) == FUNCTION_DECL) | |
2539 | cgraph_mark_needed_node (cgraph_node (BASELINK_FUNCTIONS (t))); | |
2540 | break; | |
2541 | ||
2542 | default: | |
2543 | break; | |
2544 | } | |
dd07abd7 | 2545 | |
25c84396 | 2546 | return NULL; |
8cd2462c JH |
2547 | } |
2548 | ||
0aafb128 MM |
2549 | /* This routine is called from the last rule in yyparse (). |
2550 | Its job is to create all the code needed to initialize and | |
2551 | destroy the global aggregates. We do the destruction | |
2552 | first, since that way we only need to reverse the decls once. */ | |
44a8d0b3 | 2553 | |
0aafb128 | 2554 | void |
edaf3e03 | 2555 | finish_file (void) |
0aafb128 | 2556 | { |
0aafb128 | 2557 | tree vars; |
848eed92 | 2558 | bool reconsider; |
0aafb128 | 2559 | size_t i; |
299f79b5 NS |
2560 | location_t locus; |
2561 | unsigned ssdf_count = 0; | |
8d08fdba | 2562 | |
82a98427 | 2563 | locus = input_location; |
0aafb128 | 2564 | at_eof = 1; |
faae18ab | 2565 | |
0aafb128 MM |
2566 | /* Bad parse errors. Just forget about it. */ |
2567 | if (! global_bindings_p () || current_class_type || decl_namespace_list) | |
2568 | return; | |
8d08fdba | 2569 | |
17211ab5 GK |
2570 | if (pch_file) |
2571 | c_common_write_pch (); | |
2572 | ||
93409b8c PB |
2573 | #ifdef USE_MAPPED_LOCATION |
2574 | /* FIXME - huh? */ | |
2575 | #else | |
0aafb128 MM |
2576 | /* Otherwise, GDB can get confused, because in only knows |
2577 | about source for LINENO-1 lines. */ | |
d479d37f | 2578 | input_line -= 1; |
93409b8c | 2579 | #endif |
5566b478 | 2580 | |
0aafb128 MM |
2581 | interface_unknown = 1; |
2582 | interface_only = 0; | |
ea735e02 | 2583 | |
0aafb128 MM |
2584 | /* We now have to write out all the stuff we put off writing out. |
2585 | These include: | |
d2e5ee5c | 2586 | |
0aafb128 MM |
2587 | o Template specializations that we have not yet instantiated, |
2588 | but which are needed. | |
2589 | o Initialization and destruction for non-local objects with | |
2590 | static storage duration. (Local objects with static storage | |
2591 | duration are initialized when their scope is first entered, | |
2592 | and are cleaned up via atexit.) | |
2593 | o Virtual function tables. | |
ea735e02 | 2594 | |
0aafb128 MM |
2595 | All of these may cause others to be needed. For example, |
2596 | instantiating one function may cause another to be needed, and | |
0a288b9a | 2597 | generating the initializer for an object may cause templates to be |
0aafb128 | 2598 | instantiated, etc., etc. */ |
8d08fdba | 2599 | |
2a9a326b | 2600 | timevar_push (TV_VARCONST); |
8d08fdba | 2601 | |
8fa33dfa | 2602 | emit_support_tinfos (); |
6de9cd9a | 2603 | |
0aafb128 MM |
2604 | do |
2605 | { | |
548502d3 | 2606 | tree t; |
a260bce6 | 2607 | size_t n_old, n_new; |
548502d3 | 2608 | |
848eed92 | 2609 | reconsider = false; |
0aafb128 | 2610 | |
1a6580ec MM |
2611 | /* If there are templates that we've put off instantiating, do |
2612 | them now. */ | |
0aafb128 | 2613 | instantiate_pending_templates (); |
d34cb6a1 | 2614 | ggc_collect (); |
0aafb128 | 2615 | |
6eabb241 | 2616 | /* Write out virtual tables as required. Note that writing out |
9aad8f83 MA |
2617 | the virtual table for a template class may cause the |
2618 | instantiation of members of that class. If we write out | |
2619 | vtables then we remove the class from our list so we don't | |
9bcb9aae | 2620 | have to look at it again. */ |
9aad8f83 MA |
2621 | |
2622 | while (keyed_classes != NULL_TREE | |
2623 | && maybe_emit_vtables (TREE_VALUE (keyed_classes))) | |
2624 | { | |
a260bce6 | 2625 | reconsider = true; |
9aad8f83 MA |
2626 | keyed_classes = TREE_CHAIN (keyed_classes); |
2627 | } | |
2628 | ||
2629 | t = keyed_classes; | |
2630 | if (t != NULL_TREE) | |
2631 | { | |
2632 | tree next = TREE_CHAIN (t); | |
2633 | ||
2634 | while (next) | |
2635 | { | |
2636 | if (maybe_emit_vtables (TREE_VALUE (next))) | |
2637 | { | |
a260bce6 | 2638 | reconsider = true; |
9aad8f83 MA |
2639 | TREE_CHAIN (t) = TREE_CHAIN (next); |
2640 | } | |
2641 | else | |
2642 | t = next; | |
2643 | ||
2644 | next = TREE_CHAIN (t); | |
2645 | } | |
2646 | } | |
2647 | ||
a260bce6 MA |
2648 | /* Write out needed type info variables. We have to be careful |
2649 | looping through unemitted decls, because emit_tinfo_decl may | |
2650 | cause other variables to be needed. We stick new elements | |
2651 | (and old elements that we may need to reconsider) at the end | |
2652 | of the array, then shift them back to the beginning once we're | |
9bcb9aae | 2653 | done. */ |
a260bce6 MA |
2654 | |
2655 | n_old = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls); | |
2656 | for (i = 0; i < n_old; ++i) | |
2657 | { | |
2658 | tree tinfo_decl = VARRAY_TREE (unemitted_tinfo_decls, i); | |
2659 | if (emit_tinfo_decl (tinfo_decl)) | |
2660 | reconsider = true; | |
2661 | else | |
2662 | VARRAY_PUSH_TREE (unemitted_tinfo_decls, tinfo_decl); | |
2663 | } | |
2664 | ||
2665 | /* The only elements we want to keep are the new ones. Copy | |
2666 | them to the beginning of the array, then get rid of the | |
9bcb9aae | 2667 | leftovers. */ |
a260bce6 | 2668 | n_new = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) - n_old; |
e4d91027 RH |
2669 | if (n_new) |
2670 | memmove (&VARRAY_TREE (unemitted_tinfo_decls, 0), | |
2671 | &VARRAY_TREE (unemitted_tinfo_decls, n_old), | |
2672 | n_new * sizeof (tree)); | |
a260bce6 | 2673 | memset (&VARRAY_TREE (unemitted_tinfo_decls, n_new), |
e4d91027 | 2674 | 0, n_old * sizeof (tree)); |
a260bce6 | 2675 | VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) = n_new; |
7267d692 | 2676 | |
0aafb128 | 2677 | /* The list of objects with static storage duration is built up |
313bc2c2 MM |
2678 | in reverse order. We clear STATIC_AGGREGATES so that any new |
2679 | aggregates added during the initialization of these will be | |
2680 | initialized in the correct order when we next come around the | |
2681 | loop. */ | |
cec24319 | 2682 | vars = prune_vars_needing_no_initialization (&static_aggregates); |
c472cdfd | 2683 | |
313bc2c2 MM |
2684 | if (vars) |
2685 | { | |
2686 | tree v; | |
2687 | ||
2688 | /* We need to start a new initialization function each time | |
2689 | through the loop. That's because we need to know which | |
2690 | vtables have been referenced, and TREE_SYMBOL_REFERENCED | |
2691 | isn't computed until a function is finished, and written | |
2692 | out. That's a deficiency in the back-end. When this is | |
2693 | fixed, these initialization functions could all become | |
2694 | inline, with resulting performance improvements. */ | |
299f79b5 NS |
2695 | tree ssdf_body; |
2696 | ||
2697 | /* Set the line and file, so that it is obviously not from | |
2698 | the source file. */ | |
82a98427 | 2699 | input_location = locus; |
299f79b5 | 2700 | ssdf_body = start_static_storage_duration_function (ssdf_count); |
313bc2c2 MM |
2701 | |
2702 | /* Make sure the back end knows about all the variables. */ | |
2703 | write_out_vars (vars); | |
2704 | ||
2705 | /* First generate code to do all the initializations. */ | |
2706 | for (v = vars; v; v = TREE_CHAIN (v)) | |
2707 | do_static_initialization (TREE_VALUE (v), | |
2708 | TREE_PURPOSE (v)); | |
2709 | ||
2710 | /* Then, generate code to do all the destructions. Do these | |
2711 | in reverse order so that the most recently constructed | |
bf419747 MM |
2712 | variable is the first destroyed. If we're using |
2713 | __cxa_atexit, then we don't need to do this; functions | |
4c0aad2c | 2714 | were registered at initialization time to destroy the |
bf419747 MM |
2715 | local statics. */ |
2716 | if (!flag_use_cxa_atexit) | |
2717 | { | |
2718 | vars = nreverse (vars); | |
2719 | for (v = vars; v; v = TREE_CHAIN (v)) | |
2720 | do_static_destruction (TREE_VALUE (v)); | |
2721 | } | |
2722 | else | |
2723 | vars = NULL_TREE; | |
313bc2c2 MM |
2724 | |
2725 | /* Finish up the static storage duration function for this | |
2726 | round. */ | |
82a98427 | 2727 | input_location = locus; |
313bc2c2 MM |
2728 | finish_static_storage_duration_function (ssdf_body); |
2729 | ||
2730 | /* All those initializations and finalizations might cause | |
2731 | us to need more inline functions, more template | |
2732 | instantiations, etc. */ | |
848eed92 | 2733 | reconsider = true; |
299f79b5 | 2734 | ssdf_count++; |
93409b8c PB |
2735 | #ifdef USE_MAPPED_LOCATION |
2736 | /* ??? */ | |
2737 | #else | |
299f79b5 | 2738 | locus.line++; |
93409b8c | 2739 | #endif |
0aafb128 | 2740 | } |
0aafb128 | 2741 | |
56e770bf | 2742 | for (i = 0; i < deferred_fns_used; ++i) |
0aafb128 | 2743 | { |
56e770bf | 2744 | tree decl = VARRAY_TREE (deferred_fns, i); |
ea56c40c | 2745 | |
2f0c006e GK |
2746 | if (! DECL_DECLARED_INLINE_P (decl) || ! TREE_USED (decl)) |
2747 | abort (); | |
2748 | ||
eab5474f | 2749 | /* Does it need synthesizing? */ |
0aafb128 MM |
2750 | if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl) |
2751 | && TREE_USED (decl) | |
2752 | && (! DECL_REALLY_EXTERN (decl) || DECL_INLINE (decl))) | |
2753 | { | |
2754 | /* Even though we're already at the top-level, we push | |
2755 | there again. That way, when we pop back a few lines | |
2756 | hence, all of our state is restored. Otherwise, | |
2757 | finish_function doesn't clean things up, and we end | |
2758 | up with CURRENT_FUNCTION_DECL set. */ | |
2759 | push_to_top_level (); | |
1f84ec23 | 2760 | synthesize_method (decl); |
0aafb128 | 2761 | pop_from_top_level (); |
848eed92 | 2762 | reconsider = true; |
0aafb128 | 2763 | } |
0aafb128 | 2764 | |
ea56c40c | 2765 | if (!DECL_SAVED_TREE (decl)) |
2f0c006e | 2766 | continue; |
ea56c40c | 2767 | |
e2b69423 MM |
2768 | import_export_decl (decl); |
2769 | ||
eab5474f NS |
2770 | /* We lie to the back-end, pretending that some functions |
2771 | are not defined when they really are. This keeps these | |
2772 | functions from being put out unnecessarily. But, we must | |
2773 | stop lying when the functions are referenced, or if they | |
2774 | are not comdat since they need to be put out now. This | |
2775 | is done in a separate for cycle, because if some deferred | |
2776 | function is contained in another deferred function later | |
2777 | in deferred_fns varray, rest_of_compilation would skip | |
2778 | this function and we really cannot expand the same | |
2779 | function twice. */ | |
4cb02ea1 MM |
2780 | if (DECL_NOT_REALLY_EXTERN (decl) |
2781 | && DECL_INITIAL (decl) | |
7c913d33 | 2782 | && DECL_NEEDED_P (decl)) |
4cb02ea1 | 2783 | DECL_EXTERNAL (decl) = 0; |
21b0c6dc MM |
2784 | |
2785 | /* If we're going to need to write this function out, and | |
2786 | there's already a body for it, create RTL for it now. | |
2787 | (There might be no body if this is a method we haven't | |
2788 | gotten around to synthesizing yet.) */ | |
2789 | if (!DECL_EXTERNAL (decl) | |
7c913d33 | 2790 | && DECL_NEEDED_P (decl) |
8cd2462c JH |
2791 | && !TREE_ASM_WRITTEN (decl) |
2792 | && (!flag_unit_at_a_time | |
2793 | || !cgraph_node (decl)->local.finalized)) | |
21b0c6dc | 2794 | { |
8cd2462c JH |
2795 | /* We will output the function; no longer consider it in this |
2796 | loop. */ | |
2797 | DECL_DEFER_OUTPUT (decl) = 0; | |
21b0c6dc MM |
2798 | /* Generate RTL for this function now that we know we |
2799 | need it. */ | |
8cd2462c | 2800 | expand_or_defer_fn (decl); |
21b0c6dc MM |
2801 | /* If we're compiling -fsyntax-only pretend that this |
2802 | function has been written out so that we don't try to | |
2803 | expand it again. */ | |
2804 | if (flag_syntax_only) | |
2805 | TREE_ASM_WRITTEN (decl) = 1; | |
848eed92 | 2806 | reconsider = true; |
21b0c6dc | 2807 | } |
4cb02ea1 MM |
2808 | } |
2809 | ||
4cb02ea1 | 2810 | if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0)) |
848eed92 | 2811 | reconsider = true; |
0aafb128 MM |
2812 | |
2813 | /* Static data members are just like namespace-scope globals. */ | |
2814 | for (i = 0; i < pending_statics_used; ++i) | |
2815 | { | |
2816 | tree decl = VARRAY_TREE (pending_statics, i); | |
c4d2313d | 2817 | if (var_finalized_p (decl)) |
0aafb128 MM |
2818 | continue; |
2819 | import_export_decl (decl); | |
2820 | if (DECL_NOT_REALLY_EXTERN (decl) && ! DECL_IN_AGGR_P (decl)) | |
2821 | DECL_EXTERNAL (decl) = 0; | |
2822 | } | |
4cb02ea1 MM |
2823 | if (pending_statics |
2824 | && wrapup_global_declarations (&VARRAY_TREE (pending_statics, 0), | |
2825 | pending_statics_used)) | |
848eed92 | 2826 | reconsider = true; |
f6d1b84a RH |
2827 | |
2828 | if (cgraph_assemble_pending_functions ()) | |
2829 | reconsider = true; | |
0352cfc8 | 2830 | } |
0aafb128 | 2831 | while (reconsider); |
28cbf42c | 2832 | |
9bcb9aae | 2833 | /* All used inline functions must have a definition at this point. */ |
eab5474f NS |
2834 | for (i = 0; i < deferred_fns_used; ++i) |
2835 | { | |
2836 | tree decl = VARRAY_TREE (deferred_fns, i); | |
2837 | ||
2f0c006e GK |
2838 | if (!TREE_ASM_WRITTEN (decl) && !DECL_SAVED_TREE (decl) |
2839 | /* An explicit instantiation can be used to specify | |
2840 | that the body is in another unit. It will have | |
2841 | already verified there was a definition. */ | |
2842 | && !DECL_EXPLICIT_INSTANTIATION (decl)) | |
3cfabe60 NS |
2843 | { |
2844 | cp_warning_at ("inline function `%D' used but never defined", decl); | |
2845 | /* This symbol is effectively an "extern" declaration now. | |
2846 | This is not strictly necessary, but removes a duplicate | |
2847 | warning. */ | |
2848 | TREE_PUBLIC (decl) = 1; | |
2849 | } | |
2850 | ||
eab5474f NS |
2851 | } |
2852 | ||
0352cfc8 MM |
2853 | /* We give C linkage to static constructors and destructors. */ |
2854 | push_lang_context (lang_name_c); | |
2855 | ||
2856 | /* Generate initialization and destruction functions for all | |
2857 | priorities for which they are required. */ | |
2858 | if (priority_info_map) | |
2859 | splay_tree_foreach (priority_info_map, | |
2860 | generate_ctor_and_dtor_functions_for_priority, | |
299f79b5 | 2861 | /*data=*/&locus); |
400fbc08 MM |
2862 | else |
2863 | { | |
299f79b5 | 2864 | |
400fbc08 MM |
2865 | if (static_ctors) |
2866 | generate_ctor_or_dtor_function (/*constructor_p=*/true, | |
299f79b5 | 2867 | DEFAULT_INIT_PRIORITY, &locus); |
400fbc08 MM |
2868 | if (static_dtors) |
2869 | generate_ctor_or_dtor_function (/*constructor_p=*/false, | |
299f79b5 | 2870 | DEFAULT_INIT_PRIORITY, &locus); |
400fbc08 | 2871 | } |
0352cfc8 MM |
2872 | |
2873 | /* We're done with the splay-tree now. */ | |
2874 | if (priority_info_map) | |
2875 | splay_tree_delete (priority_info_map); | |
2876 | ||
2877 | /* We're done with static constructors, so we can go back to "C++" | |
2878 | linkage now. */ | |
2879 | pop_lang_context (); | |
2880 | ||
8cd2462c JH |
2881 | if (flag_unit_at_a_time) |
2882 | { | |
2883 | cgraph_finalize_compilation_unit (); | |
2884 | cgraph_optimize (); | |
2885 | } | |
2886 | ||
6de9cd9a DN |
2887 | /* Emit mudflap static registration function. This must be done |
2888 | after all the user functions have been expanded. */ | |
2889 | if (flag_mudflap) | |
2890 | mudflap_finish_file (); | |
2891 | ||
0aafb128 | 2892 | /* Now, issue warnings about static, but not defined, functions, |
033ed340 | 2893 | etc., and emit debugging information. */ |
0aafb128 | 2894 | walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider); |
033ed340 JM |
2895 | if (pending_statics) |
2896 | check_global_declarations (&VARRAY_TREE (pending_statics, 0), | |
2897 | pending_statics_used); | |
b7484fbe | 2898 | |
faae18ab MS |
2899 | finish_repo (); |
2900 | ||
f71f87f9 | 2901 | /* The entire file is now complete. If requested, dump everything |
a1c65f9f | 2902 | to a file. */ |
b7442fb5 NS |
2903 | { |
2904 | int flags; | |
6de9cd9a | 2905 | FILE *stream = dump_begin (TDI_tu, &flags); |
b7442fb5 NS |
2906 | |
2907 | if (stream) | |
2908 | { | |
2909 | dump_node (global_namespace, flags & ~TDF_SLIM, stream); | |
6de9cd9a | 2910 | dump_end (TDI_tu, stream); |
b7442fb5 NS |
2911 | } |
2912 | } | |
2913 | ||
2a9a326b | 2914 | timevar_pop (TV_VARCONST); |
8d08fdba MS |
2915 | |
2916 | if (flag_detailed_statistics) | |
27bb8339 JM |
2917 | { |
2918 | dump_tree_statistics (); | |
2919 | dump_time_statistics (); | |
2920 | } | |
82a98427 | 2921 | input_location = locus; |
5bd61841 MM |
2922 | |
2923 | #ifdef ENABLE_CHECKING | |
2924 | validate_conversion_obstack (); | |
2925 | #endif /* ENABLE_CHECKING */ | |
8d08fdba | 2926 | } |
51c184be | 2927 | |
018a5803 NS |
2928 | /* FN is an OFFSET_REF, DOTSTAR_EXPR or MEMBER_REF indicating the |
2929 | function to call in parse-tree form; it has not yet been | |
2930 | semantically analyzed. ARGS are the arguments to the function. | |
2931 | They have already been semantically analyzed. */ | |
4ba126e4 MM |
2932 | |
2933 | tree | |
2934 | build_offset_ref_call_from_tree (tree fn, tree args) | |
2935 | { | |
d17811fd MM |
2936 | tree orig_fn; |
2937 | tree orig_args; | |
2938 | tree expr; | |
018a5803 | 2939 | tree object; |
4ba126e4 | 2940 | |
d17811fd MM |
2941 | orig_fn = fn; |
2942 | orig_args = args; | |
018a5803 | 2943 | object = TREE_OPERAND (fn, 0); |
d17811fd MM |
2944 | |
2945 | if (processing_template_decl) | |
2946 | { | |
d17811fd MM |
2947 | my_friendly_assert (TREE_CODE (fn) == DOTSTAR_EXPR |
2948 | || TREE_CODE (fn) == MEMBER_REF, | |
2949 | 20030708); | |
2950 | if (type_dependent_expression_p (fn) | |
2951 | || any_type_dependent_arguments_p (args)) | |
6de9cd9a | 2952 | return build_min_nt (CALL_EXPR, fn, args, NULL_TREE); |
d17811fd MM |
2953 | |
2954 | /* Transform the arguments and add the implicit "this" | |
2955 | parameter. That must be done before the FN is transformed | |
2956 | because we depend on the form of FN. */ | |
2957 | args = build_non_dependent_args (args); | |
d17811fd | 2958 | if (TREE_CODE (fn) == DOTSTAR_EXPR) |
018a5803 NS |
2959 | object = build_unary_op (ADDR_EXPR, object, 0); |
2960 | object = build_non_dependent_expr (object); | |
d17811fd MM |
2961 | args = tree_cons (NULL_TREE, object, args); |
2962 | /* Now that the arguments are done, transform FN. */ | |
2963 | fn = build_non_dependent_expr (fn); | |
2964 | } | |
4ba126e4 | 2965 | |
ee76b931 MM |
2966 | /* A qualified name corresponding to a bound pointer-to-member is |
2967 | represented as an OFFSET_REF: | |
4ba126e4 MM |
2968 | |
2969 | struct B { void g(); }; | |
2970 | void (B::*p)(); | |
2971 | void B::g() { (this->*p)(); } */ | |
d17811fd | 2972 | if (TREE_CODE (fn) == OFFSET_REF) |
4ba126e4 | 2973 | { |
018a5803 | 2974 | tree object_addr = build_unary_op (ADDR_EXPR, object, 0); |
4ba126e4 MM |
2975 | fn = TREE_OPERAND (fn, 1); |
2976 | fn = get_member_function_from_ptrfunc (&object_addr, fn); | |
6e9554e1 | 2977 | args = tree_cons (NULL_TREE, object_addr, args); |
4ba126e4 | 2978 | } |
4ba126e4 | 2979 | |
d17811fd MM |
2980 | expr = build_function_call (fn, args); |
2981 | if (processing_template_decl && expr != error_mark_node) | |
6de9cd9a | 2982 | return build_min_non_dep (CALL_EXPR, expr, orig_fn, orig_args, NULL_TREE); |
d17811fd | 2983 | return expr; |
4ba126e4 | 2984 | } |
9da99f7d | 2985 | |
f30432d7 MS |
2986 | |
2987 | void | |
848eed92 | 2988 | check_default_args (tree x) |
f30432d7 MS |
2989 | { |
2990 | tree arg = TYPE_ARG_TYPES (TREE_TYPE (x)); | |
848eed92 GDR |
2991 | bool saw_def = false; |
2992 | int i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE); | |
f30432d7 MS |
2993 | for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i) |
2994 | { | |
2995 | if (TREE_PURPOSE (arg)) | |
848eed92 | 2996 | saw_def = true; |
f30432d7 MS |
2997 | else if (saw_def) |
2998 | { | |
8251199e | 2999 | cp_error_at ("default argument missing for parameter %P of `%+#D'", |
b7698cf0 | 3000 | i, x); |
f30432d7 MS |
3001 | break; |
3002 | } | |
3003 | } | |
3004 | } | |
72b7eeff MS |
3005 | |
3006 | void | |
848eed92 | 3007 | mark_used (tree decl) |
72b7eeff MS |
3008 | { |
3009 | TREE_USED (decl) = 1; | |
ac5f3b67 | 3010 | if (processing_template_decl || skip_evaluation) |
5566b478 | 3011 | return; |
eab5474f NS |
3012 | |
3013 | if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl) | |
3014 | && !TREE_ASM_WRITTEN (decl)) | |
3015 | /* Remember it, so we can check it was defined. */ | |
2f0c006e GK |
3016 | { |
3017 | if (DECL_DEFERRED_FN (decl)) | |
3018 | return; | |
3019 | DECL_DEFERRED_FN (decl) = 1; | |
3020 | DECL_DEFER_OUTPUT (decl) = 1; | |
3021 | if (!deferred_fns) | |
3022 | VARRAY_TREE_INIT (deferred_fns, 32, "deferred_fns"); | |
3023 | ||
3024 | VARRAY_PUSH_TREE (deferred_fns, decl); | |
3025 | } | |
3026 | ||
ac5f3b67 | 3027 | assemble_external (decl); |
36a117a5 | 3028 | |
73aad9b9 | 3029 | /* Is it a synthesized method that needs to be synthesized? */ |
4f1c5b7d MM |
3030 | if (TREE_CODE (decl) == FUNCTION_DECL |
3031 | && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl) | |
3032 | && DECL_ARTIFICIAL (decl) | |
4c4646b5 | 3033 | && !DECL_THUNK_P (decl) |
4f1c5b7d | 3034 | && ! DECL_INITIAL (decl) |
73aad9b9 JM |
3035 | /* Kludge: don't synthesize for default args. */ |
3036 | && current_function_decl) | |
db9b2174 MM |
3037 | { |
3038 | synthesize_method (decl); | |
3039 | /* If we've already synthesized the method we don't need to | |
3040 | instantiate it, so we can return right away. */ | |
3041 | return; | |
3042 | } | |
36a117a5 MM |
3043 | |
3044 | /* If this is a function or variable that is an instance of some | |
3045 | template, we now know that we will need to actually do the | |
7c355bca | 3046 | instantiation. We check that DECL is not an explicit |
03d0f4af | 3047 | instantiation because that is not checked in instantiate_decl. */ |
872f37f9 | 3048 | if ((DECL_NON_THUNK_FUNCTION_P (decl) || TREE_CODE (decl) == VAR_DECL) |
03d0f4af | 3049 | && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl) |
7610f2ce | 3050 | && (!DECL_EXPLICIT_INSTANTIATION (decl) |
d58b7c2d MM |
3051 | || (TREE_CODE (decl) == FUNCTION_DECL |
3052 | && DECL_INLINE (DECL_TEMPLATE_RESULT | |
3053 | (template_for_substitution (decl)))))) | |
b2dd096b MM |
3054 | { |
3055 | bool defer; | |
3056 | ||
3057 | /* Normally, we put off instantiating functions in order to | |
3058 | improve compile times. Maintaining a stack of active | |
3059 | functions is expensive, and the inliner knows to | |
3060 | instantiate any functions it might need. | |
3061 | ||
3062 | However, if instantiating this function might help us mark | |
3063 | the current function TREE_NOTHROW, we go ahead and | |
d34cb6a1 JH |
3064 | instantiate it now. |
3065 | ||
3066 | This is not needed for unit-at-a-time since we reorder the functions | |
3067 | in topological order anyway. | |
3068 | */ | |
b2dd096b | 3069 | defer = (!flag_exceptions |
d34cb6a1 JH |
3070 | || flag_unit_at_a_time |
3071 | || !optimize | |
b2dd096b MM |
3072 | || TREE_CODE (decl) != FUNCTION_DECL |
3073 | /* If the called function can't throw, we don't need to | |
3074 | generate its body to find that out. */ | |
3075 | || TREE_NOTHROW (decl) | |
3076 | || !cfun | |
a7485e93 | 3077 | || !current_function_decl |
b2dd096b MM |
3078 | /* If we already know the current function can't throw, |
3079 | then we don't need to work hard to prove it. */ | |
3080 | || TREE_NOTHROW (current_function_decl) | |
3081 | /* If we already know that the current function *can* | |
3082 | throw, there's no point in gathering more | |
3083 | information. */ | |
3084 | || cp_function_chain->can_throw); | |
3085 | ||
415c974c | 3086 | instantiate_decl (decl, defer, /*undefined_ok=*/0); |
b2dd096b | 3087 | } |
72b7eeff | 3088 | } |
f62dbf03 | 3089 | |
e2500fed | 3090 | #include "gt-cp-decl2.h" |