]>
Commit | Line | Data |
---|---|---|
af86cc06 | 1 | /* Process declarations and variables for C++ compiler. |
20c01ba9 | 2 | Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, |
c3a5d13a | 3 | 2001, 2002, 2003, 2004 Free Software Foundation, Inc. |
997d68fe | 4 | Contributed by Michael Tiemann (tiemann@cygnus.com) |
471086d6 | 5 | |
510c8531 | 6 | This file is part of GCC. |
471086d6 | 7 | |
510c8531 | 8 | GCC is free software; you can redistribute it and/or modify |
471086d6 | 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 | ||
510c8531 | 13 | GCC is distributed in the hope that it will be useful, |
471086d6 | 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 | |
510c8531 | 19 | along with GCC; see the file COPYING. If not, write to |
c58d4270 | 20 | the Free Software Foundation, 59 Temple Place - Suite 330, |
21 | Boston, MA 02111-1307, USA. */ | |
471086d6 | 22 | |
23 | ||
510c8531 | 24 | /* Process declarations and symbol lookup for C++ front end. |
471086d6 | 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 | ||
471086d6 | 31 | #include "config.h" |
b3ef7553 | 32 | #include "system.h" |
805e22b2 | 33 | #include "coretypes.h" |
34 | #include "tm.h" | |
471086d6 | 35 | #include "tree.h" |
36 | #include "rtl.h" | |
f7c44134 | 37 | #include "expr.h" |
471086d6 | 38 | #include "flags.h" |
39 | #include "cp-tree.h" | |
1e3b023c | 40 | #include "tree-inline.h" |
471086d6 | 41 | #include "decl.h" |
71ccdfff | 42 | #include "output.h" |
43 | #include "except.h" | |
2a4e40b0 | 44 | #include "toplev.h" |
1f3233d1 | 45 | #include "hashtab.h" |
aed0bd19 | 46 | #include "tm_p.h" |
a767736d | 47 | #include "target.h" |
5f3cead1 | 48 | #include "c-common.h" |
5626f4cd | 49 | #include "c-pragma.h" |
6cd31fa5 | 50 | #include "diagnostic.h" |
1f3233d1 | 51 | #include "debug.h" |
851fe51a | 52 | #include "timevar.h" |
4ee9c684 | 53 | #include "tree-flow.h" |
471086d6 | 54 | |
4b9b2871 | 55 | static tree grokparms (cp_parameter_declarator *, tree *); |
1b72315d | 56 | static const char *redeclaration_error_message (tree, tree); |
57 | ||
1b72315d | 58 | static int decl_jump_unsafe (tree); |
1b72315d | 59 | static void require_complete_types_for_parms (tree); |
60 | static int ambi_op_p (enum tree_code); | |
61 | static int unary_op_p (enum tree_code); | |
1b72315d | 62 | static void push_local_name (tree); |
d7d79557 | 63 | static tree grok_reference_init (tree, tree, tree, tree *); |
7ef14399 | 64 | static tree grokfndecl (tree, tree, tree, tree, tree, int, |
2cfb6cde | 65 | enum overload_flags, cp_cv_quals, |
1b72315d | 66 | tree, int, int, int, int, int, int, tree); |
491e04ef | 67 | static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *, |
6493c502 | 68 | int, int, tree); |
1b72315d | 69 | static void record_unknown_type (tree, const char *); |
4dee9c0e | 70 | static tree builtin_function_1 (const char *, tree, tree, |
71 | enum built_in_function code, | |
72 | enum built_in_class cl, const char *, | |
1b72315d | 73 | tree); |
74 | static tree build_library_fn_1 (tree, enum tree_code, tree); | |
75 | static int member_function_or_else (tree, tree, enum overload_flags); | |
76 | static void bad_specifiers (tree, const char *, int, int, int, int, | |
77 | int); | |
1b72315d | 78 | static void check_for_uninitialized_const_var (tree); |
79 | static hashval_t typename_hash (const void *); | |
80 | static int typename_compare (const void *, const void *); | |
1b72315d | 81 | static tree local_variable_p_walkfn (tree *, int *, void *); |
1b72315d | 82 | static tree record_builtin_java_type (const char *, int); |
83 | static const char *tag_name (enum tag_types code); | |
1b72315d | 84 | static int walk_namespaces_r (tree, walk_namespaces_fn, void *); |
85 | static int walk_globals_r (tree, void*); | |
86 | static int walk_vtables_r (tree, void*); | |
1b72315d | 87 | static tree make_label_decl (tree, int); |
88 | static void use_label (tree); | |
89 | static void check_previous_goto_1 (tree, struct cp_binding_level *, tree, | |
7727e009 | 90 | const location_t *); |
1b72315d | 91 | static void check_previous_goto (struct named_label_use_list *); |
92 | static void check_switch_goto (struct cp_binding_level *); | |
93 | static void check_previous_gotos (tree); | |
94 | static void pop_label (tree, tree); | |
95 | static void pop_labels (tree); | |
96 | static void maybe_deduce_size_from_array_init (tree, tree); | |
97 | static void layout_var_decl (tree); | |
98 | static void maybe_commonize_var (tree); | |
d7d79557 | 99 | static tree check_initializer (tree, tree, int, tree *); |
1b72315d | 100 | static void make_rtl_for_nonlocal_decl (tree, tree, const char *); |
101 | static void save_function_data (tree); | |
102 | static void check_function_type (tree, tree); | |
1b72315d | 103 | static void finish_constructor_body (void); |
104 | static void begin_destructor_body (void); | |
105 | static void finish_destructor_body (void); | |
106 | static tree create_array_type_for_decl (tree, tree, tree); | |
107 | static tree get_atexit_node (void); | |
108 | static tree get_dso_handle_node (void); | |
109 | static tree start_cleanup_fn (void); | |
110 | static void end_cleanup_fn (void); | |
111 | static tree cp_make_fname_decl (tree, int); | |
112 | static void initialize_predefined_identifiers (void); | |
491e04ef | 113 | static tree check_special_function_return_type |
1b72315d | 114 | (special_function_kind, tree, tree); |
115 | static tree push_cp_library_fn (enum tree_code, tree); | |
116 | static tree build_cp_library_fn (tree, enum tree_code, tree); | |
117 | static void store_parm_decls (tree); | |
2437a99c | 118 | static void initialize_local_var (tree, tree); |
119 | static void expand_static_init (tree, tree); | |
120 | static tree next_initializable_field (tree); | |
121 | static tree reshape_init (tree, tree *); | |
954ad420 | 122 | static tree build_typename_type (tree, tree, tree); |
471086d6 | 123 | |
471086d6 | 124 | /* Erroneous argument lists can use this *IFF* they do not modify it. */ |
125 | tree error_mark_list; | |
126 | ||
72040e7e | 127 | /* The following symbols are subsumed in the cp_global_trees array, and |
980877d7 | 128 | listed here individually for documentation purposes. |
471086d6 | 129 | |
72040e7e | 130 | C++ extensions |
131 | tree wchar_decl_node; | |
c4a8ac95 | 132 | |
72040e7e | 133 | tree vtable_entry_type; |
134 | tree delta_type_node; | |
72040e7e | 135 | tree __t_desc_type_node; |
73a07fbc | 136 | tree ti_desc_type_node; |
378e5add | 137 | tree bltn_desc_type_node, ptr_desc_type_node; |
73a07fbc | 138 | tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node; |
139 | tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node; | |
15acd583 | 140 | tree ptm_desc_type_node; |
73a07fbc | 141 | tree base_desc_type_node; |
471086d6 | 142 | |
38253b86 | 143 | tree class_type_node; |
72040e7e | 144 | tree unknown_type_node; |
471086d6 | 145 | |
72040e7e | 146 | Array type `vtable_entry_type[]' |
471086d6 | 147 | |
72040e7e | 148 | tree vtbl_type_node; |
149 | tree vtbl_ptr_type_node; | |
471086d6 | 150 | |
13d8774b | 151 | Namespaces, |
471086d6 | 152 | |
72040e7e | 153 | tree std_node; |
13d8774b | 154 | tree abi_node; |
471086d6 | 155 | |
72040e7e | 156 | A FUNCTION_DECL which can call `abort'. Not necessarily the |
157 | one that the user will declare, but sufficient to be called | |
158 | by routines that want to abort the program. | |
471086d6 | 159 | |
72040e7e | 160 | tree abort_fndecl; |
471086d6 | 161 | |
72040e7e | 162 | The FUNCTION_DECL for the default `::operator delete'. |
bb0726a1 | 163 | |
72040e7e | 164 | tree global_delete_fndecl; |
471086d6 | 165 | |
72040e7e | 166 | Used by RTTI |
442fd60a | 167 | tree type_info_type_node, tinfo_decl_id, tinfo_decl_type; |
168 | tree tinfo_var_id; | |
169 | ||
72040e7e | 170 | */ |
471086d6 | 171 | |
72040e7e | 172 | tree cp_global_trees[CPTI_MAX]; |
471086d6 | 173 | |
8417823c | 174 | /* Indicates that there is a type value in some namespace, although |
72040e7e | 175 | that is not necessarily in scope at the moment. */ |
8417823c | 176 | |
836495aa | 177 | tree global_type_node; |
8417823c | 178 | |
7bfd46d1 | 179 | /* The node that holds the "name" of the global scope. */ |
836495aa | 180 | tree global_scope_name; |
7bfd46d1 | 181 | |
c48d6aec | 182 | /* Used only for jumps to as-yet undefined labels, since jumps to |
183 | defined labels can have their validity checked immediately. */ | |
184 | ||
1f3233d1 | 185 | struct named_label_use_list GTY(()) |
1ad432f2 | 186 | { |
1f3233d1 | 187 | struct cp_binding_level *binding_level; |
1ad432f2 | 188 | tree names_in_scope; |
189 | tree label_decl; | |
7727e009 | 190 | location_t o_goto_locus; |
c48d6aec | 191 | struct named_label_use_list *next; |
1ad432f2 | 192 | }; |
193 | ||
18a4cb16 | 194 | #define named_label_uses cp_function_chain->x_named_label_uses |
471086d6 | 195 | |
e6393a02 | 196 | #define local_names cp_function_chain->x_local_names |
197 | ||
471086d6 | 198 | /* A list of objects which have constructors or destructors |
199 | which reside in the global scope. The decl is stored in | |
200 | the TREE_VALUE slot and the initializer is stored | |
201 | in the TREE_PURPOSE slot. */ | |
202 | tree static_aggregates; | |
203 | ||
471086d6 | 204 | /* -- end of C++ */ |
205 | ||
775e7cc0 | 206 | /* A node for the integer constants 2, and 3. */ |
2739960c | 207 | |
775e7cc0 | 208 | tree integer_two_node, integer_three_node; |
471086d6 | 209 | |
c48d6aec | 210 | /* A list of all LABEL_DECLs in the function that have names. Here so |
211 | we can clear out their names' definitions at the end of the | |
212 | function, and so we can check the validity of jumps to these labels. */ | |
213 | ||
1f3233d1 | 214 | struct named_label_list GTY(()) |
c48d6aec | 215 | { |
1f3233d1 | 216 | struct cp_binding_level *binding_level; |
c48d6aec | 217 | tree names_in_scope; |
218 | tree old_value; | |
219 | tree label_decl; | |
220 | tree bad_decls; | |
c48d6aec | 221 | struct named_label_list *next; |
65750829 | 222 | unsigned int in_try_scope : 1; |
223 | unsigned int in_catch_scope : 1; | |
c48d6aec | 224 | }; |
471086d6 | 225 | |
1e463950 | 226 | #define named_labels cp_function_chain->x_named_labels |
471086d6 | 227 | \f |
3563027c | 228 | /* The number of function bodies which we are currently processing. |
229 | (Zero if we are at namespace scope, one inside the body of a | |
230 | function, two inside the body of a function in a local class, etc.) */ | |
231 | int function_depth; | |
88da234d | 232 | |
233 | /* States indicating how grokdeclarator() should handle declspecs marked | |
234 | with __attribute__((deprecated)). An object declared as | |
235 | __attribute__((deprecated)) suppresses warnings of uses of other | |
236 | deprecated items. */ | |
491e04ef | 237 | |
88da234d | 238 | enum deprecated_states { |
239 | DEPRECATED_NORMAL, | |
240 | DEPRECATED_SUPPRESS | |
241 | }; | |
242 | ||
243 | static enum deprecated_states deprecated_state = DEPRECATED_NORMAL; | |
244 | ||
92c38d80 | 245 | /* True if a declaration with an `extern' linkage specifier is being |
246 | processed. */ | |
247 | bool have_extern_spec; | |
248 | ||
471086d6 | 249 | \f |
242fc35c | 250 | /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or |
251 | UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the | |
252 | time the VAR_DECL was declared, the type was incomplete. */ | |
253 | ||
1f3233d1 | 254 | static GTY(()) tree incomplete_vars; |
471086d6 | 255 | \f |
3467e461 | 256 | /* Returns the kind of template specialization we are currently |
257 | processing, given that it's declaration contained N_CLASS_SCOPES | |
258 | explicit scope qualifications. */ | |
259 | ||
260 | tmpl_spec_kind | |
1b72315d | 261 | current_tmpl_spec_kind (int n_class_scopes) |
3467e461 | 262 | { |
263 | int n_template_parm_scopes = 0; | |
264 | int seen_specialization_p = 0; | |
265 | int innermost_specialization_p = 0; | |
1f3233d1 | 266 | struct cp_binding_level *b; |
3467e461 | 267 | |
268 | /* Scan through the template parameter scopes. */ | |
491e04ef | 269 | for (b = current_binding_level; |
270 | b->kind == sk_template_parms; | |
37b9a732 | 271 | b = b->level_chain) |
3467e461 | 272 | { |
273 | /* If we see a specialization scope inside a parameter scope, | |
274 | then something is wrong. That corresponds to a declaration | |
275 | like: | |
276 | ||
277 | template <class T> template <> ... | |
278 | ||
6c0cc2cd | 279 | which is always invalid since [temp.expl.spec] forbids the |
3467e461 | 280 | specialization of a class member template if the enclosing |
281 | class templates are not explicitly specialized as well. */ | |
37b9a732 | 282 | if (b->explicit_spec_p) |
3467e461 | 283 | { |
284 | if (n_template_parm_scopes == 0) | |
285 | innermost_specialization_p = 1; | |
286 | else | |
287 | seen_specialization_p = 1; | |
288 | } | |
289 | else if (seen_specialization_p == 1) | |
290 | return tsk_invalid_member_spec; | |
291 | ||
292 | ++n_template_parm_scopes; | |
293 | } | |
294 | ||
295 | /* Handle explicit instantiations. */ | |
296 | if (processing_explicit_instantiation) | |
297 | { | |
298 | if (n_template_parm_scopes != 0) | |
299 | /* We've seen a template parameter list during an explicit | |
300 | instantiation. For example: | |
301 | ||
302 | template <class T> template void f(int); | |
303 | ||
304 | This is erroneous. */ | |
305 | return tsk_invalid_expl_inst; | |
306 | else | |
307 | return tsk_expl_inst; | |
308 | } | |
309 | ||
310 | if (n_template_parm_scopes < n_class_scopes) | |
311 | /* We've not seen enough template headers to match all the | |
312 | specialized classes present. For example: | |
313 | ||
314 | template <class T> void R<T>::S<T>::f(int); | |
315 | ||
6c0cc2cd | 316 | This is invalid; there needs to be one set of template |
3467e461 | 317 | parameters for each class. */ |
318 | return tsk_insufficient_parms; | |
319 | else if (n_template_parm_scopes == n_class_scopes) | |
320 | /* We're processing a non-template declaration (even though it may | |
321 | be a member of a template class.) For example: | |
322 | ||
323 | template <class T> void S<T>::f(int); | |
324 | ||
325 | The `class T' maches the `S<T>', leaving no template headers | |
326 | corresponding to the `f'. */ | |
327 | return tsk_none; | |
328 | else if (n_template_parm_scopes > n_class_scopes + 1) | |
329 | /* We've got too many template headers. For example: | |
330 | ||
331 | template <> template <class T> void f (T); | |
332 | ||
333 | There need to be more enclosing classes. */ | |
334 | return tsk_excessive_parms; | |
335 | else | |
336 | /* This must be a template. It's of the form: | |
337 | ||
338 | template <class T> template <class U> void S<T>::f(U); | |
339 | ||
340 | This is a specialization if the innermost level was a | |
341 | specialization; otherwise it's just a definition of the | |
342 | template. */ | |
343 | return innermost_specialization_p ? tsk_expl_spec : tsk_template; | |
471086d6 | 344 | } |
345 | ||
3467e461 | 346 | /* Exit the current scope. */ |
347 | ||
348 | void | |
1b72315d | 349 | finish_scope (void) |
3467e461 | 350 | { |
351 | poplevel (0, 0, 0); | |
352 | } | |
353 | ||
2d46e540 | 354 | /* When a label goes out of scope, check to see if that label was used |
355 | in a valid manner, and issue any appropriate warnings or errors. */ | |
356 | ||
357 | static void | |
1b72315d | 358 | pop_label (tree label, tree old_value) |
2d46e540 | 359 | { |
37b9a732 | 360 | if (!processing_template_decl) |
2d46e540 | 361 | { |
149a6627 | 362 | if (DECL_INITIAL (label) == NULL_TREE) |
363 | { | |
92ddaf90 | 364 | location_t location; |
365 | ||
149a6627 | 366 | cp_error_at ("label `%D' used but not defined", label); |
357f7efa | 367 | #ifdef USE_MAPPED_LOCATION |
368 | location = input_location; /* FIXME want (input_filename, (line)0) */ | |
369 | #else | |
92ddaf90 | 370 | location.file = input_filename; |
371 | location.line = 0; | |
357f7efa | 372 | #endif |
149a6627 | 373 | /* Avoid crashing later. */ |
92ddaf90 | 374 | define_label (location, DECL_NAME (label)); |
149a6627 | 375 | } |
6dfd0eba | 376 | else if (warn_unused_label && !TREE_USED (label)) |
149a6627 | 377 | cp_warning_at ("label `%D' defined but not used", label); |
2d46e540 | 378 | } |
2d46e540 | 379 | |
c48d6aec | 380 | SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value); |
2d46e540 | 381 | } |
382 | ||
9594b69d | 383 | /* At the end of a function, all labels declared within the function |
980877d7 | 384 | go out of scope. BLOCK is the top-level block for the |
2d46e540 | 385 | function. */ |
386 | ||
387 | static void | |
1b72315d | 388 | pop_labels (tree block) |
2d46e540 | 389 | { |
c48d6aec | 390 | struct named_label_list *link; |
2d46e540 | 391 | |
392 | /* Clear out the definitions of all label names, since their scopes | |
393 | end here. */ | |
c48d6aec | 394 | for (link = named_labels; link; link = link->next) |
2d46e540 | 395 | { |
c48d6aec | 396 | pop_label (link->label_decl, link->old_value); |
2d46e540 | 397 | /* Put the labels into the "variables" of the top-level block, |
398 | so debugger can see them. */ | |
c48d6aec | 399 | TREE_CHAIN (link->label_decl) = BLOCK_VARS (block); |
400 | BLOCK_VARS (block) = link->label_decl; | |
2d46e540 | 401 | } |
402 | ||
c48d6aec | 403 | named_labels = NULL; |
2d46e540 | 404 | } |
405 | ||
abf1c5d5 | 406 | /* The following two routines are used to interface to Objective-C++. |
407 | The binding level is purposely treated as an opaque type. */ | |
408 | ||
409 | void * | |
410 | objc_get_current_scope (void) | |
411 | { | |
412 | return current_binding_level; | |
413 | } | |
414 | ||
415 | /* The following routine is used by the NeXT-style SJLJ exceptions; | |
416 | variables get marked 'volatile' so as to not be clobbered by | |
ed904873 | 417 | _setjmp()/_longjmp() calls. All variables in the current scope, |
418 | as well as parent scopes up to (but not including) ENCLOSING_BLK | |
419 | shall be thusly marked. */ | |
abf1c5d5 | 420 | |
421 | void | |
422 | objc_mark_locals_volatile (void *enclosing_blk) | |
423 | { | |
424 | struct cp_binding_level *scope; | |
425 | ||
426 | for (scope = current_binding_level; | |
427 | scope && scope != enclosing_blk && scope->kind == sk_block; | |
428 | scope = scope->level_chain) | |
429 | { | |
430 | tree decl; | |
431 | ||
432 | for (decl = scope->names; decl; decl = TREE_CHAIN (decl)) | |
433 | { | |
ed904873 | 434 | if (TREE_CODE (decl) == VAR_DECL) |
435 | { | |
436 | DECL_REGISTER (decl) = 0; | |
437 | TREE_THIS_VOLATILE (decl) = 1; | |
438 | } | |
abf1c5d5 | 439 | } |
440 | } | |
441 | } | |
442 | ||
471086d6 | 443 | /* Exit a binding level. |
444 | Pop the level off, and restore the state of the identifier-decl mappings | |
445 | that were in effect when this level was entered. | |
446 | ||
447 | If KEEP == 1, this level had explicit declarations, so | |
448 | and create a "block" (a BLOCK node) for the level | |
449 | to record its declarations and subblocks for symbol table output. | |
450 | ||
471086d6 | 451 | If FUNCTIONBODY is nonzero, this level is the body of a function, |
452 | so create a block as if KEEP were set and also clear out all | |
453 | label names. | |
454 | ||
455 | If REVERSE is nonzero, reverse the order of decls before putting | |
456 | them into the BLOCK. */ | |
457 | ||
458 | tree | |
1b72315d | 459 | poplevel (int keep, int reverse, int functionbody) |
471086d6 | 460 | { |
cd16867a | 461 | tree link; |
471086d6 | 462 | /* The chain of decls was accumulated in reverse order. |
463 | Put it into forward order, just for cleanliness. */ | |
464 | tree decls; | |
465 | int tmp = functionbody; | |
e0e489c4 | 466 | int real_functionbody; |
e0e489c4 | 467 | tree subblocks; |
2363ef00 | 468 | tree block; |
471086d6 | 469 | tree decl; |
53137e6a | 470 | int leaving_for_scope; |
e880f232 | 471 | scope_kind kind; |
53137e6a | 472 | |
851fe51a | 473 | timevar_push (TV_NAME_LOOKUP); |
2363ef00 | 474 | restart: |
475 | ||
476 | block = NULL_TREE; | |
e0e489c4 | 477 | |
b4df430b | 478 | gcc_assert (current_binding_level->kind != sk_class); |
8fc54128 | 479 | |
e880f232 | 480 | real_functionbody = (current_binding_level->kind == sk_cleanup |
e0e489c4 | 481 | ? ((functionbody = 0), tmp) : functionbody); |
e0e489c4 | 482 | subblocks = functionbody >= 0 ? current_binding_level->blocks : 0; |
483 | ||
b4df430b | 484 | gcc_assert (!VEC_length(cp_class_binding, |
485 | current_binding_level->class_shadowed)); | |
471086d6 | 486 | |
ef3eb7cc | 487 | /* We used to use KEEP == 2 to indicate that the new block should go |
488 | at the beginning of the list of blocks at this binding level, | |
489 | rather than the end. This hack is no longer used. */ | |
b4df430b | 490 | gcc_assert (keep == 0 || keep == 1); |
ef3eb7cc | 491 | |
e880f232 | 492 | if (current_binding_level->keep) |
471086d6 | 493 | keep = 1; |
494 | ||
c48d6aec | 495 | /* Any uses of undefined labels, and any defined labels, now operate |
496 | under constraints of next binding contour. */ | |
497 | if (cfun && !functionbody) | |
498 | { | |
1f3233d1 | 499 | struct cp_binding_level *level_chain; |
c48d6aec | 500 | level_chain = current_binding_level->level_chain; |
501 | if (level_chain) | |
502 | { | |
503 | struct named_label_use_list *uses; | |
504 | struct named_label_list *labels; | |
505 | for (labels = named_labels; labels; labels = labels->next) | |
506 | if (labels->binding_level == current_binding_level) | |
507 | { | |
508 | tree decl; | |
37b9a732 | 509 | if (current_binding_level->kind == sk_try) |
65750829 | 510 | labels->in_try_scope = 1; |
37b9a732 | 511 | if (current_binding_level->kind == sk_catch) |
65750829 | 512 | labels->in_catch_scope = 1; |
c48d6aec | 513 | for (decl = labels->names_in_scope; decl; |
514 | decl = TREE_CHAIN (decl)) | |
515 | if (decl_jump_unsafe (decl)) | |
516 | labels->bad_decls = tree_cons (NULL_TREE, decl, | |
517 | labels->bad_decls); | |
518 | labels->binding_level = level_chain; | |
519 | labels->names_in_scope = level_chain->names; | |
520 | } | |
521 | ||
522 | for (uses = named_label_uses; uses; uses = uses->next) | |
523 | if (uses->binding_level == current_binding_level) | |
524 | { | |
525 | uses->binding_level = level_chain; | |
526 | uses->names_in_scope = level_chain->names; | |
527 | } | |
528 | } | |
529 | } | |
530 | ||
471086d6 | 531 | /* Get the decls in the order they were written. |
532 | Usually current_binding_level->names is in reverse order. | |
533 | But parameter decls were previously put in forward order. */ | |
534 | ||
535 | if (reverse) | |
536 | current_binding_level->names | |
537 | = decls = nreverse (current_binding_level->names); | |
538 | else | |
539 | decls = current_binding_level->names; | |
540 | ||
471086d6 | 541 | /* If there were any declarations or structure tags in that level, |
542 | or if this level is a function body, | |
543 | create a BLOCK to record them for the life of this function. */ | |
471086d6 | 544 | block = NULL_TREE; |
6528331d | 545 | if (keep == 1 || functionbody) |
471086d6 | 546 | block = make_node (BLOCK); |
547 | if (block != NULL_TREE) | |
548 | { | |
6528331d | 549 | BLOCK_VARS (block) = decls; |
550 | BLOCK_SUBBLOCKS (block) = subblocks; | |
471086d6 | 551 | } |
552 | ||
553 | /* In each subblock, record that this is its superior. */ | |
471086d6 | 554 | if (keep >= 0) |
555 | for (link = subblocks; link; link = TREE_CHAIN (link)) | |
556 | BLOCK_SUPERCONTEXT (link) = block; | |
557 | ||
53137e6a | 558 | /* We still support the old for-scope rules, whereby the variables |
559 | in a for-init statement were in scope after the for-statement | |
6e9029b4 | 560 | ended. We only use the new rules if flag_new_for_scope is |
53137e6a | 561 | nonzero. */ |
980877d7 | 562 | leaving_for_scope |
37b9a732 | 563 | = current_binding_level->kind == sk_for && flag_new_for_scope == 1; |
53137e6a | 564 | |
491e04ef | 565 | /* Before we remove the declarations first check for unused variables. */ |
566 | if (warn_unused_variable | |
567 | && !processing_template_decl) | |
568 | for (decl = getdecls (); decl; decl = TREE_CHAIN (decl)) | |
569 | if (TREE_CODE (decl) == VAR_DECL | |
570 | && ! TREE_USED (decl) | |
571 | && ! DECL_IN_SYSTEM_HEADER (decl) | |
572 | && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl)) | |
573 | warning ("%Junused variable '%D'", decl, decl); | |
574 | ||
53137e6a | 575 | /* Remove declarations for all the DECLs in this level. */ |
576 | for (link = decls; link; link = TREE_CHAIN (link)) | |
577 | { | |
7108eaab | 578 | if (leaving_for_scope && TREE_CODE (link) == VAR_DECL |
579 | && DECL_NAME (link)) | |
53137e6a | 580 | { |
d09ae6d5 | 581 | tree name = DECL_NAME (link); |
582 | cxx_binding *ob; | |
53137e6a | 583 | tree ns_binding; |
584 | ||
d09ae6d5 | 585 | ob = outer_binding (name, |
586 | IDENTIFIER_BINDING (name), | |
587 | /*class_p=*/true); | |
588 | if (!ob) | |
589 | ns_binding = IDENTIFIER_NAMESPACE_VALUE (name); | |
ac63fdff | 590 | else |
591 | ns_binding = NULL_TREE; | |
592 | ||
d09ae6d5 | 593 | if (ob && ob->scope == current_binding_level->level_chain) |
53137e6a | 594 | /* We have something like: |
980877d7 | 595 | |
53137e6a | 596 | int i; |
597 | for (int i; ;); | |
980877d7 | 598 | |
53137e6a | 599 | and we are leaving the `for' scope. There's no reason to |
600 | keep the binding of the inner `i' in this case. */ | |
d09ae6d5 | 601 | pop_binding (name, link); |
602 | else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL)) | |
76608a37 | 603 | || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL)) |
53137e6a | 604 | /* Here, we have something like: |
605 | ||
606 | typedef int I; | |
607 | ||
608 | void f () { | |
609 | for (int I; ;); | |
610 | } | |
611 | ||
612 | We must pop the for-scope binding so we know what's a | |
613 | type and what isn't. */ | |
d09ae6d5 | 614 | pop_binding (name, link); |
e4ce2dc4 | 615 | else |
e4ce2dc4 | 616 | { |
53137e6a | 617 | /* Mark this VAR_DECL as dead so that we can tell we left it |
618 | there only for backward compatibility. */ | |
619 | DECL_DEAD_FOR_LOCAL (link) = 1; | |
980877d7 | 620 | |
b8afbea5 | 621 | /* Keep track of what should have happened when we |
53137e6a | 622 | popped the binding. */ |
d09ae6d5 | 623 | if (ob && ob->value) |
624 | DECL_SHADOWED_FOR_VAR (link) = ob->value; | |
53137e6a | 625 | |
626 | /* Add it to the list of dead variables in the next | |
627 | outermost binding to that we can remove these when we | |
628 | leave that binding. */ | |
629 | current_binding_level->level_chain->dead_vars_from_for | |
630 | = tree_cons (NULL_TREE, link, | |
631 | current_binding_level->level_chain-> | |
632 | dead_vars_from_for); | |
633 | ||
771cf831 | 634 | /* Although we don't pop the cxx_binding, we do clear |
76608a37 | 635 | its SCOPE since the scope is going away now. */ |
491e04ef | 636 | IDENTIFIER_BINDING (name)->scope |
d09ae6d5 | 637 | = current_binding_level->level_chain; |
e4ce2dc4 | 638 | } |
de9554eb | 639 | } |
980877d7 | 640 | else |
0a4a126e | 641 | { |
092b1d6f | 642 | tree name; |
643 | ||
53137e6a | 644 | /* Remove the binding. */ |
2da051b5 | 645 | decl = link; |
491e04ef | 646 | |
2da051b5 | 647 | if (TREE_CODE (decl) == TREE_LIST) |
648 | decl = TREE_VALUE (decl); | |
092b1d6f | 649 | name = decl; |
650 | ||
651 | if (TREE_CODE (name) == OVERLOAD) | |
652 | name = OVL_FUNCTION (name); | |
491e04ef | 653 | |
092b1d6f | 654 | gcc_assert (DECL_P (name)); |
655 | pop_binding (DECL_NAME (name), decl); | |
471086d6 | 656 | } |
53137e6a | 657 | } |
471086d6 | 658 | |
53137e6a | 659 | /* Remove declarations for any `for' variables from inner scopes |
660 | that we kept around. */ | |
661 | for (link = current_binding_level->dead_vars_from_for; | |
662 | link; link = TREE_CHAIN (link)) | |
2b77484d | 663 | pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link)); |
de9554eb | 664 | |
53137e6a | 665 | /* Restore the IDENTIFIER_TYPE_VALUEs. */ |
666 | for (link = current_binding_level->type_shadowed; | |
667 | link; link = TREE_CHAIN (link)) | |
668 | SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link)); | |
2d46e540 | 669 | |
670 | /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */ | |
671 | for (link = current_binding_level->shadowed_labels; | |
980877d7 | 672 | link; |
2d46e540 | 673 | link = TREE_CHAIN (link)) |
c48d6aec | 674 | pop_label (TREE_VALUE (link), TREE_PURPOSE (link)); |
2d46e540 | 675 | |
53137e6a | 676 | /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs |
677 | list if a `using' declaration put them there. The debugging | |
678 | back-ends won't understand OVERLOAD, so we remove them here. | |
679 | Because the BLOCK_VARS are (temporarily) shared with | |
680 | CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have | |
681 | popped all the bindings. */ | |
682 | if (block) | |
683 | { | |
684 | tree* d; | |
0a4a126e | 685 | |
02e19191 | 686 | for (d = &BLOCK_VARS (block); *d; ) |
687 | { | |
688 | if (TREE_CODE (*d) == TREE_LIST) | |
689 | *d = TREE_CHAIN (*d); | |
690 | else | |
691 | d = &TREE_CHAIN (*d); | |
692 | } | |
0a4a126e | 693 | } |
471086d6 | 694 | |
695 | /* If the level being exited is the top level of a function, | |
696 | check over all the labels. */ | |
471086d6 | 697 | if (functionbody) |
698 | { | |
2d46e540 | 699 | /* Since this is the top level block of a function, the vars are |
700 | the function's parameters. Don't leave them in the BLOCK | |
701 | because they are found in the FUNCTION_DECL instead. */ | |
471086d6 | 702 | BLOCK_VARS (block) = 0; |
2d46e540 | 703 | pop_labels (block); |
471086d6 | 704 | } |
705 | ||
e880f232 | 706 | kind = current_binding_level->kind; |
2363ef00 | 707 | if (kind == sk_cleanup) |
708 | { | |
709 | tree stmt; | |
710 | ||
711 | /* If this is a temporary binding created for a cleanup, then we'll | |
712 | have pushed a statement list level. Pop that, create a new | |
713 | BIND_EXPR for the block, and insert it into the stream. */ | |
714 | stmt = pop_stmt_list (current_binding_level->statement_list); | |
715 | stmt = c_build_bind_expr (block, stmt); | |
716 | add_stmt (stmt); | |
717 | } | |
471086d6 | 718 | |
e2b8a7ee | 719 | leave_scope (); |
471086d6 | 720 | if (functionbody) |
721 | DECL_INITIAL (current_function_decl) = block; | |
722 | else if (block) | |
6528331d | 723 | current_binding_level->blocks |
724 | = chainon (current_binding_level->blocks, block); | |
725 | ||
471086d6 | 726 | /* If we did not make a block for the level just exited, |
727 | any blocks made for inner levels | |
728 | (since they cannot be recorded as subblocks in that level) | |
729 | must be carried forward so they will later become subblocks | |
730 | of something else. */ | |
731 | else if (subblocks) | |
ef3eb7cc | 732 | current_binding_level->blocks |
733 | = chainon (current_binding_level->blocks, subblocks); | |
471086d6 | 734 | |
1ec2510f | 735 | /* Each and every BLOCK node created here in `poplevel' is important |
736 | (e.g. for proper debugging information) so if we created one | |
737 | earlier, mark it as "used". */ | |
738 | if (block) | |
739 | TREE_USED (block) = 1; | |
740 | ||
2363ef00 | 741 | /* All temporary bindings created for cleanups are popped silently. */ |
e880f232 | 742 | if (kind == sk_cleanup) |
2363ef00 | 743 | goto restart; |
471086d6 | 744 | |
851fe51a | 745 | POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block); |
471086d6 | 746 | } |
747 | ||
748 | /* Delete the node BLOCK from the current binding level. | |
749 | This is used for the block inside a stmt expr ({...}) | |
750 | so that the block can be reinserted where appropriate. */ | |
751 | ||
752 | void | |
1b72315d | 753 | delete_block (tree block) |
471086d6 | 754 | { |
755 | tree t; | |
756 | if (current_binding_level->blocks == block) | |
757 | current_binding_level->blocks = TREE_CHAIN (block); | |
758 | for (t = current_binding_level->blocks; t;) | |
759 | { | |
760 | if (TREE_CHAIN (t) == block) | |
761 | TREE_CHAIN (t) = TREE_CHAIN (block); | |
762 | else | |
763 | t = TREE_CHAIN (t); | |
764 | } | |
765 | TREE_CHAIN (block) = NULL_TREE; | |
766 | /* Clear TREE_USED which is always set by poplevel. | |
767 | The flag is set again if insert_block is called. */ | |
768 | TREE_USED (block) = 0; | |
769 | } | |
770 | ||
771 | /* Insert BLOCK at the end of the list of subblocks of the | |
772 | current binding level. This is used when a BIND_EXPR is expanded, | |
773 | to handle the BLOCK node inside the BIND_EXPR. */ | |
774 | ||
775 | void | |
1b72315d | 776 | insert_block (tree block) |
471086d6 | 777 | { |
778 | TREE_USED (block) = 1; | |
779 | current_binding_level->blocks | |
780 | = chainon (current_binding_level->blocks, block); | |
781 | } | |
782 | ||
3160db1d | 783 | /* Returns nonzero if T is a virtual function table. */ |
cec1f6a6 | 784 | |
785 | int | |
1b72315d | 786 | vtable_decl_p (tree t, void* data ATTRIBUTE_UNUSED ) |
cec1f6a6 | 787 | { |
788 | return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t)); | |
789 | } | |
790 | ||
3160db1d | 791 | /* Returns nonzero if T is a TYPE_DECL for a type with virtual |
cec1f6a6 | 792 | functions. */ |
793 | ||
794 | int | |
1b72315d | 795 | vtype_decl_p (tree t, void *data ATTRIBUTE_UNUSED ) |
cec1f6a6 | 796 | { |
797 | return (TREE_CODE (t) == TYPE_DECL | |
14b8f8f6 | 798 | && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE |
799 | && TYPE_POLYMORPHIC_P (TREE_TYPE (t))); | |
cec1f6a6 | 800 | } |
801 | ||
422f3ebe | 802 | struct walk_globals_data { |
803 | walk_globals_pred p; | |
804 | walk_globals_fn f; | |
805 | void *data; | |
806 | }; | |
807 | ||
808 | /* Walk the vtable declarations in NAMESPACE. Whenever one is found | |
3160db1d | 809 | for which P returns nonzero, call F with its address. If any call |
810 | to F returns a nonzero value, return a nonzero value. */ | |
422f3ebe | 811 | |
812 | static int | |
1b72315d | 813 | walk_vtables_r (tree namespace, void* data) |
422f3ebe | 814 | { |
815 | struct walk_globals_data* wgd = (struct walk_globals_data *) data; | |
816 | walk_globals_fn f = wgd->f; | |
817 | void *d = wgd->data; | |
818 | tree decl = NAMESPACE_LEVEL (namespace)->vtables; | |
819 | int result = 0; | |
820 | ||
821 | for (; decl ; decl = TREE_CHAIN (decl)) | |
0b4c7896 | 822 | result |= (*f) (&decl, d); |
422f3ebe | 823 | |
824 | return result; | |
825 | } | |
826 | ||
827 | /* Walk the vtable declarations. Whenever one is found for which P | |
3160db1d | 828 | returns nonzero, call F with its address. If any call to F |
829 | returns a nonzero value, return a nonzero value. */ | |
26ac6687 | 830 | bool |
831 | walk_vtables (walk_globals_pred p, walk_globals_fn f, void *data) | |
491e04ef | 832 | { |
422f3ebe | 833 | struct walk_globals_data wgd; |
491e04ef | 834 | wgd.p = p; |
422f3ebe | 835 | wgd.f = f; |
836 | wgd.data = data; | |
837 | ||
838 | return walk_namespaces (walk_vtables_r, &wgd); | |
839 | } | |
840 | ||
cec1f6a6 | 841 | /* Walk all the namespaces contained NAMESPACE, including NAMESPACE |
842 | itself, calling F for each. The DATA is passed to F as well. */ | |
843 | ||
836495aa | 844 | static int |
845 | walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data) | |
846 | { | |
847 | int result = 0; | |
491e04ef | 848 | tree current = NAMESPACE_LEVEL (namespace)->namespaces; |
471086d6 | 849 | |
836495aa | 850 | result |= (*f) (namespace, data); |
471086d6 | 851 | |
836495aa | 852 | for (; current; current = TREE_CHAIN (current)) |
853 | result |= walk_namespaces_r (current, f, data); | |
a35129cf | 854 | |
836495aa | 855 | return result; |
e857e9c7 | 856 | } |
857 | ||
836495aa | 858 | /* Walk all the namespaces, calling F for each. The DATA is passed to |
859 | F as well. */ | |
860 | ||
861 | int | |
862 | walk_namespaces (walk_namespaces_fn f, void* data) | |
e857e9c7 | 863 | { |
836495aa | 864 | return walk_namespaces_r (global_namespace, f, data); |
471086d6 | 865 | } |
866 | ||
836495aa | 867 | /* Walk the global declarations in NAMESPACE. Whenever one is found |
868 | for which P returns nonzero, call F with its address. If any call | |
869 | to F returns a nonzero value, return a nonzero value. */ | |
471086d6 | 870 | |
836495aa | 871 | static int |
872 | walk_globals_r (tree namespace, void* data) | |
873 | { | |
874 | struct walk_globals_data* wgd = (struct walk_globals_data *) data; | |
875 | walk_globals_pred p = wgd->p; | |
876 | walk_globals_fn f = wgd->f; | |
877 | void *d = wgd->data; | |
878 | tree *t; | |
879 | int result = 0; | |
471086d6 | 880 | |
836495aa | 881 | t = &NAMESPACE_LEVEL (namespace)->names; |
1e4853c2 | 882 | |
836495aa | 883 | while (*t) |
471086d6 | 884 | { |
836495aa | 885 | tree glbl = *t; |
471086d6 | 886 | |
836495aa | 887 | if ((*p) (glbl, d)) |
888 | result |= (*f) (t, d); | |
b7d1e8ea | 889 | |
836495aa | 890 | /* If F changed *T, then *T still points at the next item to |
891 | examine. */ | |
892 | if (*t == glbl) | |
893 | t = &TREE_CHAIN (*t); | |
8417823c | 894 | } |
471086d6 | 895 | |
836495aa | 896 | return result; |
471086d6 | 897 | } |
898 | ||
836495aa | 899 | /* Walk the global declarations. Whenever one is found for which P |
900 | returns true, call F with its address. If any call to F | |
901 | returns true, return true. */ | |
8417823c | 902 | |
836495aa | 903 | bool |
904 | walk_globals (walk_globals_pred p, walk_globals_fn f, void *data) | |
8417823c | 905 | { |
836495aa | 906 | struct walk_globals_data wgd; |
907 | wgd.p = p; | |
908 | wgd.f = f; | |
909 | wgd.data = data; | |
96624a9e | 910 | |
836495aa | 911 | return walk_namespaces (walk_globals_r, &wgd); |
0543e7a9 | 912 | } |
913 | ||
836495aa | 914 | /* Call wrapup_globals_declarations for the globals in NAMESPACE. If |
915 | DATA is non-NULL, this is the last time we will call | |
916 | wrapup_global_declarations for this NAMESPACE. */ | |
63e8563c | 917 | |
836495aa | 918 | int |
919 | wrapup_globals_for_namespace (tree namespace, void* data) | |
63e8563c | 920 | { |
836495aa | 921 | struct cp_binding_level *level = NAMESPACE_LEVEL (namespace); |
922 | varray_type statics = level->static_decls; | |
923 | tree *vec = &VARRAY_TREE (statics, 0); | |
924 | int len = VARRAY_ACTIVE_SIZE (statics); | |
925 | int last_time = (data != 0); | |
980877d7 | 926 | |
836495aa | 927 | if (last_time) |
63e8563c | 928 | { |
836495aa | 929 | check_global_declarations (vec, len); |
930 | return 0; | |
63e8563c | 931 | } |
932 | ||
836495aa | 933 | /* Write out any globals that need to be output. */ |
934 | return wrapup_global_declarations (vec, len); | |
63e8563c | 935 | } |
936 | ||
836495aa | 937 | \f |
70a658bd | 938 | /* In C++, you don't have to write `struct S' to refer to `S'; you |
939 | can just use `S'. We accomplish this by creating a TYPE_DECL as | |
940 | if the user had written `typedef struct S S'. Create and return | |
941 | the TYPE_DECL for TYPE. */ | |
942 | ||
943 | tree | |
1b72315d | 944 | create_implicit_typedef (tree name, tree type) |
70a658bd | 945 | { |
946 | tree decl; | |
947 | ||
948 | decl = build_decl (TYPE_DECL, name, type); | |
ecdd3d84 | 949 | DECL_ARTIFICIAL (decl) = 1; |
70a658bd | 950 | /* There are other implicit type declarations, like the one *within* |
951 | a class that allows you to write `S::S'. We must distinguish | |
952 | amongst these. */ | |
953 | SET_DECL_IMPLICIT_TYPEDEF_P (decl); | |
954 | TYPE_NAME (type) = decl; | |
955 | ||
956 | return decl; | |
957 | } | |
958 | ||
e6393a02 | 959 | /* Remember a local name for name-mangling purposes. */ |
960 | ||
961 | static void | |
1b72315d | 962 | push_local_name (tree decl) |
e6393a02 | 963 | { |
964 | size_t i, nelts; | |
965 | tree t, name; | |
966 | ||
851fe51a | 967 | timevar_push (TV_NAME_LOOKUP); |
e6393a02 | 968 | if (!local_names) |
969 | VARRAY_TREE_INIT (local_names, 8, "local_names"); | |
970 | ||
971 | name = DECL_NAME (decl); | |
972 | ||
973 | nelts = VARRAY_ACTIVE_SIZE (local_names); | |
974 | for (i = 0; i < nelts; i++) | |
975 | { | |
976 | t = VARRAY_TREE (local_names, i); | |
977 | if (DECL_NAME (t) == name) | |
978 | { | |
979 | if (!DECL_LANG_SPECIFIC (decl)) | |
980 | retrofit_lang_decl (decl); | |
1f3233d1 | 981 | DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1; |
e6393a02 | 982 | if (DECL_LANG_SPECIFIC (t)) |
983 | DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1; | |
984 | else | |
985 | DECL_DISCRIMINATOR (decl) = 1; | |
986 | ||
987 | VARRAY_TREE (local_names, i) = decl; | |
4fa0b096 | 988 | timevar_pop (TV_NAME_LOOKUP); |
989 | return; | |
e6393a02 | 990 | } |
991 | } | |
992 | ||
993 | VARRAY_PUSH_TREE (local_names, decl); | |
851fe51a | 994 | timevar_pop (TV_NAME_LOOKUP); |
e6393a02 | 995 | } |
471086d6 | 996 | \f |
997 | /* Subroutine of duplicate_decls: return truthvalue of whether | |
998 | or not types of these decls match. | |
999 | ||
1000 | For C++, we must compare the parameter list so that `int' can match | |
1001 | `int&' in a parameter position, but `int&' is not confused with | |
1002 | `const int&'. */ | |
96624a9e | 1003 | |
a74e8896 | 1004 | int |
1b72315d | 1005 | decls_match (tree newdecl, tree olddecl) |
471086d6 | 1006 | { |
1007 | int types_match; | |
1008 | ||
42085533 | 1009 | if (newdecl == olddecl) |
1010 | return 1; | |
1011 | ||
5b35cb67 | 1012 | if (TREE_CODE (newdecl) != TREE_CODE (olddecl)) |
1013 | /* If the two DECLs are not even the same kind of thing, we're not | |
1014 | interested in their types. */ | |
1015 | return 0; | |
1016 | ||
1017 | if (TREE_CODE (newdecl) == FUNCTION_DECL) | |
471086d6 | 1018 | { |
1019 | tree f1 = TREE_TYPE (newdecl); | |
1020 | tree f2 = TREE_TYPE (olddecl); | |
1021 | tree p1 = TYPE_ARG_TYPES (f1); | |
1022 | tree p2 = TYPE_ARG_TYPES (f2); | |
1023 | ||
9ba4048d | 1024 | if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl) |
a2697ab6 | 1025 | && ! (DECL_EXTERN_C_P (newdecl) |
1026 | && DECL_EXTERN_C_P (olddecl))) | |
510e8b9c | 1027 | return 0; |
1028 | ||
471086d6 | 1029 | if (TREE_CODE (f1) != TREE_CODE (f2)) |
30fbe833 | 1030 | return 0; |
471086d6 | 1031 | |
daf9ff67 | 1032 | if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2))) |
0543e7a9 | 1033 | { |
0f497990 | 1034 | if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl) |
1035 | && (DECL_BUILT_IN (olddecl) | |
1036 | #ifndef NO_IMPLICIT_EXTERN_C | |
1037 | || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl)) | |
1038 | || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl)) | |
1039 | #endif | |
1040 | )) | |
e581f478 | 1041 | { |
1042 | types_match = self_promoting_args_p (p1); | |
1043 | if (p1 == void_list_node) | |
1044 | TREE_TYPE (newdecl) = TREE_TYPE (olddecl); | |
1045 | } | |
0f497990 | 1046 | #ifndef NO_IMPLICIT_EXTERN_C |
1047 | else if (p1 == NULL_TREE | |
1048 | && (DECL_EXTERN_C_P (olddecl) | |
1049 | && DECL_IN_SYSTEM_HEADER (olddecl) | |
1050 | && !DECL_CLASS_SCOPE_P (olddecl)) | |
1051 | && (DECL_EXTERN_C_P (newdecl) | |
1052 | && DECL_IN_SYSTEM_HEADER (newdecl) | |
1053 | && !DECL_CLASS_SCOPE_P (newdecl))) | |
e581f478 | 1054 | { |
1055 | types_match = self_promoting_args_p (p2); | |
1056 | TREE_TYPE (newdecl) = TREE_TYPE (olddecl); | |
1057 | } | |
0f497990 | 1058 | #endif |
0543e7a9 | 1059 | else |
3e04bd45 | 1060 | types_match = compparms (p1, p2); |
0543e7a9 | 1061 | } |
471086d6 | 1062 | else |
1063 | types_match = 0; | |
1064 | } | |
5b35cb67 | 1065 | else if (TREE_CODE (newdecl) == TEMPLATE_DECL) |
ac9386a0 | 1066 | { |
f9b9bf39 | 1067 | if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) |
1068 | != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))) | |
1069 | return 0; | |
1070 | ||
c0b419db | 1071 | if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl), |
1072 | DECL_TEMPLATE_PARMS (olddecl))) | |
1073 | return 0; | |
1074 | ||
f3110581 | 1075 | if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL) |
c0b419db | 1076 | types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)), |
1077 | TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))); | |
f3110581 | 1078 | else |
1079 | types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl), | |
1080 | DECL_TEMPLATE_RESULT (newdecl)); | |
ac9386a0 | 1081 | } |
471086d6 | 1082 | else |
1083 | { | |
1084 | if (TREE_TYPE (newdecl) == error_mark_node) | |
1085 | types_match = TREE_TYPE (olddecl) == error_mark_node; | |
1086 | else if (TREE_TYPE (olddecl) == NULL_TREE) | |
1087 | types_match = TREE_TYPE (newdecl) == NULL_TREE; | |
ddb9bca7 | 1088 | else if (TREE_TYPE (newdecl) == NULL_TREE) |
1089 | types_match = 0; | |
471086d6 | 1090 | else |
ca23ec64 | 1091 | types_match = comptypes (TREE_TYPE (newdecl), |
daf9ff67 | 1092 | TREE_TYPE (olddecl), |
1093 | COMPARE_REDECLARATION); | |
471086d6 | 1094 | } |
1095 | ||
1096 | return types_match; | |
1097 | } | |
1098 | ||
1099 | /* If NEWDECL is `static' and an `extern' was seen previously, | |
dcbe7838 | 1100 | warn about it. OLDDECL is the previous declaration. |
471086d6 | 1101 | |
1102 | Note that this does not apply to the C++ case of declaring | |
1103 | a variable `extern const' and then later `const'. | |
1104 | ||
471086d6 | 1105 | Don't complain about built-in functions, since they are beyond |
1106 | the user's control. */ | |
1107 | ||
9a49d46b | 1108 | void |
1b72315d | 1109 | warn_extern_redeclared_static (tree newdecl, tree olddecl) |
471086d6 | 1110 | { |
dcbe7838 | 1111 | tree name; |
1112 | ||
980877d7 | 1113 | if (TREE_CODE (newdecl) == TYPE_DECL |
b81be439 | 1114 | || TREE_CODE (newdecl) == TEMPLATE_DECL |
2a9d763b | 1115 | || TREE_CODE (newdecl) == CONST_DECL |
1116 | || TREE_CODE (newdecl) == NAMESPACE_DECL) | |
471086d6 | 1117 | return; |
980877d7 | 1118 | |
8a4bf740 | 1119 | /* Don't get confused by static member functions; that's a different |
1120 | use of `static'. */ | |
1121 | if (TREE_CODE (newdecl) == FUNCTION_DECL | |
1122 | && DECL_STATIC_FUNCTION_P (newdecl)) | |
1123 | return; | |
471086d6 | 1124 | |
dcbe7838 | 1125 | /* If the old declaration was `static', or the new one isn't, then |
1126 | then everything is OK. */ | |
1127 | if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl)) | |
1128 | return; | |
1129 | ||
1130 | /* It's OK to declare a builtin function as `static'. */ | |
1131 | if (TREE_CODE (olddecl) == FUNCTION_DECL | |
1132 | && DECL_ARTIFICIAL (olddecl)) | |
1133 | return; | |
1134 | ||
471086d6 | 1135 | name = DECL_ASSEMBLER_NAME (newdecl); |
28bbd27a | 1136 | pedwarn ("`%D' was declared `extern' and later `static'", newdecl); |
dcbe7838 | 1137 | cp_pedwarn_at ("previous declaration of `%D'", olddecl); |
471086d6 | 1138 | } |
1139 | ||
947f430b | 1140 | /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations. |
1141 | If the redeclaration is invalid, a diagnostic is issued, and the | |
1142 | error_mark_node is returned. Otherwise, OLDDECL is returned. | |
471086d6 | 1143 | |
947f430b | 1144 | If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is |
1145 | returned. */ | |
471086d6 | 1146 | |
947f430b | 1147 | tree |
1b72315d | 1148 | duplicate_decls (tree newdecl, tree olddecl) |
471086d6 | 1149 | { |
471086d6 | 1150 | unsigned olddecl_uid = DECL_UID (olddecl); |
1151 | int olddecl_friend = 0, types_match = 0; | |
3340d527 | 1152 | int new_defines_function = 0; |
e857e9c7 | 1153 | |
1154 | if (newdecl == olddecl) | |
947f430b | 1155 | return olddecl; |
471086d6 | 1156 | |
0543e7a9 | 1157 | types_match = decls_match (newdecl, olddecl); |
471086d6 | 1158 | |
471086d6 | 1159 | /* If either the type of the new decl or the type of the old decl is an |
1160 | error_mark_node, then that implies that we have already issued an | |
1161 | error (earlier) for some bogus type specification, and in that case, | |
1162 | it is rather pointless to harass the user with yet more error message | |
3340d527 | 1163 | about the same declaration, so just pretend the types match here. */ |
b465397d | 1164 | if (TREE_TYPE (newdecl) == error_mark_node |
1165 | || TREE_TYPE (olddecl) == error_mark_node) | |
471086d6 | 1166 | types_match = 1; |
980877d7 | 1167 | |
5955c361 | 1168 | if (DECL_P (olddecl) |
1169 | && TREE_CODE (newdecl) == FUNCTION_DECL | |
1170 | && TREE_CODE (olddecl) == FUNCTION_DECL | |
1171 | && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl))) | |
1172 | { | |
1173 | if (DECL_DECLARED_INLINE_P (newdecl) | |
1174 | && DECL_UNINLINABLE (newdecl) | |
1175 | && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl))) | |
1176 | /* Already warned elsewhere. */; | |
1177 | else if (DECL_DECLARED_INLINE_P (olddecl) | |
1178 | && DECL_UNINLINABLE (olddecl) | |
1179 | && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl))) | |
1180 | /* Already warned. */; | |
1181 | else if (DECL_DECLARED_INLINE_P (newdecl) | |
1182 | && DECL_UNINLINABLE (olddecl) | |
1183 | && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl))) | |
1184 | { | |
9bc3739f | 1185 | warning ("%Jfunction '%D' redeclared as inline", newdecl, newdecl); |
1186 | warning ("%Jprevious declaration of '%D' with attribute noinline", | |
1187 | olddecl, olddecl); | |
5955c361 | 1188 | } |
1189 | else if (DECL_DECLARED_INLINE_P (olddecl) | |
1190 | && DECL_UNINLINABLE (newdecl) | |
1191 | && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl))) | |
1192 | { | |
9bc3739f | 1193 | warning ("%Jfunction '%D' redeclared with attribute noinline", |
1194 | newdecl, newdecl); | |
1195 | warning ("%Jprevious declaration of '%D' was inline", | |
1196 | olddecl, olddecl); | |
5955c361 | 1197 | } |
1198 | } | |
1199 | ||
a109dc3b | 1200 | /* Check for redeclaration and other discrepancies. */ |
48ec80c8 | 1201 | if (TREE_CODE (olddecl) == FUNCTION_DECL |
175a96e8 | 1202 | && DECL_ARTIFICIAL (olddecl)) |
1203 | { | |
1204 | if (TREE_CODE (newdecl) != FUNCTION_DECL) | |
1205 | { | |
ae8cbbc8 | 1206 | /* Avoid warnings redeclaring anticipated built-ins. */ |
1207 | if (DECL_ANTICIPATED (olddecl)) | |
947f430b | 1208 | return NULL_TREE; |
ae8cbbc8 | 1209 | |
175a96e8 | 1210 | /* If you declare a built-in or predefined function name as static, |
1211 | the old definition is overridden, but optionally warn this was a | |
1212 | bad choice of name. */ | |
1213 | if (! TREE_PUBLIC (newdecl)) | |
1214 | { | |
1215 | if (warn_shadow) | |
cf103c6c | 1216 | warning ("shadowing %s function `%#D'", |
175a96e8 | 1217 | DECL_BUILT_IN (olddecl) ? "built-in" : "library", |
1218 | olddecl); | |
1219 | /* Discard the old built-in function. */ | |
947f430b | 1220 | return NULL_TREE; |
175a96e8 | 1221 | } |
1222 | /* If the built-in is not ansi, then programs can override | |
1223 | it even globally without an error. */ | |
1224 | else if (! DECL_BUILT_IN (olddecl)) | |
cf103c6c | 1225 | warning ("library function `%#D' redeclared as non-function `%#D'", |
175a96e8 | 1226 | olddecl, newdecl); |
1227 | else | |
1228 | { | |
cf103c6c | 1229 | error ("declaration of `%#D'", newdecl); |
1230 | error ("conflicts with built-in declaration `%#D'", | |
d81e00a4 | 1231 | olddecl); |
175a96e8 | 1232 | } |
947f430b | 1233 | return NULL_TREE; |
d81e00a4 | 1234 | } |
175a96e8 | 1235 | else if (!types_match) |
471086d6 | 1236 | { |
ae8cbbc8 | 1237 | /* Avoid warnings redeclaring anticipated built-ins. */ |
1238 | if (DECL_ANTICIPATED (olddecl)) | |
e256d445 | 1239 | { |
1240 | /* Deal with fileptr_type_node. FILE type is not known | |
1241 | at the time we create the builtins. */ | |
1242 | tree t1, t2; | |
1243 | ||
1244 | for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)), | |
1245 | t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl)); | |
1246 | t1 || t2; | |
1247 | t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2)) | |
1248 | if (!t1 || !t2) | |
1249 | break; | |
1250 | else if (TREE_VALUE (t2) == fileptr_type_node) | |
1251 | { | |
1252 | tree t = TREE_VALUE (t1); | |
1253 | ||
1254 | if (TREE_CODE (t) == POINTER_TYPE | |
1255 | && TYPE_NAME (TREE_TYPE (t)) | |
1256 | && DECL_NAME (TYPE_NAME (TREE_TYPE (t))) | |
1257 | == get_identifier ("FILE") | |
1258 | && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2))) | |
1259 | { | |
1260 | tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl)); | |
1261 | ||
1262 | TYPE_ARG_TYPES (TREE_TYPE (olddecl)) | |
1263 | = TYPE_ARG_TYPES (TREE_TYPE (newdecl)); | |
1264 | types_match = decls_match (newdecl, olddecl); | |
1265 | if (types_match) | |
1266 | return duplicate_decls (newdecl, olddecl); | |
1267 | TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs; | |
1268 | } | |
1269 | } | |
1270 | else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2))) | |
1271 | break; | |
1272 | } | |
ae8cbbc8 | 1273 | else if ((DECL_EXTERN_C_P (newdecl) |
d7d79557 | 1274 | && DECL_EXTERN_C_P (olddecl)) |
1275 | || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)), | |
1276 | TYPE_ARG_TYPES (TREE_TYPE (olddecl)))) | |
d81e00a4 | 1277 | { |
175a96e8 | 1278 | /* A near match; override the builtin. */ |
1279 | ||
1280 | if (TREE_PUBLIC (newdecl)) | |
d81e00a4 | 1281 | { |
cf103c6c | 1282 | warning ("new declaration `%#D'", newdecl); |
1283 | warning ("ambiguates built-in declaration `%#D'", | |
175a96e8 | 1284 | olddecl); |
d81e00a4 | 1285 | } |
175a96e8 | 1286 | else if (warn_shadow) |
cf103c6c | 1287 | warning ("shadowing %s function `%#D'", |
175a96e8 | 1288 | DECL_BUILT_IN (olddecl) ? "built-in" : "library", |
1289 | olddecl); | |
d81e00a4 | 1290 | } |
175a96e8 | 1291 | else |
1292 | /* Discard the old built-in function. */ | |
947f430b | 1293 | return NULL_TREE; |
70e907c2 | 1294 | |
1295 | /* Replace the old RTL to avoid problems with inlining. */ | |
146c1b4f | 1296 | COPY_DECL_RTL (newdecl, olddecl); |
471086d6 | 1297 | } |
88d394b3 | 1298 | /* Even if the types match, prefer the new declarations type |
4df55fce | 1299 | for anticipated built-ins, for exception lists, etc... */ |
88d394b3 | 1300 | else if (DECL_ANTICIPATED (olddecl)) |
8a6f9fad | 1301 | { |
f5af39bc | 1302 | tree type = TREE_TYPE (newdecl); |
1303 | tree attribs = (*targetm.merge_type_attributes) | |
1304 | (TREE_TYPE (olddecl), type); | |
1305 | ||
b3beaf30 | 1306 | type = cp_build_type_attribute_variant (type, attribs); |
f5af39bc | 1307 | TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type; |
8a6f9fad | 1308 | } |
980877d7 | 1309 | |
d7d79557 | 1310 | /* Whether or not the builtin can throw exceptions has no |
1311 | bearing on this declarator. */ | |
1312 | TREE_NOTHROW (olddecl) = 0; | |
1313 | ||
dcbe7838 | 1314 | if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl)) |
1315 | { | |
1316 | /* If a builtin function is redeclared as `static', merge | |
1317 | the declarations, but make the original one static. */ | |
1318 | DECL_THIS_STATIC (olddecl) = 1; | |
1319 | TREE_PUBLIC (olddecl) = 0; | |
3da16ddc | 1320 | |
f0edcca6 | 1321 | /* Make the old declaration consistent with the new one so |
1322 | that all remnants of the builtin-ness of this function | |
1323 | will be banished. */ | |
4b1984f5 | 1324 | SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl)); |
146c1b4f | 1325 | COPY_DECL_RTL (newdecl, olddecl); |
dcbe7838 | 1326 | } |
bc3887cf | 1327 | } |
1328 | else if (TREE_CODE (olddecl) != TREE_CODE (newdecl)) | |
1329 | { | |
f826d4f9 | 1330 | if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl) |
1331 | && TREE_CODE (newdecl) != TYPE_DECL | |
1332 | && ! (TREE_CODE (newdecl) == TEMPLATE_DECL | |
1333 | && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)) | |
1334 | || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl) | |
1335 | && TREE_CODE (olddecl) != TYPE_DECL | |
1336 | && ! (TREE_CODE (olddecl) == TEMPLATE_DECL | |
1337 | && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) | |
1338 | == TYPE_DECL)))) | |
1339 | { | |
1340 | /* We do nothing special here, because C++ does such nasty | |
1341 | things with TYPE_DECLs. Instead, just let the TYPE_DECL | |
1342 | get shadowed, and know that if we need to find a TYPE_DECL | |
1343 | for a given name, we can look in the IDENTIFIER_TYPE_VALUE | |
1344 | slot of the identifier. */ | |
947f430b | 1345 | return NULL_TREE; |
f826d4f9 | 1346 | } |
1347 | ||
bc3887cf | 1348 | if ((TREE_CODE (newdecl) == FUNCTION_DECL |
e857e9c7 | 1349 | && DECL_FUNCTION_TEMPLATE_P (olddecl)) |
bc3887cf | 1350 | || (TREE_CODE (olddecl) == FUNCTION_DECL |
e857e9c7 | 1351 | && DECL_FUNCTION_TEMPLATE_P (newdecl))) |
947f430b | 1352 | return NULL_TREE; |
f826d4f9 | 1353 | |
cf103c6c | 1354 | error ("`%#D' redeclared as different kind of symbol", newdecl); |
bc3887cf | 1355 | if (TREE_CODE (olddecl) == TREE_LIST) |
1356 | olddecl = TREE_VALUE (olddecl); | |
905d4035 | 1357 | cp_error_at ("previous declaration of `%#D'", olddecl); |
bc3887cf | 1358 | |
1940f978 | 1359 | return error_mark_node; |
471086d6 | 1360 | } |
471086d6 | 1361 | else if (!types_match) |
1362 | { | |
9ba4048d | 1363 | if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)) |
91bbfe2a | 1364 | /* These are certainly not duplicate declarations; they're |
1365 | from different scopes. */ | |
947f430b | 1366 | return NULL_TREE; |
91bbfe2a | 1367 | |
0543e7a9 | 1368 | if (TREE_CODE (newdecl) == TEMPLATE_DECL) |
617abf06 | 1369 | { |
1370 | /* The name of a class template may not be declared to refer to | |
1371 | any other template, class, function, object, namespace, value, | |
96624a9e | 1372 | or type in the same scope. */ |
e857e9c7 | 1373 | if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL |
1374 | || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL) | |
617abf06 | 1375 | { |
cf103c6c | 1376 | error ("declaration of template `%#D'", newdecl); |
905d4035 | 1377 | cp_error_at ("conflicts with previous declaration `%#D'", |
617abf06 | 1378 | olddecl); |
1379 | } | |
dbdf67c6 | 1380 | else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL |
1381 | && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL | |
1382 | && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))), | |
3e04bd45 | 1383 | TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)))) |
668ae905 | 1384 | && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl), |
a81e6834 | 1385 | DECL_TEMPLATE_PARMS (olddecl)) |
1386 | /* Template functions can be disambiguated by | |
1387 | return type. */ | |
1388 | && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)), | |
1389 | TREE_TYPE (TREE_TYPE (olddecl)))) | |
dbdf67c6 | 1390 | { |
cf103c6c | 1391 | error ("new declaration `%#D'", newdecl); |
905d4035 | 1392 | cp_error_at ("ambiguates old declaration `%#D'", olddecl); |
dbdf67c6 | 1393 | } |
947f430b | 1394 | return NULL_TREE; |
617abf06 | 1395 | } |
0543e7a9 | 1396 | if (TREE_CODE (newdecl) == FUNCTION_DECL) |
1397 | { | |
a2697ab6 | 1398 | if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl)) |
0543e7a9 | 1399 | { |
cf103c6c | 1400 | error ("declaration of C function `%#D' conflicts with", |
0543e7a9 | 1401 | newdecl); |
905d4035 | 1402 | cp_error_at ("previous declaration `%#D' here", olddecl); |
0543e7a9 | 1403 | } |
6495357a | 1404 | else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)), |
3e04bd45 | 1405 | TYPE_ARG_TYPES (TREE_TYPE (olddecl)))) |
94f3b32d | 1406 | { |
cf103c6c | 1407 | error ("new declaration `%#D'", newdecl); |
905d4035 | 1408 | cp_error_at ("ambiguates old declaration `%#D'", olddecl); |
94f3b32d | 1409 | } |
1410 | else | |
947f430b | 1411 | return NULL_TREE; |
0543e7a9 | 1412 | } |
28bbd27a | 1413 | else |
471086d6 | 1414 | { |
2a9d763b | 1415 | error ("conflicting declaration '%#D'", newdecl); |
1416 | cp_error_at ("'%D' has a previous declaration as `%#D'", | |
1417 | olddecl, olddecl); | |
947f430b | 1418 | return NULL_TREE; |
471086d6 | 1419 | } |
1420 | } | |
980877d7 | 1421 | else if (TREE_CODE (newdecl) == FUNCTION_DECL |
668ae905 | 1422 | && ((DECL_TEMPLATE_SPECIALIZATION (olddecl) |
1423 | && (!DECL_TEMPLATE_INFO (newdecl) | |
980877d7 | 1424 | || (DECL_TI_TEMPLATE (newdecl) |
668ae905 | 1425 | != DECL_TI_TEMPLATE (olddecl)))) |
1426 | || (DECL_TEMPLATE_SPECIALIZATION (newdecl) | |
1427 | && (!DECL_TEMPLATE_INFO (olddecl) | |
980877d7 | 1428 | || (DECL_TI_TEMPLATE (olddecl) |
668ae905 | 1429 | != DECL_TI_TEMPLATE (newdecl)))))) |
b1cfe2be | 1430 | /* It's OK to have a template specialization and a non-template |
1431 | with the same type, or to have specializations of two | |
668ae905 | 1432 | different templates with the same type. Note that if one is a |
1433 | specialization, and the other is an instantiation of the same | |
1434 | template, that we do not exit at this point. That situation | |
1435 | can occur if we instantiate a template class, and then | |
6c0cc2cd | 1436 | specialize one of its methods. This situation is valid, but |
668ae905 | 1437 | the declarations must be merged in the usual way. */ |
947f430b | 1438 | return NULL_TREE; |
980877d7 | 1439 | else if (TREE_CODE (newdecl) == FUNCTION_DECL |
1440 | && ((DECL_TEMPLATE_INSTANTIATION (olddecl) | |
668ae905 | 1441 | && !DECL_USE_TEMPLATE (newdecl)) |
1442 | || (DECL_TEMPLATE_INSTANTIATION (newdecl) | |
1443 | && !DECL_USE_TEMPLATE (olddecl)))) | |
1444 | /* One of the declarations is a template instantiation, and the | |
1445 | other is not a template at all. That's OK. */ | |
947f430b | 1446 | return NULL_TREE; |
5575ae2d | 1447 | else if (TREE_CODE (newdecl) == NAMESPACE_DECL) |
1448 | { | |
1449 | /* In [namespace.alias] we have: | |
1450 | ||
1451 | In a declarative region, a namespace-alias-definition can be | |
1452 | used to redefine a namespace-alias declared in that declarative | |
1453 | region to refer only to the namespace to which it already | |
1454 | refers. | |
1455 | ||
1456 | Therefore, if we encounter a second alias directive for the same | |
1457 | alias, we can just ignore the second directive. */ | |
1458 | if (DECL_NAMESPACE_ALIAS (newdecl) | |
1459 | && (DECL_NAMESPACE_ALIAS (newdecl) | |
1460 | == DECL_NAMESPACE_ALIAS (olddecl))) | |
1461 | return olddecl; | |
1462 | /* [namespace.alias] | |
1463 | ||
1464 | A namespace-name or namespace-alias shall not be declared as | |
1465 | the name of any other entity in the same declarative region. | |
1466 | A namespace-name defined at global scope shall not be | |
4a44ba29 | 1467 | declared as the name of any other entity in any global scope |
5575ae2d | 1468 | of the program. */ |
1469 | error ("declaration of `namespace %D' conflicts with", newdecl); | |
1470 | cp_error_at ("previous declaration of `namespace %D' here", olddecl); | |
1471 | return error_mark_node; | |
1472 | } | |
471086d6 | 1473 | else |
1474 | { | |
e1721763 | 1475 | const char *errmsg = redeclaration_error_message (newdecl, olddecl); |
905d4035 | 1476 | if (errmsg) |
471086d6 | 1477 | { |
cf103c6c | 1478 | error (errmsg, newdecl); |
471086d6 | 1479 | if (DECL_NAME (olddecl) != NULL_TREE) |
1480 | cp_error_at ((DECL_INITIAL (olddecl) | |
8417823c | 1481 | && namespace_bindings_p ()) |
905d4035 | 1482 | ? "`%#D' previously defined here" |
1483 | : "`%#D' previously declared here", olddecl); | |
947f430b | 1484 | return error_mark_node; |
471086d6 | 1485 | } |
1486 | else if (TREE_CODE (olddecl) == FUNCTION_DECL | |
1487 | && DECL_INITIAL (olddecl) != NULL_TREE | |
1488 | && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE | |
1489 | && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE) | |
1490 | { | |
1491 | /* Prototype decl follows defn w/o prototype. */ | |
905d4035 | 1492 | cp_warning_at ("prototype for `%#D'", newdecl); |
9bc3739f | 1493 | warning ("%Jfollows non-prototype definition here", olddecl); |
471086d6 | 1494 | } |
1495 | else if (TREE_CODE (olddecl) == FUNCTION_DECL | |
1496 | && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl)) | |
0543e7a9 | 1497 | { |
1498 | /* extern "C" int foo (); | |
1499 | int foo () { bar (); } | |
1500 | is OK. */ | |
b53db2b0 | 1501 | if (current_lang_depth () == 0) |
4b1984f5 | 1502 | SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl)); |
0543e7a9 | 1503 | else |
1504 | { | |
905d4035 | 1505 | cp_error_at ("previous declaration of `%#D' with %L linkage", |
0543e7a9 | 1506 | olddecl, DECL_LANGUAGE (olddecl)); |
cf103c6c | 1507 | error ("conflicts with new declaration with %L linkage", |
0543e7a9 | 1508 | DECL_LANGUAGE (newdecl)); |
1509 | } | |
1510 | } | |
bcf789d7 | 1511 | |
2329ce7e | 1512 | if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl)) |
a5a4ff77 | 1513 | ; |
1514 | else if (TREE_CODE (olddecl) == FUNCTION_DECL) | |
bcf789d7 | 1515 | { |
1516 | tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl)); | |
1517 | tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)); | |
1518 | int i = 1; | |
1519 | ||
1520 | if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE) | |
1521 | t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2); | |
980877d7 | 1522 | |
bcf789d7 | 1523 | for (; t1 && t1 != void_list_node; |
1524 | t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++) | |
1525 | if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2)) | |
1526 | { | |
8953e390 | 1527 | if (1 == simple_cst_equal (TREE_PURPOSE (t1), |
1528 | TREE_PURPOSE (t2))) | |
bcf789d7 | 1529 | { |
26c29087 | 1530 | pedwarn ("default argument given for parameter %d of `%#D'", |
1531 | i, newdecl); | |
1532 | cp_pedwarn_at ("after previous specification in `%#D'", | |
1533 | olddecl); | |
bcf789d7 | 1534 | } |
1535 | else | |
1536 | { | |
cf103c6c | 1537 | error ("default argument given for parameter %d of `%#D'", |
bcf789d7 | 1538 | i, newdecl); |
905d4035 | 1539 | cp_error_at ("after previous specification in `%#D'", |
bcf789d7 | 1540 | olddecl); |
1541 | } | |
1542 | } | |
127a1cd0 | 1543 | |
491e04ef | 1544 | if (DECL_DECLARED_INLINE_P (newdecl) |
d3981643 | 1545 | && ! DECL_DECLARED_INLINE_P (olddecl) |
d200dc92 | 1546 | && TREE_ADDRESSABLE (olddecl) && warn_inline) |
ef34cee5 | 1547 | { |
9bc3739f | 1548 | warning ("`%#D' was used before it was declared inline", newdecl); |
1549 | warning ("%Jprevious non-inline declaration here", olddecl); | |
ef34cee5 | 1550 | } |
bcf789d7 | 1551 | } |
471086d6 | 1552 | } |
1553 | ||
c498fbee | 1554 | /* Do not merge an implicit typedef with an explicit one. In: |
1555 | ||
1556 | class A; | |
1557 | ... | |
1558 | typedef class A A __attribute__ ((foo)); | |
1559 | ||
1560 | the attribute should apply only to the typedef. */ | |
1561 | if (TREE_CODE (olddecl) == TYPE_DECL | |
1562 | && (DECL_IMPLICIT_TYPEDEF_P (olddecl) | |
1563 | || DECL_IMPLICIT_TYPEDEF_P (newdecl))) | |
947f430b | 1564 | return NULL_TREE; |
c498fbee | 1565 | |
471086d6 | 1566 | /* If new decl is `static' and an `extern' was seen previously, |
1567 | warn about it. */ | |
1568 | warn_extern_redeclared_static (newdecl, olddecl); | |
1569 | ||
96624a9e | 1570 | /* We have committed to returning 1 at this point. */ |
471086d6 | 1571 | if (TREE_CODE (newdecl) == FUNCTION_DECL) |
1572 | { | |
1573 | /* Now that functions must hold information normally held | |
1574 | by field decls, there is extra work to do so that | |
1575 | declaration information does not get destroyed during | |
1576 | definition. */ | |
1577 | if (DECL_VINDEX (olddecl)) | |
1578 | DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl); | |
1579 | if (DECL_CONTEXT (olddecl)) | |
1580 | DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl); | |
bcf789d7 | 1581 | DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl); |
1582 | DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl); | |
a98fd0a1 | 1583 | DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl); |
8cb67d5d | 1584 | DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl); |
8a4bf740 | 1585 | DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl); |
dcbeb3ef | 1586 | if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK) |
1587 | SET_OVERLOADED_OPERATOR_CODE | |
1588 | (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl)); | |
3340d527 | 1589 | new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE; |
980877d7 | 1590 | |
3340d527 | 1591 | /* Optionally warn about more than one declaration for the same |
1592 | name, but don't warn about a function declaration followed by a | |
1593 | definition. */ | |
1594 | if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl) | |
1595 | && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE) | |
a109dc3b | 1596 | /* Don't warn about extern decl followed by definition. */ |
3340d527 | 1597 | && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl)) |
a109dc3b | 1598 | /* Don't warn about friends, let add_friend take care of it. */ |
7bf4741d | 1599 | && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl))) |
3340d527 | 1600 | { |
cf103c6c | 1601 | warning ("redundant redeclaration of `%D' in same scope", newdecl); |
905d4035 | 1602 | cp_warning_at ("previous declaration of `%D'", olddecl); |
3340d527 | 1603 | } |
471086d6 | 1604 | } |
1605 | ||
1606 | /* Deal with C++: must preserve virtual function table size. */ | |
1607 | if (TREE_CODE (olddecl) == TYPE_DECL) | |
1608 | { | |
cd16867a | 1609 | tree newtype = TREE_TYPE (newdecl); |
1610 | tree oldtype = TREE_TYPE (olddecl); | |
471086d6 | 1611 | |
1612 | if (newtype != error_mark_node && oldtype != error_mark_node | |
1613 | && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype)) | |
c83788c9 | 1614 | CLASSTYPE_FRIEND_CLASSES (newtype) |
1615 | = CLASSTYPE_FRIEND_CLASSES (oldtype); | |
4df55fce | 1616 | |
33f7d3d2 | 1617 | DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl); |
471086d6 | 1618 | } |
1619 | ||
471086d6 | 1620 | /* Copy all the DECL_... slots specified in the new decl |
1621 | except for any that we copy here from the old type. */ | |
e3c541f0 | 1622 | DECL_ATTRIBUTES (newdecl) |
57e4bbfb | 1623 | = (*targetm.merge_decl_attributes) (olddecl, newdecl); |
471086d6 | 1624 | |
e857e9c7 | 1625 | if (TREE_CODE (newdecl) == TEMPLATE_DECL) |
1626 | { | |
a072266a | 1627 | TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)); |
980877d7 | 1628 | DECL_TEMPLATE_SPECIALIZATIONS (olddecl) |
a072266a | 1629 | = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl), |
1630 | DECL_TEMPLATE_SPECIALIZATIONS (newdecl)); | |
980877d7 | 1631 | |
6ac91b4a | 1632 | /* If the new declaration is a definition, update the file and |
1633 | line information on the declaration. */ | |
a7501a3c | 1634 | if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE |
1635 | && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE) | |
6ac91b4a | 1636 | { |
491e04ef | 1637 | DECL_SOURCE_LOCATION (olddecl) |
346064d9 | 1638 | = DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (olddecl)) |
1639 | = DECL_SOURCE_LOCATION (newdecl); | |
d45cef9b | 1640 | if (DECL_FUNCTION_TEMPLATE_P (newdecl)) |
1641 | DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (olddecl)) | |
1642 | = DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (newdecl)); | |
6ac91b4a | 1643 | } |
1644 | ||
3b67dbda | 1645 | if (DECL_FUNCTION_TEMPLATE_P (newdecl)) |
1646 | { | |
491e04ef | 1647 | DECL_INLINE (DECL_TEMPLATE_RESULT (olddecl)) |
3b67dbda | 1648 | |= DECL_INLINE (DECL_TEMPLATE_RESULT (newdecl)); |
1649 | DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (olddecl)) | |
1650 | |= DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (newdecl)); | |
1651 | } | |
1652 | ||
947f430b | 1653 | return olddecl; |
e857e9c7 | 1654 | } |
980877d7 | 1655 | |
471086d6 | 1656 | if (types_match) |
1657 | { | |
1658 | /* Automatically handles default parameters. */ | |
1659 | tree oldtype = TREE_TYPE (olddecl); | |
bcf789d7 | 1660 | tree newtype; |
471086d6 | 1661 | |
bcf789d7 | 1662 | /* Merge the data types specified in the two decls. */ |
be94aed9 | 1663 | newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl)); |
bcf789d7 | 1664 | |
be94aed9 | 1665 | /* If merge_types produces a non-typedef type, just use the old type. */ |
1459abb8 | 1666 | if (TREE_CODE (newdecl) == TYPE_DECL |
1667 | && newtype == DECL_ORIGINAL_TYPE (newdecl)) | |
1668 | newtype = oldtype; | |
1669 | ||
471086d6 | 1670 | if (TREE_CODE (newdecl) == VAR_DECL) |
23ed74d8 | 1671 | { |
1672 | DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl); | |
1673 | DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl); | |
878870b4 | 1674 | DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl) |
1675 | |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl); | |
23ed74d8 | 1676 | } |
1677 | ||
be94aed9 | 1678 | /* Do this after calling `merge_types' so that default |
471086d6 | 1679 | parameters don't confuse us. */ |
1680 | else if (TREE_CODE (newdecl) == FUNCTION_DECL | |
1681 | && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)) | |
1682 | != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)))) | |
1683 | { | |
ce28ee2e | 1684 | TREE_TYPE (newdecl) = build_exception_variant (newtype, |
471086d6 | 1685 | TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))); |
ce28ee2e | 1686 | TREE_TYPE (olddecl) = build_exception_variant (newtype, |
471086d6 | 1687 | TYPE_RAISES_EXCEPTIONS (oldtype)); |
1688 | ||
e7b664be | 1689 | if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl)) |
357f7efa | 1690 | && ! DECL_IS_BUILTIN (olddecl) |
39c8ac16 | 1691 | && flag_exceptions |
316b7a44 | 1692 | && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)), |
1693 | TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1)) | |
471086d6 | 1694 | { |
cf103c6c | 1695 | error ("declaration of `%F' throws different exceptions", |
346064d9 | 1696 | newdecl); |
deb27283 | 1697 | cp_error_at ("than previous declaration `%F'", olddecl); |
471086d6 | 1698 | } |
1699 | } | |
1700 | TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype; | |
1701 | ||
1702 | /* Lay the type out, unless already done. */ | |
4d9c8e11 | 1703 | if (! same_type_p (newtype, oldtype) |
e857e9c7 | 1704 | && TREE_TYPE (newdecl) != error_mark_node |
3cc0b4b9 | 1705 | && !(processing_template_decl && uses_template_parms (newdecl))) |
1e66592c | 1706 | layout_type (TREE_TYPE (newdecl)); |
1707 | ||
e857e9c7 | 1708 | if ((TREE_CODE (newdecl) == VAR_DECL |
1709 | || TREE_CODE (newdecl) == PARM_DECL | |
1710 | || TREE_CODE (newdecl) == RESULT_DECL | |
1711 | || TREE_CODE (newdecl) == FIELD_DECL | |
1712 | || TREE_CODE (newdecl) == TYPE_DECL) | |
3cc0b4b9 | 1713 | && !(processing_template_decl && uses_template_parms (newdecl))) |
1e66592c | 1714 | layout_decl (newdecl, 0); |
471086d6 | 1715 | |
1716 | /* Merge the type qualifiers. */ | |
1717 | if (TREE_READONLY (newdecl)) | |
1718 | TREE_READONLY (olddecl) = 1; | |
1719 | if (TREE_THIS_VOLATILE (newdecl)) | |
1720 | TREE_THIS_VOLATILE (olddecl) = 1; | |
1721 | ||
1722 | /* Merge the initialization information. */ | |
0543e7a9 | 1723 | if (DECL_INITIAL (newdecl) == NULL_TREE |
1724 | && DECL_INITIAL (olddecl) != NULL_TREE) | |
1725 | { | |
1726 | DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl); | |
346064d9 | 1727 | DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl); |
c6138f2d | 1728 | if (CAN_HAVE_FULL_LANG_DECL_P (newdecl) |
1729 | && DECL_LANG_SPECIFIC (newdecl) | |
a072266a | 1730 | && DECL_LANG_SPECIFIC (olddecl)) |
acd77abe | 1731 | { |
1732 | DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl); | |
cbc44df5 | 1733 | DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl); |
acd77abe | 1734 | } |
0543e7a9 | 1735 | } |
bc3887cf | 1736 | |
1737 | /* Merge the section attribute. | |
1738 | We want to issue an error if the sections conflict but that must be | |
1739 | done later in decl_attributes since we are called before attributes | |
1740 | are assigned. */ | |
1741 | if (DECL_SECTION_NAME (newdecl) == NULL_TREE) | |
1742 | DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl); | |
1743 | ||
8f8ac140 | 1744 | if (TREE_CODE (newdecl) == FUNCTION_DECL) |
1745 | { | |
1746 | DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl) | |
1747 | |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl); | |
32ef1cd2 | 1748 | DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl); |
f2f6bdab | 1749 | TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl); |
1750 | TREE_READONLY (newdecl) |= TREE_READONLY (olddecl); | |
1751 | TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl); | |
32ef1cd2 | 1752 | DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl); |
1753 | DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl); | |
b3609646 | 1754 | /* Keep the old RTL. */ |
1755 | COPY_DECL_RTL (olddecl, newdecl); | |
1756 | } | |
491e04ef | 1757 | else if (TREE_CODE (newdecl) == VAR_DECL |
b3609646 | 1758 | && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl))) |
1759 | { | |
1760 | /* Keep the old RTL. We cannot keep the old RTL if the old | |
1761 | declaration was for an incomplete object and the new | |
1762 | declaration is not since many attributes of the RTL will | |
1763 | change. */ | |
1764 | COPY_DECL_RTL (olddecl, newdecl); | |
8f8ac140 | 1765 | } |
471086d6 | 1766 | } |
1767 | /* If cannot merge, then use the new type and qualifiers, | |
1768 | and don't preserve the old rtl. */ | |
1769 | else | |
1770 | { | |
1771 | /* Clean out any memory we had of the old declaration. */ | |
1772 | tree oldstatic = value_member (olddecl, static_aggregates); | |
1773 | if (oldstatic) | |
1774 | TREE_VALUE (oldstatic) = error_mark_node; | |
1775 | ||
1776 | TREE_TYPE (olddecl) = TREE_TYPE (newdecl); | |
1777 | TREE_READONLY (olddecl) = TREE_READONLY (newdecl); | |
1778 | TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl); | |
1779 | TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl); | |
1780 | } | |
1781 | ||
1782 | /* Merge the storage class information. */ | |
296c463e | 1783 | merge_weak (newdecl, olddecl); |
1784 | ||
96624a9e | 1785 | DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl); |
73aad9b9 | 1786 | DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl); |
d0622bdf | 1787 | TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl); |
1788 | TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl); | |
1789 | if (! DECL_EXTERNAL (olddecl)) | |
1790 | DECL_EXTERNAL (newdecl) = 0; | |
980877d7 | 1791 | |
3340d527 | 1792 | if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl)) |
471086d6 | 1793 | { |
d0622bdf | 1794 | DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl); |
1795 | DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl); | |
9d06cca0 | 1796 | DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl); |
980877d7 | 1797 | DECL_TEMPLATE_INSTANTIATED (newdecl) |
2699dcee | 1798 | |= DECL_TEMPLATE_INSTANTIATED (olddecl); |
3340d527 | 1799 | /* Don't really know how much of the language-specific |
1800 | values we should copy from old to new. */ | |
1801 | DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl); | |
491e04ef | 1802 | DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 = |
1f3233d1 | 1803 | DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2; |
3340d527 | 1804 | DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl); |
caa6fdce | 1805 | DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl); |
4012c20a | 1806 | DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl); |
c792eccc | 1807 | DECL_INITIALIZED_IN_CLASS_P (newdecl) |
1808 | |= DECL_INITIALIZED_IN_CLASS_P (olddecl); | |
3340d527 | 1809 | olddecl_friend = DECL_FRIEND_P (olddecl); |
a731c87f | 1810 | |
1811 | /* Only functions have DECL_BEFRIENDING_CLASSES. */ | |
1812 | if (TREE_CODE (newdecl) == FUNCTION_DECL | |
1813 | || DECL_FUNCTION_TEMPLATE_P (newdecl)) | |
641985fa | 1814 | { |
1815 | DECL_BEFRIENDING_CLASSES (newdecl) | |
1816 | = chainon (DECL_BEFRIENDING_CLASSES (newdecl), | |
1817 | DECL_BEFRIENDING_CLASSES (olddecl)); | |
fb6e00c5 | 1818 | /* DECL_THUNKS is only valid for virtual functions, |
1819 | otherwise it is a DECL_FRIEND_CONTEXT. */ | |
1820 | if (DECL_VIRTUAL_P (newdecl)) | |
1821 | DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl); | |
641985fa | 1822 | } |
471086d6 | 1823 | } |
1824 | ||
471086d6 | 1825 | if (TREE_CODE (newdecl) == FUNCTION_DECL) |
1826 | { | |
980877d7 | 1827 | if (DECL_TEMPLATE_INSTANTIATION (olddecl) |
1828 | && !DECL_TEMPLATE_INSTANTIATION (newdecl)) | |
668ae905 | 1829 | { |
1830 | /* If newdecl is not a specialization, then it is not a | |
1831 | template-related function at all. And that means that we | |
c465b94a | 1832 | should have exited above, returning 0. */ |
b4df430b | 1833 | gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl)); |
668ae905 | 1834 | |
980877d7 | 1835 | if (TREE_USED (olddecl)) |
668ae905 | 1836 | /* From [temp.expl.spec]: |
980877d7 | 1837 | |
668ae905 | 1838 | If a template, a member template or the member of a class |
1839 | template is explicitly specialized then that | |
1840 | specialization shall be declared before the first use of | |
1841 | that specialization that would cause an implicit | |
1842 | instantiation to take place, in every translation unit in | |
1843 | which such a use occurs. */ | |
cf103c6c | 1844 | error ("explicit specialization of %D after first use", |
668ae905 | 1845 | olddecl); |
1846 | ||
1847 | SET_DECL_TEMPLATE_SPECIALIZATION (olddecl); | |
1d1c6a54 | 1848 | |
1849 | /* [temp.expl.spec/14] We don't inline explicit specialization | |
1850 | just because the primary template says so. */ | |
668ae905 | 1851 | } |
1d1c6a54 | 1852 | else |
1853 | { | |
1854 | if (DECL_PENDING_INLINE_INFO (newdecl) == 0) | |
1855 | DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl); | |
bb09dca5 | 1856 | |
1d1c6a54 | 1857 | DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl); |
bb09dca5 | 1858 | |
491e04ef | 1859 | /* If either decl says `inline', this fn is inline, unless |
1d1c6a54 | 1860 | its definition was passed already. */ |
1861 | if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE) | |
1862 | DECL_INLINE (olddecl) = 1; | |
1863 | DECL_INLINE (newdecl) = DECL_INLINE (olddecl); | |
1864 | ||
1865 | DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl) | |
1866 | = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)); | |
1867 | } | |
5955c361 | 1868 | |
8f80e66d | 1869 | /* Preserve abstractness on cloned [cd]tors. */ |
1870 | DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl); | |
1871 | ||
94f3b32d | 1872 | if (! types_match) |
1873 | { | |
4b1984f5 | 1874 | SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl)); |
7e64c604 | 1875 | COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl); |
146c1b4f | 1876 | COPY_DECL_RTL (newdecl, olddecl); |
e857e9c7 | 1877 | } |
1878 | if (! types_match || new_defines_function) | |
1879 | { | |
8036fa43 | 1880 | /* These need to be copied so that the names are available. |
1881 | Note that if the types do match, we'll preserve inline | |
1882 | info and other bits, but if not, we won't. */ | |
94f3b32d | 1883 | DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl); |
1884 | DECL_RESULT (olddecl) = DECL_RESULT (newdecl); | |
94f3b32d | 1885 | } |
471086d6 | 1886 | if (new_defines_function) |
1887 | /* If defining a function declared with other language | |
1888 | linkage, use the previously declared language linkage. */ | |
4b1984f5 | 1889 | SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl)); |
8036fa43 | 1890 | else if (types_match) |
471086d6 | 1891 | { |
1892 | /* If redeclaring a builtin function, and not a definition, | |
1893 | it stays built in. */ | |
1894 | if (DECL_BUILT_IN (olddecl)) | |
1895 | { | |
8305149e | 1896 | DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl); |
bc3887cf | 1897 | DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl); |
471086d6 | 1898 | /* If we're keeping the built-in definition, keep the rtl, |
1899 | regardless of declaration matches. */ | |
146c1b4f | 1900 | COPY_DECL_RTL (olddecl, newdecl); |
471086d6 | 1901 | } |
471086d6 | 1902 | |
1903 | DECL_RESULT (newdecl) = DECL_RESULT (olddecl); | |
471086d6 | 1904 | /* Don't clear out the arguments if we're redefining a function. */ |
1905 | if (DECL_ARGUMENTS (olddecl)) | |
1906 | DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl); | |
1907 | } | |
1908 | } | |
6146c0d9 | 1909 | else if (TREE_CODE (newdecl) == NAMESPACE_DECL) |
1910 | NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl); | |
d0622bdf | 1911 | |
471086d6 | 1912 | /* Now preserve various other info from the definition. */ |
1913 | TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl); | |
1914 | TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl); | |
1915 | DECL_COMMON (newdecl) = DECL_COMMON (olddecl); | |
7e64c604 | 1916 | COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl); |
471086d6 | 1917 | |
b212f378 | 1918 | /* Warn about conflicting visibility specifications. */ |
91caa6ca | 1919 | if (DECL_VISIBILITY_SPECIFIED (olddecl) |
1920 | && DECL_VISIBILITY_SPECIFIED (newdecl) | |
b212f378 | 1921 | && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl)) |
1922 | { | |
1923 | warning ("%J'%D': visibility attribute ignored because it", | |
91caa6ca | 1924 | newdecl, newdecl); |
b212f378 | 1925 | warning ("%Jconflicts with previous declaration here", olddecl); |
1926 | } | |
1927 | /* Choose the declaration which specified visibility. */ | |
1928 | if (DECL_VISIBILITY_SPECIFIED (olddecl)) | |
50333348 | 1929 | { |
50333348 | 1930 | DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl); |
b212f378 | 1931 | DECL_VISIBILITY_SPECIFIED (newdecl) = 1; |
1932 | } | |
50333348 | 1933 | |
471086d6 | 1934 | if (TREE_CODE (newdecl) == FUNCTION_DECL) |
1935 | { | |
1936 | int function_size; | |
471086d6 | 1937 | |
1938 | function_size = sizeof (struct tree_decl); | |
1939 | ||
f702522a | 1940 | memcpy ((char *) olddecl + sizeof (struct tree_common), |
1941 | (char *) newdecl + sizeof (struct tree_common), | |
1942 | function_size - sizeof (struct tree_common)); | |
471086d6 | 1943 | |
668ae905 | 1944 | if (DECL_TEMPLATE_INSTANTIATION (newdecl)) |
0886adbc | 1945 | /* If newdecl is a template instantiation, it is possible that |
1946 | the following sequence of events has occurred: | |
1947 | ||
1948 | o A friend function was declared in a class template. The | |
1949 | class template was instantiated. | |
1950 | ||
1951 | o The instantiation of the friend declaration was | |
1952 | recorded on the instantiation list, and is newdecl. | |
1953 | ||
1954 | o Later, however, instantiate_class_template called pushdecl | |
1955 | on the newdecl to perform name injection. But, pushdecl in | |
1956 | turn called duplicate_decls when it discovered that another | |
1957 | declaration of a global function with the same name already | |
1958 | existed. | |
1959 | ||
1960 | o Here, in duplicate_decls, we decided to clobber newdecl. | |
1961 | ||
1962 | If we're going to do that, we'd better make sure that | |
1963 | olddecl, and not newdecl, is on the list of | |
1964 | instantiations so that if we try to do the instantiation | |
1965 | again we won't get the clobbered declaration. */ | |
491e04ef | 1966 | reregister_specialization (newdecl, |
1967 | DECL_TI_TEMPLATE (newdecl), | |
0886adbc | 1968 | olddecl); |
471086d6 | 1969 | } |
1970 | else | |
1971 | { | |
f702522a | 1972 | memcpy ((char *) olddecl + sizeof (struct tree_common), |
1973 | (char *) newdecl + sizeof (struct tree_common), | |
1974 | sizeof (struct tree_decl) - sizeof (struct tree_common) | |
ab1a776d | 1975 | + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *)); |
471086d6 | 1976 | } |
1977 | ||
1978 | DECL_UID (olddecl) = olddecl_uid; | |
1979 | if (olddecl_friend) | |
1980 | DECL_FRIEND_P (olddecl) = 1; | |
1981 | ||
0bf60c2b | 1982 | /* NEWDECL contains the merged attribute lists. |
1983 | Update OLDDECL to be the same. */ | |
e3c541f0 | 1984 | DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl); |
0bf60c2b | 1985 | |
f8ed00ce | 1986 | /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl |
1987 | so that encode_section_info has a chance to look at the new decl | |
1988 | flags and attributes. */ | |
491e04ef | 1989 | if (DECL_RTL_SET_P (olddecl) |
f8ed00ce | 1990 | && (TREE_CODE (olddecl) == FUNCTION_DECL |
1991 | || (TREE_CODE (olddecl) == VAR_DECL | |
1992 | && TREE_STATIC (olddecl)))) | |
b2c4af5e | 1993 | make_decl_rtl (olddecl); |
f8ed00ce | 1994 | |
947f430b | 1995 | return olddecl; |
471086d6 | 1996 | } |
471086d6 | 1997 | \f |
905d4035 | 1998 | /* Return zero if the declaration NEWDECL is valid |
471086d6 | 1999 | when the declaration OLDDECL (assumed to be for the same name) |
2000 | has already been seen. | |
2001 | Otherwise return an error message format string with a %s | |
2002 | where the identifier should go. */ | |
2003 | ||
e1721763 | 2004 | static const char * |
1b72315d | 2005 | redeclaration_error_message (tree newdecl, tree olddecl) |
471086d6 | 2006 | { |
2007 | if (TREE_CODE (newdecl) == TYPE_DECL) | |
2008 | { | |
2009 | /* Because C++ can put things into name space for free, | |
2010 | constructs like "typedef struct foo { ... } foo" | |
2011 | would look like an erroneous redeclaration. */ | |
daf9ff67 | 2012 | if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl))) |
905d4035 | 2013 | return 0; |
471086d6 | 2014 | else |
905d4035 | 2015 | return "redefinition of `%#D'"; |
471086d6 | 2016 | } |
2017 | else if (TREE_CODE (newdecl) == FUNCTION_DECL) | |
2018 | { | |
2019 | /* If this is a pure function, its olddecl will actually be | |
2020 | the original initialization to `0' (which we force to call | |
2021 | abort()). Don't complain about redefinition in this case. */ | |
a98fd0a1 | 2022 | if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)) |
905d4035 | 2023 | return 0; |
471086d6 | 2024 | |
8417823c | 2025 | /* If both functions come from different namespaces, this is not |
a109dc3b | 2026 | a redeclaration - this is a conflict with a used function. */ |
ddb39453 | 2027 | if (DECL_NAMESPACE_SCOPE_P (olddecl) |
8417823c | 2028 | && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)) |
905d4035 | 2029 | return "`%D' conflicts with used function"; |
8417823c | 2030 | |
c25194fd | 2031 | /* We'll complain about linkage mismatches in |
2032 | warn_extern_redeclared_static. */ | |
2033 | ||
8417823c | 2034 | /* Defining the same name twice is no good. */ |
471086d6 | 2035 | if (DECL_INITIAL (olddecl) != NULL_TREE |
bb09dca5 | 2036 | && DECL_INITIAL (newdecl) != NULL_TREE) |
471086d6 | 2037 | { |
2038 | if (DECL_NAME (olddecl) == NULL_TREE) | |
905d4035 | 2039 | return "`%#D' not declared in class"; |
471086d6 | 2040 | else |
905d4035 | 2041 | return "redefinition of `%#D'"; |
471086d6 | 2042 | } |
905d4035 | 2043 | return 0; |
471086d6 | 2044 | } |
ac9386a0 | 2045 | else if (TREE_CODE (newdecl) == TEMPLATE_DECL) |
2046 | { | |
1611df57 | 2047 | tree nt, ot; |
2048 | ||
2049 | if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL) | |
2050 | { | |
2051 | if (COMPLETE_TYPE_P (TREE_TYPE (newdecl)) | |
2052 | && COMPLETE_TYPE_P (TREE_TYPE (olddecl))) | |
2053 | return "redefinition of `%#D'"; | |
2054 | return NULL; | |
2055 | } | |
2056 | ||
2057 | if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL | |
491e04ef | 2058 | || (DECL_TEMPLATE_RESULT (newdecl) |
1611df57 | 2059 | == DECL_TEMPLATE_RESULT (olddecl))) |
2060 | return NULL; | |
2061 | ||
2062 | nt = DECL_TEMPLATE_RESULT (newdecl); | |
2063 | if (DECL_TEMPLATE_INFO (nt)) | |
2064 | nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt)); | |
2065 | ot = DECL_TEMPLATE_RESULT (olddecl); | |
2066 | if (DECL_TEMPLATE_INFO (ot)) | |
2067 | ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot)); | |
2068 | if (DECL_INITIAL (nt) && DECL_INITIAL (ot)) | |
905d4035 | 2069 | return "redefinition of `%#D'"; |
1611df57 | 2070 | |
2071 | return NULL; | |
ac9386a0 | 2072 | } |
e238c961 | 2073 | else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl)) |
471086d6 | 2074 | { |
2075 | /* Objects declared at top level: */ | |
2076 | /* If at least one is a reference, it's ok. */ | |
2077 | if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl)) | |
905d4035 | 2078 | return 0; |
0543e7a9 | 2079 | /* Reject two definitions. */ |
905d4035 | 2080 | return "redefinition of `%#D'"; |
471086d6 | 2081 | } |
2082 | else | |
2083 | { | |
2084 | /* Objects declared with block scope: */ | |
2085 | /* Reject two definitions, and reject a definition | |
2086 | together with an external reference. */ | |
2087 | if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl))) | |
905d4035 | 2088 | return "redeclaration of `%#D'"; |
2089 | return 0; | |
471086d6 | 2090 | } |
2091 | } | |
2092 | \f | |
2d46e540 | 2093 | /* Create a new label, named ID. */ |
471086d6 | 2094 | |
2d46e540 | 2095 | static tree |
1b72315d | 2096 | make_label_decl (tree id, int local_p) |
471086d6 | 2097 | { |
2d46e540 | 2098 | tree decl; |
471086d6 | 2099 | |
2d46e540 | 2100 | decl = build_decl (LABEL_DECL, id, void_type_node); |
2d46e540 | 2101 | |
2102 | DECL_CONTEXT (decl) = current_function_decl; | |
2103 | DECL_MODE (decl) = VOIDmode; | |
2104 | C_DECLARED_LABEL_FLAG (decl) = local_p; | |
471086d6 | 2105 | |
2d46e540 | 2106 | /* Say where one reference is to the label, for the sake of the |
2107 | error if it is not defined. */ | |
346064d9 | 2108 | DECL_SOURCE_LOCATION (decl) = input_location; |
2d46e540 | 2109 | |
2110 | /* Record the fact that this identifier is bound to this label. */ | |
2111 | SET_IDENTIFIER_LABEL_VALUE (id, decl); | |
2112 | ||
c48d6aec | 2113 | return decl; |
2114 | } | |
2115 | ||
2116 | /* Record this label on the list of used labels so that we can check | |
2117 | at the end of the function to see whether or not the label was | |
2118 | actually defined, and so we can check when the label is defined whether | |
2119 | this use is valid. */ | |
2120 | ||
2121 | static void | |
1b72315d | 2122 | use_label (tree decl) |
c48d6aec | 2123 | { |
2124 | if (named_label_uses == NULL | |
2125 | || named_label_uses->names_in_scope != current_binding_level->names | |
2126 | || named_label_uses->label_decl != decl) | |
2127 | { | |
2128 | struct named_label_use_list *new_ent; | |
a33db04a | 2129 | new_ent = GGC_NEW (struct named_label_use_list); |
1ad432f2 | 2130 | new_ent->label_decl = decl; |
2131 | new_ent->names_in_scope = current_binding_level->names; | |
2132 | new_ent->binding_level = current_binding_level; | |
6a86d77b | 2133 | new_ent->o_goto_locus = input_location; |
1ad432f2 | 2134 | new_ent->next = named_label_uses; |
2135 | named_label_uses = new_ent; | |
471086d6 | 2136 | } |
2d46e540 | 2137 | } |
471086d6 | 2138 | |
2d46e540 | 2139 | /* Look for a label named ID in the current function. If one cannot |
2140 | be found, create one. (We keep track of used, but undefined, | |
2141 | labels, and complain about them at the end of a function.) */ | |
471086d6 | 2142 | |
980877d7 | 2143 | tree |
1b72315d | 2144 | lookup_label (tree id) |
2d46e540 | 2145 | { |
2146 | tree decl; | |
c48d6aec | 2147 | struct named_label_list *ent; |
471086d6 | 2148 | |
851fe51a | 2149 | timevar_push (TV_NAME_LOOKUP); |
2d46e540 | 2150 | /* You can't use labels at global scope. */ |
2151 | if (current_function_decl == NULL_TREE) | |
2152 | { | |
286daa79 | 2153 | error ("label `%E' referenced outside of any function", id); |
851fe51a | 2154 | POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE); |
2d46e540 | 2155 | } |
980877d7 | 2156 | |
2d46e540 | 2157 | /* See if we've already got this label. */ |
2158 | decl = IDENTIFIER_LABEL_VALUE (id); | |
2159 | if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl) | |
851fe51a | 2160 | POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl); |
471086d6 | 2161 | |
2d46e540 | 2162 | /* Record this label on the list of labels used in this function. |
2163 | We do this before calling make_label_decl so that we get the | |
2164 | IDENTIFIER_LABEL_VALUE before the new label is declared. */ | |
a33db04a | 2165 | ent = GGC_CNEW (struct named_label_list); |
c48d6aec | 2166 | ent->old_value = IDENTIFIER_LABEL_VALUE (id); |
2167 | ent->next = named_labels; | |
2168 | named_labels = ent; | |
2169 | ||
2d46e540 | 2170 | /* We need a new label. */ |
2171 | decl = make_label_decl (id, /*local_p=*/0); | |
c48d6aec | 2172 | |
2d46e540 | 2173 | /* Now fill in the information we didn't have before. */ |
c48d6aec | 2174 | ent->label_decl = decl; |
471086d6 | 2175 | |
851fe51a | 2176 | POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl); |
471086d6 | 2177 | } |
2178 | ||
2d46e540 | 2179 | /* Declare a local label named ID. */ |
471086d6 | 2180 | |
2181 | tree | |
1b72315d | 2182 | declare_local_label (tree id) |
471086d6 | 2183 | { |
2d46e540 | 2184 | tree decl; |
471086d6 | 2185 | |
2d46e540 | 2186 | /* Add a new entry to the SHADOWED_LABELS list so that when we leave |
2187 | this scope we can restore the old value of | |
2188 | IDENTIFIER_TYPE_VALUE. */ | |
980877d7 | 2189 | current_binding_level->shadowed_labels |
2d46e540 | 2190 | = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE, |
2191 | current_binding_level->shadowed_labels); | |
2192 | /* Look for the label. */ | |
2193 | decl = make_label_decl (id, /*local_p=*/1); | |
2194 | /* Now fill in the information we didn't have before. */ | |
2195 | TREE_VALUE (current_binding_level->shadowed_labels) = decl; | |
980877d7 | 2196 | |
2d46e540 | 2197 | return decl; |
471086d6 | 2198 | } |
2199 | ||
c48d6aec | 2200 | /* Returns nonzero if it is ill-formed to jump past the declaration of |
2201 | DECL. Returns 2 if it's also a real problem. */ | |
2202 | ||
2203 | static int | |
1b72315d | 2204 | decl_jump_unsafe (tree decl) |
c48d6aec | 2205 | { |
2206 | if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)) | |
2207 | return 0; | |
2208 | ||
2209 | if (DECL_INITIAL (decl) == NULL_TREE | |
2210 | && pod_type_p (TREE_TYPE (decl))) | |
2211 | return 0; | |
2212 | ||
2213 | /* This is really only important if we're crossing an initialization. | |
2214 | The POD stuff is just pedantry; why should it matter if the class | |
2215 | contains a field of pointer to member type? */ | |
2216 | if (DECL_INITIAL (decl) | |
2217 | || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))) | |
2218 | return 2; | |
2219 | return 1; | |
2220 | } | |
2221 | ||
2222 | /* Check that a single previously seen jump to a newly defined label | |
2223 | is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for | |
2224 | the jump context; NAMES are the names in scope in LEVEL at the jump | |
2225 | context; FILE and LINE are the source position of the jump or 0. */ | |
2226 | ||
2227 | static void | |
1b72315d | 2228 | check_previous_goto_1 (tree decl, |
2229 | struct cp_binding_level* level, | |
7727e009 | 2230 | tree names, const location_t *locus) |
c48d6aec | 2231 | { |
2232 | int identified = 0; | |
2233 | int saw_eh = 0; | |
1f3233d1 | 2234 | struct cp_binding_level *b = current_binding_level; |
c48d6aec | 2235 | for (; b; b = b->level_chain) |
2236 | { | |
2237 | tree new_decls = b->names; | |
2238 | tree old_decls = (b == level ? names : NULL_TREE); | |
2239 | for (; new_decls != old_decls; | |
2240 | new_decls = TREE_CHAIN (new_decls)) | |
2241 | { | |
2242 | int problem = decl_jump_unsafe (new_decls); | |
2243 | if (! problem) | |
2244 | continue; | |
2245 | ||
2246 | if (! identified) | |
2247 | { | |
2248 | if (decl) | |
cf103c6c | 2249 | pedwarn ("jump to label `%D'", decl); |
c48d6aec | 2250 | else |
2251 | pedwarn ("jump to case label"); | |
2252 | ||
7727e009 | 2253 | if (locus) |
2254 | pedwarn ("%H from here", locus); | |
c48d6aec | 2255 | identified = 1; |
2256 | } | |
2257 | ||
65750829 | 2258 | if (problem > 1) |
c48d6aec | 2259 | cp_error_at (" crosses initialization of `%#D'", |
2260 | new_decls); | |
2261 | else | |
2262 | cp_pedwarn_at (" enters scope of non-POD `%#D'", | |
2263 | new_decls); | |
2264 | } | |
2265 | ||
2266 | if (b == level) | |
2267 | break; | |
37b9a732 | 2268 | if ((b->kind == sk_try || b->kind == sk_catch) && ! saw_eh) |
c48d6aec | 2269 | { |
2270 | if (! identified) | |
2271 | { | |
2272 | if (decl) | |
cf103c6c | 2273 | pedwarn ("jump to label `%D'", decl); |
c48d6aec | 2274 | else |
2275 | pedwarn ("jump to case label"); | |
2276 | ||
7727e009 | 2277 | if (locus) |
2278 | pedwarn ("%H from here", locus); | |
c48d6aec | 2279 | identified = 1; |
2280 | } | |
37b9a732 | 2281 | if (b->kind == sk_try) |
65750829 | 2282 | error (" enters try block"); |
2283 | else | |
2284 | error (" enters catch block"); | |
c48d6aec | 2285 | saw_eh = 1; |
2286 | } | |
2287 | } | |
2288 | } | |
2289 | ||
2290 | static void | |
1b72315d | 2291 | check_previous_goto (struct named_label_use_list* use) |
c48d6aec | 2292 | { |
2293 | check_previous_goto_1 (use->label_decl, use->binding_level, | |
7727e009 | 2294 | use->names_in_scope, &use->o_goto_locus); |
c48d6aec | 2295 | } |
2296 | ||
2297 | static void | |
1b72315d | 2298 | check_switch_goto (struct cp_binding_level* level) |
c48d6aec | 2299 | { |
7727e009 | 2300 | check_previous_goto_1 (NULL_TREE, level, level->names, NULL); |
c48d6aec | 2301 | } |
2302 | ||
2303 | /* Check that any previously seen jumps to a newly defined label DECL | |
2304 | are OK. Called by define_label. */ | |
2305 | ||
2306 | static void | |
1b72315d | 2307 | check_previous_gotos (tree decl) |
c48d6aec | 2308 | { |
2309 | struct named_label_use_list **usep; | |
2310 | ||
2311 | if (! TREE_USED (decl)) | |
2312 | return; | |
2313 | ||
2314 | for (usep = &named_label_uses; *usep; ) | |
2315 | { | |
2316 | struct named_label_use_list *use = *usep; | |
2317 | if (use->label_decl == decl) | |
2318 | { | |
2319 | check_previous_goto (use); | |
2320 | *usep = use->next; | |
2321 | } | |
2322 | else | |
2323 | usep = &(use->next); | |
2324 | } | |
2325 | } | |
2326 | ||
2327 | /* Check that a new jump to a label DECL is OK. Called by | |
2328 | finish_goto_stmt. */ | |
2329 | ||
2330 | void | |
1b72315d | 2331 | check_goto (tree decl) |
c48d6aec | 2332 | { |
2333 | int identified = 0; | |
2334 | tree bad; | |
2335 | struct named_label_list *lab; | |
2336 | ||
5ba7b7e9 | 2337 | /* We can't know where a computed goto is jumping. So we assume |
2338 | that it's OK. */ | |
2339 | if (! DECL_P (decl)) | |
2340 | return; | |
2341 | ||
c48d6aec | 2342 | /* If the label hasn't been defined yet, defer checking. */ |
2343 | if (! DECL_INITIAL (decl)) | |
2344 | { | |
2345 | use_label (decl); | |
2346 | return; | |
2347 | } | |
2348 | ||
2349 | for (lab = named_labels; lab; lab = lab->next) | |
2350 | if (decl == lab->label_decl) | |
2351 | break; | |
2352 | ||
2353 | /* If the label is not on named_labels it's a gcc local label, so | |
2354 | it must be in an outer scope, so jumping to it is always OK. */ | |
2355 | if (lab == 0) | |
2356 | return; | |
2357 | ||
65750829 | 2358 | if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls) |
2359 | && !identified) | |
c48d6aec | 2360 | { |
2361 | cp_pedwarn_at ("jump to label `%D'", decl); | |
2362 | pedwarn (" from here"); | |
2363 | identified = 1; | |
2364 | } | |
2365 | ||
2366 | for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad)) | |
2367 | { | |
2368 | tree b = TREE_VALUE (bad); | |
2369 | int u = decl_jump_unsafe (b); | |
2370 | ||
2371 | if (u > 1 && DECL_ARTIFICIAL (b)) | |
2372 | /* Can't skip init of __exception_info. */ | |
9bc3739f | 2373 | error ("%J enters catch block", b); |
c48d6aec | 2374 | else if (u > 1) |
2375 | cp_error_at (" skips initialization of `%#D'", b); | |
2376 | else | |
2377 | cp_pedwarn_at (" enters scope of non-POD `%#D'", b); | |
2378 | } | |
2379 | ||
65750829 | 2380 | if (lab->in_try_scope) |
c48d6aec | 2381 | error (" enters try block"); |
65750829 | 2382 | else if (lab->in_catch_scope) |
2383 | error (" enters catch block"); | |
c48d6aec | 2384 | } |
2385 | ||
471086d6 | 2386 | /* Define a label, specifying the location in the source file. |
91a39dda | 2387 | Return the LABEL_DECL node for the label. */ |
471086d6 | 2388 | |
2389 | tree | |
92ddaf90 | 2390 | define_label (location_t location, tree name) |
471086d6 | 2391 | { |
edf2a96a | 2392 | tree decl = lookup_label (name); |
c48d6aec | 2393 | struct named_label_list *ent; |
cd16867a | 2394 | struct cp_binding_level *p; |
c48d6aec | 2395 | |
851fe51a | 2396 | timevar_push (TV_NAME_LOOKUP); |
c48d6aec | 2397 | for (ent = named_labels; ent; ent = ent->next) |
2398 | if (ent->label_decl == decl) | |
2399 | break; | |
471086d6 | 2400 | |
886deab8 | 2401 | /* After labels, make any new cleanups in the function go into their |
471086d6 | 2402 | own new (temporary) binding contour. */ |
491e04ef | 2403 | for (p = current_binding_level; |
2404 | p->kind != sk_function_parms; | |
37b9a732 | 2405 | p = p->level_chain) |
886deab8 | 2406 | p->more_cleanups_ok = 0; |
471086d6 | 2407 | |
bcf789d7 | 2408 | if (name == get_identifier ("wchar_t")) |
cf103c6c | 2409 | pedwarn ("label named wchar_t"); |
bcf789d7 | 2410 | |
471086d6 | 2411 | if (DECL_INITIAL (decl) != NULL_TREE) |
91a39dda | 2412 | error ("duplicate label `%D'", decl); |
471086d6 | 2413 | else |
2414 | { | |
471086d6 | 2415 | /* Mark label as having been defined. */ |
2416 | DECL_INITIAL (decl) = error_mark_node; | |
2417 | /* Say where in the source. */ | |
346064d9 | 2418 | DECL_SOURCE_LOCATION (decl) = location; |
c48d6aec | 2419 | if (ent) |
2420 | { | |
2421 | ent->names_in_scope = current_binding_level->names; | |
2422 | ent->binding_level = current_binding_level; | |
2423 | } | |
2424 | check_previous_gotos (decl); | |
471086d6 | 2425 | } |
91a39dda | 2426 | |
851fe51a | 2427 | timevar_pop (TV_NAME_LOOKUP); |
91a39dda | 2428 | return decl; |
471086d6 | 2429 | } |
2430 | ||
127a1cd0 | 2431 | struct cp_switch |
2432 | { | |
1f3233d1 | 2433 | struct cp_binding_level *level; |
127a1cd0 | 2434 | struct cp_switch *next; |
225ec6aa | 2435 | /* The SWITCH_STMT being built. */ |
2436 | tree switch_stmt; | |
2437 | /* A splay-tree mapping the low element of a case range to the high | |
2438 | element, or NULL_TREE if there is no high element. Used to | |
2439 | determine whether or not a new case label duplicates an old case | |
2440 | label. We need a tree, rather than simply a hash table, because | |
2441 | of the GNU case range extension. */ | |
2442 | splay_tree cases; | |
127a1cd0 | 2443 | }; |
2444 | ||
225ec6aa | 2445 | /* A stack of the currently active switch statements. The innermost |
2446 | switch statement is on the top of the stack. There is no need to | |
2447 | mark the stack for garbage collection because it is only active | |
2448 | during the processing of the body of a function, and we never | |
2449 | collect at that point. */ | |
3c3beda6 | 2450 | |
127a1cd0 | 2451 | static struct cp_switch *switch_stack; |
2452 | ||
225ec6aa | 2453 | /* Called right after a switch-statement condition is parsed. |
2454 | SWITCH_STMT is the switch statement being parsed. */ | |
2455 | ||
127a1cd0 | 2456 | void |
1b72315d | 2457 | push_switch (tree switch_stmt) |
127a1cd0 | 2458 | { |
6edf18a6 | 2459 | struct cp_switch *p = xmalloc (sizeof (struct cp_switch)); |
127a1cd0 | 2460 | p->level = current_binding_level; |
2461 | p->next = switch_stack; | |
225ec6aa | 2462 | p->switch_stmt = switch_stmt; |
2463 | p->cases = splay_tree_new (case_compare, NULL, NULL); | |
127a1cd0 | 2464 | switch_stack = p; |
2465 | } | |
2466 | ||
2467 | void | |
1b72315d | 2468 | pop_switch (void) |
127a1cd0 | 2469 | { |
4ee9c684 | 2470 | struct cp_switch *cs = switch_stack; |
2471 | ||
2472 | /* Emit warnings as needed. */ | |
2473 | c_do_switch_warnings (cs->cases, cs->switch_stmt); | |
3c3beda6 | 2474 | |
225ec6aa | 2475 | splay_tree_delete (cs->cases); |
127a1cd0 | 2476 | switch_stack = switch_stack->next; |
769177ac | 2477 | free (cs); |
127a1cd0 | 2478 | } |
2479 | ||
c2af356c | 2480 | /* Note that we've seen a definition of a case label, and complain if this |
2481 | is a bad place for one. */ | |
96624a9e | 2482 | |
4aa0811f | 2483 | tree |
1b72315d | 2484 | finish_case_label (tree low_value, tree high_value) |
471086d6 | 2485 | { |
4aa0811f | 2486 | tree cond, r; |
cd16867a | 2487 | struct cp_binding_level *p; |
127a1cd0 | 2488 | |
225ec6aa | 2489 | if (processing_template_decl) |
2490 | { | |
e41f0d80 | 2491 | tree label; |
2492 | ||
225ec6aa | 2493 | /* For templates, just add the case label; we'll do semantic |
2494 | analysis at instantiation-time. */ | |
e41f0d80 | 2495 | label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); |
4aa0811f | 2496 | return add_stmt (build_case_label (low_value, high_value, label)); |
225ec6aa | 2497 | } |
2498 | ||
2499 | /* Find the condition on which this switch statement depends. */ | |
2500 | cond = SWITCH_COND (switch_stack->switch_stmt); | |
2501 | if (cond && TREE_CODE (cond) == TREE_LIST) | |
2502 | cond = TREE_VALUE (cond); | |
225ec6aa | 2503 | |
2ca392fd | 2504 | r = c_add_case_label (switch_stack->cases, cond, TREE_TYPE (cond), |
2505 | low_value, high_value); | |
471086d6 | 2506 | |
c48d6aec | 2507 | check_switch_goto (switch_stack->level); |
127a1cd0 | 2508 | |
886deab8 | 2509 | /* After labels, make any new cleanups in the function go into their |
471086d6 | 2510 | own new (temporary) binding contour. */ |
491e04ef | 2511 | for (p = current_binding_level; |
2512 | p->kind != sk_function_parms; | |
37b9a732 | 2513 | p = p->level_chain) |
886deab8 | 2514 | p->more_cleanups_ok = 0; |
4aa0811f | 2515 | |
2516 | return r; | |
471086d6 | 2517 | } |
2518 | \f | |
e4e283ec | 2519 | /* Hash a TYPENAME_TYPE. K is really of type `tree'. */ |
2520 | ||
1f3233d1 | 2521 | static hashval_t |
1b72315d | 2522 | typename_hash (const void* k) |
e4e283ec | 2523 | { |
1f3233d1 | 2524 | hashval_t hash; |
2525 | tree t = (tree) k; | |
e4e283ec | 2526 | |
957b210f | 2527 | hash = (htab_hash_pointer (TYPE_CONTEXT (t)) |
2528 | ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t)))); | |
e4e283ec | 2529 | |
2530 | return hash; | |
2531 | } | |
2532 | ||
2533 | /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */ | |
2534 | ||
1f3233d1 | 2535 | static int |
1b72315d | 2536 | typename_compare (const void * k1, const void * k2) |
e4e283ec | 2537 | { |
2538 | tree t1; | |
2539 | tree t2; | |
2540 | tree d1; | |
2541 | tree d2; | |
2542 | ||
2543 | t1 = (tree) k1; | |
2544 | t2 = (tree) k2; | |
2545 | d1 = TYPE_NAME (t1); | |
2546 | d2 = TYPE_NAME (t2); | |
980877d7 | 2547 | |
e4e283ec | 2548 | return (DECL_NAME (d1) == DECL_NAME (d2) |
1f3233d1 | 2549 | && TYPE_CONTEXT (t1) == TYPE_CONTEXT (t2) |
980877d7 | 2550 | && ((TREE_TYPE (t1) != NULL_TREE) |
e4e283ec | 2551 | == (TREE_TYPE (t2) != NULL_TREE)) |
2552 | && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)) | |
2553 | && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2)); | |
2554 | } | |
2555 | ||
871d88e7 | 2556 | /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is |
2557 | the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE | |
2558 | is non-NULL, this type is being created by the implicit typename | |
2559 | extension, and BASE_TYPE is a type named `t' in some base class of | |
980877d7 | 2560 | `T' which depends on template parameters. |
871d88e7 | 2561 | |
2562 | Returns the new TYPENAME_TYPE. */ | |
2563 | ||
1f3233d1 | 2564 | static GTY ((param_is (union tree_node))) htab_t typename_htab; |
2565 | ||
9140e457 | 2566 | static tree |
954ad420 | 2567 | build_typename_type (tree context, tree name, tree fullname) |
871d88e7 | 2568 | { |
2569 | tree t; | |
2570 | tree d; | |
b9a7cc69 | 2571 | void **e; |
871d88e7 | 2572 | |
1f3233d1 | 2573 | if (typename_htab == NULL) |
1e4853c2 | 2574 | { |
491e04ef | 2575 | typename_htab = htab_create_ggc (61, &typename_hash, |
1f3233d1 | 2576 | &typename_compare, NULL); |
1e4853c2 | 2577 | } |
871d88e7 | 2578 | |
2579 | /* Build the TYPENAME_TYPE. */ | |
9972f65e | 2580 | t = make_aggr_type (TYPENAME_TYPE); |
871d88e7 | 2581 | TYPE_CONTEXT (t) = FROB_CONTEXT (context); |
2582 | TYPENAME_TYPE_FULLNAME (t) = fullname; | |
871d88e7 | 2583 | |
2584 | /* Build the corresponding TYPE_DECL. */ | |
2585 | d = build_decl (TYPE_DECL, name, t); | |
2586 | TYPE_NAME (TREE_TYPE (d)) = d; | |
2587 | TYPE_STUB_DECL (TREE_TYPE (d)) = d; | |
2588 | DECL_CONTEXT (d) = FROB_CONTEXT (context); | |
caa99b15 | 2589 | DECL_ARTIFICIAL (d) = 1; |
871d88e7 | 2590 | |
e4e283ec | 2591 | /* See if we already have this type. */ |
1f3233d1 | 2592 | e = htab_find_slot (typename_htab, t, INSERT); |
2593 | if (*e) | |
2594 | t = (tree) *e; | |
e4e283ec | 2595 | else |
1f3233d1 | 2596 | *e = t; |
e4e283ec | 2597 | |
871d88e7 | 2598 | return t; |
2599 | } | |
2600 | ||
97dbca2f | 2601 | /* Resolve `typename CONTEXT::NAME'. Returns an appropriate type, |
2602 | unless an error occurs, in which case error_mark_node is returned. | |
9edbac04 | 2603 | If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is |
2604 | set, we return that, rather than the _TYPE it corresponds to, in | |
2605 | other cases we look through the type decl. If TF_ERROR is set, | |
2606 | complain about errors, otherwise be quiet. */ | |
97dbca2f | 2607 | |
e857e9c7 | 2608 | tree |
1b72315d | 2609 | make_typename_type (tree context, tree name, tsubst_flags_t complain) |
e857e9c7 | 2610 | { |
15ba7646 | 2611 | tree fullname; |
bccffb3a | 2612 | |
50a06544 | 2613 | if (name == error_mark_node |
2614 | || context == NULL_TREE | |
2615 | || context == error_mark_node) | |
2616 | return error_mark_node; | |
2617 | ||
9308e976 | 2618 | if (TYPE_P (name)) |
91fa7c70 | 2619 | { |
980877d7 | 2620 | if (!(TYPE_LANG_SPECIFIC (name) |
2621 | && (CLASSTYPE_IS_TEMPLATE (name) | |
91fa7c70 | 2622 | || CLASSTYPE_USE_TEMPLATE (name)))) |
2623 | name = TYPE_IDENTIFIER (name); | |
2624 | else | |
2625 | /* Create a TEMPLATE_ID_EXPR for the type. */ | |
2626 | name = build_nt (TEMPLATE_ID_EXPR, | |
2627 | CLASSTYPE_TI_TEMPLATE (name), | |
2628 | CLASSTYPE_TI_ARGS (name)); | |
2629 | } | |
9dc9e65f | 2630 | else if (TREE_CODE (name) == TYPE_DECL) |
bccffb3a | 2631 | name = DECL_NAME (name); |
15ba7646 | 2632 | |
2633 | fullname = name; | |
2634 | ||
2635 | if (TREE_CODE (name) == TEMPLATE_ID_EXPR) | |
eab00fbe | 2636 | { |
2637 | name = TREE_OPERAND (name, 0); | |
2638 | if (TREE_CODE (name) == TEMPLATE_DECL) | |
2639 | name = TREE_OPERAND (fullname, 0) = DECL_NAME (name); | |
2640 | } | |
69773da0 | 2641 | if (TREE_CODE (name) == TEMPLATE_DECL) |
2642 | { | |
cf103c6c | 2643 | error ("`%D' used without template parameters", name); |
69773da0 | 2644 | return error_mark_node; |
2645 | } | |
b4df430b | 2646 | gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); |
491e04ef | 2647 | |
aba12bf8 | 2648 | if (TREE_CODE (context) == NAMESPACE_DECL) |
2649 | { | |
2650 | /* We can get here from typename_sub0 in the explicit_template_type | |
2651 | expansion. Just fail. */ | |
9edbac04 | 2652 | if (complain & tf_error) |
cf103c6c | 2653 | error ("no class template named `%#T' in `%#T'", |
97dbca2f | 2654 | name, context); |
aba12bf8 | 2655 | return error_mark_node; |
2656 | } | |
2657 | ||
c04baa53 | 2658 | if (!dependent_type_p (context) |
7e277854 | 2659 | || currently_open_class (context)) |
e857e9c7 | 2660 | { |
15ba7646 | 2661 | if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR) |
2662 | { | |
73c10977 | 2663 | tree tmpl = NULL_TREE; |
15ba7646 | 2664 | if (IS_AGGR_TYPE (context)) |
b330805e | 2665 | tmpl = lookup_field (context, name, 0, false); |
73c10977 | 2666 | if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl)) |
15ba7646 | 2667 | { |
9edbac04 | 2668 | if (complain & tf_error) |
cf103c6c | 2669 | error ("no class template named `%#T' in `%#T'", |
97dbca2f | 2670 | name, context); |
15ba7646 | 2671 | return error_mark_node; |
2672 | } | |
241ce711 | 2673 | |
7a468236 | 2674 | if (complain & tf_error) |
e4f430b5 | 2675 | perform_or_defer_access_check (TYPE_BINFO (context), tmpl); |
01d4830b | 2676 | |
980877d7 | 2677 | return lookup_template_class (tmpl, |
73c10977 | 2678 | TREE_OPERAND (fullname, 1), |
980877d7 | 2679 | NULL_TREE, context, |
f8ce2bac | 2680 | /*entering_scope=*/0, |
b992fe70 | 2681 | tf_error | tf_warning | tf_user); |
15ba7646 | 2682 | } |
2683 | else | |
e857e9c7 | 2684 | { |
1f3b0a54 | 2685 | tree t; |
980877d7 | 2686 | |
1f3b0a54 | 2687 | if (!IS_AGGR_TYPE (context)) |
15ba7646 | 2688 | { |
9edbac04 | 2689 | if (complain & tf_error) |
cf103c6c | 2690 | error ("no type named `%#T' in `%#T'", name, context); |
15ba7646 | 2691 | return error_mark_node; |
2692 | } | |
1d23987c | 2693 | |
b330805e | 2694 | t = lookup_field (context, name, 0, true); |
60c1a862 | 2695 | if (t) |
9edbac04 | 2696 | { |
981a251c | 2697 | if (TREE_CODE (t) != TYPE_DECL) |
2698 | { | |
2699 | if (complain & tf_error) | |
2700 | error ("no type named `%#T' in `%#T'", name, context); | |
2701 | return error_mark_node; | |
2702 | } | |
2703 | ||
7a468236 | 2704 | if (complain & tf_error) |
e4f430b5 | 2705 | perform_or_defer_access_check (TYPE_BINFO (context), t); |
01d4830b | 2706 | |
9edbac04 | 2707 | if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl)) |
2708 | t = TREE_TYPE (t); | |
491e04ef | 2709 | |
9edbac04 | 2710 | return t; |
2711 | } | |
e857e9c7 | 2712 | } |
e857e9c7 | 2713 | } |
06a748d7 | 2714 | |
2715 | /* If the CONTEXT is not a template type, then either the field is | |
2716 | there now or its never going to be. */ | |
c04baa53 | 2717 | if (!dependent_type_p (context)) |
06a748d7 | 2718 | { |
9edbac04 | 2719 | if (complain & tf_error) |
cf103c6c | 2720 | error ("no type named `%#T' in `%#T'", name, context); |
06a748d7 | 2721 | return error_mark_node; |
2722 | } | |
980877d7 | 2723 | |
954ad420 | 2724 | return build_typename_type (context, name, fullname); |
e857e9c7 | 2725 | } |
2726 | ||
47d727d4 | 2727 | /* Resolve `CONTEXT::template NAME'. Returns an appropriate type, |
2728 | unless an error occurs, in which case error_mark_node is returned. | |
9edbac04 | 2729 | If we locate a TYPE_DECL, we return that, rather than the _TYPE it |
2730 | corresponds to. If COMPLAIN zero, don't complain about any errors | |
2731 | that occur. */ | |
47d727d4 | 2732 | |
2733 | tree | |
1b72315d | 2734 | make_unbound_class_template (tree context, tree name, tsubst_flags_t complain) |
47d727d4 | 2735 | { |
2736 | tree t; | |
2737 | tree d; | |
2738 | ||
2739 | if (TYPE_P (name)) | |
2740 | name = TYPE_IDENTIFIER (name); | |
2741 | else if (DECL_P (name)) | |
2742 | name = DECL_NAME (name); | |
092b1d6f | 2743 | gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); |
47d727d4 | 2744 | |
c04baa53 | 2745 | if (!dependent_type_p (context) |
47d727d4 | 2746 | || currently_open_class (context)) |
2747 | { | |
2748 | tree tmpl = NULL_TREE; | |
2749 | ||
2750 | if (IS_AGGR_TYPE (context)) | |
b330805e | 2751 | tmpl = lookup_field (context, name, 0, false); |
47d727d4 | 2752 | |
2753 | if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl)) | |
2754 | { | |
b9a2c51c | 2755 | if (complain & tf_error) |
cf103c6c | 2756 | error ("no class template named `%#T' in `%#T'", name, context); |
47d727d4 | 2757 | return error_mark_node; |
2758 | } | |
491e04ef | 2759 | |
7a468236 | 2760 | if (complain & tf_error) |
e4f430b5 | 2761 | perform_or_defer_access_check (TYPE_BINFO (context), tmpl); |
47d727d4 | 2762 | |
2763 | return tmpl; | |
2764 | } | |
2765 | ||
2766 | /* Build the UNBOUND_CLASS_TEMPLATE. */ | |
2767 | t = make_aggr_type (UNBOUND_CLASS_TEMPLATE); | |
2768 | TYPE_CONTEXT (t) = FROB_CONTEXT (context); | |
2769 | TREE_TYPE (t) = NULL_TREE; | |
2770 | ||
2771 | /* Build the corresponding TEMPLATE_DECL. */ | |
2772 | d = build_decl (TEMPLATE_DECL, name, t); | |
2773 | TYPE_NAME (TREE_TYPE (d)) = d; | |
2774 | TYPE_STUB_DECL (TREE_TYPE (d)) = d; | |
2775 | DECL_CONTEXT (d) = FROB_CONTEXT (context); | |
2776 | DECL_ARTIFICIAL (d) = 1; | |
2777 | ||
2778 | return t; | |
2779 | } | |
2780 | ||
471086d6 | 2781 | \f |
54bd1509 | 2782 | |
471086d6 | 2783 | /* Push the declarations of builtin types into the namespace. |
b7d1e8ea | 2784 | RID_INDEX is the index of the builtin type in the array |
2785 | RID_POINTERS. NAME is the name used when looking up the builtin | |
2786 | type. TYPE is the _TYPE node for the builtin type. */ | |
471086d6 | 2787 | |
174fcc61 | 2788 | void |
491e04ef | 2789 | record_builtin_type (enum rid rid_index, |
2790 | const char* name, | |
1b72315d | 2791 | tree type) |
471086d6 | 2792 | { |
2793 | tree rname = NULL_TREE, tname = NULL_TREE; | |
034b484a | 2794 | tree tdecl = NULL_TREE; |
471086d6 | 2795 | |
518796ad | 2796 | if ((int) rid_index < (int) RID_MAX) |
471086d6 | 2797 | rname = ridpointers[(int) rid_index]; |
2798 | if (name) | |
2799 | tname = get_identifier (name); | |
2800 | ||
b7d1e8ea | 2801 | /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be |
2802 | eliminated. Built-in types should not be looked up name; their | |
2803 | names are keywords that the parser can recognize. However, there | |
2804 | is code in c-common.c that uses identifier_global_value to look | |
2805 | up built-in types by name. */ | |
471086d6 | 2806 | if (tname) |
2807 | { | |
b7d1e8ea | 2808 | tdecl = build_decl (TYPE_DECL, tname, type); |
2809 | DECL_ARTIFICIAL (tdecl) = 1; | |
37b9a732 | 2810 | SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl); |
471086d6 | 2811 | } |
b7d1e8ea | 2812 | if (rname) |
471086d6 | 2813 | { |
b7d1e8ea | 2814 | if (!tdecl) |
471086d6 | 2815 | { |
b7d1e8ea | 2816 | tdecl = build_decl (TYPE_DECL, rname, type); |
2817 | DECL_ARTIFICIAL (tdecl) = 1; | |
471086d6 | 2818 | } |
b7d1e8ea | 2819 | SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl); |
471086d6 | 2820 | } |
b7d1e8ea | 2821 | |
2822 | if (!TYPE_NAME (type)) | |
2823 | TYPE_NAME (type) = tdecl; | |
54bd1509 | 2824 | |
2825 | if (tdecl) | |
73ae3ef7 | 2826 | debug_hooks->type_decl (tdecl, 0); |
471086d6 | 2827 | } |
2828 | ||
7d53e30d | 2829 | /* Record one of the standard Java types. |
84ea6a1d | 2830 | * Declare it as having the given NAME. |
2831 | * If SIZE > 0, it is the size of one of the integral types; | |
2832 | * otherwise it is the negative of the size of one of the other types. */ | |
7d53e30d | 2833 | |
2834 | static tree | |
1b72315d | 2835 | record_builtin_java_type (const char* name, int size) |
7d53e30d | 2836 | { |
2837 | tree type, decl; | |
2838 | if (size > 0) | |
2839 | type = make_signed_type (size); | |
2840 | else if (size > -32) | |
a109dc3b | 2841 | { /* "__java_char" or ""__java_boolean". */ |
7d53e30d | 2842 | type = make_unsigned_type (-size); |
2843 | /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/ | |
2844 | } | |
2845 | else | |
a109dc3b | 2846 | { /* "__java_float" or ""__java_double". */ |
7d53e30d | 2847 | type = make_node (REAL_TYPE); |
2848 | TYPE_PRECISION (type) = - size; | |
2849 | layout_type (type); | |
2850 | } | |
518796ad | 2851 | record_builtin_type (RID_MAX, name, type); |
7d53e30d | 2852 | decl = TYPE_NAME (type); |
47b15141 | 2853 | |
2854 | /* Suppress generate debug symbol entries for these types, | |
2855 | since for normal C++ they are just clutter. | |
a109dc3b | 2856 | However, push_lang_context undoes this if extern "Java" is seen. */ |
7d53e30d | 2857 | DECL_IGNORED_P (decl) = 1; |
47b15141 | 2858 | |
7d53e30d | 2859 | TYPE_FOR_JAVA (type) = 1; |
2860 | return type; | |
2861 | } | |
2862 | ||
a109dc3b | 2863 | /* Push a type into the namespace so that the back-ends ignore it. */ |
2100d3e8 | 2864 | |
2865 | static void | |
1b72315d | 2866 | record_unknown_type (tree type, const char* name) |
2100d3e8 | 2867 | { |
2868 | tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type)); | |
2869 | /* Make sure the "unknown type" typedecl gets ignored for debug info. */ | |
2870 | DECL_IGNORED_P (decl) = 1; | |
2871 | TYPE_DECL_SUPPRESS_DEBUG (decl) = 1; | |
2872 | TYPE_SIZE (type) = TYPE_SIZE (void_type_node); | |
2873 | TYPE_ALIGN (type) = 1; | |
aca14577 | 2874 | TYPE_USER_ALIGN (type) = 0; |
2100d3e8 | 2875 | TYPE_MODE (type) = TYPE_MODE (void_type_node); |
980877d7 | 2876 | } |
2100d3e8 | 2877 | |
8eadd521 | 2878 | /* An string for which we should create an IDENTIFIER_NODE at |
2879 | startup. */ | |
2880 | ||
2881 | typedef struct predefined_identifier | |
2882 | { | |
2883 | /* The name of the identifier. */ | |
e99c3a1d | 2884 | const char *const name; |
8eadd521 | 2885 | /* The place where the IDENTIFIER_NODE should be stored. */ |
e99c3a1d | 2886 | tree *const node; |
3160db1d | 2887 | /* Nonzero if this is the name of a constructor or destructor. */ |
e99c3a1d | 2888 | const int ctor_or_dtor_p; |
8eadd521 | 2889 | } predefined_identifier; |
2890 | ||
2891 | /* Create all the predefined identifiers. */ | |
2892 | ||
2893 | static void | |
1b72315d | 2894 | initialize_predefined_identifiers (void) |
8eadd521 | 2895 | { |
e99c3a1d | 2896 | const predefined_identifier *pid; |
8eadd521 | 2897 | |
2898 | /* A table of identifiers to create at startup. */ | |
e99c3a1d | 2899 | static const predefined_identifier predefined_identifiers[] = { |
f04596da | 2900 | { "C++", &lang_name_cplusplus, 0 }, |
2901 | { "C", &lang_name_c, 0 }, | |
2902 | { "Java", &lang_name_java, 0 }, | |
2903 | { CTOR_NAME, &ctor_identifier, 1 }, | |
2904 | { "__base_ctor", &base_ctor_identifier, 1 }, | |
2905 | { "__comp_ctor", &complete_ctor_identifier, 1 }, | |
2906 | { DTOR_NAME, &dtor_identifier, 1 }, | |
2907 | { "__comp_dtor", &complete_dtor_identifier, 1 }, | |
2908 | { "__base_dtor", &base_dtor_identifier, 1 }, | |
2909 | { "__deleting_dtor", &deleting_dtor_identifier, 1 }, | |
f04596da | 2910 | { IN_CHARGE_NAME, &in_charge_identifier, 0 }, |
f04596da | 2911 | { "nelts", &nelts_identifier, 0 }, |
2912 | { THIS_NAME, &this_identifier, 0 }, | |
dc9b5a48 | 2913 | { VTABLE_DELTA_NAME, &delta_identifier, 0 }, |
f04596da | 2914 | { VTABLE_PFN_NAME, &pfn_identifier, 0 }, |
f04596da | 2915 | { "_vptr", &vptr_identifier, 0 }, |
0ce25b06 | 2916 | { "__vtt_parm", &vtt_parm_identifier, 0 }, |
7bfd46d1 | 2917 | { "::", &global_scope_name, 0 }, |
98eaf693 | 2918 | { "std", &std_identifier, 0 }, |
f04596da | 2919 | { NULL, NULL, 0 } |
8eadd521 | 2920 | }; |
2921 | ||
2922 | for (pid = predefined_identifiers; pid->name; ++pid) | |
f04596da | 2923 | { |
2924 | *pid->node = get_identifier (pid->name); | |
2925 | if (pid->ctor_or_dtor_p) | |
2926 | IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1; | |
2927 | } | |
8eadd521 | 2928 | } |
2929 | ||
471086d6 | 2930 | /* Create the predefined scalar types of C, |
2931 | and some nodes representing standard constants (0, 1, (void *)0). | |
2932 | Initialize the global binding level. | |
2933 | Make definitions for built-in primitive functions. */ | |
2934 | ||
2935 | void | |
1b72315d | 2936 | cxx_init_decl_processing (void) |
471086d6 | 2937 | { |
d2d4bdde | 2938 | tree void_ftype; |
2939 | tree void_ftype_ptr; | |
471086d6 | 2940 | |
1561d3cd | 2941 | build_common_tree_nodes (flag_signed_char, false); |
0366834b | 2942 | |
8eadd521 | 2943 | /* Create all the identifiers we need. */ |
2944 | initialize_predefined_identifiers (); | |
471086d6 | 2945 | |
1e4853c2 | 2946 | /* Create the global variables. */ |
2947 | push_to_top_level (); | |
509cd7a7 | 2948 | |
7bfd46d1 | 2949 | current_function_decl = NULL_TREE; |
66115136 | 2950 | current_binding_level = NULL; |
a109dc3b | 2951 | /* Enter the global namespace. */ |
b4df430b | 2952 | gcc_assert (global_namespace == NULL_TREE); |
7bfd46d1 | 2953 | global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name, |
2954 | void_type_node); | |
e880f232 | 2955 | begin_scope (sk_namespace, global_namespace); |
7bfd46d1 | 2956 | |
18e99d00 | 2957 | current_lang_name = NULL_TREE; |
2958 | ||
5882ce16 | 2959 | /* Adjust various flags based on command-line settings. */ |
a442e18f | 2960 | if (!flag_permissive) |
caa99b15 | 2961 | flag_pedantic_errors = 1; |
5882ce16 | 2962 | if (!flag_no_inline) |
1f1fa73c | 2963 | { |
2964 | flag_inline_trees = 1; | |
2965 | flag_no_inline = 1; | |
2966 | } | |
10c08065 | 2967 | if (flag_inline_functions) |
2968 | { | |
2969 | flag_inline_trees = 2; | |
2970 | flag_inline_functions = 0; | |
2971 | } | |
eae9825c | 2972 | |
fc5cb4c0 | 2973 | /* Force minimum function alignment if using the least significant |
2974 | bit of function pointers to store the virtual bit. */ | |
2975 | if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn | |
2976 | && force_align_functions_log < 1) | |
2977 | force_align_functions_log = 1; | |
2978 | ||
471086d6 | 2979 | /* Initially, C. */ |
2980 | current_lang_name = lang_name_c; | |
2981 | ||
471086d6 | 2982 | error_mark_list = build_tree_list (error_mark_node, error_mark_node); |
2983 | TREE_TYPE (error_mark_list) = error_mark_node; | |
2984 | ||
0270ae90 | 2985 | /* Create the `std' namespace. */ |
eaf45f93 | 2986 | push_namespace (std_identifier); |
2987 | std_node = current_namespace; | |
2988 | pop_namespace (); | |
3c3beda6 | 2989 | |
174fcc61 | 2990 | c_common_nodes_and_builtins (); |
c4a8ac95 | 2991 | |
84ea6a1d | 2992 | java_byte_type_node = record_builtin_java_type ("__java_byte", 8); |
2993 | java_short_type_node = record_builtin_java_type ("__java_short", 16); | |
2994 | java_int_type_node = record_builtin_java_type ("__java_int", 32); | |
2995 | java_long_type_node = record_builtin_java_type ("__java_long", 64); | |
2996 | java_float_type_node = record_builtin_java_type ("__java_float", -32); | |
2997 | java_double_type_node = record_builtin_java_type ("__java_double", -64); | |
2998 | java_char_type_node = record_builtin_java_type ("__java_char", -16); | |
2999 | java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1); | |
7d53e30d | 3000 | |
7016c612 | 3001 | integer_two_node = build_int_cst (NULL_TREE, 2); |
3002 | integer_three_node = build_int_cst (NULL_TREE, 3); | |
471086d6 | 3003 | |
ca2be8b5 | 3004 | record_builtin_type (RID_BOOL, "bool", boolean_type_node); |
3c2239cf | 3005 | truthvalue_type_node = boolean_type_node; |
3006 | truthvalue_false_node = boolean_false_node; | |
3007 | truthvalue_true_node = boolean_true_node; | |
bb0726a1 | 3008 | |
316b7a44 | 3009 | empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE); |
6bf5ed8d | 3010 | |
3011 | #if 0 | |
4d698345 | 3012 | record_builtin_type (RID_MAX, NULL, string_type_node); |
6bf5ed8d | 3013 | #endif |
3014 | ||
606b494c | 3015 | delta_type_node = ptrdiff_type_node; |
3016 | vtable_index_type = ptrdiff_type_node; | |
63a6a423 | 3017 | |
0ce25b06 | 3018 | vtt_parm_type = build_pointer_type (const_ptr_type_node); |
d2d4bdde | 3019 | void_ftype = build_function_type (void_type_node, void_list_node); |
3020 | void_ftype_ptr = build_function_type (void_type_node, | |
3021 | tree_cons (NULL_TREE, | |
491e04ef | 3022 | ptr_type_node, |
d2d4bdde | 3023 | void_list_node)); |
02d7f858 | 3024 | void_ftype_ptr |
316b7a44 | 3025 | = build_exception_variant (void_ftype_ptr, empty_except_spec); |
471086d6 | 3026 | |
471086d6 | 3027 | /* C++ extensions */ |
3028 | ||
3029 | unknown_type_node = make_node (UNKNOWN_TYPE); | |
2100d3e8 | 3030 | record_unknown_type (unknown_type_node, "unknown type"); |
3031 | ||
471086d6 | 3032 | /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */ |
3033 | TREE_TYPE (unknown_type_node) = unknown_type_node; | |
c4d89d79 | 3034 | |
c4d89d79 | 3035 | /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same |
3036 | result. */ | |
471086d6 | 3037 | TYPE_POINTER_TO (unknown_type_node) = unknown_type_node; |
3038 | TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node; | |
3039 | ||
dc9b5a48 | 3040 | { |
3041 | /* Make sure we get a unique function type, so we can give | |
3042 | its pointer type a name. (This wins for gdb.) */ | |
3043 | tree vfunc_type = make_node (FUNCTION_TYPE); | |
3044 | TREE_TYPE (vfunc_type) = integer_type_node; | |
3045 | TYPE_ARG_TYPES (vfunc_type) = NULL_TREE; | |
3046 | layout_type (vfunc_type); | |
3047 | ||
3048 | vtable_entry_type = build_pointer_type (vfunc_type); | |
3049 | } | |
518796ad | 3050 | record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type); |
471086d6 | 3051 | |
471086d6 | 3052 | vtbl_type_node |
457b74c8 | 3053 | = build_cplus_array_type (vtable_entry_type, NULL_TREE); |
471086d6 | 3054 | layout_type (vtbl_type_node); |
3e04bd45 | 3055 | vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST); |
4d698345 | 3056 | record_builtin_type (RID_MAX, NULL, vtbl_type_node); |
8ec060ec | 3057 | vtbl_ptr_type_node = build_pointer_type (vtable_entry_type); |
3058 | layout_type (vtbl_ptr_type_node); | |
4d698345 | 3059 | record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node); |
471086d6 | 3060 | |
606b494c | 3061 | push_namespace (get_identifier ("__cxxabiv1")); |
3062 | abi_node = current_namespace; | |
3063 | pop_namespace (); | |
6686e84d | 3064 | |
8417823c | 3065 | global_type_node = make_node (LANG_TYPE); |
2100d3e8 | 3066 | record_unknown_type (global_type_node, "global type"); |
8417823c | 3067 | |
c25194fd | 3068 | /* Now, C++. */ |
3069 | current_lang_name = lang_name_cplusplus; | |
471086d6 | 3070 | |
4b7a79e2 | 3071 | { |
b7d1e8ea | 3072 | tree bad_alloc_id; |
3073 | tree bad_alloc_type_node; | |
3074 | tree bad_alloc_decl; | |
3075 | tree newtype, deltype; | |
d2d4bdde | 3076 | tree ptr_ftype_sizetype; |
3077 | ||
eaf45f93 | 3078 | push_namespace (std_identifier); |
b7d1e8ea | 3079 | bad_alloc_id = get_identifier ("bad_alloc"); |
3080 | bad_alloc_type_node = make_aggr_type (RECORD_TYPE); | |
3081 | TYPE_CONTEXT (bad_alloc_type_node) = current_namespace; | |
491e04ef | 3082 | bad_alloc_decl |
b7d1e8ea | 3083 | = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node); |
3084 | DECL_CONTEXT (bad_alloc_decl) = current_namespace; | |
3085 | TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl; | |
eaf45f93 | 3086 | pop_namespace (); |
491e04ef | 3087 | |
3088 | ptr_ftype_sizetype | |
d2d4bdde | 3089 | = build_function_type (ptr_type_node, |
3090 | tree_cons (NULL_TREE, | |
654ef926 | 3091 | size_type_node, |
d2d4bdde | 3092 | void_list_node)); |
8417823c | 3093 | newtype = build_exception_variant |
65b7f83f | 3094 | (ptr_ftype_sizetype, add_exception_specifier |
3095 | (NULL_TREE, bad_alloc_type_node, -1)); | |
316b7a44 | 3096 | deltype = build_exception_variant (void_ftype_ptr, empty_except_spec); |
97cc4539 | 3097 | push_cp_library_fn (NEW_EXPR, newtype); |
3098 | push_cp_library_fn (VEC_NEW_EXPR, newtype); | |
3099 | global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype); | |
3100 | push_cp_library_fn (VEC_DELETE_EXPR, deltype); | |
4b7a79e2 | 3101 | } |
471086d6 | 3102 | |
3103 | abort_fndecl | |
606b494c | 3104 | = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype); |
471086d6 | 3105 | |
471086d6 | 3106 | /* Perform other language dependent initializations. */ |
3107 | init_class_processing (); | |
1ca0e0c0 | 3108 | init_rtti_processing (); |
471086d6 | 3109 | |
596c0ae6 | 3110 | if (flag_exceptions) |
f96b25bb | 3111 | init_exception_processing (); |
63b1d638 | 3112 | |
d200dc92 | 3113 | if (! supports_one_only ()) |
3d4e092a | 3114 | flag_weak = 0; |
471086d6 | 3115 | |
9e5a737d | 3116 | make_fname_decl = cp_make_fname_decl; |
65b7f83f | 3117 | start_fname_decls (); |
471086d6 | 3118 | |
0dbd1c74 | 3119 | /* Show we use EH for cleanups. */ |
4ee9c684 | 3120 | if (flag_exceptions) |
3121 | using_eh_for_cleanups (); | |
fce73460 | 3122 | } |
3123 | ||
65b7f83f | 3124 | /* Generate an initializer for a function naming variable from |
4880ab99 | 3125 | NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is |
331bc0ad | 3126 | filled in with the type of the init. */ |
65b7f83f | 3127 | |
3128 | tree | |
4880ab99 | 3129 | cp_fname_init (const char* name, tree *type_p) |
65b7f83f | 3130 | { |
3131 | tree domain = NULL_TREE; | |
3132 | tree type; | |
3133 | tree init = NULL_TREE; | |
3134 | size_t length = 0; | |
3135 | ||
3136 | if (name) | |
3137 | { | |
3138 | length = strlen (name); | |
3139 | domain = build_index_type (size_int (length)); | |
3140 | init = build_string (length + 1, name); | |
3141 | } | |
491e04ef | 3142 | |
65b7f83f | 3143 | type = build_qualified_type (char_type_node, TYPE_QUAL_CONST); |
3144 | type = build_cplus_array_type (type, domain); | |
3145 | ||
4880ab99 | 3146 | *type_p = type; |
491e04ef | 3147 | |
65b7f83f | 3148 | if (init) |
3149 | TREE_TYPE (init) = type; | |
3150 | else | |
4880ab99 | 3151 | init = error_mark_node; |
491e04ef | 3152 | |
65b7f83f | 3153 | return init; |
3154 | } | |
3155 | ||
9e5a737d | 3156 | /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the |
3157 | decl, NAME is the initialization string and TYPE_DEP indicates whether | |
3158 | NAME depended on the type of the function. We make use of that to detect | |
65b7f83f | 3159 | __PRETTY_FUNCTION__ inside a template fn. This is being done |
f5f73833 | 3160 | lazily at the point of first use, so we mustn't push the decl now. */ |
9e5a737d | 3161 | |
3162 | static tree | |
1b72315d | 3163 | cp_make_fname_decl (tree id, int type_dep) |
9e5a737d | 3164 | { |
0d95286f | 3165 | const char *const name = (type_dep && processing_template_decl |
d148dc28 | 3166 | ? NULL : fname_as_string (type_dep)); |
4880ab99 | 3167 | tree type; |
3168 | tree init = cp_fname_init (name, &type); | |
3169 | tree decl = build_decl (VAR_DECL, id, type); | |
9e5a737d | 3170 | |
15c4b973 | 3171 | if (name) |
3172 | free ((char *) name); | |
3173 | ||
81010c97 | 3174 | /* As we're using pushdecl_with_scope, we must set the context. */ |
65b7f83f | 3175 | DECL_CONTEXT (decl) = current_function_decl; |
3176 | DECL_PRETTY_FUNCTION_P (decl) = type_dep; | |
491e04ef | 3177 | |
9e5a737d | 3178 | TREE_STATIC (decl) = 1; |
3179 | TREE_READONLY (decl) = 1; | |
9e5a737d | 3180 | DECL_ARTIFICIAL (decl) = 1; |
9e5a737d | 3181 | DECL_INITIAL (decl) = init; |
491e04ef | 3182 | |
65b7f83f | 3183 | TREE_USED (decl) = 1; |
3c3beda6 | 3184 | |
81010c97 | 3185 | if (current_function_decl) |
3186 | { | |
3187 | struct cp_binding_level *b = current_binding_level; | |
37b9a732 | 3188 | while (b->level_chain->kind != sk_function_parms) |
81010c97 | 3189 | b = b->level_chain; |
3190 | pushdecl_with_scope (decl, b); | |
2f24a61c | 3191 | cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING); |
d148dc28 | 3192 | } |
2f24a61c | 3193 | else |
3194 | pushdecl_top_level_and_finish (decl, init); | |
491e04ef | 3195 | |
9e5a737d | 3196 | return decl; |
3197 | } | |
3198 | ||
ae8cbbc8 | 3199 | /* Make a definition for a builtin function named NAME in the current |
3200 | namespace, whose data type is TYPE and whose context is CONTEXT. | |
3201 | TYPE should be a function type with argument types. | |
471086d6 | 3202 | |
d267eaf5 | 3203 | CLASS and CODE tell later passes how to compile calls to this function. |
3204 | See tree.h for possible values. | |
3205 | ||
3206 | If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME, | |
a06abcfb | 3207 | the name to be called if we can't opencode the function. |
3208 | If ATTRS is nonzero, use that for the function's attribute | |
3209 | list. */ | |
471086d6 | 3210 | |
ae8cbbc8 | 3211 | static tree |
1b72315d | 3212 | builtin_function_1 (const char* name, |
3213 | tree type, | |
3214 | tree context, | |
4dee9c0e | 3215 | enum built_in_function code, |
1b72315d | 3216 | enum built_in_class class, |
3217 | const char* libname, | |
3218 | tree attrs) | |
471086d6 | 3219 | { |
97cc4539 | 3220 | tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type); |
d267eaf5 | 3221 | DECL_BUILT_IN_CLASS (decl) = class; |
3222 | DECL_FUNCTION_CODE (decl) = code; | |
ae8cbbc8 | 3223 | DECL_CONTEXT (decl) = context; |
00dd2e9e | 3224 | |
0270ae90 | 3225 | pushdecl (decl); |
0270ae90 | 3226 | |
471086d6 | 3227 | /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME, |
3228 | we cannot change DECL_ASSEMBLER_NAME until we have installed this | |
3229 | function in the namespace. */ | |
d267eaf5 | 3230 | if (libname) |
7e64c604 | 3231 | SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname)); |
c324ed63 | 3232 | |
3233 | /* Warn if a function in the namespace for users | |
3234 | is used without an occasion to consider it declared. */ | |
3235 | if (name[0] != '_' || name[1] != '_') | |
3236 | DECL_ANTICIPATED (decl) = 1; | |
3237 | ||
7d3b509a | 3238 | /* Possibly apply some default attributes to this built-in function. */ |
a06abcfb | 3239 | if (attrs) |
3240 | decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN); | |
3241 | else | |
3242 | decl_attributes (&decl, NULL_TREE, 0); | |
7d3b509a | 3243 | |
471086d6 | 3244 | return decl; |
3245 | } | |
72040e7e | 3246 | |
ae8cbbc8 | 3247 | /* Entry point for the benefit of c_common_nodes_and_builtins. |
3248 | ||
755edffd | 3249 | Make a definition for a builtin function named NAME and whose data type |
ae8cbbc8 | 3250 | is TYPE. TYPE should be a function type with argument types. This |
3251 | function places the anticipated declaration in the global namespace | |
3252 | and additionally in the std namespace if appropriate. | |
3253 | ||
3254 | CLASS and CODE tell later passes how to compile calls to this function. | |
3255 | See tree.h for possible values. | |
3256 | ||
3257 | If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME, | |
a06abcfb | 3258 | the name to be called if we can't opencode the function. |
3259 | ||
3260 | If ATTRS is nonzero, use that for the function's attribute | |
3261 | list. */ | |
ae8cbbc8 | 3262 | |
3263 | tree | |
1b72315d | 3264 | builtin_function (const char* name, |
3265 | tree type, | |
3266 | int code, | |
4dee9c0e | 3267 | enum built_in_class cl, |
1b72315d | 3268 | const char* libname, |
3269 | tree attrs) | |
ae8cbbc8 | 3270 | { |
3271 | /* All builtins that don't begin with an '_' should additionally | |
3272 | go in the 'std' namespace. */ | |
3273 | if (name[0] != '_') | |
3274 | { | |
3275 | push_namespace (std_identifier); | |
4dee9c0e | 3276 | builtin_function_1 (name, type, std_node, code, cl, libname, attrs); |
ae8cbbc8 | 3277 | pop_namespace (); |
3278 | } | |
3279 | ||
a06abcfb | 3280 | return builtin_function_1 (name, type, NULL_TREE, code, |
4dee9c0e | 3281 | cl, libname, attrs); |
ae8cbbc8 | 3282 | } |
3283 | ||
d267eaf5 | 3284 | /* Generate a FUNCTION_DECL with the typical flags for a runtime library |
3285 | function. Not called directly. */ | |
3286 | ||
3287 | static tree | |
1b72315d | 3288 | build_library_fn_1 (tree name, enum tree_code operator_code, tree type) |
d267eaf5 | 3289 | { |
3290 | tree fn = build_lang_decl (FUNCTION_DECL, name, type); | |
3291 | DECL_EXTERNAL (fn) = 1; | |
3292 | TREE_PUBLIC (fn) = 1; | |
3293 | DECL_ARTIFICIAL (fn) = 1; | |
3294 | TREE_NOTHROW (fn) = 1; | |
97cc4539 | 3295 | SET_OVERLOADED_OPERATOR_CODE (fn, operator_code); |
4b1984f5 | 3296 | SET_DECL_LANGUAGE (fn, lang_c); |
91caa6ca | 3297 | /* Runtime library routines are, by definition, available in an |
3298 | external shared object. */ | |
3299 | DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT; | |
3300 | DECL_VISIBILITY_SPECIFIED (fn) = 1; | |
d267eaf5 | 3301 | return fn; |
3302 | } | |
c215939a | 3303 | |
d267eaf5 | 3304 | /* Returns the _DECL for a library function with C linkage. |
3305 | We assume that such functions never throw; if this is incorrect, | |
3306 | callers should unset TREE_NOTHROW. */ | |
c215939a | 3307 | |
72040e7e | 3308 | tree |
1b72315d | 3309 | build_library_fn (tree name, tree type) |
d267eaf5 | 3310 | { |
0e8e37b2 | 3311 | return build_library_fn_1 (name, ERROR_MARK, type); |
d267eaf5 | 3312 | } |
3313 | ||
3314 | /* Returns the _DECL for a library function with C++ linkage. */ | |
3315 | ||
97cc4539 | 3316 | static tree |
1b72315d | 3317 | build_cp_library_fn (tree name, enum tree_code operator_code, tree type) |
d267eaf5 | 3318 | { |
97cc4539 | 3319 | tree fn = build_library_fn_1 (name, operator_code, type); |
d267eaf5 | 3320 | TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type); |
c87435c8 | 3321 | DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace); |
4b1984f5 | 3322 | SET_DECL_LANGUAGE (fn, lang_cplusplus); |
d267eaf5 | 3323 | return fn; |
3324 | } | |
3325 | ||
3326 | /* Like build_library_fn, but takes a C string instead of an | |
3327 | IDENTIFIER_NODE. */ | |
3328 | ||
3329 | tree | |
1b72315d | 3330 | build_library_fn_ptr (const char* name, tree type) |
72040e7e | 3331 | { |
d267eaf5 | 3332 | return build_library_fn (get_identifier (name), type); |
3333 | } | |
3334 | ||
3335 | /* Like build_cp_library_fn, but takes a C string instead of an | |
3336 | IDENTIFIER_NODE. */ | |
3337 | ||
3338 | tree | |
1b72315d | 3339 | build_cp_library_fn_ptr (const char* name, tree type) |
d267eaf5 | 3340 | { |
97cc4539 | 3341 | return build_cp_library_fn (get_identifier (name), ERROR_MARK, type); |
d267eaf5 | 3342 | } |
3343 | ||
3344 | /* Like build_library_fn, but also pushes the function so that we will | |
3345 | be able to find it via IDENTIFIER_GLOBAL_VALUE. */ | |
3346 | ||
3347 | tree | |
1b72315d | 3348 | push_library_fn (tree name, tree type) |
d267eaf5 | 3349 | { |
3350 | tree fn = build_library_fn (name, type); | |
3351 | pushdecl_top_level (fn); | |
3352 | return fn; | |
3353 | } | |
3354 | ||
3355 | /* Like build_cp_library_fn, but also pushes the function so that it | |
3356 | will be found by normal lookup. */ | |
3357 | ||
97cc4539 | 3358 | static tree |
1b72315d | 3359 | push_cp_library_fn (enum tree_code operator_code, tree type) |
d267eaf5 | 3360 | { |
3c3beda6 | 3361 | tree fn = build_cp_library_fn (ansi_opname (operator_code), |
97cc4539 | 3362 | operator_code, |
3363 | type); | |
d267eaf5 | 3364 | pushdecl (fn); |
3365 | return fn; | |
3366 | } | |
3367 | ||
3368 | /* Like push_library_fn, but takes a TREE_LIST of parm types rather than | |
3369 | a FUNCTION_TYPE. */ | |
3370 | ||
3371 | tree | |
1b72315d | 3372 | push_void_library_fn (tree name, tree parmtypes) |
d267eaf5 | 3373 | { |
3374 | tree type = build_function_type (void_type_node, parmtypes); | |
3375 | return push_library_fn (name, type); | |
3376 | } | |
3377 | ||
93d6541c | 3378 | /* Like push_library_fn, but also note that this function throws |
d267eaf5 | 3379 | and does not return. Used for __throw_foo and the like. */ |
3380 | ||
3381 | tree | |
1b72315d | 3382 | push_throw_library_fn (tree name, tree type) |
d267eaf5 | 3383 | { |
93d6541c | 3384 | tree fn = push_library_fn (name, type); |
d267eaf5 | 3385 | TREE_THIS_VOLATILE (fn) = 1; |
3386 | TREE_NOTHROW (fn) = 0; | |
3387 | return fn; | |
72040e7e | 3388 | } |
471086d6 | 3389 | \f |
0f2952a1 | 3390 | /* When we call finish_struct for an anonymous union, we create |
3391 | default copy constructors and such. But, an anonymous union | |
3392 | shouldn't have such things; this function undoes the damage to the | |
3393 | anonymous union type T. | |
3394 | ||
3395 | (The reason that we create the synthesized methods is that we don't | |
3396 | distinguish `union { int i; }' from `typedef union { int i; } U'. | |
3397 | The first is an anonymous union; the second is just an ordinary | |
3398 | union type.) */ | |
3399 | ||
3400 | void | |
1b72315d | 3401 | fixup_anonymous_aggr (tree t) |
0f2952a1 | 3402 | { |
3403 | tree *q; | |
3404 | ||
331bc0ad | 3405 | /* Wipe out memory of synthesized methods. */ |
0f2952a1 | 3406 | TYPE_HAS_CONSTRUCTOR (t) = 0; |
3407 | TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0; | |
3408 | TYPE_HAS_INIT_REF (t) = 0; | |
3409 | TYPE_HAS_CONST_INIT_REF (t) = 0; | |
3410 | TYPE_HAS_ASSIGN_REF (t) = 0; | |
0f2952a1 | 3411 | TYPE_HAS_CONST_ASSIGN_REF (t) = 0; |
3412 | ||
3413 | /* Splice the implicitly generated functions out of the TYPE_METHODS | |
3414 | list. */ | |
3415 | q = &TYPE_METHODS (t); | |
3416 | while (*q) | |
3417 | { | |
3418 | if (DECL_ARTIFICIAL (*q)) | |
3419 | *q = TREE_CHAIN (*q); | |
3420 | else | |
3421 | q = &TREE_CHAIN (*q); | |
3422 | } | |
3423 | ||
657c76e1 | 3424 | /* ISO C++ 9.5.3. Anonymous unions may not have function members. */ |
0f2952a1 | 3425 | if (TYPE_METHODS (t)) |
9bc3739f | 3426 | error ("%Jan anonymous union cannot have function members", |
3427 | TYPE_MAIN_DECL (t)); | |
69821268 | 3428 | |
3429 | /* Anonymous aggregates cannot have fields with ctors, dtors or complex | |
3430 | assignment operators (because they cannot have these methods themselves). | |
3431 | For anonymous unions this is already checked because they are not allowed | |
3432 | in any union, otherwise we have to check it. */ | |
3433 | if (TREE_CODE (t) != UNION_TYPE) | |
3434 | { | |
3435 | tree field, type; | |
3436 | ||
3437 | for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field)) | |
3438 | if (TREE_CODE (field) == FIELD_DECL) | |
3439 | { | |
3440 | type = TREE_TYPE (field); | |
3441 | if (CLASS_TYPE_P (type)) | |
3442 | { | |
3443 | if (TYPE_NEEDS_CONSTRUCTING (type)) | |
3444 | cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate", | |
3445 | field); | |
3446 | if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) | |
3447 | cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate", | |
3448 | field); | |
3449 | if (TYPE_HAS_COMPLEX_ASSIGN_REF (type)) | |
3450 | cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate", | |
3451 | field); | |
3452 | } | |
3453 | } | |
3454 | } | |
0f2952a1 | 3455 | } |
3456 | ||
37b8b0d0 | 3457 | /* Make sure that a declaration with no declarator is well-formed, i.e. |
0a3b29ad | 3458 | just declares a tagged type or anonymous union. |
471086d6 | 3459 | |
0a3b29ad | 3460 | Returns the type declared; or NULL_TREE if none. */ |
471086d6 | 3461 | |
37b8b0d0 | 3462 | tree |
4b9b2871 | 3463 | check_tag_decl (cp_decl_specifier_seq *declspecs) |
471086d6 | 3464 | { |
4b9b2871 | 3465 | int saw_friend = declspecs->specs[(int)ds_friend] != 0; |
3466 | int saw_typedef = declspecs->specs[(int)ds_typedef] != 0; | |
0a3b29ad | 3467 | /* If a class, struct, or enum type is declared by the DECLSPECS |
3468 | (i.e, if a class-specifier, enum-specifier, or non-typename | |
3469 | elaborated-type-specifier appears in the DECLSPECS), | |
3470 | DECLARED_TYPE is set to the corresponding type. */ | |
3471 | tree declared_type = NULL_TREE; | |
3472 | bool error_p = false; | |
471086d6 | 3473 | |
4b9b2871 | 3474 | if (declspecs->multiple_types_p) |
37b8b0d0 | 3475 | error ("multiple types in one declaration"); |
4b9b2871 | 3476 | else if (declspecs->redefined_builtin_type) |
3477 | { | |
3478 | if (!in_system_header) | |
036dda9d | 3479 | pedwarn ("redeclaration of C++ built-in type %qT", |
4b9b2871 | 3480 | declspecs->redefined_builtin_type); |
3481 | return NULL_TREE; | |
3482 | } | |
48994391 | 3483 | |
4b9b2871 | 3484 | if (TYPE_P (declspecs->type) |
491e04ef | 3485 | && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE |
4b9b2871 | 3486 | && IS_AGGR_TYPE (declspecs->type)) |
3487 | || TREE_CODE (declspecs->type) == ENUMERAL_TYPE)) | |
3488 | declared_type = declspecs->type; | |
3489 | else if (declspecs->type == error_mark_node) | |
3490 | error_p = true; | |
0a3b29ad | 3491 | if (declared_type == NULL_TREE && ! saw_friend && !error_p) |
48994391 | 3492 | pedwarn ("declaration does not declare anything"); |
83c4eacf | 3493 | /* Check for an anonymous union. */ |
0a3b29ad | 3494 | else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type)) |
3495 | && TYPE_ANONYMOUS_P (declared_type)) | |
84b5d9d7 | 3496 | { |
a614c830 | 3497 | /* 7/3 In a simple-declaration, the optional init-declarator-list |
3498 | can be omitted only when declaring a class (clause 9) or | |
3499 | enumeration (7.2), that is, when the decl-specifier-seq contains | |
3500 | either a class-specifier, an elaborated-type-specifier with | |
3501 | a class-key (9.1), or an enum-specifier. In these cases and | |
3502 | whenever a class-specifier or enum-specifier is present in the | |
3503 | decl-specifier-seq, the identifiers in these specifiers are among | |
3504 | the names being declared by the declaration (as class-name, | |
3505 | enum-names, or enumerators, depending on the syntax). In such | |
3506 | cases, and except for the declaration of an unnamed bit-field (9.6), | |
3507 | the decl-specifier-seq shall introduce one or more names into the | |
3508 | program, or shall redeclare a name introduced by a previous | |
3509 | declaration. [Example: | |
3510 | enum { }; // ill-formed | |
3511 | typedef class { }; // ill-formed | |
3512 | --end example] */ | |
3513 | if (saw_typedef) | |
3514 | { | |
ebae5c09 | 3515 | error ("missing type-name in typedef-declaration"); |
a614c830 | 3516 | return NULL_TREE; |
3517 | } | |
84b5d9d7 | 3518 | /* Anonymous unions are objects, so they can have specifiers. */; |
0a3b29ad | 3519 | SET_ANON_AGGR_TYPE_P (declared_type); |
128e1d72 | 3520 | |
491e04ef | 3521 | if (TREE_CODE (declared_type) != UNION_TYPE && pedantic |
0a3b29ad | 3522 | && !in_system_header) |
128e1d72 | 3523 | pedwarn ("ISO C++ prohibits anonymous structs"); |
84b5d9d7 | 3524 | } |
3525 | ||
4b9b2871 | 3526 | else |
471086d6 | 3527 | { |
4b9b2871 | 3528 | if (declspecs->specs[(int)ds_inline] |
3529 | || declspecs->specs[(int)ds_virtual]) | |
491e04ef | 3530 | error ("`%s' can only be specified for functions", |
3531 | declspecs->specs[(int)ds_inline] | |
4b9b2871 | 3532 | ? "inline" : "virtual"); |
3533 | else if (saw_friend | |
491e04ef | 3534 | && (!current_class_type |
4b9b2871 | 3535 | || current_scope () != current_class_type)) |
3536 | error ("`friend' can only be specified inside a class"); | |
3537 | else if (declspecs->specs[(int)ds_explicit]) | |
3538 | error ("`explicit' can only be specified for constructors"); | |
3539 | else if (declspecs->storage_class) | |
3540 | error ("a storage class can only be specified for objects " | |
3541 | "and functions"); | |
3542 | else if (declspecs->specs[(int)ds_const] | |
3543 | || declspecs->specs[(int)ds_volatile] | |
3544 | || declspecs->specs[(int)ds_restrict] | |
3545 | || declspecs->specs[(int)ds_thread]) | |
3546 | error ("qualifiers can only be specified for objects " | |
3547 | "and functions"); | |
37b8b0d0 | 3548 | } |
471086d6 | 3549 | |
0a3b29ad | 3550 | return declared_type; |
37b8b0d0 | 3551 | } |
3552 | ||
3553 | /* Called when a declaration is seen that contains no names to declare. | |
3554 | If its type is a reference to a structure, union or enum inherited | |
3555 | from a containing scope, shadow that tag name for the current scope | |
3556 | with a forward reference. | |
3557 | If its type defines a new named structure or union | |
3558 | or defines an enum, it is valid but we need not do anything here. | |
3559 | Otherwise, it is an error. | |
3560 | ||
3561 | C++: may have to grok the declspecs to learn about static, | |
491e04ef | 3562 | complain for anonymous unions. |
37b8b0d0 | 3563 | |
0a3b29ad | 3564 | Returns the TYPE declared -- or NULL_TREE if none. */ |
3565 | ||
3566 | tree | |
4b9b2871 | 3567 | shadow_tag (cp_decl_specifier_seq *declspecs) |
37b8b0d0 | 3568 | { |
3569 | tree t = check_tag_decl (declspecs); | |
3570 | ||
0a3b29ad | 3571 | if (!t) |
3572 | return NULL_TREE; | |
3573 | ||
3574 | maybe_process_partial_specialization (t); | |
37b8b0d0 | 3575 | |
3576 | /* This is where the variables in an anonymous union are | |
3577 | declared. An anonymous union declaration looks like: | |
3578 | union { ... } ; | |
3579 | because there is no declarator after the union, the parser | |
3580 | sends that declaration here. */ | |
0a3b29ad | 3581 | if (ANON_AGGR_TYPE_P (t)) |
37b8b0d0 | 3582 | { |
128e1d72 | 3583 | fixup_anonymous_aggr (t); |
37b8b0d0 | 3584 | |
3585 | if (TYPE_FIELDS (t)) | |
3586 | { | |
491e04ef | 3587 | tree decl = grokdeclarator (/*declarator=*/NULL, |
3046c0a3 | 3588 | declspecs, NORMAL, 0, NULL); |
37b8b0d0 | 3589 | finish_anon_union (decl); |
3590 | } | |
471086d6 | 3591 | } |
0a3b29ad | 3592 | |
3593 | return t; | |
471086d6 | 3594 | } |
3595 | \f | |
3596 | /* Decode a "typename", such as "int **", returning a ..._TYPE node. */ | |
3597 | ||
3598 | tree | |
491e04ef | 3599 | groktypename (cp_decl_specifier_seq *type_specifiers, |
4b9b2871 | 3600 | const cp_declarator *declarator) |
471086d6 | 3601 | { |
4b9b2871 | 3602 | tree attrs; |
bf2bc322 | 3603 | tree type; |
4b9b2871 | 3604 | attrs = type_specifiers->attributes; |
3605 | type_specifiers->attributes = NULL_TREE; | |
3606 | type = grokdeclarator (declarator, type_specifiers, TYPENAME, 0, &attrs); | |
bf2bc322 | 3607 | if (attrs) |
3608 | cplus_decl_attributes (&type, attrs, 0); | |
3609 | return type; | |
471086d6 | 3610 | } |
3611 | ||
3612 | /* Decode a declarator in an ordinary declaration or data definition. | |
3613 | This is called as soon as the type information and variable name | |
3614 | have been parsed, before parsing the initializer if any. | |
3615 | Here we create the ..._DECL node, fill in its type, | |
3616 | and put it on the list of decls for the current context. | |
3617 | The ..._DECL node is returned as the value. | |
3618 | ||
3619 | Exception: for arrays where the length is not specified, | |
e4118769 | 3620 | the type is left null, to be filled in by `cp_finish_decl'. |
471086d6 | 3621 | |
3622 | Function definitions do not come here; they go to start_function | |
3623 | instead. However, external and forward declarations of functions | |
3624 | do go through here. Structure field declarations are done by | |
3625 | grokfield and not through here. */ | |
3626 | ||
471086d6 | 3627 | tree |
491e04ef | 3628 | start_decl (const cp_declarator *declarator, |
4b9b2871 | 3629 | cp_decl_specifier_seq *declspecs, |
491e04ef | 3630 | int initialized, |
3631 | tree attributes, | |
91caa6ca | 3632 | tree prefix_attributes, |
3633 | bool *pop_scope_p) | |
471086d6 | 3634 | { |
9581e01c | 3635 | tree decl; |
cd16867a | 3636 | tree type, tem; |
471086d6 | 3637 | tree context; |
471086d6 | 3638 | |
96624a9e | 3639 | /* This should only be done once on the top most decl. */ |
92c38d80 | 3640 | if (have_extern_spec) |
471086d6 | 3641 | { |
4b9b2871 | 3642 | declspecs->storage_class = sc_extern; |
92c38d80 | 3643 | have_extern_spec = false; |
471086d6 | 3644 | } |
3645 | ||
88da234d | 3646 | /* An object declared as __attribute__((deprecated)) suppresses |
3647 | warnings of uses of other deprecated items. */ | |
3648 | if (lookup_attribute ("deprecated", attributes)) | |
3649 | deprecated_state = DEPRECATED_SUPPRESS; | |
3650 | ||
e3c541f0 | 3651 | attributes = chainon (attributes, prefix_attributes); |
d8f6e09c | 3652 | |
f9670f72 | 3653 | decl = grokdeclarator (declarator, declspecs, NORMAL, initialized, |
e3c541f0 | 3654 | &attributes); |
980877d7 | 3655 | |
88da234d | 3656 | deprecated_state = DEPRECATED_NORMAL; |
3657 | ||
f468434d | 3658 | if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE) |
471086d6 | 3659 | return NULL_TREE; |
3660 | ||
3661 | type = TREE_TYPE (decl); | |
3662 | ||
67b61957 | 3663 | if (type == error_mark_node) |
3664 | return NULL_TREE; | |
3665 | ||
9ba4048d | 3666 | context = DECL_CONTEXT (decl); |
471086d6 | 3667 | |
91caa6ca | 3668 | if (context) |
3669 | *pop_scope_p = push_scope (context); | |
3670 | else | |
3671 | *pop_scope_p = false; | |
3672 | ||
a109dc3b | 3673 | /* We are only interested in class contexts, later. */ |
8417823c | 3674 | if (context && TREE_CODE (context) == NAMESPACE_DECL) |
3675 | context = NULL_TREE; | |
3676 | ||
471086d6 | 3677 | if (initialized) |
3678 | /* Is it valid for this decl to have an initializer at all? | |
3679 | If not, set INITIALIZED to zero, which will indirectly | |
e4118769 | 3680 | tell `cp_finish_decl' to ignore the initializer once it is parsed. */ |
471086d6 | 3681 | switch (TREE_CODE (decl)) |
3682 | { | |
3683 | case TYPE_DECL: | |
bffbea28 | 3684 | error ("typedef `%D' is initialized (use __typeof__ instead)", decl); |
f6f89f14 | 3685 | initialized = 0; |
471086d6 | 3686 | break; |
3687 | ||
3688 | case FUNCTION_DECL: | |
cf103c6c | 3689 | error ("function `%#D' is initialized like a variable", decl); |
471086d6 | 3690 | initialized = 0; |
3691 | break; | |
3692 | ||
3693 | default: | |
4a7414ab | 3694 | break; |
471086d6 | 3695 | } |
3696 | ||
471086d6 | 3697 | if (initialized) |
3698 | { | |
d0622bdf | 3699 | if (! toplevel_bindings_p () |
471086d6 | 3700 | && DECL_EXTERNAL (decl)) |
cf103c6c | 3701 | warning ("declaration of `%#D' has `extern' and is initialized", |
471086d6 | 3702 | decl); |
3703 | DECL_EXTERNAL (decl) = 0; | |
e857e9c7 | 3704 | if (toplevel_bindings_p ()) |
471086d6 | 3705 | TREE_STATIC (decl) = 1; |
3706 | ||
3707 | /* Tell `pushdecl' this is an initialized decl | |
3708 | even though we don't yet have the initializer expression. | |
e4118769 | 3709 | Also tell `cp_finish_decl' it may store the real initializer. */ |
471086d6 | 3710 | DECL_INITIAL (decl) = error_mark_node; |
3711 | } | |
3712 | ||
9f45906c | 3713 | /* Set attributes here so if duplicate decl, will have proper attributes. */ |
e3c541f0 | 3714 | cplus_decl_attributes (&decl, attributes, 0); |
9f45906c | 3715 | |
5626f4cd | 3716 | /* If #pragma weak was used, mark the decl weak now. */ |
ddeeea02 | 3717 | if (global_scope_p (current_binding_level)) |
5626f4cd | 3718 | maybe_apply_pragma_weak (decl); |
3719 | ||
5955c361 | 3720 | if (TREE_CODE (decl) == FUNCTION_DECL |
3721 | && DECL_DECLARED_INLINE_P (decl) | |
3722 | && DECL_UNINLINABLE (decl) | |
3723 | && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl))) | |
9bc3739f | 3724 | warning ("%Jinline function '%D' given attribute noinline", decl, decl); |
5955c361 | 3725 | |
4b72716d | 3726 | if (context && COMPLETE_TYPE_P (complete_type (context))) |
822f06da | 3727 | { |
3728 | if (TREE_CODE (decl) == VAR_DECL) | |
3729 | { | |
b330805e | 3730 | tree field = lookup_field (context, DECL_NAME (decl), 0, false); |
822f06da | 3731 | if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL) |
cf103c6c | 3732 | error ("`%#D' is not a static member of `%#T'", decl, context); |
1ad432f2 | 3733 | else |
3734 | { | |
3735 | if (DECL_CONTEXT (field) != context) | |
3d2dcf3a | 3736 | { |
0a3b29ad | 3737 | if (!same_type_p (DECL_CONTEXT (field), context)) |
3738 | pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'", | |
3739 | DECL_CONTEXT (field), DECL_NAME (decl), | |
3740 | context, DECL_NAME (decl)); | |
3d2dcf3a | 3741 | DECL_CONTEXT (decl) = DECL_CONTEXT (field); |
3742 | } | |
668ae905 | 3743 | /* Static data member are tricky; an in-class initialization |
3744 | still doesn't provide a definition, so the in-class | |
3745 | declaration will have DECL_EXTERNAL set, but will have an | |
3746 | initialization. Thus, duplicate_decls won't warn | |
3747 | about this situation, and so we check here. */ | |
3748 | if (DECL_INITIAL (decl) && DECL_INITIAL (field)) | |
cf103c6c | 3749 | error ("duplicate initialization of %D", decl); |
1ad432f2 | 3750 | if (duplicate_decls (decl, field)) |
3751 | decl = field; | |
3752 | } | |
822f06da | 3753 | } |
ce28ee2e | 3754 | else |
3755 | { | |
7bdfc61c | 3756 | tree field = check_classfn (context, decl, |
0122f52b | 3757 | (processing_template_decl |
3758 | > template_class_depth (context)) | |
3759 | ? current_template_parms | |
3760 | : NULL_TREE); | |
ce28ee2e | 3761 | if (field && duplicate_decls (decl, field)) |
3762 | decl = field; | |
3763 | } | |
3764 | ||
3765 | /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */ | |
8a5e9d02 | 3766 | DECL_IN_AGGR_P (decl) = 0; |
980877d7 | 3767 | if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl)) |
98eaf693 | 3768 | || CLASSTYPE_TEMPLATE_INSTANTIATION (context)) |
2ad9569d | 3769 | { |
3770 | SET_DECL_TEMPLATE_SPECIALIZATION (decl); | |
3771 | /* [temp.expl.spec] An explicit specialization of a static data | |
3772 | member of a template is a definition if the declaration | |
3773 | includes an initializer; otherwise, it is a declaration. | |
3774 | ||
3775 | We check for processing_specialization so this only applies | |
3776 | to the new specialization syntax. */ | |
3777 | if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization) | |
3778 | DECL_EXTERNAL (decl) = 1; | |
3779 | } | |
ce28ee2e | 3780 | |
ef5a592c | 3781 | if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl)) |
cf103c6c | 3782 | pedwarn ("declaration of `%#D' outside of class is not definition", |
ce28ee2e | 3783 | decl); |
822f06da | 3784 | } |
3785 | ||
70a658bd | 3786 | /* Enter this declaration into the symbol table. */ |
3787 | tem = maybe_push_decl (decl); | |
de9554eb | 3788 | |
3cc0b4b9 | 3789 | if (processing_template_decl) |
ce23987e | 3790 | tem = push_template_decl (tem); |
3cbf947d | 3791 | if (tem == error_mark_node) |
3792 | return error_mark_node; | |
e857e9c7 | 3793 | |
de9554eb | 3794 | #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS) |
ad91f3ed | 3795 | /* Tell the back-end to use or not use .common as appropriate. If we say |
4c4e55a3 | 3796 | -fconserve-space, we want this to save .data space, at the expense of |
3797 | wrong semantics. If we say -fno-conserve-space, we want this to | |
3798 | produce errors about redefs; to do this we force variables into the | |
3799 | data segment. */ | |
d6981147 | 3800 | DECL_COMMON (tem) = ((TREE_CODE (tem) != VAR_DECL |
3801 | || !DECL_THREAD_LOCAL (tem)) | |
2555ff80 | 3802 | && (flag_conserve_space || ! TREE_PUBLIC (tem))); |
de9554eb | 3803 | #endif |
980877d7 | 3804 | |
3cc0b4b9 | 3805 | if (! processing_template_decl) |
e857e9c7 | 3806 | start_decl_1 (tem); |
471086d6 | 3807 | |
471086d6 | 3808 | return tem; |
3809 | } | |
3810 | ||
e857e9c7 | 3811 | void |
1b72315d | 3812 | start_decl_1 (tree decl) |
471086d6 | 3813 | { |
e857e9c7 | 3814 | tree type = TREE_TYPE (decl); |
3815 | int initialized = (DECL_INITIAL (decl) != NULL_TREE); | |
471086d6 | 3816 | |
67b61957 | 3817 | if (type == error_mark_node) |
3818 | return; | |
3819 | ||
e857e9c7 | 3820 | if (initialized) |
3821 | /* Is it valid for this decl to have an initializer at all? | |
3822 | If not, set INITIALIZED to zero, which will indirectly | |
3823 | tell `cp_finish_decl' to ignore the initializer once it is parsed. */ | |
471086d6 | 3824 | { |
e857e9c7 | 3825 | /* Don't allow initializations for incomplete types except for |
3826 | arrays which might be completed by the initialization. */ | |
4b72716d | 3827 | if (COMPLETE_TYPE_P (complete_type (type))) |
e857e9c7 | 3828 | ; /* A complete type is ok. */ |
3829 | else if (TREE_CODE (type) != ARRAY_TYPE) | |
471086d6 | 3830 | { |
cf103c6c | 3831 | error ("variable `%#D' has initializer but incomplete type", |
e857e9c7 | 3832 | decl); |
3833 | initialized = 0; | |
3aa622aa | 3834 | type = TREE_TYPE (decl) = error_mark_node; |
e857e9c7 | 3835 | } |
4b72716d | 3836 | else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type)))) |
e857e9c7 | 3837 | { |
3838 | if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)) | |
cf103c6c | 3839 | error ("elements of array `%#D' have incomplete type", decl); |
e857e9c7 | 3840 | /* else we already gave an error in start_decl. */ |
3841 | initialized = 0; | |
471086d6 | 3842 | } |
471086d6 | 3843 | } |
3844 | ||
e857e9c7 | 3845 | if (!initialized |
3846 | && TREE_CODE (decl) != TYPE_DECL | |
3847 | && TREE_CODE (decl) != TEMPLATE_DECL | |
3d411d73 | 3848 | && type != error_mark_node |
3c3beda6 | 3849 | && IS_AGGR_TYPE (type) |
3d411d73 | 3850 | && ! DECL_EXTERNAL (decl)) |
471086d6 | 3851 | { |
3cc0b4b9 | 3852 | if ((! processing_template_decl || ! uses_template_parms (type)) |
4b72716d | 3853 | && !COMPLETE_TYPE_P (complete_type (type))) |
e857e9c7 | 3854 | { |
242fc35c | 3855 | error ("aggregate `%#D' has incomplete type and cannot be defined", |
e857e9c7 | 3856 | decl); |
3857 | /* Change the type so that assemble_variable will give | |
3858 | DECL an rtl we can live with: (mem (const_int 0)). */ | |
3aa622aa | 3859 | type = TREE_TYPE (decl) = error_mark_node; |
e857e9c7 | 3860 | } |
3861 | else | |
3862 | { | |
3863 | /* If any base type in the hierarchy of TYPE needs a constructor, | |
3864 | then we set initialized to 1. This way any nodes which are | |
3865 | created for the purposes of initializing this aggregate | |
3866 | will live as long as it does. This is necessary for global | |
3867 | aggregates which do not have their initializers processed until | |
3868 | the end of the file. */ | |
3869 | initialized = TYPE_NEEDS_CONSTRUCTING (type); | |
3870 | } | |
3871 | } | |
3872 | ||
e857e9c7 | 3873 | if (! initialized) |
3874 | DECL_INITIAL (decl) = NULL_TREE; | |
6f46e702 | 3875 | |
3876 | /* Create a new scope to hold this declaration if necessary. | |
3877 | Whether or not a new scope is necessary cannot be determined | |
3878 | until after the type has been completed; if the type is a | |
3879 | specialization of a class template it is not until after | |
3880 | instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR | |
3881 | will be set correctly. */ | |
3882 | maybe_push_cleanup_level (type); | |
e857e9c7 | 3883 | } |
3884 | ||
d7d79557 | 3885 | /* Handle initialization of references. DECL, TYPE, and INIT have the |
3886 | same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry, | |
3887 | but will be set to a new CLEANUP_STMT if a temporary is created | |
63eff20d | 3888 | that must be destroyed subsequently. |
d7d79557 | 3889 | |
3890 | Returns an initializer expression to use to initialize DECL, or | |
3891 | NULL if the initialization can be performed statically. | |
96624a9e | 3892 | |
3893 | Quotes on semantics can be found in ARM 8.4.3. */ | |
3894 | ||
e6393a02 | 3895 | static tree |
d7d79557 | 3896 | grok_reference_init (tree decl, tree type, tree init, tree *cleanup) |
e857e9c7 | 3897 | { |
3898 | tree tmp; | |
3899 | ||
3900 | if (init == NULL_TREE) | |
3901 | { | |
3902 | if ((DECL_LANG_SPECIFIC (decl) == 0 | |
3903 | || DECL_IN_AGGR_P (decl) == 0) | |
3904 | && ! DECL_THIS_EXTERN (decl)) | |
cf103c6c | 3905 | error ("`%D' declared as reference but not initialized", decl); |
e6393a02 | 3906 | return NULL_TREE; |
e857e9c7 | 3907 | } |
3908 | ||
18a4cb16 | 3909 | if (TREE_CODE (init) == CONSTRUCTOR) |
e857e9c7 | 3910 | { |
cf103c6c | 3911 | error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl); |
e6393a02 | 3912 | return NULL_TREE; |
471086d6 | 3913 | } |
3914 | ||
3915 | if (TREE_CODE (init) == TREE_LIST) | |
8a4008da | 3916 | init = build_x_compound_expr_from_list (init, "initializer"); |
471086d6 | 3917 | |
1a3f833b | 3918 | if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE) |
3919 | init = convert_from_reference (init); | |
3920 | ||
471086d6 | 3921 | if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE |
3922 | && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE) | |
a681799d | 3923 | /* Note: default conversion is only called in very special cases. */ |
3924 | init = decay_conversion (init); | |
980877d7 | 3925 | |
2243fa67 | 3926 | /* Convert INIT to the reference type TYPE. This may involve the |
3927 | creation of a temporary, whose lifetime must be the same as that | |
7dd37241 | 3928 | of the reference. If so, a DECL_EXPR for the temporary will be |
3929 | added just after the DECL_EXPR for DECL. That's why we don't set | |
2243fa67 | 3930 | DECL_INITIAL for local references (instead assigning to them |
3931 | explicitly); we need to allow the temporary to be initialized | |
3932 | first. */ | |
d7d79557 | 3933 | tmp = initialize_reference (type, init, decl, cleanup); |
471086d6 | 3934 | |
ad91f3ed | 3935 | if (tmp == error_mark_node) |
e6393a02 | 3936 | return NULL_TREE; |
3937 | else if (tmp == NULL_TREE) | |
471086d6 | 3938 | { |
cf103c6c | 3939 | error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init)); |
e6393a02 | 3940 | return NULL_TREE; |
471086d6 | 3941 | } |
471086d6 | 3942 | |
e6393a02 | 3943 | if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp)) |
3944 | return tmp; | |
3945 | ||
ca106ab1 | 3946 | DECL_INITIAL (decl) = tmp; |
e6393a02 | 3947 | |
3948 | return NULL_TREE; | |
471086d6 | 3949 | } |
3950 | ||
ece7bde7 | 3951 | /* When parsing `int a[] = {1, 2};' we don't know the size of the |
3952 | array until we finish parsing the initializer. If that's the | |
3953 | situation we're in, update DECL accordingly. */ | |
3954 | ||
3955 | static void | |
1b72315d | 3956 | maybe_deduce_size_from_array_init (tree decl, tree init) |
ece7bde7 | 3957 | { |
3958 | tree type = TREE_TYPE (decl); | |
3959 | ||
3960 | if (TREE_CODE (type) == ARRAY_TYPE | |
3961 | && TYPE_DOMAIN (type) == NULL_TREE | |
3962 | && TREE_CODE (decl) != TYPE_DECL) | |
3963 | { | |
cb4cc35f | 3964 | /* do_default is really a C-ism to deal with tentative definitions. |
3965 | But let's leave it here to ease the eventual merge. */ | |
3966 | int do_default = !DECL_EXTERNAL (decl); | |
ece7bde7 | 3967 | tree initializer = init ? init : DECL_INITIAL (decl); |
3968 | int failure = complete_array_type (type, initializer, do_default); | |
3969 | ||
3970 | if (failure == 1) | |
cf103c6c | 3971 | error ("initializer fails to determine size of `%D'", decl); |
ece7bde7 | 3972 | |
3973 | if (failure == 2) | |
3974 | { | |
3975 | if (do_default) | |
cf103c6c | 3976 | error ("array size missing in `%D'", decl); |
ece7bde7 | 3977 | /* If a `static' var's size isn't known, make it extern as |
3978 | well as static, so it does not get allocated. If it's not | |
3979 | `static', then don't mark it extern; finish_incomplete_decl | |
3980 | will give it a default size and it will get allocated. */ | |
3981 | else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl)) | |
3982 | DECL_EXTERNAL (decl) = 1; | |
3983 | } | |
3984 | ||
3985 | if (pedantic && TYPE_DOMAIN (type) != NULL_TREE | |
3986 | && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), | |
3987 | integer_zero_node)) | |
cf103c6c | 3988 | error ("zero-size array `%D'", decl); |
ece7bde7 | 3989 | |
3990 | layout_decl (decl, 0); | |
3991 | } | |
3992 | } | |
3993 | ||
3994 | /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue | |
73b8a26b | 3995 | any appropriate error messages regarding the layout. */ |
ece7bde7 | 3996 | |
73b8a26b | 3997 | static void |
1b72315d | 3998 | layout_var_decl (tree decl) |
ece7bde7 | 3999 | { |
73b8a26b | 4000 | tree type = TREE_TYPE (decl); |
949d8cc7 | 4001 | #if 0 |
73b8a26b | 4002 | tree ttype = target_type (type); |
949d8cc7 | 4003 | #endif |
73b8a26b | 4004 | |
4005 | /* If we haven't already layed out this declaration, do so now. | |
4006 | Note that we must not call complete type for an external object | |
4007 | because it's type might involve templates that we are not | |
755edffd | 4008 | supposed to instantiate yet. (And it's perfectly valid to say |
73b8a26b | 4009 | `extern X x' for some incomplete type `X'.) */ |
4010 | if (!DECL_EXTERNAL (decl)) | |
4011 | complete_type (type); | |
491e04ef | 4012 | if (!DECL_SIZE (decl) |
2c73aca0 | 4013 | && TREE_TYPE (decl) != error_mark_node |
15a7c339 | 4014 | && (COMPLETE_TYPE_P (type) |
491e04ef | 4015 | || (TREE_CODE (type) == ARRAY_TYPE |
15a7c339 | 4016 | && !TYPE_DOMAIN (type) |
4017 | && COMPLETE_TYPE_P (TREE_TYPE (type))))) | |
ece7bde7 | 4018 | layout_decl (decl, 0); |
4019 | ||
9f9b1983 | 4020 | if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE) |
ece7bde7 | 4021 | { |
4022 | /* An automatic variable with an incomplete type: that is an error. | |
4023 | Don't talk about array types here, since we took care of that | |
4024 | message in grokdeclarator. */ | |
cf103c6c | 4025 | error ("storage size of `%D' isn't known", decl); |
ece7bde7 | 4026 | TREE_TYPE (decl) = error_mark_node; |
4027 | } | |
b3908271 | 4028 | #if 0 |
4029 | /* Keep this code around in case we later want to control debug info | |
4030 | based on whether a type is "used". (jason 1999-11-11) */ | |
4031 | ||
ece7bde7 | 4032 | else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype)) |
4033 | /* Let debugger know it should output info for this type. */ | |
4034 | note_debug_info_needed (ttype); | |
4035 | ||
4036 | if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl)) | |
4037 | note_debug_info_needed (DECL_CONTEXT (decl)); | |
b3908271 | 4038 | #endif |
ece7bde7 | 4039 | |
4040 | if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl)) | |
4041 | && DECL_SIZE (decl) != NULL_TREE | |
4042 | && ! TREE_CONSTANT (DECL_SIZE (decl))) | |
4043 | { | |
4044 | if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST) | |
4045 | constant_expression_warning (DECL_SIZE (decl)); | |
4046 | else | |
cf103c6c | 4047 | error ("storage size of `%D' isn't constant", decl); |
ece7bde7 | 4048 | } |
e6393a02 | 4049 | |
4050 | if (TREE_STATIC (decl) | |
4051 | && !DECL_ARTIFICIAL (decl) | |
4052 | && current_function_decl | |
4053 | && DECL_CONTEXT (decl) == current_function_decl) | |
4054 | push_local_name (decl); | |
ece7bde7 | 4055 | } |
4056 | ||
ece7bde7 | 4057 | /* If a local static variable is declared in an inline function, or if |
4058 | we have a weak definition, we must endeavor to create only one | |
4059 | instance of the variable at link-time. */ | |
4060 | ||
4061 | static void | |
1b72315d | 4062 | maybe_commonize_var (tree decl) |
ece7bde7 | 4063 | { |
4064 | /* Static data in a function with comdat linkage also has comdat | |
4065 | linkage. */ | |
4066 | if (TREE_STATIC (decl) | |
4067 | /* Don't mess with __FUNCTION__. */ | |
93d6541c | 4068 | && ! DECL_ARTIFICIAL (decl) |
20b8c6bf | 4069 | && DECL_FUNCTION_SCOPE_P (decl) |
4070 | /* Unfortunately, import_export_decl has not always been called | |
4071 | before the function is processed, so we cannot simply check | |
491e04ef | 4072 | DECL_COMDAT. */ |
a70c1164 | 4073 | && (DECL_COMDAT (DECL_CONTEXT (decl)) |
20b8c6bf | 4074 | || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl)) |
4075 | || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl))) | |
4076 | && TREE_PUBLIC (DECL_CONTEXT (decl))))) | |
ece7bde7 | 4077 | { |
de496319 | 4078 | if (flag_weak) |
ece7bde7 | 4079 | { |
de496319 | 4080 | /* With weak symbols, we simply make the variable COMDAT; |
4081 | that will cause copies in multiple translations units to | |
4082 | be merged. */ | |
4083 | comdat_linkage (decl); | |
4084 | } | |
4085 | else | |
4086 | { | |
4087 | if (DECL_INITIAL (decl) == NULL_TREE | |
4088 | || DECL_INITIAL (decl) == error_mark_node) | |
ece7bde7 | 4089 | { |
de496319 | 4090 | /* Without weak symbols, we can use COMMON to merge |
4091 | uninitialized variables. */ | |
ece7bde7 | 4092 | TREE_PUBLIC (decl) = 1; |
4093 | DECL_COMMON (decl) = 1; | |
4094 | } | |
de496319 | 4095 | else |
ece7bde7 | 4096 | { |
de496319 | 4097 | /* While for initialized variables, we must use internal |
4098 | linkage -- which means that multiple copies will not | |
4099 | be merged. */ | |
4100 | TREE_PUBLIC (decl) = 0; | |
4101 | DECL_COMMON (decl) = 0; | |
ece7bde7 | 4102 | cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl); |
9bc3739f | 4103 | warning ("%J you can work around this by removing the initializer", |
4104 | decl); | |
ece7bde7 | 4105 | } |
4106 | } | |
4107 | } | |
4108 | else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl)) | |
4109 | /* Set it up again; we might have set DECL_INITIAL since the last | |
4110 | time. */ | |
4111 | comdat_linkage (decl); | |
4112 | } | |
4113 | ||
3e04bd45 | 4114 | /* Issue an error message if DECL is an uninitialized const variable. */ |
4115 | ||
4116 | static void | |
1b72315d | 4117 | check_for_uninitialized_const_var (tree decl) |
3e04bd45 | 4118 | { |
4119 | tree type = TREE_TYPE (decl); | |
4120 | ||
4121 | /* ``Unless explicitly declared extern, a const object does not have | |
4122 | external linkage and must be initialized. ($8.4; $12.1)'' ARM | |
4123 | 7.1.6 */ | |
4124 | if (TREE_CODE (decl) == VAR_DECL | |
4125 | && TREE_CODE (type) != REFERENCE_TYPE | |
4126 | && CP_TYPE_CONST_P (type) | |
4127 | && !TYPE_NEEDS_CONSTRUCTING (type) | |
4128 | && !DECL_INITIAL (decl)) | |
cf103c6c | 4129 | error ("uninitialized const `%D'", decl); |
3e04bd45 | 4130 | } |
4131 | ||
2437a99c | 4132 | /* FIELD is a FIELD_DECL or NULL. In the former case, the value |
4133 | returned is the next FIELD_DECL (possibly FIELD itself) that can be | |
4134 | initialized. If there are no more such fields, the return value | |
4135 | will be NULL. */ | |
4136 | ||
4137 | static tree | |
4138 | next_initializable_field (tree field) | |
4139 | { | |
4140 | while (field | |
4141 | && (TREE_CODE (field) != FIELD_DECL | |
4142 | || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field)) | |
4143 | || DECL_ARTIFICIAL (field))) | |
4144 | field = TREE_CHAIN (field); | |
4145 | ||
4146 | return field; | |
4147 | } | |
4148 | ||
4149 | /* Undo the brace-elision allowed by [dcl.init.aggr] in a | |
4150 | brace-enclosed aggregate initializer. | |
4151 | ||
4152 | *INITP is one of a list of initializers describing a brace-enclosed | |
4153 | initializer for an entity of the indicated aggregate TYPE. It may | |
4154 | not presently match the shape of the TYPE; for example: | |
491e04ef | 4155 | |
2437a99c | 4156 | struct S { int a; int b; }; |
4157 | struct S a[] = { 1, 2, 3, 4 }; | |
4158 | ||
4159 | Here *INITP will point to TREE_LIST of four elements, rather than a | |
4160 | list of two elements, each itself a list of two elements. This | |
4161 | routine transforms INIT from the former form into the latter. The | |
4162 | revised initializer is returned. */ | |
4163 | ||
4164 | static tree | |
4165 | reshape_init (tree type, tree *initp) | |
4166 | { | |
4167 | tree inits; | |
4168 | tree old_init; | |
4169 | tree old_init_value; | |
4170 | tree new_init; | |
4171 | bool brace_enclosed_p; | |
4172 | ||
4173 | old_init = *initp; | |
4174 | old_init_value = (TREE_CODE (*initp) == TREE_LIST | |
4175 | ? TREE_VALUE (*initp) : old_init); | |
4176 | ||
b4df430b | 4177 | gcc_assert (old_init_value); |
062e8fef | 4178 | |
2437a99c | 4179 | /* If the initializer is brace-enclosed, pull initializers from the |
4180 | enclosed elements. Advance past the brace-enclosed initializer | |
4181 | now. */ | |
5264d007 | 4182 | if (TREE_CODE (old_init_value) == CONSTRUCTOR |
e6517de8 | 4183 | && BRACE_ENCLOSED_INITIALIZER_P (old_init_value)) |
2437a99c | 4184 | { |
4185 | *initp = TREE_CHAIN (old_init); | |
4186 | TREE_CHAIN (old_init) = NULL_TREE; | |
4187 | inits = CONSTRUCTOR_ELTS (old_init_value); | |
4188 | initp = &inits; | |
4189 | brace_enclosed_p = true; | |
4190 | } | |
4191 | else | |
4192 | { | |
4193 | inits = NULL_TREE; | |
4194 | brace_enclosed_p = false; | |
4195 | } | |
4196 | ||
4197 | /* A non-aggregate type is always initialized with a single | |
4198 | initializer. */ | |
4199 | if (!CP_AGGREGATE_TYPE_P (type)) | |
4200 | { | |
4201 | *initp = TREE_CHAIN (old_init); | |
4202 | TREE_CHAIN (old_init) = NULL_TREE; | |
4203 | /* It is invalid to initialize a non-aggregate type with a | |
4204 | brace-enclosed initializer. */ | |
4205 | if (brace_enclosed_p) | |
4206 | { | |
4207 | error ("brace-enclosed initializer used to initialize `%T'", | |
4208 | type); | |
4209 | if (TREE_CODE (old_init) == TREE_LIST) | |
4210 | TREE_VALUE (old_init) = error_mark_node; | |
4211 | else | |
4212 | old_init = error_mark_node; | |
4213 | } | |
491e04ef | 4214 | |
2437a99c | 4215 | return old_init; |
4216 | } | |
4217 | ||
4218 | /* [dcl.init.aggr] | |
4219 | ||
4220 | All implicit type conversions (clause _conv_) are considered when | |
4221 | initializing the aggregate member with an initializer from an | |
4222 | initializer-list. If the initializer can initialize a member, | |
4223 | the member is initialized. Otherwise, if the member is itself a | |
4224 | non-empty subaggregate, brace elision is assumed and the | |
4225 | initializer is considered for the initialization of the first | |
4226 | member of the subaggregate. */ | |
5264d007 | 4227 | if (!brace_enclosed_p |
2437a99c | 4228 | && can_convert_arg (type, TREE_TYPE (old_init_value), old_init_value)) |
4229 | { | |
4230 | *initp = TREE_CHAIN (old_init); | |
4231 | TREE_CHAIN (old_init) = NULL_TREE; | |
4232 | return old_init; | |
4233 | } | |
4234 | ||
94302392 | 4235 | if (TREE_CODE (old_init_value) == STRING_CST |
2437a99c | 4236 | && TREE_CODE (type) == ARRAY_TYPE |
791f63f0 | 4237 | && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))) |
2437a99c | 4238 | { |
4239 | /* [dcl.init.string] | |
4240 | ||
4241 | A char array (whether plain char, signed char, or unsigned char) | |
4242 | can be initialized by a string-literal (optionally enclosed in | |
4243 | braces); a wchar_t array can be initialized by a wide | |
4244 | string-literal (optionally enclosed in braces). */ | |
4245 | new_init = old_init; | |
4246 | /* Move past the initializer. */ | |
4247 | *initp = TREE_CHAIN (old_init); | |
4248 | TREE_CHAIN (old_init) = NULL_TREE; | |
4249 | } | |
4250 | else | |
4251 | { | |
491e04ef | 4252 | /* Build a CONSTRUCTOR to hold the contents of the aggregate. */ |
e6517de8 | 4253 | new_init = build_constructor (NULL_TREE, NULL_TREE); |
2437a99c | 4254 | |
4255 | if (CLASS_TYPE_P (type)) | |
4256 | { | |
4257 | tree field; | |
4258 | ||
4259 | field = next_initializable_field (TYPE_FIELDS (type)); | |
4260 | ||
4261 | if (!field) | |
4262 | { | |
4263 | /* [dcl.init.aggr] | |
491e04ef | 4264 | |
2437a99c | 4265 | An initializer for an aggregate member that is an |
4266 | empty class shall have the form of an empty | |
4267 | initializer-list {}. */ | |
4268 | if (!brace_enclosed_p) | |
a6143adf | 4269 | { |
4270 | error ("initializer for `%T' must be brace-enclosed", | |
4271 | type); | |
4272 | return error_mark_node; | |
4273 | } | |
2437a99c | 4274 | } |
4275 | else | |
4276 | { | |
4277 | /* Loop through the initializable fields, gathering | |
4278 | initializers. */ | |
35e7b3ed | 4279 | while (*initp) |
2437a99c | 4280 | { |
4281 | tree field_init; | |
4282 | ||
35e7b3ed | 4283 | /* Handle designated initializers, as an extension. */ |
4284 | if (TREE_PURPOSE (*initp)) | |
4285 | { | |
4286 | if (pedantic) | |
4287 | pedwarn ("ISO C++ does not allow designated initializers"); | |
4288 | field = lookup_field_1 (type, TREE_PURPOSE (*initp), | |
4289 | /*want_type=*/false); | |
4290 | if (!field || TREE_CODE (field) != FIELD_DECL) | |
4291 | error ("`%T' has no non-static data member named `%D'", | |
4292 | type, TREE_PURPOSE (*initp)); | |
4293 | } | |
4294 | if (!field) | |
4295 | break; | |
4296 | ||
2437a99c | 4297 | field_init = reshape_init (TREE_TYPE (field), initp); |
a6143adf | 4298 | if (field_init == error_mark_node) |
4299 | return error_mark_node; | |
2437a99c | 4300 | TREE_CHAIN (field_init) = CONSTRUCTOR_ELTS (new_init); |
4301 | CONSTRUCTOR_ELTS (new_init) = field_init; | |
491e04ef | 4302 | /* [dcl.init.aggr] |
2437a99c | 4303 | |
4304 | When a union is initialized with a brace-enclosed | |
4305 | initializer, the braces shall only contain an | |
4306 | initializer for the first member of the union. */ | |
4307 | if (TREE_CODE (type) == UNION_TYPE) | |
4308 | break; | |
2437a99c | 4309 | field = next_initializable_field (TREE_CHAIN (field)); |
4310 | } | |
4311 | } | |
4312 | } | |
e6517de8 | 4313 | else if (TREE_CODE (type) == ARRAY_TYPE |
4314 | || TREE_CODE (type) == VECTOR_TYPE) | |
2437a99c | 4315 | { |
4316 | tree index; | |
4317 | tree max_index; | |
4318 | ||
4319 | /* If the bound of the array is known, take no more initializers | |
4320 | than are allowed. */ | |
d76f7d08 | 4321 | max_index = NULL_TREE; |
4322 | if (TREE_CODE (type) == ARRAY_TYPE) | |
4323 | { | |
4324 | if (TYPE_DOMAIN (type)) | |
4325 | max_index = array_type_nelts (type); | |
4326 | } | |
4327 | else | |
4328 | { | |
4329 | /* For a vector, the representation type is a struct | |
4330 | containing a single member which is an array of the | |
4331 | appropriate size. */ | |
4332 | tree rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type); | |
4333 | if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype)))) | |
4334 | max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype))); | |
4335 | } | |
4336 | ||
2437a99c | 4337 | /* Loop through the array elements, gathering initializers. */ |
4338 | for (index = size_zero_node; | |
4339 | *initp && (!max_index || !tree_int_cst_lt (max_index, index)); | |
4340 | index = size_binop (PLUS_EXPR, index, size_one_node)) | |
4341 | { | |
4342 | tree element_init; | |
4343 | ||
4344 | element_init = reshape_init (TREE_TYPE (type), initp); | |
a6143adf | 4345 | if (element_init == error_mark_node) |
4346 | return error_mark_node; | |
2437a99c | 4347 | TREE_CHAIN (element_init) = CONSTRUCTOR_ELTS (new_init); |
4348 | CONSTRUCTOR_ELTS (new_init) = element_init; | |
4349 | if (TREE_PURPOSE (element_init)) | |
3b67dbda | 4350 | { |
4351 | tree next_index = TREE_PURPOSE (element_init); | |
4352 | if (TREE_CODE (next_index) == IDENTIFIER_NODE) | |
4353 | { | |
4354 | error ("name `%D' used in a GNU-style designated " | |
4355 | "initializer for an array", next_index); | |
4356 | TREE_PURPOSE (element_init) = NULL_TREE; | |
4357 | } | |
4358 | else | |
4359 | index = next_index; | |
4360 | } | |
2437a99c | 4361 | } |
4362 | } | |
4363 | else | |
092b1d6f | 4364 | gcc_unreachable (); |
2437a99c | 4365 | |
4366 | /* The initializers were placed in reverse order in the | |
4367 | CONSTRUCTOR. */ | |
4368 | CONSTRUCTOR_ELTS (new_init) = nreverse (CONSTRUCTOR_ELTS (new_init)); | |
4369 | ||
4370 | if (TREE_CODE (old_init) == TREE_LIST) | |
4371 | new_init = build_tree_list (TREE_PURPOSE (old_init), new_init); | |
4372 | } | |
4373 | ||
4374 | /* If this was a brace-enclosed initializer and all of the | |
4375 | initializers were not used up, there is a problem. */ | |
4376 | if (brace_enclosed_p && *initp) | |
4377 | error ("too many initializers for `%T'", type); | |
4378 | ||
4379 | return new_init; | |
4380 | } | |
4381 | ||
9f9b1983 | 4382 | /* Verify INIT (the initializer for DECL), and record the |
d7d79557 | 4383 | initialization in DECL_INITIAL, if appropriate. CLEANUP is as for |
4384 | grok_reference_init. | |
2437a99c | 4385 | |
4386 | If the return value is non-NULL, it is an expression that must be | |
4387 | evaluated dynamically to initialize DECL. */ | |
ece7bde7 | 4388 | |
9f9b1983 | 4389 | static tree |
d7d79557 | 4390 | check_initializer (tree decl, tree init, int flags, tree *cleanup) |
ece7bde7 | 4391 | { |
23ed74d8 | 4392 | tree type = TREE_TYPE (decl); |
3afe9b43 | 4393 | tree init_code = NULL; |
a35129cf | 4394 | |
ece7bde7 | 4395 | /* If `start_decl' didn't like having an initialization, ignore it now. */ |
4396 | if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE) | |
4397 | init = NULL_TREE; | |
ece7bde7 | 4398 | |
23ed74d8 | 4399 | /* If an initializer is present, DECL_INITIAL has been |
4400 | error_mark_node, to indicate that an as-of-yet unevaluated | |
4401 | initialization will occur. From now on, DECL_INITIAL reflects | |
4402 | the static initialization -- if any -- of DECL. */ | |
4403 | DECL_INITIAL (decl) = NULL_TREE; | |
4404 | ||
2c73aca0 | 4405 | /* Things that are going to be initialized need to have complete |
4406 | type. */ | |
4407 | TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl)); | |
9f9b1983 | 4408 | |
2c73aca0 | 4409 | if (type == error_mark_node) |
4410 | /* We will have already complained. */ | |
4411 | init = NULL_TREE; | |
491e04ef | 4412 | else if (init && COMPLETE_TYPE_P (type) |
2c73aca0 | 4413 | && !TREE_CONSTANT (TYPE_SIZE (type))) |
4414 | { | |
4415 | error ("variable-sized object `%D' may not be initialized", decl); | |
4416 | init = NULL_TREE; | |
4417 | } | |
4418 | else if (TREE_CODE (type) == ARRAY_TYPE | |
4419 | && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type)))) | |
4420 | { | |
4421 | error ("elements of array `%#D' have incomplete type", decl); | |
4422 | init = NULL_TREE; | |
4423 | } | |
4424 | else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type)) | |
4425 | { | |
4426 | error ("`%D' has incomplete type", decl); | |
4427 | TREE_TYPE (decl) = error_mark_node; | |
4428 | init = NULL_TREE; | |
ece7bde7 | 4429 | } |
4430 | ||
4431 | if (TREE_CODE (decl) == CONST_DECL) | |
4432 | { | |
b4df430b | 4433 | gcc_assert (TREE_CODE (decl) != REFERENCE_TYPE); |
ece7bde7 | 4434 | |
4435 | DECL_INITIAL (decl) = init; | |
4436 | ||
b4df430b | 4437 | gcc_assert (init != NULL_TREE); |
ece7bde7 | 4438 | init = NULL_TREE; |
4439 | } | |
9f9b1983 | 4440 | else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE) |
d7d79557 | 4441 | init = grok_reference_init (decl, type, init, cleanup); |
ece7bde7 | 4442 | else if (init) |
4443 | { | |
491e04ef | 4444 | if (TREE_CODE (init) == CONSTRUCTOR |
e6517de8 | 4445 | && BRACE_ENCLOSED_INITIALIZER_P (init)) |
a9df464b | 4446 | { |
4447 | /* [dcl.init] paragraph 13, | |
4448 | If T is a scalar type, then a declaration of the form | |
4449 | T x = { a }; | |
4450 | is equivalent to | |
4451 | T x = a; | |
491e04ef | 4452 | |
a9df464b | 4453 | reshape_init will complain about the extra braces, |
4454 | and doesn't do anything useful in the case where TYPE is | |
4455 | scalar, so just don't call it. */ | |
4456 | if (CP_AGGREGATE_TYPE_P (type)) | |
4457 | init = reshape_init (type, &init); | |
b448d263 | 4458 | |
4459 | if ((*targetm.vector_opaque_p) (type)) | |
4460 | { | |
4461 | error ("opaque vector types cannot be initialized"); | |
4462 | init = error_mark_node; | |
4463 | } | |
a9df464b | 4464 | } |
2437a99c | 4465 | |
4466 | /* If DECL has an array type without a specific bound, deduce the | |
4467 | array size from the initializer. */ | |
4468 | maybe_deduce_size_from_array_init (decl, init); | |
4469 | type = TREE_TYPE (decl); | |
2437a99c | 4470 | |
ece7bde7 | 4471 | if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type)) |
4472 | { | |
4473 | if (TREE_CODE (type) == ARRAY_TYPE) | |
2437a99c | 4474 | goto initialize_aggr; |
ece7bde7 | 4475 | else if (TREE_CODE (init) == CONSTRUCTOR |
e6517de8 | 4476 | && BRACE_ENCLOSED_INITIALIZER_P (init)) |
ece7bde7 | 4477 | { |
4478 | if (TYPE_NON_AGGREGATE_CLASS (type)) | |
4479 | { | |
cf103c6c | 4480 | error ("`%D' must be initialized by constructor, not by `{...}'", |
2437a99c | 4481 | decl); |
ece7bde7 | 4482 | init = error_mark_node; |
4483 | } | |
4484 | else | |
4485 | goto dont_use_constructor; | |
4486 | } | |
2437a99c | 4487 | else |
4488 | { | |
4489 | int saved_stmts_are_full_exprs_p; | |
4490 | ||
4491 | initialize_aggr: | |
4492 | saved_stmts_are_full_exprs_p = 0; | |
4493 | if (building_stmt_tree ()) | |
4494 | { | |
4495 | saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p (); | |
4496 | current_stmt_tree ()->stmts_are_full_exprs_p = 1; | |
4497 | } | |
4498 | init = build_aggr_init (decl, init, flags); | |
4499 | if (building_stmt_tree ()) | |
4500 | current_stmt_tree ()->stmts_are_full_exprs_p = | |
4501 | saved_stmts_are_full_exprs_p; | |
4502 | return init; | |
4503 | } | |
ece7bde7 | 4504 | } |
4505 | else | |
4506 | { | |
4507 | dont_use_constructor: | |
4508 | if (TREE_CODE (init) != TREE_VEC) | |
3afe9b43 | 4509 | { |
4510 | init_code = store_init_value (decl, init); | |
4511 | init = NULL; | |
4512 | } | |
ece7bde7 | 4513 | } |
ece7bde7 | 4514 | } |
4515 | else if (DECL_EXTERNAL (decl)) | |
4516 | ; | |
2437a99c | 4517 | else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type)) |
4518 | goto initialize_aggr; | |
4519 | else if (IS_AGGR_TYPE (type)) | |
ece7bde7 | 4520 | { |
4521 | tree core_type = strip_array_types (type); | |
4522 | ||
2437a99c | 4523 | if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)) |
4524 | error ("structure `%D' with uninitialized const members", decl); | |
4525 | if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)) | |
4526 | error ("structure `%D' with uninitialized reference members", | |
4527 | decl); | |
ece7bde7 | 4528 | |
4529 | check_for_uninitialized_const_var (decl); | |
ece7bde7 | 4530 | } |
4531 | else | |
4532 | check_for_uninitialized_const_var (decl); | |
980877d7 | 4533 | |
2437a99c | 4534 | if (init && init != error_mark_node) |
831d52a2 | 4535 | init_code = build2 (INIT_EXPR, type, decl, init); |
2437a99c | 4536 | |
3afe9b43 | 4537 | return init_code; |
ece7bde7 | 4538 | } |
4539 | ||
4540 | /* If DECL is not a local variable, give it RTL. */ | |
4541 | ||
4542 | static void | |
1b72315d | 4543 | make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec) |
ece7bde7 | 4544 | { |
5ef286c9 | 4545 | int toplev = toplevel_bindings_p (); |
4546 | int defer_p; | |
ece7bde7 | 4547 | |
b2c4af5e | 4548 | /* Set the DECL_ASSEMBLER_NAME for the object. */ |
4549 | if (asmspec) | |
4550 | { | |
4551 | /* The `register' keyword, when used together with an | |
4552 | asm-specification, indicates that the variable should be | |
4553 | placed in a particular register. */ | |
4554 | if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)) | |
4555 | { | |
4556 | change_decl_assembler_name (decl, get_identifier (asmspec)); | |
4557 | DECL_HARD_REGISTER (decl) = 1; | |
4558 | } | |
4559 | else | |
4560 | set_user_assembler_name (decl, asmspec); | |
4561 | } | |
4562 | ||
a8e8221e | 4563 | /* Handle non-variables up front. */ |
4564 | if (TREE_CODE (decl) != VAR_DECL) | |
4565 | { | |
b2c4af5e | 4566 | rest_of_decl_compilation (decl, toplev, at_eof); |
a8e8221e | 4567 | return; |
4568 | } | |
4569 | ||
5ef286c9 | 4570 | /* If we see a class member here, it should be a static data |
4571 | member. */ | |
4572 | if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl)) | |
4573 | { | |
b4df430b | 4574 | gcc_assert (TREE_STATIC (decl)); |
5ef286c9 | 4575 | /* An in-class declaration of a static data member should be |
4576 | external; it is only a declaration, and not a definition. */ | |
4577 | if (init == NULL_TREE) | |
b4df430b | 4578 | gcc_assert (DECL_EXTERNAL (decl)); |
5ef286c9 | 4579 | } |
4580 | ||
5ef286c9 | 4581 | /* We don't create any RTL for local variables. */ |
4582 | if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl)) | |
4583 | return; | |
ece7bde7 | 4584 | |
5ef286c9 | 4585 | /* We defer emission of local statics until the corresponding |
7dd37241 | 4586 | DECL_EXPR is expanded. */ |
5ef286c9 | 4587 | defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl); |
4588 | ||
f626b489 | 4589 | /* We try to defer namespace-scope static constants so that they are |
4590 | not emitted into the object file unnecessarily. */ | |
4591 | if (!DECL_VIRTUAL_P (decl) | |
4592 | && TREE_READONLY (decl) | |
4593 | && DECL_INITIAL (decl) != NULL_TREE | |
4594 | && DECL_INITIAL (decl) != error_mark_node | |
4595 | && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)) | |
4596 | && toplev | |
4597 | && !TREE_PUBLIC (decl)) | |
c4c3877b | 4598 | { |
4599 | /* Fool with the linkage of static consts according to #pragma | |
4600 | interface. */ | |
62bf98ad | 4601 | struct c_fileinfo *finfo = get_fileinfo (input_filename); |
4602 | if (!finfo->interface_unknown && !TREE_PUBLIC (decl)) | |
ece7bde7 | 4603 | { |
5ef286c9 | 4604 | TREE_PUBLIC (decl) = 1; |
62bf98ad | 4605 | DECL_EXTERNAL (decl) = finfo->interface_only; |
ece7bde7 | 4606 | } |
ece7bde7 | 4607 | |
5ef286c9 | 4608 | defer_p = 1; |
ece7bde7 | 4609 | } |
f626b489 | 4610 | /* Likewise for template instantiations. */ |
caa6fdce | 4611 | else if (DECL_LANG_SPECIFIC (decl) |
4612 | && DECL_IMPLICIT_INSTANTIATION (decl)) | |
f626b489 | 4613 | defer_p = 1; |
5ef286c9 | 4614 | |
5ef286c9 | 4615 | /* If we're not deferring, go ahead and assemble the variable. */ |
b2c4af5e | 4616 | if (!defer_p) |
4617 | rest_of_decl_compilation (decl, toplev, at_eof); | |
ece7bde7 | 4618 | } |
4619 | ||
18a4cb16 | 4620 | /* Generate code to initialize DECL (a local variable). */ |
ece7bde7 | 4621 | |
2437a99c | 4622 | static void |
1b72315d | 4623 | initialize_local_var (tree decl, tree init) |
ece7bde7 | 4624 | { |
43295e27 | 4625 | tree type = TREE_TYPE (decl); |
ce0c3b07 | 4626 | tree cleanup; |
ece7bde7 | 4627 | |
b4df430b | 4628 | gcc_assert (TREE_CODE (decl) == VAR_DECL |
4629 | || TREE_CODE (decl) == RESULT_DECL); | |
4630 | gcc_assert (!TREE_STATIC (decl)); | |
ba3a3d1f | 4631 | |
2437a99c | 4632 | if (DECL_SIZE (decl) == NULL_TREE) |
ba3a3d1f | 4633 | { |
4634 | /* If we used it already as memory, it must stay in memory. */ | |
4635 | DECL_INITIAL (decl) = NULL_TREE; | |
4636 | TREE_ADDRESSABLE (decl) = TREE_USED (decl); | |
4637 | } | |
4638 | ||
ece7bde7 | 4639 | if (DECL_SIZE (decl) && type != error_mark_node) |
4640 | { | |
4641 | int already_used; | |
980877d7 | 4642 | |
ece7bde7 | 4643 | /* Compute and store the initial value. */ |
ece7bde7 | 4644 | already_used = TREE_USED (decl) || TREE_USED (type); |
4645 | ||
2437a99c | 4646 | /* Perform the initialization. */ |
4647 | if (init) | |
ece7bde7 | 4648 | { |
2243fa67 | 4649 | int saved_stmts_are_full_exprs_p; |
4650 | ||
b4df430b | 4651 | gcc_assert (building_stmt_tree ()); |
5c3247a9 | 4652 | saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p (); |
a08e60ae | 4653 | current_stmt_tree ()->stmts_are_full_exprs_p = 1; |
2437a99c | 4654 | finish_expr_stmt (init); |
3c3beda6 | 4655 | current_stmt_tree ()->stmts_are_full_exprs_p = |
a08e60ae | 4656 | saved_stmts_are_full_exprs_p; |
ece7bde7 | 4657 | } |
4658 | ||
4659 | /* Set this to 0 so we can tell whether an aggregate which was | |
4660 | initialized was ever used. Don't do this if it has a | |
4661 | destructor, so we don't complain about the 'resource | |
ba3a3d1f | 4662 | allocation is initialization' idiom. Now set |
4663 | attribute((unused)) on types so decls of that type will be | |
4664 | marked used. (see TREE_USED, above.) */ | |
ece7bde7 | 4665 | if (TYPE_NEEDS_CONSTRUCTING (type) |
4666 | && ! already_used | |
89e923d8 | 4667 | && TYPE_HAS_TRIVIAL_DESTRUCTOR (type) |
ece7bde7 | 4668 | && DECL_NAME (decl)) |
4669 | TREE_USED (decl) = 0; | |
ba3a3d1f | 4670 | else if (already_used) |
ece7bde7 | 4671 | TREE_USED (decl) = 1; |
4672 | } | |
2243fa67 | 4673 | |
2437a99c | 4674 | /* Generate a cleanup, if necessary. */ |
ce0c3b07 | 4675 | cleanup = cxx_maybe_build_cleanup (decl); |
4676 | if (DECL_SIZE (decl) && cleanup) | |
4677 | finish_decl_cleanup (decl, cleanup); | |
2243fa67 | 4678 | } |
4679 | ||
aff47ac3 | 4680 | /* DECL is a VAR_DECL for a compiler-generated variable with static |
4681 | storage duration (like a virtual table) whose initializer is a | |
4682 | compile-time constant. Initialize the variable and provide it to | |
4683 | the back end. */ | |
4684 | ||
4685 | void | |
4686 | initialize_artificial_var (tree decl, tree init) | |
4687 | { | |
4688 | DECL_INITIAL (decl) = build_constructor (NULL_TREE, init); | |
4689 | DECL_INITIALIZED_P (decl) = 1; | |
4690 | determine_visibility (decl); | |
4691 | layout_var_decl (decl); | |
4692 | maybe_commonize_var (decl); | |
4693 | make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL); | |
4694 | } | |
4695 | ||
471086d6 | 4696 | /* Finish processing of a declaration; |
4697 | install its line number and initial value. | |
4698 | If the length of an array type is not known before, | |
4699 | it must be determined now, from the initial value, or it is an error. | |
4700 | ||
0f497990 | 4701 | INIT holds the value of an initializer that should be allowed to escape |
471086d6 | 4702 | the normal rules. |
4703 | ||
8823d708 | 4704 | FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0 |
991ab8f3 | 4705 | if the (init) syntax was used. */ |
471086d6 | 4706 | |
4707 | void | |
1b72315d | 4708 | cp_finish_decl (tree decl, tree init, tree asmspec_tree, int flags) |
471086d6 | 4709 | { |
d7d79557 | 4710 | tree type; |
ece7bde7 | 4711 | tree ttype = NULL_TREE; |
d7d79557 | 4712 | tree cleanup; |
023b3db6 | 4713 | const char *asmspec = NULL; |
471086d6 | 4714 | int was_readonly = 0; |
4715 | ||
f3959165 | 4716 | if (decl == error_mark_node) |
4717 | return; | |
4718 | else if (! decl) | |
471086d6 | 4719 | { |
4720 | if (init) | |
905d4035 | 4721 | error ("assignment (not initialization) in declaration"); |
471086d6 | 4722 | return; |
4723 | } | |
4724 | ||
b4df430b | 4725 | gcc_assert (TREE_CODE (decl) != RESULT_DECL); |
ce0c3b07 | 4726 | |
d7d79557 | 4727 | /* Assume no cleanup is required. */ |
4728 | cleanup = NULL_TREE; | |
4729 | ||
d81e00a4 | 4730 | /* If a name was specified, get the string. */ |
ddeeea02 | 4731 | if (global_scope_p (current_binding_level)) |
ea42c4de | 4732 | asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree); |
491e04ef | 4733 | if (asmspec_tree) |
c4c3877b | 4734 | asmspec = TREE_STRING_POINTER (asmspec_tree); |
471086d6 | 4735 | |
8417823c | 4736 | if (init && TREE_CODE (init) == NAMESPACE_DECL) |
4737 | { | |
cf103c6c | 4738 | error ("cannot initialize `%D' to namespace `%D'", |
8417823c | 4739 | decl, init); |
4740 | init = NULL_TREE; | |
4741 | } | |
4742 | ||
df5066e2 | 4743 | if (current_class_type |
9ba4048d | 4744 | && CP_DECL_CONTEXT (decl) == current_class_type |
df5066e2 | 4745 | && TYPE_BEING_DEFINED (current_class_type) |
4746 | && (DECL_INITIAL (decl) || init)) | |
c792eccc | 4747 | DECL_INITIALIZED_IN_CLASS_P (decl) = 1; |
df5066e2 | 4748 | |
9f9b1983 | 4749 | type = TREE_TYPE (decl); |
471086d6 | 4750 | |
c38086bd | 4751 | if (type == error_mark_node) |
91caa6ca | 4752 | goto finish_end; |
3c3beda6 | 4753 | |
6f9b1420 | 4754 | if (TYPE_HAS_MUTABLE_P (type)) |
4755 | TREE_READONLY (decl) = 0; | |
2243fa67 | 4756 | |
3cc0b4b9 | 4757 | if (processing_template_decl) |
e857e9c7 | 4758 | { |
ca106ab1 | 4759 | /* Add this declaration to the statement-tree. */ |
ce0c3b07 | 4760 | if (at_function_scope_p ()) |
7dd37241 | 4761 | add_decl_expr (decl); |
ca106ab1 | 4762 | |
e857e9c7 | 4763 | if (init && DECL_INITIAL (decl)) |
f8b2b358 | 4764 | DECL_INITIAL (decl) = init; |
e6d8a6d5 | 4765 | if (TREE_CODE (decl) == VAR_DECL |
4766 | && !DECL_PRETTY_FUNCTION_P (decl) | |
4767 | && !dependent_type_p (TREE_TYPE (decl))) | |
4768 | maybe_deduce_size_from_array_init (decl, init); | |
91caa6ca | 4769 | goto finish_end; |
e857e9c7 | 4770 | } |
4a7414ab | 4771 | |
ece7bde7 | 4772 | /* Parameters are handled by store_parm_decls, not cp_finish_decl. */ |
b4df430b | 4773 | gcc_assert (TREE_CODE (decl) != PARM_DECL); |
ece7bde7 | 4774 | |
471086d6 | 4775 | /* Take care of TYPE_DECLs up front. */ |
4776 | if (TREE_CODE (decl) == TYPE_DECL) | |
4777 | { | |
ddb9bca7 | 4778 | if (type != error_mark_node |
4779 | && IS_AGGR_TYPE (type) && DECL_NAME (decl)) | |
471086d6 | 4780 | { |
4781 | if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type) | |
cf103c6c | 4782 | warning ("shadowing previous type declaration of `%#D'", decl); |
b7d1e8ea | 4783 | set_identifier_type_value (DECL_NAME (decl), decl); |
471086d6 | 4784 | } |
fff5e605 | 4785 | |
4786 | /* If we have installed this as the canonical typedef for this | |
4787 | type, and that type has not been defined yet, delay emitting | |
ad87de1e | 4788 | the debug information for it, as we will emit it later. */ |
b0df6589 | 4789 | if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl |
4b72716d | 4790 | && !COMPLETE_TYPE_P (TREE_TYPE (decl))) |
fff5e605 | 4791 | TYPE_DECL_SUPPRESS_DEBUG (decl) = 1; |
4792 | ||
b2c4af5e | 4793 | rest_of_decl_compilation (decl, DECL_CONTEXT (decl) == NULL_TREE, |
4794 | at_eof); | |
471086d6 | 4795 | goto finish_end; |
4796 | } | |
4a7414ab | 4797 | |
471086d6 | 4798 | if (TREE_CODE (decl) != FUNCTION_DECL) |
4a7414ab | 4799 | ttype = target_type (type); |
471086d6 | 4800 | |
491e04ef | 4801 | |
09742c66 | 4802 | /* Currently, GNU C++ puts constants in text space, making them |
4803 | impossible to initialize. In the future, one would hope for | |
4804 | an operating system which understood the difference between | |
4805 | initialization and the running of a program. */ | |
4806 | if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)) | |
471086d6 | 4807 | { |
471086d6 | 4808 | was_readonly = 1; |
491e04ef | 4809 | if (TYPE_NEEDS_CONSTRUCTING (type) |
09742c66 | 4810 | || TREE_CODE (type) == REFERENCE_TYPE) |
4811 | TREE_READONLY (decl) = 0; | |
471086d6 | 4812 | } |
4813 | ||
6c666cd5 | 4814 | if (TREE_CODE (decl) == VAR_DECL) |
23ed74d8 | 4815 | { |
4816 | /* Only PODs can have thread-local storage. Other types may require | |
4817 | various kinds of non-trivial initialization. */ | |
4818 | if (DECL_THREAD_LOCAL (decl) && !pod_type_p (TREE_TYPE (decl))) | |
4819 | error ("`%D' cannot be thread-local because it has non-POD type `%T'", | |
4820 | decl, TREE_TYPE (decl)); | |
4821 | /* Convert the initializer to the type of DECL, if we have not | |
4822 | already initialized DECL. */ | |
4823 | if (!DECL_INITIALIZED_P (decl) | |
4824 | /* If !DECL_EXTERNAL then DECL is being defined. In the | |
2437a99c | 4825 | case of a static data member initialized inside the |
23ed74d8 | 4826 | class-specifier, there can be an initializer even if DECL |
4827 | is *not* defined. */ | |
4828 | && (!DECL_EXTERNAL (decl) || init)) | |
4829 | { | |
d7d79557 | 4830 | init = check_initializer (decl, init, flags, &cleanup); |
77b5d754 | 4831 | /* Thread-local storage cannot be dynamically initialized. */ |
4832 | if (DECL_THREAD_LOCAL (decl) && init) | |
4833 | { | |
4834 | error ("`%D' is thread-local and so cannot be dynamically " | |
4835 | "initialized", decl); | |
4836 | init = NULL_TREE; | |
4837 | } | |
23ed74d8 | 4838 | /* Handle: |
491e04ef | 4839 | |
23ed74d8 | 4840 | [dcl.init] |
491e04ef | 4841 | |
23ed74d8 | 4842 | The memory occupied by any object of static storage |
4843 | duration is zero-initialized at program startup before | |
4844 | any other initialization takes place. | |
491e04ef | 4845 | |
23ed74d8 | 4846 | We cannot create an appropriate initializer until after |
4847 | the type of DECL is finalized. If DECL_INITIAL is set, | |
4848 | then the DECL is statically initialized, and any | |
4849 | necessary zero-initialization has already been performed. */ | |
4850 | if (TREE_STATIC (decl) && !DECL_INITIAL (decl)) | |
4851 | DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl), | |
5d3c3f21 | 4852 | /*nelts=*/NULL_TREE, |
23ed74d8 | 4853 | /*static_storage_p=*/true); |
4854 | /* Remember that the initialization for this variable has | |
4855 | taken place. */ | |
4856 | DECL_INITIALIZED_P (decl) = 1; | |
91caa6ca | 4857 | /* The variable is being defined, so determine its |
4858 | visibility. */ | |
4859 | determine_visibility (decl); | |
23ed74d8 | 4860 | } |
db2d58f1 | 4861 | /* If the variable has an array type, lay out the type, even if |
4862 | there is no initializer. It is valid to index through the | |
4863 | array, and we must get TYPE_ALIGN set correctly on the array | |
4864 | type. */ | |
4865 | else if (TREE_CODE (type) == ARRAY_TYPE) | |
4866 | layout_type (type); | |
23ed74d8 | 4867 | } |
4a7414ab | 4868 | |
ddb449aa | 4869 | /* Add this declaration to the statement-tree. This needs to happen |
7dd37241 | 4870 | after the call to check_initializer so that the DECL_EXPR for a |
4871 | reference temp is added before the DECL_EXPR for the reference itself. */ | |
ce0c3b07 | 4872 | if (at_function_scope_p ()) |
7dd37241 | 4873 | add_decl_expr (decl); |
ca106ab1 | 4874 | |
471086d6 | 4875 | if (TREE_CODE (decl) == VAR_DECL) |
73b8a26b | 4876 | layout_var_decl (decl); |
471086d6 | 4877 | |
4878 | /* Output the assembler code and/or RTL code for variables and functions, | |
4879 | unless the type is an undefined structure or union. | |
4880 | If not, it will get done when the type is completed. */ | |
ce0c3b07 | 4881 | if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL) |
471086d6 | 4882 | { |
ece7bde7 | 4883 | if (TREE_CODE (decl) == VAR_DECL) |
4884 | maybe_commonize_var (decl); | |
471086d6 | 4885 | |
ece7bde7 | 4886 | make_rtl_for_nonlocal_decl (decl, init, asmspec); |
471086d6 | 4887 | |
d97a7640 | 4888 | /* Check for abstractness of the type. Notice that there is no |
4889 | need to strip array types here since the check for those types | |
4890 | is already done within create_array_type_for_decl. */ | |
980877d7 | 4891 | if (TREE_CODE (type) == FUNCTION_TYPE |
ece7bde7 | 4892 | || TREE_CODE (type) == METHOD_TYPE) |
d97a7640 | 4893 | abstract_virtuals_error (decl, TREE_TYPE (type)); |
980877d7 | 4894 | else |
71817734 | 4895 | abstract_virtuals_error (decl, type); |
471086d6 | 4896 | |
491e04ef | 4897 | if (TREE_CODE (decl) == FUNCTION_DECL |
2437a99c | 4898 | || TREE_TYPE (decl) == error_mark_node) |
4899 | /* No initialization required. */ | |
bb09dca5 | 4900 | ; |
bf1b65b4 | 4901 | else if (DECL_EXTERNAL (decl) |
4902 | && ! (DECL_LANG_SPECIFIC (decl) | |
4903 | && DECL_NOT_REALLY_EXTERN (decl))) | |
e857e9c7 | 4904 | { |
4905 | if (init) | |
4906 | DECL_INITIAL (decl) = init; | |
4907 | } | |
2437a99c | 4908 | else |
471086d6 | 4909 | { |
2437a99c | 4910 | /* A variable definition. */ |
4911 | if (DECL_FUNCTION_SCOPE_P (decl)) | |
2243fa67 | 4912 | { |
2437a99c | 4913 | /* Initialize the local variable. */ |
4914 | if (processing_template_decl) | |
4915 | { | |
4916 | if (init || DECL_INITIAL (decl) == error_mark_node) | |
4917 | DECL_INITIAL (decl) = init; | |
4918 | } | |
4919 | else if (!TREE_STATIC (decl)) | |
4920 | initialize_local_var (decl, init); | |
2243fa67 | 4921 | } |
2437a99c | 4922 | |
4923 | if (TREE_STATIC (decl)) | |
43295e27 | 4924 | expand_static_init (decl, init); |
4925 | } | |
471086d6 | 4926 | } |
4927 | ||
d7d79557 | 4928 | /* If a CLEANUP_STMT was created to destroy a temporary bound to a |
4929 | reference, insert it in the statement-tree now. */ | |
4930 | if (cleanup) | |
2363ef00 | 4931 | push_cleanup (decl, cleanup, false); |
d7d79557 | 4932 | |
471086d6 | 4933 | finish_end: |
4934 | ||
471086d6 | 4935 | if (was_readonly) |
4936 | TREE_READONLY (decl) = 1; | |
40109983 | 4937 | |
4938 | /* If this was marked 'used', be sure it will be output. */ | |
4939 | if (lookup_attribute ("used", DECL_ATTRIBUTES (decl))) | |
4490a821 | 4940 | mark_decl_referenced (decl); |
471086d6 | 4941 | } |
4942 | ||
331bc0ad | 4943 | /* This is here for a midend callback from c-common.c. */ |
96624a9e | 4944 | |
e4118769 | 4945 | void |
1b72315d | 4946 | finish_decl (tree decl, tree init, tree asmspec_tree) |
e4118769 | 4947 | { |
ce23987e | 4948 | cp_finish_decl (decl, init, asmspec_tree, 0); |
e4118769 | 4949 | } |
4950 | ||
1da45f21 | 4951 | /* Returns a declaration for a VAR_DECL as if: |
4952 | ||
4953 | extern "C" TYPE NAME; | |
4954 | ||
4955 | had been seen. Used to create compiler-generated global | |
4956 | variables. */ | |
4957 | ||
4958 | tree | |
1b72315d | 4959 | declare_global_var (tree name, tree type) |
1da45f21 | 4960 | { |
4961 | tree decl; | |
4962 | ||
4963 | push_to_top_level (); | |
4964 | decl = build_decl (VAR_DECL, name, type); | |
4965 | TREE_PUBLIC (decl) = 1; | |
4966 | DECL_EXTERNAL (decl) = 1; | |
4967 | DECL_ARTIFICIAL (decl) = 1; | |
4968 | pushdecl (decl); | |
4969 | cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0); | |
4970 | pop_from_top_level (); | |
4971 | ||
4972 | return decl; | |
4973 | } | |
4974 | ||
4975 | /* Returns a pointer to the `atexit' function. Note that if | |
3160db1d | 4976 | FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new |
1da45f21 | 4977 | `__cxa_atexit' function specified in the IA64 C++ ABI. */ |
4978 | ||
4979 | static tree | |
1b72315d | 4980 | get_atexit_node (void) |
1da45f21 | 4981 | { |
4982 | tree atexit_fndecl; | |
4983 | tree arg_types; | |
4984 | tree fn_type; | |
4985 | tree fn_ptr_type; | |
4986 | const char *name; | |
4987 | ||
4988 | if (atexit_node) | |
4989 | return atexit_node; | |
4990 | ||
4991 | if (flag_use_cxa_atexit) | |
4992 | { | |
4993 | /* The declaration for `__cxa_atexit' is: | |
4994 | ||
4995 | int __cxa_atexit (void (*)(void *), void *, void *) | |
4996 | ||
4997 | We build up the argument types and then then function type | |
4998 | itself. */ | |
980877d7 | 4999 | |
1da45f21 | 5000 | /* First, build the pointer-to-function type for the first |
5001 | argument. */ | |
5002 | arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node); | |
5003 | fn_type = build_function_type (void_type_node, arg_types); | |
5004 | fn_ptr_type = build_pointer_type (fn_type); | |
5005 | /* Then, build the rest of the argument types. */ | |
5006 | arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node); | |
5007 | arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types); | |
5008 | arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types); | |
5009 | /* And the final __cxa_atexit type. */ | |
5010 | fn_type = build_function_type (integer_type_node, arg_types); | |
5011 | fn_ptr_type = build_pointer_type (fn_type); | |
5012 | name = "__cxa_atexit"; | |
5013 | } | |
5014 | else | |
5015 | { | |
5016 | /* The declaration for `atexit' is: | |
980877d7 | 5017 | |
1da45f21 | 5018 | int atexit (void (*)()); |
5019 | ||
5020 | We build up the argument types and then then function type | |
5021 | itself. */ | |
5022 | fn_type = build_function_type (void_type_node, void_list_node); | |
5023 | fn_ptr_type = build_pointer_type (fn_type); | |
5024 | arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node); | |
5025 | /* Build the final atexit type. */ | |
5026 | fn_type = build_function_type (integer_type_node, arg_types); | |
5027 | name = "atexit"; | |
5028 | } | |
5029 | ||
5030 | /* Now, build the function declaration. */ | |
5031 | push_lang_context (lang_name_c); | |
d267eaf5 | 5032 | atexit_fndecl = build_library_fn_ptr (name, fn_type); |
1da45f21 | 5033 | mark_used (atexit_fndecl); |
5034 | pop_lang_context (); | |
a681799d | 5035 | atexit_node = decay_conversion (atexit_fndecl); |
1da45f21 | 5036 | |
5037 | return atexit_node; | |
5038 | } | |
5039 | ||
5040 | /* Returns the __dso_handle VAR_DECL. */ | |
5041 | ||
5042 | static tree | |
1b72315d | 5043 | get_dso_handle_node (void) |
1da45f21 | 5044 | { |
5045 | if (dso_handle_node) | |
5046 | return dso_handle_node; | |
5047 | ||
5048 | /* Declare the variable. */ | |
5049 | dso_handle_node = declare_global_var (get_identifier ("__dso_handle"), | |
5050 | ptr_type_node); | |
5051 | ||
5052 | return dso_handle_node; | |
5053 | } | |
5054 | ||
5055 | /* Begin a new function with internal linkage whose job will be simply | |
5056 | to destroy some particular variable. */ | |
5057 | ||
4c1de685 | 5058 | static GTY(()) int start_cleanup_cnt; |
5059 | ||
1da45f21 | 5060 | static tree |
1b72315d | 5061 | start_cleanup_fn (void) |
1da45f21 | 5062 | { |
1da45f21 | 5063 | char name[32]; |
5064 | tree parmtypes; | |
5065 | tree fntype; | |
5066 | tree fndecl; | |
5067 | ||
5068 | push_to_top_level (); | |
5069 | ||
5070 | /* No need to mangle this. */ | |
5071 | push_lang_context (lang_name_c); | |
5072 | ||
1da45f21 | 5073 | /* Build the parameter-types. */ |
5074 | parmtypes = void_list_node; | |
5075 | /* Functions passed to __cxa_atexit take an additional parameter. | |
5076 | We'll just ignore it. After we implement the new calling | |
5077 | convention for destructors, we can eliminate the use of | |
5078 | additional cleanup functions entirely in the -fnew-abi case. */ | |
5079 | if (flag_use_cxa_atexit) | |
5080 | parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes); | |
5081 | /* Build the function type itself. */ | |
5082 | fntype = build_function_type (void_type_node, parmtypes); | |
5083 | /* Build the name of the function. */ | |
4c1de685 | 5084 | sprintf (name, "__tcf_%d", start_cleanup_cnt++); |
1da45f21 | 5085 | /* Build the function declaration. */ |
5086 | fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype); | |
5087 | /* It's a function with internal linkage, generated by the | |
5088 | compiler. */ | |
5089 | TREE_PUBLIC (fndecl) = 0; | |
5090 | DECL_ARTIFICIAL (fndecl) = 1; | |
52b5ec4c | 5091 | /* Make the function `inline' so that it is only emitted if it is |
5092 | actually needed. It is unlikely that it will be inlined, since | |
4109ca29 | 5093 | it is only called via a function pointer, but we avoid unnecessary |
52b5ec4c | 5094 | emissions this way. */ |
5095 | DECL_INLINE (fndecl) = 1; | |
19489abd | 5096 | DECL_DECLARED_INLINE_P (fndecl) = 1; |
5097 | DECL_INTERFACE_KNOWN (fndecl) = 1; | |
1da45f21 | 5098 | /* Build the parameter. */ |
5099 | if (flag_use_cxa_atexit) | |
5100 | { | |
5101 | tree parmdecl; | |
5102 | ||
d145d8d5 | 5103 | parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node); |
1da45f21 | 5104 | DECL_CONTEXT (parmdecl) = fndecl; |
1da45f21 | 5105 | TREE_USED (parmdecl) = 1; |
5106 | DECL_ARGUMENTS (fndecl) = parmdecl; | |
5107 | } | |
5108 | ||
24c5ffc6 | 5109 | pushdecl (fndecl); |
3046c0a3 | 5110 | start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED); |
1da45f21 | 5111 | |
1da45f21 | 5112 | pop_lang_context (); |
5113 | ||
5114 | return current_function_decl; | |
5115 | } | |
5116 | ||
5117 | /* Finish the cleanup function begun by start_cleanup_fn. */ | |
5118 | ||
5119 | static void | |
1b72315d | 5120 | end_cleanup_fn (void) |
1da45f21 | 5121 | { |
6cb758f0 | 5122 | expand_or_defer_fn (finish_function (0)); |
1da45f21 | 5123 | |
5124 | pop_from_top_level (); | |
5125 | } | |
5126 | ||
060ff7d8 | 5127 | /* Generate code to handle the destruction of DECL, an object with |
5128 | static storage duration. */ | |
b9920b13 | 5129 | |
4813f5af | 5130 | tree |
1b72315d | 5131 | register_dtor_fn (tree decl) |
b9920b13 | 5132 | { |
1da45f21 | 5133 | tree cleanup; |
b9920b13 | 5134 | tree compound_stmt; |
1da45f21 | 5135 | tree args; |
5136 | tree fcall; | |
b9920b13 | 5137 | |
89e923d8 | 5138 | if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl))) |
4813f5af | 5139 | return void_zero_node; |
060ff7d8 | 5140 | |
b9920b13 | 5141 | /* Call build_cleanup before we enter the anonymous function so that |
5142 | any access checks will be done relative to the current scope, | |
5143 | rather than the scope of the anonymous function. */ | |
5144 | build_cleanup (decl); | |
5145 | ||
5146 | /* Now start the function. */ | |
1da45f21 | 5147 | cleanup = start_cleanup_fn (); |
b9920b13 | 5148 | |
5149 | /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer | |
5150 | to the original function, rather than the anonymous one. That | |
5151 | will make the back-end think that nested functions are in use, | |
5152 | which causes confusion. */ | |
491e04ef | 5153 | |
4cab8273 | 5154 | push_deferring_access_checks (dk_no_check); |
b9920b13 | 5155 | fcall = build_cleanup (decl); |
4cab8273 | 5156 | pop_deferring_access_checks (); |
b9920b13 | 5157 | |
5158 | /* Create the body of the anonymous function. */ | |
2363ef00 | 5159 | compound_stmt = begin_compound_stmt (BCS_FN_BODY); |
b9920b13 | 5160 | finish_expr_stmt (fcall); |
68f8f8cc | 5161 | finish_compound_stmt (compound_stmt); |
1da45f21 | 5162 | end_cleanup_fn (); |
b9920b13 | 5163 | |
5164 | /* Call atexit with the cleanup function. */ | |
9b86eec0 | 5165 | cxx_mark_addressable (cleanup); |
b04d4dc3 | 5166 | mark_used (cleanup); |
b9920b13 | 5167 | cleanup = build_unary_op (ADDR_EXPR, cleanup, 0); |
1da45f21 | 5168 | if (flag_use_cxa_atexit) |
5169 | { | |
491e04ef | 5170 | args = tree_cons (NULL_TREE, |
ffe1802e | 5171 | build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0), |
5172 | NULL_TREE); | |
1da45f21 | 5173 | args = tree_cons (NULL_TREE, null_pointer_node, args); |
5174 | args = tree_cons (NULL_TREE, cleanup, args); | |
5175 | } | |
5176 | else | |
5177 | args = tree_cons (NULL_TREE, cleanup, NULL_TREE); | |
4813f5af | 5178 | return build_function_call (get_atexit_node (), args); |
b9920b13 | 5179 | } |
5180 | ||
2437a99c | 5181 | /* DECL is a VAR_DECL with static storage duration. INIT, if present, |
5182 | is its initializer. Generate code to handle the construction | |
5183 | and destruction of DECL. */ | |
5184 | ||
5185 | static void | |
1b72315d | 5186 | expand_static_init (tree decl, tree init) |
471086d6 | 5187 | { |
b4df430b | 5188 | gcc_assert (TREE_CODE (decl) == VAR_DECL); |
5189 | gcc_assert (TREE_STATIC (decl)); | |
2437a99c | 5190 | |
5191 | /* Some variables require no initialization. */ | |
491e04ef | 5192 | if (!init |
2437a99c | 5193 | && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)) |
5194 | && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl))) | |
5195 | return; | |
5196 | ||
c0731520 | 5197 | if (DECL_FUNCTION_SCOPE_P (decl)) |
471086d6 | 5198 | { |
5199 | /* Emit code to perform this initialization but once. */ | |
218e09bc | 5200 | tree if_stmt, inner_if_stmt = NULL_TREE; |
5201 | tree then_clause, inner_then_clause = NULL_TREE; | |
4813f5af | 5202 | tree guard, guard_addr, guard_addr_list; |
5203 | tree acquire_fn, release_fn, abort_fn; | |
5204 | tree flag, begin; | |
471086d6 | 5205 | |
1fc84929 | 5206 | /* Emit code to perform this initialization but once. This code |
5207 | looks like: | |
5208 | ||
4813f5af | 5209 | static <type> guard; |
5210 | if (!guard.first_byte) { | |
5211 | if (__cxa_guard_acquire (&guard)) { | |
5212 | bool flag = false; | |
5213 | try { | |
5214 | // Do initialization. | |
5215 | flag = true; __cxa_guard_release (&guard); | |
5216 | // Register variable for destruction at end of program. | |
5217 | } catch { | |
5218 | if (!flag) __cxa_guard_abort (&guard); | |
5219 | } | |
1fc84929 | 5220 | } |
5221 | ||
4813f5af | 5222 | Note that the `flag' variable is only set to 1 *after* the |
1fc84929 | 5223 | initialization is complete. This ensures that an exception, |
5224 | thrown during the construction, will cause the variable to | |
5225 | reinitialized when we pass through this code again, as per: | |
980877d7 | 5226 | |
1fc84929 | 5227 | [stmt.dcl] |
5228 | ||
4813f5af | 5229 | If the initialization exits by throwing an exception, the |
1fc84929 | 5230 | initialization is not complete, so it will be tried again |
5231 | the next time control enters the declaration. | |
5232 | ||
4813f5af | 5233 | This process should be thread-safe, too; multiple threads |
5234 | should not be able to initialize the variable more than | |
5235 | once. */ | |
4eb32e62 | 5236 | |
5237 | /* Create the guard variable. */ | |
5238 | guard = get_guard (decl); | |
1fc84929 | 5239 | |
5240 | /* Begin the conditional initialization. */ | |
ba3a3d1f | 5241 | if_stmt = begin_if_stmt (); |
4eb32e62 | 5242 | finish_if_stmt_cond (get_guard_cond (guard), if_stmt); |
4813f5af | 5243 | then_clause = begin_compound_stmt (BCS_NO_SCOPE); |
5244 | ||
5245 | if (flag_threadsafe_statics) | |
5246 | { | |
5247 | guard_addr = build_address (guard); | |
5248 | guard_addr_list = build_tree_list (NULL_TREE, guard_addr); | |
5249 | ||
5250 | acquire_fn = get_identifier ("__cxa_guard_acquire"); | |
5251 | release_fn = get_identifier ("__cxa_guard_release"); | |
5252 | abort_fn = get_identifier ("__cxa_guard_abort"); | |
5253 | if (!get_global_value_if_present (acquire_fn, &acquire_fn)) | |
5254 | { | |
5255 | tree argtypes = tree_cons (NULL_TREE, TREE_TYPE (guard_addr), | |
5256 | void_list_node); | |
5257 | tree vfntype = build_function_type (void_type_node, argtypes); | |
5258 | acquire_fn = push_library_fn | |
5259 | (acquire_fn, build_function_type (integer_type_node, argtypes)); | |
5260 | release_fn = push_library_fn (release_fn, vfntype); | |
5261 | abort_fn = push_library_fn (abort_fn, vfntype); | |
5262 | } | |
5263 | else | |
5264 | { | |
5265 | release_fn = identifier_global_value (release_fn); | |
5266 | abort_fn = identifier_global_value (abort_fn); | |
5267 | } | |
5268 | ||
5269 | inner_if_stmt = begin_if_stmt (); | |
5270 | finish_if_stmt_cond (build_call (acquire_fn, guard_addr_list), | |
5271 | inner_if_stmt); | |
5272 | ||
5273 | inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE); | |
5274 | begin = get_target_expr (boolean_false_node); | |
5275 | flag = TARGET_EXPR_SLOT (begin); | |
5276 | ||
5277 | TARGET_EXPR_CLEANUP (begin) | |
5278 | = build (COND_EXPR, void_type_node, flag, | |
5279 | void_zero_node, | |
5280 | build_call (abort_fn, guard_addr_list)); | |
5281 | CLEANUP_EH_ONLY (begin) = 1; | |
5282 | ||
5283 | /* Do the initialization itself. */ | |
5284 | init = add_stmt_to_compound (begin, init); | |
5285 | init = add_stmt_to_compound | |
5286 | (init, build (MODIFY_EXPR, void_type_node, flag, boolean_true_node)); | |
5287 | init = add_stmt_to_compound | |
5288 | (init, build_call (release_fn, guard_addr_list)); | |
5289 | } | |
b48733fd | 5290 | else |
4813f5af | 5291 | init = add_stmt_to_compound (init, set_guard (guard)); |
3d4e092a | 5292 | |
1fc84929 | 5293 | /* Use atexit to register a function for destroying this static |
5294 | variable. */ | |
4813f5af | 5295 | init = add_stmt_to_compound (init, register_dtor_fn (decl)); |
5296 | ||
5297 | finish_expr_stmt (init); | |
5298 | ||
5299 | if (flag_threadsafe_statics) | |
5300 | { | |
5301 | finish_compound_stmt (inner_then_clause); | |
5302 | finish_then_clause (inner_if_stmt); | |
5303 | finish_if_stmt (inner_if_stmt); | |
5304 | } | |
3d4e092a | 5305 | |
68f8f8cc | 5306 | finish_compound_stmt (then_clause); |
ba3a3d1f | 5307 | finish_then_clause (if_stmt); |
2363ef00 | 5308 | finish_if_stmt (if_stmt); |
471086d6 | 5309 | } |
5310 | else | |
b53fb33d | 5311 | static_aggregates = tree_cons (init, decl, static_aggregates); |
471086d6 | 5312 | } |
357d301c | 5313 | |
471086d6 | 5314 | \f |
5315 | /* Make TYPE a complete type based on INITIAL_VALUE. | |
5316 | Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered, | |
2ec59cf5 | 5317 | 2 if there was no information (in which case assume 0 if DO_DEFAULT). */ |
471086d6 | 5318 | |
5319 | int | |
1b72315d | 5320 | complete_array_type (tree type, tree initial_value, int do_default) |
471086d6 | 5321 | { |
cd16867a | 5322 | tree maxindex = NULL_TREE; |
471086d6 | 5323 | int value = 0; |
980877d7 | 5324 | |
471086d6 | 5325 | if (initial_value) |
5326 | { | |
e67164f5 | 5327 | /* An array of character type can be initialized from a |
5328 | brace-enclosed string constant. */ | |
5329 | if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))) | |
5330 | && TREE_CODE (initial_value) == CONSTRUCTOR | |
5331 | && CONSTRUCTOR_ELTS (initial_value) | |
5332 | && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value))) | |
5333 | == STRING_CST) | |
5334 | && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE) | |
5335 | initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)); | |
5336 | ||
5337 | /* Note MAXINDEX is really the maximum index, one less than the | |
5338 | size. */ | |
471086d6 | 5339 | if (TREE_CODE (initial_value) == STRING_CST) |
bcf789d7 | 5340 | { |
5341 | int eltsize | |
5342 | = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value))); | |
7c446c95 | 5343 | maxindex = build_int_cst (NULL_TREE, |
5344 | (TREE_STRING_LENGTH (initial_value) | |
7016c612 | 5345 | / eltsize) - 1); |
bcf789d7 | 5346 | } |
471086d6 | 5347 | else if (TREE_CODE (initial_value) == CONSTRUCTOR) |
5348 | { | |
bcf789d7 | 5349 | tree elts = CONSTRUCTOR_ELTS (initial_value); |
902de8ed | 5350 | |
85390276 | 5351 | maxindex = ssize_int (-1); |
bcf789d7 | 5352 | for (; elts; elts = TREE_CHAIN (elts)) |
5353 | { | |
5354 | if (TREE_PURPOSE (elts)) | |
5355 | maxindex = TREE_PURPOSE (elts); | |
5356 | else | |
902de8ed | 5357 | maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1)); |
bcf789d7 | 5358 | } |
471086d6 | 5359 | } |
5360 | else | |
5361 | { | |
5362 | /* Make an error message unless that happened already. */ | |
5363 | if (initial_value != error_mark_node) | |
5364 | value = 1; | |
308c6c51 | 5365 | else |
5366 | initial_value = NULL_TREE; | |
471086d6 | 5367 | |
5368 | /* Prevent further error messages. */ | |
7016c612 | 5369 | maxindex = build_int_cst (NULL_TREE, 0); |
471086d6 | 5370 | } |
5371 | } | |
5372 | ||
5373 | if (!maxindex) | |
5374 | { | |
5375 | if (do_default) | |
7016c612 | 5376 | maxindex = build_int_cst (NULL_TREE, 0); |
471086d6 | 5377 | value = 2; |
5378 | } | |
5379 | ||
5380 | if (maxindex) | |
5381 | { | |
ac9386a0 | 5382 | tree itype; |
2ec59cf5 | 5383 | tree domain; |
e945eb2d | 5384 | tree elt_type; |
2ec59cf5 | 5385 | |
5386 | domain = build_index_type (maxindex); | |
5387 | TYPE_DOMAIN (type) = domain; | |
ac9386a0 | 5388 | |
ac9386a0 | 5389 | if (initial_value) |
5390 | itype = TREE_TYPE (initial_value); | |
5391 | else | |
5392 | itype = NULL; | |
5393 | if (itype && !TYPE_DOMAIN (itype)) | |
2ec59cf5 | 5394 | TYPE_DOMAIN (itype) = domain; |
ef34cee5 | 5395 | /* The type of the main variant should never be used for arrays |
5396 | of different sizes. It should only ever be completed with the | |
5397 | size of the array. */ | |
5398 | if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type))) | |
2ec59cf5 | 5399 | TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain; |
e945eb2d | 5400 | |
5401 | elt_type = TREE_TYPE (type); | |
5402 | TYPE_NEEDS_CONSTRUCTING (type) | |
5403 | = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type)); | |
5404 | TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type) | |
491e04ef | 5405 | = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type)); |
471086d6 | 5406 | } |
5407 | ||
5408 | /* Lay out the type now that we can get the real answer. */ | |
5409 | ||
5410 | layout_type (type); | |
5411 | ||
5412 | return value; | |
5413 | } | |
5414 | \f | |
5415 | /* Return zero if something is declared to be a member of type | |
5416 | CTYPE when in the context of CUR_TYPE. STRING is the error | |
5417 | message to print in that case. Otherwise, quietly return 1. */ | |
96624a9e | 5418 | |
471086d6 | 5419 | static int |
1b72315d | 5420 | member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags) |
471086d6 | 5421 | { |
5422 | if (ctype && ctype != cur_type) | |
5423 | { | |
017fafd4 | 5424 | if (flags == DTOR_FLAG) |
cf103c6c | 5425 | error ("destructor for alien class `%T' cannot be a member", |
a0ec9fa5 | 5426 | ctype); |
017fafd4 | 5427 | else |
cf103c6c | 5428 | error ("constructor for alien class `%T' cannot be a member", |
a0ec9fa5 | 5429 | ctype); |
471086d6 | 5430 | return 0; |
5431 | } | |
5432 | return 1; | |
5433 | } | |
5434 | \f | |
5435 | /* Subroutine of `grokdeclarator'. */ | |
5436 | ||
5437 | /* Generate errors possibly applicable for a given set of specifiers. | |
5438 | This is for ARM $7.1.2. */ | |
96624a9e | 5439 | |
471086d6 | 5440 | static void |
1b72315d | 5441 | bad_specifiers (tree object, |
5442 | const char* type, | |
5443 | int virtualp, | |
5444 | int quals, | |
23aecd7a | 5445 | int inlinep, |
1b72315d | 5446 | int friendp, |
23aecd7a | 5447 | int raises) |
471086d6 | 5448 | { |
5449 | if (virtualp) | |
cf103c6c | 5450 | error ("`%D' declared as a `virtual' %s", object, type); |
471086d6 | 5451 | if (inlinep) |
cf103c6c | 5452 | error ("`%D' declared as an `inline' %s", object, type); |
471086d6 | 5453 | if (quals) |
cf103c6c | 5454 | error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration", |
e581f478 | 5455 | object, type); |
471086d6 | 5456 | if (friendp) |
ab88d33b | 5457 | cp_error_at ("`%D' declared as a friend", object); |
a49facc5 | 5458 | if (raises |
5459 | && (TREE_CODE (object) == TYPE_DECL | |
5460 | || (!TYPE_PTRFN_P (TREE_TYPE (object)) | |
054e01a7 | 5461 | && !TYPE_REFFN_P (TREE_TYPE (object)) |
a49facc5 | 5462 | && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object))))) |
ab88d33b | 5463 | cp_error_at ("`%D' declared with an exception specification", object); |
471086d6 | 5464 | } |
5465 | ||
5466 | /* CTYPE is class type, or null if non-class. | |
5467 | TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE | |
5468 | or METHOD_TYPE. | |
5469 | DECLARATOR is the function's name. | |
7ef14399 | 5470 | PARMS is a chain of PARM_DECLs for the function. |
471086d6 | 5471 | VIRTUALP is truthvalue of whether the function is virtual or not. |
5472 | FLAGS are to be passed through to `grokclassfn'. | |
5473 | QUALS are qualifiers indicating whether the function is `const' | |
5474 | or `volatile'. | |
5475 | RAISES is a list of exceptions that this function can raise. | |
5476 | CHECK is 1 if we must find this method in CTYPE, 0 if we should | |
980877d7 | 5477 | not look, and -1 if we should not call `grokclassfn' at all. |
76c1ba40 | 5478 | |
e0d8778b | 5479 | Returns `NULL_TREE' if something goes wrong, after issuing |
76c1ba40 | 5480 | applicable error messages. */ |
96624a9e | 5481 | |
471086d6 | 5482 | static tree |
491e04ef | 5483 | grokfndecl (tree ctype, |
1b72315d | 5484 | tree type, |
5485 | tree declarator, | |
7ef14399 | 5486 | tree parms, |
1b72315d | 5487 | tree orig_declarator, |
5488 | int virtualp, | |
5489 | enum overload_flags flags, | |
2cfb6cde | 5490 | cp_cv_quals quals, |
1b72315d | 5491 | tree raises, |
491e04ef | 5492 | int check, |
5493 | int friendp, | |
5494 | int publicp, | |
5495 | int inlinep, | |
5496 | int funcdef_flag, | |
1b72315d | 5497 | int template_count, |
5498 | tree in_namespace) | |
471086d6 | 5499 | { |
83c4eacf | 5500 | tree decl; |
471086d6 | 5501 | int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE; |
8a5f292f | 5502 | int has_default_arg = 0; |
03db3ebd | 5503 | tree t; |
471086d6 | 5504 | |
471086d6 | 5505 | if (raises) |
01779b5f | 5506 | type = build_exception_variant (type, raises); |
f9670f72 | 5507 | |
471086d6 | 5508 | decl = build_lang_decl (FUNCTION_DECL, declarator, type); |
7ef14399 | 5509 | DECL_ARGUMENTS (decl) = parms; |
a109dc3b | 5510 | /* Propagate volatile out from type to decl. */ |
471086d6 | 5511 | if (TYPE_VOLATILE (type)) |
f69ecb3b | 5512 | TREE_THIS_VOLATILE (decl) = 1; |
471086d6 | 5513 | |
62be7b35 | 5514 | /* If this decl has namespace scope, set that up. */ |
8417823c | 5515 | if (in_namespace) |
ce82f1c3 | 5516 | set_decl_namespace (decl, in_namespace, friendp); |
f4ef27d5 | 5517 | else if (!ctype) |
62be7b35 | 5518 | DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace); |
8417823c | 5519 | |
16fd72fa | 5520 | /* `main' and builtins have implicit 'C' linkage. */ |
5521 | if ((MAIN_NAME_P (declarator) | |
5522 | || (IDENTIFIER_LENGTH (declarator) > 10 | |
5523 | && IDENTIFIER_POINTER (declarator)[0] == '_' | |
5524 | && IDENTIFIER_POINTER (declarator)[1] == '_' | |
5525 | && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0)) | |
5526 | && current_lang_name == lang_name_cplusplus | |
3ea58ecd | 5527 | && ctype == NULL_TREE |
62be7b35 | 5528 | /* NULL_TREE means global namespace. */ |
5529 | && DECL_CONTEXT (decl) == NULL_TREE) | |
4b1984f5 | 5530 | SET_DECL_LANGUAGE (decl, lang_c); |
16fd72fa | 5531 | |
471086d6 | 5532 | /* Should probably propagate const out from type to decl I bet (mrs). */ |
5533 | if (staticp) | |
5534 | { | |
5535 | DECL_STATIC_FUNCTION_P (decl) = 1; | |
5536 | DECL_CONTEXT (decl) = ctype; | |
471086d6 | 5537 | } |
5538 | ||
e4ce2dc4 | 5539 | if (ctype) |
9ba4048d | 5540 | DECL_CONTEXT (decl) = ctype; |
e4ce2dc4 | 5541 | |
16fd72fa | 5542 | if (ctype == NULL_TREE && DECL_MAIN_P (decl)) |
bb09dca5 | 5543 | { |
95b2ac55 | 5544 | if (processing_template_decl) |
76afd7f0 | 5545 | error ("cannot declare `::main' to be a template"); |
bb09dca5 | 5546 | if (inlinep) |
76afd7f0 | 5547 | error ("cannot declare `::main' to be inline"); |
78390ff9 | 5548 | if (!publicp) |
76afd7f0 | 5549 | error ("cannot declare `::main' to be static"); |
78390ff9 | 5550 | if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)), |
5551 | integer_type_node)) | |
5552 | error ("`main' must return `int'"); | |
bb09dca5 | 5553 | inlinep = 0; |
5554 | publicp = 1; | |
5555 | } | |
844e1a9a | 5556 | |
6cbb4197 | 5557 | /* Members of anonymous types and local classes have no linkage; make |
1112ccbc | 5558 | them internal. If a typedef is made later, this will be changed. */ |
83c4eacf | 5559 | if (ctype && (TYPE_ANONYMOUS_P (ctype) |
9ba4048d | 5560 | || decl_function_context (TYPE_MAIN_DECL (ctype)))) |
844e1a9a | 5561 | publicp = 0; |
5562 | ||
5563 | if (publicp) | |
5564 | { | |
5565 | /* [basic.link]: A name with no linkage (notably, the name of a class | |
5566 | or enumeration declared in a local scope) shall not be used to | |
5567 | declare an entity with linkage. | |
5568 | ||
bf594afa | 5569 | Only check this for public decls for now. See core 319, 389. */ |
caa6fdce | 5570 | t = no_linkage_check (TREE_TYPE (decl), |
5571 | /*relaxed_p=*/false); | |
844e1a9a | 5572 | if (t) |
5573 | { | |
83c4eacf | 5574 | if (TYPE_ANONYMOUS_P (t)) |
cbaacf5e | 5575 | { |
a2697ab6 | 5576 | if (DECL_EXTERN_C_P (decl)) |
cbaacf5e | 5577 | /* Allow this; it's pretty common in C. */; |
5578 | else | |
83c4eacf | 5579 | { |
cf103c6c | 5580 | pedwarn ("non-local function `%#D' uses anonymous type", |
83c4eacf | 5581 | decl); |
5582 | if (DECL_ORIGINAL_TYPE (TYPE_NAME (t))) | |
5583 | cp_pedwarn_at ("\ | |
5584 | `%#D' does not refer to the unqualified type, so it is not used for linkage", | |
5585 | TYPE_NAME (t)); | |
5586 | } | |
cbaacf5e | 5587 | } |
844e1a9a | 5588 | else |
cf103c6c | 5589 | pedwarn ("non-local function `%#D' uses local type `%T'", |
0762a377 | 5590 | decl, t); |
844e1a9a | 5591 | } |
5592 | } | |
5593 | ||
f69ecb3b | 5594 | TREE_PUBLIC (decl) = publicp; |
bb09dca5 | 5595 | if (! publicp) |
f69ecb3b | 5596 | { |
5597 | DECL_INTERFACE_KNOWN (decl) = 1; | |
5598 | DECL_NOT_REALLY_EXTERN (decl) = 1; | |
5599 | } | |
bb09dca5 | 5600 | |
10c08065 | 5601 | /* If the declaration was declared inline, mark it as such. */ |
bb09dca5 | 5602 | if (inlinep) |
10c08065 | 5603 | DECL_DECLARED_INLINE_P (decl) = 1; |
5604 | /* We inline functions that are explicitly declared inline, or, when | |
5605 | the user explicitly asks us to, all functions. */ | |
746149b7 | 5606 | if (DECL_DECLARED_INLINE_P (decl) |
5607 | || (flag_inline_trees == 2 && !DECL_INLINE (decl) && funcdef_flag)) | |
10c08065 | 5608 | DECL_INLINE (decl) = 1; |
471086d6 | 5609 | |
5610 | DECL_EXTERNAL (decl) = 1; | |
2cfb6cde | 5611 | if (quals && TREE_CODE (type) == FUNCTION_TYPE) |
471086d6 | 5612 | { |
2cfb6cde | 5613 | error ("%smember function `%D' cannot have cv-qualifier", |
5614 | (ctype ? "static " : "non-"), decl); | |
5615 | quals = TYPE_UNQUALIFIED; | |
471086d6 | 5616 | } |
5617 | ||
97cc4539 | 5618 | if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))) |
b7d1e8ea | 5619 | grok_op_properties (decl, friendp, /*complain=*/true); |
471086d6 | 5620 | |
9ba4048d | 5621 | if (ctype && decl_function_context (decl)) |
f69ecb3b | 5622 | DECL_NO_STATIC_CHAIN (decl) = 1; |
e4ce2dc4 | 5623 | |
03db3ebd | 5624 | for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t)) |
5625 | if (TREE_PURPOSE (t) | |
5626 | && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG) | |
5627 | { | |
8a5f292f | 5628 | has_default_arg = 1; |
03db3ebd | 5629 | break; |
5630 | } | |
5631 | ||
a16804f1 | 5632 | if (friendp |
5633 | && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR) | |
5634 | { | |
5635 | if (funcdef_flag) | |
cf103c6c | 5636 | error |
905d4035 | 5637 | ("defining explicit specialization `%D' in friend declaration", |
a16804f1 | 5638 | orig_declarator); |
5639 | else | |
5640 | { | |
178ecb0c | 5641 | tree fns = TREE_OPERAND (orig_declarator, 0); |
5642 | tree args = TREE_OPERAND (orig_declarator, 1); | |
20c01ba9 | 5643 | |
44d34baf | 5644 | if (PROCESSING_REAL_TEMPLATE_DECL_P ()) |
5645 | { | |
5646 | /* Something like `template <class T> friend void f<T>()'. */ | |
cf103c6c | 5647 | error ("invalid use of template-id `%D' in declaration of primary template", |
44d34baf | 5648 | orig_declarator); |
e0d8778b | 5649 | return NULL_TREE; |
44d34baf | 5650 | } |
5651 | ||
8a5f292f | 5652 | |
a16804f1 | 5653 | /* A friend declaration of the form friend void f<>(). Record |
5654 | the information in the TEMPLATE_ID_EXPR. */ | |
5655 | SET_DECL_IMPLICIT_INSTANTIATION (decl); | |
178ecb0c | 5656 | |
5657 | if (TREE_CODE (fns) == COMPONENT_REF) | |
5658 | { | |
5659 | /* Due to bison parser ickiness, we will have already looked | |
5660 | up an operator_name or PFUNCNAME within the current class | |
5661 | (see template_id in parse.y). If the current class contains | |
a109dc3b | 5662 | such a name, we'll get a COMPONENT_REF here. Undo that. */ |
20c01ba9 | 5663 | |
b4df430b | 5664 | gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0)) |
5665 | == current_class_type); | |
178ecb0c | 5666 | fns = TREE_OPERAND (fns, 1); |
5667 | } | |
b4df430b | 5668 | gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE |
5669 | || TREE_CODE (fns) == OVERLOAD); | |
178ecb0c | 5670 | DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE); |
8a5f292f | 5671 | |
5672 | if (has_default_arg) | |
5673 | { | |
cf103c6c | 5674 | error ("default arguments are not allowed in declaration of friend template specialization `%D'", |
8a5f292f | 5675 | decl); |
5676 | return NULL_TREE; | |
5677 | } | |
5678 | ||
5679 | if (inlinep) | |
5680 | { | |
cf103c6c | 5681 | error ("`inline' is not allowed in declaration of friend template specialization `%D'", |
8a5f292f | 5682 | decl); |
5683 | return NULL_TREE; | |
5684 | } | |
a16804f1 | 5685 | } |
f3110581 | 5686 | } |
b1cfe2be | 5687 | |
f13e7b2b | 5688 | if (funcdef_flag) |
5689 | /* Make the init_value nonzero so pushdecl knows this is not | |
5690 | tentative. error_mark_node is replaced later with the BLOCK. */ | |
5691 | DECL_INITIAL (decl) = error_mark_node; | |
5692 | ||
78fdeecc | 5693 | if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl)) |
90252716 | 5694 | TREE_NOTHROW (decl) = 1; |
5695 | ||
668ae905 | 5696 | /* Caller will do the rest of this. */ |
471086d6 | 5697 | if (check < 0) |
5698 | return decl; | |
5699 | ||
0a3b29ad | 5700 | if (flags == NO_SPECIAL && ctype && constructor_name_p (declarator, ctype)) |
3467e461 | 5701 | DECL_CONSTRUCTOR_P (decl) = 1; |
5702 | ||
5703 | /* Function gets the ugly name, field gets the nice one. This call | |
5704 | may change the type of the function (because of default | |
5705 | parameters)! */ | |
5706 | if (ctype != NULL_TREE) | |
5707 | grokclassfn (ctype, decl, flags, quals); | |
5708 | ||
5709 | decl = check_explicit_specialization (orig_declarator, decl, | |
5710 | template_count, | |
5711 | 2 * (funcdef_flag != 0) + | |
5712 | 4 * (friendp != 0)); | |
5713 | if (decl == error_mark_node) | |
5714 | return NULL_TREE; | |
64b4f183 | 5715 | |
3467e461 | 5716 | if (ctype != NULL_TREE |
5717 | && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl)) | |
5718 | && check) | |
471086d6 | 5719 | { |
3467e461 | 5720 | tree old_decl; |
471086d6 | 5721 | |
7bdfc61c | 5722 | old_decl = check_classfn (ctype, decl, |
0122f52b | 5723 | (processing_template_decl |
5724 | > template_class_depth (ctype)) | |
5725 | ? current_template_parms | |
5726 | : NULL_TREE); | |
471086d6 | 5727 | |
3467e461 | 5728 | if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL) |
5729 | /* Because grokfndecl is always supposed to return a | |
5730 | FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT | |
5731 | here. We depend on our callers to figure out that its | |
5732 | really a template that's being returned. */ | |
5733 | old_decl = DECL_TEMPLATE_RESULT (old_decl); | |
1d42585d | 5734 | |
3467e461 | 5735 | if (old_decl && DECL_STATIC_FUNCTION_P (old_decl) |
5736 | && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE) | |
7ef14399 | 5737 | /* Remove the `this' parm added by grokclassfn. |
5738 | XXX Isn't this done in start_function, too? */ | |
5739 | revert_static_member_fn (decl); | |
3467e461 | 5740 | if (old_decl && DECL_ARTIFICIAL (old_decl)) |
cf103c6c | 5741 | error ("definition of implicitly-declared `%D'", old_decl); |
471086d6 | 5742 | |
3467e461 | 5743 | if (old_decl) |
471086d6 | 5744 | { |
f12b8e1e | 5745 | tree ok; |
1cbda81f | 5746 | bool pop_p; |
66bf0ee5 | 5747 | |
3467e461 | 5748 | /* Since we've smashed OLD_DECL to its |
5749 | DECL_TEMPLATE_RESULT, we must do the same to DECL. */ | |
5750 | if (TREE_CODE (decl) == TEMPLATE_DECL) | |
5751 | decl = DECL_TEMPLATE_RESULT (decl); | |
5752 | ||
5753 | /* Attempt to merge the declarations. This can fail, in | |
6c0cc2cd | 5754 | the case of some invalid specialization declarations. */ |
1cbda81f | 5755 | pop_p = push_scope (ctype); |
66bf0ee5 | 5756 | ok = duplicate_decls (decl, old_decl); |
1cbda81f | 5757 | if (pop_p) |
5758 | pop_scope (ctype); | |
66bf0ee5 | 5759 | if (!ok) |
5760 | { | |
5761 | error ("no `%#D' member function declared in class `%T'", | |
5762 | decl, ctype); | |
5763 | return NULL_TREE; | |
5764 | } | |
3467e461 | 5765 | return old_decl; |
471086d6 | 5766 | } |
5767 | } | |
3467e461 | 5768 | |
5769 | if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl)) | |
5770 | return NULL_TREE; | |
5771 | ||
5772 | if (ctype == NULL_TREE || check) | |
5773 | return decl; | |
5774 | ||
5775 | if (virtualp) | |
4c481f71 | 5776 | DECL_VIRTUAL_P (decl) = 1; |
3467e461 | 5777 | |
471086d6 | 5778 | return decl; |
5779 | } | |
5780 | ||
caa6fdce | 5781 | /* DECL is a VAR_DECL for a static data member. Set flags to reflect |
5782 | the linkage that DECL will receive in the object file. */ | |
5783 | ||
5784 | static void | |
5785 | set_linkage_for_static_data_member (tree decl) | |
5786 | { | |
5787 | /* A static data member always has static storage duration and | |
5788 | external linkage. Note that static data members are forbidden in | |
5789 | local classes -- the only situation in which a class has | |
5790 | non-external linkage. */ | |
5791 | TREE_PUBLIC (decl) = 1; | |
5792 | TREE_STATIC (decl) = 1; | |
5793 | /* For non-template classes, static data members are always put | |
5794 | out in exactly those files where they are defined, just as | |
4a44ba29 | 5795 | with ordinary namespace-scope variables. */ |
caa6fdce | 5796 | if (!processing_template_decl) |
5797 | DECL_INTERFACE_KNOWN (decl) = 1; | |
5798 | } | |
5799 | ||
491e04ef | 5800 | /* Create a VAR_DECL named NAME with the indicated TYPE. |
3645386f | 5801 | |
5802 | If SCOPE is non-NULL, it is the class type or namespace containing | |
5803 | the variable. If SCOPE is NULL, the variable should is created in | |
5804 | the innermost enclosings scope. */ | |
5805 | ||
471086d6 | 5806 | static tree |
1b72315d | 5807 | grokvardecl (tree type, |
5808 | tree name, | |
6493c502 | 5809 | const cp_decl_specifier_seq *declspecs, |
1b72315d | 5810 | int initialized, |
5811 | int constp, | |
5812 | tree scope) | |
471086d6 | 5813 | { |
5814 | tree decl; | |
eaf26d83 | 5815 | |
b4df430b | 5816 | gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE); |
3645386f | 5817 | |
3645386f | 5818 | /* Compute the scope in which to place the variable. */ |
5819 | if (!scope) | |
471086d6 | 5820 | { |
3645386f | 5821 | /* An explicit "extern" specifier indicates a namespace-scope |
5822 | variable. */ | |
4b9b2871 | 5823 | if (declspecs->storage_class == sc_extern) |
3645386f | 5824 | scope = current_namespace; |
5825 | else if (!at_function_scope_p ()) | |
5826 | { | |
5827 | scope = current_scope (); | |
5828 | if (!scope) | |
5829 | scope = current_namespace; | |
5830 | } | |
5831 | } | |
5832 | ||
5833 | if (scope | |
5834 | && (/* If the variable is a namespace-scope variable declared in a | |
5835 | template, we need DECL_LANG_SPECIFIC. */ | |
5836 | (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl) | |
5837 | /* Similarly for namespace-scope variables with language linkage | |
5838 | other than C++. */ | |
491e04ef | 5839 | || (TREE_CODE (scope) == NAMESPACE_DECL |
3645386f | 5840 | && current_lang_name != lang_name_cplusplus) |
5841 | /* Similarly for static data members. */ | |
5842 | || TYPE_P (scope))) | |
5843 | decl = build_lang_decl (VAR_DECL, name, type); | |
471086d6 | 5844 | else |
3645386f | 5845 | decl = build_decl (VAR_DECL, name, type); |
62be7b35 | 5846 | |
3645386f | 5847 | if (scope && TREE_CODE (scope) == NAMESPACE_DECL) |
5848 | set_decl_namespace (decl, scope, 0); | |
5849 | else | |
5850 | DECL_CONTEXT (decl) = scope; | |
a74e8896 | 5851 | |
4b9b2871 | 5852 | if (declspecs->storage_class == sc_extern) |
471086d6 | 5853 | { |
5854 | DECL_THIS_EXTERN (decl) = 1; | |
5855 | DECL_EXTERNAL (decl) = !initialized; | |
5856 | } | |
5857 | ||
00d2b1b9 | 5858 | if (DECL_CLASS_SCOPE_P (decl)) |
471086d6 | 5859 | { |
caa6fdce | 5860 | set_linkage_for_static_data_member (decl); |
5861 | /* This function is only called with out-of-class definitions. */ | |
822f06da | 5862 | DECL_EXTERNAL (decl) = 0; |
471086d6 | 5863 | } |
5864 | /* At top level, either `static' or no s.c. makes a definition | |
5865 | (perhaps tentative), and absence of `static' makes it public. */ | |
d0622bdf | 5866 | else if (toplevel_bindings_p ()) |
471086d6 | 5867 | { |
4b9b2871 | 5868 | TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static |
02b4641e | 5869 | && (DECL_THIS_EXTERN (decl) || ! constp)); |
471086d6 | 5870 | TREE_STATIC (decl) = ! DECL_EXTERNAL (decl); |
5871 | } | |
5872 | /* Not at top level, only `static' makes a static definition. */ | |
5873 | else | |
5874 | { | |
4b9b2871 | 5875 | TREE_STATIC (decl) = declspecs->storage_class == sc_static; |
471086d6 | 5876 | TREE_PUBLIC (decl) = DECL_EXTERNAL (decl); |
5877 | } | |
844e1a9a | 5878 | |
4b9b2871 | 5879 | if (declspecs->specs[(int)ds_thread]) |
e396cd54 | 5880 | { |
5881 | if (targetm.have_tls) | |
5882 | DECL_THREAD_LOCAL (decl) = 1; | |
5883 | else | |
5884 | /* A mere warning is sure to result in improper semantics | |
5885 | at runtime. Don't bother to allow this to compile. */ | |
5886 | error ("thread-local storage not supported for this target"); | |
5887 | } | |
5888 | ||
844e1a9a | 5889 | if (TREE_PUBLIC (decl)) |
5890 | { | |
5891 | /* [basic.link]: A name with no linkage (notably, the name of a class | |
5892 | or enumeration declared in a local scope) shall not be used to | |
5893 | declare an entity with linkage. | |
5894 | ||
5895 | Only check this for public decls for now. */ | |
caa6fdce | 5896 | tree t = no_linkage_check (TREE_TYPE (decl), |
5897 | /*relaxed_p=*/false); | |
844e1a9a | 5898 | if (t) |
5899 | { | |
83c4eacf | 5900 | if (TYPE_ANONYMOUS_P (t)) |
1112ccbc | 5901 | { |
5902 | if (DECL_EXTERN_C_P (decl)) | |
5903 | /* Allow this; it's pretty common in C. */; | |
5904 | else | |
5905 | { | |
5906 | pedwarn ("non-local variable `%#D' uses anonymous type", | |
5907 | decl); | |
5908 | if (DECL_ORIGINAL_TYPE (TYPE_NAME (t))) | |
5909 | cp_pedwarn_at ("\ | |
5910 | `%#D' does not refer to the unqualified type, so it is not used for linkage", | |
5911 | TYPE_NAME (t)); | |
5912 | } | |
5913 | } | |
844e1a9a | 5914 | else |
cf103c6c | 5915 | pedwarn ("non-local variable `%#D' uses local type `%T'", |
844e1a9a | 5916 | decl, t); |
5917 | } | |
5918 | } | |
5919 | ||
471086d6 | 5920 | return decl; |
5921 | } | |
5922 | ||
2b77484d | 5923 | /* Create and return a canonical pointer to member function type, for |
5924 | TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */ | |
471086d6 | 5925 | |
5926 | tree | |
1b72315d | 5927 | build_ptrmemfunc_type (tree type) |
471086d6 | 5928 | { |
805e22b2 | 5929 | tree field, fields; |
471086d6 | 5930 | tree t; |
3970dedc | 5931 | tree unqualified_variant = NULL_TREE; |
471086d6 | 5932 | |
594f37d2 | 5933 | if (type == error_mark_node) |
5934 | return type; | |
20c01ba9 | 5935 | |
471086d6 | 5936 | /* If a canonical type already exists for this type, use it. We use |
5937 | this method instead of type_hash_canon, because it only does a | |
5938 | simple equality check on the list of field members. */ | |
5939 | ||
5940 | if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type))) | |
5941 | return t; | |
5942 | ||
3970dedc | 5943 | /* Make sure that we always have the unqualified pointer-to-member |
5944 | type first. */ | |
3119c950 | 5945 | if (cp_type_quals (type) != TYPE_UNQUALIFIED) |
980877d7 | 5946 | unqualified_variant |
3970dedc | 5947 | = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type)); |
5948 | ||
9972f65e | 5949 | t = make_aggr_type (RECORD_TYPE); |
a6460bf1 | 5950 | xref_basetypes (t, NULL_TREE); |
491e04ef | 5951 | |
8417823c | 5952 | /* Let the front-end know this is a pointer to member function... */ |
c25194fd | 5953 | TYPE_PTRMEMFUNC_FLAG (t) = 1; |
8417823c | 5954 | /* ... and not really an aggregate. */ |
e4e283ec | 5955 | SET_IS_AGGR_TYPE (t, 0); |
471086d6 | 5956 | |
805e22b2 | 5957 | field = build_decl (FIELD_DECL, pfn_identifier, type); |
5958 | fields = field; | |
491e04ef | 5959 | |
805e22b2 | 5960 | field = build_decl (FIELD_DECL, delta_identifier, delta_type_node); |
5961 | TREE_CHAIN (field) = fields; | |
5962 | fields = field; | |
491e04ef | 5963 | |
805e22b2 | 5964 | finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node); |
471086d6 | 5965 | |
471086d6 | 5966 | /* Zap out the name so that the back-end will give us the debugging |
5967 | information for this anonymous RECORD_TYPE. */ | |
5968 | TYPE_NAME (t) = NULL_TREE; | |
5969 | ||
3970dedc | 5970 | /* If this is not the unqualified form of this pointer-to-member |
5971 | type, set the TYPE_MAIN_VARIANT for this type to be the | |
5972 | unqualified type. Since they are actually RECORD_TYPEs that are | |
5973 | not variants of each other, we must do this manually. */ | |
3119c950 | 5974 | if (cp_type_quals (type) != TYPE_UNQUALIFIED) |
3970dedc | 5975 | { |
3119c950 | 5976 | t = build_qualified_type (t, cp_type_quals (type)); |
3970dedc | 5977 | TYPE_MAIN_VARIANT (t) = unqualified_variant; |
5978 | TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant); | |
5979 | TYPE_NEXT_VARIANT (unqualified_variant) = t; | |
5980 | } | |
5981 | ||
5982 | /* Cache this pointer-to-member type so that we can find it again | |
5983 | later. */ | |
471086d6 | 5984 | TYPE_SET_PTRMEMFUNC_TYPE (type, t); |
5985 | ||
471086d6 | 5986 | return t; |
5987 | } | |
5988 | ||
3645386f | 5989 | /* Create and return a pointer to data member type. */ |
5990 | ||
5991 | tree | |
5992 | build_ptrmem_type (tree class_type, tree member_type) | |
5993 | { | |
1bc16cab | 5994 | if (TREE_CODE (member_type) == METHOD_TYPE) |
5995 | { | |
5996 | tree arg_types; | |
5997 | ||
5998 | arg_types = TYPE_ARG_TYPES (member_type); | |
491e04ef | 5999 | class_type = (cp_build_qualified_type |
1bc16cab | 6000 | (class_type, |
6001 | cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types))))); | |
491e04ef | 6002 | member_type |
6003 | = build_method_type_directly (class_type, | |
5bfb0742 | 6004 | TREE_TYPE (member_type), |
6005 | TREE_CHAIN (arg_types)); | |
1bc16cab | 6006 | return build_ptrmemfunc_type (build_pointer_type (member_type)); |
6007 | } | |
6008 | else | |
6009 | { | |
b4df430b | 6010 | gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE); |
1bc16cab | 6011 | return build_offset_type (class_type, member_type); |
6012 | } | |
3645386f | 6013 | } |
6014 | ||
d8f6e09c | 6015 | /* DECL is a VAR_DECL defined in-class, whose TYPE is also given. |
6016 | Check to see that the definition is valid. Issue appropriate error | |
6017 | messages. Return 1 if the definition is particularly bad, or 0 | |
6018 | otherwise. */ | |
6019 | ||
6020 | int | |
1b72315d | 6021 | check_static_variable_definition (tree decl, tree type) |
d8f6e09c | 6022 | { |
6023 | /* Motion 10 at San Diego: If a static const integral data member is | |
6024 | initialized with an integral constant expression, the initializer | |
6025 | may appear either in the declaration (within the class), or in | |
6026 | the definition, but not both. If it appears in the class, the | |
6027 | member is a member constant. The file-scope definition is always | |
6028 | required. */ | |
0fe26a86 | 6029 | if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE) |
d8f6e09c | 6030 | { |
cf103c6c | 6031 | error ("invalid in-class initialization of static data member of non-integral type `%T'", |
0fe26a86 | 6032 | type); |
d8f6e09c | 6033 | /* If we just return the declaration, crashes will sometimes |
0f3ccaa3 | 6034 | occur. We therefore return void_type_node, as if this were a |
d8f6e09c | 6035 | friend declaration, to cause callers to completely ignore |
6036 | this declaration. */ | |
6037 | return 1; | |
6038 | } | |
6039 | else if (!CP_TYPE_CONST_P (type)) | |
cf103c6c | 6040 | error ("ISO C++ forbids in-class initialization of non-const static member `%D'", |
d8f6e09c | 6041 | decl); |
6042 | else if (pedantic && !INTEGRAL_TYPE_P (type)) | |
cf103c6c | 6043 | pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type); |
d8f6e09c | 6044 | |
6045 | return 0; | |
6046 | } | |
6047 | ||
b1e0749b | 6048 | /* Given the SIZE (i.e., number of elements) in an array, compute an |
6049 | appropriate index type for the array. If non-NULL, NAME is the | |
6050 | name of the thing being declared. */ | |
6051 | ||
949d8cc7 | 6052 | tree |
1b72315d | 6053 | compute_array_index_type (tree name, tree size) |
b1e0749b | 6054 | { |
1cd6548d | 6055 | tree type = TREE_TYPE (size); |
b1e0749b | 6056 | tree itype; |
6057 | ||
1cd6548d | 6058 | /* The array bound must be an integer type. */ |
6059 | if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type)) | |
b1e0749b | 6060 | { |
1cd6548d | 6061 | if (name) |
6062 | error ("size of array `%D' has non-integral type `%T'", name, type); | |
6063 | else | |
6064 | error ("size of array has non-integral type `%T'", type); | |
6065 | size = integer_one_node; | |
6066 | type = TREE_TYPE (size); | |
b1e0749b | 6067 | } |
6068 | ||
1cd6548d | 6069 | if (abi_version_at_least (2) |
6070 | /* We should only handle value dependent expressions specially. */ | |
6071 | ? value_dependent_expression_p (size) | |
6072 | /* But for abi-1, we handled all instances in templates. This | |
6073 | effects the manglings produced. */ | |
6074 | : processing_template_decl) | |
6075 | return build_index_type (build_min (MINUS_EXPR, sizetype, | |
6076 | size, integer_one_node)); | |
6077 | ||
a109dc3b | 6078 | /* The size might be the result of a cast. */ |
db4f24e2 | 6079 | STRIP_TYPE_NOPS (size); |
6080 | ||
6081 | /* It might be a const variable or enumeration constant. */ | |
6082 | size = decl_constant_value (size); | |
6083 | ||
b1e0749b | 6084 | /* Normally, the array-bound will be a constant. */ |
f9b9bf39 | 6085 | if (TREE_CODE (size) == INTEGER_CST) |
b1e0749b | 6086 | { |
6087 | /* Check to see if the array bound overflowed. Make that an | |
6088 | error, no matter how generous we're being. */ | |
6089 | int old_flag_pedantic_errors = flag_pedantic_errors; | |
6090 | int old_pedantic = pedantic; | |
6091 | pedantic = flag_pedantic_errors = 1; | |
6092 | constant_expression_warning (size); | |
6093 | pedantic = old_pedantic; | |
6094 | flag_pedantic_errors = old_flag_pedantic_errors; | |
6095 | ||
6096 | /* An array must have a positive number of elements. */ | |
6097 | if (INT_CST_LT (size, integer_zero_node)) | |
6098 | { | |
32997f84 | 6099 | if (name) |
cf103c6c | 6100 | error ("size of array `%D' is negative", name); |
32997f84 | 6101 | else |
cf103c6c | 6102 | error ("size of array is negative"); |
b1e0749b | 6103 | size = integer_one_node; |
6104 | } | |
8f034d15 | 6105 | /* As an extension we allow zero-sized arrays. We always allow |
6106 | them in system headers because glibc uses them. */ | |
b1e0749b | 6107 | else if (integer_zerop (size) && pedantic && !in_system_header) |
32997f84 | 6108 | { |
6109 | if (name) | |
cf103c6c | 6110 | pedwarn ("ISO C++ forbids zero-size array `%D'", name); |
32997f84 | 6111 | else |
cf103c6c | 6112 | pedwarn ("ISO C++ forbids zero-size array"); |
32997f84 | 6113 | } |
b1e0749b | 6114 | } |
f9b9bf39 | 6115 | else if (TREE_CONSTANT (size)) |
6116 | { | |
6117 | /* `(int) &fn' is not a valid array bound. */ | |
6118 | if (name) | |
cf103c6c | 6119 | error ("size of array `%D' is not an integral constant-expression", |
f9b9bf39 | 6120 | name); |
6121 | else | |
cf103c6c | 6122 | error ("size of array is not an integral constant-expression"); |
f9b9bf39 | 6123 | } |
1cd6548d | 6124 | else if (pedantic) |
6125 | { | |
6126 | if (name) | |
6127 | pedwarn ("ISO C++ forbids variable-size array `%D'", name); | |
6128 | else | |
6129 | pedwarn ("ISO C++ forbids variable-size array"); | |
6130 | } | |
b1e0749b | 6131 | |
1cd6548d | 6132 | if (processing_template_decl && !TREE_CONSTANT (size)) |
6133 | /* A variable sized array. */ | |
6134 | itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node); | |
6135 | else | |
b1e0749b | 6136 | { |
1cd6548d | 6137 | /* Compute the index of the largest element in the array. It is |
6138 | one less than the number of elements in the array. */ | |
6139 | itype | |
6140 | = fold (cp_build_binary_op (MINUS_EXPR, | |
6141 | cp_convert (ssizetype, size), | |
6142 | cp_convert (ssizetype, integer_one_node))); | |
6143 | if (!TREE_CONSTANT (itype)) | |
331bc0ad | 6144 | /* A variable sized array. */ |
1cd6548d | 6145 | itype = variable_size (itype); |
6146 | /* Make sure that there was no overflow when creating to a signed | |
6147 | index type. (For example, on a 32-bit machine, an array with | |
6148 | size 2^32 - 1 is too big.) */ | |
6149 | else if (TREE_OVERFLOW (itype)) | |
b1e0749b | 6150 | { |
1cd6548d | 6151 | error ("overflow in array dimension"); |
6152 | TREE_OVERFLOW (itype) = 0; | |
b1e0749b | 6153 | } |
b1e0749b | 6154 | } |
980877d7 | 6155 | |
b1e0749b | 6156 | /* Create and return the appropriate index type. */ |
6157 | return build_index_type (itype); | |
6158 | } | |
6159 | ||
0a3b29ad | 6160 | /* Returns the scope (if any) in which the entity declared by |
6161 | DECLARATOR will be located. If the entity was declared with an | |
6162 | unqualified name, NULL_TREE is returned. */ | |
6163 | ||
6164 | tree | |
3046c0a3 | 6165 | get_scope_of_declarator (const cp_declarator *declarator) |
0a3b29ad | 6166 | { |
3046c0a3 | 6167 | while (declarator && declarator->kind != cdk_id) |
6168 | declarator = declarator->declarator; | |
6169 | ||
6170 | /* If the declarator-id is a SCOPE_REF, the scope in which the | |
6171 | declaration occurs is the first operand. */ | |
6172 | if (declarator | |
6173 | && declarator->u.id.name | |
6174 | && TREE_CODE (declarator->u.id.name) == SCOPE_REF) | |
6175 | return TREE_OPERAND (declarator->u.id.name, 0); | |
6176 | ||
4a44ba29 | 6177 | /* Otherwise, the declarator is not a qualified name; the entity will |
3046c0a3 | 6178 | be declared in the current scope. */ |
6179 | return NULL_TREE; | |
0a3b29ad | 6180 | } |
6181 | ||
b1e0749b | 6182 | /* Returns an ARRAY_TYPE for an array with SIZE elements of the |
6183 | indicated TYPE. If non-NULL, NAME is the NAME of the declaration | |
6184 | with this type. */ | |
6185 | ||
6186 | static tree | |
1b72315d | 6187 | create_array_type_for_decl (tree name, tree type, tree size) |
b1e0749b | 6188 | { |
6189 | tree itype = NULL_TREE; | |
6190 | const char* error_msg; | |
6191 | ||
6192 | /* If things have already gone awry, bail now. */ | |
6193 | if (type == error_mark_node || size == error_mark_node) | |
6194 | return error_mark_node; | |
6195 | ||
6196 | /* Assume that everything will go OK. */ | |
6197 | error_msg = NULL; | |
6198 | ||
6199 | /* There are some types which cannot be array elements. */ | |
6200 | switch (TREE_CODE (type)) | |
6201 | { | |
6202 | case VOID_TYPE: | |
6203 | error_msg = "array of void"; | |
6204 | break; | |
6205 | ||
6206 | case FUNCTION_TYPE: | |
6207 | error_msg = "array of functions"; | |
6208 | break; | |
6209 | ||
6210 | case REFERENCE_TYPE: | |
6211 | error_msg = "array of references"; | |
6212 | break; | |
6213 | ||
b1e0749b | 6214 | case METHOD_TYPE: |
6215 | error_msg = "array of function members"; | |
6216 | break; | |
6217 | ||
6218 | default: | |
6219 | break; | |
6220 | } | |
6221 | ||
6222 | /* If something went wrong, issue an error-message and return. */ | |
6223 | if (error_msg) | |
6224 | { | |
6225 | if (name) | |
cf103c6c | 6226 | error ("declaration of `%D' as %s", name, error_msg); |
b1e0749b | 6227 | else |
cf103c6c | 6228 | error ("creating %s", error_msg); |
b1e0749b | 6229 | |
6230 | return error_mark_node; | |
6231 | } | |
6232 | ||
6233 | /* [dcl.array] | |
980877d7 | 6234 | |
b1e0749b | 6235 | The constant expressions that specify the bounds of the arrays |
6236 | can be omitted only for the first member of the sequence. */ | |
6237 | if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)) | |
6238 | { | |
80ca7112 | 6239 | if (name) |
cf103c6c | 6240 | error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first", |
80ca7112 | 6241 | name); |
6242 | else | |
cf103c6c | 6243 | error ("multidimensional array must have bounds for all dimensions except the first"); |
b1e0749b | 6244 | |
6245 | return error_mark_node; | |
6246 | } | |
6247 | ||
6248 | /* Figure out the index type for the array. */ | |
6249 | if (size) | |
6250 | itype = compute_array_index_type (name, size); | |
6251 | ||
d97a7640 | 6252 | /* [dcl.array] |
6253 | T is called the array element type; this type shall not be [...] an | |
6254 | abstract class type. */ | |
6255 | abstract_virtuals_error (name, type); | |
6256 | ||
b1e0749b | 6257 | return build_cplus_array_type (type, itype); |
6258 | } | |
6259 | ||
bb855ff9 | 6260 | /* Check that it's OK to declare a function with the indicated TYPE. |
6261 | SFK indicates the kind of special function (if any) that this | |
606b494c | 6262 | function is. OPTYPE is the type given in a conversion operator |
853b7640 | 6263 | declaration, or the class type for a constructor/destructor. |
6264 | Returns the actual return type of the function; that | |
bb855ff9 | 6265 | may be different than TYPE if an error occurs, or for certain |
6266 | special functions. */ | |
6267 | ||
6268 | static tree | |
1b72315d | 6269 | check_special_function_return_type (special_function_kind sfk, |
6270 | tree type, | |
6271 | tree optype) | |
bb855ff9 | 6272 | { |
6273 | switch (sfk) | |
6274 | { | |
6275 | case sfk_constructor: | |
6276 | if (type) | |
cf103c6c | 6277 | error ("return type specification for constructor invalid"); |
3c3beda6 | 6278 | |
853b7640 | 6279 | if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype)) |
6280 | type = build_pointer_type (optype); | |
6281 | else | |
6282 | type = void_type_node; | |
bb855ff9 | 6283 | break; |
6284 | ||
6285 | case sfk_destructor: | |
6286 | if (type) | |
cf103c6c | 6287 | error ("return type specification for destructor invalid"); |
853b7640 | 6288 | /* We can't use the proper return type here because we run into |
4a44ba29 | 6289 | problems with ambiguous bases and covariant returns. |
853b7640 | 6290 | Java classes are left unchanged because (void *) isn't a valid |
6291 | Java type, and we don't want to change the Java ABI. */ | |
6292 | if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype)) | |
6293 | type = build_pointer_type (void_type_node); | |
6294 | else | |
6295 | type = void_type_node; | |
bb855ff9 | 6296 | break; |
6297 | ||
6298 | case sfk_conversion: | |
6299 | if (type && !same_type_p (type, optype)) | |
cf103c6c | 6300 | error ("operator `%T' declared to return `%T'", optype, type); |
bb855ff9 | 6301 | else if (type) |
cf103c6c | 6302 | pedwarn ("return type specified for `operator %T'", optype); |
bb855ff9 | 6303 | type = optype; |
6304 | break; | |
6305 | ||
6306 | default: | |
092b1d6f | 6307 | gcc_unreachable (); |
bb855ff9 | 6308 | } |
6309 | ||
6310 | return type; | |
6311 | } | |
6312 | ||
0a3b29ad | 6313 | /* Given declspecs and a declarator (abstract or otherwise), determine |
6314 | the name and type of the object declared and construct a DECL node | |
6315 | for it. | |
471086d6 | 6316 | |
6317 | DECLSPECS is a chain of tree_list nodes whose value fields | |
6318 | are the storage classes and type specifiers. | |
6319 | ||
6320 | DECL_CONTEXT says which syntactic context this declaration is in: | |
6321 | NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL. | |
6322 | FUNCDEF for a function definition. Like NORMAL but a few different | |
6323 | error messages in each case. Return value may be zero meaning | |
6324 | this definition is too screwy to try to parse. | |
6325 | MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to | |
6326 | handle member functions (which have FIELD context). | |
6327 | Return value may be zero meaning this definition is too screwy to | |
6328 | try to parse. | |
6329 | PARM for a parameter declaration (either within a function prototype | |
6330 | or before a function body). Make a PARM_DECL, or return void_type_node. | |
c25194fd | 6331 | CATCHPARM for a parameter declaration before a catch clause. |
471086d6 | 6332 | TYPENAME if for a typename (in a cast or sizeof). |
6333 | Don't make a DECL node; just return the ..._TYPE node. | |
6334 | FIELD for a struct or union field; make a FIELD_DECL. | |
6335 | BITFIELD for a field with specified width. | |
6336 | INITIALIZED is 1 if the decl has an initializer. | |
6337 | ||
e3c541f0 | 6338 | ATTRLIST is a pointer to the list of attributes, which may be NULL |
6339 | if there are none; *ATTRLIST may be modified if attributes from inside | |
6340 | the declarator should be applied to the declaration. | |
d8f6e09c | 6341 | |
0a3b29ad | 6342 | When this function is called, scoping variables (such as |
6343 | CURRENT_CLASS_TYPE) should reflect the scope in which the | |
6344 | declaration occurs, not the scope in which the new declaration will | |
6345 | be placed. For example, on: | |
471086d6 | 6346 | |
0a3b29ad | 6347 | void S::f() { ... } |
471086d6 | 6348 | |
0a3b29ad | 6349 | when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE |
6350 | should not be `S'. */ | |
471086d6 | 6351 | |
471086d6 | 6352 | tree |
3046c0a3 | 6353 | grokdeclarator (const cp_declarator *declarator, |
6493c502 | 6354 | const cp_decl_specifier_seq *declspecs, |
1b72315d | 6355 | enum decl_context decl_context, |
6356 | int initialized, | |
6357 | tree* attrlist) | |
471086d6 | 6358 | { |
471086d6 | 6359 | tree type = NULL_TREE; |
6360 | int longlong = 0; | |
3e04bd45 | 6361 | int type_quals; |
c25194fd | 6362 | int virtualp, explicitp, friendp, inlinep, staticp; |
471086d6 | 6363 | int explicit_int = 0; |
6364 | int explicit_char = 0; | |
c4a8ac95 | 6365 | int defaulted_int = 0; |
6debb1d0 | 6366 | tree dependant_name = NULL_TREE; |
491e04ef | 6367 | |
471086d6 | 6368 | tree typedef_decl = NULL_TREE; |
3046c0a3 | 6369 | const char *name = NULL; |
471086d6 | 6370 | tree typedef_type = NULL_TREE; |
6371 | int funcdef_flag = 0; | |
3046c0a3 | 6372 | cp_declarator_kind innermost_code = cdk_error; |
471086d6 | 6373 | int bitfield = 0; |
7d85c040 | 6374 | #if 0 |
6375 | /* See the code below that used this. */ | |
e3c541f0 | 6376 | tree decl_attr = NULL_TREE; |
7d85c040 | 6377 | #endif |
471086d6 | 6378 | |
6379 | /* Keep track of what sort of function is being processed | |
6380 | so that we can warn about default return values, or explicit | |
6381 | return values which do not match prescribed defaults. */ | |
bb855ff9 | 6382 | special_function_kind sfk = sfk_none; |
471086d6 | 6383 | |
6384 | tree dname = NULL_TREE; | |
471086d6 | 6385 | tree ctor_return_type = NULL_TREE; |
6386 | enum overload_flags flags = NO_SPECIAL; | |
2cfb6cde | 6387 | cp_cv_quals quals = TYPE_UNQUALIFIED; |
f9670f72 | 6388 | tree raises = NULL_TREE; |
b1cfe2be | 6389 | int template_count = 0; |
e3c541f0 | 6390 | tree returned_attrs = NULL_TREE; |
7ef14399 | 6391 | tree parms = NULL_TREE; |
3046c0a3 | 6392 | const cp_declarator *id_declarator; |
6393 | /* The unqualified name of the declarator; either an | |
6394 | IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */ | |
6395 | tree unqualified_id; | |
6396 | /* The class type, if any, in which this entity is located, | |
6397 | or NULL_TREE if none. Note that this value may be different from | |
6398 | the current class type; for example if an attempt is made to declare | |
6399 | "A::f" inside "B", this value will be "A". */ | |
6400 | tree ctype = current_class_type; | |
6401 | /* The NAMESPACE_DECL for the namespace in which this entity is | |
6402 | located. If an unqualified name is used to declare the entity, | |
6403 | this value will be NULL_TREE, even if the entity is located at | |
491e04ef | 6404 | namespace scope. */ |
3046c0a3 | 6405 | tree in_namespace = NULL_TREE; |
4b9b2871 | 6406 | cp_decl_spec ds; |
6493c502 | 6407 | cp_storage_class storage_class; |
6408 | bool unsigned_p, signed_p, short_p, long_p, thread_p; | |
6409 | ||
6410 | signed_p = declspecs->specs[(int)ds_signed]; | |
6411 | unsigned_p = declspecs->specs[(int)ds_unsigned]; | |
6412 | short_p = declspecs->specs[(int)ds_short]; | |
6413 | long_p = declspecs->specs[(int)ds_long]; | |
6414 | thread_p = declspecs->specs[(int)ds_thread]; | |
471086d6 | 6415 | |
471086d6 | 6416 | if (decl_context == FUNCDEF) |
6417 | funcdef_flag = 1, decl_context = NORMAL; | |
6418 | else if (decl_context == MEMFUNCDEF) | |
6419 | funcdef_flag = -1, decl_context = FIELD; | |
6420 | else if (decl_context == BITFIELD) | |
6421 | bitfield = 1, decl_context = FIELD; | |
6422 | ||
471086d6 | 6423 | /* Look inside a declarator for the name being declared |
6424 | and get it as a string, for an error message. */ | |
491e04ef | 6425 | for (id_declarator = declarator; |
6426 | id_declarator; | |
3046c0a3 | 6427 | id_declarator = id_declarator->declarator) |
6428 | { | |
6429 | if (id_declarator->kind != cdk_id) | |
6430 | innermost_code = id_declarator->kind; | |
471086d6 | 6431 | |
3046c0a3 | 6432 | switch (id_declarator->kind) |
6433 | { | |
6434 | case cdk_function: | |
6435 | if (id_declarator->declarator | |
6436 | && id_declarator->declarator->kind == cdk_id) | |
471086d6 | 6437 | { |
3046c0a3 | 6438 | sfk = id_declarator->declarator->u.id.sfk; |
6439 | if (sfk == sfk_destructor) | |
6440 | flags = DTOR_FLAG; | |
ac9386a0 | 6441 | } |
3046c0a3 | 6442 | break; |
652e1a2d | 6443 | |
3046c0a3 | 6444 | case cdk_id: |
6445 | { | |
6446 | tree decl = id_declarator->u.id.name; | |
6447 | if (!decl) | |
6448 | break; | |
6449 | if (TREE_CODE (decl) == SCOPE_REF) | |
471086d6 | 6450 | { |
3046c0a3 | 6451 | tree qualifying_scope = TREE_OPERAND (decl, 0); |
fb871e92 | 6452 | |
3046c0a3 | 6453 | /* It is valid to write: |
0a3b29ad | 6454 | |
6455 | class C { void f(); }; | |
6456 | typedef C D; | |
6457 | void D::f(); | |
6458 | ||
6459 | The standard is not clear about whether `typedef const C D' is | |
6460 | legal; as of 2002-09-15 the committee is considering | |
6461 | that question. EDG 3.0 allows that syntax. | |
6462 | Therefore, we do as well. */ | |
3046c0a3 | 6463 | if (qualifying_scope && TYPE_P (qualifying_scope)) |
6464 | { | |
491e04ef | 6465 | ctype = TYPE_MAIN_VARIANT (qualifying_scope); |
3046c0a3 | 6466 | if (innermost_code != cdk_function |
6467 | && current_class_type | |
491e04ef | 6468 | && !UNIQUELY_DERIVED_FROM_P (ctype, |
3046c0a3 | 6469 | current_class_type)) |
6470 | { | |
6471 | error ("type `%T' is not derived from type `%T'", | |
6472 | ctype, current_class_type); | |
6473 | ctype = NULL_TREE; | |
6474 | } | |
491e04ef | 6475 | TREE_OPERAND (decl, 0) = ctype; |
3046c0a3 | 6476 | } |
6477 | else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL) | |
6478 | in_namespace = qualifying_scope; | |
6479 | decl = TREE_OPERAND (decl, 1); | |
6480 | } | |
6481 | if (TREE_CODE (decl) == BASELINK) | |
6482 | decl = BASELINK_FUNCTIONS (decl); | |
d92cdb26 | 6483 | if (decl == error_mark_node) |
6484 | return error_mark_node; | |
3046c0a3 | 6485 | switch (TREE_CODE (decl)) |
6486 | { | |
6487 | case BIT_NOT_EXPR: | |
652e1a2d | 6488 | { |
3046c0a3 | 6489 | tree type = TREE_OPERAND (decl, 0); |
6490 | type = constructor_name (type); | |
6491 | name = IDENTIFIER_POINTER (type); | |
6492 | } | |
6493 | break; | |
e8d95fdc | 6494 | |
3046c0a3 | 6495 | case TEMPLATE_ID_EXPR: |
6496 | { | |
6497 | tree fns = TREE_OPERAND (decl, 0); | |
e8d95fdc | 6498 | |
3046c0a3 | 6499 | dname = fns; |
6500 | if (TREE_CODE (dname) == COMPONENT_REF) | |
6501 | dname = TREE_OPERAND (dname, 1); | |
6502 | if (TREE_CODE (dname) != IDENTIFIER_NODE) | |
652e1a2d | 6503 | { |
b4df430b | 6504 | gcc_assert (is_overloaded_fn (dname)); |
3046c0a3 | 6505 | dname = DECL_NAME (get_first_fn (dname)); |
652e1a2d | 6506 | } |
6507 | } | |
3046c0a3 | 6508 | /* Fall through. */ |
652e1a2d | 6509 | |
3046c0a3 | 6510 | case IDENTIFIER_NODE: |
6511 | if (TREE_CODE (decl) == IDENTIFIER_NODE) | |
6512 | dname = decl; | |
652e1a2d | 6513 | |
3046c0a3 | 6514 | if (C_IS_RESERVED_WORD (dname)) |
6515 | { | |
6516 | error ("declarator-id missing; using reserved word `%D'", | |
6517 | dname); | |
6518 | name = IDENTIFIER_POINTER (dname); | |
6519 | } | |
6520 | else if (!IDENTIFIER_TYPENAME_P (dname)) | |
6521 | name = IDENTIFIER_POINTER (dname); | |
6522 | else | |
6523 | { | |
b4df430b | 6524 | gcc_assert (flags == NO_SPECIAL); |
3046c0a3 | 6525 | flags = TYPENAME_FLAG; |
6526 | ctor_return_type = TREE_TYPE (dname); | |
6527 | sfk = sfk_conversion; | |
6528 | if (is_typename_at_global_scope (dname)) | |
6529 | name = IDENTIFIER_POINTER (dname); | |
6530 | else | |
6531 | name = "<invalid operator>"; | |
6532 | } | |
6533 | break; | |
6534 | ||
6535 | case TYPE_DECL: | |
6536 | dname = constructor_name (TREE_TYPE (decl)); | |
6537 | name = IDENTIFIER_POINTER (dname); | |
6538 | break; | |
6539 | ||
6540 | default: | |
092b1d6f | 6541 | gcc_unreachable (); |
3046c0a3 | 6542 | } |
e178a5a9 | 6543 | break; |
6544 | ||
3046c0a3 | 6545 | case cdk_array: |
6546 | case cdk_pointer: | |
6547 | case cdk_reference: | |
6548 | case cdk_ptrmem: | |
4ac852cb | 6549 | break; |
acb91513 | 6550 | |
3046c0a3 | 6551 | case cdk_error: |
acb91513 | 6552 | break; |
3046c0a3 | 6553 | |
652e1a2d | 6554 | default: |
092b1d6f | 6555 | gcc_unreachable (); |
471086d6 | 6556 | } |
3046c0a3 | 6557 | } |
6558 | if (id_declarator->kind == cdk_id) | |
6559 | break; | |
6560 | } | |
471086d6 | 6561 | |
6562 | /* A function definition's declarator must have the form of | |
6563 | a function declarator. */ | |
6564 | ||
3046c0a3 | 6565 | if (funcdef_flag && innermost_code != cdk_function) |
471086d6 | 6566 | return 0; |
6567 | ||
bcf789d7 | 6568 | if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG) |
3046c0a3 | 6569 | && innermost_code != cdk_function |
4b9b2871 | 6570 | && ! (ctype && !declspecs->any_specifiers_p)) |
bcf789d7 | 6571 | { |
cf103c6c | 6572 | error ("declaration of `%D' as non-function", dname); |
bcf789d7 | 6573 | return void_type_node; |
6574 | } | |
6575 | ||
471086d6 | 6576 | /* Anything declared one level down from the top level |
6577 | must be one of the parameters of a function | |
6578 | (because the body is at least two levels down). */ | |
6579 | ||
6580 | /* This heuristic cannot be applied to C++ nodes! Fixed, however, | |
6581 | by not allowing C++ class definitions to specify their parameters | |
6582 | with xdecls (must be spec.d in the parmlist). | |
6583 | ||
6584 | Since we now wait to push a class scope until we are sure that | |
6585 | we are in a legitimate method context, we must set oldcname | |
d0622bdf | 6586 | explicitly (since current_class_name is not yet alive). |
6587 | ||
6588 | We also want to avoid calling this a PARM if it is in a namespace. */ | |
471086d6 | 6589 | |
70a658bd | 6590 | if (decl_context == NORMAL && !toplevel_bindings_p ()) |
d0622bdf | 6591 | { |
1f3233d1 | 6592 | struct cp_binding_level *b = current_binding_level; |
fa3834f1 | 6593 | current_binding_level = b->level_chain; |
d0622bdf | 6594 | if (current_binding_level != 0 && toplevel_bindings_p ()) |
6595 | decl_context = PARM; | |
fa3834f1 | 6596 | current_binding_level = b; |
d0622bdf | 6597 | } |
471086d6 | 6598 | |
2a80b8e1 | 6599 | if (name == NULL) |
6600 | name = decl_context == PARM ? "parameter" : "type name"; | |
980877d7 | 6601 | |
4b9b2871 | 6602 | /* If there were multiple types specified in the decl-specifier-seq, |
6603 | issue an error message. */ | |
6604 | if (declspecs->multiple_types_p) | |
6605 | error ("two or more data types in declaration of `%s'", name); | |
6606 | /* Extract the basic type from the decl-specifier-seq. */ | |
6607 | type = declspecs->type; | |
6608 | if (type == error_mark_node) | |
6609 | type = NULL_TREE; | |
6610 | /* If the entire declaration is itself tagged as deprecated then | |
6611 | suppress reports of deprecated items. */ | |
6612 | if (type && TREE_DEPRECATED (type) | |
6613 | && deprecated_state != DEPRECATED_SUPPRESS) | |
6614 | warn_deprecated_use (type); | |
6615 | if (type && TREE_CODE (type) == TYPE_DECL) | |
471086d6 | 6616 | { |
4b9b2871 | 6617 | typedef_decl = type; |
6618 | type = TREE_TYPE (typedef_decl); | |
6619 | } | |
6620 | /* No type at all: default to `int', and set DEFAULTED_INT | |
6621 | because it was not a user-defined typedef. */ | |
6493c502 | 6622 | if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p)) |
4b9b2871 | 6623 | { |
6624 | /* These imply 'int'. */ | |
6625 | type = integer_type_node; | |
6626 | defaulted_int = 1; | |
6627 | } | |
6628 | /* Gather flags. */ | |
6629 | explicit_int = declspecs->explicit_int_p; | |
6630 | explicit_char = declspecs->explicit_char_p; | |
e396cd54 | 6631 | |
4b9b2871 | 6632 | /* Check for repeated decl-specifiers. */ |
491e04ef | 6633 | for (ds = ds_first; ds != ds_last; ++ds) |
4b9b2871 | 6634 | { |
6635 | unsigned count = declspecs->specs[(int)ds]; | |
6636 | if (count < 2) | |
6637 | continue; | |
491e04ef | 6638 | /* The "long" specifier is a special case because of |
4b9b2871 | 6639 | "long long". */ |
6640 | if (ds == ds_long) | |
471086d6 | 6641 | { |
4b9b2871 | 6642 | if (count > 2) |
6643 | error ("`long long long' is too long for GCC"); | |
6644 | else if (pedantic && !in_system_header && warn_long_long) | |
6645 | pedwarn ("ISO C++ does not support `long long'"); | |
471086d6 | 6646 | else |
4b9b2871 | 6647 | longlong = 1; |
491e04ef | 6648 | } |
4b9b2871 | 6649 | else if (declspecs->specs[(int)ds] > 1) |
c802bb91 | 6650 | { |
2cfb6cde | 6651 | static const char *const decl_spec_names[] = { |
c802bb91 | 6652 | "signed", |
6653 | "unsigned", | |
6654 | "short", | |
6655 | "long", | |
6656 | "const", | |
6657 | "volatile", | |
6658 | "restrict", | |
6659 | "inline", | |
6660 | "virtual", | |
6661 | "explicit", | |
6662 | "friend", | |
6663 | "typedef", | |
6664 | "__complex", | |
6665 | "__thread" | |
6666 | }; | |
6667 | error ("duplicate `%s'", decl_spec_names[(int)ds]); | |
6668 | } | |
471086d6 | 6669 | } |
6670 | ||
47fd99f9 | 6671 | #if 0 |
6672 | /* See the code below that used this. */ | |
6673 | if (typedef_decl) | |
6674 | decl_attr = DECL_ATTRIBUTES (typedef_decl); | |
6675 | #endif | |
471086d6 | 6676 | typedef_type = type; |
6677 | ||
ad91f3ed | 6678 | |
853b7640 | 6679 | if (sfk != sfk_conversion) |
6680 | ctor_return_type = ctype; | |
6681 | ||
bb855ff9 | 6682 | if (sfk != sfk_none) |
6683 | type = check_special_function_return_type (sfk, type, | |
bb855ff9 | 6684 | ctor_return_type); |
6685 | else if (type == NULL_TREE) | |
471086d6 | 6686 | { |
bb855ff9 | 6687 | int is_main; |
6688 | ||
471086d6 | 6689 | explicit_int = -1; |
bb855ff9 | 6690 | |
fccd46be | 6691 | /* We handle `main' specially here, because 'main () { }' is so |
6692 | common. With no options, it is allowed. With -Wreturn-type, | |
6693 | it is a warning. It is only an error with -pedantic-errors. */ | |
bb855ff9 | 6694 | is_main = (funcdef_flag |
6cd31fa5 | 6695 | && dname && MAIN_NAME_P (dname) |
bb855ff9 | 6696 | && ctype == NULL_TREE |
6697 | && in_namespace == NULL_TREE | |
6698 | && current_namespace == global_namespace); | |
6699 | ||
6700 | if (in_system_header || flag_ms_extensions) | |
6701 | /* Allow it, sigh. */; | |
6702 | else if (pedantic || ! is_main) | |
cf103c6c | 6703 | pedwarn ("ISO C++ forbids declaration of `%s' with no type", |
bb855ff9 | 6704 | name); |
6705 | else if (warn_return_type) | |
cf103c6c | 6706 | warning ("ISO C++ forbids declaration of `%s' with no type", |
bb855ff9 | 6707 | name); |
262108c9 | 6708 | |
bb855ff9 | 6709 | type = integer_type_node; |
ac9386a0 | 6710 | } |
491e04ef | 6711 | |
471086d6 | 6712 | ctype = NULL_TREE; |
6713 | ||
6714 | /* Now process the modifiers that were specified | |
6715 | and check for invalid combinations. */ | |
6716 | ||
6717 | /* Long double is a special combination. */ | |
6493c502 | 6718 | if (long_p && TYPE_MAIN_VARIANT (type) == double_type_node) |
471086d6 | 6719 | { |
6493c502 | 6720 | long_p = false; |
980877d7 | 6721 | type = build_qualified_type (long_double_type_node, |
3119c950 | 6722 | cp_type_quals (type)); |
471086d6 | 6723 | } |
6724 | ||
6725 | /* Check all other uses of type modifiers. */ | |
6726 | ||
6493c502 | 6727 | if (unsigned_p || signed_p || long_p || short_p) |
471086d6 | 6728 | { |
6729 | int ok = 0; | |
6730 | ||
6731 | if (TREE_CODE (type) == REAL_TYPE) | |
905d4035 | 6732 | error ("short, signed or unsigned invalid for `%s'", name); |
1e66592c | 6733 | else if (TREE_CODE (type) != INTEGER_TYPE) |
905d4035 | 6734 | error ("long, short, signed or unsigned invalid for `%s'", name); |
6493c502 | 6735 | else if (long_p && short_p) |
905d4035 | 6736 | error ("long and short specified together for `%s'", name); |
6493c502 | 6737 | else if ((long_p || short_p) && explicit_char) |
905d4035 | 6738 | error ("long or short specified with char for `%s'", name); |
6493c502 | 6739 | else if ((long_p|| short_p) && TREE_CODE (type) == REAL_TYPE) |
905d4035 | 6740 | error ("long or short specified with floating type for `%s'", name); |
6493c502 | 6741 | else if (signed_p && unsigned_p) |
905d4035 | 6742 | error ("signed and unsigned given together for `%s'", name); |
471086d6 | 6743 | else |
6744 | { | |
6745 | ok = 1; | |
c4a8ac95 | 6746 | if (!explicit_int && !defaulted_int && !explicit_char && pedantic) |
471086d6 | 6747 | { |
905d4035 | 6748 | pedwarn ("long, short, signed or unsigned used invalidly for `%s'", |
471086d6 | 6749 | name); |
6750 | if (flag_pedantic_errors) | |
6751 | ok = 0; | |
6752 | } | |
6753 | } | |
6754 | ||
6755 | /* Discard the type modifiers if they are invalid. */ | |
6756 | if (! ok) | |
6757 | { | |
6493c502 | 6758 | unsigned_p = false; |
6759 | signed_p = false; | |
6760 | long_p = false; | |
6761 | short_p = false; | |
471086d6 | 6762 | longlong = 0; |
6763 | } | |
6764 | } | |
6765 | ||
6766 | /* Decide whether an integer type is signed or not. | |
6767 | Optionally treat bitfields as signed by default. */ | |
6493c502 | 6768 | if (unsigned_p |
3498bcb9 | 6769 | /* [class.bit] |
6770 | ||
6771 | It is implementation-defined whether a plain (neither | |
6772 | explicitly signed or unsigned) char, short, int, or long | |
6773 | bit-field is signed or unsigned. | |
980877d7 | 6774 | |
3498bcb9 | 6775 | Naturally, we extend this to long long as well. Note that |
6776 | this does not include wchar_t. */ | |
6777 | || (bitfield && !flag_signed_bitfields | |
6493c502 | 6778 | && !signed_p |
3498bcb9 | 6779 | /* A typedef for plain `int' without `signed' can be |
6780 | controlled just like plain `int', but a typedef for | |
6781 | `signed int' cannot be so controlled. */ | |
980877d7 | 6782 | && !(typedef_decl |
b981ae4a | 6783 | && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)) |
3498bcb9 | 6784 | && (TREE_CODE (type) == INTEGER_TYPE |
6785 | || TREE_CODE (type) == CHAR_TYPE) | |
b981ae4a | 6786 | && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node))) |
471086d6 | 6787 | { |
6788 | if (longlong) | |
6789 | type = long_long_unsigned_type_node; | |
6493c502 | 6790 | else if (long_p) |
471086d6 | 6791 | type = long_unsigned_type_node; |
6493c502 | 6792 | else if (short_p) |
471086d6 | 6793 | type = short_unsigned_type_node; |
6794 | else if (type == char_type_node) | |
6795 | type = unsigned_char_type_node; | |
6796 | else if (typedef_decl) | |
4070745f | 6797 | type = c_common_unsigned_type (type); |
471086d6 | 6798 | else |
6799 | type = unsigned_type_node; | |
6800 | } | |
6493c502 | 6801 | else if (signed_p && type == char_type_node) |
471086d6 | 6802 | type = signed_char_type_node; |
6803 | else if (longlong) | |
6804 | type = long_long_integer_type_node; | |
6493c502 | 6805 | else if (long_p) |
471086d6 | 6806 | type = long_integer_type_node; |
6493c502 | 6807 | else if (short_p) |
471086d6 | 6808 | type = short_integer_type_node; |
6809 | ||
4b9b2871 | 6810 | if (declspecs->specs[(int)ds_complex]) |
c4a8ac95 | 6811 | { |
6493c502 | 6812 | if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE) |
6813 | error ("complex invalid for `%s'", name); | |
c4a8ac95 | 6814 | /* If we just have "complex", it is equivalent to |
6815 | "complex double", but if any modifiers at all are specified it is | |
6816 | the complex form of TYPE. E.g, "complex short" is | |
6817 | "complex short int". */ | |
6818 | ||
6493c502 | 6819 | else if (defaulted_int && ! longlong |
6820 | && ! (long_p || short_p || signed_p || unsigned_p)) | |
c4a8ac95 | 6821 | type = complex_double_type_node; |
6822 | else if (type == integer_type_node) | |
6823 | type = complex_integer_type_node; | |
6824 | else if (type == float_type_node) | |
6825 | type = complex_float_type_node; | |
6826 | else if (type == double_type_node) | |
6827 | type = complex_double_type_node; | |
6828 | else if (type == long_double_type_node) | |
6829 | type = complex_long_double_type_node; | |
6830 | else | |
6831 | type = build_complex_type (type); | |
6832 | } | |
6833 | ||
9edbac04 | 6834 | type_quals = TYPE_UNQUALIFIED; |
4b9b2871 | 6835 | if (declspecs->specs[(int)ds_const]) |
9edbac04 | 6836 | type_quals |= TYPE_QUAL_CONST; |
4b9b2871 | 6837 | if (declspecs->specs[(int)ds_volatile]) |
9edbac04 | 6838 | type_quals |= TYPE_QUAL_VOLATILE; |
4b9b2871 | 6839 | if (declspecs->specs[(int)ds_restrict]) |
9edbac04 | 6840 | type_quals |= TYPE_QUAL_RESTRICT; |
6841 | if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED) | |
cf103c6c | 6842 | error ("qualifiers are not allowed on declaration of `operator %T'", |
1ca935fd | 6843 | ctor_return_type); |
6844 | ||
9edbac04 | 6845 | type_quals |= cp_type_quals (type); |
6846 | type = cp_build_qualified_type_real | |
6847 | (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl) | |
6848 | ? tf_ignore_bad_quals : 0) | tf_error | tf_warning)); | |
6849 | /* We might have ignored or rejected some of the qualifiers. */ | |
6850 | type_quals = cp_type_quals (type); | |
491e04ef | 6851 | |
471086d6 | 6852 | staticp = 0; |
4b9b2871 | 6853 | inlinep = !! declspecs->specs[(int)ds_inline]; |
6854 | virtualp = !! declspecs->specs[(int)ds_virtual]; | |
6855 | explicitp = !! declspecs->specs[(int)ds_explicit]; | |
471086d6 | 6856 | |
6493c502 | 6857 | storage_class = declspecs->storage_class; |
6858 | if (storage_class == sc_static) | |
471086d6 | 6859 | staticp = 1 + (decl_context == FIELD); |
6860 | ||
6861 | if (virtualp && staticp == 2) | |
6862 | { | |
cf103c6c | 6863 | error ("member `%D' cannot be declared both virtual and static", |
471086d6 | 6864 | dname); |
6865 | staticp = 0; | |
6866 | } | |
4b9b2871 | 6867 | friendp = !! declspecs->specs[(int)ds_friend]; |
471086d6 | 6868 | |
6debb1d0 | 6869 | if (dependant_name && !friendp) |
6870 | { | |
6871 | error ("`%T::%D' is not a valid declarator", ctype, dependant_name); | |
6872 | return void_type_node; | |
6873 | } | |
471086d6 | 6874 | |
4b9b2871 | 6875 | /* Issue errors about use of storage classes for parameters. */ |
6876 | if (decl_context == PARM) | |
471086d6 | 6877 | { |
4b9b2871 | 6878 | if (declspecs->specs[(int)ds_typedef]) |
6879 | error ("typedef declaration invalid in parameter declaration"); | |
6493c502 | 6880 | else if (storage_class == sc_static |
6881 | || storage_class == sc_extern | |
6882 | || thread_p) | |
905d4035 | 6883 | error ("storage class specifiers invalid in parameter declarations"); |
471086d6 | 6884 | } |
6885 | ||
6886 | /* Give error if `virtual' is used outside of class declaration. */ | |
1e66592c | 6887 | if (virtualp |
6888 | && (current_class_name == NULL_TREE || decl_context != FIELD)) | |
471086d6 | 6889 | { |
905d4035 | 6890 | error ("virtual outside class declaration"); |
471086d6 | 6891 | virtualp = 0; |
6892 | } | |
471086d6 | 6893 | |
6894 | /* Static anonymous unions are dealt with here. */ | |
6895 | if (staticp && decl_context == TYPENAME | |
4b9b2871 | 6896 | && declspecs->type |
6897 | && ANON_AGGR_TYPE_P (declspecs->type)) | |
471086d6 | 6898 | decl_context = FIELD; |
6899 | ||
471086d6 | 6900 | /* Warn about storage classes that are invalid for certain |
6901 | kinds of declarations (parameters, typenames, etc.). */ | |
4b9b2871 | 6902 | if (declspecs->multiple_storage_classes_p) |
905d4035 | 6903 | error ("multiple storage classes in declaration of `%s'", name); |
6493c502 | 6904 | else if (thread_p |
491e04ef | 6905 | && ((storage_class |
6493c502 | 6906 | && storage_class != sc_extern |
6907 | && storage_class != sc_static) | |
c802bb91 | 6908 | || declspecs->specs[(int)ds_typedef])) |
6909 | { | |
6910 | error ("multiple storage classes in declaration of `%s'", name); | |
6493c502 | 6911 | thread_p = false; |
c802bb91 | 6912 | } |
491e04ef | 6913 | else if (decl_context != NORMAL |
6493c502 | 6914 | && ((storage_class != sc_none |
6915 | && storage_class != sc_mutable) | |
6916 | || thread_p)) | |
471086d6 | 6917 | { |
c25194fd | 6918 | if ((decl_context == PARM || decl_context == CATCHPARM) |
6493c502 | 6919 | && (storage_class == sc_register |
6920 | || storage_class == sc_auto)) | |
471086d6 | 6921 | ; |
4b9b2871 | 6922 | else if (declspecs->specs[(int)ds_typedef]) |
d2a15a12 | 6923 | ; |
471086d6 | 6924 | else if (decl_context == FIELD |
331bc0ad | 6925 | /* C++ allows static class elements. */ |
6493c502 | 6926 | && storage_class == sc_static) |
20c01ba9 | 6927 | /* C++ also allows inlines and signed and unsigned elements, |
6928 | but in those cases we don't come in here. */ | |
471086d6 | 6929 | ; |
6930 | else | |
6931 | { | |
6932 | if (decl_context == FIELD) | |
6933 | { | |
1e66592c | 6934 | tree tmp = NULL_TREE; |
cd16867a | 6935 | int op = 0; |
1e66592c | 6936 | |
6937 | if (declarator) | |
6938 | { | |
980877d7 | 6939 | /* Avoid trying to get an operand off an identifier node. */ |
3046c0a3 | 6940 | if (declarator->kind != cdk_id) |
6941 | tmp = declarator->declarator->u.id.name; | |
63b1d638 | 6942 | else |
3046c0a3 | 6943 | tmp = declarator->u.id.name; |
1e66592c | 6944 | op = IDENTIFIER_OPNAME_P (tmp); |
97cc4539 | 6945 | if (IDENTIFIER_TYPENAME_P (tmp)) |
6946 | { | |
df2c7ecb | 6947 | if (is_typename_at_global_scope (tmp)) |
97cc4539 | 6948 | name = IDENTIFIER_POINTER (tmp); |
6949 | else | |
6950 | name = "<invalid operator>"; | |
6951 | } | |
1e66592c | 6952 | } |
905d4035 | 6953 | error ("storage class specified for %s `%s'", |
771665d8 | 6954 | op ? "member operator" : "field", |
97cc4539 | 6955 | name); |
471086d6 | 6956 | } |
6957 | else | |
5212eb00 | 6958 | { |
6959 | if (decl_context == PARM || decl_context == CATCHPARM) | |
6960 | error ("storage class specified for parameter `%s'", name); | |
6961 | else | |
6962 | error ("storage class specified for typename"); | |
6963 | } | |
6493c502 | 6964 | if (storage_class == sc_register |
6965 | || storage_class == sc_auto | |
6966 | || storage_class == sc_extern | |
6967 | || thread_p) | |
6968 | storage_class = sc_none; | |
471086d6 | 6969 | } |
6970 | } | |
491e04ef | 6971 | else if (storage_class == sc_extern && initialized |
4b9b2871 | 6972 | && !funcdef_flag) |
471086d6 | 6973 | { |
d0622bdf | 6974 | if (toplevel_bindings_p ()) |
471086d6 | 6975 | { |
3748625f | 6976 | /* It's common practice (and completely valid) to have a const |
471086d6 | 6977 | be initialized and declared extern. */ |
0cb64d99 | 6978 | if (!(type_quals & TYPE_QUAL_CONST)) |
905d4035 | 6979 | warning ("`%s' initialized and declared `extern'", name); |
471086d6 | 6980 | } |
6981 | else | |
905d4035 | 6982 | error ("`%s' has both `extern' and initializer", name); |
471086d6 | 6983 | } |
6493c502 | 6984 | else if (storage_class == sc_extern && funcdef_flag |
d0622bdf | 6985 | && ! toplevel_bindings_p ()) |
905d4035 | 6986 | error ("nested function `%s' declared `extern'", name); |
d0622bdf | 6987 | else if (toplevel_bindings_p ()) |
471086d6 | 6988 | { |
6493c502 | 6989 | if (storage_class == sc_auto) |
905d4035 | 6990 | error ("top-level declaration of `%s' specifies `auto'", name); |
471086d6 | 6991 | } |
6493c502 | 6992 | else if (thread_p |
6993 | && storage_class != sc_extern | |
6994 | && storage_class != sc_static) | |
e396cd54 | 6995 | { |
6996 | error ("function-scope `%s' implicitly auto and declared `__thread'", | |
6997 | name); | |
6493c502 | 6998 | thread_p = false; |
e396cd54 | 6999 | } |
471086d6 | 7000 | |
6493c502 | 7001 | if (storage_class && friendp) |
905d4035 | 7002 | error ("storage class specifiers invalid in friend function declarations"); |
4742975e | 7003 | |
3046c0a3 | 7004 | if (!id_declarator) |
7005 | unqualified_id = NULL_TREE; | |
7006 | else | |
471086d6 | 7007 | { |
3046c0a3 | 7008 | unqualified_id = id_declarator->u.id.name; |
7009 | if (TREE_CODE (unqualified_id) == SCOPE_REF) | |
7010 | unqualified_id = TREE_OPERAND (unqualified_id, 1); | |
7011 | if (TREE_CODE (unqualified_id) == BASELINK) | |
7012 | unqualified_id = BASELINK_FUNCTIONS (unqualified_id); | |
7013 | switch (TREE_CODE (unqualified_id)) | |
471086d6 | 7014 | { |
3046c0a3 | 7015 | case BIT_NOT_EXPR: |
491e04ef | 7016 | unqualified_id |
3046c0a3 | 7017 | = constructor_name (TREE_OPERAND (unqualified_id, 0)); |
7018 | break; | |
491e04ef | 7019 | |
3046c0a3 | 7020 | case TYPE_DECL: |
491e04ef | 7021 | unqualified_id |
3046c0a3 | 7022 | = constructor_name (TREE_TYPE (unqualified_id)); |
7023 | break; | |
57e7b4d8 | 7024 | |
3046c0a3 | 7025 | case IDENTIFIER_NODE: |
7026 | case TEMPLATE_ID_EXPR: | |
222b8af3 | 7027 | break; |
491e04ef | 7028 | |
3046c0a3 | 7029 | default: |
092b1d6f | 7030 | gcc_unreachable (); |
3046c0a3 | 7031 | } |
7032 | } | |
222b8af3 | 7033 | |
3046c0a3 | 7034 | /* Determine the type of the entity declared by recurring on the |
7035 | declarator. */ | |
491e04ef | 7036 | for (; |
3046c0a3 | 7037 | declarator && declarator->kind != cdk_id; |
7038 | declarator = declarator->declarator) | |
7039 | { | |
7040 | const cp_declarator *inner_declarator; | |
7041 | tree attrs; | |
471086d6 | 7042 | |
3046c0a3 | 7043 | if (type == error_mark_node) |
7044 | return error_mark_node; | |
faa4e1f1 | 7045 | |
3046c0a3 | 7046 | inner_declarator = declarator->declarator; |
4ee9c684 | 7047 | |
3046c0a3 | 7048 | attrs = declarator->attributes; |
7049 | if (attrs) | |
7050 | { | |
7051 | int attr_flags; | |
491e04ef | 7052 | |
3046c0a3 | 7053 | attr_flags = 0; |
7054 | if (declarator == NULL || declarator->kind == cdk_id) | |
7055 | attr_flags |= (int) ATTR_FLAG_DECL_NEXT; | |
7056 | if (declarator->kind == cdk_function) | |
7057 | attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT; | |
7058 | if (declarator->kind == cdk_array) | |
7059 | attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT; | |
7060 | returned_attrs = decl_attributes (&type, | |
7061 | chainon (returned_attrs, attrs), | |
7062 | attr_flags); | |
7063 | } | |
7064 | ||
7065 | switch (declarator->kind) | |
7066 | { | |
7067 | case cdk_array: | |
491e04ef | 7068 | type = create_array_type_for_decl (dname, type, |
3046c0a3 | 7069 | declarator->u.array.bounds); |
7070 | if (inner_declarator | |
7071 | && (inner_declarator->kind == cdk_pointer | |
7072 | || inner_declarator->kind == cdk_reference | |
7073 | || inner_declarator->kind == cdk_ptrmem)) | |
7074 | /* We can never complete an array type which is the | |
7075 | target of a pointer, so go ahead and lay it out. */ | |
7076 | layout_type (type); | |
471086d6 | 7077 | break; |
7078 | ||
3046c0a3 | 7079 | case cdk_function: |
471086d6 | 7080 | { |
7081 | tree arg_types; | |
c38086bd | 7082 | int funcdecl_p; |
471086d6 | 7083 | |
7084 | /* Declaring a function type. | |
7085 | Make sure we have a valid type for the function to return. */ | |
471086d6 | 7086 | |
3e04bd45 | 7087 | /* We now know that the TYPE_QUALS don't apply to the |
77b7e009 | 7088 | decl, but to its return type. */ |
3e04bd45 | 7089 | type_quals = TYPE_UNQUALIFIED; |
471086d6 | 7090 | |
7091 | /* Warn about some types functions can't return. */ | |
7092 | ||
7093 | if (TREE_CODE (type) == FUNCTION_TYPE) | |
7094 | { | |
905d4035 | 7095 | error ("`%s' declared as function returning a function", name); |
471086d6 | 7096 | type = integer_type_node; |
7097 | } | |
7098 | if (TREE_CODE (type) == ARRAY_TYPE) | |
7099 | { | |
905d4035 | 7100 | error ("`%s' declared as function returning an array", name); |
471086d6 | 7101 | type = integer_type_node; |
7102 | } | |
7103 | ||
1e66592c | 7104 | /* Pick up type qualifiers which should be applied to `this'. */ |
3046c0a3 | 7105 | quals = declarator->u.function.qualifiers; |
1e66592c | 7106 | |
f9670f72 | 7107 | /* Pick up the exception specifications. */ |
3046c0a3 | 7108 | raises = declarator->u.function.exception_specification; |
f9670f72 | 7109 | |
c38086bd | 7110 | /* Say it's a definition only for the CALL_EXPR |
7111 | closest to the identifier. */ | |
3046c0a3 | 7112 | funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id; |
980877d7 | 7113 | |
471086d6 | 7114 | if (ctype == NULL_TREE |
7115 | && decl_context == FIELD | |
c38086bd | 7116 | && funcdecl_p |
471086d6 | 7117 | && (friendp == 0 || dname == current_class_name)) |
7118 | ctype = current_class_type; | |
7119 | ||
bb855ff9 | 7120 | if (ctype && sfk == sfk_conversion) |
471086d6 | 7121 | TYPE_HAS_CONVERSION (ctype) = 1; |
3046c0a3 | 7122 | if (ctype && (sfk == sfk_constructor |
7123 | || sfk == sfk_destructor)) | |
471086d6 | 7124 | { |
7125 | /* We are within a class's scope. If our declarator name | |
7126 | is the same as the class name, and we are defining | |
7127 | a function, then it is a constructor/destructor, and | |
7128 | therefore returns a void type. */ | |
7129 | ||
7130 | if (flags == DTOR_FLAG) | |
7131 | { | |
657c76e1 | 7132 | /* ISO C++ 12.4/2. A destructor may not be |
7133 | declared const or volatile. A destructor may | |
7134 | not be static. */ | |
471086d6 | 7135 | if (staticp == 2) |
905d4035 | 7136 | error ("destructor cannot be static member function"); |
1e66592c | 7137 | if (quals) |
471086d6 | 7138 | { |
2cfb6cde | 7139 | error ("destructors may not be cv-qualified"); |
7140 | quals = TYPE_UNQUALIFIED; | |
471086d6 | 7141 | } |
7142 | if (decl_context == FIELD) | |
7143 | { | |
017fafd4 | 7144 | if (! member_function_or_else (ctype, |
7145 | current_class_type, | |
7146 | flags)) | |
471086d6 | 7147 | return void_type_node; |
7148 | } | |
7149 | } | |
8417823c | 7150 | else /* It's a constructor. */ |
471086d6 | 7151 | { |
c25194fd | 7152 | if (explicitp == 1) |
7153 | explicitp = 2; | |
657c76e1 | 7154 | /* ISO C++ 12.1. A constructor may not be |
7155 | declared const or volatile. A constructor may | |
7156 | not be virtual. A constructor may not be | |
7157 | static. */ | |
471086d6 | 7158 | if (staticp == 2) |
905d4035 | 7159 | error ("constructor cannot be static member function"); |
471086d6 | 7160 | if (virtualp) |
7161 | { | |
905d4035 | 7162 | pedwarn ("constructors cannot be declared virtual"); |
471086d6 | 7163 | virtualp = 0; |
7164 | } | |
1e66592c | 7165 | if (quals) |
471086d6 | 7166 | { |
2cfb6cde | 7167 | error ("constructors may not be cv-qualified"); |
7168 | quals = TYPE_UNQUALIFIED; | |
20c01ba9 | 7169 | } |
771665d8 | 7170 | if (decl_context == FIELD) |
471086d6 | 7171 | { |
017fafd4 | 7172 | if (! member_function_or_else (ctype, |
7173 | current_class_type, | |
7174 | flags)) | |
471086d6 | 7175 | return void_type_node; |
7176 | TYPE_HAS_CONSTRUCTOR (ctype) = 1; | |
bb855ff9 | 7177 | if (sfk != sfk_constructor) |
471086d6 | 7178 | return NULL_TREE; |
7179 | } | |
7180 | } | |
7181 | if (decl_context == FIELD) | |
7182 | staticp = 0; | |
7183 | } | |
1e66592c | 7184 | else if (friendp) |
471086d6 | 7185 | { |
1e66592c | 7186 | if (initialized) |
905d4035 | 7187 | error ("can't initialize friend function `%s'", name); |
1e66592c | 7188 | if (virtualp) |
7189 | { | |
7190 | /* Cannot be both friend and virtual. */ | |
905d4035 | 7191 | error ("virtual functions cannot be friends"); |
1e66592c | 7192 | friendp = 0; |
7193 | } | |
bea7d742 | 7194 | if (decl_context == NORMAL) |
905d4035 | 7195 | error ("friend declaration not in class definition"); |
bea7d742 | 7196 | if (current_function_decl && funcdef_flag) |
cf103c6c | 7197 | error ("can't define friend function `%s' in a local class definition", |
bea7d742 | 7198 | name); |
471086d6 | 7199 | } |
7200 | ||
491e04ef | 7201 | arg_types = grokparms (declarator->u.function.parameters, |
3046c0a3 | 7202 | &parms); |
471086d6 | 7203 | |
3046c0a3 | 7204 | if (inner_declarator |
7205 | && inner_declarator->kind == cdk_id | |
7206 | && inner_declarator->u.id.sfk == sfk_destructor | |
7207 | && arg_types != void_list_node) | |
471086d6 | 7208 | { |
3046c0a3 | 7209 | error ("destructors may not have parameters"); |
7210 | arg_types = void_list_node; | |
7211 | parms = NULL_TREE; | |
471086d6 | 7212 | } |
491e04ef | 7213 | |
48ec80c8 | 7214 | type = build_function_type (type, arg_types); |
471086d6 | 7215 | } |
7216 | break; | |
7217 | ||
3046c0a3 | 7218 | case cdk_pointer: |
7219 | case cdk_reference: | |
7220 | case cdk_ptrmem: | |
471086d6 | 7221 | /* Filter out pointers-to-references and references-to-references. |
7222 | We can get these if a TYPE_DECL is used. */ | |
7223 | ||
7224 | if (TREE_CODE (type) == REFERENCE_TYPE) | |
7225 | { | |
3046c0a3 | 7226 | error (declarator->kind == cdk_reference |
7f134624 | 7227 | ? "cannot declare reference to `%#T'" |
7228 | : "cannot declare pointer to `%#T'", type); | |
127a1cd0 | 7229 | type = TREE_TYPE (type); |
7230 | } | |
3046c0a3 | 7231 | else if (VOID_TYPE_P (type)) |
7232 | { | |
7233 | if (declarator->kind == cdk_reference) | |
7234 | error ("cannot declare reference to `%#T'", type); | |
7235 | else if (declarator->kind == cdk_ptrmem) | |
7236 | error ("cannot declare pointer to `%#T' member", type); | |
7237 | } | |
0f2952a1 | 7238 | |
3e04bd45 | 7239 | /* We now know that the TYPE_QUALS don't apply to the decl, |
7240 | but to the target of the pointer. */ | |
7241 | type_quals = TYPE_UNQUALIFIED; | |
471086d6 | 7242 | |
3046c0a3 | 7243 | if (declarator->kind == cdk_ptrmem |
7244 | && (TREE_CODE (type) == FUNCTION_TYPE | |
7245 | || (quals && TREE_CODE (type) == METHOD_TYPE))) | |
7246 | { | |
7247 | tree dummy = build_decl (TYPE_DECL, NULL_TREE, type); | |
491e04ef | 7248 | grok_method_quals (declarator->u.pointer.class_type, |
3046c0a3 | 7249 | dummy, quals); |
7250 | type = TREE_TYPE (dummy); | |
2cfb6cde | 7251 | quals = TYPE_UNQUALIFIED; |
3046c0a3 | 7252 | } |
7253 | ||
7254 | if (declarator->kind == cdk_reference) | |
471086d6 | 7255 | { |
7f134624 | 7256 | if (!VOID_TYPE_P (type)) |
938b347c | 7257 | type = build_reference_type (type); |
471086d6 | 7258 | } |
7259 | else if (TREE_CODE (type) == METHOD_TYPE) | |
2b77484d | 7260 | type = build_ptrmemfunc_type (build_pointer_type (type)); |
3046c0a3 | 7261 | else if (declarator->kind == cdk_ptrmem) |
491e04ef | 7262 | type = build_ptrmem_type (declarator->u.pointer.class_type, |
3046c0a3 | 7263 | type); |
471086d6 | 7264 | else |
7265 | type = build_pointer_type (type); | |
7266 | ||
7267 | /* Process a list of type modifier keywords (such as | |
7268 | const or volatile) that were given inside the `*' or `&'. */ | |
7269 | ||
3046c0a3 | 7270 | if (declarator->u.pointer.qualifiers) |
471086d6 | 7271 | { |
491e04ef | 7272 | type |
7273 | = cp_build_qualified_type (type, | |
2cfb6cde | 7274 | declarator->u.pointer.qualifiers); |
9edbac04 | 7275 | type_quals = cp_type_quals (type); |
471086d6 | 7276 | } |
471086d6 | 7277 | ctype = NULL_TREE; |
7278 | break; | |
7279 | ||
3046c0a3 | 7280 | case cdk_error: |
7281 | break; | |
471086d6 | 7282 | |
3046c0a3 | 7283 | default: |
092b1d6f | 7284 | gcc_unreachable (); |
3046c0a3 | 7285 | } |
7286 | } | |
491e04ef | 7287 | |
3046c0a3 | 7288 | if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR |
7289 | && TREE_CODE (type) != FUNCTION_TYPE | |
7290 | && TREE_CODE (type) != METHOD_TYPE) | |
7291 | { | |
491e04ef | 7292 | error ("template-id `%D' used as a declarator", |
3046c0a3 | 7293 | unqualified_id); |
7294 | unqualified_id = dname; | |
7295 | } | |
b1cfe2be | 7296 | |
3046c0a3 | 7297 | /* If DECLARATOR is non-NULL, we know it is a cdk_id declarator; |
7298 | otherwise, we would not have exited the loop above. */ | |
491e04ef | 7299 | if (declarator |
3046c0a3 | 7300 | && TREE_CODE (declarator->u.id.name) == SCOPE_REF |
7301 | /* If the qualifying scope was invalid, it will have been set to | |
7302 | NULL_TREE above. */ | |
7303 | && TREE_OPERAND (declarator->u.id.name, 0) | |
7304 | && TYPE_P (TREE_OPERAND (declarator->u.id.name, 0))) | |
7305 | { | |
7306 | tree t; | |
471086d6 | 7307 | |
3046c0a3 | 7308 | ctype = TREE_OPERAND (declarator->u.id.name, 0); |
7309 | if (TYPE_P (ctype)) | |
7310 | ctype = TYPE_MAIN_VARIANT (ctype); | |
7311 | t = ctype; | |
7312 | while (t != NULL_TREE && CLASS_TYPE_P (t)) | |
7313 | { | |
7314 | /* You're supposed to have one `template <...>' for every | |
7315 | template class, but you don't need one for a full | |
7316 | specialization. For example: | |
471086d6 | 7317 | |
3046c0a3 | 7318 | template <class T> struct S{}; |
7319 | template <> struct S<int> { void f(); }; | |
7320 | void S<int>::f () {} | |
bea7d742 | 7321 | |
3046c0a3 | 7322 | is correct; there shouldn't be a `template <>' for the |
7323 | definition of `S<int>::f'. */ | |
7324 | if (CLASSTYPE_TEMPLATE_INFO (t) | |
7325 | && (CLASSTYPE_TEMPLATE_INSTANTIATION (t) | |
7326 | || uses_template_parms (CLASSTYPE_TI_ARGS (t))) | |
7327 | && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t))) | |
7328 | template_count += 1; | |
bea7d742 | 7329 | |
3046c0a3 | 7330 | t = TYPE_MAIN_DECL (t); |
7331 | t = DECL_CONTEXT (t); | |
7332 | } | |
471086d6 | 7333 | |
3046c0a3 | 7334 | if (ctype == current_class_type) |
7335 | { | |
7336 | /* class A { | |
7337 | void A::f (); | |
7338 | }; | |
471086d6 | 7339 | |
3046c0a3 | 7340 | Is this ill-formed? */ |
471086d6 | 7341 | |
3046c0a3 | 7342 | if (pedantic) |
7343 | pedwarn ("extra qualification `%T::' on member `%s' ignored", | |
7344 | ctype, name); | |
7345 | } | |
7346 | else if (TREE_CODE (type) == FUNCTION_TYPE) | |
7347 | { | |
7348 | tree sname = TREE_OPERAND (declarator->u.id.name, 1); | |
4ac852cb | 7349 | |
3046c0a3 | 7350 | if (TREE_CODE (sname) == IDENTIFIER_NODE |
7351 | && NEW_DELETE_OPNAME_P (sname)) | |
7352 | /* Overloaded operator new and operator delete | |
7353 | are always static functions. */ | |
7354 | ; | |
7355 | else if (current_class_type == NULL_TREE || friendp) | |
491e04ef | 7356 | type |
7357 | = build_method_type_directly (ctype, | |
3046c0a3 | 7358 | TREE_TYPE (type), |
7359 | TYPE_ARG_TYPES (type)); | |
7360 | else | |
7361 | { | |
7362 | error ("cannot declare member function `%T::%s' within `%T'", | |
7363 | ctype, name, current_class_type); | |
7364 | return error_mark_node; | |
7365 | } | |
7366 | } | |
4b9b2871 | 7367 | else if (declspecs->specs[(int)ds_typedef] |
3046c0a3 | 7368 | || COMPLETE_TYPE_P (complete_type (ctype))) |
7369 | { | |
7370 | /* Have to move this code elsewhere in this function. | |
7371 | this code is used for i.e., typedef int A::M; M *pm; | |
471086d6 | 7372 | |
3046c0a3 | 7373 | It is? How? jason 10/2/94 */ |
471086d6 | 7374 | |
3046c0a3 | 7375 | if (current_class_type) |
7376 | { | |
7377 | error ("cannot declare member `%T::%s' within `%T'", | |
7378 | ctype, name, current_class_type); | |
7379 | return void_type_node; | |
7380 | } | |
7381 | } | |
7382 | else | |
7383 | { | |
7384 | cxx_incomplete_type_error (NULL_TREE, ctype); | |
7385 | return error_mark_node; | |
471086d6 | 7386 | } |
7387 | } | |
7388 | ||
e3c541f0 | 7389 | if (returned_attrs) |
57e7b4d8 | 7390 | { |
e3c541f0 | 7391 | if (attrlist) |
7392 | *attrlist = chainon (returned_attrs, *attrlist); | |
57e7b4d8 | 7393 | else |
e3c541f0 | 7394 | attrlist = &returned_attrs; |
57e7b4d8 | 7395 | } |
7396 | ||
4a442922 | 7397 | /* Now TYPE has the actual type. */ |
7398 | ||
119c9424 | 7399 | /* Did array size calculations overflow? */ |
7400 | ||
7401 | if (TREE_CODE (type) == ARRAY_TYPE | |
7402 | && COMPLETE_TYPE_P (type) | |
7403 | && TREE_OVERFLOW (TYPE_SIZE (type))) | |
7404 | { | |
7405 | error ("size of array `%s' is too large", name); | |
4109ca29 | 7406 | /* If we proceed with the array type as it is, we'll eventually |
119c9424 | 7407 | crash in tree_low_cst(). */ |
7408 | type = error_mark_node; | |
7409 | } | |
7410 | ||
c015cd2f | 7411 | if ((decl_context == FIELD || decl_context == PARM) |
491e04ef | 7412 | && !processing_template_decl |
1f8a6ff8 | 7413 | && variably_modified_type_p (type, NULL_TREE)) |
bab7b18e | 7414 | { |
c015cd2f | 7415 | if (decl_context == FIELD) |
7416 | error ("data member may not have variably modified type `%T'", type); | |
7417 | else | |
7418 | error ("parameter may not have variably modified type `%T'", type); | |
bab7b18e | 7419 | type = error_mark_node; |
7420 | } | |
7421 | ||
2a80b8e1 | 7422 | if (explicitp == 1 || (explicitp && friendp)) |
c25194fd | 7423 | { |
2a80b8e1 | 7424 | /* [dcl.fct.spec] The explicit specifier shall only be used in |
7425 | declarations of constructors within a class definition. */ | |
7426 | error ("only declarations of constructors can be `explicit'"); | |
c25194fd | 7427 | explicitp = 0; |
7428 | } | |
7429 | ||
6493c502 | 7430 | if (storage_class == sc_mutable) |
ce28ee2e | 7431 | { |
e4494371 | 7432 | if (decl_context != FIELD || friendp) |
2a80b8e1 | 7433 | { |
7434 | error ("non-member `%s' cannot be declared `mutable'", name); | |
6493c502 | 7435 | storage_class = sc_none; |
2a80b8e1 | 7436 | } |
4b9b2871 | 7437 | else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef]) |
ce28ee2e | 7438 | { |
2a80b8e1 | 7439 | error ("non-object member `%s' cannot be declared `mutable'", name); |
6493c502 | 7440 | storage_class = sc_none; |
ce28ee2e | 7441 | } |
2a80b8e1 | 7442 | else if (TREE_CODE (type) == FUNCTION_TYPE |
7443 | || TREE_CODE (type) == METHOD_TYPE) | |
7444 | { | |
7445 | error ("function `%s' cannot be declared `mutable'", name); | |
6493c502 | 7446 | storage_class = sc_none; |
2a80b8e1 | 7447 | } |
ce28ee2e | 7448 | else if (staticp) |
7449 | { | |
905d4035 | 7450 | error ("static `%s' cannot be declared `mutable'", name); |
6493c502 | 7451 | storage_class = sc_none; |
ce28ee2e | 7452 | } |
2a80b8e1 | 7453 | else if (type_quals & TYPE_QUAL_CONST) |
7454 | { | |
7455 | error ("const `%s' cannot be declared `mutable'", name); | |
6493c502 | 7456 | storage_class = sc_none; |
2a80b8e1 | 7457 | } |
ce28ee2e | 7458 | } |
7459 | ||
4a442922 | 7460 | /* If this is declaring a typedef name, return a TYPE_DECL. */ |
4b9b2871 | 7461 | if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME) |
471086d6 | 7462 | { |
7463 | tree decl; | |
7464 | ||
7465 | /* Note that the grammar rejects storage classes | |
7466 | in typenames, fields or parameters. */ | |
7d53e30d | 7467 | if (current_lang_name == lang_name_java) |
7468 | TYPE_FOR_JAVA (type) = 1; | |
471086d6 | 7469 | |
b0df6589 | 7470 | if (decl_context == FIELD) |
7471 | { | |
3046c0a3 | 7472 | if (constructor_name_p (unqualified_id, current_class_type)) |
cf103c6c | 7473 | pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class", |
3046c0a3 | 7474 | unqualified_id); |
7475 | decl = build_lang_decl (TYPE_DECL, unqualified_id, type); | |
b0df6589 | 7476 | } |
7477 | else | |
b04d77fe | 7478 | { |
3046c0a3 | 7479 | decl = build_decl (TYPE_DECL, unqualified_id, type); |
0a3b29ad | 7480 | if (in_namespace || ctype) |
9bc3739f | 7481 | error ("%Jtypedef name may not be a nested-name-specifier", decl); |
b04d77fe | 7482 | if (!current_function_decl) |
7483 | DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace); | |
7484 | } | |
491e04ef | 7485 | |
70a658bd | 7486 | /* If the user declares "typedef struct {...} foo" then the |
7487 | struct will have an anonymous name. Fill that name in now. | |
7488 | Nothing can refer to it, so nothing needs know about the name | |
7489 | change. */ | |
471086d6 | 7490 | if (type != error_mark_node |
3046c0a3 | 7491 | && unqualified_id |
471086d6 | 7492 | && TYPE_NAME (type) |
7493 | && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL | |
83c4eacf | 7494 | && TYPE_ANONYMOUS_P (type) |
88be9eb2 | 7495 | /* Don't do this if there are attributes. */ |
7496 | && (!attrlist || !*attrlist) | |
3119c950 | 7497 | && cp_type_quals (type) == TYPE_UNQUALIFIED) |
471086d6 | 7498 | { |
1717856a | 7499 | tree oldname = TYPE_NAME (type); |
7500 | tree t; | |
7501 | ||
8417823c | 7502 | /* Replace the anonymous name with the real name everywhere. */ |
3046c0a3 | 7503 | lookup_tag_reverse (type, unqualified_id); |
1717856a | 7504 | for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t)) |
7505 | if (TYPE_NAME (t) == oldname) | |
7506 | TYPE_NAME (t) = decl; | |
471086d6 | 7507 | |
7508 | if (TYPE_LANG_SPECIFIC (type)) | |
7509 | TYPE_WAS_ANONYMOUS (type) = 1; | |
7510 | ||
586f49f7 | 7511 | /* If this is a typedef within a template class, the nested |
7512 | type is a (non-primary) template. The name for the | |
7513 | template needs updating as well. */ | |
7514 | if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type)) | |
980877d7 | 7515 | DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)) |
586f49f7 | 7516 | = TYPE_IDENTIFIER (type); |
7517 | ||
844e1a9a | 7518 | /* FIXME remangle member functions; member functions of a |
7519 | type with external linkage have external linkage. */ | |
d2a15a12 | 7520 | } |
d2a15a12 | 7521 | |
0a3b29ad | 7522 | if (quals) |
471086d6 | 7523 | { |
7524 | if (ctype == NULL_TREE) | |
7525 | { | |
7526 | if (TREE_CODE (type) != METHOD_TYPE) | |
9bc3739f | 7527 | error ("%Jinvalid type qualifier for non-member function type", |
7528 | decl); | |
471086d6 | 7529 | else |
7530 | ctype = TYPE_METHOD_BASETYPE (type); | |
7531 | } | |
7532 | if (ctype != NULL_TREE) | |
7533 | grok_method_quals (ctype, decl, quals); | |
7534 | } | |
7535 | ||
6493c502 | 7536 | if (signed_p |
471086d6 | 7537 | || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))) |
7538 | C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1; | |
7539 | ||
491e04ef | 7540 | bad_specifiers (decl, "type", virtualp, quals != TYPE_UNQUALIFIED, |
1e28ccf1 | 7541 | inlinep, friendp, raises != NULL_TREE); |
7542 | ||
471086d6 | 7543 | return decl; |
7544 | } | |
7545 | ||
7546 | /* Detect the case of an array type of unspecified size | |
7547 | which came, as such, direct from a typedef name. | |
47fd99f9 | 7548 | We must copy the type, so that the array's domain can be |
7549 | individually set by the object's initializer. */ | |
471086d6 | 7550 | |
47fd99f9 | 7551 | if (type && typedef_type |
7552 | && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type) | |
119c9424 | 7553 | && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type)) |
47fd99f9 | 7554 | type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE); |
471086d6 | 7555 | |
54da4cc8 | 7556 | /* Detect where we're using a typedef of function type to declare a |
7ef14399 | 7557 | function. PARMS will not be set, so we must create it now. */ |
491e04ef | 7558 | |
54da4cc8 | 7559 | if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE) |
7560 | { | |
7561 | tree decls = NULL_TREE; | |
7562 | tree args; | |
7563 | ||
7564 | for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args)) | |
7565 | { | |
d145d8d5 | 7566 | tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args)); |
54da4cc8 | 7567 | |
7568 | TREE_CHAIN (decl) = decls; | |
7569 | decls = decl; | |
7570 | } | |
491e04ef | 7571 | |
7ef14399 | 7572 | parms = nreverse (decls); |
54da4cc8 | 7573 | } |
7574 | ||
471086d6 | 7575 | /* If this is a type name (such as, in a cast or sizeof), |
7576 | compute the type and return it now. */ | |
7577 | ||
7578 | if (decl_context == TYPENAME) | |
7579 | { | |
7580 | /* Note that the grammar rejects storage classes | |
7581 | in typenames, fields or parameters. */ | |
3e04bd45 | 7582 | if (type_quals != TYPE_UNQUALIFIED) |
771665d8 | 7583 | type_quals = TYPE_UNQUALIFIED; |
471086d6 | 7584 | |
7585 | /* Special case: "friend class foo" looks like a TYPENAME context. */ | |
7586 | if (friendp) | |
7587 | { | |
3e04bd45 | 7588 | if (type_quals != TYPE_UNQUALIFIED) |
1e66592c | 7589 | { |
cf103c6c | 7590 | error ("type qualifiers specified for friend class declaration"); |
3e04bd45 | 7591 | type_quals = TYPE_UNQUALIFIED; |
1e66592c | 7592 | } |
7593 | if (inlinep) | |
7594 | { | |
cf103c6c | 7595 | error ("`inline' specified for friend class declaration"); |
1e66592c | 7596 | inlinep = 0; |
7597 | } | |
cb4cc35f | 7598 | |
55ebab6e | 7599 | if (!current_aggr) |
eccec853 | 7600 | { |
55ebab6e | 7601 | /* Don't allow friend declaration without a class-key. */ |
eccec853 | 7602 | if (TREE_CODE (type) == TEMPLATE_TYPE_PARM) |
55ebab6e | 7603 | pedwarn ("template parameters cannot be friends"); |
cb4cc35f | 7604 | else if (TREE_CODE (type) == TYPENAME_TYPE) |
55ebab6e | 7605 | pedwarn ("friend declaration requires class-key, " |
7606 | "i.e. `friend class %T::%D'", | |
7607 | TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type)); | |
eccec853 | 7608 | else |
55ebab6e | 7609 | pedwarn ("friend declaration requires class-key, " |
7610 | "i.e. `friend %#T'", | |
7611 | type); | |
eccec853 | 7612 | } |
1e66592c | 7613 | |
7614 | /* Only try to do this stuff if we didn't already give up. */ | |
7615 | if (type != integer_type_node) | |
7616 | { | |
7617 | /* A friendly class? */ | |
7618 | if (current_class_type) | |
b123b79d | 7619 | make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type), |
7620 | /*complain=*/true); | |
1e66592c | 7621 | else |
cf103c6c | 7622 | error ("trying to make class `%T' a friend of global scope", |
a0ec9fa5 | 7623 | type); |
20c01ba9 | 7624 | |
1e66592c | 7625 | type = void_type_node; |
7626 | } | |
471086d6 | 7627 | } |
7628 | else if (quals) | |
7629 | { | |
471086d6 | 7630 | if (ctype == NULL_TREE) |
7631 | { | |
7b2c7b37 | 7632 | if (TREE_CODE (type) != METHOD_TYPE) |
cf103c6c | 7633 | error ("invalid qualifiers on non-member function type"); |
7b2c7b37 | 7634 | else |
7635 | ctype = TYPE_METHOD_BASETYPE (type); | |
7636 | } | |
7637 | if (ctype) | |
7638 | { | |
3046c0a3 | 7639 | tree dummy = build_decl (TYPE_DECL, unqualified_id, type); |
7b2c7b37 | 7640 | grok_method_quals (ctype, dummy, quals); |
7641 | type = TREE_TYPE (dummy); | |
471086d6 | 7642 | } |
471086d6 | 7643 | } |
7644 | ||
7645 | return type; | |
7646 | } | |
3046c0a3 | 7647 | else if (unqualified_id == NULL_TREE && decl_context != PARM |
c25194fd | 7648 | && decl_context != CATCHPARM |
471086d6 | 7649 | && TREE_CODE (type) != UNION_TYPE |
7650 | && ! bitfield) | |
7651 | { | |
cf103c6c | 7652 | error ("abstract declarator `%T' used as declaration", type); |
3046c0a3 | 7653 | unqualified_id = make_anon_name (); |
471086d6 | 7654 | } |
7655 | ||
7656 | /* `void' at top level (not within pointer) | |
7657 | is allowed only in typedefs or type names. | |
7658 | We don't complain about parms either, but that is because | |
7659 | a better error message can be made later. */ | |
7660 | ||
f468434d | 7661 | if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM) |
471086d6 | 7662 | { |
3046c0a3 | 7663 | if (! unqualified_id) |
905d4035 | 7664 | error ("unnamed variable or field declared void"); |
3046c0a3 | 7665 | else if (TREE_CODE (unqualified_id) == IDENTIFIER_NODE) |
471086d6 | 7666 | { |
092b1d6f | 7667 | gcc_assert (!IDENTIFIER_OPNAME_P (unqualified_id)); |
7668 | error ("variable or field `%s' declared void", name); | |
471086d6 | 7669 | } |
7670 | else | |
905d4035 | 7671 | error ("variable or field declared void"); |
471086d6 | 7672 | type = integer_type_node; |
7673 | } | |
7674 | ||
7675 | /* Now create the decl, which may be a VAR_DECL, a PARM_DECL | |
7676 | or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */ | |
7677 | ||
77b7e009 | 7678 | if (decl_context == PARM || decl_context == CATCHPARM) |
7679 | { | |
7680 | if (ctype || in_namespace) | |
7681 | error ("cannot use `::' in parameter declaration"); | |
7682 | ||
7683 | /* A parameter declared as an array of T is really a pointer to T. | |
7684 | One declared as a function is really a pointer to a function. | |
7685 | One declared as a member is really a pointer to member. */ | |
7686 | ||
7687 | if (TREE_CODE (type) == ARRAY_TYPE) | |
7688 | { | |
7689 | /* Transfer const-ness of array into that of type pointed to. */ | |
7690 | type = build_pointer_type (TREE_TYPE (type)); | |
3e04bd45 | 7691 | type_quals = TYPE_UNQUALIFIED; |
77b7e009 | 7692 | } |
7693 | else if (TREE_CODE (type) == FUNCTION_TYPE) | |
7694 | type = build_pointer_type (type); | |
77b7e009 | 7695 | } |
980877d7 | 7696 | |
471086d6 | 7697 | { |
cd16867a | 7698 | tree decl; |
471086d6 | 7699 | |
7700 | if (decl_context == PARM) | |
7701 | { | |
3046c0a3 | 7702 | decl = cp_build_parm_decl (unqualified_id, type); |
471086d6 | 7703 | |
2cfb6cde | 7704 | bad_specifiers (decl, "parameter", virtualp, quals != TYPE_UNQUALIFIED, |
471086d6 | 7705 | inlinep, friendp, raises != NULL_TREE); |
471086d6 | 7706 | } |
7707 | else if (decl_context == FIELD) | |
7708 | { | |
30bedc1f | 7709 | /* The C99 flexible array extension. */ |
7710 | if (!staticp && TREE_CODE (type) == ARRAY_TYPE | |
7711 | && TYPE_DOMAIN (type) == NULL_TREE) | |
7712 | { | |
7713 | tree itype = compute_array_index_type (dname, integer_zero_node); | |
7714 | type = build_cplus_array_type (TREE_TYPE (type), itype); | |
7715 | } | |
7716 | ||
471086d6 | 7717 | if (type == error_mark_node) |
7718 | { | |
7719 | /* Happens when declaring arrays of sizes which | |
7720 | are error_mark_node, for example. */ | |
7721 | decl = NULL_TREE; | |
7722 | } | |
4e8042b1 | 7723 | else if (in_namespace && !friendp) |
f50dc4d4 | 7724 | { |
7725 | /* Something like struct S { int N::j; }; */ | |
cf103c6c | 7726 | error ("invalid use of `::'"); |
f50dc4d4 | 7727 | decl = NULL_TREE; |
7728 | } | |
471086d6 | 7729 | else if (TREE_CODE (type) == FUNCTION_TYPE) |
7730 | { | |
7731 | int publicp = 0; | |
1146f179 | 7732 | tree function_context; |
471086d6 | 7733 | |
3d4e092a | 7734 | /* We catch the others as conflicts with the builtin |
7735 | typedefs. */ | |
3046c0a3 | 7736 | if (friendp && unqualified_id == ridpointers[(int) RID_SIGNED]) |
3d4e092a | 7737 | { |
cf103c6c | 7738 | error ("function `%D' cannot be declared friend", |
3046c0a3 | 7739 | unqualified_id); |
3d4e092a | 7740 | friendp = 0; |
7741 | } | |
7742 | ||
471086d6 | 7743 | if (friendp == 0) |
7744 | { | |
7745 | if (ctype == NULL_TREE) | |
7746 | ctype = current_class_type; | |
7747 | ||
7748 | if (ctype == NULL_TREE) | |
7749 | { | |
cf103c6c | 7750 | error ("can't make `%D' into a method -- not in a class", |
3046c0a3 | 7751 | unqualified_id); |
471086d6 | 7752 | return void_type_node; |
7753 | } | |
7754 | ||
7755 | /* ``A union may [ ... ] not [ have ] virtual functions.'' | |
7756 | ARM 9.5 */ | |
7757 | if (virtualp && TREE_CODE (ctype) == UNION_TYPE) | |
7758 | { | |
cf103c6c | 7759 | error ("function `%D' declared virtual inside a union", |
3046c0a3 | 7760 | unqualified_id); |
471086d6 | 7761 | return void_type_node; |
7762 | } | |
7763 | ||
3046c0a3 | 7764 | if (NEW_DELETE_OPNAME_P (unqualified_id)) |
471086d6 | 7765 | { |
7766 | if (virtualp) | |
7767 | { | |
cf103c6c | 7768 | error ("`%D' cannot be declared virtual, since it is always static", |
3046c0a3 | 7769 | unqualified_id); |
471086d6 | 7770 | virtualp = 0; |
7771 | } | |
7772 | } | |
7773 | else if (staticp < 2) | |
491e04ef | 7774 | type = build_method_type_directly (ctype, |
5bfb0742 | 7775 | TREE_TYPE (type), |
7776 | TYPE_ARG_TYPES (type)); | |
471086d6 | 7777 | } |
7778 | ||
7779 | /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */ | |
980877d7 | 7780 | function_context = (ctype != NULL_TREE) ? |
9ba4048d | 7781 | decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE; |
1146f179 | 7782 | publicp = (! friendp || ! staticp) |
7783 | && function_context == NULL_TREE; | |
980877d7 | 7784 | decl = grokfndecl (ctype, type, |
3046c0a3 | 7785 | TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR |
7786 | ? unqualified_id : dname, | |
7ef14399 | 7787 | parms, |
3046c0a3 | 7788 | unqualified_id, |
607f6131 | 7789 | virtualp, flags, quals, raises, |
b1cfe2be | 7790 | friendp ? -1 : 0, friendp, publicp, inlinep, |
8417823c | 7791 | funcdef_flag, template_count, in_namespace); |
e0d8778b | 7792 | if (decl == NULL_TREE) |
76c1ba40 | 7793 | return decl; |
7d85c040 | 7794 | #if 0 |
7795 | /* This clobbers the attrs stored in `decl' from `attrlist'. */ | |
e3c541f0 | 7796 | /* The decl and setting of decl_attr is also turned off. */ |
7797 | decl = build_decl_attribute_variant (decl, decl_attr); | |
7d85c040 | 7798 | #endif |
617abf06 | 7799 | |
6c5af975 | 7800 | /* [class.conv.ctor] |
7801 | ||
7802 | A constructor declared without the function-specifier | |
7803 | explicit that can be called with a single parameter | |
7804 | specifies a conversion from the type of its first | |
7805 | parameter to the type of its class. Such a constructor | |
7806 | is called a converting constructor. */ | |
c25194fd | 7807 | if (explicitp == 2) |
7808 | DECL_NONCONVERTING_P (decl) = 1; | |
6c5af975 | 7809 | else if (DECL_CONSTRUCTOR_P (decl)) |
7810 | { | |
7811 | /* The constructor can be called with exactly one | |
7812 | parameter if there is at least one parameter, and | |
7813 | any subsequent parameters have default arguments. | |
dcbeb3ef | 7814 | Ignore any compiler-added parms. */ |
7815 | tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl); | |
6c5af975 | 7816 | |
7817 | if (arg_types == void_list_node | |
980877d7 | 7818 | || (arg_types |
7819 | && TREE_CHAIN (arg_types) | |
6c5af975 | 7820 | && TREE_CHAIN (arg_types) != void_list_node |
7821 | && !TREE_PURPOSE (TREE_CHAIN (arg_types)))) | |
7822 | DECL_NONCONVERTING_P (decl) = 1; | |
7823 | } | |
471086d6 | 7824 | } |
7825 | else if (TREE_CODE (type) == METHOD_TYPE) | |
7826 | { | |
bb09dca5 | 7827 | /* We only get here for friend declarations of |
7828 | members of other classes. */ | |
471086d6 | 7829 | /* All method decls are public, so tell grokfndecl to set |
7830 | TREE_PUBLIC, also. */ | |
6994351f | 7831 | decl = grokfndecl (ctype, type, |
3046c0a3 | 7832 | TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR |
7833 | ? unqualified_id : dname, | |
7ef14399 | 7834 | parms, |
3046c0a3 | 7835 | unqualified_id, |
607f6131 | 7836 | virtualp, flags, quals, raises, |
b1cfe2be | 7837 | friendp ? -1 : 0, friendp, 1, 0, funcdef_flag, |
8417823c | 7838 | template_count, in_namespace); |
617abf06 | 7839 | if (decl == NULL_TREE) |
7840 | return NULL_TREE; | |
471086d6 | 7841 | } |
d2b38b0e | 7842 | else if (!staticp && !dependent_type_p (type) |
4b72716d | 7843 | && !COMPLETE_TYPE_P (complete_type (type)) |
471086d6 | 7844 | && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0)) |
7845 | { | |
3046c0a3 | 7846 | if (unqualified_id) |
7847 | error ("field `%D' has incomplete type", unqualified_id); | |
1e66592c | 7848 | else |
cf103c6c | 7849 | error ("name `%T' has incomplete type", type); |
471086d6 | 7850 | |
7851 | /* If we're instantiating a template, tell them which | |
7852 | instantiation made the field's type be incomplete. */ | |
7853 | if (current_class_type | |
7854 | && TYPE_NAME (current_class_type) | |
b0df6589 | 7855 | && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type)) |
4b9b2871 | 7856 | && declspecs->type |
7857 | && declspecs->type == type) | |
cf103c6c | 7858 | error (" in instantiation of template `%T'", |
c25194fd | 7859 | current_class_type); |
7860 | ||
471086d6 | 7861 | type = error_mark_node; |
7862 | decl = NULL_TREE; | |
7863 | } | |
7864 | else | |
7865 | { | |
7866 | if (friendp) | |
7867 | { | |
286daa79 | 7868 | error ("`%E' is neither function nor member function; " |
3046c0a3 | 7869 | "cannot be declared friend", unqualified_id); |
471086d6 | 7870 | friendp = 0; |
7871 | } | |
7872 | decl = NULL_TREE; | |
7873 | } | |
7874 | ||
7875 | if (friendp) | |
7876 | { | |
7877 | /* Friends are treated specially. */ | |
7878 | if (ctype == current_class_type) | |
905d4035 | 7879 | warning ("member functions are implicitly friends of their class"); |
69b6679c | 7880 | else if (decl && DECL_NAME (decl)) |
7881 | { | |
7882 | if (template_class_depth (current_class_type) == 0) | |
7883 | { | |
7884 | decl = check_explicit_specialization | |
3046c0a3 | 7885 | (unqualified_id, decl, template_count, |
69b6679c | 7886 | 2 * (funcdef_flag != 0) + 4); |
7887 | if (decl == error_mark_node) | |
7888 | return error_mark_node; | |
7889 | } | |
491e04ef | 7890 | |
3046c0a3 | 7891 | decl = do_friend (ctype, unqualified_id, decl, |
7ef14399 | 7892 | *attrlist, flags, quals, funcdef_flag); |
69b6679c | 7893 | return decl; |
7894 | } | |
7895 | else | |
7896 | return void_type_node; | |
471086d6 | 7897 | } |
7898 | ||
331bc0ad | 7899 | /* Structure field. It may not be a function, except for C++. */ |
471086d6 | 7900 | |
7901 | if (decl == NULL_TREE) | |
7902 | { | |
471086d6 | 7903 | if (initialized) |
7904 | { | |
1ca935fd | 7905 | if (!staticp) |
7906 | { | |
7907 | /* An attempt is being made to initialize a non-static | |
7908 | member. But, from [class.mem]: | |
980877d7 | 7909 | |
1ca935fd | 7910 | 4 A member-declarator can contain a |
7911 | constant-initializer only if it declares a static | |
7912 | member (_class.static_) of integral or enumeration | |
980877d7 | 7913 | type, see _class.static.data_. |
1ca935fd | 7914 | |
7915 | This used to be relatively common practice, but | |
7916 | the rest of the compiler does not correctly | |
7917 | handle the initialization unless the member is | |
7918 | static so we make it static below. */ | |
cf103c6c | 7919 | pedwarn ("ISO C++ forbids initialization of member `%D'", |
3046c0a3 | 7920 | unqualified_id); |
7921 | pedwarn ("making `%D' static", unqualified_id); | |
1ca935fd | 7922 | staticp = 1; |
7923 | } | |
7924 | ||
df5066e2 | 7925 | if (uses_template_parms (type)) |
7926 | /* We'll check at instantiation time. */ | |
7927 | ; | |
3046c0a3 | 7928 | else if (check_static_variable_definition (unqualified_id, |
df5066e2 | 7929 | type)) |
7930 | /* If we just return the declaration, crashes | |
7931 | will sometimes occur. We therefore return | |
37b8b0d0 | 7932 | void_type_node, as if this was a friend |
7933 | declaration, to cause callers to completely | |
7934 | ignore this declaration. */ | |
df5066e2 | 7935 | return void_type_node; |
471086d6 | 7936 | } |
7937 | ||
1ca935fd | 7938 | if (staticp) |
471086d6 | 7939 | { |
2ee03578 | 7940 | /* C++ allows static class members. All other work |
7941 | for this is done by grokfield. */ | |
3046c0a3 | 7942 | decl = build_lang_decl (VAR_DECL, unqualified_id, type); |
caa6fdce | 7943 | set_linkage_for_static_data_member (decl); |
7944 | /* Even if there is an in-class initialization, DECL | |
7945 | is considered undefined until an out-of-class | |
7946 | definition is provided. */ | |
7947 | DECL_EXTERNAL (decl) = 1; | |
471086d6 | 7948 | } |
7949 | else | |
7950 | { | |
3046c0a3 | 7951 | decl = build_decl (FIELD_DECL, unqualified_id, type); |
851dfbff | 7952 | DECL_NONADDRESSABLE_P (decl) = bitfield; |
6493c502 | 7953 | if (storage_class == sc_mutable) |
471086d6 | 7954 | { |
7955 | DECL_MUTABLE_P (decl) = 1; | |
6493c502 | 7956 | storage_class = sc_none; |
471086d6 | 7957 | } |
7958 | } | |
7959 | ||
2cfb6cde | 7960 | bad_specifiers (decl, "field", virtualp, quals != TYPE_UNQUALIFIED, |
471086d6 | 7961 | inlinep, friendp, raises != NULL_TREE); |
7962 | } | |
7963 | } | |
e310e8dd | 7964 | else if (TREE_CODE (type) == FUNCTION_TYPE |
7965 | || TREE_CODE (type) == METHOD_TYPE) | |
471086d6 | 7966 | { |
b1cfe2be | 7967 | tree original_name; |
471086d6 | 7968 | int publicp = 0; |
7969 | ||
3046c0a3 | 7970 | if (!unqualified_id) |
471086d6 | 7971 | return NULL_TREE; |
7972 | ||
3046c0a3 | 7973 | if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR) |
b1cfe2be | 7974 | original_name = dname; |
7975 | else | |
3046c0a3 | 7976 | original_name = unqualified_id; |
b1cfe2be | 7977 | |
6493c502 | 7978 | if (storage_class == sc_auto) |
905d4035 | 7979 | error ("storage class `auto' invalid for function `%s'", name); |
6493c502 | 7980 | else if (storage_class == sc_register) |
905d4035 | 7981 | error ("storage class `register' invalid for function `%s'", name); |
6493c502 | 7982 | else if (thread_p) |
e396cd54 | 7983 | error ("storage class `__thread' invalid for function `%s'", name); |
471086d6 | 7984 | |
7985 | /* Function declaration not at top level. | |
7986 | Storage classes other than `extern' are not allowed | |
7987 | and `extern' makes no difference. */ | |
d0622bdf | 7988 | if (! toplevel_bindings_p () |
6493c502 | 7989 | && (storage_class == sc_static |
4b9b2871 | 7990 | || declspecs->specs[(int)ds_inline]) |
471086d6 | 7991 | && pedantic) |
0543e7a9 | 7992 | { |
6493c502 | 7993 | if (storage_class == sc_static) |
4b9b2871 | 7994 | pedwarn ("`static' specified invalid for function `%s' declared out of global scope", name); |
0543e7a9 | 7995 | else |
4b9b2871 | 7996 | pedwarn ("`inline' specifier invalid for function `%s' declared out of global scope", name); |
0543e7a9 | 7997 | } |
980877d7 | 7998 | |
471086d6 | 7999 | if (ctype == NULL_TREE) |
8000 | { | |
8001 | if (virtualp) | |
8002 | { | |
905d4035 | 8003 | error ("virtual non-class function `%s'", name); |
471086d6 | 8004 | virtualp = 0; |
8005 | } | |
471086d6 | 8006 | } |
7ef14399 | 8007 | else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2 |
8008 | && !NEW_DELETE_OPNAME_P (original_name)) | |
491e04ef | 8009 | type = build_method_type_directly (ctype, |
5bfb0742 | 8010 | TREE_TYPE (type), |
8011 | TYPE_ARG_TYPES (type)); | |
471086d6 | 8012 | |
c76251c1 | 8013 | /* Record presence of `static'. */ |
bb09dca5 | 8014 | publicp = (ctype != NULL_TREE |
6493c502 | 8015 | || storage_class == sc_extern |
8016 | || storage_class != sc_static); | |
471086d6 | 8017 | |
3046c0a3 | 8018 | decl = grokfndecl (ctype, type, original_name, parms, unqualified_id, |
607f6131 | 8019 | virtualp, flags, quals, raises, |
668ae905 | 8020 | 1, friendp, |
980877d7 | 8021 | publicp, inlinep, funcdef_flag, |
8417823c | 8022 | template_count, in_namespace); |
617abf06 | 8023 | if (decl == NULL_TREE) |
8024 | return NULL_TREE; | |
471086d6 | 8025 | |
471086d6 | 8026 | if (staticp == 1) |
8027 | { | |
6c0cc2cd | 8028 | int invalid_static = 0; |
471086d6 | 8029 | |
8030 | /* Don't allow a static member function in a class, and forbid | |
8031 | declaring main to be static. */ | |
8032 | if (TREE_CODE (type) == METHOD_TYPE) | |
8033 | { | |
cf103c6c | 8034 | pedwarn ("cannot declare member function `%D' to have static linkage", decl); |
6c0cc2cd | 8035 | invalid_static = 1; |
471086d6 | 8036 | } |
471086d6 | 8037 | else if (current_function_decl) |
8038 | { | |
8039 | /* FIXME need arm citation */ | |
905d4035 | 8040 | error ("cannot declare static function inside another function"); |
6c0cc2cd | 8041 | invalid_static = 1; |
471086d6 | 8042 | } |
8043 | ||
6c0cc2cd | 8044 | if (invalid_static) |
471086d6 | 8045 | { |
8046 | staticp = 0; | |
6493c502 | 8047 | storage_class = sc_none; |
471086d6 | 8048 | } |
8049 | } | |
471086d6 | 8050 | } |
8051 | else | |
8052 | { | |
8053 | /* It's a variable. */ | |
8054 | ||
8055 | /* An uninitialized decl with `extern' is a reference. */ | |
491e04ef | 8056 | decl = grokvardecl (type, unqualified_id, |
4b9b2871 | 8057 | declspecs, |
980877d7 | 8058 | initialized, |
8059 | (type_quals & TYPE_QUAL_CONST) != 0, | |
3645386f | 8060 | ctype ? ctype : in_namespace); |
2cfb6cde | 8061 | bad_specifiers (decl, "variable", virtualp, quals != TYPE_UNQUALIFIED, |
471086d6 | 8062 | inlinep, friendp, raises != NULL_TREE); |
8063 | ||
8064 | if (ctype) | |
8065 | { | |
617abf06 | 8066 | DECL_CONTEXT (decl) = ctype; |
471086d6 | 8067 | if (staticp == 1) |
8068 | { | |
cf103c6c | 8069 | pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member"); |
471086d6 | 8070 | staticp = 0; |
6493c502 | 8071 | storage_class = sc_none; |
471086d6 | 8072 | } |
6493c502 | 8073 | if (storage_class == sc_register && TREE_STATIC (decl)) |
1e66592c | 8074 | { |
cf103c6c | 8075 | error ("static member `%D' declared `register'", decl); |
6493c502 | 8076 | storage_class = sc_none; |
1e66592c | 8077 | } |
6493c502 | 8078 | if (storage_class == sc_extern && pedantic) |
471086d6 | 8079 | { |
cf103c6c | 8080 | pedwarn ("cannot explicitly declare member `%#D' to have extern linkage", |
ce28ee2e | 8081 | decl); |
6493c502 | 8082 | storage_class = sc_none; |
471086d6 | 8083 | } |
8084 | } | |
8085 | } | |
8086 | ||
471086d6 | 8087 | /* Record `register' declaration for warnings on & |
8088 | and in case doing stupid register allocation. */ | |
8089 | ||
6493c502 | 8090 | if (storage_class == sc_register) |
471086d6 | 8091 | DECL_REGISTER (decl) = 1; |
6493c502 | 8092 | else if (storage_class == sc_extern) |
0543e7a9 | 8093 | DECL_THIS_EXTERN (decl) = 1; |
6493c502 | 8094 | else if (storage_class == sc_static) |
bb09dca5 | 8095 | DECL_THIS_STATIC (decl) = 1; |
8096 | ||
e9c0ac6a | 8097 | /* Record constancy and volatility. There's no need to do this |
8098 | when processing a template; we'll do this for the instantiated | |
8099 | declaration based on the type of DECL. */ | |
8100 | if (!processing_template_decl) | |
8101 | c_apply_type_quals_to_decl (type_quals, decl); | |
471086d6 | 8102 | |
8103 | return decl; | |
8104 | } | |
8105 | } | |
8106 | \f | |
53137e6a | 8107 | /* Subroutine of start_function. Ensure that each of the parameter |
8108 | types (as listed in PARMS) is complete, as is required for a | |
8109 | function definition. */ | |
96624a9e | 8110 | |
471086d6 | 8111 | static void |
1b72315d | 8112 | require_complete_types_for_parms (tree parms) |
471086d6 | 8113 | { |
3d411d73 | 8114 | for (; parms; parms = TREE_CHAIN (parms)) |
471086d6 | 8115 | { |
1d75985e | 8116 | if (VOID_TYPE_P (TREE_TYPE (parms))) |
331bc0ad | 8117 | /* grokparms will have already issued an error. */ |
1d75985e | 8118 | TREE_TYPE (parms) = error_mark_node; |
8119 | else if (complete_type_or_else (TREE_TYPE (parms), parms)) | |
4c9d06ba | 8120 | { |
8121 | layout_decl (parms, 0); | |
8122 | DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms)); | |
8123 | } | |
471086d6 | 8124 | } |
8125 | } | |
8126 | ||
3160db1d | 8127 | /* Returns nonzero if T is a local variable. */ |
74410faa | 8128 | |
31236dcd | 8129 | int |
1b72315d | 8130 | local_variable_p (tree t) |
74410faa | 8131 | { |
980877d7 | 8132 | if ((TREE_CODE (t) == VAR_DECL |
74410faa | 8133 | /* A VAR_DECL with a context that is a _TYPE is a static data |
8134 | member. */ | |
8135 | && !TYPE_P (CP_DECL_CONTEXT (t)) | |
8136 | /* Any other non-local variable must be at namespace scope. */ | |
31236dcd | 8137 | && !DECL_NAMESPACE_SCOPE_P (t)) |
74410faa | 8138 | || (TREE_CODE (t) == PARM_DECL)) |
31236dcd | 8139 | return 1; |
74410faa | 8140 | |
31236dcd | 8141 | return 0; |
8142 | } | |
8143 | ||
3160db1d | 8144 | /* Returns nonzero if T is an automatic local variable or a label. |
31236dcd | 8145 | (These are the declarations that need to be remapped when the code |
8146 | containing them is duplicated.) */ | |
8147 | ||
8148 | int | |
1b72315d | 8149 | nonstatic_local_decl_p (tree t) |
31236dcd | 8150 | { |
8151 | return ((local_variable_p (t) && !TREE_STATIC (t)) | |
8152 | || TREE_CODE (t) == LABEL_DECL | |
8153 | || TREE_CODE (t) == RESULT_DECL); | |
8154 | } | |
8155 | ||
8156 | /* Like local_variable_p, but suitable for use as a tree-walking | |
8157 | function. */ | |
8158 | ||
8159 | static tree | |
6374121b | 8160 | local_variable_p_walkfn (tree *tp, int *walk_subtrees, |
8161 | void *data ATTRIBUTE_UNUSED) | |
31236dcd | 8162 | { |
6374121b | 8163 | if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp)) |
8164 | return *tp; | |
8165 | else if (TYPE_P (*tp)) | |
8166 | *walk_subtrees = 0; | |
8167 | ||
8168 | return NULL_TREE; | |
74410faa | 8169 | } |
8170 | ||
6374121b | 8171 | |
74410faa | 8172 | /* Check that ARG, which is a default-argument expression for a |
6c0cc2cd | 8173 | parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if |
74410faa | 8174 | something goes wrong. DECL may also be a _TYPE node, rather than a |
8175 | DECL, if there is no DECL available. */ | |
8176 | ||
8177 | tree | |
1b72315d | 8178 | check_default_argument (tree decl, tree arg) |
74410faa | 8179 | { |
8180 | tree var; | |
8181 | tree decl_type; | |
8182 | ||
8183 | if (TREE_CODE (arg) == DEFAULT_ARG) | |
8184 | /* We get a DEFAULT_ARG when looking at an in-class declaration | |
8185 | with a default argument. Ignore the argument for now; we'll | |
8186 | deal with it after the class is complete. */ | |
8187 | return arg; | |
8188 | ||
8189 | if (processing_template_decl || uses_template_parms (arg)) | |
8190 | /* We don't do anything checking until instantiation-time. Note | |
8191 | that there may be uninstantiated arguments even for an | |
8192 | instantiated function, since default arguments are not | |
8193 | instantiated until they are needed. */ | |
8194 | return arg; | |
8195 | ||
8196 | if (TYPE_P (decl)) | |
8197 | { | |
8198 | decl_type = decl; | |
8199 | decl = NULL_TREE; | |
8200 | } | |
8201 | else | |
8202 | decl_type = TREE_TYPE (decl); | |
8203 | ||
980877d7 | 8204 | if (arg == error_mark_node |
74410faa | 8205 | || decl == error_mark_node |
8206 | || TREE_TYPE (arg) == error_mark_node | |
8207 | || decl_type == error_mark_node) | |
8208 | /* Something already went wrong. There's no need to check | |
8209 | further. */ | |
8210 | return error_mark_node; | |
8211 | ||
8212 | /* [dcl.fct.default] | |
980877d7 | 8213 | |
74410faa | 8214 | A default argument expression is implicitly converted to the |
8215 | parameter type. */ | |
8216 | if (!TREE_TYPE (arg) | |
8217 | || !can_convert_arg (decl_type, TREE_TYPE (arg), arg)) | |
8218 | { | |
8219 | if (decl) | |
cf103c6c | 8220 | error ("default argument for `%#D' has type `%T'", |
74410faa | 8221 | decl, TREE_TYPE (arg)); |
8222 | else | |
cf103c6c | 8223 | error ("default argument for parameter of type `%T' has type `%T'", |
74410faa | 8224 | decl_type, TREE_TYPE (arg)); |
8225 | ||
8226 | return error_mark_node; | |
8227 | } | |
8228 | ||
8229 | /* [dcl.fct.default] | |
8230 | ||
8231 | Local variables shall not be used in default argument | |
980877d7 | 8232 | expressions. |
74410faa | 8233 | |
8234 | The keyword `this' shall not be used in a default argument of a | |
8235 | member function. */ | |
3c3beda6 | 8236 | var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn, |
39adccd6 | 8237 | NULL); |
74410faa | 8238 | if (var) |
8239 | { | |
cf103c6c | 8240 | error ("default argument `%E' uses local variable `%D'", |
74410faa | 8241 | arg, var); |
8242 | return error_mark_node; | |
8243 | } | |
8244 | ||
8245 | /* All is well. */ | |
8246 | return arg; | |
8247 | } | |
8248 | ||
471086d6 | 8249 | /* Decode the list of parameter types for a function type. |
8250 | Given the list of things declared inside the parens, | |
8251 | return a list of types. | |
8252 | ||
3046c0a3 | 8253 | If this parameter does not end with an ellipsis, we append |
8254 | void_list_node. | |
1d75985e | 8255 | |
7ef14399 | 8256 | *PARMS is set to the chain of PARM_DECLs created. */ |
471086d6 | 8257 | |
8258 | static tree | |
4b9b2871 | 8259 | grokparms (cp_parameter_declarator *first_parm, tree *parms) |
471086d6 | 8260 | { |
8261 | tree result = NULL_TREE; | |
8262 | tree decls = NULL_TREE; | |
3046c0a3 | 8263 | int ellipsis = !first_parm || first_parm->ellipsis_p; |
4b9b2871 | 8264 | cp_parameter_declarator *parm; |
1d75985e | 8265 | int any_error = 0; |
471086d6 | 8266 | |
3046c0a3 | 8267 | for (parm = first_parm; parm != NULL; parm = parm->next) |
471086d6 | 8268 | { |
8bc97186 | 8269 | tree type = NULL_TREE; |
3046c0a3 | 8270 | tree init = parm->default_argument; |
4b9b2871 | 8271 | tree attrs; |
3046c0a3 | 8272 | tree decl; |
471086d6 | 8273 | |
3046c0a3 | 8274 | if (parm == no_parameters) |
1d75985e | 8275 | break; |
471086d6 | 8276 | |
4b9b2871 | 8277 | attrs = parm->decl_specifiers.attributes; |
8278 | parm->decl_specifiers.attributes = NULL_TREE; | |
8279 | decl = grokdeclarator (parm->declarator, &parm->decl_specifiers, | |
bf2bc322 | 8280 | PARM, init != NULL_TREE, &attrs); |
1d75985e | 8281 | if (! decl || TREE_TYPE (decl) == error_mark_node) |
8282 | continue; | |
20c01ba9 | 8283 | |
bf2bc322 | 8284 | if (attrs) |
8285 | cplus_decl_attributes (&decl, attrs, 0); | |
8286 | ||
1d75985e | 8287 | type = TREE_TYPE (decl); |
8288 | if (VOID_TYPE_P (type)) | |
8289 | { | |
8290 | if (same_type_p (type, void_type_node) | |
3046c0a3 | 8291 | && !DECL_NAME (decl) && !result && !parm->next && !ellipsis) |
1d75985e | 8292 | /* this is a parmlist of `(void)', which is ok. */ |
8293 | break; | |
1dd25100 | 8294 | cxx_incomplete_type_error (decl, type); |
8bc97186 | 8295 | /* It's not a good idea to actually create parameters of |
8296 | type `void'; other parts of the compiler assume that a | |
8297 | void type terminates the parameter list. */ | |
0cd69b17 | 8298 | type = error_mark_node; |
8bc97186 | 8299 | TREE_TYPE (decl) = error_mark_node; |
1d75985e | 8300 | } |
471086d6 | 8301 | |
20c01ba9 | 8302 | if (type != error_mark_node) |
0cd69b17 | 8303 | { |
8304 | /* Top-level qualifiers on the parameters are | |
8305 | ignored for function types. */ | |
66521570 | 8306 | type = cp_build_qualified_type (type, 0); |
0cd69b17 | 8307 | if (TREE_CODE (type) == METHOD_TYPE) |
8308 | { | |
cf103c6c | 8309 | error ("parameter `%D' invalidly declared method type", decl); |
0cd69b17 | 8310 | type = build_pointer_type (type); |
8311 | TREE_TYPE (decl) = type; | |
8312 | } | |
0cd69b17 | 8313 | else if (abstract_virtuals_error (decl, type)) |
a109dc3b | 8314 | any_error = 1; /* Seems like a good idea. */ |
0cd69b17 | 8315 | else if (POINTER_TYPE_P (type)) |
8316 | { | |
8317 | /* [dcl.fct]/6, parameter types cannot contain pointers | |
8318 | (references) to arrays of unknown bound. */ | |
3b6baa6d | 8319 | tree t = TREE_TYPE (type); |
8320 | int ptr = TYPE_PTR_P (type); | |
8321 | ||
8322 | while (1) | |
8323 | { | |
8324 | if (TYPE_PTR_P (t)) | |
8325 | ptr = 1; | |
8326 | else if (TREE_CODE (t) != ARRAY_TYPE) | |
8327 | break; | |
8328 | else if (!TYPE_DOMAIN (t)) | |
8329 | break; | |
8330 | t = TREE_TYPE (t); | |
8331 | } | |
0cd69b17 | 8332 | if (TREE_CODE (t) == ARRAY_TYPE) |
cf103c6c | 8333 | error ("parameter `%D' includes %s to array of unknown bound `%T'", |
3b6baa6d | 8334 | decl, ptr ? "pointer" : "reference", t); |
0cd69b17 | 8335 | } |
8336 | ||
0cd69b17 | 8337 | if (!any_error && init) |
43895b7f | 8338 | init = check_default_argument (decl, init); |
0cd69b17 | 8339 | else |
8340 | init = NULL_TREE; | |
8341 | } | |
471086d6 | 8342 | |
1d75985e | 8343 | TREE_CHAIN (decl) = decls; |
8344 | decls = decl; | |
8bc97186 | 8345 | result = tree_cons (init, type, result); |
471086d6 | 8346 | } |
1d75985e | 8347 | decls = nreverse (decls); |
8348 | result = nreverse (result); | |
8349 | if (!ellipsis) | |
8350 | result = chainon (result, void_list_node); | |
7ef14399 | 8351 | *parms = decls; |
471086d6 | 8352 | |
471086d6 | 8353 | return result; |
8354 | } | |
03db3ebd | 8355 | |
471086d6 | 8356 | \f |
01779b5f | 8357 | /* D is a constructor or overloaded `operator='. |
8358 | ||
8359 | Let T be the class in which D is declared. Then, this function | |
8360 | returns: | |
8361 | ||
8362 | -1 if D's is an ill-formed constructor or copy assignment operator | |
8363 | whose first parameter is of type `T'. | |
8364 | 0 if D is not a copy constructor or copy assignment | |
8365 | operator. | |
8366 | 1 if D is a copy constructor or copy assignment operator whose | |
8367 | first parameter is a reference to const qualified T. | |
8368 | 2 if D is a copy constructor or copy assignment operator whose | |
8369 | first parameter is a reference to non-const qualified T. | |
8370 | ||
8371 | This function can be used as a predicate. Positive values indicate | |
3160db1d | 8372 | a copy constructor and nonzero values indicate a copy assignment |
9ba4048d | 8373 | operator. */ |
8374 | ||
f9670f72 | 8375 | int |
1b72315d | 8376 | copy_fn_p (tree d) |
f9670f72 | 8377 | { |
01779b5f | 8378 | tree args; |
8379 | tree arg_type; | |
8380 | int result = 1; | |
491e04ef | 8381 | |
b4df430b | 8382 | gcc_assert (DECL_FUNCTION_MEMBER_P (d)); |
9ba4048d | 8383 | |
01779b5f | 8384 | if (DECL_TEMPLATE_INFO (d) && is_member_template (DECL_TI_TEMPLATE (d))) |
8385 | /* Instantiations of template member functions are never copy | |
8386 | functions. Note that member functions of templated classes are | |
8387 | represented as template functions internally, and we must | |
8388 | accept those as copy functions. */ | |
8389 | return 0; | |
491e04ef | 8390 | |
01779b5f | 8391 | args = FUNCTION_FIRST_USER_PARMTYPE (d); |
8392 | if (!args) | |
9ba4048d | 8393 | return 0; |
8394 | ||
01779b5f | 8395 | arg_type = TREE_VALUE (args); |
8396 | ||
8397 | if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d)) | |
8398 | { | |
8399 | /* Pass by value copy assignment operator. */ | |
8400 | result = -1; | |
8401 | } | |
8402 | else if (TREE_CODE (arg_type) == REFERENCE_TYPE | |
8403 | && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d)) | |
8404 | { | |
8405 | if (CP_TYPE_CONST_P (TREE_TYPE (arg_type))) | |
8406 | result = 2; | |
8407 | } | |
8408 | else | |
8409 | return 0; | |
491e04ef | 8410 | |
01779b5f | 8411 | args = TREE_CHAIN (args); |
8412 | ||
8413 | if (args && args != void_list_node && !TREE_PURPOSE (args)) | |
8414 | /* There are more non-optional args. */ | |
8415 | return 0; | |
8416 | ||
8417 | return result; | |
8418 | } | |
8419 | ||
8420 | /* Remember any special properties of member function DECL. */ | |
8421 | ||
1b72315d | 8422 | void grok_special_member_properties (tree decl) |
01779b5f | 8423 | { |
8424 | if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl)) | |
8425 | ; /* Not special. */ | |
8426 | else if (DECL_CONSTRUCTOR_P (decl)) | |
8427 | { | |
8428 | int ctor = copy_fn_p (decl); | |
491e04ef | 8429 | |
01779b5f | 8430 | if (ctor > 0) |
8431 | { | |
8432 | /* [class.copy] | |
491e04ef | 8433 | |
01779b5f | 8434 | A non-template constructor for class X is a copy |
8435 | constructor if its first parameter is of type X&, const | |
8436 | X&, volatile X& or const volatile X&, and either there | |
8437 | are no other parameters or else all other parameters have | |
8438 | default arguments. */ | |
8439 | TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1; | |
8440 | if (ctor > 1) | |
8441 | TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1; | |
8442 | } | |
8443 | else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl))) | |
8444 | TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1; | |
8445 | } | |
8446 | else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR) | |
8447 | { | |
8448 | /* [class.copy] | |
491e04ef | 8449 | |
01779b5f | 8450 | A non-template assignment operator for class X is a copy |
8451 | assignment operator if its parameter is of type X, X&, const | |
8452 | X&, volatile X& or const volatile X&. */ | |
491e04ef | 8453 | |
01779b5f | 8454 | int assop = copy_fn_p (decl); |
491e04ef | 8455 | |
01779b5f | 8456 | if (assop) |
8457 | { | |
8458 | TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1; | |
8459 | if (assop != 1) | |
8460 | TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1; | |
01779b5f | 8461 | } |
8462 | } | |
f9670f72 | 8463 | } |
8464 | ||
01779b5f | 8465 | /* Check a constructor DECL has the correct form. Complains |
8466 | if the class has a constructor of the form X(X). */ | |
96624a9e | 8467 | |
ddb9bca7 | 8468 | int |
1b72315d | 8469 | grok_ctor_properties (tree ctype, tree decl) |
471086d6 | 8470 | { |
01779b5f | 8471 | int ctor_parm = copy_fn_p (decl); |
8472 | ||
8473 | if (ctor_parm < 0) | |
8474 | { | |
8475 | /* [class.copy] | |
491e04ef | 8476 | |
01779b5f | 8477 | A declaration of a constructor for a class X is ill-formed if |
8478 | its first parameter is of type (optionally cv-qualified) X | |
8479 | and either there are no other parameters or else all other | |
8480 | parameters have default arguments. | |
491e04ef | 8481 | |
01779b5f | 8482 | We *don't* complain about member template instantiations that |
8483 | have this form, though; they can occur as we try to decide | |
8484 | what constructor to use during overload resolution. Since | |
8485 | overload resolution will never prefer such a constructor to | |
8486 | the non-template copy constructor (which is either explicitly | |
8487 | or implicitly defined), there's no need to worry about their | |
8488 | existence. Theoretically, they should never even be | |
8489 | instantiated, but that's hard to forestall. */ | |
cf103c6c | 8490 | error ("invalid constructor; you probably meant `%T (const %T&)'", |
745f5bd2 | 8491 | ctype, ctype); |
745f5bd2 | 8492 | return 0; |
471086d6 | 8493 | } |
491e04ef | 8494 | |
ddb9bca7 | 8495 | return 1; |
471086d6 | 8496 | } |
8497 | ||
97cc4539 | 8498 | /* An operator with this code is unary, but can also be binary. */ |
96624a9e | 8499 | |
e581f478 | 8500 | static int |
1b72315d | 8501 | ambi_op_p (enum tree_code code) |
471086d6 | 8502 | { |
97cc4539 | 8503 | return (code == INDIRECT_REF |
8504 | || code == ADDR_EXPR | |
8505 | || code == CONVERT_EXPR | |
8506 | || code == NEGATE_EXPR | |
8507 | || code == PREINCREMENT_EXPR | |
8508 | || code == PREDECREMENT_EXPR); | |
471086d6 | 8509 | } |
8510 | ||
8511 | /* An operator with this name can only be unary. */ | |
96624a9e | 8512 | |
e581f478 | 8513 | static int |
1b72315d | 8514 | unary_op_p (enum tree_code code) |
471086d6 | 8515 | { |
97cc4539 | 8516 | return (code == TRUTH_NOT_EXPR |
8517 | || code == BIT_NOT_EXPR | |
8518 | || code == COMPONENT_REF | |
8519 | || code == TYPE_EXPR); | |
471086d6 | 8520 | } |
8521 | ||
b7d1e8ea | 8522 | /* DECL is a declaration for an overloaded operator. Returns true if |
8523 | the declaration is valid; false otherwise. If COMPLAIN is true, | |
8524 | errors are issued for invalid declarations. */ | |
96624a9e | 8525 | |
b7d1e8ea | 8526 | bool |
8527 | grok_op_properties (tree decl, int friendp, bool complain) | |
471086d6 | 8528 | { |
8529 | tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl)); | |
97cc4539 | 8530 | tree argtype; |
471086d6 | 8531 | int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE); |
8532 | tree name = DECL_NAME (decl); | |
97cc4539 | 8533 | enum tree_code operator_code; |
8534 | int arity; | |
b7d1e8ea | 8535 | bool ok; |
8536 | ||
8537 | /* Assume that the declaration is valid. */ | |
8538 | ok = true; | |
97cc4539 | 8539 | |
8540 | /* Count the number of arguments. */ | |
8541 | for (argtype = argtypes, arity = 0; | |
8542 | argtype && argtype != void_list_node; | |
8543 | argtype = TREE_CHAIN (argtype)) | |
8544 | ++arity; | |
471086d6 | 8545 | |
e581f478 | 8546 | if (current_class_type == NULL_TREE) |
8547 | friendp = 1; | |
471086d6 | 8548 | |
97cc4539 | 8549 | if (DECL_CONV_FN_P (decl)) |
8550 | operator_code = TYPE_EXPR; | |
8551 | else | |
8552 | do | |
8553 | { | |
c5144efa | 8554 | #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \ |
8555 | if (ansi_opname (CODE) == name) \ | |
8556 | { \ | |
7216a9ff | 8557 | operator_code = (CODE); \ |
c5144efa | 8558 | break; \ |
8559 | } \ | |
8560 | else if (ansi_assopname (CODE) == name) \ | |
8561 | { \ | |
7216a9ff | 8562 | operator_code = (CODE); \ |
c5144efa | 8563 | DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \ |
8564 | break; \ | |
97cc4539 | 8565 | } |
8566 | ||
8567 | #include "operators.def" | |
8568 | #undef DEF_OPERATOR | |
8569 | ||
092b1d6f | 8570 | gcc_unreachable (); |
97cc4539 | 8571 | } |
8572 | while (0); | |
b4df430b | 8573 | gcc_assert (operator_code != LAST_CPLUS_TREE_CODE); |
97cc4539 | 8574 | SET_OVERLOADED_OPERATOR_CODE (decl, operator_code); |
8575 | ||
e581f478 | 8576 | if (! friendp) |
8577 | { | |
97cc4539 | 8578 | switch (operator_code) |
8579 | { | |
97cc4539 | 8580 | case NEW_EXPR: |
8581 | TYPE_HAS_NEW_OPERATOR (current_class_type) = 1; | |
8582 | break; | |
3c3beda6 | 8583 | |
97cc4539 | 8584 | case DELETE_EXPR: |
8585 | TYPE_GETS_DELETE (current_class_type) |= 1; | |
8586 | break; | |
3c3beda6 | 8587 | |
97cc4539 | 8588 | case VEC_NEW_EXPR: |
8589 | TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1; | |
8590 | break; | |
3c3beda6 | 8591 | |
97cc4539 | 8592 | case VEC_DELETE_EXPR: |
8593 | TYPE_GETS_DELETE (current_class_type) |= 2; | |
8594 | break; | |
8595 | ||
8596 | default: | |
8597 | break; | |
8598 | } | |
8599 | } | |
8600 | ||
c62b41e8 | 8601 | /* [basic.std.dynamic.allocation]/1: |
8602 | ||
8603 | A program is ill-formed if an allocation function is declared | |
8604 | in a namespace scope other than global scope or declared static | |
8605 | in global scope. | |
8606 | ||
8607 | The same also holds true for deallocation functions. */ | |
8608 | if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR | |
8609 | || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR) | |
8610 | { | |
8611 | if (DECL_NAMESPACE_SCOPE_P (decl)) | |
8612 | { | |
8613 | if (CP_DECL_CONTEXT (decl) != global_namespace) | |
8614 | error ("`%D' may not be declared within a namespace", decl); | |
8615 | else if (!TREE_PUBLIC (decl)) | |
8616 | error ("`%D' may not be declared as static", decl); | |
8617 | } | |
8618 | } | |
8619 | ||
97cc4539 | 8620 | if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR) |
7ef14399 | 8621 | TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl)); |
97cc4539 | 8622 | else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR) |
7ef14399 | 8623 | TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl)); |
471086d6 | 8624 | else |
8625 | { | |
8626 | /* An operator function must either be a non-static member function | |
8627 | or have at least one parameter of a class, a reference to a class, | |
8628 | an enumeration, or a reference to an enumeration. 13.4.0.6 */ | |
94f3b32d | 8629 | if (! methodp || DECL_STATIC_FUNCTION_P (decl)) |
471086d6 | 8630 | { |
97cc4539 | 8631 | if (operator_code == TYPE_EXPR |
8632 | || operator_code == CALL_EXPR | |
8633 | || operator_code == COMPONENT_REF | |
8634 | || operator_code == ARRAY_REF | |
8635 | || operator_code == NOP_EXPR) | |
cf103c6c | 8636 | error ("`%D' must be a nonstatic member function", decl); |
471086d6 | 8637 | else |
8638 | { | |
b7d1e8ea | 8639 | tree p; |
471086d6 | 8640 | |
94f3b32d | 8641 | if (DECL_STATIC_FUNCTION_P (decl)) |
cf103c6c | 8642 | error ("`%D' must be either a non-static member function or a non-member function", decl); |
94f3b32d | 8643 | |
b7d1e8ea | 8644 | for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p)) |
8645 | { | |
8646 | tree arg = non_reference (TREE_VALUE (p)); | |
8647 | /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used | |
8648 | because these checks are performed even on | |
8649 | template functions. */ | |
8650 | if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE) | |
8651 | break; | |
8652 | } | |
8653 | ||
8654 | if (!p || p == void_list_node) | |
8655 | { | |
8656 | if (!complain) | |
8657 | return false; | |
8658 | ||
8659 | error ("`%D' must have an argument of class or " | |
8660 | "enumerated type", | |
8661 | decl); | |
8662 | ok = false; | |
8663 | } | |
471086d6 | 8664 | } |
8665 | } | |
980877d7 | 8666 | |
b7d1e8ea | 8667 | /* There are no restrictions on the arguments to an overloaded |
8668 | "operator ()". */ | |
97cc4539 | 8669 | if (operator_code == CALL_EXPR) |
b7d1e8ea | 8670 | return ok; |
471086d6 | 8671 | |
38281c46 | 8672 | if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl)) |
ddb9bca7 | 8673 | { |
8674 | tree t = TREE_TYPE (name); | |
6d97d550 | 8675 | if (! friendp) |
ddb9bca7 | 8676 | { |
8677 | int ref = (TREE_CODE (t) == REFERENCE_TYPE); | |
e1721763 | 8678 | const char *what = 0; |
3c3beda6 | 8679 | |
ddb9bca7 | 8680 | if (ref) |
8681 | t = TYPE_MAIN_VARIANT (TREE_TYPE (t)); | |
8682 | ||
6d97d550 | 8683 | if (TREE_CODE (t) == VOID_TYPE) |
8684 | what = "void"; | |
8685 | else if (t == current_class_type) | |
ddb9bca7 | 8686 | what = "the same type"; |
38281c46 | 8687 | /* Don't force t to be complete here. */ |
ddb9bca7 | 8688 | else if (IS_AGGR_TYPE (t) |
4b72716d | 8689 | && COMPLETE_TYPE_P (t) |
ddb9bca7 | 8690 | && DERIVED_FROM_P (t, current_class_type)) |
8691 | what = "a base class"; | |
8692 | ||
65404a7f | 8693 | if (what && warn_conversion) |
905d4035 | 8694 | warning ("conversion to %s%s will never use a type conversion operator", |
ddb9bca7 | 8695 | ref ? "a reference to " : "", what); |
8696 | } | |
8697 | } | |
01779b5f | 8698 | if (operator_code == COND_EXPR) |
471086d6 | 8699 | { |
8700 | /* 13.4.0.3 */ | |
cf103c6c | 8701 | error ("ISO C++ prohibits overloading operator ?:"); |
980877d7 | 8702 | } |
97cc4539 | 8703 | else if (ambi_op_p (operator_code)) |
471086d6 | 8704 | { |
97cc4539 | 8705 | if (arity == 1) |
8706 | /* We pick the one-argument operator codes by default, so | |
8707 | we don't have to change anything. */ | |
8708 | ; | |
8709 | else if (arity == 2) | |
471086d6 | 8710 | { |
97cc4539 | 8711 | /* If we thought this was a unary operator, we now know |
8712 | it to be a binary operator. */ | |
8713 | switch (operator_code) | |
8714 | { | |
8715 | case INDIRECT_REF: | |
8716 | operator_code = MULT_EXPR; | |
8717 | break; | |
8718 | ||
8719 | case ADDR_EXPR: | |
8720 | operator_code = BIT_AND_EXPR; | |
8721 | break; | |
8722 | ||
8723 | case CONVERT_EXPR: | |
8724 | operator_code = PLUS_EXPR; | |
8725 | break; | |
8726 | ||
8727 | case NEGATE_EXPR: | |
8728 | operator_code = MINUS_EXPR; | |
8729 | break; | |
8730 | ||
8731 | case PREINCREMENT_EXPR: | |
8732 | operator_code = POSTINCREMENT_EXPR; | |
8733 | break; | |
8734 | ||
8735 | case PREDECREMENT_EXPR: | |
b81be439 | 8736 | operator_code = POSTDECREMENT_EXPR; |
97cc4539 | 8737 | break; |
8738 | ||
8739 | default: | |
092b1d6f | 8740 | gcc_unreachable (); |
97cc4539 | 8741 | } |
8742 | ||
8743 | SET_OVERLOADED_OPERATOR_CODE (decl, operator_code); | |
8744 | ||
8745 | if ((operator_code == POSTINCREMENT_EXPR | |
8746 | || operator_code == POSTDECREMENT_EXPR) | |
3cc0b4b9 | 8747 | && ! processing_template_decl |
48edae76 | 8748 | && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node)) |
471086d6 | 8749 | { |
8750 | if (methodp) | |
cf103c6c | 8751 | error ("postfix `%D' must take `int' as its argument", |
471086d6 | 8752 | decl); |
8753 | else | |
cf103c6c | 8754 | error |
905d4035 | 8755 | ("postfix `%D' must take `int' as its second argument", |
8756 | decl); | |
471086d6 | 8757 | } |
8758 | } | |
8759 | else | |
8760 | { | |
8761 | if (methodp) | |
cf103c6c | 8762 | error ("`%D' must take either zero or one argument", decl); |
471086d6 | 8763 | else |
cf103c6c | 8764 | error ("`%D' must take either one or two arguments", decl); |
471086d6 | 8765 | } |
02d7f858 | 8766 | |
8767 | /* More Effective C++ rule 6. */ | |
f85d646a | 8768 | if (warn_ecpp |
97cc4539 | 8769 | && (operator_code == POSTINCREMENT_EXPR |
8770 | || operator_code == POSTDECREMENT_EXPR | |
8771 | || operator_code == PREINCREMENT_EXPR | |
8772 | || operator_code == PREDECREMENT_EXPR)) | |
02d7f858 | 8773 | { |
8774 | tree arg = TREE_VALUE (argtypes); | |
8775 | tree ret = TREE_TYPE (TREE_TYPE (decl)); | |
8776 | if (methodp || TREE_CODE (arg) == REFERENCE_TYPE) | |
8777 | arg = TREE_TYPE (arg); | |
8778 | arg = TYPE_MAIN_VARIANT (arg); | |
97cc4539 | 8779 | if (operator_code == PREINCREMENT_EXPR |
8780 | || operator_code == PREDECREMENT_EXPR) | |
02d7f858 | 8781 | { |
8782 | if (TREE_CODE (ret) != REFERENCE_TYPE | |
daf9ff67 | 8783 | || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)), |
8784 | arg)) | |
cf103c6c | 8785 | warning ("prefix `%D' should return `%T'", decl, |
02d7f858 | 8786 | build_reference_type (arg)); |
8787 | } | |
8788 | else | |
8789 | { | |
daf9ff67 | 8790 | if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg)) |
cf103c6c | 8791 | warning ("postfix `%D' should return `%T'", decl, arg); |
02d7f858 | 8792 | } |
8793 | } | |
471086d6 | 8794 | } |
97cc4539 | 8795 | else if (unary_op_p (operator_code)) |
471086d6 | 8796 | { |
97cc4539 | 8797 | if (arity != 1) |
471086d6 | 8798 | { |
8799 | if (methodp) | |
cf103c6c | 8800 | error ("`%D' must take `void'", decl); |
471086d6 | 8801 | else |
cf103c6c | 8802 | error ("`%D' must take exactly one argument", decl); |
471086d6 | 8803 | } |
8804 | } | |
97cc4539 | 8805 | else /* if (binary_op_p (operator_code)) */ |
471086d6 | 8806 | { |
97cc4539 | 8807 | if (arity != 2) |
471086d6 | 8808 | { |
8809 | if (methodp) | |
cf103c6c | 8810 | error ("`%D' must take exactly one argument", decl); |
471086d6 | 8811 | else |
cf103c6c | 8812 | error ("`%D' must take exactly two arguments", decl); |
471086d6 | 8813 | } |
02d7f858 | 8814 | |
8815 | /* More Effective C++ rule 7. */ | |
f85d646a | 8816 | if (warn_ecpp |
97cc4539 | 8817 | && (operator_code == TRUTH_ANDIF_EXPR |
8818 | || operator_code == TRUTH_ORIF_EXPR | |
8819 | || operator_code == COMPOUND_EXPR)) | |
cf103c6c | 8820 | warning ("user-defined `%D' always evaluates both arguments", |
02d7f858 | 8821 | decl); |
8822 | } | |
8823 | ||
8824 | /* Effective C++ rule 23. */ | |
f85d646a | 8825 | if (warn_ecpp |
97cc4539 | 8826 | && arity == 2 |
40590b10 | 8827 | && !DECL_ASSIGNMENT_OPERATOR_P (decl) |
97cc4539 | 8828 | && (operator_code == PLUS_EXPR |
8829 | || operator_code == MINUS_EXPR | |
8830 | || operator_code == TRUNC_DIV_EXPR | |
40590b10 | 8831 | || operator_code == MULT_EXPR |
8832 | || operator_code == TRUNC_MOD_EXPR) | |
02d7f858 | 8833 | && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE) |
cf103c6c | 8834 | warning ("`%D' should return by value", decl); |
471086d6 | 8835 | |
01779b5f | 8836 | /* [over.oper]/8 */ |
356ca252 | 8837 | for (; argtypes && argtypes != void_list_node; |
8838 | argtypes = TREE_CHAIN (argtypes)) | |
8839 | if (TREE_PURPOSE (argtypes)) | |
8840 | { | |
8841 | TREE_PURPOSE (argtypes) = NULL_TREE; | |
97cc4539 | 8842 | if (operator_code == POSTINCREMENT_EXPR |
8843 | || operator_code == POSTDECREMENT_EXPR) | |
356ca252 | 8844 | { |
8845 | if (pedantic) | |
cf103c6c | 8846 | pedwarn ("`%D' cannot have default arguments", decl); |
356ca252 | 8847 | } |
8848 | else | |
cf103c6c | 8849 | error ("`%D' cannot have default arguments", decl); |
356ca252 | 8850 | } |
8851 | ||
471086d6 | 8852 | } |
b7d1e8ea | 8853 | |
8854 | return ok; | |
471086d6 | 8855 | } |
8856 | \f | |
e1721763 | 8857 | static const char * |
1b72315d | 8858 | tag_name (enum tag_types code) |
435a15bf | 8859 | { |
8860 | switch (code) | |
8861 | { | |
8862 | case record_type: | |
8863 | return "struct"; | |
8864 | case class_type: | |
8865 | return "class"; | |
8866 | case union_type: | |
8867 | return "union "; | |
8868 | case enum_type: | |
8869 | return "enum"; | |
435a15bf | 8870 | default: |
092b1d6f | 8871 | gcc_unreachable (); |
435a15bf | 8872 | } |
8873 | } | |
8874 | ||
ac12b007 | 8875 | /* Name lookup in an elaborated-type-specifier (after the keyword |
b7d1e8ea | 8876 | indicated by TAG_CODE) has found the TYPE_DECL DECL. If the |
ac12b007 | 8877 | elaborated-type-specifier is invalid, issue a diagnostic and return |
b7d1e8ea | 8878 | error_mark_node; otherwise, return the *_TYPE to which it referred. |
220b71ed | 8879 | If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */ |
ac12b007 | 8880 | |
8172be22 | 8881 | tree |
ac12b007 | 8882 | check_elaborated_type_specifier (enum tag_types tag_code, |
b7d1e8ea | 8883 | tree decl, |
220b71ed | 8884 | bool allow_template_p) |
ac12b007 | 8885 | { |
b7d1e8ea | 8886 | tree type; |
ac12b007 | 8887 | |
b7d1e8ea | 8888 | /* In the case of: |
8889 | ||
8890 | struct S { struct S *p; }; | |
8891 | ||
8892 | name lookup will find the TYPE_DECL for the implicit "S::S" | |
8893 | typedef. Adjust for that here. */ | |
8894 | if (DECL_SELF_REFERENCE_P (decl)) | |
8895 | decl = TYPE_NAME (TREE_TYPE (decl)); | |
8896 | ||
8897 | type = TREE_TYPE (decl); | |
8898 | ||
491e04ef | 8899 | /* [dcl.type.elab] |
b7d1e8ea | 8900 | |
8901 | If the identifier resolves to a typedef-name or a template | |
8902 | type-parameter, the elaborated-type-specifier is ill-formed. | |
8903 | ||
8904 | In other words, the only legitimate declaration to use in the | |
8905 | elaborated type specifier is the implicit typedef created when | |
8906 | the type is declared. */ | |
8907 | if (!DECL_IMPLICIT_TYPEDEF_P (decl)) | |
ac12b007 | 8908 | { |
b7d1e8ea | 8909 | error ("using typedef-name `%D' after `%s'", decl, tag_name (tag_code)); |
8910 | return IS_AGGR_TYPE (type) ? type : error_mark_node; | |
ac12b007 | 8911 | } |
491e04ef | 8912 | |
b7d1e8ea | 8913 | if (TREE_CODE (type) == TEMPLATE_TYPE_PARM) |
ac12b007 | 8914 | { |
8915 | error ("using template type parameter `%T' after `%s'", | |
8916 | type, tag_name (tag_code)); | |
b7d1e8ea | 8917 | return error_mark_node; |
ac12b007 | 8918 | } |
220b71ed | 8919 | else if (TREE_CODE (type) != RECORD_TYPE |
8920 | && TREE_CODE (type) != UNION_TYPE | |
8921 | && tag_code != enum_type) | |
8922 | { | |
8923 | error ("`%T' referred to as `%s'", type, tag_name (tag_code)); | |
b7d1e8ea | 8924 | return error_mark_node; |
220b71ed | 8925 | } |
8926 | else if (TREE_CODE (type) != ENUMERAL_TYPE | |
8927 | && tag_code == enum_type) | |
8928 | { | |
8929 | error ("`%T' referred to as enum", type); | |
b7d1e8ea | 8930 | return error_mark_node; |
220b71ed | 8931 | } |
8932 | else if (!allow_template_p | |
8933 | && TREE_CODE (type) == RECORD_TYPE | |
8934 | && CLASSTYPE_IS_TEMPLATE (type)) | |
8935 | { | |
8936 | /* If a class template appears as elaborated type specifier | |
8937 | without a template header such as: | |
8938 | ||
8939 | template <class T> class C {}; | |
8940 | void f(class C); // No template header here | |
8941 | ||
8942 | then the required template argument is missing. */ | |
8943 | ||
8944 | error ("template argument required for `%s %T'", | |
8945 | tag_name (tag_code), | |
8946 | DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))); | |
b7d1e8ea | 8947 | return error_mark_node; |
220b71ed | 8948 | } |
ac12b007 | 8949 | |
b7d1e8ea | 8950 | return type; |
ac12b007 | 8951 | } |
8952 | ||
220b71ed | 8953 | /* Get the struct, enum or union (TAG_CODE says which) with tag NAME. |
471086d6 | 8954 | Define the tag as a forward-reference if it is not defined. |
8955 | ||
220b71ed | 8956 | If a declaration is given, process it here, and report an error if |
fb3e3237 | 8957 | multiple declarations are not identical. |
471086d6 | 8958 | |
220b71ed | 8959 | GLOBALIZE is false when this is also a definition. Only look in |
471086d6 | 8960 | the current frame for the name (since C++ allows new names in any |
220b71ed | 8961 | scope.) |
8962 | ||
8963 | TEMPLATE_HEADER_P is true when this declaration is preceded by | |
8964 | a set of template parameters. */ | |
471086d6 | 8965 | |
471086d6 | 8966 | tree |
fb3e3237 | 8967 | xref_tag (enum tag_types tag_code, tree name, |
220b71ed | 8968 | bool globalize, bool template_header_p) |
471086d6 | 8969 | { |
471086d6 | 8970 | enum tree_code code; |
cd16867a | 8971 | tree t; |
1f3233d1 | 8972 | struct cp_binding_level *b = current_binding_level; |
162ed5b9 | 8973 | tree context = NULL_TREE; |
f5edc715 | 8974 | |
851fe51a | 8975 | timevar_push (TV_NAME_LOOKUP); |
220b71ed | 8976 | |
b4df430b | 8977 | gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); |
220b71ed | 8978 | |
471086d6 | 8979 | switch (tag_code) |
8980 | { | |
8981 | case record_type: | |
8982 | case class_type: | |
471086d6 | 8983 | code = RECORD_TYPE; |
471086d6 | 8984 | break; |
8985 | case union_type: | |
8986 | code = UNION_TYPE; | |
471086d6 | 8987 | break; |
8988 | case enum_type: | |
8989 | code = ENUMERAL_TYPE; | |
8990 | break; | |
8991 | default: | |
092b1d6f | 8992 | gcc_unreachable (); |
471086d6 | 8993 | } |
8994 | ||
1a3f833b | 8995 | if (! globalize) |
471086d6 | 8996 | { |
c24cced6 | 8997 | /* If we know we are defining this tag, only look it up in |
8998 | this scope and don't try to find it as a type. */ | |
220b71ed | 8999 | t = lookup_tag (code, name, b, 1); |
471086d6 | 9000 | } |
9001 | else | |
9002 | { | |
d48f6141 | 9003 | tree decl = lookup_name (name, 2); |
220b71ed | 9004 | |
9005 | if (decl && DECL_CLASS_TEMPLATE_P (decl)) | |
9006 | decl = DECL_TEMPLATE_RESULT (decl); | |
980877d7 | 9007 | |
220b71ed | 9008 | if (decl && TREE_CODE (decl) == TYPE_DECL) |
162ed5b9 | 9009 | { |
220b71ed | 9010 | /* Two cases we need to consider when deciding if a class |
9011 | template is allowed as an elaborated type specifier: | |
9012 | 1. It is a self reference to its own class. | |
9013 | 2. It comes with a template header. | |
162ed5b9 | 9014 | |
220b71ed | 9015 | For example: |
0f0d5a69 | 9016 | |
220b71ed | 9017 | template <class T> class C { |
9018 | class C *c1; // DECL_SELF_REFERENCE_P is true | |
9019 | class D; | |
9020 | }; | |
9021 | template <class U> class C; // template_header_p is true | |
9022 | template <class T> class C<T>::D { | |
9023 | class C *c2; // DECL_SELF_REFERENCE_P is true | |
9024 | }; */ | |
9025 | ||
b7d1e8ea | 9026 | t = check_elaborated_type_specifier (tag_code, |
9027 | decl, | |
220b71ed | 9028 | template_header_p |
9029 | | DECL_SELF_REFERENCE_P (decl)); | |
9030 | if (t == error_mark_node) | |
9031 | POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); | |
162ed5b9 | 9032 | } |
220b71ed | 9033 | else |
9034 | t = NULL_TREE; | |
162ed5b9 | 9035 | |
220b71ed | 9036 | if (t && current_class_type |
980877d7 | 9037 | && template_class_depth (current_class_type) |
220b71ed | 9038 | && template_header_p) |
162ed5b9 | 9039 | { |
3160db1d | 9040 | /* Since GLOBALIZE is nonzero, we are not looking at a |
162ed5b9 | 9041 | definition of this tag. Since, in addition, we are currently |
9042 | processing a (member) template declaration of a template | |
9043 | class, we must be very careful; consider: | |
9044 | ||
9045 | template <class X> | |
9046 | struct S1 | |
9047 | ||
9048 | template <class U> | |
9049 | struct S2 | |
9050 | { template <class V> | |
9051 | friend struct S1; }; | |
9052 | ||
9053 | Here, the S2::S1 declaration should not be confused with the | |
9054 | outer declaration. In particular, the inner version should | |
9055 | have a template parameter of level 2, not level 1. This | |
9056 | would be particularly important if the member declaration | |
9057 | were instead: | |
9058 | ||
9059 | template <class V = U> friend struct S1; | |
9060 | ||
9061 | say, when we should tsubst into `U' when instantiating | |
9062 | S2. On the other hand, when presented with: | |
9063 | ||
9064 | template <class T> | |
9065 | struct S1 { | |
9066 | template <class U> | |
9067 | struct S2 {}; | |
9068 | template <class U> | |
9069 | friend struct S2; | |
9070 | }; | |
9071 | ||
9072 | we must find the inner binding eventually. We | |
9073 | accomplish this by making sure that the new type we | |
9074 | create to represent this declaration has the right | |
9075 | TYPE_CONTEXT. */ | |
220b71ed | 9076 | context = TYPE_CONTEXT (t); |
9077 | t = NULL_TREE; | |
471086d6 | 9078 | } |
9079 | } | |
9080 | ||
220b71ed | 9081 | if (! t) |
471086d6 | 9082 | { |
9083 | /* If no such tag is yet defined, create a forward-reference node | |
9084 | and record it as the "definition". | |
9085 | When a real declaration of this type is found, | |
9086 | the forward-reference will be altered into a real type. */ | |
471086d6 | 9087 | if (code == ENUMERAL_TYPE) |
9088 | { | |
cf103c6c | 9089 | error ("use of enum `%#D' without previous declaration", name); |
84a51273 | 9090 | POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); |
471086d6 | 9091 | } |
471086d6 | 9092 | else |
9093 | { | |
220b71ed | 9094 | t = make_aggr_type (code); |
9095 | TYPE_CONTEXT (t) = context; | |
9096 | pushtag (name, t, globalize); | |
471086d6 | 9097 | } |
9098 | } | |
9099 | else | |
9100 | { | |
220b71ed | 9101 | if (!globalize && processing_template_decl && IS_AGGR_TYPE (t)) |
9102 | redeclare_class_template (t, current_template_parms); | |
491e04ef | 9103 | else if (!processing_template_decl |
86b92c8e | 9104 | && CLASS_TYPE_P (t) |
9105 | && CLASSTYPE_IS_TEMPLATE (t)) | |
9106 | { | |
9107 | error ("redeclaration of `%T' as a non-template", t); | |
9108 | t = error_mark_node; | |
9109 | } | |
471086d6 | 9110 | } |
9111 | ||
220b71ed | 9112 | POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t); |
471086d6 | 9113 | } |
1a3f833b | 9114 | |
d2a15a12 | 9115 | tree |
1b72315d | 9116 | xref_tag_from_type (tree old, tree id, int globalize) |
d2a15a12 | 9117 | { |
160175b4 | 9118 | enum tag_types tag_kind; |
d2a15a12 | 9119 | |
9120 | if (TREE_CODE (old) == RECORD_TYPE) | |
160175b4 | 9121 | tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type); |
d2a15a12 | 9122 | else |
160175b4 | 9123 | tag_kind = union_type; |
d2a15a12 | 9124 | |
9125 | if (id == NULL_TREE) | |
9126 | id = TYPE_IDENTIFIER (old); | |
9127 | ||
fb3e3237 | 9128 | return xref_tag (tag_kind, id, globalize, false); |
d2a15a12 | 9129 | } |
9130 | ||
168db9a4 | 9131 | /* Create the binfo hierarchy for REF with (possibly NULL) base list |
9132 | BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an | |
9133 | access_* node, and the TREE_VALUE is the type of the base-class. | |
9134 | Non-NULL TREE_TYPE indicates virtual inheritance. */ | |
d1aed66b | 9135 | |
1a3f833b | 9136 | void |
95f3173a | 9137 | xref_basetypes (tree ref, tree base_list) |
1a3f833b | 9138 | { |
954ad420 | 9139 | tree *basep; |
f6cc6a08 | 9140 | tree binfo, base_binfo; |
4a44ba29 | 9141 | unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */ |
9142 | unsigned max_bases = 0; /* Maximum direct bases. */ | |
954ad420 | 9143 | int i; |
168db9a4 | 9144 | tree default_access; |
9145 | tree igo_prev; /* Track Inheritance Graph Order. */ | |
e4eb931c | 9146 | |
670f67e2 | 9147 | if (ref == error_mark_node) |
9148 | return; | |
9149 | ||
168db9a4 | 9150 | /* The base of a derived class is private by default, all others are |
9151 | public. */ | |
9152 | default_access = (TREE_CODE (ref) == RECORD_TYPE | |
9153 | && CLASSTYPE_DECLARED_CLASS (ref) | |
9154 | ? access_private_node : access_public_node); | |
8042247d | 9155 | |
b90e9c68 | 9156 | /* First, make sure that any templates in base-classes are |
9157 | instantiated. This ensures that if we call ourselves recursively | |
9158 | we do not get confused about which classes are marked and which | |
9159 | are not. */ | |
491e04ef | 9160 | basep = &base_list; |
9161 | while (*basep) | |
954ad420 | 9162 | { |
9163 | tree basetype = TREE_VALUE (*basep); | |
491e04ef | 9164 | |
954ad420 | 9165 | if (!(processing_template_decl && uses_template_parms (basetype)) |
9166 | && !complete_type_or_else (basetype, NULL)) | |
95f3173a | 9167 | /* An incomplete type. Remove it from the list. */ |
954ad420 | 9168 | *basep = TREE_CHAIN (*basep); |
9169 | else | |
168db9a4 | 9170 | { |
9171 | max_bases++; | |
9172 | if (TREE_TYPE (*basep)) | |
9173 | max_vbases++; | |
9174 | if (CLASS_TYPE_P (basetype)) | |
9175 | max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype)); | |
9176 | basep = &TREE_CHAIN (*basep); | |
9177 | } | |
954ad420 | 9178 | } |
b90e9c68 | 9179 | |
1a3f833b | 9180 | SET_CLASSTYPE_MARKED (ref); |
168db9a4 | 9181 | |
a6460bf1 | 9182 | /* The binfo slot should be empty, unless this is an (ill-formed) |
9183 | redefinition. */ | |
b4df430b | 9184 | gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref)); |
9185 | gcc_assert (TYPE_MAIN_VARIANT (ref) == ref); | |
491e04ef | 9186 | |
f6cc6a08 | 9187 | binfo = make_tree_binfo (max_bases); |
491e04ef | 9188 | |
168db9a4 | 9189 | TYPE_BINFO (ref) = binfo; |
9190 | BINFO_OFFSET (binfo) = size_zero_node; | |
9191 | BINFO_TYPE (binfo) = ref; | |
491e04ef | 9192 | |
168db9a4 | 9193 | if (max_bases) |
9194 | { | |
db77fe17 | 9195 | BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, max_bases); |
168db9a4 | 9196 | /* An aggregate cannot have baseclasses. */ |
9197 | CLASSTYPE_NON_AGGREGATE (ref) = 1; | |
491e04ef | 9198 | |
168db9a4 | 9199 | if (TREE_CODE (ref) == UNION_TYPE) |
9200 | error ("derived union `%T' invalid", ref); | |
9201 | } | |
491e04ef | 9202 | |
168db9a4 | 9203 | if (max_bases > 1) |
95f3173a | 9204 | { |
168db9a4 | 9205 | TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1; |
9206 | /* If there is more than one non-empty they cannot be at the | |
9207 | same address. */ | |
9208 | TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1; | |
491e04ef | 9209 | |
168db9a4 | 9210 | if (TYPE_FOR_JAVA (ref)) |
9211 | error ("Java class '%T' cannot have multiple bases", ref); | |
9212 | } | |
491e04ef | 9213 | |
168db9a4 | 9214 | if (max_vbases) |
9215 | { | |
9216 | CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, max_vbases); | |
9217 | TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1; | |
9218 | /* Converting to a virtual base class requires looking up the | |
9219 | offset of the virtual base. */ | |
9220 | TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1; | |
491e04ef | 9221 | |
168db9a4 | 9222 | if (TYPE_FOR_JAVA (ref)) |
9223 | error ("Java class '%T' cannot have virtual bases", ref); | |
9224 | } | |
a6460bf1 | 9225 | |
168db9a4 | 9226 | for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list)) |
9227 | { | |
9228 | tree access = TREE_PURPOSE (base_list); | |
9229 | int via_virtual = TREE_TYPE (base_list) != NULL_TREE; | |
9230 | tree basetype = TREE_VALUE (base_list); | |
491e04ef | 9231 | |
168db9a4 | 9232 | if (access == access_default_node) |
9233 | access = default_access; | |
491e04ef | 9234 | |
168db9a4 | 9235 | if (TREE_CODE (basetype) == TYPE_DECL) |
9236 | basetype = TREE_TYPE (basetype); | |
9237 | if (TREE_CODE (basetype) != RECORD_TYPE | |
9238 | && TREE_CODE (basetype) != TYPENAME_TYPE | |
9239 | && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM | |
9240 | && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM) | |
9241 | { | |
9242 | error ("base type `%T' fails to be a struct or class type", | |
9243 | basetype); | |
9244 | continue; | |
1a3f833b | 9245 | } |
491e04ef | 9246 | |
168db9a4 | 9247 | if (CLASSTYPE_MARKED (basetype)) |
d9a369a2 | 9248 | { |
168db9a4 | 9249 | if (basetype == ref) |
9250 | error ("recursive type `%T' undefined", basetype); | |
9251 | else | |
9252 | error ("duplicate base type `%T' invalid", basetype); | |
9253 | continue; | |
d9a369a2 | 9254 | } |
168db9a4 | 9255 | SET_CLASSTYPE_MARKED (basetype); |
491e04ef | 9256 | |
168db9a4 | 9257 | if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0)) |
9258 | TYPE_FOR_JAVA (ref) = 1; | |
9259 | ||
f6cc6a08 | 9260 | base_binfo = NULL_TREE; |
168db9a4 | 9261 | if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype)) |
95f3173a | 9262 | { |
168db9a4 | 9263 | base_binfo = TYPE_BINFO (basetype); |
4a44ba29 | 9264 | /* The original basetype could have been a typedef'd type. */ |
168db9a4 | 9265 | basetype = BINFO_TYPE (base_binfo); |
491e04ef | 9266 | |
168db9a4 | 9267 | /* Inherit flags from the base. */ |
9268 | TYPE_HAS_NEW_OPERATOR (ref) | |
9269 | |= TYPE_HAS_NEW_OPERATOR (basetype); | |
9270 | TYPE_HAS_ARRAY_NEW_OPERATOR (ref) | |
9271 | |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype); | |
9272 | TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype); | |
9273 | TYPE_USES_MULTIPLE_INHERITANCE (ref) | |
9274 | |= TYPE_USES_MULTIPLE_INHERITANCE (basetype); | |
9275 | TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) | |
9276 | |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype); | |
9277 | TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype); | |
954ad420 | 9278 | } |
491e04ef | 9279 | |
168db9a4 | 9280 | base_binfo = copy_binfo (base_binfo, basetype, ref, |
9281 | &igo_prev, via_virtual); | |
9282 | if (!BINFO_INHERITANCE_CHAIN (base_binfo)) | |
9283 | BINFO_INHERITANCE_CHAIN (base_binfo) = binfo; | |
de4355dc | 9284 | |
f6cc6a08 | 9285 | BINFO_BASE_APPEND (binfo, base_binfo); |
db77fe17 | 9286 | BINFO_BASE_ACCESS_APPEND (binfo, access); |
a6460bf1 | 9287 | } |
9288 | ||
95f3173a | 9289 | /* Unmark all the types. */ |
f6cc6a08 | 9290 | for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) |
9291 | CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (base_binfo)); | |
1a3f833b | 9292 | CLEAR_CLASSTYPE_MARKED (ref); |
1a3f833b | 9293 | } |
980877d7 | 9294 | |
471086d6 | 9295 | \f |
471086d6 | 9296 | /* Begin compiling the definition of an enumeration type. |
9297 | NAME is its name (or null if anonymous). | |
9298 | Returns the type object, as yet incomplete. | |
9299 | Also records info about it so that build_enumerator | |
9300 | may be used to declare the individual values as they are read. */ | |
9301 | ||
9302 | tree | |
1b72315d | 9303 | start_enum (tree name) |
471086d6 | 9304 | { |
cd16867a | 9305 | tree enumtype = NULL_TREE; |
1f3233d1 | 9306 | struct cp_binding_level *b = current_binding_level; |
471086d6 | 9307 | |
9308 | /* If this is the real definition for a previous forward reference, | |
9309 | fill in the contents in the same object that used to be the | |
9310 | forward reference. */ | |
9311 | ||
9312 | if (name != NULL_TREE) | |
9313 | enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1); | |
9314 | ||
9315 | if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE) | |
43476131 | 9316 | { |
cf103c6c | 9317 | error ("multiple definition of `%#T'", enumtype); |
9bc3739f | 9318 | error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype)); |
383acc13 | 9319 | /* Clear out TYPE_VALUES, and start again. */ |
9320 | TYPE_VALUES (enumtype) = NULL_TREE; | |
43476131 | 9321 | } |
471086d6 | 9322 | else |
9323 | { | |
9324 | enumtype = make_node (ENUMERAL_TYPE); | |
9325 | pushtag (name, enumtype, 0); | |
9326 | } | |
9327 | ||
471086d6 | 9328 | return enumtype; |
9329 | } | |
9330 | ||
9331 | /* After processing and defining all the values of an enumeration type, | |
9332 | install their decls in the enumeration type and finish it off. | |
a4fb1d94 | 9333 | ENUMTYPE is the type object and VALUES a list of name-value pairs. */ |
471086d6 | 9334 | |
a4fb1d94 | 9335 | void |
1b72315d | 9336 | finish_enum (tree enumtype) |
471086d6 | 9337 | { |
ee1ab431 | 9338 | tree values; |
9339 | tree decl; | |
9340 | tree value; | |
a4fb1d94 | 9341 | tree minnode; |
9342 | tree maxnode; | |
9343 | tree t; | |
9344 | bool unsignedp; | |
9345 | int lowprec; | |
491e04ef | 9346 | int highprec; |
a4fb1d94 | 9347 | int precision; |
ee1ab431 | 9348 | integer_type_kind itk; |
d0ef003f | 9349 | tree underlying_type = NULL_TREE; |
a4fb1d94 | 9350 | |
9351 | /* We built up the VALUES in reverse order. */ | |
9352 | TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype)); | |
9353 | ||
15da6f57 | 9354 | /* For an enum defined in a template, just set the type of the values; |
9355 | all further processing is postponed until the template is | |
9356 | instantiated. We need to set the type so that tsubst of a CONST_DECL | |
9357 | works. */ | |
a4fb1d94 | 9358 | if (processing_template_decl) |
9359 | { | |
491e04ef | 9360 | for (values = TYPE_VALUES (enumtype); |
9361 | values; | |
ee1ab431 | 9362 | values = TREE_CHAIN (values)) |
9363 | TREE_TYPE (TREE_VALUE (values)) = enumtype; | |
334ec926 | 9364 | if (at_function_scope_p ()) |
a4fb1d94 | 9365 | add_stmt (build_min (TAG_DEFN, enumtype)); |
a4fb1d94 | 9366 | return; |
9367 | } | |
9368 | ||
ee1ab431 | 9369 | /* Determine the minimum and maximum values of the enumerators. */ |
a4fb1d94 | 9370 | if (TYPE_VALUES (enumtype)) |
471086d6 | 9371 | { |
a4fb1d94 | 9372 | minnode = maxnode = NULL_TREE; |
e857e9c7 | 9373 | |
491e04ef | 9374 | for (values = TYPE_VALUES (enumtype); |
9375 | values; | |
ee1ab431 | 9376 | values = TREE_CHAIN (values)) |
471086d6 | 9377 | { |
ee1ab431 | 9378 | decl = TREE_VALUE (values); |
15da6f57 | 9379 | |
9380 | /* [dcl.enum]: Following the closing brace of an enum-specifier, | |
9381 | each enumerator has the type of its enumeration. Prior to the | |
9382 | closing brace, the type of each enumerator is the type of its | |
9383 | initializing value. */ | |
9384 | TREE_TYPE (decl) = enumtype; | |
9385 | ||
ee1ab431 | 9386 | /* Update the minimum and maximum values, if appropriate. */ |
9387 | value = DECL_INITIAL (decl); | |
15da6f57 | 9388 | /* Figure out what the minimum and maximum values of the |
9389 | enumerators are. */ | |
9390 | if (!minnode) | |
9391 | minnode = maxnode = value; | |
9392 | else if (tree_int_cst_lt (maxnode, value)) | |
9393 | maxnode = value; | |
9394 | else if (tree_int_cst_lt (value, minnode)) | |
9395 | minnode = value; | |
471086d6 | 9396 | } |
9397 | } | |
c38086bd | 9398 | else |
ee1ab431 | 9399 | /* [dcl.enum] |
9400 | ||
9401 | If the enumerator-list is empty, the underlying type is as if | |
9402 | the enumeration had a single enumerator with value 0. */ | |
a4fb1d94 | 9403 | minnode = maxnode = integer_zero_node; |
9404 | ||
9405 | /* Compute the number of bits require to represent all values of the | |
9406 | enumeration. We must do this before the type of MINNODE and | |
9407 | MAXNODE are transformed, since min_precision relies on the | |
9408 | TREE_TYPE of the value it is passed. */ | |
9409 | unsignedp = tree_int_cst_sgn (minnode) >= 0; | |
9410 | lowprec = min_precision (minnode, unsignedp); | |
9411 | highprec = min_precision (maxnode, unsignedp); | |
9412 | precision = MAX (lowprec, highprec); | |
9413 | ||
ee1ab431 | 9414 | /* Determine the underlying type of the enumeration. |
9415 | ||
9416 | [dcl.enum] | |
9417 | ||
9418 | The underlying type of an enumeration is an integral type that | |
9419 | can represent all the enumerator values defined in the | |
9420 | enumeration. It is implementation-defined which integral type is | |
9421 | used as the underlying type for an enumeration except that the | |
9422 | underlying type shall not be larger than int unless the value of | |
491e04ef | 9423 | an enumerator cannot fit in an int or unsigned int. |
ee1ab431 | 9424 | |
9425 | We use "int" or an "unsigned int" as the underlying type, even if | |
9426 | a smaller integral type would work, unless the user has | |
9427 | explicitly requested that we use the smallest possible type. */ | |
491e04ef | 9428 | for (itk = (flag_short_enums ? itk_char : itk_int); |
9429 | itk != itk_none; | |
ee1ab431 | 9430 | itk++) |
1791b32e | 9431 | { |
ee1ab431 | 9432 | underlying_type = integer_types[itk]; |
9433 | if (TYPE_PRECISION (underlying_type) >= precision | |
78a8ed03 | 9434 | && TYPE_UNSIGNED (underlying_type) == unsignedp) |
ee1ab431 | 9435 | break; |
9436 | } | |
9437 | if (itk == itk_none) | |
9438 | { | |
9439 | /* DR 377 | |
9440 | ||
9441 | IF no integral type can represent all the enumerator values, the | |
9442 | enumeration is ill-formed. */ | |
1791b32e | 9443 | error ("no integral type can represent all of the enumerator values " |
9444 | "for `%T'", enumtype); | |
9445 | precision = TYPE_PRECISION (long_long_integer_type_node); | |
ee1ab431 | 9446 | underlying_type = integer_types[itk_unsigned_long_long]; |
1791b32e | 9447 | } |
9448 | ||
491e04ef | 9449 | /* Compute the minium and maximum values for the type. |
471086d6 | 9450 | |
ee1ab431 | 9451 | [dcl.enum] |
9452 | ||
9453 | For an enumeration where emin is the smallest enumerator and emax | |
9454 | is the largest, the values of the enumeration are the values of the | |
9455 | underlying type in the range bmin to bmax, where bmin and bmax are, | |
9456 | respectively, the smallest and largest values of the smallest bit- | |
9457 | field that can store emin and emax. */ | |
30fa03f2 | 9458 | |
9459 | /* The middle-end currently assumes that types with TYPE_PRECISION | |
9460 | narrower than their underlying type are suitably zero or sign | |
9461 | extended to fill their mode. g++ doesn't make these guarantees. | |
9462 | Until the middle-end can represent such paradoxical types, we | |
4a44ba29 | 9463 | set the TYPE_PRECISION to the width of the underlying type. */ |
30fa03f2 | 9464 | TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type); |
9465 | ||
ee1ab431 | 9466 | set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp); |
9467 | ||
9468 | /* [dcl.enum] | |
491e04ef | 9469 | |
ee1ab431 | 9470 | The value of sizeof() applied to an enumeration type, an object |
9471 | of an enumeration type, or an enumerator, is the value of sizeof() | |
9472 | applied to the underlying type. */ | |
9473 | TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type); | |
9474 | TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type); | |
9475 | TYPE_MODE (enumtype) = TYPE_MODE (underlying_type); | |
9476 | TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type); | |
9477 | TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type); | |
78a8ed03 | 9478 | TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type); |
ee1ab431 | 9479 | |
9480 | /* Convert each of the enumerators to the type of the underlying | |
9481 | type of the enumeration. */ | |
9482 | for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values)) | |
9483 | { | |
9484 | decl = TREE_VALUE (values); | |
9485 | value = perform_implicit_conversion (underlying_type, | |
9486 | DECL_INITIAL (decl)); | |
00b76131 | 9487 | |
9488 | /* Do not clobber shared ints. */ | |
9489 | value = copy_node (value); | |
9490 | ||
ee1ab431 | 9491 | TREE_TYPE (value) = enumtype; |
9492 | DECL_INITIAL (decl) = value; | |
9493 | TREE_VALUE (values) = value; | |
1791b32e | 9494 | } |
471086d6 | 9495 | |
a4fb1d94 | 9496 | /* Fix up all variant types of this enum type. */ |
9497 | for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t)) | |
9498 | { | |
9499 | TYPE_VALUES (t) = TYPE_VALUES (enumtype); | |
9500 | TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype); | |
9501 | TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype); | |
9502 | TYPE_SIZE (t) = TYPE_SIZE (enumtype); | |
9503 | TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype); | |
9504 | TYPE_MODE (t) = TYPE_MODE (enumtype); | |
9505 | TYPE_PRECISION (t) = TYPE_PRECISION (enumtype); | |
9506 | TYPE_ALIGN (t) = TYPE_ALIGN (enumtype); | |
9507 | TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype); | |
78a8ed03 | 9508 | TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype); |
1bb4c5ad | 9509 | } |
9510 | ||
a4fb1d94 | 9511 | /* Finish debugging output for this type. */ |
9512 | rest_of_type_compilation (enumtype, namespace_bindings_p ()); | |
471086d6 | 9513 | } |
9514 | ||
990c78e1 | 9515 | /* Build and install a CONST_DECL for an enumeration constant of the |
383acc13 | 9516 | enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided. |
471086d6 | 9517 | Assignment of sequential values by default is handled here. */ |
9518 | ||
383acc13 | 9519 | void |
1b72315d | 9520 | build_enumerator (tree name, tree value, tree enumtype) |
471086d6 | 9521 | { |
383acc13 | 9522 | tree decl; |
10151236 | 9523 | tree context; |
383acc13 | 9524 | tree type; |
471086d6 | 9525 | |
9526 | /* Remove no-op casts from the value. */ | |
9527 | if (value) | |
9528 | STRIP_TYPE_NOPS (value); | |
9529 | ||
383acc13 | 9530 | if (! processing_template_decl) |
9531 | { | |
9532 | /* Validate and default VALUE. */ | |
9533 | if (value != NULL_TREE) | |
9534 | { | |
1202e392 | 9535 | value = decl_constant_value (value); |
383acc13 | 9536 | |
9537 | if (TREE_CODE (value) == INTEGER_CST) | |
9538 | { | |
a681799d | 9539 | value = perform_integral_promotions (value); |
383acc13 | 9540 | constant_expression_warning (value); |
9541 | } | |
9542 | else | |
9543 | { | |
cf103c6c | 9544 | error ("enumerator value for `%D' not integer constant", name); |
383acc13 | 9545 | value = NULL_TREE; |
9546 | } | |
9547 | } | |
9548 | ||
9549 | /* Default based on previous value. */ | |
b4451e15 | 9550 | if (value == NULL_TREE) |
383acc13 | 9551 | { |
383acc13 | 9552 | if (TYPE_VALUES (enumtype)) |
9553 | { | |
637fdc50 | 9554 | HOST_WIDE_INT hi; |
9555 | unsigned HOST_WIDE_INT lo; | |
9556 | tree prev_value; | |
9557 | bool overflowed; | |
9558 | ||
9559 | /* The next value is the previous value plus one. We can | |
9560 | safely assume that the previous value is an INTEGER_CST. | |
9561 | add_double doesn't know the type of the target expression, | |
9562 | so we must check with int_fits_type_p as well. */ | |
383acc13 | 9563 | prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype))); |
637fdc50 | 9564 | overflowed = add_double (TREE_INT_CST_LOW (prev_value), |
9565 | TREE_INT_CST_HIGH (prev_value), | |
9566 | 1, 0, &lo, &hi); | |
9567 | value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi); | |
9568 | overflowed |= !int_fits_type_p (value, TREE_TYPE (prev_value)); | |
980877d7 | 9569 | |
637fdc50 | 9570 | if (overflowed) |
cf103c6c | 9571 | error ("overflow in enumeration values at `%D'", name); |
383acc13 | 9572 | } |
9573 | else | |
9574 | value = integer_zero_node; | |
9575 | } | |
9576 | ||
9577 | /* Remove no-op casts from the value. */ | |
15da6f57 | 9578 | STRIP_TYPE_NOPS (value); |
383acc13 | 9579 | } |
471086d6 | 9580 | |
471086d6 | 9581 | /* C++ associates enums with global, function, or class declarations. */ |
383acc13 | 9582 | context = current_scope (); |
ee1ab431 | 9583 | if (!context) |
9584 | context = current_namespace; | |
383acc13 | 9585 | |
9586 | /* Build the actual enumeration constant. Note that the enumeration | |
9587 | constants have the type of their initializers until the | |
9588 | enumeration is complete: | |
9589 | ||
9590 | [ dcl.enum ] | |
9591 | ||
9592 | Following the closing brace of an enum-specifier, each enumer- | |
9593 | ator has the type of its enumeration. Prior to the closing | |
9594 | brace, the type of each enumerator is the type of its | |
9595 | initializing value. | |
9596 | ||
9597 | In finish_enum we will reset the type. Of course, if we're | |
a109dc3b | 9598 | processing a template, there may be no value. */ |
383acc13 | 9599 | type = value ? TREE_TYPE (value) : NULL_TREE; |
9600 | ||
9601 | if (context && context == current_class_type) | |
9602 | /* This enum declaration is local to the class. We need the full | |
e41f0d80 | 9603 | lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */ |
383acc13 | 9604 | decl = build_lang_decl (CONST_DECL, name, type); |
9605 | else | |
9606 | /* It's a global enum, or it's local to a function. (Note local to | |
10151236 | 9607 | a function could mean local to a class method. */ |
383acc13 | 9608 | decl = build_decl (CONST_DECL, name, type); |
10151236 | 9609 | |
383acc13 | 9610 | DECL_CONTEXT (decl) = FROB_CONTEXT (context); |
4ee9c684 | 9611 | TREE_CONSTANT (decl) = 1; |
9612 | TREE_INVARIANT (decl) = 1; | |
9613 | TREE_READONLY (decl) = 1; | |
383acc13 | 9614 | DECL_INITIAL (decl) = value; |
10151236 | 9615 | |
383acc13 | 9616 | if (context && context == current_class_type) |
9617 | /* In something like `struct S { enum E { i = 7 }; };' we put `i' | |
ee1ab431 | 9618 | on the TYPE_FIELDS list for `S'. (That's so that you can say |
9619 | things like `S::i' later.) */ | |
383acc13 | 9620 | finish_member_declaration (decl); |
9621 | else | |
d03f29c4 | 9622 | pushdecl (decl); |
383acc13 | 9623 | |
9624 | /* Add this enumeration constant to the list for this type. */ | |
9625 | TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype)); | |
471086d6 | 9626 | } |
9627 | ||
471086d6 | 9628 | \f |
d119628b | 9629 | /* We're defining DECL. Make sure that it's type is OK. */ |
9630 | ||
9631 | static void | |
1b72315d | 9632 | check_function_type (tree decl, tree current_function_parms) |
d119628b | 9633 | { |
9634 | tree fntype = TREE_TYPE (decl); | |
4b72716d | 9635 | tree return_type = complete_type (TREE_TYPE (fntype)); |
d119628b | 9636 | |
9637 | /* In a function definition, arg types must be complete. */ | |
9638 | require_complete_types_for_parms (current_function_parms); | |
9639 | ||
4b72716d | 9640 | if (!COMPLETE_OR_VOID_TYPE_P (return_type)) |
d119628b | 9641 | { |
cf103c6c | 9642 | error ("return type `%#T' is incomplete", TREE_TYPE (fntype)); |
d119628b | 9643 | |
9644 | /* Make it return void instead, but don't change the | |
9645 | type of the DECL_RESULT, in case we have a named return value. */ | |
9646 | if (TREE_CODE (fntype) == METHOD_TYPE) | |
9647 | { | |
9648 | tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))); | |
9649 | TREE_TYPE (decl) | |
5bfb0742 | 9650 | = build_method_type_directly (ctype, |
9651 | void_type_node, | |
9652 | FUNCTION_ARG_CHAIN (decl)); | |
d119628b | 9653 | } |
9654 | else | |
9655 | TREE_TYPE (decl) | |
9656 | = build_function_type (void_type_node, | |
9657 | TYPE_ARG_TYPES (TREE_TYPE (decl))); | |
980877d7 | 9658 | TREE_TYPE (decl) |
d119628b | 9659 | = build_exception_variant (fntype, |
9660 | TYPE_RAISES_EXCEPTIONS (fntype)); | |
9661 | } | |
9662 | else | |
9663 | abstract_virtuals_error (decl, TREE_TYPE (fntype)); | |
9664 | } | |
9665 | ||
471086d6 | 9666 | /* Create the FUNCTION_DECL for a function definition. |
9667 | DECLSPECS and DECLARATOR are the parts of the declaration; | |
9668 | they describe the function's name and the type it returns, | |
9669 | but twisted together in a fashion that parallels the syntax of C. | |
9670 | ||
d119628b | 9671 | FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the |
9672 | DECLARATOR is really the DECL for the function we are about to | |
9673 | process and that DECLSPECS should be ignored), SF_INCLASS_INLINE | |
6528331d | 9674 | indicating that the function is an inline defined in-class. |
980877d7 | 9675 | |
471086d6 | 9676 | This function creates a binding context for the function body |
9677 | as well as setting up the FUNCTION_DECL in current_function_decl. | |
9678 | ||
471086d6 | 9679 | For C++, we must first check whether that datum makes any sense. |
9680 | For example, "class A local_a(1,2);" means that variable local_a | |
9681 | is an aggregate of type A, which should have a constructor | |
23f83a9a | 9682 | applied to it with the argument list [1, 2]. */ |
471086d6 | 9683 | |
3046c0a3 | 9684 | void |
9685 | start_preparsed_function (tree decl1, tree attrs, int flags) | |
471086d6 | 9686 | { |
471086d6 | 9687 | tree ctype = NULL_TREE; |
9688 | tree fntype; | |
9689 | tree restype; | |
471086d6 | 9690 | int doing_friend = 0; |
1f3233d1 | 9691 | struct cp_binding_level *bl; |
6528331d | 9692 | tree current_function_parms; |
62bf98ad | 9693 | struct c_fileinfo *finfo = get_fileinfo (input_filename); |
471086d6 | 9694 | |
471086d6 | 9695 | /* Sanity check. */ |
b4df430b | 9696 | gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE); |
9697 | gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE); | |
471086d6 | 9698 | |
3046c0a3 | 9699 | fntype = TREE_TYPE (decl1); |
9700 | if (TREE_CODE (fntype) == METHOD_TYPE) | |
9701 | ctype = TYPE_METHOD_BASETYPE (fntype); | |
491e04ef | 9702 | |
3046c0a3 | 9703 | /* ISO C++ 11.4/5. A friend function defined in a class is in |
9704 | the (lexical) scope of the class in which it is defined. */ | |
9705 | if (!ctype && DECL_FRIEND_P (decl1)) | |
471086d6 | 9706 | { |
3046c0a3 | 9707 | ctype = DECL_FRIEND_CONTEXT (decl1); |
491e04ef | 9708 | |
3046c0a3 | 9709 | /* CTYPE could be null here if we're dealing with a template; |
9710 | for example, `inline friend float foo()' inside a template | |
9711 | will have no CTYPE set. */ | |
9712 | if (ctype && TREE_CODE (ctype) != RECORD_TYPE) | |
9713 | ctype = NULL_TREE; | |
9714 | else | |
9715 | doing_friend = 1; | |
471086d6 | 9716 | } |
980877d7 | 9717 | |
5955c361 | 9718 | if (DECL_DECLARED_INLINE_P (decl1) |
9719 | && lookup_attribute ("noinline", attrs)) | |
9bc3739f | 9720 | warning ("%Jinline function '%D' given attribute noinline", decl1, decl1); |
5955c361 | 9721 | |
a321abdb | 9722 | if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1)) |
9723 | /* This is a constructor, we must ensure that any default args | |
9724 | introduced by this definition are propagated to the clones | |
9725 | now. The clones are used directly in overload resolution. */ | |
9726 | adjust_clone_args (decl1); | |
9727 | ||
e0e489c4 | 9728 | /* Sometimes we don't notice that a function is a static member, and |
9729 | build a METHOD_TYPE for it. Fix that up now. */ | |
9730 | if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1) | |
9731 | && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE) | |
9732 | { | |
11fa0266 | 9733 | revert_static_member_fn (decl1); |
e0e489c4 | 9734 | ctype = NULL_TREE; |
9735 | } | |
471086d6 | 9736 | |
53137e6a | 9737 | /* Set up current_class_type, and enter the scope of the class, if |
9738 | appropriate. */ | |
9739 | if (ctype) | |
5f6526e1 | 9740 | push_nested_class (ctype); |
53137e6a | 9741 | else if (DECL_STATIC_FUNCTION_P (decl1)) |
5f6526e1 | 9742 | push_nested_class (DECL_CONTEXT (decl1)); |
53137e6a | 9743 | |
9744 | /* Now that we have entered the scope of the class, we must restore | |
9745 | the bindings for any template parameters surrounding DECL1, if it | |
9746 | is an inline member template. (Order is important; consider the | |
9747 | case where a template parameter has the same name as a field of | |
9748 | the class.) It is not until after this point that | |
9749 | PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */ | |
d119628b | 9750 | if (flags & SF_INCLASS_INLINE) |
53137e6a | 9751 | maybe_begin_member_template_processing (decl1); |
9752 | ||
225ec6aa | 9753 | /* Effective C++ rule 15. */ |
70a658bd | 9754 | if (warn_ecpp |
97cc4539 | 9755 | && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR |
70a658bd | 9756 | && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE) |
cf103c6c | 9757 | warning ("`operator=' should return a reference to `*this'"); |
70a658bd | 9758 | |
9759 | /* Make the init_value nonzero so pushdecl knows this is not tentative. | |
9760 | error_mark_node is replaced below (in poplevel) with the BLOCK. */ | |
e0e489c4 | 9761 | if (!DECL_INITIAL (decl1)) |
9762 | DECL_INITIAL (decl1) = error_mark_node; | |
70a658bd | 9763 | |
70a658bd | 9764 | /* This function exists in static storage. |
9765 | (This does not mean `static' in the C sense!) */ | |
9766 | TREE_STATIC (decl1) = 1; | |
9767 | ||
9768 | /* We must call push_template_decl after current_class_type is set | |
9769 | up. (If we are processing inline definitions after exiting a | |
9770 | class scope, current_class_type will be NULL_TREE until set above | |
9771 | by push_nested_class.) */ | |
9772 | if (processing_template_decl) | |
9773 | decl1 = push_template_decl (decl1); | |
9774 | ||
53137e6a | 9775 | /* We are now in the scope of the function being defined. */ |
471086d6 | 9776 | current_function_decl = decl1; |
53137e6a | 9777 | |
e857e9c7 | 9778 | /* Save the parm names or decls from this function's declarator |
9779 | where store_parm_decls will find them. */ | |
7ef14399 | 9780 | current_function_parms = DECL_ARGUMENTS (decl1); |
471086d6 | 9781 | |
d119628b | 9782 | /* Make sure the parameter and return types are reasonable. When |
9783 | you declare a function, these types can be incomplete, but they | |
9784 | must be complete when you define the function. */ | |
3cc0b4b9 | 9785 | if (! processing_template_decl) |
6528331d | 9786 | check_function_type (decl1, current_function_parms); |
53137e6a | 9787 | |
d119628b | 9788 | /* Build the return declaration for the function. */ |
9789 | restype = TREE_TYPE (fntype); | |
b8e2eb91 | 9790 | /* Promote the value to int before returning it. */ |
9791 | if (c_promoting_integer_type_p (restype)) | |
9792 | restype = type_promotes_to (restype); | |
9793 | if (DECL_RESULT (decl1) == NULL_TREE) | |
d119628b | 9794 | { |
540edea7 | 9795 | tree resdecl; |
9796 | ||
9797 | resdecl = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype)); | |
9798 | DECL_ARTIFICIAL (resdecl) = 1; | |
9799 | DECL_IGNORED_P (resdecl) = 1; | |
9800 | DECL_RESULT (decl1) = resdecl; | |
9801 | ||
9802 | c_apply_type_quals_to_decl (cp_type_quals (restype), resdecl); | |
e857e9c7 | 9803 | } |
d119628b | 9804 | |
9805 | /* Initialize RTL machinery. We cannot do this until | |
9806 | CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this | |
9807 | even when processing a template; this is how we get | |
90a83261 | 9808 | CFUN set up, and our per-function variables initialized. |
9809 | FIXME factor out the non-RTL stuff. */ | |
d119628b | 9810 | bl = current_binding_level; |
90e3d9ba | 9811 | allocate_struct_function (decl1); |
fa3834f1 | 9812 | current_binding_level = bl; |
d119628b | 9813 | |
9814 | /* Even though we're inside a function body, we still don't want to | |
9815 | call expand_expr to calculate the size of a variable-sized array. | |
9816 | We haven't necessarily assigned RTL to all variables yet, so it's | |
9817 | not safe to try to expand expressions involving them. */ | |
08513b52 | 9818 | cfun->x_dont_save_pending_sizes_p = 1; |
d119628b | 9819 | |
6528331d | 9820 | /* Start the statement-tree, start the tree now. */ |
2363ef00 | 9821 | DECL_SAVED_TREE (decl1) = push_stmt_list (); |
76a24869 | 9822 | |
d119628b | 9823 | /* Let the user know we're compiling this function. */ |
a6260fc7 | 9824 | announce_function (decl1); |
1e66592c | 9825 | |
b248d3f7 | 9826 | /* Record the decl so that the function name is defined. |
9827 | If we already have a decl for this name, and it is a FUNCTION_DECL, | |
9828 | use the old decl. */ | |
d119628b | 9829 | if (!processing_template_decl && !(flags & SF_PRE_PARSED)) |
b248d3f7 | 9830 | { |
668ae905 | 9831 | /* A specialization is not used to guide overload resolution. */ |
f99f0e9c | 9832 | if (!DECL_FUNCTION_MEMBER_P (decl1) |
491e04ef | 9833 | && !(DECL_USE_TEMPLATE (decl1) && |
f99f0e9c | 9834 | PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1)))) |
947f430b | 9835 | { |
9836 | tree olddecl = pushdecl (decl1); | |
9837 | ||
9838 | if (olddecl == error_mark_node) | |
9839 | /* If something went wrong when registering the declaration, | |
9840 | use DECL1; we have to have a FUNCTION_DECL to use when | |
9841 | parsing the body of the function. */ | |
9842 | ; | |
9843 | else | |
9844 | /* Otherwise, OLDDECL is either a previous declaration of | |
9845 | the same function or DECL1 itself. */ | |
9846 | decl1 = olddecl; | |
9847 | } | |
8417823c | 9848 | else |
ef5a592c | 9849 | { |
a109dc3b | 9850 | /* We need to set the DECL_CONTEXT. */ |
ef5a592c | 9851 | if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1)) |
9852 | DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1)); | |
9853 | /* And make sure we have enough default args. */ | |
9854 | check_default_args (decl1); | |
9855 | } | |
b248d3f7 | 9856 | fntype = TREE_TYPE (decl1); |
9857 | } | |
e857e9c7 | 9858 | |
3aa0c315 | 9859 | /* Determine the ELF visibility attribute for the function. We must |
9860 | not do this before calling "pushdecl", as we must allow | |
9861 | "duplicate_decls" to merge any attributes appropriately. */ | |
9862 | if (!DECL_CLONED_FUNCTION_P (decl1)) | |
9863 | determine_visibility (decl1); | |
9864 | ||
d119628b | 9865 | /* Reset these in case the call to pushdecl changed them. */ |
e857e9c7 | 9866 | current_function_decl = decl1; |
08513b52 | 9867 | cfun->decl = decl1; |
b248d3f7 | 9868 | |
c15addfa | 9869 | /* If we are (erroneously) defining a function that we have already |
9870 | defined before, wipe out what we knew before. */ | |
1f3233d1 | 9871 | if (!DECL_PENDING_INLINE_P (decl1)) |
9872 | DECL_SAVED_FUNCTION_DATA (decl1) = NULL; | |
e0e489c4 | 9873 | |
6528331d | 9874 | if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1)) |
e0e489c4 | 9875 | { |
9876 | /* We know that this was set up by `grokclassfn'. We do not | |
9877 | wait until `store_parm_decls', since evil parse errors may | |
9878 | never get us to that point. Here we keep the consistency | |
9879 | between `current_class_type' and `current_class_ptr'. */ | |
9880 | tree t = DECL_ARGUMENTS (decl1); | |
980877d7 | 9881 | |
b4df430b | 9882 | gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL); |
9883 | gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE); | |
980877d7 | 9884 | |
9885 | cp_function_chain->x_current_class_ref | |
4d698345 | 9886 | = build_indirect_ref (t, NULL); |
e0e489c4 | 9887 | cp_function_chain->x_current_class_ptr = t; |
9888 | ||
16cb20eb | 9889 | /* Constructors and destructors need to know whether they're "in |
9890 | charge" of initializing virtual base classes. */ | |
dcbeb3ef | 9891 | t = TREE_CHAIN (t); |
a23287c6 | 9892 | if (DECL_HAS_IN_CHARGE_PARM_P (decl1)) |
dcbeb3ef | 9893 | { |
9894 | current_in_charge_parm = t; | |
9895 | t = TREE_CHAIN (t); | |
9896 | } | |
9897 | if (DECL_HAS_VTT_PARM_P (decl1)) | |
9898 | { | |
092b1d6f | 9899 | gcc_assert (DECL_NAME (t) == vtt_parm_identifier); |
dcbeb3ef | 9900 | current_vtt_parm = t; |
9901 | } | |
e0e489c4 | 9902 | } |
9903 | ||
c25194fd | 9904 | if (DECL_INTERFACE_KNOWN (decl1)) |
bb09dca5 | 9905 | { |
9ba4048d | 9906 | tree ctx = decl_function_context (decl1); |
f5246b56 | 9907 | |
bb09dca5 | 9908 | if (DECL_NOT_REALLY_EXTERN (decl1)) |
9909 | DECL_EXTERNAL (decl1) = 0; | |
f5246b56 | 9910 | |
d3981643 | 9911 | if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx) |
f5246b56 | 9912 | && TREE_PUBLIC (ctx)) |
9913 | /* This is a function in a local class in an extern inline | |
9914 | function. */ | |
9915 | comdat_linkage (decl1); | |
bb09dca5 | 9916 | } |
471086d6 | 9917 | /* If this function belongs to an interface, it is public. |
9918 | If it belongs to someone else's interface, it is also external. | |
c576929b | 9919 | This only affects inlines and template instantiations. */ |
62bf98ad | 9920 | else if (finfo->interface_unknown == 0 |
c79f94a2 | 9921 | && ! DECL_TEMPLATE_INSTANTIATION (decl1)) |
471086d6 | 9922 | { |
491e04ef | 9923 | if (DECL_DECLARED_INLINE_P (decl1) |
d3981643 | 9924 | || DECL_TEMPLATE_INSTANTIATION (decl1) |
3cc0b4b9 | 9925 | || processing_template_decl) |
c576929b | 9926 | { |
9927 | DECL_EXTERNAL (decl1) | |
62bf98ad | 9928 | = (finfo->interface_only |
491e04ef | 9929 | || (DECL_DECLARED_INLINE_P (decl1) |
d3981643 | 9930 | && ! flag_implement_inlines |
f3758bba | 9931 | && !DECL_VINDEX (decl1))); |
c576929b | 9932 | |
9933 | /* For WIN32 we also want to put these in linkonce sections. */ | |
9934 | maybe_make_one_only (decl1); | |
9935 | } | |
c25194fd | 9936 | else |
f69ecb3b | 9937 | DECL_EXTERNAL (decl1) = 0; |
3f7d79e4 | 9938 | DECL_NOT_REALLY_EXTERN (decl1) = 0; |
c25194fd | 9939 | DECL_INTERFACE_KNOWN (decl1) = 1; |
caa6fdce | 9940 | /* If this function is in an interface implemented in this file, |
9941 | make sure that the backend knows to emit this function | |
9942 | here. */ | |
9943 | if (!DECL_EXTERNAL (decl1)) | |
9944 | mark_needed (decl1); | |
471086d6 | 9945 | } |
62bf98ad | 9946 | else if (finfo->interface_unknown && finfo->interface_only |
c79f94a2 | 9947 | && ! DECL_TEMPLATE_INSTANTIATION (decl1)) |
d557c996 | 9948 | { |
9949 | /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma | |
62bf98ad | 9950 | interface, we will have both finfo->interface_unknown and |
9951 | finfo->interface_only set. In that case, we don't want to | |
9952 | use the normal heuristics because someone will supply a | |
9953 | #pragma implementation elsewhere, and deducing it here would | |
9954 | produce a conflict. */ | |
d557c996 | 9955 | comdat_linkage (decl1); |
9956 | DECL_EXTERNAL (decl1) = 0; | |
9957 | DECL_INTERFACE_KNOWN (decl1) = 1; | |
9958 | DECL_DEFER_OUTPUT (decl1) = 1; | |
9959 | } | |
471086d6 | 9960 | else |
ddb9bca7 | 9961 | { |
9962 | /* This is a definition, not a reference. | |
1e66592c | 9963 | So clear DECL_EXTERNAL. */ |
9964 | DECL_EXTERNAL (decl1) = 0; | |
bb09dca5 | 9965 | |
491e04ef | 9966 | if ((DECL_DECLARED_INLINE_P (decl1) |
d3981643 | 9967 | || DECL_TEMPLATE_INSTANTIATION (decl1)) |
e857e9c7 | 9968 | && ! DECL_INTERFACE_KNOWN (decl1) |
9969 | /* Don't try to defer nested functions for now. */ | |
9ba4048d | 9970 | && ! decl_function_context (decl1)) |
b248d3f7 | 9971 | DECL_DEFER_OUTPUT (decl1) = 1; |
9972 | else | |
f69ecb3b | 9973 | DECL_INTERFACE_KNOWN (decl1) = 1; |
c25194fd | 9974 | } |
d0622bdf | 9975 | |
e880f232 | 9976 | begin_scope (sk_function_parms, decl1); |
471086d6 | 9977 | |
e857e9c7 | 9978 | ++function_depth; |
9979 | ||
853b7640 | 9980 | if (DECL_DESTRUCTOR_P (decl1) |
9981 | || (DECL_CONSTRUCTOR_P (decl1) | |
9982 | && targetm.cxx.cdtor_returns_this ())) | |
31236dcd | 9983 | { |
853b7640 | 9984 | cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); |
9985 | DECL_CONTEXT (cdtor_label) = current_function_decl; | |
31236dcd | 9986 | } |
471086d6 | 9987 | |
65b7f83f | 9988 | start_fname_decls (); |
491e04ef | 9989 | |
6528331d | 9990 | store_parm_decls (current_function_parms); |
3046c0a3 | 9991 | } |
9992 | ||
9993 | ||
9994 | /* Like start_preparsed_function, except that instead of a | |
9995 | FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR. | |
9996 | ||
9997 | Returns 1 on success. If the DECLARATOR is not suitable for a function | |
9998 | (it defines a datum instead), we return 0, which tells | |
9999 | yyparse to report a parse error. */ | |
10000 | ||
10001 | int | |
491e04ef | 10002 | start_function (cp_decl_specifier_seq *declspecs, |
4b9b2871 | 10003 | const cp_declarator *declarator, |
3046c0a3 | 10004 | tree attrs) |
10005 | { | |
10006 | tree decl1; | |
10007 | ||
10008 | if (have_extern_spec) | |
10009 | { | |
4b9b2871 | 10010 | declspecs->storage_class = sc_extern; |
3046c0a3 | 10011 | /* This should only be done once on the outermost decl. */ |
10012 | have_extern_spec = false; | |
10013 | } | |
491e04ef | 10014 | |
3046c0a3 | 10015 | decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs); |
10016 | /* If the declarator is not suitable for a function definition, | |
10017 | cause a syntax error. */ | |
10018 | if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) | |
10019 | return 0; | |
491e04ef | 10020 | |
3046c0a3 | 10021 | cplus_decl_attributes (&decl1, attrs, 0); |
491e04ef | 10022 | |
3046c0a3 | 10023 | /* If #pragma weak was used, mark the decl weak now. */ |
10024 | if (global_scope_p (current_binding_level)) | |
10025 | maybe_apply_pragma_weak (decl1); | |
491e04ef | 10026 | |
3046c0a3 | 10027 | if (DECL_MAIN_P (decl1)) |
10028 | { | |
10029 | /* If this doesn't return integer_type, or a typedef to | |
10030 | integer_type, complain. */ | |
10031 | if (!same_type_p (TREE_TYPE (TREE_TYPE (decl1)), integer_type_node)) | |
10032 | { | |
10033 | if (pedantic || warn_return_type) | |
10034 | pedwarn ("return type for `main' changed to `int'"); | |
10035 | TREE_TYPE (decl1) = default_function_type; | |
10036 | } | |
10037 | } | |
10038 | ||
10039 | start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT); | |
6528331d | 10040 | |
471086d6 | 10041 | return 1; |
10042 | } | |
10043 | \f | |
10044 | /* Store the parameter declarations into the current function declaration. | |
10045 | This is called after parsing the parameter declarations, before | |
10046 | digesting the body of the function. | |
10047 | ||
10048 | Also install to binding contour return value identifier, if any. */ | |
10049 | ||
6528331d | 10050 | static void |
1b72315d | 10051 | store_parm_decls (tree current_function_parms) |
471086d6 | 10052 | { |
cd16867a | 10053 | tree fndecl = current_function_decl; |
10054 | tree parm; | |
471086d6 | 10055 | |
471086d6 | 10056 | /* This is a chain of any other decls that came in among the parm |
10057 | declarations. If a parm is declared with enum {foo, bar} x; | |
10058 | then CONST_DECLs for foo and bar are put here. */ | |
10059 | tree nonparms = NULL_TREE; | |
10060 | ||
e0e489c4 | 10061 | if (current_function_parms) |
471086d6 | 10062 | { |
10063 | /* This case is when the function was defined with an ANSI prototype. | |
10064 | The parms already have decls, so we need not do anything here | |
10065 | except record them as in effect | |
10066 | and complain if any redundant old-style parm decls were written. */ | |
10067 | ||
e0e489c4 | 10068 | tree specparms = current_function_parms; |
10069 | tree next; | |
10070 | ||
6528331d | 10071 | /* Must clear this because it might contain TYPE_DECLs declared |
e0e489c4 | 10072 | at class level. */ |
836495aa | 10073 | current_binding_level->names = NULL; |
471086d6 | 10074 | |
6528331d | 10075 | /* If we're doing semantic analysis, then we'll call pushdecl |
e0e489c4 | 10076 | for each of these. We must do them in reverse order so that |
10077 | they end in the correct forward order. */ | |
6528331d | 10078 | specparms = nreverse (specparms); |
e857e9c7 | 10079 | |
e0e489c4 | 10080 | for (parm = specparms; parm; parm = next) |
471086d6 | 10081 | { |
10082 | next = TREE_CHAIN (parm); | |
10083 | if (TREE_CODE (parm) == PARM_DECL) | |
10084 | { | |
6528331d | 10085 | if (DECL_NAME (parm) == NULL_TREE |
10086 | || TREE_CODE (parm) != VOID_TYPE) | |
10087 | pushdecl (parm); | |
10088 | else | |
cf103c6c | 10089 | error ("parameter `%D' declared void", parm); |
471086d6 | 10090 | } |
10091 | else | |
10092 | { | |
10093 | /* If we find an enum constant or a type tag, | |
10094 | put it aside for the moment. */ | |
10095 | TREE_CHAIN (parm) = NULL_TREE; | |
10096 | nonparms = chainon (nonparms, parm); | |
10097 | } | |
10098 | } | |
10099 | ||
6528331d | 10100 | /* Get the decls in their original chain order and record in the |
10101 | function. This is all and only the PARM_DECLs that were | |
10102 | pushed into scope by the loop above. */ | |
10103 | DECL_ARGUMENTS (fndecl) = getdecls (); | |
471086d6 | 10104 | } |
10105 | else | |
10106 | DECL_ARGUMENTS (fndecl) = NULL_TREE; | |
10107 | ||
10108 | /* Now store the final chain of decls for the arguments | |
10109 | as the decl-chain of the current lexical scope. | |
10110 | Put the enumerators in as well, at the front so that | |
10111 | DECL_ARGUMENTS is not modified. */ | |
836495aa | 10112 | current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl)); |
f85d646a | 10113 | |
dddcebdc | 10114 | /* For a cloned function, we've already got all the code we need; |
10115 | there's no need to add any extra bits. */ | |
10116 | if (!DECL_CLONED_FUNCTION_P (fndecl)) | |
10117 | { | |
10118 | /* Do the starting of the exception specifications, if we have any. */ | |
10119 | if (flag_exceptions && !processing_template_decl | |
10120 | && flag_enforce_eh_specs | |
10121 | && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl))) | |
10122 | current_eh_spec_block = begin_eh_spec_block (); | |
10123 | } | |
471086d6 | 10124 | } |
10125 | ||
471086d6 | 10126 | \f |
7f075a5e | 10127 | /* We have finished doing semantic analysis on DECL, but have not yet |
10128 | generated RTL for its body. Save away our current state, so that | |
10129 | when we want to generate RTL later we know what to do. */ | |
10130 | ||
10131 | static void | |
1b72315d | 10132 | save_function_data (tree decl) |
7f075a5e | 10133 | { |
1f3233d1 | 10134 | struct language_function *f; |
7f075a5e | 10135 | |
10136 | /* Save the language-specific per-function data so that we can | |
10137 | get it back when we really expand this function. */ | |
b4df430b | 10138 | gcc_assert (!DECL_PENDING_INLINE_P (decl)); |
980877d7 | 10139 | |
7f075a5e | 10140 | /* Make a copy. */ |
a33db04a | 10141 | f = GGC_NEW (struct language_function); |
1f3233d1 | 10142 | memcpy (f, cp_function_chain, sizeof (struct language_function)); |
7f075a5e | 10143 | DECL_SAVED_FUNCTION_DATA (decl) = f; |
10144 | ||
10145 | /* Clear out the bits we don't need. */ | |
2363ef00 | 10146 | f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE; |
7f075a5e | 10147 | f->x_named_label_uses = NULL; |
10148 | f->bindings = NULL; | |
e6393a02 | 10149 | f->x_local_names = NULL; |
7f075a5e | 10150 | } |
10151 | ||
7e3e1bb9 | 10152 | |
853b7640 | 10153 | /* Set the return value of the constructor (if present). */ |
51046b65 | 10154 | |
10155 | static void | |
1b72315d | 10156 | finish_constructor_body (void) |
51046b65 | 10157 | { |
853b7640 | 10158 | tree val; |
10159 | tree exprstmt; | |
10160 | ||
10161 | if (targetm.cxx.cdtor_returns_this ()) | |
10162 | { | |
10163 | /* Any return from a constructor will end up here. */ | |
10164 | add_stmt (build_stmt (LABEL_EXPR, cdtor_label)); | |
10165 | ||
10166 | val = DECL_ARGUMENTS (current_function_decl); | |
831d52a2 | 10167 | val = build2 (MODIFY_EXPR, TREE_TYPE (val), |
10168 | DECL_RESULT (current_function_decl), val); | |
853b7640 | 10169 | /* Return the address of the object. */ |
10170 | exprstmt = build_stmt (RETURN_EXPR, val); | |
10171 | add_stmt (exprstmt); | |
10172 | } | |
51046b65 | 10173 | } |
10174 | ||
7e3e1bb9 | 10175 | /* Do all the processing for the beginning of a destructor; set up the |
10176 | vtable pointers and cleanups for bases and members. */ | |
10177 | ||
10178 | static void | |
1b72315d | 10179 | begin_destructor_body (void) |
7e3e1bb9 | 10180 | { |
10181 | tree if_stmt; | |
10182 | tree compound_stmt; | |
10183 | ||
10184 | /* If the dtor is empty, and we know there is not any possible | |
10185 | way we could use any vtable entries, before they are possibly | |
10186 | set by a base class dtor, we don't have to setup the vtables, | |
10187 | as we know that any base class dtor will set up any vtables | |
10188 | it needs. We avoid MI, because one base class dtor can do a | |
10189 | virtual dispatch to an overridden function that would need to | |
10190 | have a non-related vtable set up, we cannot avoid setting up | |
10191 | vtables in that case. We could change this to see if there | |
10192 | is just one vtable. | |
10193 | ||
10194 | ??? In the destructor for a class, the vtables are set | |
10195 | appropriately for that class. There will be no non-related | |
10196 | vtables. jason 2001-12-11. */ | |
10197 | if_stmt = begin_if_stmt (); | |
10198 | ||
10199 | /* If it is not safe to avoid setting up the vtables, then | |
491e04ef | 10200 | someone will change the condition to be boolean_true_node. |
7e3e1bb9 | 10201 | (Actually, for now, we do not have code to set the condition |
10202 | appropriately, so we just assume that we always need to | |
10203 | initialize the vtables.) */ | |
10204 | finish_if_stmt_cond (boolean_true_node, if_stmt); | |
7e3e1bb9 | 10205 | |
2363ef00 | 10206 | compound_stmt = begin_compound_stmt (0); |
7e3e1bb9 | 10207 | |
10208 | /* Make all virtual function table pointers in non-virtual base | |
10209 | classes point to CURRENT_CLASS_TYPE's virtual function | |
10210 | tables. */ | |
10211 | initialize_vtbl_ptrs (current_class_ptr); | |
10212 | ||
68f8f8cc | 10213 | finish_compound_stmt (compound_stmt); |
7e3e1bb9 | 10214 | finish_then_clause (if_stmt); |
2363ef00 | 10215 | finish_if_stmt (if_stmt); |
7e3e1bb9 | 10216 | |
10217 | /* And insert cleanups for our bases and members so that they | |
10218 | will be properly destroyed if we throw. */ | |
10219 | push_base_cleanups (); | |
10220 | } | |
10221 | ||
52616263 | 10222 | /* At the end of every destructor we generate code to delete the object if |
10223 | necessary. Do that now. */ | |
3da16ddc | 10224 | |
10225 | static void | |
1b72315d | 10226 | finish_destructor_body (void) |
3da16ddc | 10227 | { |
3da16ddc | 10228 | tree exprstmt; |
10229 | ||
c47a7ada | 10230 | /* Any return from a destructor will end up here; that way all base |
10231 | and member cleanups will be run when the function returns. */ | |
853b7640 | 10232 | add_stmt (build_stmt (LABEL_EXPR, cdtor_label)); |
c47a7ada | 10233 | |
b429d3ee | 10234 | /* In a virtual destructor, we must call delete. */ |
10235 | if (DECL_VIRTUAL_P (current_function_decl)) | |
10236 | { | |
10237 | tree if_stmt; | |
d4c4d95c | 10238 | tree virtual_size = cxx_sizeof (current_class_type); |
980877d7 | 10239 | |
b429d3ee | 10240 | /* [class.dtor] |
980877d7 | 10241 | |
52616263 | 10242 | At the point of definition of a virtual destructor (including |
10243 | an implicit definition), non-placement operator delete shall | |
10244 | be looked up in the scope of the destructor's class and if | |
10245 | found shall be accessible and unambiguous. */ | |
b429d3ee | 10246 | exprstmt = build_op_delete_call |
491e04ef | 10247 | (DELETE_EXPR, current_class_ptr, virtual_size, |
1611df57 | 10248 | /*global_p=*/false, NULL_TREE); |
f04596da | 10249 | |
b429d3ee | 10250 | if_stmt = begin_if_stmt (); |
831d52a2 | 10251 | finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node, |
10252 | current_in_charge_parm, | |
10253 | integer_one_node), | |
b429d3ee | 10254 | if_stmt); |
10255 | finish_expr_stmt (exprstmt); | |
10256 | finish_then_clause (if_stmt); | |
2363ef00 | 10257 | finish_if_stmt (if_stmt); |
b429d3ee | 10258 | } |
853b7640 | 10259 | |
10260 | if (targetm.cxx.cdtor_returns_this ()) | |
10261 | { | |
10262 | tree val; | |
10263 | ||
10264 | val = DECL_ARGUMENTS (current_function_decl); | |
831d52a2 | 10265 | val = build2 (MODIFY_EXPR, TREE_TYPE (val), |
10266 | DECL_RESULT (current_function_decl), val); | |
853b7640 | 10267 | /* Return the address of the object. */ |
10268 | exprstmt = build_stmt (RETURN_EXPR, val); | |
10269 | add_stmt (exprstmt); | |
10270 | } | |
52616263 | 10271 | } |
3da16ddc | 10272 | |
52616263 | 10273 | /* Do the necessary processing for the beginning of a function body, which |
10274 | in this case includes member-initializers, but not the catch clauses of | |
10275 | a function-try-block. Currently, this means opening a binding level | |
10276 | for the member-initializers (in a ctor) and member cleanups (in a dtor). | |
10277 | In other functions, this isn't necessary, but it doesn't hurt. */ | |
10278 | ||
10279 | tree | |
1b72315d | 10280 | begin_function_body (void) |
52616263 | 10281 | { |
7e3e1bb9 | 10282 | tree stmt; |
10283 | ||
e0c6233d | 10284 | if (processing_template_decl) |
10285 | /* Do nothing now. */; | |
10286 | else | |
10287 | /* Always keep the BLOCK node associated with the outermost pair of | |
10288 | curly braces of a function. These are needed for correct | |
10289 | operation of dwarfout.c. */ | |
e880f232 | 10290 | keep_next_level (true); |
e0c6233d | 10291 | |
2363ef00 | 10292 | stmt = begin_compound_stmt (BCS_FN_BODY); |
7e3e1bb9 | 10293 | |
10294 | if (processing_template_decl) | |
10295 | /* Do nothing now. */; | |
7e3e1bb9 | 10296 | else if (DECL_DESTRUCTOR_P (current_function_decl)) |
10297 | begin_destructor_body (); | |
10298 | ||
52616263 | 10299 | return stmt; |
3da16ddc | 10300 | } |
10301 | ||
52616263 | 10302 | /* Do the processing for the end of a function body. Currently, this means |
10303 | closing out the cleanups for fully-constructed bases and members, and in | |
10304 | the case of the destructor, deleting the object if desired. Again, this | |
10305 | is only meaningful for [cd]tors, since they are the only functions where | |
10306 | there is a significant distinction between the main body and any | |
10307 | function catch clauses. Handling, say, main() return semantics here | |
10308 | would be wrong, as flowing off the end of a function catch clause for | |
10309 | main() would also need to return 0. */ | |
10310 | ||
10311 | void | |
1b72315d | 10312 | finish_function_body (tree compstmt) |
52616263 | 10313 | { |
c47a7ada | 10314 | /* Close the block. */ |
68f8f8cc | 10315 | finish_compound_stmt (compstmt); |
52616263 | 10316 | |
10317 | if (processing_template_decl) | |
10318 | /* Do nothing now. */; | |
10319 | else if (DECL_CONSTRUCTOR_P (current_function_decl)) | |
10320 | finish_constructor_body (); | |
10321 | else if (DECL_DESTRUCTOR_P (current_function_decl)) | |
10322 | finish_destructor_body (); | |
491e04ef | 10323 | } |
52616263 | 10324 | |
471086d6 | 10325 | /* Finish up a function declaration and compile that function |
10326 | all the way to assembler language output. The free the storage | |
10327 | for the function definition. | |
10328 | ||
980877d7 | 10329 | FLAGS is a bitwise or of the following values: |
53137e6a | 10330 | 2 - INCLASS_INLINE |
10331 | We just finished processing the body of an in-class inline | |
10332 | function definition. (This processing will have taken place | |
23f83a9a | 10333 | after the class definition is complete.) */ |
471086d6 | 10334 | |
07d01fbf | 10335 | tree |
1b72315d | 10336 | finish_function (int flags) |
471086d6 | 10337 | { |
cd16867a | 10338 | tree fndecl = current_function_decl; |
471086d6 | 10339 | tree fntype, ctype = NULL_TREE; |
53137e6a | 10340 | int inclass_inline = (flags & 2) != 0; |
23f83a9a | 10341 | int nested; |
471086d6 | 10342 | |
10343 | /* When we get some parse errors, we can end up without a | |
10344 | current_function_decl, so cope. */ | |
10345 | if (fndecl == NULL_TREE) | |
07d01fbf | 10346 | return error_mark_node; |
471086d6 | 10347 | |
9bacae7e | 10348 | if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl) |
10349 | && DECL_VIRTUAL_P (fndecl) | |
10350 | && !processing_template_decl) | |
10351 | { | |
10352 | tree fnclass = DECL_CONTEXT (fndecl); | |
10353 | if (fndecl == CLASSTYPE_KEY_METHOD (fnclass)) | |
10354 | keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes); | |
10355 | } | |
10356 | ||
23f83a9a | 10357 | nested = function_depth > 1; |
471086d6 | 10358 | fntype = TREE_TYPE (fndecl); |
10359 | ||
3da16ddc | 10360 | /* TREE_READONLY (fndecl) = 1; |
10361 | This caused &foo to be of type ptr-to-const-function | |
10362 | which then got a warning when stored in a ptr-to-function variable. */ | |
471086d6 | 10363 | |
b4df430b | 10364 | gcc_assert (building_stmt_tree ()); |
491e04ef | 10365 | |
e55cba4c | 10366 | /* For a cloned function, we've already got all the code we need; |
10367 | there's no need to add any extra bits. */ | |
6528331d | 10368 | if (!DECL_CLONED_FUNCTION_P (fndecl)) |
471086d6 | 10369 | { |
52616263 | 10370 | if (DECL_MAIN_P (current_function_decl)) |
51046b65 | 10371 | { |
10372 | /* Make it so that `main' always returns 0 by default. */ | |
d442be7a | 10373 | #if VMS_TARGET |
51046b65 | 10374 | finish_return_stmt (integer_one_node); |
10375 | #else | |
10376 | finish_return_stmt (integer_zero_node); | |
10377 | #endif | |
10378 | } | |
23f83a9a | 10379 | |
e0e489c4 | 10380 | /* Finish dealing with exception specifiers. */ |
10381 | if (flag_exceptions && !processing_template_decl | |
90252716 | 10382 | && flag_enforce_eh_specs |
e0e489c4 | 10383 | && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl))) |
df4b504c | 10384 | finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS |
10385 | (TREE_TYPE (current_function_decl)), | |
10386 | current_eh_spec_block); | |
e857e9c7 | 10387 | } |
980877d7 | 10388 | |
019cf886 | 10389 | /* If we're saving up tree structure, tie off the function now. */ |
2363ef00 | 10390 | DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl)); |
10391 | ||
10392 | finish_fname_decls (); | |
f96b25bb | 10393 | |
95cedffb | 10394 | /* If this function can't throw any exceptions, remember that. */ |
10395 | if (!processing_template_decl | |
10396 | && !cp_function_chain->can_throw | |
10397 | && !flag_non_call_exceptions) | |
10398 | TREE_NOTHROW (fndecl) = 1; | |
10399 | ||
471086d6 | 10400 | /* This must come after expand_function_end because cleanups might |
10401 | have declarations (from inline functions) that need to go into | |
10402 | this function's blocks. */ | |
491e04ef | 10403 | |
6cd31fa5 | 10404 | /* If the current binding level isn't the outermost binding level |
10405 | for this function, either there is a bug, or we have experienced | |
10406 | syntax errors and the statement tree is malformed. */ | |
37b9a732 | 10407 | if (current_binding_level->kind != sk_function_parms) |
6cd31fa5 | 10408 | { |
10409 | /* Make sure we have already experienced errors. */ | |
092b1d6f | 10410 | gcc_assert (errorcount); |
6cd31fa5 | 10411 | |
10412 | /* Throw away the broken statement tree and extra binding | |
10413 | levels. */ | |
632f8185 | 10414 | DECL_SAVED_TREE (fndecl) = alloc_stmt_list (); |
6cd31fa5 | 10415 | |
37b9a732 | 10416 | while (current_binding_level->kind != sk_function_parms) |
6cd31fa5 | 10417 | { |
37b9a732 | 10418 | if (current_binding_level->kind == sk_class) |
6cd31fa5 | 10419 | pop_nested_class (); |
10420 | else | |
10421 | poplevel (0, 0, 0); | |
10422 | } | |
10423 | } | |
6528331d | 10424 | poplevel (1, 0, 1); |
471086d6 | 10425 | |
90e3d9ba | 10426 | /* Statements should always be full-expressions at the outermost set |
10427 | of curly braces for a function. */ | |
b4df430b | 10428 | gcc_assert (stmts_are_full_exprs_p ()); |
90e3d9ba | 10429 | |
4ee9c684 | 10430 | /* Set up the named return value optimization, if we can. Candidate |
10431 | variables are selected in check_return_value. */ | |
4cfd9030 | 10432 | if (current_function_return_value) |
10433 | { | |
10434 | tree r = current_function_return_value; | |
7a8682e3 | 10435 | tree outer; |
10436 | ||
4cfd9030 | 10437 | if (r != error_mark_node |
7a8682e3 | 10438 | /* This is only worth doing for fns that return in memory--and |
10439 | simpler, since we don't have to worry about promoted modes. */ | |
45550790 | 10440 | && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl) |
7a8682e3 | 10441 | /* Only allow this for variables declared in the outer scope of |
10442 | the function so we know that their lifetime always ends with a | |
10443 | return; see g++.dg/opt/nrv6.C. We could be more flexible if | |
10444 | we were to do this optimization in tree-ssa. */ | |
2363ef00 | 10445 | && (outer = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl))) |
7a8682e3 | 10446 | /* Skip the artificial function body block. */ |
2363ef00 | 10447 | && (outer = BLOCK_SUBBLOCKS (outer)) |
10448 | && chain_member (r, BLOCK_VARS (outer))) | |
4ee9c684 | 10449 | finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl)); |
10450 | ||
10451 | current_function_return_value = NULL_TREE; | |
4cfd9030 | 10452 | } |
10453 | ||
d119628b | 10454 | /* Remember that we were in class scope. */ |
c25194fd | 10455 | if (current_class_name) |
d119628b | 10456 | ctype = current_class_type; |
c25194fd | 10457 | |
c98119cd | 10458 | /* Must mark the RESULT_DECL as being in this function. */ |
10459 | DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl; | |
10460 | ||
10461 | /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point | |
10462 | to the FUNCTION_DECL node itself. */ | |
10463 | BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl; | |
10464 | ||
7f075a5e | 10465 | /* Save away current state, if appropriate. */ |
6528331d | 10466 | if (!processing_template_decl) |
7f075a5e | 10467 | save_function_data (fndecl); |
10468 | ||
69f4b398 | 10469 | /* Complain if there's just no return statement. */ |
4edb3605 | 10470 | if (warn_return_type |
69f4b398 | 10471 | && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE |
7fac55ae | 10472 | && !dependent_type_p (TREE_TYPE (fntype)) |
8fb42a55 | 10473 | && !current_function_returns_value && !current_function_returns_null |
69f4b398 | 10474 | /* Don't complain if we abort or throw. */ |
10475 | && !current_function_returns_abnormally | |
86752479 | 10476 | && !DECL_NAME (DECL_RESULT (fndecl)) |
4edb3605 | 10477 | /* Normally, with -Wreturn-type, flow will complain. Unless we're an |
69f4b398 | 10478 | inline function, as we might never be compiled separately. */ |
853b7640 | 10479 | && (DECL_INLINE (fndecl) || processing_template_decl) |
10480 | /* Structor return values (if any) are set by the compiler. */ | |
10481 | && !DECL_CONSTRUCTOR_P (fndecl) | |
10482 | && !DECL_DESTRUCTOR_P (fndecl)) | |
69f4b398 | 10483 | warning ("no return statement in function returning non-void"); |
90e3d9ba | 10484 | |
4ee9c684 | 10485 | /* Store the end of the function, so that we get good line number |
10486 | info for the epilogue. */ | |
10487 | cfun->function_end_locus = input_location; | |
10488 | ||
10489 | /* Genericize before inlining. */ | |
10490 | if (!processing_template_decl) | |
10491 | { | |
667fed2f | 10492 | struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl); |
dddab69e | 10493 | cp_genericize (fndecl); |
667fed2f | 10494 | /* Clear out the bits we don't need. */ |
10495 | f->x_current_class_ptr = NULL; | |
10496 | f->x_current_class_ref = NULL; | |
10497 | f->x_eh_spec_block = NULL; | |
10498 | f->x_in_charge_parm = NULL; | |
10499 | f->x_vtt_parm = NULL; | |
10500 | f->x_return_value = NULL; | |
10501 | f->bindings = NULL; | |
4ee9c684 | 10502 | |
10503 | /* Handle attribute((warn_unused_result)). Relies on gimple input. */ | |
10504 | c_warn_unused_result (&DECL_SAVED_TREE (fndecl)); | |
10505 | } | |
667fed2f | 10506 | /* Clear out the bits we don't need. */ |
10507 | local_names = NULL; | |
10508 | named_label_uses = NULL; | |
4ee9c684 | 10509 | |
10510 | /* We're leaving the context of this function, so zap cfun. It's still in | |
10511 | DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */ | |
6528331d | 10512 | cfun = NULL; |
c437b0dc | 10513 | current_function_decl = NULL; |
d119628b | 10514 | |
92d27c95 | 10515 | /* If this is an in-class inline definition, we may have to pop the |
d119628b | 10516 | bindings for the template parameters that we added in |
10517 | maybe_begin_member_template_processing when start_function was | |
10518 | called. */ | |
10519 | if (inclass_inline) | |
10520 | maybe_end_member_template_processing (); | |
10521 | ||
10522 | /* Leave the scope of the class. */ | |
10523 | if (ctype) | |
10524 | pop_nested_class (); | |
e857e9c7 | 10525 | |
10526 | --function_depth; | |
471086d6 | 10527 | |
07d01fbf | 10528 | /* Clean up. */ |
bea7d742 | 10529 | if (! nested) |
d7c47c0e | 10530 | /* Let the error reporting routines know that we're outside a |
10531 | function. For a nested function, this value is used in | |
c80c4f22 | 10532 | cxx_pop_function_context and then reset via pop_function_context. */ |
d7c47c0e | 10533 | current_function_decl = NULL_TREE; |
07d01fbf | 10534 | |
10535 | return fndecl; | |
471086d6 | 10536 | } |
10537 | \f | |
10538 | /* Create the FUNCTION_DECL for a function definition. | |
471086d6 | 10539 | DECLSPECS and DECLARATOR are the parts of the declaration; |
10540 | they describe the return type and the name of the function, | |
10541 | but twisted together in a fashion that parallels the syntax of C. | |
10542 | ||
10543 | This function creates a binding context for the function body | |
10544 | as well as setting up the FUNCTION_DECL in current_function_decl. | |
10545 | ||
10546 | Returns a FUNCTION_DECL on success. | |
10547 | ||
10548 | If the DECLARATOR is not suitable for a function (it defines a datum | |
10549 | instead), we return 0, which tells yyparse to report a parse error. | |
10550 | ||
10551 | May return void_type_node indicating that this method is actually | |
10552 | a friend. See grokfield for more details. | |
10553 | ||
10554 | Came here with a `.pushlevel' . | |
10555 | ||
10556 | DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING | |
10557 | CHANGES TO CODE IN `grokfield'. */ | |
96624a9e | 10558 | |
471086d6 | 10559 | tree |
491e04ef | 10560 | start_method (cp_decl_specifier_seq *declspecs, |
4b9b2871 | 10561 | const cp_declarator *declarator, tree attrlist) |
471086d6 | 10562 | { |
f9670f72 | 10563 | tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0, |
e3c541f0 | 10564 | &attrlist); |
471086d6 | 10565 | |
0a3b29ad | 10566 | if (fndecl == error_mark_node) |
10567 | return error_mark_node; | |
10568 | ||
10569 | if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL) | |
10570 | { | |
10571 | error ("invalid member function declaration"); | |
10572 | return error_mark_node; | |
10573 | } | |
471086d6 | 10574 | |
34966237 | 10575 | if (attrlist) |
10576 | cplus_decl_attributes (&fndecl, attrlist, 0); | |
10577 | ||
471086d6 | 10578 | /* Pass friends other than inline friend functions back. */ |
f468434d | 10579 | if (fndecl == void_type_node) |
471086d6 | 10580 | return fndecl; |
10581 | ||
471086d6 | 10582 | if (DECL_IN_AGGR_P (fndecl)) |
10583 | { | |
28bbd27a | 10584 | if (DECL_CONTEXT (fndecl) |
10585 | && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL) | |
10586 | error ("`%D' is already defined in class `%T'", fndecl, | |
10587 | DECL_CONTEXT (fndecl)); | |
471086d6 | 10588 | return void_type_node; |
10589 | } | |
10590 | ||
c24cced6 | 10591 | check_template_shadow (fndecl); |
10592 | ||
d3981643 | 10593 | DECL_DECLARED_INLINE_P (fndecl) = 1; |
0543e7a9 | 10594 | if (flag_default_inline) |
471086d6 | 10595 | DECL_INLINE (fndecl) = 1; |
10596 | ||
34197853 | 10597 | /* We process method specializations in finish_struct_1. */ |
10598 | if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl)) | |
b7d1e8ea | 10599 | { |
10600 | fndecl = push_template_decl (fndecl); | |
10601 | if (fndecl == error_mark_node) | |
10602 | return fndecl; | |
10603 | } | |
ddb9bca7 | 10604 | |
471086d6 | 10605 | if (! DECL_FRIEND_P (fndecl)) |
10606 | { | |
471086d6 | 10607 | if (TREE_CHAIN (fndecl)) |
10608 | { | |
10609 | fndecl = copy_node (fndecl); | |
10610 | TREE_CHAIN (fndecl) = NULL_TREE; | |
10611 | } | |
01779b5f | 10612 | grok_special_member_properties (fndecl); |
471086d6 | 10613 | } |
10614 | ||
ce23987e | 10615 | cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0); |
471086d6 | 10616 | |
331bc0ad | 10617 | /* Make a place for the parms. */ |
e880f232 | 10618 | begin_scope (sk_function_parms, fndecl); |
980877d7 | 10619 | |
471086d6 | 10620 | DECL_IN_AGGR_P (fndecl) = 1; |
10621 | return fndecl; | |
10622 | } | |
10623 | ||
10624 | /* Go through the motions of finishing a function definition. | |
10625 | We don't compile this method until after the whole class has | |
10626 | been processed. | |
10627 | ||
10628 | FINISH_METHOD must return something that looks as though it | |
10629 | came from GROKFIELD (since we are defining a method, after all). | |
10630 | ||
10631 | This is called after parsing the body of the function definition. | |
10632 | STMTS is the chain of statements that makes up the function body. | |
10633 | ||
10634 | DECL is the ..._DECL that `start_method' provided. */ | |
10635 | ||
10636 | tree | |
1b72315d | 10637 | finish_method (tree decl) |
471086d6 | 10638 | { |
cd16867a | 10639 | tree fndecl = decl; |
471086d6 | 10640 | tree old_initial; |
471086d6 | 10641 | |
cd16867a | 10642 | tree link; |
471086d6 | 10643 | |
f468434d | 10644 | if (decl == void_type_node) |
471086d6 | 10645 | return decl; |
10646 | ||
10647 | old_initial = DECL_INITIAL (fndecl); | |
10648 | ||
10649 | /* Undo the level for the parms (from start_method). | |
10650 | This is like poplevel, but it causes nothing to be | |
10651 | saved. Saving information here confuses symbol-table | |
10652 | output routines. Besides, this information will | |
10653 | be correctly output when this method is actually | |
10654 | compiled. */ | |
10655 | ||
10656 | /* Clear out the meanings of the local variables of this level; | |
10657 | also record in each decl which block it belongs to. */ | |
10658 | ||
10659 | for (link = current_binding_level->names; link; link = TREE_CHAIN (link)) | |
10660 | { | |
10661 | if (DECL_NAME (link) != NULL_TREE) | |
2b77484d | 10662 | pop_binding (DECL_NAME (link), link); |
b4df430b | 10663 | gcc_assert (TREE_CODE (link) != FUNCTION_DECL); |
471086d6 | 10664 | DECL_CONTEXT (link) = NULL_TREE; |
10665 | } | |
10666 | ||
471086d6 | 10667 | poplevel (0, 0, 0); |
10668 | ||
10669 | DECL_INITIAL (fndecl) = old_initial; | |
10670 | ||
10671 | /* We used to check if the context of FNDECL was different from | |
10672 | current_class_type as another way to get inside here. This didn't work | |
10673 | for String.cc in libg++. */ | |
10674 | if (DECL_FRIEND_P (fndecl)) | |
10675 | { | |
10676 | CLASSTYPE_INLINE_FRIENDS (current_class_type) | |
10677 | = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type)); | |
10678 | decl = void_type_node; | |
10679 | } | |
10680 | ||
10681 | return decl; | |
10682 | } | |
10683 | \f | |
242fc35c | 10684 | |
10685 | /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that | |
10686 | we can lay it out later, when and if its type becomes complete. */ | |
471086d6 | 10687 | |
10688 | void | |
1b72315d | 10689 | maybe_register_incomplete_var (tree var) |
471086d6 | 10690 | { |
b4df430b | 10691 | gcc_assert (TREE_CODE (var) == VAR_DECL); |
471086d6 | 10692 | |
242fc35c | 10693 | /* Keep track of variables with incomplete types. */ |
491e04ef | 10694 | if (!processing_template_decl && TREE_TYPE (var) != error_mark_node |
242fc35c | 10695 | && DECL_EXTERNAL (var)) |
fd8d6049 | 10696 | { |
242fc35c | 10697 | tree inner_type = TREE_TYPE (var); |
491e04ef | 10698 | |
242fc35c | 10699 | while (TREE_CODE (inner_type) == ARRAY_TYPE) |
10700 | inner_type = TREE_TYPE (inner_type); | |
10701 | inner_type = TYPE_MAIN_VARIANT (inner_type); | |
491e04ef | 10702 | |
242fc35c | 10703 | if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type)) |
10704 | /* RTTI TD entries are created while defining the type_info. */ | |
10705 | || (TYPE_LANG_SPECIFIC (inner_type) | |
10706 | && TYPE_BEING_DEFINED (inner_type))) | |
10707 | incomplete_vars = tree_cons (inner_type, var, incomplete_vars); | |
fd8d6049 | 10708 | } |
242fc35c | 10709 | } |
fd8d6049 | 10710 | |
242fc35c | 10711 | /* Called when a class type (given by TYPE) is defined. If there are |
10712 | any existing VAR_DECLs whose type hsa been completed by this | |
10713 | declaration, update them now. */ | |
fd8d6049 | 10714 | |
242fc35c | 10715 | void |
1b72315d | 10716 | complete_vars (tree type) |
242fc35c | 10717 | { |
10718 | tree *list = &incomplete_vars; | |
10719 | ||
b4df430b | 10720 | gcc_assert (CLASS_TYPE_P (type)); |
491e04ef | 10721 | while (*list) |
242fc35c | 10722 | { |
10723 | if (same_type_p (type, TREE_PURPOSE (*list))) | |
fd8d6049 | 10724 | { |
242fc35c | 10725 | tree var = TREE_VALUE (*list); |
b3609646 | 10726 | /* Complete the type of the variable. The VAR_DECL itself |
10727 | will be laid out in expand_expr. */ | |
10728 | complete_type (TREE_TYPE (var)); | |
242fc35c | 10729 | /* Remove this entry from the list. */ |
10730 | *list = TREE_CHAIN (*list); | |
ce28ee2e | 10731 | } |
10732 | else | |
242fc35c | 10733 | list = &TREE_CHAIN (*list); |
ce28ee2e | 10734 | } |
d97a7640 | 10735 | |
10736 | /* Check for pending declarations which may have abstract type. */ | |
10737 | complete_type_check_abstract (type); | |
471086d6 | 10738 | } |
10739 | ||
675996d9 | 10740 | /* If DECL is of a type which needs a cleanup, build that cleanup |
10741 | here. */ | |
96624a9e | 10742 | |
675996d9 | 10743 | tree |
1b72315d | 10744 | cxx_maybe_build_cleanup (tree decl) |
471086d6 | 10745 | { |
10746 | tree type = TREE_TYPE (decl); | |
675996d9 | 10747 | |
89e923d8 | 10748 | if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) |
471086d6 | 10749 | { |
5af5654a | 10750 | int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR; |
471086d6 | 10751 | tree rval; |
471086d6 | 10752 | |
471086d6 | 10753 | if (TREE_CODE (type) == ARRAY_TYPE) |
10754 | rval = decl; | |
10755 | else | |
10756 | { | |
9b86eec0 | 10757 | cxx_mark_addressable (decl); |
471086d6 | 10758 | rval = build_unary_op (ADDR_EXPR, decl, 0); |
10759 | } | |
10760 | ||
10761 | /* Optimize for space over speed here. */ | |
10762 | if (! TYPE_USES_VIRTUAL_BASECLASSES (type) | |
10763 | || flag_expensive_optimizations) | |
10764 | flags |= LOOKUP_NONVIRTUAL; | |
10765 | ||
675996d9 | 10766 | rval = build_delete (TREE_TYPE (rval), rval, |
10767 | sfk_complete_destructor, flags, 0); | |
471086d6 | 10768 | |
10769 | if (TYPE_USES_VIRTUAL_BASECLASSES (type) | |
10770 | && ! TYPE_HAS_DESTRUCTOR (type)) | |
8a4008da | 10771 | rval = build_compound_expr (rval, build_vbase_delete (type, decl)); |
471086d6 | 10772 | |
471086d6 | 10773 | return rval; |
10774 | } | |
7b6facbf | 10775 | return NULL_TREE; |
471086d6 | 10776 | } |
10777 | \f | |
019cf886 | 10778 | /* When a stmt has been parsed, this function is called. */ |
471086d6 | 10779 | |
10780 | void | |
1b72315d | 10781 | finish_stmt (void) |
471086d6 | 10782 | { |
471086d6 | 10783 | } |
10784 | ||
11fa0266 | 10785 | /* DECL was originally constructed as a non-static member function, |
10786 | but turned out to be static. Update it accordingly. */ | |
94f3b32d | 10787 | |
2d45f35b | 10788 | void |
1b72315d | 10789 | revert_static_member_fn (tree decl) |
471086d6 | 10790 | { |
94f3b32d | 10791 | tree tmp; |
11fa0266 | 10792 | tree function = TREE_TYPE (decl); |
10793 | tree args = TYPE_ARG_TYPES (function); | |
471086d6 | 10794 | |
3119c950 | 10795 | if (cp_type_quals (TREE_TYPE (TREE_VALUE (args))) |
3e04bd45 | 10796 | != TYPE_UNQUALIFIED) |
cf103c6c | 10797 | error ("static member function `%#D' declared with type qualifiers", |
2eee06a0 | 10798 | decl); |
ce28ee2e | 10799 | |
94f3b32d | 10800 | args = TREE_CHAIN (args); |
10801 | tmp = build_function_type (TREE_TYPE (function), args); | |
3119c950 | 10802 | tmp = build_qualified_type (tmp, cp_type_quals (function)); |
ce28ee2e | 10803 | tmp = build_exception_variant (tmp, |
471086d6 | 10804 | TYPE_RAISES_EXCEPTIONS (function)); |
11fa0266 | 10805 | TREE_TYPE (decl) = tmp; |
10806 | if (DECL_ARGUMENTS (decl)) | |
10807 | DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl)); | |
10808 | DECL_STATIC_FUNCTION_P (decl) = 1; | |
471086d6 | 10809 | } |
d81e00a4 | 10810 | |
980877d7 | 10811 | /* Initialize the variables used during compilation of a C++ |
10812 | function. */ | |
c25194fd | 10813 | |
c80c4f22 | 10814 | void |
1b72315d | 10815 | cxx_push_function_context (struct function * f) |
54c2eeba | 10816 | { |
a33db04a | 10817 | struct language_function *p = GGC_CNEW (struct language_function); |
1f3233d1 | 10818 | f->language = p; |
c25194fd | 10819 | |
b48733fd | 10820 | /* Whenever we start a new function, we destroy temporaries in the |
10821 | usual way. */ | |
a08e60ae | 10822 | current_stmt_tree ()->stmts_are_full_exprs_p = 1; |
90e3d9ba | 10823 | |
10824 | if (f->decl) | |
10825 | { | |
10826 | tree fn = f->decl; | |
10827 | ||
90e3d9ba | 10828 | if (DECL_SAVED_FUNCTION_DATA (fn)) |
10829 | { | |
10830 | /* If we already parsed this function, and we're just expanding it | |
10831 | now, restore saved state. */ | |
10832 | *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn); | |
10833 | ||
90e3d9ba | 10834 | /* We don't need the saved data anymore. Unless this is an inline |
491e04ef | 10835 | function; we need the named return value info for |
8e7912a5 | 10836 | declare_return_variable. */ |
90e3d9ba | 10837 | if (! DECL_INLINE (fn)) |
10838 | DECL_SAVED_FUNCTION_DATA (fn) = NULL; | |
10839 | } | |
10840 | } | |
c25194fd | 10841 | } |
10842 | ||
d119628b | 10843 | /* Free the language-specific parts of F, now that we've finished |
10844 | compiling the function. */ | |
c25194fd | 10845 | |
c80c4f22 | 10846 | void |
1b72315d | 10847 | cxx_pop_function_context (struct function * f) |
c25194fd | 10848 | { |
54c2eeba | 10849 | f->language = 0; |
c25194fd | 10850 | } |
5eb54a7a | 10851 | |
1f3233d1 | 10852 | /* Return which tree structure is used by T, or TS_CP_GENERIC if T is |
10853 | one of the language-independent trees. */ | |
1e463950 | 10854 | |
1f3233d1 | 10855 | enum cp_tree_node_structure_enum |
1b72315d | 10856 | cp_tree_node_structure (union lang_tree_node * t) |
1e463950 | 10857 | { |
1f3233d1 | 10858 | switch (TREE_CODE (&t->generic)) |
1e463950 | 10859 | { |
0a3b29ad | 10860 | case DEFAULT_ARG: return TS_CP_DEFAULT_ARG; |
1f3233d1 | 10861 | case IDENTIFIER_NODE: return TS_CP_IDENTIFIER; |
1f3233d1 | 10862 | case OVERLOAD: return TS_CP_OVERLOAD; |
10863 | case TEMPLATE_PARM_INDEX: return TS_CP_TPI; | |
018c1ab0 | 10864 | case TINST_LEVEL: return TS_CP_TINST_LEVEL; |
1f3233d1 | 10865 | case PTRMEM_CST: return TS_CP_PTRMEM; |
8c1f65e6 | 10866 | case BASELINK: return TS_CP_BASELINK; |
1f3233d1 | 10867 | default: return TS_CP_GENERIC; |
1e463950 | 10868 | } |
10869 | } | |
6bf5ed8d | 10870 | |
174fcc61 | 10871 | /* Build the void_list_node (void_type_node having been created). */ |
10872 | tree | |
1b72315d | 10873 | build_void_list_node (void) |
174fcc61 | 10874 | { |
10875 | tree t = build_tree_list (NULL_TREE, void_type_node); | |
174fcc61 | 10876 | return t; |
10877 | } | |
10878 | ||
4ee9c684 | 10879 | bool |
1b72315d | 10880 | cp_missing_noreturn_ok_p (tree decl) |
20c01ba9 | 10881 | { |
10882 | /* A missing noreturn is ok for the `main' function. */ | |
7e64c604 | 10883 | return DECL_MAIN_P (decl); |
20c01ba9 | 10884 | } |
1f3233d1 | 10885 | |
537cd941 | 10886 | /* Return the COMDAT group into which DECL should be placed. */ |
10887 | ||
10888 | const char * | |
10889 | cxx_comdat_group (tree decl) | |
10890 | { | |
10891 | tree name; | |
10892 | ||
10893 | /* Virtual tables, construction virtual tables, and virtual table | |
10894 | tables all go in a single COMDAT group, named after the primary | |
10895 | virtual table. */ | |
10896 | if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl)) | |
10897 | name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl))); | |
10898 | /* For all other DECLs, the COMDAT group is the mangled name of the | |
10899 | declaration itself. */ | |
10900 | else | |
10901 | name = DECL_ASSEMBLER_NAME (decl); | |
10902 | ||
10903 | return IDENTIFIER_POINTER (name); | |
10904 | } | |
10905 | ||
1f3233d1 | 10906 | #include "gt-cp-decl.h" |