1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
22 /* Process declarations and symbol lookup for C front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
37 #include <sys/types.h>
41 #define obstack_chunk_alloc xmalloc
42 #define obstack_chunk_free free
44 extern tree builtin_return_address_fndecl;
46 extern struct obstack permanent_obstack;
48 extern int current_class_depth;
50 extern tree cleanups_this_call;
52 extern tree static_ctors, static_dtors;
54 /* Stack of places to restore the search obstack back to. */
56 /* Obstack used for remembering local class declarations (like
57 enums and static (const) members. */
59 static struct obstack decl_obstack;
60 static struct stack_level *decl_stack;
62 #ifndef CHAR_TYPE_SIZE
63 #define CHAR_TYPE_SIZE BITS_PER_UNIT
66 #ifndef SHORT_TYPE_SIZE
67 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
71 #define INT_TYPE_SIZE BITS_PER_WORD
74 #ifndef LONG_TYPE_SIZE
75 #define LONG_TYPE_SIZE BITS_PER_WORD
78 #ifndef LONG_LONG_TYPE_SIZE
79 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
82 #ifndef WCHAR_UNSIGNED
83 #define WCHAR_UNSIGNED 0
86 #ifndef FLOAT_TYPE_SIZE
87 #define FLOAT_TYPE_SIZE BITS_PER_WORD
90 #ifndef DOUBLE_TYPE_SIZE
91 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
94 #ifndef LONG_DOUBLE_TYPE_SIZE
95 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
98 #ifndef BOOL_TYPE_SIZE
99 #ifdef SLOW_BYTE_ACCESS
100 #define BOOL_TYPE_SIZE BITS_PER_WORD
102 #define BOOL_TYPE_SIZE BITS_PER_UNIT
106 /* We let tm.h override the types used here, to handle trivial differences
107 such as the choice of unsigned int or long unsigned int for size_t.
108 When machines start needing nontrivial differences in the size type,
109 it would be best to do something here to figure out automatically
110 from other information what type to use. */
113 #define SIZE_TYPE "long unsigned int"
117 #define PTRDIFF_TYPE "long int"
121 #define WCHAR_TYPE "int"
124 static tree grokparms PROTO((tree, int));
125 static tree lookup_nested_type PROTO((tree, tree));
126 static char *redeclaration_error_message PROTO((tree, tree));
127 static void grok_op_properties PROTO((tree, int, int));
130 PROTO((char *, tree, enum built_in_function, void (*)(), char *));
132 /* a node which has tree code ERROR_MARK, and whose type is itself.
133 All erroneous expressions are replaced with this node. All functions
134 that accept nodes as arguments should avoid generating error messages
135 if this node is one of the arguments, since it is undesirable to get
136 multiple error messages from one error in the input. */
138 tree error_mark_node;
140 /* Erroneous argument lists can use this *IFF* they do not modify it. */
141 tree error_mark_list;
143 /* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
145 tree short_integer_type_node;
146 tree integer_type_node;
147 tree long_integer_type_node;
148 tree long_long_integer_type_node;
150 tree short_unsigned_type_node;
151 tree unsigned_type_node;
152 tree long_unsigned_type_node;
153 tree long_long_unsigned_type_node;
155 tree ptrdiff_type_node;
157 tree unsigned_char_type_node;
158 tree signed_char_type_node;
160 tree wchar_type_node;
161 tree signed_wchar_type_node;
162 tree unsigned_wchar_type_node;
164 tree wchar_decl_node;
166 tree float_type_node;
167 tree double_type_node;
168 tree long_double_type_node;
170 tree intQI_type_node;
171 tree intHI_type_node;
172 tree intSI_type_node;
173 tree intDI_type_node;
175 tree unsigned_intQI_type_node;
176 tree unsigned_intHI_type_node;
177 tree unsigned_intSI_type_node;
178 tree unsigned_intDI_type_node;
180 /* a VOID_TYPE node, and the same, packaged in a TREE_LIST. */
182 tree void_type_node, void_list_node;
185 /* Nodes for types `void *' and `const void *'. */
187 tree ptr_type_node, const_ptr_type_node;
189 /* Nodes for types `char *' and `const char *'. */
191 tree string_type_node, const_string_type_node;
193 /* Type `char[256]' or something like it.
194 Used when an array of char is needed and the size is irrelevant. */
196 tree char_array_type_node;
198 /* Type `int[256]' or something like it.
199 Used when an array of int needed and the size is irrelevant. */
201 tree int_array_type_node;
203 /* Type `wchar_t[256]' or something like it.
204 Used when a wide string literal is created. */
206 tree wchar_array_type_node;
208 /* The bool data type, and constants */
209 tree boolean_type_node, boolean_true_node, boolean_false_node;
211 /* type `int ()' -- used for implicit declaration of functions. */
213 tree default_function_type;
215 /* function types `double (double)' and `double (double, double)', etc. */
217 tree double_ftype_double, double_ftype_double_double;
218 tree int_ftype_int, long_ftype_long;
220 /* Function type `void (void *, void *, int)' and similar ones. */
222 tree void_ftype_ptr_ptr_int, int_ftype_ptr_ptr_int, void_ftype_ptr_int_int;
224 /* Function type `char *(char *, char *)' and similar ones */
225 tree string_ftype_ptr_ptr, int_ftype_string_string;
227 /* Function type `size_t (const char *)' */
228 tree sizet_ftype_string;
230 /* Function type `int (const void *, const void *, size_t)' */
231 tree int_ftype_cptr_cptr_sizet;
234 tree vtable_entry_type;
235 tree delta_type_node;
237 /* Old rtti stuff. */
238 tree __baselist_desc_type_node;
239 tree __i_desc_type_node, __m_desc_type_node;
240 tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
242 tree __t_desc_type_node, __tp_desc_type_node;
243 tree __access_mode_type_node;
244 tree __bltn_desc_type_node, __user_desc_type_node, __class_desc_type_node;
245 tree __ptr_desc_type_node, __attr_desc_type_node, __func_desc_type_node;
246 tree __ptmf_desc_type_node, __ptmd_desc_type_node;
248 /* Not needed yet? May be needed one day? */
249 tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
250 tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
251 tree __ptmf_desc_array_type, __ptmd_desc_array_type;
254 tree class_star_type_node;
255 tree class_type_node, record_type_node, union_type_node, enum_type_node;
256 tree unknown_type_node;
257 tree opaque_type_node, signature_type_node;
258 tree sigtable_entry_type;
259 tree maybe_gc_cleanup;
261 /* Array type `vtable_entry_type[]' */
264 /* In a destructor, the point at which all derived class destroying
265 has been done, just before any base class destroying will be done. */
269 /* In a constructor, the point at which we are ready to return
270 the pointer to the initialized object. */
274 /* A FUNCTION_DECL which can call `abort'. Not necessarily the
275 one that the user will declare, but sufficient to be called
276 by routines that want to abort the program. */
280 extern rtx cleanup_label, return_label;
282 /* If original DECL_RESULT of current function was a register,
283 but due to being an addressable named return value, would up
284 on the stack, this variable holds the named return value's
285 original location. */
286 rtx original_result_rtx;
288 /* Sequence of insns which represents base initialization. */
291 /* C++: Keep these around to reduce calls to `get_identifier'.
292 Identifiers for `this' in member functions and the auto-delete
293 parameter for destructors. */
294 tree this_identifier, in_charge_identifier;
295 /* Used in pointer to member functions, and in vtables. */
296 tree pfn_identifier, index_identifier, delta_identifier, delta2_identifier;
297 tree pfn_or_delta2_identifier;
299 /* A list (chain of TREE_LIST nodes) of named label uses.
300 The TREE_PURPOSE field is the list of variables defined
301 the the label's scope defined at the point of use.
302 The TREE_VALUE field is the LABEL_DECL used.
303 The TREE_TYPE field holds `current_binding_level' at the
304 point of the label's use.
306 Used only for jumps to as-yet undefined labels, since
307 jumps to defined labels can have their validity checked
310 static tree named_label_uses;
312 /* A list of objects which have constructors or destructors
313 which reside in the global scope. The decl is stored in
314 the TREE_VALUE slot and the initializer is stored
315 in the TREE_PURPOSE slot. */
316 tree static_aggregates;
320 /* Two expressions that are constants with value zero.
321 The first is of type `int', the second of type `void *'. */
323 tree integer_zero_node;
324 tree null_pointer_node;
326 /* A node for the integer constants 1, 2, and 3. */
328 tree integer_one_node, integer_two_node, integer_three_node;
330 /* Nonzero if we have seen an invalid cross reference
331 to a struct, union, or enum, but not yet printed the message. */
333 tree pending_invalid_xref;
334 /* File and line to appear in the eventual error message. */
335 char *pending_invalid_xref_file;
336 int pending_invalid_xref_line;
338 /* While defining an enum type, this is 1 plus the last enumerator
341 static tree enum_next_value;
343 /* Nonzero means that there was overflow computing enum_next_value. */
345 static int enum_overflow;
347 /* Parsing a function declarator leaves a list of parameter names
348 or a chain or parameter decls here. */
350 tree last_function_parms;
352 /* Parsing a function declarator leaves here a chain of structure
353 and enum types declared in the parmlist. */
355 static tree last_function_parm_tags;
357 /* After parsing the declarator that starts a function definition,
358 `start_function' puts here the list of parameter names or chain of decls.
359 `store_parm_decls' finds it here. */
361 static tree current_function_parms;
363 /* Similar, for last_function_parm_tags. */
364 static tree current_function_parm_tags;
366 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
367 that have names. Here so we can clear out their names' definitions
368 at the end of the function. */
370 static tree named_labels;
372 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
374 static tree shadowed_labels;
376 #if 0 /* Not needed by C++ */
377 /* Nonzero when store_parm_decls is called indicates a varargs function.
378 Value not meaningful after store_parm_decls. */
380 static int c_function_varargs;
383 /* The FUNCTION_DECL for the function currently being compiled,
384 or 0 if between functions. */
385 tree current_function_decl;
387 /* Set to 0 at beginning of a function definition, set to 1 if
388 a return statement that specifies a return value is seen. */
390 int current_function_returns_value;
392 /* Set to 0 at beginning of a function definition, set to 1 if
393 a return statement with no argument is seen. */
395 int current_function_returns_null;
397 /* Set to 0 at beginning of a function definition, and whenever
398 a label (case or named) is defined. Set to value of expression
399 returned from function when that value can be transformed into
400 a named return value. */
402 tree current_function_return_value;
404 /* Set to nonzero by `grokdeclarator' for a function
405 whose return type is defaulted, if warnings for this are desired. */
407 static int warn_about_return_type;
409 /* Nonzero means give `double' the same size as `float'. */
411 extern int flag_short_double;
413 /* Nonzero means don't recognize any builtin functions. */
415 extern int flag_no_builtin;
417 /* Nonzero means don't recognize the non-ANSI builtin functions.
420 extern int flag_no_nonansi_builtin;
422 /* Nonzero means enable obscure ANSI features and disable GNU extensions
423 that might cause ANSI-compliant code to be miscompiled. */
425 extern int flag_ansi;
427 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
429 extern int flag_huge_objects;
431 /* Nonzero if we want to conserve space in the .o files. We do this
432 by putting uninitialized data and runtime initialized data into
433 .common instead of .data at the expense of not flaging multiple
435 extern int flag_conserve_space;
437 /* Pointers to the base and current top of the language name stack. */
439 extern tree *current_lang_base, *current_lang_stack;
441 /* C and C++ flags are in decl2.c. */
443 /* Set to 0 at beginning of a constructor, set to 1
444 if that function does an allocation before referencing its
445 instance variable. */
446 int current_function_assigns_this;
447 int current_function_just_assigned_this;
449 /* Set to 0 at beginning of a function. Set non-zero when
450 store_parm_decls is called. Don't call store_parm_decls
451 if this flag is non-zero! */
452 int current_function_parms_stored;
454 /* Current end of entries in the gc obstack for stack pointer variables. */
456 int current_function_obstack_index;
458 /* Flag saying whether we have used the obstack in this function or not. */
460 int current_function_obstack_usage;
462 /* Flag used when debugging spew.c */
464 extern int spew_debug;
466 /* This is a copy of the class_shadowed list of the previous class binding
467 contour when at global scope. It's used to reset IDENTIFIER_CLASS_VALUEs
468 when entering another class scope (i.e. a cache miss). */
469 extern tree previous_class_values;
472 /* Allocate a level of searching. */
474 push_decl_level (stack, obstack)
475 struct stack_level *stack;
476 struct obstack *obstack;
478 struct stack_level tem;
481 return push_stack_level (obstack, (char *)&tem, sizeof (tem));
484 /* For each binding contour we allocate a binding_level structure
485 * which records the names defined in that contour.
488 * 1) one for each function definition,
489 * where internal declarations of the parameters appear.
490 * 2) one for each compound statement,
491 * to record its declarations.
493 * The current meaning of a name can be found by searching the levels from
494 * the current one out to the global one.
496 * Off to the side, may be the class_binding_level. This exists
497 * only to catch class-local declarations. It is otherwise
500 * Also there may be binding levels that catch cleanups that
501 * must be run when exceptions occur.
504 /* Note that the information in the `names' component of the global contour
505 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
509 /* A chain of _DECL nodes for all variables, constants, functions,
510 * and typedef types. These are in the reverse of the order supplied.
514 /* A list of structure, union and enum definitions,
515 * for looking up tag names.
516 * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
517 * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
518 * or ENUMERAL_TYPE node.
520 * C++: the TREE_VALUE nodes can be simple types for component_bindings.
525 /* For each level, a list of shadowed outer-level local definitions
526 to be restored when this level is popped.
527 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
528 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
531 /* Same, for IDENTIFIER_CLASS_VALUE. */
534 /* Same, for IDENTIFIER_TYPE_VALUE. */
537 /* For each level (except not the global one),
538 a chain of BLOCK nodes for all the levels
539 that were entered and exited one level down. */
542 /* The BLOCK node for this level, if one has been preallocated.
543 If 0, the BLOCK is allocated (if needed) when the level is popped. */
546 /* The binding level which this one is contained in (inherits from). */
547 struct binding_level *level_chain;
549 /* Number of decls in `names' that have incomplete
550 structure or union types. */
551 unsigned int n_incomplete;
553 /* 1 for the level that holds the parameters of a function.
554 2 for the level that holds a class declaration.
555 3 for levels that hold parameter declarations. */
556 unsigned parm_flag : 4;
558 /* 1 means make a BLOCK for this level regardless of all else.
559 2 for temporary binding contours created by the compiler. */
562 /* Nonzero if this level "doesn't exist" for tags. */
563 unsigned tag_transparent : 1;
565 /* Nonzero if this level can safely have additional
566 cleanup-needing variables added to it. */
567 unsigned more_cleanups_ok : 1;
568 unsigned have_cleanups : 1;
570 /* Nonzero if we should accept any name as an identifier in
571 this scope. This happens in some template definitions. */
572 unsigned accept_any : 1;
574 /* Nonzero if this level is for completing a template class definition
575 inside a binding level that temporarily binds the parameters. This
576 means that definitions here should not be popped off when unwinding
577 this binding level. (Not actually implemented this way,
579 unsigned pseudo_global : 1;
581 /* Two bits left for this word. */
583 #if defined(DEBUG_CP_BINDING_LEVELS)
584 /* Binding depth at which this level began. */
585 unsigned binding_depth;
586 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
589 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
591 /* The (non-class) binding level currently in effect. */
593 static struct binding_level *current_binding_level;
595 /* The binding level of the current class, if any. */
597 static struct binding_level *class_binding_level;
599 /* The current (class or non-class) binding level currently in effect. */
601 #define inner_binding_level \
602 (class_binding_level ? class_binding_level : current_binding_level)
604 /* A chain of binding_level structures awaiting reuse. */
606 static struct binding_level *free_binding_level;
608 /* The outermost binding level, for names of file scope.
609 This is created when the compiler is started and exists
610 through the entire run. */
612 static struct binding_level *global_binding_level;
614 /* Binding level structures are initialized by copying this one. */
616 static struct binding_level clear_binding_level;
618 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
620 static int keep_next_level_flag;
622 #if defined(DEBUG_CP_BINDING_LEVELS)
623 static int binding_depth = 0;
624 static int is_class_level = 0;
631 for (i = 0; i < binding_depth*2; i++)
634 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
636 static tree pushdecl_with_scope PROTO((tree, struct binding_level *));
639 push_binding_level (newlevel, tag_transparent, keep)
640 struct binding_level *newlevel;
641 int tag_transparent, keep;
643 /* Add this level to the front of the chain (stack) of levels that
645 *newlevel = clear_binding_level;
646 if (class_binding_level)
648 newlevel->level_chain = class_binding_level;
649 class_binding_level = (struct binding_level *)0;
653 newlevel->level_chain = current_binding_level;
655 current_binding_level = newlevel;
656 newlevel->tag_transparent = tag_transparent;
657 newlevel->more_cleanups_ok = 1;
658 newlevel->keep = keep;
659 #if defined(DEBUG_CP_BINDING_LEVELS)
660 newlevel->binding_depth = binding_depth;
662 fprintf (stderr, "push %s level 0x%08x line %d\n",
663 (is_class_level) ? "class" : "block", newlevel, lineno);
666 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
672 if (class_binding_level)
673 current_binding_level = class_binding_level;
675 if (global_binding_level)
677 /* cannot pop a level, if there are none left to pop. */
678 if (current_binding_level == global_binding_level)
679 my_friendly_abort (123);
681 /* Pop the current level, and free the structure for reuse. */
682 #if defined(DEBUG_CP_BINDING_LEVELS)
685 fprintf (stderr, "pop %s level 0x%08x line %d\n",
686 (is_class_level) ? "class" : "block",
687 current_binding_level, lineno);
688 if (is_class_level != (current_binding_level == class_binding_level))
689 #if 0 /* XXX Don't abort when we're watching how things are being managed. */
694 fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
698 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
700 register struct binding_level *level = current_binding_level;
701 current_binding_level = current_binding_level->level_chain;
702 level->level_chain = free_binding_level;
703 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
704 if (level->binding_depth != binding_depth)
706 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
707 free_binding_level = level;
709 class_binding_level = current_binding_level;
710 if (class_binding_level->parm_flag != 2)
711 class_binding_level = 0;
712 while (current_binding_level->parm_flag == 2)
713 current_binding_level = current_binding_level->level_chain;
717 /* Nonzero if we are currently in the global binding level. */
722 return current_binding_level == global_binding_level;
728 keep_next_level_flag = 1;
731 /* Nonzero if the current level needs to have a BLOCK made. */
736 return (current_binding_level->blocks != NULL_TREE
737 || current_binding_level->keep
738 || current_binding_level->names != NULL_TREE
739 || (current_binding_level->tags != NULL_TREE
740 && !current_binding_level->tag_transparent));
743 /* Identify this binding level as a level of parameters. */
746 declare_parm_level ()
748 current_binding_level->parm_flag = 1;
752 declare_uninstantiated_type_level ()
754 current_binding_level->accept_any = 1;
758 uninstantiated_type_level_p ()
760 return current_binding_level->accept_any;
764 declare_pseudo_global_level ()
766 current_binding_level->pseudo_global = 1;
770 pseudo_global_level_p ()
772 return current_binding_level->pseudo_global;
776 set_class_shadows (shadows)
779 class_binding_level->class_shadowed = shadows;
782 /* Enter a new binding level.
783 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
784 not for that of tags. */
787 pushlevel (tag_transparent)
790 register struct binding_level *newlevel = NULL_BINDING_LEVEL;
792 /* If this is the top level of a function,
793 just make sure that NAMED_LABELS is 0.
794 They should have been set to 0 at the end of the previous function. */
796 if (current_binding_level == global_binding_level)
797 my_friendly_assert (named_labels == NULL_TREE, 134);
799 /* Reuse or create a struct for this binding level. */
801 #if defined(DEBUG_CP_BINDING_LEVELS)
803 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
804 if (free_binding_level)
805 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
807 newlevel = free_binding_level;
808 free_binding_level = free_binding_level->level_chain;
812 /* Create a new `struct binding_level'. */
813 newlevel = (struct binding_level *) xmalloc (sizeof (struct binding_level));
815 push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
816 GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
817 keep_next_level_flag = 0;
821 pushlevel_temporary (tag_transparent)
824 pushlevel (tag_transparent);
825 current_binding_level->keep = 2;
828 /* Note we don't call push_momentary() here. Otherwise, it would cause
829 cleanups to be allocated on the momentary obstack, and they will be
830 overwritten by the next statement. */
832 expand_start_bindings (0);
835 /* Exit a binding level.
836 Pop the level off, and restore the state of the identifier-decl mappings
837 that were in effect when this level was entered.
839 If KEEP == 1, this level had explicit declarations, so
840 and create a "block" (a BLOCK node) for the level
841 to record its declarations and subblocks for symbol table output.
843 If KEEP == 2, this level's subblocks go to the front,
844 not the back of the current binding level. This happens,
845 for instance, when code for constructors and destructors
846 need to generate code at the end of a function which must
847 be moved up to the front of the function.
849 If FUNCTIONBODY is nonzero, this level is the body of a function,
850 so create a block as if KEEP were set and also clear out all
853 If REVERSE is nonzero, reverse the order of decls before putting
854 them into the BLOCK. */
857 poplevel (keep, reverse, functionbody)
863 /* The chain of decls was accumulated in reverse order.
864 Put it into forward order, just for cleanliness. */
866 int tmp = functionbody;
867 int implicit_try_block = current_binding_level->parm_flag == 3;
868 int real_functionbody = current_binding_level->keep == 2
869 ? ((functionbody = 0), tmp) : functionbody;
870 tree tags = functionbody >= 0 ? current_binding_level->tags : 0;
871 tree subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
872 tree block = NULL_TREE;
874 int block_previously_created;
876 GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
877 (HOST_WIDE_INT) current_binding_level->level_chain,
878 current_binding_level->parm_flag,
879 current_binding_level->keep,
880 current_binding_level->tag_transparent);
882 if (current_binding_level->keep == 1)
885 /* This warning is turned off because it causes warnings for
886 declarations like `extern struct foo *x'. */
888 /* Warn about incomplete structure types in this level. */
889 for (link = tags; link; link = TREE_CHAIN (link))
890 if (TYPE_SIZE (TREE_VALUE (link)) == NULL_TREE)
892 tree type = TREE_VALUE (link);
894 switch (TREE_CODE (type))
897 errmsg = "`struct %s' incomplete in scope ending here";
900 errmsg = "`union %s' incomplete in scope ending here";
903 errmsg = "`enum %s' incomplete in scope ending here";
906 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
907 error (errmsg, IDENTIFIER_POINTER (TYPE_NAME (type)));
909 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
910 error (errmsg, TYPE_NAME_STRING (type));
914 /* Get the decls in the order they were written.
915 Usually current_binding_level->names is in reverse order.
916 But parameter decls were previously put in forward order. */
919 current_binding_level->names
920 = decls = nreverse (current_binding_level->names);
922 decls = current_binding_level->names;
924 /* Output any nested inline functions within this block
925 if they weren't already output. */
927 for (decl = decls; decl; decl = TREE_CHAIN (decl))
928 if (TREE_CODE (decl) == FUNCTION_DECL
929 && ! TREE_ASM_WRITTEN (decl)
930 && DECL_INITIAL (decl) != NULL_TREE
931 && TREE_ADDRESSABLE (decl)
932 && decl_function_context (decl) == current_function_decl)
934 /* If this decl was copied from a file-scope decl
935 on account of a block-scope extern decl,
936 propagate TREE_ADDRESSABLE to the file-scope decl. */
937 if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
938 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
941 push_function_context ();
942 output_inline_function (decl);
943 pop_function_context ();
947 /* If there were any declarations or structure tags in that level,
948 or if this level is a function body,
949 create a BLOCK to record them for the life of this function. */
952 block_previously_created = (current_binding_level->this_block != NULL_TREE);
953 if (block_previously_created)
954 block = current_binding_level->this_block;
955 else if (keep == 1 || functionbody)
956 block = make_node (BLOCK);
957 if (block != NULL_TREE)
959 BLOCK_VARS (block) = decls;
960 BLOCK_TYPE_TAGS (block) = tags;
961 BLOCK_SUBBLOCKS (block) = subblocks;
962 /* If we created the block earlier on, and we are just diddling it now,
963 then it already should have a proper BLOCK_END_NOTE value associated
964 with it, so avoid trashing that. Otherwise, for a new block, install
965 a new BLOCK_END_NOTE value. */
966 if (! block_previously_created)
967 remember_end_note (block);
970 /* In each subblock, record that this is its superior. */
973 for (link = subblocks; link; link = TREE_CHAIN (link))
974 BLOCK_SUPERCONTEXT (link) = block;
976 /* Clear out the meanings of the local variables of this level. */
978 for (link = decls; link; link = TREE_CHAIN (link))
980 if (DECL_NAME (link) != NULL_TREE)
982 /* If the ident. was used or addressed via a local extern decl,
983 don't forget that fact. */
984 if (DECL_EXTERNAL (link))
986 if (TREE_USED (link))
987 TREE_USED (DECL_ASSEMBLER_NAME (link)) = 1;
988 if (TREE_ADDRESSABLE (link))
989 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
991 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = NULL_TREE;
995 /* Restore all name-meanings of the outer levels
996 that were shadowed by this level. */
998 for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
999 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1000 for (link = current_binding_level->class_shadowed;
1001 link; link = TREE_CHAIN (link))
1002 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1003 for (link = current_binding_level->type_shadowed;
1004 link; link = TREE_CHAIN (link))
1005 IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1007 /* If the level being exited is the top level of a function,
1008 check over all the labels. */
1012 /* If this is the top level block of a function,
1013 the vars are the function's parameters.
1014 Don't leave them in the BLOCK because they are
1015 found in the FUNCTION_DECL instead. */
1017 BLOCK_VARS (block) = 0;
1019 /* Clear out the definitions of all label names,
1020 since their scopes end here. */
1022 for (link = named_labels; link; link = TREE_CHAIN (link))
1024 register tree label = TREE_VALUE (link);
1026 if (DECL_INITIAL (label) == NULL_TREE)
1028 cp_error_at ("label `%D' used but not defined", label);
1029 /* Avoid crashing later. */
1030 define_label (input_filename, 1, DECL_NAME (label));
1032 else if (warn_unused && !TREE_USED (label))
1033 cp_warning_at ("label `%D' defined but not used", label);
1034 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), NULL_TREE);
1036 /* Put the labels into the "variables" of the
1037 top-level block, so debugger can see them. */
1038 TREE_CHAIN (label) = BLOCK_VARS (block);
1039 BLOCK_VARS (block) = label;
1042 named_labels = NULL_TREE;
1045 /* Any uses of undefined labels now operate under constraints
1046 of next binding contour. */
1048 struct binding_level *level_chain;
1049 level_chain = current_binding_level->level_chain;
1053 for (labels = named_label_uses; labels; labels = TREE_CHAIN (labels))
1054 if (TREE_TYPE (labels) == (tree)current_binding_level)
1056 TREE_TYPE (labels) = (tree)level_chain;
1057 TREE_PURPOSE (labels) = level_chain->names;
1062 tmp = current_binding_level->keep;
1064 pop_binding_level ();
1066 DECL_INITIAL (current_function_decl) = block;
1069 if (!block_previously_created)
1070 current_binding_level->blocks
1071 = chainon (current_binding_level->blocks, block);
1073 /* If we did not make a block for the level just exited,
1074 any blocks made for inner levels
1075 (since they cannot be recorded as subblocks in that level)
1076 must be carried forward so they will later become subblocks
1077 of something else. */
1081 current_binding_level->blocks
1082 = chainon (subblocks, current_binding_level->blocks);
1084 current_binding_level->blocks
1085 = chainon (current_binding_level->blocks, subblocks);
1088 /* Take care of compiler's internal binding structures. */
1092 /* We did not call push_momentary for this
1093 binding contour, so there is nothing to pop. */
1096 expand_end_bindings (getdecls (), keep, 1);
1097 /* Each and every BLOCK node created here in `poplevel' is important
1098 (e.g. for proper debugging information) so if we created one
1099 earlier, mark it as "used". */
1101 TREE_USED (block) = 1;
1102 block = poplevel (keep, reverse, real_functionbody);
1105 /* Each and every BLOCK node created here in `poplevel' is important
1106 (e.g. for proper debugging information) so if we created one
1107 earlier, mark it as "used". */
1109 TREE_USED (block) = 1;
1113 /* Delete the node BLOCK from the current binding level.
1114 This is used for the block inside a stmt expr ({...})
1115 so that the block can be reinserted where appropriate. */
1118 delete_block (block)
1122 if (current_binding_level->blocks == block)
1123 current_binding_level->blocks = TREE_CHAIN (block);
1124 for (t = current_binding_level->blocks; t;)
1126 if (TREE_CHAIN (t) == block)
1127 TREE_CHAIN (t) = TREE_CHAIN (block);
1131 TREE_CHAIN (block) = NULL_TREE;
1132 /* Clear TREE_USED which is always set by poplevel.
1133 The flag is set again if insert_block is called. */
1134 TREE_USED (block) = 0;
1137 /* Insert BLOCK at the end of the list of subblocks of the
1138 current binding level. This is used when a BIND_EXPR is expanded,
1139 to handle the BLOCK node inside the BIND_EXPR. */
1142 insert_block (block)
1145 TREE_USED (block) = 1;
1146 current_binding_level->blocks
1147 = chainon (current_binding_level->blocks, block);
1150 /* Add BLOCK to the current list of blocks for this binding contour. */
1152 add_block_current_level (block)
1155 current_binding_level->blocks
1156 = chainon (current_binding_level->blocks, block);
1159 /* Set the BLOCK node for the innermost scope
1160 (the one we are currently in). */
1164 register tree block;
1166 current_binding_level->this_block = block;
1169 /* Do a pushlevel for class declarations. */
1173 register struct binding_level *newlevel;
1175 /* Reuse or create a struct for this binding level. */
1176 #if defined(DEBUG_CP_BINDING_LEVELS)
1178 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1179 if (free_binding_level)
1180 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1182 newlevel = free_binding_level;
1183 free_binding_level = free_binding_level->level_chain;
1187 /* Create a new `struct binding_level'. */
1188 newlevel = (struct binding_level *) xmalloc (sizeof (struct binding_level));
1191 #if defined(DEBUG_CP_BINDING_LEVELS)
1193 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1195 push_binding_level (newlevel, 0, 0);
1197 decl_stack = push_decl_level (decl_stack, &decl_obstack);
1198 class_binding_level = current_binding_level;
1199 class_binding_level->parm_flag = 2;
1200 /* We have just pushed into a new binding level. Now, fake out the rest
1201 of the compiler. Set the `current_binding_level' back to point to
1202 the most closely containing non-class binding level. */
1205 current_binding_level = current_binding_level->level_chain;
1207 while (current_binding_level->parm_flag == 2);
1210 /* ...and a poplevel for class declarations. FORCE is used to force
1211 clearing out of CLASS_VALUEs after a class definition. */
1213 poplevel_class (force)
1216 register struct binding_level *level = class_binding_level;
1217 tree block = NULL_TREE;
1220 my_friendly_assert (level != 0, 354);
1222 decl_stack = pop_stack_level (decl_stack);
1223 for (shadowed = level->shadowed; shadowed; shadowed = TREE_CHAIN (shadowed))
1224 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (shadowed)) = TREE_VALUE (shadowed);
1225 /* If we're leaving a toplevel class, don't bother to do the setting
1226 of IDENTIFER_CLASS_VALUE to NULL_TREE, since first of all this slot
1227 shouldn't even be used when current_class_type isn't set, and second,
1228 if we don't touch it here, we're able to use the caching effect if the
1229 next time we're entering a class scope, it is the same class. */
1230 if (current_class_depth != 1 || force)
1231 for (shadowed = level->class_shadowed;
1233 shadowed = TREE_CHAIN (shadowed))
1234 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = TREE_VALUE (shadowed);
1236 /* Remember to save what IDENTIFIER's were bound in this scope so we
1237 can recover from cache misses. */
1238 previous_class_values = class_binding_level->class_shadowed;
1239 for (shadowed = level->type_shadowed;
1241 shadowed = TREE_CHAIN (shadowed))
1242 IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed)) = TREE_VALUE (shadowed);
1244 GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1245 (HOST_WIDE_INT) class_binding_level->level_chain,
1246 class_binding_level->parm_flag,
1247 class_binding_level->keep,
1248 class_binding_level->tag_transparent);
1250 if (class_binding_level->parm_flag != 2)
1251 class_binding_level = (struct binding_level *)0;
1253 /* Now, pop out of the the binding level which we created up in the
1254 `pushlevel_class' routine. */
1255 #if defined(DEBUG_CP_BINDING_LEVELS)
1257 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1259 pop_binding_level ();
1264 /* For debugging. */
1265 int no_print_functions = 0;
1266 int no_print_builtins = 0;
1269 print_binding_level (lvl)
1270 struct binding_level *lvl;
1274 fprintf (stderr, " blocks=");
1275 fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1276 fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1277 lvl->n_incomplete, lvl->parm_flag, lvl->keep);
1278 if (lvl->tag_transparent)
1279 fprintf (stderr, " tag-transparent");
1280 if (lvl->more_cleanups_ok)
1281 fprintf (stderr, " more-cleanups-ok");
1282 if (lvl->have_cleanups)
1283 fprintf (stderr, " have-cleanups");
1284 fprintf (stderr, "\n");
1287 fprintf (stderr, " names:\t");
1288 /* We can probably fit 3 names to a line? */
1289 for (t = lvl->names; t; t = TREE_CHAIN (t))
1291 if (no_print_functions && (TREE_CODE(t) == FUNCTION_DECL))
1293 if (no_print_builtins
1294 && (TREE_CODE(t) == TYPE_DECL)
1295 && (!strcmp(DECL_SOURCE_FILE(t),"<built-in>")))
1298 /* Function decls tend to have longer names. */
1299 if (TREE_CODE (t) == FUNCTION_DECL)
1306 fprintf (stderr, "\n\t");
1309 print_node_brief (stderr, "", t, 0);
1310 if (TREE_CODE (t) == ERROR_MARK)
1314 fprintf (stderr, "\n");
1318 fprintf (stderr, " tags:\t");
1320 for (t = lvl->tags; t; t = TREE_CHAIN (t))
1322 if (TREE_PURPOSE (t) == NULL_TREE)
1324 else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1331 fprintf (stderr, "\n\t");
1334 if (TREE_PURPOSE (t) == NULL_TREE)
1336 print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
1337 fprintf (stderr, ">");
1339 else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1340 print_node_brief (stderr, "", TREE_VALUE (t), 0);
1343 print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
1344 print_node_brief (stderr, "", TREE_VALUE (t), 0);
1345 fprintf (stderr, ">");
1349 fprintf (stderr, "\n");
1353 fprintf (stderr, " shadowed:");
1354 for (t = lvl->shadowed; t; t = TREE_CHAIN (t))
1356 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1358 fprintf (stderr, "\n");
1360 if (lvl->class_shadowed)
1362 fprintf (stderr, " class-shadowed:");
1363 for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1365 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1367 fprintf (stderr, "\n");
1369 if (lvl->type_shadowed)
1371 fprintf (stderr, " type-shadowed:");
1372 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1375 fprintf (stderr, "\n\t");
1376 print_node_brief (stderr, "<", TREE_PURPOSE (t), 0);
1378 print_node_brief (stderr, " ", TREE_VALUE (t), 0);
1380 fprintf (stderr, " (none)");
1381 fprintf (stderr, ">");
1383 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1386 fprintf (stderr, "\n");
1391 print_other_binding_stack (stack)
1392 struct binding_level *stack;
1394 struct binding_level *level;
1395 for (level = stack; level != global_binding_level; level = level->level_chain)
1397 fprintf (stderr, "binding level ");
1398 fprintf (stderr, HOST_PTR_PRINTF, level);
1399 fprintf (stderr, "\n");
1400 print_binding_level (level);
1405 print_binding_stack ()
1407 struct binding_level *b;
1408 fprintf (stderr, "current_binding_level=");
1409 fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
1410 fprintf (stderr, "\nclass_binding_level=");
1411 fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
1412 fprintf (stderr, "\nglobal_binding_level=");
1413 fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
1414 fprintf (stderr, "\n");
1415 if (class_binding_level)
1417 for (b = class_binding_level; b; b = b->level_chain)
1418 if (b == current_binding_level)
1421 b = class_binding_level;
1423 b = current_binding_level;
1426 b = current_binding_level;
1427 print_other_binding_stack (b);
1428 fprintf (stderr, "global:\n");
1429 print_binding_level (global_binding_level);
1432 /* Subroutines for reverting temporarily to top-level for instantiation
1433 of templates and such. We actually need to clear out the class- and
1434 local-value slots of all identifiers, so that only the global values
1435 are at all visible. Simply setting current_binding_level to the global
1436 scope isn't enough, because more binding levels may be pushed. */
1437 struct saved_scope {
1438 struct binding_level *old_binding_level;
1440 struct saved_scope *prev;
1441 tree class_name, class_type, class_decl, function_decl;
1442 tree base_init_list, member_init_list;
1443 struct binding_level *class_bindings;
1444 tree previous_class_type;
1445 tree *lang_base, *lang_stack, lang_name;
1449 static struct saved_scope *current_saved_scope;
1450 extern tree prev_class_type;
1453 push_to_top_level ()
1455 extern int current_lang_stacksize;
1456 struct saved_scope *s =
1457 (struct saved_scope *) xmalloc (sizeof (struct saved_scope));
1458 struct binding_level *b = current_binding_level;
1459 tree old_bindings = NULL_TREE;
1461 /* Have to include global_binding_level, because class-level decls
1462 aren't listed anywhere useful. */
1463 for (; b; b = b->level_chain)
1467 if (b == global_binding_level)
1470 for (t = b->names; t; t = TREE_CHAIN (t))
1472 tree binding, t1, t2 = t;
1473 tree id = DECL_ASSEMBLER_NAME (t2);
1476 || (!IDENTIFIER_LOCAL_VALUE (id)
1477 && !IDENTIFIER_CLASS_VALUE (id)))
1480 for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
1481 if (TREE_VEC_ELT (t1, 0) == id)
1484 binding = make_tree_vec (4);
1487 my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
1488 TREE_VEC_ELT (binding, 0) = id;
1489 TREE_VEC_ELT (binding, 1) = IDENTIFIER_TYPE_VALUE (id);
1490 TREE_VEC_ELT (binding, 2) = IDENTIFIER_LOCAL_VALUE (id);
1491 TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
1492 IDENTIFIER_LOCAL_VALUE (id) = NULL_TREE;
1493 IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
1495 TREE_CHAIN (binding) = old_bindings;
1496 old_bindings = binding;
1500 /* Unwind type-value slots back to top level. */
1501 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
1502 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
1504 /* Clear out class-level bindings cache. */
1505 if (current_binding_level == global_binding_level
1506 && previous_class_type != NULL_TREE)
1509 previous_class_type = NULL_TREE;
1512 s->old_binding_level = current_binding_level;
1513 current_binding_level = global_binding_level;
1515 s->class_name = current_class_name;
1516 s->class_type = current_class_type;
1517 s->class_decl = current_class_decl;
1518 s->function_decl = current_function_decl;
1519 s->base_init_list = current_base_init_list;
1520 s->member_init_list = current_member_init_list;
1521 s->class_bindings = class_binding_level;
1522 s->previous_class_type = previous_class_type;
1523 s->lang_stack = current_lang_stack;
1524 s->lang_base = current_lang_base;
1525 s->lang_stacksize = current_lang_stacksize;
1526 s->lang_name = current_lang_name;
1527 s->named_labels = named_labels;
1528 current_class_name = current_class_type = current_class_decl = NULL_TREE;
1529 current_function_decl = NULL_TREE;
1530 class_binding_level = (struct binding_level *)0;
1531 previous_class_type = NULL_TREE;
1532 current_lang_stacksize = 10;
1533 current_lang_stack = current_lang_base
1534 = (tree *) xmalloc (current_lang_stacksize * sizeof (tree));
1535 current_lang_name = lang_name_cplusplus;
1536 strict_prototype = strict_prototypes_lang_cplusplus;
1537 named_labels = NULL_TREE;
1539 s->prev = current_saved_scope;
1540 s->old_bindings = old_bindings;
1541 current_saved_scope = s;
1545 pop_from_top_level ()
1547 extern int current_lang_stacksize;
1548 struct saved_scope *s = current_saved_scope;
1551 if (previous_class_type)
1552 previous_class_type = NULL_TREE;
1554 current_binding_level = s->old_binding_level;
1555 current_saved_scope = s->prev;
1556 for (t = s->old_bindings; t; t = TREE_CHAIN (t))
1558 tree id = TREE_VEC_ELT (t, 0);
1561 IDENTIFIER_TYPE_VALUE (id) = TREE_VEC_ELT (t, 1);
1562 IDENTIFIER_LOCAL_VALUE (id) = TREE_VEC_ELT (t, 2);
1563 IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
1566 current_class_name = s->class_name;
1567 current_class_type = s->class_type;
1568 current_class_decl = s->class_decl;
1569 if (current_class_type)
1570 C_C_D = CLASSTYPE_INST_VAR (current_class_type);
1573 current_base_init_list = s->base_init_list;
1574 current_member_init_list = s->member_init_list;
1575 current_function_decl = s->function_decl;
1576 class_binding_level = s->class_bindings;
1577 previous_class_type = s->previous_class_type;
1578 free (current_lang_base);
1579 current_lang_base = s->lang_base;
1580 current_lang_stack = s->lang_stack;
1581 current_lang_name = s->lang_name;
1582 current_lang_stacksize = s->lang_stacksize;
1583 if (current_lang_name == lang_name_cplusplus)
1584 strict_prototype = strict_prototypes_lang_cplusplus;
1585 else if (current_lang_name == lang_name_c)
1586 strict_prototype = strict_prototypes_lang_c;
1587 named_labels = s->named_labels;
1592 /* Push a definition of struct, union or enum tag "name".
1593 into binding_level "b". "type" should be the type node,
1594 We assume that the tag "name" is not already defined.
1596 Note that the definition may really be just a forward reference.
1597 In that case, the TYPE_SIZE will be a NULL_TREE.
1599 C++ gratuitously puts all these tags in the name space. */
1601 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
1602 record the shadowed value for this binding contour. TYPE is
1603 the type that ID maps to. */
1606 set_identifier_type_value_with_scope (id, type, b)
1609 struct binding_level *b;
1611 if (b != global_binding_level)
1613 tree old_type_value = IDENTIFIER_TYPE_VALUE (id);
1615 = tree_cons (id, old_type_value, b->type_shadowed);
1617 SET_IDENTIFIER_TYPE_VALUE (id, type);
1620 /* As set_identifier_type_value_with_scope, but using inner_binding_level. */
1623 set_identifier_type_value (id, type)
1627 set_identifier_type_value_with_scope (id, type, inner_binding_level);
1630 /* Subroutine "set_nested_typename" builds the nested-typename of
1631 the type decl in question. (Argument CLASSNAME can actually be
1632 a function as well, if that's the smallest containing scope.) */
1635 set_nested_typename (decl, classname, name, type)
1636 tree decl, classname, name, type;
1639 my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 136);
1641 /* No need to do this for anonymous names, since they're unique. */
1642 if (ANON_AGGRNAME_P (name))
1644 DECL_NESTED_TYPENAME (decl) = name;
1648 if (classname == NULL_TREE)
1649 classname = get_identifier ("");
1651 my_friendly_assert (TREE_CODE (classname) == IDENTIFIER_NODE, 137);
1652 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 138);
1653 buf = (char *) alloca (4 + IDENTIFIER_LENGTH (classname)
1654 + IDENTIFIER_LENGTH (name));
1655 sprintf (buf, "%s::%s", IDENTIFIER_POINTER (classname),
1656 IDENTIFIER_POINTER (name));
1657 DECL_NESTED_TYPENAME (decl) = get_identifier (buf);
1658 TREE_MANGLED (DECL_NESTED_TYPENAME (decl)) = 1;
1660 /* Create an extra decl so that the nested name will have a type value
1661 where appropriate. */
1663 tree nested, type_decl;
1664 nested = DECL_NESTED_TYPENAME (decl);
1665 type_decl = build_decl (TYPE_DECL, nested, type);
1666 DECL_NESTED_TYPENAME (type_decl) = nested;
1667 SET_DECL_ARTIFICIAL (type_decl);
1668 /* Mark the TYPE_DECL node created just above as a gratuitous one so that
1669 dwarfout.c will know not to generate a TAG_typedef DIE for it, and
1670 sdbout.c won't try to output a .def for "::foo". */
1671 DECL_IGNORED_P (type_decl) = 1;
1673 /* Remove this when local classes are fixed. */
1674 SET_IDENTIFIER_TYPE_VALUE (nested, type);
1676 pushdecl_nonclass_level (type_decl);
1680 /* Pop off extraneous binding levels left over due to syntax errors. */
1684 #ifdef DEBUG_CP_BINDING_LEVELS
1685 fprintf (stderr, "XXX entering pop_everything ()\n");
1687 while (current_binding_level != global_binding_level
1688 && ! current_binding_level->pseudo_global)
1690 if (class_binding_level)
1691 pop_nested_class (1);
1695 #ifdef DEBUG_CP_BINDING_LEVELS
1696 fprintf (stderr, "XXX leaving pop_everything ()\n");
1700 #if 0 /* not yet, should get fixed properly later */
1701 /* Create a TYPE_DECL node with the correct DECL_ASSEMBLER_NAME.
1702 Other routines shouldn't use build_decl directly; they'll produce
1703 incorrect results with `-g' unless they duplicate this code.
1705 This is currently needed mainly for dbxout.c, but we can make
1706 use of it in method.c later as well. */
1708 make_type_decl (name, type)
1712 decl = build_decl (TYPE_DECL, name, type);
1713 if (TYPE_NAME (type) == name)
1714 /* Class/union/enum definition, or a redundant typedef for same. */
1716 id = get_identifier (build_overload_name (type, 1, 1));
1717 DECL_ASSEMBLER_NAME (decl) = id;
1719 else if (TYPE_NAME (type) != NULL_TREE)
1720 /* Explicit typedef, or implicit typedef for template expansion. */
1721 DECL_ASSEMBLER_NAME (decl) = DECL_ASSEMBLER_NAME (TYPE_NAME (type));
1724 /* XXX: Typedef for unnamed struct; some other situations.
1725 TYPE_NAME is null; what's right here? */
1731 /* Push a tag name NAME for struct/class/union/enum type TYPE.
1732 Normally put into into the inner-most non-tag-tranparent scope,
1733 but if GLOBALIZE is true, put it in the inner-most non-class scope.
1734 The latter is needed for implicit declarations. */
1737 pushtag (name, type, globalize)
1741 register struct binding_level *b;
1745 b = inner_binding_level;
1746 while (b->tag_transparent
1747 || (globalize && b->parm_flag == 2))
1750 if (b == global_binding_level)
1751 b->tags = perm_tree_cons (name, type, b->tags);
1753 b->tags = saveable_tree_cons (name, type, b->tags);
1757 context = type ? TYPE_CONTEXT (type) : NULL_TREE;
1758 if (! context && ! globalize)
1759 context = current_scope ();
1761 c_decl = TREE_CODE (context) == FUNCTION_DECL
1762 ? context : TYPE_MAIN_DECL (context);
1765 /* Record the identifier as the type's name if it has none. */
1766 if (TYPE_NAME (type) == NULL_TREE)
1767 TYPE_NAME (type) = name;
1770 /* Do C++ gratuitous typedefing. */
1771 if (IDENTIFIER_TYPE_VALUE (name) != type)
1776 if (b->parm_flag != 2
1777 || TYPE_SIZE (current_class_type) != NULL_TREE)
1779 d = lookup_nested_type (type, c_decl);
1784 #if 0 /* not yet, should get fixed properly later */
1785 d = make_type_decl (name, type);
1787 d = build_decl (TYPE_DECL, name, type);
1789 SET_DECL_ARTIFICIAL (d);
1790 #ifdef DWARF_DEBUGGING_INFO
1791 if (write_symbols == DWARF_DEBUG)
1793 /* Mark the TYPE_DECL node we created just above as an
1794 gratuitous one. We need to do this so that dwarfout.c
1795 will understand that it is not supposed to output a
1796 TAG_typedef DIE for it. */
1797 DECL_IGNORED_P (d) = 1;
1799 #endif /* DWARF_DEBUGGING_INFO */
1800 set_identifier_type_value_with_scope (name, type, b);
1805 TYPE_NAME (type) = d;
1807 /* If it is anonymous, then we are called from pushdecl,
1808 and we don't want to infinitely recurse. */
1809 if (! ANON_AGGRNAME_P (name))
1811 if (b->parm_flag == 2)
1812 d = pushdecl_class_level (d);
1814 d = pushdecl_with_scope (d, b);
1819 /* Make nested declarations go into class-level scope. */
1821 d = build_decl (TYPE_DECL, name, type);
1822 SET_DECL_ARTIFICIAL (d);
1823 #ifdef DWARF_DEBUGGING_INFO
1824 if (write_symbols == DWARF_DEBUG)
1826 /* Mark the TYPE_DECL node we created just above as an
1827 gratuitous one. We need to do this so that dwarfout.c
1828 will understand that it is not supposed to output a
1829 TAG_typedef DIE for it. */
1830 DECL_IGNORED_P (d) = 1;
1832 #endif /* DWARF_DEBUGGING_INFO */
1834 TYPE_MAIN_DECL (type) = d;
1836 /* Make sure we're in this type's scope when we push the
1837 decl for a template, otherwise class_binding_level will
1838 be NULL and we'll end up dying inside of
1839 push_class_level_binding. */
1840 if (TREE_CODE (type) == UNINSTANTIATED_P_TYPE)
1841 pushclass (type, 0);
1842 d = pushdecl_class_level (d);
1843 if (TREE_CODE (type) == UNINSTANTIATED_P_TYPE)
1848 if (write_symbols != DWARF_DEBUG)
1850 if (ANON_AGGRNAME_P (name))
1851 DECL_IGNORED_P (d) = 1;
1854 if (context == NULL_TREE)
1855 /* Non-nested class. */
1856 set_nested_typename (d, NULL_TREE, name, type);
1857 else if (context && TREE_CODE (context) == FUNCTION_DECL)
1858 /* Function-nested class. */
1859 set_nested_typename (d, DECL_ASSEMBLER_NAME (c_decl),
1861 else /* if (context && IS_AGGR_TYPE (context)) */
1862 /* Class-nested class. */
1863 set_nested_typename (d, DECL_NESTED_TYPENAME (c_decl),
1866 DECL_CONTEXT (d) = context;
1867 TYPE_CONTEXT (type) = DECL_CONTEXT (d);
1868 DECL_ASSEMBLER_NAME (d)
1869 = get_identifier (build_overload_name (type, 1, 1));
1872 if (b->parm_flag == 2)
1874 TREE_NONLOCAL_FLAG (type) = 1;
1875 if (TYPE_SIZE (current_class_type) == NULL_TREE)
1876 CLASSTYPE_TAGS (current_class_type) = b->tags;
1880 if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1881 /* Use the canonical TYPE_DECL for this node. */
1882 TYPE_STUB_DECL (type) = TYPE_NAME (type);
1885 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
1886 will be the tagged type we just added to the current
1887 binding level. This fake NULL-named TYPE_DECL node helps
1888 dwarfout.c to know when it needs to output a
1889 representation of a tagged type, and it also gives us a
1890 convenient place to record the "scope start" address for
1893 #if 0 /* not yet, should get fixed properly later */
1894 tree d = make_type_decl (NULL_TREE, type);
1896 tree d = build_decl (TYPE_DECL, NULL_TREE, type);
1898 TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
1902 /* Counter used to create anonymous type names. */
1903 static int anon_cnt = 0;
1905 /* Return an IDENTIFIER which can be used as a name for
1906 anonymous structs and unions. */
1912 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1913 return get_identifier (buf);
1916 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
1917 This keeps dbxout from getting confused. */
1921 register struct binding_level *b;
1923 static int last_cnt = 0;
1925 /* Fast out if no new anon names were declared. */
1926 if (last_cnt == anon_cnt)
1929 b = current_binding_level;
1930 while (b->tag_transparent)
1935 /* A NULL purpose means we have already processed all tags
1936 from here to the end of the list. */
1937 if (TREE_PURPOSE (tags) == NULL_TREE)
1939 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
1940 TREE_PURPOSE (tags) = NULL_TREE;
1941 tags = TREE_CHAIN (tags);
1943 last_cnt = anon_cnt;
1946 /* Subroutine of duplicate_decls: return truthvalue of whether
1947 or not types of these decls match.
1949 For C++, we must compare the parameter list so that `int' can match
1950 `int&' in a parameter position, but `int&' is not confused with
1953 decls_match (newdecl, olddecl)
1954 tree newdecl, olddecl;
1958 if (TREE_CODE (newdecl) == FUNCTION_DECL
1959 && TREE_CODE (olddecl) == FUNCTION_DECL)
1961 tree f1 = TREE_TYPE (newdecl);
1962 tree f2 = TREE_TYPE (olddecl);
1963 tree p1 = TYPE_ARG_TYPES (f1);
1964 tree p2 = TYPE_ARG_TYPES (f2);
1966 /* When we parse a static member function definition,
1967 we put together a FUNCTION_DECL which thinks its type
1968 is METHOD_TYPE. Change that to FUNCTION_TYPE, and
1970 if (TREE_CODE (f1) == METHOD_TYPE && DECL_STATIC_FUNCTION_P (olddecl))
1971 revert_static_member_fn (&newdecl, &f1, &p1);
1972 else if (TREE_CODE (f2) == METHOD_TYPE
1973 && DECL_STATIC_FUNCTION_P (newdecl))
1974 revert_static_member_fn (&olddecl, &f2, &p2);
1976 /* Here we must take care of the case where new default
1977 parameters are specified. Also, warn if an old
1978 declaration becomes ambiguous because default
1979 parameters may cause the two to be ambiguous. */
1980 if (TREE_CODE (f1) != TREE_CODE (f2))
1982 if (TREE_CODE (f1) == OFFSET_TYPE)
1983 cp_compiler_error ("`%D' redeclared as member function", newdecl);
1985 cp_compiler_error ("`%D' redeclared as non-member function", newdecl);
1989 if (comptypes (TREE_TYPE (f1), TREE_TYPE (f2), 1))
1991 if (! strict_prototypes_lang_c && DECL_LANGUAGE (olddecl) == lang_c
1994 types_match = self_promoting_args_p (p1);
1995 if (p1 == void_list_node)
1996 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1998 else if (!strict_prototypes_lang_c && DECL_LANGUAGE (olddecl)==lang_c
1999 && DECL_LANGUAGE (newdecl) == lang_c && p1 == NULL_TREE)
2001 types_match = self_promoting_args_p (p2);
2002 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2005 types_match = compparms (p1, p2, 3);
2010 else if (TREE_CODE (newdecl) == TEMPLATE_DECL
2011 && TREE_CODE (olddecl) == TEMPLATE_DECL)
2013 tree newargs = DECL_TEMPLATE_PARMS (newdecl);
2014 tree oldargs = DECL_TEMPLATE_PARMS (olddecl);
2015 int i, len = TREE_VEC_LENGTH (newargs);
2017 if (TREE_VEC_LENGTH (oldargs) != len)
2020 for (i = 0; i < len; i++)
2022 tree newarg = TREE_VALUE (TREE_VEC_ELT (newargs, i));
2023 tree oldarg = TREE_VALUE (TREE_VEC_ELT (oldargs, i));
2024 if (TREE_CODE (newarg) != TREE_CODE (oldarg))
2026 else if (TREE_CODE (newarg) == TYPE_DECL)
2028 else if (! comptypes (TREE_TYPE (newarg), TREE_TYPE (oldarg), 1))
2032 if (DECL_TEMPLATE_IS_CLASS (newdecl)
2033 != DECL_TEMPLATE_IS_CLASS (olddecl))
2035 else if (DECL_TEMPLATE_IS_CLASS (newdecl))
2038 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2039 DECL_TEMPLATE_RESULT (newdecl));
2043 if (TREE_TYPE (newdecl) == error_mark_node)
2044 types_match = TREE_TYPE (olddecl) == error_mark_node;
2045 else if (TREE_TYPE (olddecl) == NULL_TREE)
2046 types_match = TREE_TYPE (newdecl) == NULL_TREE;
2047 else if (TREE_TYPE (newdecl) == NULL_TREE)
2050 types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl), 1);
2056 /* If NEWDECL is `static' and an `extern' was seen previously,
2057 warn about it. (OLDDECL may be NULL_TREE; NAME contains
2058 information about previous usage as an `extern'.)
2060 Note that this does not apply to the C++ case of declaring
2061 a variable `extern const' and then later `const'.
2063 Don't complain if -traditional, since traditional compilers
2066 Don't complain about built-in functions, since they are beyond
2067 the user's control. */
2070 warn_extern_redeclared_static (newdecl, olddecl)
2071 tree newdecl, olddecl;
2075 static char *explicit_extern_static_warning
2076 = "`%D' was declared `extern' and later `static'";
2077 static char *implicit_extern_static_warning
2078 = "`%D' was declared implicitly `extern' and later `static'";
2080 if (flag_traditional
2081 || TREE_CODE (newdecl) == TYPE_DECL)
2084 name = DECL_ASSEMBLER_NAME (newdecl);
2085 if (TREE_PUBLIC (name) && DECL_THIS_STATIC (newdecl))
2087 /* It's okay to redeclare an ANSI built-in function as static,
2088 or to declare a non-ANSI built-in function as anything. */
2089 if (! (TREE_CODE (newdecl) == FUNCTION_DECL
2090 && olddecl != NULL_TREE
2091 && TREE_CODE (olddecl) == FUNCTION_DECL
2092 && (DECL_BUILT_IN (olddecl)
2093 || DECL_BUILT_IN_NONANSI (olddecl))))
2095 cp_warning (IDENTIFIER_IMPLICIT_DECL (name)
2096 ? implicit_extern_static_warning
2097 : explicit_extern_static_warning, newdecl);
2098 if (olddecl != NULL_TREE)
2099 cp_warning_at ("previous declaration of `%D'", olddecl);
2104 /* Handle when a new declaration NEWDECL has the same name as an old
2105 one OLDDECL in the same binding contour. Prints an error message
2108 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2109 Otherwise, return 0. */
2112 duplicate_decls (newdecl, olddecl)
2113 register tree newdecl, olddecl;
2115 extern struct obstack permanent_obstack;
2116 unsigned olddecl_uid = DECL_UID (olddecl);
2117 int olddecl_friend = 0, types_match = 0;
2118 int new_defines_function;
2119 tree previous_c_decl = NULL_TREE;
2121 if (TREE_CODE_CLASS (TREE_CODE (olddecl)) == 'd')
2122 DECL_MACHINE_ATTRIBUTES (newdecl) = DECL_MACHINE_ATTRIBUTES (olddecl);
2124 types_match = decls_match (newdecl, olddecl);
2126 if (TREE_CODE (olddecl) != TREE_LIST)
2127 olddecl_friend = DECL_LANG_SPECIFIC (olddecl) && DECL_FRIEND_P (olddecl);
2129 /* If either the type of the new decl or the type of the old decl is an
2130 error_mark_node, then that implies that we have already issued an
2131 error (earlier) for some bogus type specification, and in that case,
2132 it is rather pointless to harass the user with yet more error message
2133 about the same declaration, so well just pretent the types match here. */
2134 if ((TREE_TYPE (newdecl)
2135 && TREE_CODE (TREE_TYPE (newdecl)) == ERROR_MARK)
2136 || (TREE_TYPE (olddecl)
2137 && TREE_CODE (TREE_TYPE (olddecl)) == ERROR_MARK))
2140 if (flag_traditional && TREE_CODE (newdecl) == FUNCTION_DECL
2141 && IDENTIFIER_IMPLICIT_DECL (DECL_ASSEMBLER_NAME (newdecl)) == olddecl)
2142 /* If -traditional, avoid error for redeclaring fcn
2143 after implicit decl. */
2145 else if (TREE_CODE (olddecl) == FUNCTION_DECL
2146 && DECL_ARTIFICIAL (olddecl)
2147 && (DECL_BUILT_IN (olddecl) || DECL_BUILT_IN_NONANSI (olddecl)))
2149 /* If you declare a built-in or predefined function name as static,
2150 the old definition is overridden, but optionally warn this was a
2151 bad choice of name. Ditto for overloads. */
2152 if (! DECL_PUBLIC (newdecl)
2153 || (TREE_CODE (newdecl) == FUNCTION_DECL
2154 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl)))
2157 cp_warning ("shadowing %s function `%#D'",
2158 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
2160 /* Discard the old built-in function. */
2163 else if (! types_match)
2165 if (TREE_CODE (newdecl) != FUNCTION_DECL)
2167 /* If the built-in is not ansi, then programs can override
2168 it even globally without an error. */
2169 if (! DECL_BUILT_IN (olddecl))
2170 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
2174 cp_error ("declaration of `%#D'", newdecl);
2175 cp_error ("conflicts with built-in declaration `%#D'",
2181 cp_warning ("declaration of `%#D'", newdecl);
2182 cp_warning ("conflicts with built-in declaration `%#D'",
2186 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
2188 if ((TREE_CODE (newdecl) == FUNCTION_DECL
2189 && TREE_CODE (olddecl) == TEMPLATE_DECL
2190 && ! DECL_TEMPLATE_IS_CLASS (olddecl))
2191 || (TREE_CODE (olddecl) == FUNCTION_DECL
2192 && TREE_CODE (newdecl) == TEMPLATE_DECL
2193 && ! DECL_TEMPLATE_IS_CLASS (newdecl)))
2196 cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
2197 if (TREE_CODE (olddecl) == TREE_LIST)
2198 olddecl = TREE_VALUE (olddecl);
2199 cp_error_at ("previous declaration of `%#D'", olddecl);
2201 /* New decl is completely inconsistent with the old one =>
2202 tell caller to replace the old one. */
2206 else if (!types_match)
2208 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2210 /* The name of a class template may not be declared to refer to
2211 any other template, class, function, object, namespace, value,
2212 or type in the same scope. */
2213 if (DECL_TEMPLATE_IS_CLASS (olddecl)
2214 || DECL_TEMPLATE_IS_CLASS (newdecl))
2216 cp_error ("declaration of template `%#D'", newdecl);
2217 cp_error_at ("conflicts with previous declaration `%#D'",
2222 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2224 if (DECL_LANGUAGE (newdecl) == lang_c
2225 && DECL_LANGUAGE (olddecl) == lang_c)
2227 cp_error ("declaration of C function `%#D' conflicts with",
2229 cp_error_at ("previous declaration `%#D' here", olddecl);
2231 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
2232 TYPE_ARG_TYPES (TREE_TYPE (olddecl)), 3))
2234 cp_error ("new declaration `%#D'", newdecl);
2235 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
2241 /* Already complained about this, so don't do so again. */
2242 else if (current_class_type == NULL_TREE
2243 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
2245 cp_error ("conflicting types for `%#D'", newdecl);
2246 cp_error_at ("previous declaration as `%#D'", olddecl);
2251 char *errmsg = redeclaration_error_message (newdecl, olddecl);
2254 cp_error (errmsg, newdecl);
2255 if (DECL_NAME (olddecl) != NULL_TREE)
2256 cp_error_at ((DECL_INITIAL (olddecl)
2257 && current_binding_level == global_binding_level)
2258 ? "`%#D' previously defined here"
2259 : "`%#D' previously declared here", olddecl);
2261 else if (TREE_CODE (olddecl) == FUNCTION_DECL
2262 && DECL_INITIAL (olddecl) != NULL_TREE
2263 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
2264 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
2266 /* Prototype decl follows defn w/o prototype. */
2267 cp_warning_at ("prototype for `%#D'", newdecl);
2268 cp_warning_at ("follows non-prototype definition here", olddecl);
2270 else if (TREE_CODE (olddecl) == FUNCTION_DECL
2271 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
2273 /* extern "C" int foo ();
2274 int foo () { bar (); }
2276 if (current_lang_stack == current_lang_base)
2277 DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
2280 cp_error_at ("previous declaration of `%#D' with %L linkage",
2281 olddecl, DECL_LANGUAGE (olddecl));
2282 cp_error ("conflicts with new declaration with %L linkage",
2283 DECL_LANGUAGE (newdecl));
2287 if (TREE_CODE (olddecl) == FUNCTION_DECL)
2289 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
2290 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
2293 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
2294 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
2296 for (; t1 && t1 != void_list_node;
2297 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
2298 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
2300 if (simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
2304 cp_pedwarn ("default argument given for parameter %d of `%#D'",
2306 cp_pedwarn_at ("after previous specification in `%#D'",
2312 cp_error ("default argument given for parameter %d of `%#D'",
2314 cp_error_at ("conflicts with previous specification in `%#D'",
2319 /* These bits are logically part of the type for non-functions. */
2320 else if (TREE_READONLY (newdecl) != TREE_READONLY (olddecl)
2321 || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl))
2323 cp_pedwarn ("type qualifiers for `%#D'", newdecl);
2324 cp_pedwarn_at ("conflict with previous decl `%#D'", olddecl);
2328 /* If new decl is `static' and an `extern' was seen previously,
2330 warn_extern_redeclared_static (newdecl, olddecl);
2332 /* We have committed to returning 1 at this point. */
2333 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2335 /* Now that functions must hold information normally held
2336 by field decls, there is extra work to do so that
2337 declaration information does not get destroyed during
2339 if (DECL_VINDEX (olddecl))
2340 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
2341 if (DECL_CONTEXT (olddecl))
2342 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
2343 if (DECL_CLASS_CONTEXT (olddecl))
2344 DECL_CLASS_CONTEXT (newdecl) = DECL_CLASS_CONTEXT (olddecl);
2345 if (DECL_CHAIN (newdecl) == NULL_TREE)
2346 DECL_CHAIN (newdecl) = DECL_CHAIN (olddecl);
2347 if (DECL_NEXT_METHOD (newdecl) == NULL_TREE)
2348 DECL_NEXT_METHOD (newdecl) = DECL_NEXT_METHOD (olddecl);
2349 if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
2350 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
2351 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
2352 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
2353 DECL_ABSTRACT_VIRTUAL_P (newdecl) |= DECL_ABSTRACT_VIRTUAL_P (olddecl);
2356 /* Deal with C++: must preserve virtual function table size. */
2357 if (TREE_CODE (olddecl) == TYPE_DECL)
2359 register tree newtype = TREE_TYPE (newdecl);
2360 register tree oldtype = TREE_TYPE (olddecl);
2362 DECL_NESTED_TYPENAME (newdecl) = DECL_NESTED_TYPENAME (olddecl);
2364 if (newtype != error_mark_node && oldtype != error_mark_node
2365 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
2367 CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
2368 CLASSTYPE_FRIEND_CLASSES (newtype)
2369 = CLASSTYPE_FRIEND_CLASSES (oldtype);
2372 /* why assert here? Just because debugging information is
2374 /* it happens on something like:
2375 typedef struct Thing {
2380 my_friendly_assert (DECL_IGNORED_P (olddecl) == DECL_IGNORED_P (newdecl),
2385 /* Special handling ensues if new decl is a function definition. */
2386 new_defines_function = (TREE_CODE (newdecl) == FUNCTION_DECL
2387 && DECL_INITIAL (newdecl) != NULL_TREE);
2389 /* Optionally warn about more than one declaration for the same name,
2390 but don't warn about a function declaration followed by a definition. */
2391 if (warn_redundant_decls
2392 && ! DECL_ARTIFICIAL (olddecl)
2393 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
2394 /* Don't warn about extern decl followed by (tentative) definition. */
2395 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl)))
2397 cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
2398 cp_warning ("previous declaration of `%D'", olddecl);
2401 /* Copy all the DECL_... slots specified in the new decl
2402 except for any that we copy here from the old type. */
2406 /* Automatically handles default parameters. */
2407 tree oldtype = TREE_TYPE (olddecl);
2410 /* Make sure we put the new type in the same obstack as the old one. */
2412 push_obstacks (TYPE_OBSTACK (oldtype), TYPE_OBSTACK (oldtype));
2415 push_obstacks_nochange ();
2416 end_temporary_allocation ();
2419 /* Merge the data types specified in the two decls. */
2420 newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
2422 if (TREE_CODE (newdecl) == VAR_DECL)
2423 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
2424 /* Do this after calling `common_type' so that default
2425 parameters don't confuse us. */
2426 else if (TREE_CODE (newdecl) == FUNCTION_DECL
2427 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
2428 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
2430 tree ctype = NULL_TREE;
2431 ctype = DECL_CLASS_CONTEXT (newdecl);
2432 TREE_TYPE (newdecl) = build_exception_variant (ctype, newtype,
2433 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
2434 TREE_TYPE (olddecl) = build_exception_variant (ctype, newtype,
2435 TYPE_RAISES_EXCEPTIONS (oldtype));
2437 if (! compexcepttypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl), 0))
2439 cp_error ("declaration of `%D' throws different exceptions...",
2441 cp_error_at ("...from previous declaration here", olddecl);
2444 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
2446 /* Lay the type out, unless already done. */
2447 if (oldtype != TREE_TYPE (newdecl)
2448 && TREE_TYPE (newdecl) != error_mark_node)
2449 layout_type (TREE_TYPE (newdecl));
2451 if (TREE_CODE (newdecl) == VAR_DECL
2452 || TREE_CODE (newdecl) == PARM_DECL
2453 || TREE_CODE (newdecl) == RESULT_DECL
2454 || TREE_CODE (newdecl) == FIELD_DECL
2455 || TREE_CODE (newdecl) == TYPE_DECL)
2456 layout_decl (newdecl, 0);
2458 /* Merge the type qualifiers. */
2459 if (TREE_READONLY (newdecl))
2460 TREE_READONLY (olddecl) = 1;
2461 if (TREE_THIS_VOLATILE (newdecl))
2462 TREE_THIS_VOLATILE (olddecl) = 1;
2464 /* Merge the initialization information. */
2465 if (DECL_INITIAL (newdecl) == NULL_TREE
2466 && DECL_INITIAL (olddecl) != NULL_TREE)
2468 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2469 DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
2470 DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
2473 /* Merge the section attribute.
2474 We want to issue an error if the sections conflict but that must be
2475 done later in decl_attributes since we are called before attributes
2477 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
2478 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
2480 /* Keep the old rtl since we can safely use it, unless it's the
2481 call to abort() used for abstract virtuals. */
2482 if ((DECL_LANG_SPECIFIC (olddecl)
2483 && !DECL_ABSTRACT_VIRTUAL_P (olddecl))
2484 || DECL_RTL (olddecl) != DECL_RTL (abort_fndecl))
2485 DECL_RTL (newdecl) = DECL_RTL (olddecl);
2489 /* If cannot merge, then use the new type and qualifiers,
2490 and don't preserve the old rtl. */
2493 /* Clean out any memory we had of the old declaration. */
2494 tree oldstatic = value_member (olddecl, static_aggregates);
2496 TREE_VALUE (oldstatic) = error_mark_node;
2498 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
2499 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
2500 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
2501 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
2504 /* Merge the storage class information. */
2505 if (DECL_EXTERNAL (newdecl))
2507 TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
2508 DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
2509 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
2511 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2513 DECL_C_STATIC (newdecl) = DECL_C_STATIC (olddecl);
2514 DECL_INTERFACE_KNOWN (newdecl) = DECL_INTERFACE_KNOWN (olddecl);
2515 DECL_NOT_REALLY_EXTERN (newdecl) = DECL_NOT_REALLY_EXTERN (olddecl);
2520 TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
2521 /* A `const' which was not declared `extern' gets internal linkage. */
2522 if (TREE_CODE (newdecl) == VAR_DECL
2523 && TREE_READONLY (newdecl) && ! DECL_THIS_EXTERN (newdecl))
2524 TREE_PUBLIC (newdecl) = 0;
2527 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
2529 /* If this clears PUBLIC, clear it in the identifier too. */
2530 if (TREE_CODE (newdecl) == FUNCTION_DECL && ! TREE_PUBLIC (olddecl))
2531 TREE_PUBLIC (DECL_ASSEMBLER_NAME (olddecl)) = 0;
2535 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2537 DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
2539 /* If either decl says `inline', this fn is inline, unless its
2540 definition was passed already. */
2541 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
2542 DECL_INLINE (olddecl) = 1;
2543 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
2547 DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
2548 DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
2549 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
2550 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
2551 DECL_RTL (olddecl) = DECL_RTL (newdecl);
2553 if (new_defines_function)
2554 /* If defining a function declared with other language
2555 linkage, use the previously declared language linkage. */
2556 DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
2559 /* If redeclaring a builtin function, and not a definition,
2560 it stays built in. */
2561 if (DECL_BUILT_IN (olddecl))
2563 DECL_BUILT_IN (newdecl) = 1;
2564 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2565 /* If we're keeping the built-in definition, keep the rtl,
2566 regardless of declaration matches. */
2567 DECL_RTL (newdecl) = DECL_RTL (olddecl);
2570 DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
2572 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2573 if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
2574 /* Previously saved insns go together with
2575 the function's previous definition. */
2576 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2577 /* Don't clear out the arguments if we're redefining a function. */
2578 if (DECL_ARGUMENTS (olddecl))
2579 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2581 if (DECL_LANG_SPECIFIC (olddecl))
2582 DECL_MAIN_VARIANT (newdecl) = DECL_MAIN_VARIANT (olddecl);
2585 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2587 if (DECL_TEMPLATE_INFO (olddecl)->length)
2588 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
2589 DECL_TEMPLATE_MEMBERS (newdecl) = DECL_TEMPLATE_MEMBERS (olddecl);
2590 DECL_TEMPLATE_INSTANTIATIONS (newdecl)
2591 = DECL_TEMPLATE_INSTANTIATIONS (olddecl);
2592 if (DECL_CHAIN (newdecl) == NULL_TREE)
2593 DECL_CHAIN (newdecl) = DECL_CHAIN (olddecl);
2596 /* Now preserve various other info from the definition. */
2597 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
2598 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
2599 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2600 DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
2602 /* Don't really know how much of the language-specific
2603 values we should copy from old to new. */
2604 if (DECL_LANG_SPECIFIC (olddecl))
2606 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
2607 DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
2608 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
2611 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2614 struct lang_decl *ol = DECL_LANG_SPECIFIC (olddecl);
2615 struct lang_decl *nl = DECL_LANG_SPECIFIC (newdecl);
2617 function_size = sizeof (struct tree_decl);
2619 bcopy ((char *) newdecl + sizeof (struct tree_common),
2620 (char *) olddecl + sizeof (struct tree_common),
2621 function_size - sizeof (struct tree_common));
2623 /* Can we safely free the storage used by newdecl? */
2625 #define ROUND(x) ((x + obstack_alignment_mask (&permanent_obstack)) \
2626 & ~ obstack_alignment_mask (&permanent_obstack))
2628 if ((char *)newdecl + ROUND (function_size)
2629 + ROUND (sizeof (struct lang_decl))
2630 == obstack_next_free (&permanent_obstack))
2632 DECL_MAIN_VARIANT (newdecl) = olddecl;
2633 DECL_LANG_SPECIFIC (olddecl) = ol;
2634 bcopy ((char *)nl, (char *)ol, sizeof (struct lang_decl));
2636 obstack_free (&permanent_obstack, newdecl);
2638 else if (LANG_DECL_PERMANENT (ol))
2640 if (DECL_MAIN_VARIANT (olddecl) == olddecl)
2642 /* Save these lang_decls that would otherwise be lost. */
2643 extern tree free_lang_decl_chain;
2644 tree free_lang_decl = (tree) ol;
2645 TREE_CHAIN (free_lang_decl) = free_lang_decl_chain;
2646 free_lang_decl_chain = free_lang_decl;
2656 bcopy ((char *) newdecl + sizeof (struct tree_common),
2657 (char *) olddecl + sizeof (struct tree_common),
2658 sizeof (struct tree_decl) - sizeof (struct tree_common)
2659 + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
2662 DECL_UID (olddecl) = olddecl_uid;
2664 DECL_FRIEND_P (olddecl) = 1;
2669 /* Record a decl-node X as belonging to the current lexical scope.
2670 Check for errors (such as an incompatible declaration for the same
2671 name already seen in the same scope).
2673 Returns either X or an old decl for the same name.
2674 If an old decl is returned, it may have been smashed
2675 to agree with what X says. */
2682 #if 0 /* not yet, should get fixed properly later */
2685 register tree name = DECL_ASSEMBLER_NAME (x);
2687 register struct binding_level *b = current_binding_level;
2690 static int nglobals; int len;
2692 len = list_length (global_binding_level->names);
2694 my_friendly_abort (8);
2695 else if (len > nglobals)
2699 if (x != current_function_decl
2700 /* Don't change DECL_CONTEXT of virtual methods. */
2701 && (TREE_CODE (x) != FUNCTION_DECL || !DECL_VIRTUAL_P (x))
2702 && ! DECL_CONTEXT (x))
2703 DECL_CONTEXT (x) = current_function_decl;
2704 /* A local declaration for a function doesn't constitute nesting. */
2705 if (TREE_CODE (x) == FUNCTION_DECL && DECL_INITIAL (x) == 0)
2706 DECL_CONTEXT (x) = 0;
2708 #if 0 /* not yet, should get fixed properly later */
2709 /* For functions and class static data, we currently look up the encoded
2710 form of the name. For types, we want the real name. The former will
2711 probably be changed soon, according to MDT. */
2712 if (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
2713 name = DECL_ASSEMBLER_NAME (x);
2715 name = DECL_NAME (x);
2717 /* Type are looked up using the DECL_NAME, as that is what the rest of the
2718 compiler wants to use. */
2719 if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL)
2720 name = DECL_NAME (x);
2728 t = lookup_name_current_level (name);
2729 if (t == error_mark_node)
2731 /* error_mark_node is 0 for a while during initialization! */
2733 cp_error_at ("`%#D' used prior to declaration", x);
2736 else if (t != NULL_TREE)
2738 if (TREE_CODE (t) == PARM_DECL)
2740 if (DECL_CONTEXT (t) == NULL_TREE)
2741 fatal ("parse errors have confused me too much");
2743 file = DECL_SOURCE_FILE (t);
2744 line = DECL_SOURCE_LINE (t);
2746 if (((TREE_CODE (x) == FUNCTION_DECL && DECL_LANGUAGE (x) == lang_c)
2747 || (TREE_CODE (x) == TEMPLATE_DECL
2748 && ! DECL_TEMPLATE_IS_CLASS (x)))
2749 && is_overloaded_fn (t))
2750 /* don't do anything just yet */;
2751 else if (t == wchar_decl_node)
2753 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
2754 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
2756 /* Throw away the redeclaration. */
2759 else if (TREE_CODE (t) != TREE_CODE (x))
2761 if ((TREE_CODE (t) == TYPE_DECL && DECL_ARTIFICIAL (t))
2762 || (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2764 /* We do nothing special here, because C++ does such nasty
2765 things with TYPE_DECLs. Instead, just let the TYPE_DECL
2766 get shadowed, and know that if we need to find a TYPE_DECL
2767 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
2768 slot of the identifier. */
2771 else if (duplicate_decls (x, t))
2774 else if (duplicate_decls (x, t))
2777 /* This is turned off until I have time to do it right (bpk). */
2779 /* Also warn if they did a prototype with `static' on it, but
2780 then later left the `static' off. */
2781 if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
2783 if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
2788 cp_warning ("`static' missing from declaration of `%D'",
2790 warning_with_file_and_line (file, line,
2791 "previous declaration of `%s'",
2792 decl_as_string (t, 0));
2795 /* Now fix things so it'll do what they expect. */
2796 if (current_function_decl)
2797 TREE_PUBLIC (current_function_decl) = 0;
2799 /* Due to interference in memory reclamation (X may be
2800 obstack-deallocated at this point), we must guard against
2801 one really special case. [jason: This should be handled
2802 by start_function] */
2803 if (current_function_decl == x)
2804 current_function_decl = t;
2806 if (TREE_CODE (t) == TYPE_DECL)
2807 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
2813 if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_FUNCTION_MEMBER_P (x))
2815 t = push_overloaded_decl (x, 1);
2816 if (t != x || DECL_LANGUAGE (x) == lang_c)
2819 else if (TREE_CODE (x) == TEMPLATE_DECL && ! DECL_TEMPLATE_IS_CLASS (x))
2820 return push_overloaded_decl (x, 0);
2822 /* If declaring a type as a typedef, and the type has no known
2823 typedef name, install this TYPE_DECL as its typedef name. */
2824 if (TREE_CODE (x) == TYPE_DECL)
2826 tree type = TREE_TYPE (x);
2827 tree name = (type != error_mark_node) ? TYPE_NAME (type) : x;
2829 if (name == NULL_TREE || TREE_CODE (name) != TYPE_DECL)
2831 /* If these are different names, and we're at the global
2832 binding level, make two equivalent definitions. */
2834 if (global_bindings_p ())
2835 TYPE_NAME (type) = x;
2839 tree tname = DECL_NAME (name);
2841 /* This is a disgusting kludge for dealing with UPTs. */
2842 if (global_bindings_p () && ANON_AGGRNAME_P (tname))
2844 /* do gratuitous C++ typedefing, and make sure that
2845 we access this type either through TREE_TYPE field
2846 or via the tags list. */
2847 TYPE_NAME (TREE_TYPE (x)) = x;
2848 pushtag (tname, TREE_TYPE (x), 0);
2851 my_friendly_assert (TREE_CODE (name) == TYPE_DECL, 140);
2853 /* Don't set nested_typename on template type parms, for instance.
2854 Any artificial decls that need DECL_NESTED_TYPENAME will have it
2856 if (! DECL_NESTED_TYPENAME (x) && ! DECL_ARTIFICIAL (x))
2857 set_nested_typename (x, current_class_name, DECL_NAME (x), type);
2859 if (type != error_mark_node
2861 && TYPE_IDENTIFIER (type))
2862 set_identifier_type_value_with_scope (DECL_NAME (x), type, b);
2865 /* Multiple external decls of the same identifier ought to match.
2867 We get warnings about inline functions where they are defined.
2868 We get warnings about other functions from push_overloaded_decl.
2870 Avoid duplicate warnings where they are used. */
2871 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
2875 if (IDENTIFIER_GLOBAL_VALUE (name) != NULL_TREE
2876 && (DECL_EXTERNAL (IDENTIFIER_GLOBAL_VALUE (name))
2877 || TREE_PUBLIC (IDENTIFIER_GLOBAL_VALUE (name))))
2878 decl = IDENTIFIER_GLOBAL_VALUE (name);
2883 /* If different sort of thing, we already gave an error. */
2884 && TREE_CODE (decl) == TREE_CODE (x)
2885 && ! comptypes (TREE_TYPE (x), TREE_TYPE (decl), 1))
2887 cp_pedwarn ("type mismatch with previous external decl", x);
2888 cp_pedwarn_at ("previous external decl of `%#D'", decl);
2892 /* In PCC-compatibility mode, extern decls of vars with no current decl
2893 take effect at top level no matter where they are. */
2894 if (flag_traditional && DECL_EXTERNAL (x)
2895 && lookup_name (name, 0) == NULL_TREE)
2896 b = global_binding_level;
2898 /* This name is new in its binding level.
2899 Install the new declaration and return it. */
2900 if (b == global_binding_level)
2902 /* Install a global value. */
2904 /* Rule for VAR_DECLs, but not for other kinds of _DECLs:
2905 A `const' which was not declared `extern' is invisible. */
2906 if (TREE_CODE (x) == VAR_DECL
2907 && TREE_READONLY (x) && ! DECL_THIS_EXTERN (x))
2908 TREE_PUBLIC (x) = 0;
2910 /* If the first global decl has external linkage,
2911 warn if we later see static one. */
2912 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && DECL_PUBLIC (x))
2913 TREE_PUBLIC (name) = 1;
2915 /* Don't install an artificial TYPE_DECL if we already have
2916 another _DECL with that name. */
2917 if (TREE_CODE (x) != TYPE_DECL
2919 || ! DECL_ARTIFICIAL (x))
2920 IDENTIFIER_GLOBAL_VALUE (name) = x;
2922 /* Don't forget if the function was used via an implicit decl. */
2923 if (IDENTIFIER_IMPLICIT_DECL (name)
2924 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
2927 /* Don't forget if its address was taken in that way. */
2928 if (IDENTIFIER_IMPLICIT_DECL (name)
2929 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
2930 TREE_ADDRESSABLE (x) = 1;
2932 /* Warn about mismatches against previous implicit decl. */
2933 if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
2934 /* If this real decl matches the implicit, don't complain. */
2935 && ! (TREE_CODE (x) == FUNCTION_DECL
2936 && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
2938 ("`%D' was previously implicitly declared to return `int'", x);
2940 /* If new decl is `static' and an `extern' was seen previously,
2942 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
2943 warn_extern_redeclared_static (x, t);
2947 /* Here to install a non-global value. */
2948 tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
2949 tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
2951 /* Don't install an artificial TYPE_DECL if we already have
2952 another _DECL with that name. */
2953 if (TREE_CODE (x) != TYPE_DECL
2955 || ! DECL_ARTIFICIAL (x))
2957 b->shadowed = tree_cons (name, oldlocal, b->shadowed);
2958 IDENTIFIER_LOCAL_VALUE (name) = x;
2961 /* If this is a TYPE_DECL, push it into the type value slot. */
2962 if (TREE_CODE (x) == TYPE_DECL)
2963 set_identifier_type_value_with_scope (name, TREE_TYPE (x), b);
2965 /* If this is an extern function declaration, see if we
2966 have a global definition or declaration for the function. */
2967 if (oldlocal == NULL_TREE
2968 && DECL_EXTERNAL (x)
2969 && oldglobal != NULL_TREE
2970 && TREE_CODE (x) == FUNCTION_DECL
2971 && TREE_CODE (oldglobal) == FUNCTION_DECL)
2973 /* We have one. Their types must agree. */
2974 if (duplicate_decls (x, oldglobal))
2978 cp_warning ("extern declaration of `%#D' doesn't match", x);
2979 cp_warning_at ("global declaration `%#D'", oldglobal);
2982 /* If we have a local external declaration,
2983 and no file-scope declaration has yet been seen,
2984 then if we later have a file-scope decl it must not be static. */
2985 if (oldlocal == NULL_TREE
2986 && oldglobal == NULL_TREE
2987 && DECL_EXTERNAL (x)
2990 TREE_PUBLIC (name) = 1;
2993 if (DECL_FROM_INLINE (x))
2994 /* Inline decls shadow nothing. */;
2996 /* Warn if shadowing an argument at the top level of the body. */
2997 else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
2998 && TREE_CODE (oldlocal) == PARM_DECL
2999 && TREE_CODE (x) != PARM_DECL)
3001 /* Go to where the parms should be and see if we
3003 struct binding_level *b = current_binding_level->level_chain;
3009 if (b->parm_flag == 1)
3010 cp_error ("declaration of `%#D' shadows a parameter", name);
3012 /* Maybe warn if shadowing something else. */
3013 else if (warn_shadow && !DECL_EXTERNAL (x)
3014 /* No shadow warnings for internally generated vars. */
3015 && ! DECL_ARTIFICIAL (x)
3016 /* No shadow warnings for vars made for inlining. */
3017 && ! DECL_FROM_INLINE (x))
3019 char *warnstring = NULL;
3021 if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
3022 warnstring = "declaration of `%s' shadows a parameter";
3023 else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
3024 && !TREE_STATIC (name))
3025 warnstring = "declaration of `%s' shadows a member of `this'";
3026 else if (oldlocal != NULL_TREE)
3027 warnstring = "declaration of `%s' shadows previous local";
3028 else if (oldglobal != NULL_TREE)
3029 warnstring = "declaration of `%s' shadows global declaration";
3032 warning (warnstring, IDENTIFIER_POINTER (name));
3036 if (TREE_CODE (x) == FUNCTION_DECL)
3038 /* This is probably the wrong place to check this, but it has to
3039 come after the call to duplicate_decls. */
3040 tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
3041 int saw_def = 0, i = 1;
3042 for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
3044 if (TREE_PURPOSE (arg))
3048 cp_error ("default argument missing for parameter %d of `%#D'",
3055 /* Keep count of variables in this level with incomplete type. */
3056 if (TREE_CODE (x) != TEMPLATE_DECL
3057 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
3058 && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
3060 if (++b->n_incomplete == 0)
3061 error ("too many incomplete variables at this point");
3064 /* Keep count of variables in this level with incomplete type. */
3065 /* RTTI TD entries are created while defining the type_info. */
3066 if (TREE_CODE (x) == VAR_DECL
3067 && TREE_TYPE (x) != error_mark_node
3068 && TYPE_LANG_SPECIFIC (TREE_TYPE (x))
3069 && TYPE_BEING_DEFINED (TREE_TYPE (x)))
3071 if (++b->n_incomplete == 0)
3072 error ("too many incomplete variables at this point");
3076 /* Put decls on list in reverse order.
3077 We will reverse them later if necessary. */
3078 TREE_CHAIN (x) = b->names;
3080 if (! (b != global_binding_level || TREE_PERMANENT (x)))
3081 my_friendly_abort (124);
3086 /* Same as pushdecl, but define X in binding-level LEVEL. */
3089 pushdecl_with_scope (x, level)
3091 struct binding_level *level;
3093 register struct binding_level *b = current_binding_level;
3095 current_binding_level = level;
3097 current_binding_level = b;
3101 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
3104 pushdecl_top_level (x)
3107 register struct binding_level *b = inner_binding_level;
3108 register tree t = pushdecl_with_scope (x, global_binding_level);
3110 /* Now, the type_shadowed stack may screw us. Munge it so it does
3112 if (TREE_CODE (x) == TYPE_DECL)
3114 tree name = DECL_NAME (x);
3116 tree *ptr = (tree *)0;
3117 for (; b != global_binding_level; b = b->level_chain)
3119 tree shadowed = b->type_shadowed;
3120 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3121 if (TREE_PURPOSE (shadowed) == name)
3123 ptr = &TREE_VALUE (shadowed);
3124 /* Can't break out of the loop here because sometimes
3125 a binding level will have duplicate bindings for
3126 PT names. It's gross, but I haven't time to fix it. */
3129 newval = TREE_TYPE (x);
3130 if (ptr == (tree *)0)
3132 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3133 up here if this is changed to an assertion. --KR */
3134 SET_IDENTIFIER_TYPE_VALUE (name, newval);
3139 /* Disabled this 11/10/92, since there are many cases which
3140 behave just fine when *ptr doesn't satisfy either of these.
3141 For example, nested classes declared as friends of their enclosing
3142 class will not meet this criteria. (bpk) */
3143 my_friendly_assert (*ptr == NULL_TREE || *ptr == newval, 141);
3151 /* Like push_overloaded_decl, only it places X in GLOBAL_BINDING_LEVEL,
3154 push_overloaded_decl_top_level (x, forget)
3158 struct binding_level *b = current_binding_level;
3160 current_binding_level = global_binding_level;
3161 push_overloaded_decl (x, forget);
3162 current_binding_level = b;
3165 /* Make the declaration of X appear in CLASS scope. */
3167 pushdecl_class_level (x)
3170 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
3171 scope looks for the pre-mangled name. */
3172 register tree name = DECL_NAME (x);
3176 if (TYPE_BEING_DEFINED (current_class_type))
3178 /* Check for inconsistent use of this name in the class body.
3179 Types, enums, and static vars are checked here; other
3180 members are checked in finish_struct. */
3181 tree icv = IDENTIFIER_CLASS_VALUE (name);
3184 /* Don't complain about inherited names. */
3185 && id_in_current_class (name)
3186 /* Or shadowed tags. */
3187 && !(TREE_CODE (icv) == TYPE_DECL
3188 && DECL_CONTEXT (icv) == current_class_type))
3190 cp_error ("declaration of identifier `%D' as `%#D'", name, x);
3191 cp_error_at ("conflicts with previous use in class as `%#D'",
3196 push_class_level_binding (name, x);
3197 if (TREE_CODE (x) == TYPE_DECL)
3199 set_identifier_type_value (name, TREE_TYPE (x));
3201 /* Don't set nested_typename on template type parms, for instance.
3202 Any artificial decls that need DECL_NESTED_TYPENAME will have it
3204 if (! DECL_NESTED_TYPENAME (x) && ! DECL_ARTIFICIAL (x))
3205 set_nested_typename (x, current_class_name, name, TREE_TYPE (x));
3211 /* This function is used to push the mangled decls for nested types into
3212 the appropriate scope. Previously pushdecl_top_level was used, but that
3213 is incorrect for members of local classes. */
3215 pushdecl_nonclass_level (x)
3218 struct binding_level *b = current_binding_level;
3221 /* Get out of class scope -- this isn't necessary, because class scope
3222 doesn't make it into current_binding_level. */
3223 while (b->parm_flag == 2)
3226 my_friendly_assert (b->parm_flag != 2, 180);
3229 /* Get out of template binding levels */
3230 while (b->pseudo_global)
3233 pushdecl_with_scope (x, b);
3236 /* Make the declaration(s) of X appear in CLASS scope
3237 under the name NAME. */
3239 push_class_level_binding (name, x)
3243 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3244 && purpose_member (name, class_binding_level->class_shadowed))
3247 maybe_push_cache_obstack ();
3248 class_binding_level->class_shadowed
3249 = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
3250 class_binding_level->class_shadowed);
3252 IDENTIFIER_CLASS_VALUE (name) = x;
3253 obstack_ptr_grow (&decl_obstack, x);
3256 /* Tell caller how to interpret a TREE_LIST which contains
3257 chains of FUNCTION_DECLS. */
3259 overloaded_globals_p (list)
3262 my_friendly_assert (TREE_CODE (list) == TREE_LIST, 142);
3264 /* Don't commit caller to seeing them as globals. */
3265 if (TREE_NONLOCAL_FLAG (list))
3267 /* Do commit caller to seeing them as globals. */
3268 if (TREE_CODE (TREE_PURPOSE (list)) == IDENTIFIER_NODE)
3270 /* Do commit caller to not seeing them as globals. */
3274 /* DECL is a FUNCTION_DECL which may have other definitions already in
3275 place. We get around this by making the value of the identifier point
3276 to a list of all the things that want to be referenced by that name. It
3277 is then up to the users of that name to decide what to do with that
3280 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
3281 slot. It is dealt with the same way.
3283 The value returned may be a previous declaration if we guessed wrong
3284 about what language DECL should belong to (C or C++). Otherwise,
3285 it's always DECL (and never something that's not a _DECL). */
3287 push_overloaded_decl (decl, forgettable)
3291 tree orig_name = DECL_NAME (decl);
3293 int doing_global = (global_bindings_p () || ! forgettable
3294 || flag_traditional || pseudo_global_level_p ());
3298 old = IDENTIFIER_GLOBAL_VALUE (orig_name);
3299 if (old && TREE_CODE (old) == FUNCTION_DECL
3300 && DECL_ARTIFICIAL (old)
3301 && (DECL_BUILT_IN (old) || DECL_BUILT_IN_NONANSI (old)))
3303 if (duplicate_decls (decl, old))
3310 old = IDENTIFIER_LOCAL_VALUE (orig_name);
3312 if (! purpose_member (orig_name, current_binding_level->shadowed))
3314 current_binding_level->shadowed
3315 = tree_cons (orig_name, old, current_binding_level->shadowed);
3323 /* We cache the value of builtin functions as ADDR_EXPRs
3324 in the name space. Convert it to some kind of _DECL after
3325 remembering what to forget. */
3326 if (TREE_CODE (old) == ADDR_EXPR)
3327 old = TREE_OPERAND (old, 0);
3330 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
3332 tree t = TREE_TYPE (old);
3333 if (IS_AGGR_TYPE (t) && warn_shadow)
3334 cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
3337 else if (is_overloaded_fn (old))
3341 for (tmp = get_first_fn (old); tmp; tmp = DECL_CHAIN (tmp))
3342 if (decl == tmp || duplicate_decls (decl, tmp))
3347 cp_error_at ("previous non-function declaration `%#D'", old);
3348 cp_error ("conflicts with function declaration `%#D'", decl);
3349 return error_mark_node;
3353 if (old || TREE_CODE (decl) == TEMPLATE_DECL)
3355 if (old && is_overloaded_fn (old))
3356 DECL_CHAIN (decl) = get_first_fn (old);
3358 DECL_CHAIN (decl) = NULL_TREE;
3359 old = tree_cons (orig_name, decl, NULL_TREE);
3360 TREE_TYPE (old) = unknown_type_node;
3363 /* orig_name is not ambiguous. */
3367 IDENTIFIER_GLOBAL_VALUE (orig_name) = old;
3369 IDENTIFIER_LOCAL_VALUE (orig_name) = old;
3374 /* Generate an implicit declaration for identifier FUNCTIONID
3375 as a function of type int (). Print a warning if appropriate. */
3378 implicitly_declare (functionid)
3382 int temp = allocation_temporary_p ();
3384 push_obstacks_nochange ();
3386 /* Save the decl permanently so we can warn if definition follows.
3387 In ANSI C, warn_implicit is usually false, so the saves little space.
3388 But in C++, it's usually true, hence the extra code. */
3389 if (temp && (flag_traditional || !warn_implicit
3390 || current_binding_level == global_binding_level))
3391 end_temporary_allocation ();
3393 /* We used to reuse an old implicit decl here,
3394 but this loses with inline functions because it can clobber
3395 the saved decl chains. */
3396 decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
3398 DECL_EXTERNAL (decl) = 1;
3399 TREE_PUBLIC (decl) = 1;
3401 /* ANSI standard says implicit declarations are in the innermost block.
3402 So we record the decl in the standard fashion.
3403 If flag_traditional is set, pushdecl does it top-level. */
3405 rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
3408 /* Only one warning per identifier. */
3409 && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
3411 cp_pedwarn ("implicit declaration of function `%#D'", decl);
3414 SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
3421 /* Return zero if the declaration NEWDECL is valid
3422 when the declaration OLDDECL (assumed to be for the same name)
3423 has already been seen.
3424 Otherwise return an error message format string with a %s
3425 where the identifier should go. */
3428 redeclaration_error_message (newdecl, olddecl)
3429 tree newdecl, olddecl;
3431 if (TREE_CODE (newdecl) == TYPE_DECL)
3433 /* Because C++ can put things into name space for free,
3434 constructs like "typedef struct foo { ... } foo"
3435 would look like an erroneous redeclaration. */
3436 if (comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl), 0))
3439 return "redefinition of `%#D'";
3441 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
3443 /* If this is a pure function, its olddecl will actually be
3444 the original initialization to `0' (which we force to call
3445 abort()). Don't complain about redefinition in this case. */
3446 if (DECL_LANG_SPECIFIC (olddecl) && DECL_ABSTRACT_VIRTUAL_P (olddecl))
3449 /* We'll complain about linkage mismatches in
3450 warn_extern_redeclared_static. */
3452 /* defining the same name twice is no good. */
3453 if (DECL_INITIAL (olddecl) != NULL_TREE
3454 && DECL_INITIAL (newdecl) != NULL_TREE)
3456 if (DECL_NAME (olddecl) == NULL_TREE)
3457 return "`%#D' not declared in class";
3459 return "redefinition of `%#D'";
3463 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3465 if (DECL_INITIAL (olddecl) && DECL_INITIAL (newdecl))
3466 return "redefinition of `%#D'";
3469 else if (current_binding_level == global_binding_level)
3471 /* Objects declared at top level: */
3472 /* Insist that the linkage match. */
3473 if (! TREE_PUBLIC (newdecl) && TREE_PUBLIC (olddecl))
3474 return "conflicting declarations of `%#D'";
3475 /* If at least one is a reference, it's ok. */
3476 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
3478 /* Reject two definitions. */
3479 return "redefinition of `%#D'";
3483 /* Objects declared with block scope: */
3484 /* Reject two definitions, and reject a definition
3485 together with an external reference. */
3486 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
3487 return "redeclaration of `%#D'";
3492 /* Get the LABEL_DECL corresponding to identifier ID as a label.
3493 Create one if none exists so far for the current function.
3494 This function is called for both label definitions and label references. */
3500 register tree decl = IDENTIFIER_LABEL_VALUE (id);
3502 if (current_function_decl == NULL_TREE)
3504 error ("label `%s' referenced outside of any function",
3505 IDENTIFIER_POINTER (id));
3509 if ((decl == NULL_TREE
3510 || DECL_SOURCE_LINE (decl) == 0)
3511 && (named_label_uses == NULL_TREE
3512 || TREE_PURPOSE (named_label_uses) != current_binding_level->names
3513 || TREE_VALUE (named_label_uses) != decl))
3516 = tree_cons (current_binding_level->names, decl, named_label_uses);
3517 TREE_TYPE (named_label_uses) = (tree)current_binding_level;
3520 /* Use a label already defined or ref'd with this name. */
3521 if (decl != NULL_TREE)
3523 /* But not if it is inherited and wasn't declared to be inheritable. */
3524 if (DECL_CONTEXT (decl) != current_function_decl
3525 && ! C_DECLARED_LABEL_FLAG (decl))
3526 return shadow_label (id);
3530 decl = build_decl (LABEL_DECL, id, void_type_node);
3532 /* A label not explicitly declared must be local to where it's ref'd. */
3533 DECL_CONTEXT (decl) = current_function_decl;
3535 DECL_MODE (decl) = VOIDmode;
3537 /* Say where one reference is to the label,
3538 for the sake of the error if it is not defined. */
3539 DECL_SOURCE_LINE (decl) = lineno;
3540 DECL_SOURCE_FILE (decl) = input_filename;
3542 SET_IDENTIFIER_LABEL_VALUE (id, decl);
3544 named_labels = tree_cons (NULL_TREE, decl, named_labels);
3545 TREE_VALUE (named_label_uses) = decl;
3550 /* Make a label named NAME in the current function,
3551 shadowing silently any that may be inherited from containing functions
3552 or containing scopes.
3554 Note that valid use, if the label being shadowed
3555 comes from another scope in the same function,
3556 requires calling declare_nonlocal_label right away. */
3562 register tree decl = IDENTIFIER_LABEL_VALUE (name);
3564 if (decl != NULL_TREE)
3566 shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
3567 SET_IDENTIFIER_LABEL_VALUE (name, NULL_TREE);
3568 SET_IDENTIFIER_LABEL_VALUE (decl, NULL_TREE);
3571 return lookup_label (name);
3574 /* Define a label, specifying the location in the source file.
3575 Return the LABEL_DECL node for the label, if the definition is valid.
3576 Otherwise return 0. */
3579 define_label (filename, line, name)
3584 tree decl = lookup_label (name);
3586 /* After labels, make any new cleanups go into their
3587 own new (temporary) binding contour. */
3588 current_binding_level->more_cleanups_ok = 0;
3590 /* If label with this name is known from an outer context, shadow it. */
3591 if (decl != NULL_TREE && DECL_CONTEXT (decl) != current_function_decl)
3593 shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
3594 SET_IDENTIFIER_LABEL_VALUE (name, NULL_TREE);
3595 decl = lookup_label (name);
3598 if (name == get_identifier ("wchar_t"))
3599 cp_pedwarn ("label named wchar_t");
3601 if (DECL_INITIAL (decl) != NULL_TREE)
3603 cp_error ("duplicate label `%D'", decl);
3611 /* Mark label as having been defined. */
3612 DECL_INITIAL (decl) = error_mark_node;
3613 /* Say where in the source. */
3614 DECL_SOURCE_FILE (decl) = filename;
3615 DECL_SOURCE_LINE (decl) = line;
3617 for (prev = NULL_TREE, uses = named_label_uses;
3619 prev = uses, uses = TREE_CHAIN (uses))
3620 if (TREE_VALUE (uses) == decl)
3622 struct binding_level *b = current_binding_level;
3625 tree new_decls = b->names;
3626 tree old_decls = ((tree)b == TREE_TYPE (uses)
3627 ? TREE_PURPOSE (uses) : NULL_TREE);
3628 while (new_decls != old_decls)
3630 if (TREE_CODE (new_decls) == VAR_DECL
3631 /* Don't complain about crossing initialization
3632 of internal entities. They can't be accessed,
3633 and they should be cleaned up
3634 by the time we get to the label. */
3635 && ! DECL_ARTIFICIAL (new_decls)
3636 && ((DECL_INITIAL (new_decls) != NULL_TREE
3637 && DECL_INITIAL (new_decls) != error_mark_node)
3638 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
3641 cp_error ("jump to label `%D'", decl);
3643 cp_error_at (" crosses initialization of `%#D'",
3646 new_decls = TREE_CHAIN (new_decls);
3648 if ((tree)b == TREE_TYPE (uses))
3654 TREE_CHAIN (prev) = TREE_CHAIN (uses);
3656 named_label_uses = TREE_CHAIN (uses);
3658 current_function_return_value = NULL_TREE;
3663 /* Same, but for CASE labels. If DECL is NULL_TREE, it's the default. */
3664 /* XXX Note decl is never actually used. (bpk) */
3666 define_case_label (decl)
3669 tree cleanup = last_cleanup_this_contour ();
3672 static int explained = 0;
3673 cp_error_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
3674 error ("where case label appears here");
3677 error ("(enclose actions of previous case statements requiring");
3678 error ("destructors in their own binding contours.)");
3683 /* After labels, make any new cleanups go into their
3684 own new (temporary) binding contour. */
3686 current_binding_level->more_cleanups_ok = 0;
3687 current_function_return_value = NULL_TREE;
3690 /* Return the list of declarations of the current level.
3691 Note that this list is in reverse order unless/until
3692 you nreverse it; and when you do nreverse it, you must
3693 store the result back using `storedecls' or you will lose. */
3698 return current_binding_level->names;
3701 /* Return the list of type-tags (for structs, etc) of the current level. */
3706 return current_binding_level->tags;
3709 /* Store the list of declarations of the current level.
3710 This is done for the parameter declarations of a function being defined,
3711 after they are modified in the light of any missing parameters. */
3717 current_binding_level->names = decls;
3720 /* Similarly, store the list of tags of the current level. */
3726 current_binding_level->tags = tags;
3729 /* Given NAME, an IDENTIFIER_NODE,
3730 return the structure (or union or enum) definition for that name.
3731 Searches binding levels from BINDING_LEVEL up to the global level.
3732 If THISLEVEL_ONLY is nonzero, searches only the specified context
3733 (but skips any tag-transparent contexts to find one that is
3734 meaningful for tags).
3735 FORM says which kind of type the caller wants;
3736 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
3737 If the wrong kind of type is found, and it's not a template, an error is
3741 lookup_tag (form, name, binding_level, thislevel_only)
3742 enum tree_code form;
3743 struct binding_level *binding_level;
3747 register struct binding_level *level;
3749 for (level = binding_level; level; level = level->level_chain)
3752 if (ANON_AGGRNAME_P (name))
3753 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
3755 /* There's no need for error checking here, because
3756 anon names are unique throughout the compilation. */
3757 if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
3758 return TREE_VALUE (tail);
3761 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
3763 if (TREE_PURPOSE (tail) == name)
3765 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
3766 /* Should tighten this up; it'll probably permit
3767 UNION_TYPE and a struct template, for example. */
3769 && !(form != ENUMERAL_TYPE
3770 && (code == TEMPLATE_DECL
3771 || code == UNINSTANTIATED_P_TYPE)))
3774 /* Definition isn't the kind we were looking for. */
3775 cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
3778 return TREE_VALUE (tail);
3781 if (thislevel_only && ! level->tag_transparent)
3783 if (current_class_type && level->level_chain == global_binding_level)
3785 /* Try looking in this class's tags before heading into
3786 global binding level. */
3787 tree context = current_class_type;
3790 switch (TREE_CODE_CLASS (TREE_CODE (context)))
3794 these_tags = CLASSTYPE_TAGS (context);
3795 if (ANON_AGGRNAME_P (name))
3798 if (TYPE_IDENTIFIER (TREE_VALUE (these_tags))
3800 return TREE_VALUE (tail);
3801 these_tags = TREE_CHAIN (these_tags);
3806 if (TREE_PURPOSE (these_tags) == name)
3808 if (TREE_CODE (TREE_VALUE (these_tags)) != form)
3810 cp_error ("`%#D' redeclared as %C in class scope",
3811 TREE_VALUE (tail), form);
3813 return TREE_VALUE (tail);
3815 these_tags = TREE_CHAIN (these_tags);
3817 /* If this type is not yet complete, then don't
3818 look at its context. */
3819 if (TYPE_SIZE (context) == NULL_TREE)
3821 /* Go to next enclosing type, if any. */
3822 context = DECL_CONTEXT (TYPE_NAME (context));
3825 context = DECL_CONTEXT (context);
3828 my_friendly_abort (10);
3840 set_current_level_tags_transparency (tags_transparent)
3841 int tags_transparent;
3843 current_binding_level->tag_transparent = tags_transparent;
3846 /* Given a type, find the tag that was defined for it and return the tag name.
3847 Otherwise return 0. However, the value can never be 0
3848 in the cases in which this is used.
3850 C++: If NAME is non-zero, this is the new name to install. This is
3851 done when replacing anonymous tags with real tag names. */
3854 lookup_tag_reverse (type, name)
3858 register struct binding_level *level;
3860 for (level = current_binding_level; level; level = level->level_chain)
3863 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
3865 if (TREE_VALUE (tail) == type)
3868 TREE_PURPOSE (tail) = name;
3869 return TREE_PURPOSE (tail);
3876 /* Given type TYPE which was not declared in C++ language context,
3877 attempt to find a name by which it is referred. */
3879 typedecl_for_tag (tag)
3882 struct binding_level *b = current_binding_level;
3884 if (TREE_CODE (TYPE_NAME (tag)) == TYPE_DECL)
3885 return TYPE_NAME (tag);
3889 tree decls = b->names;
3892 if (TREE_CODE (decls) == TYPE_DECL && TREE_TYPE (decls) == tag)
3894 decls = TREE_CHAIN (decls);
3903 /* Lookup TYPE in CONTEXT (a chain of nested types or a FUNCTION_DECL).
3904 Return the type value, or NULL_TREE if not found. */
3906 lookup_nested_type (type, context)
3910 if (context == NULL_TREE)
3914 switch (TREE_CODE (context))
3918 tree ctype = TREE_TYPE (context);
3919 tree match = value_member (type, CLASSTYPE_TAGS (ctype));
3921 return TREE_VALUE (match);
3922 context = DECL_CONTEXT (context);
3924 /* When we have a nested class whose member functions have
3925 local types (e.g., a set of enums), we'll arrive here
3926 with the DECL_CONTEXT as the actual RECORD_TYPE node for
3927 the enclosing class. Instead, we want to make sure we
3928 come back in here with the TYPE_DECL, not the RECORD_TYPE. */
3929 if (context && TREE_CODE (context) == RECORD_TYPE)
3930 context = TREE_CHAIN (context);
3934 if (TYPE_NAME (type) && TYPE_IDENTIFIER (type))
3935 return lookup_name (TYPE_IDENTIFIER (type), 1);
3938 my_friendly_abort (12);
3944 /* Look up NAME in the current binding level and its superiors in the
3945 namespace of variables, functions and typedefs. Return a ..._DECL
3946 node of some kind representing its definition if there is only one
3947 such declaration, or return a TREE_LIST with all the overloaded
3948 definitions if there are many, or return 0 if it is undefined.
3950 If PREFER_TYPE is > 0, we prefer TYPE_DECLs.
3951 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
3952 Otherwise we prefer non-TYPE_DECLs. */
3955 lookup_name_real (name, prefer_type, nonclass)
3957 int prefer_type, nonclass;
3961 tree from_obj = NULL_TREE;
3963 if (prefer_type == -2)
3965 extern int looking_for_typename;
3969 prefer_type = looking_for_typename;
3978 if (type == error_mark_node)
3979 return error_mark_node;
3980 else if (type == void_type_node)
3981 val = IDENTIFIER_GLOBAL_VALUE (name);
3982 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
3983 /* TFIXME -- don't do this for UPTs in new model. */
3984 || TREE_CODE (type) == UNINSTANTIATED_P_TYPE)
3986 if (prefer_type > 0)
3987 val = create_nested_upt (type, name);
3991 else if (! IS_AGGR_TYPE (type))
3992 /* Someone else will give an error about this if needed. */
3994 else if (TYPE_BEING_DEFINED (type))
3996 val = IDENTIFIER_CLASS_VALUE (name);
3997 if (val && DECL_CONTEXT (val) != type)
3999 struct binding_level *b = class_binding_level;
4000 for (val = NULL_TREE; b; b = b->level_chain)
4002 tree t = purpose_member (name, b->class_shadowed);
4003 if (t && TREE_VALUE (t)
4004 && DECL_CONTEXT (TREE_VALUE (t)) == type)
4006 val = TREE_VALUE (t);
4011 if (val == NULL_TREE
4012 && CLASSTYPE_LOCAL_TYPEDECLS (type))
4013 val = lookup_field (type, name, 0, 1);
4015 else if (type == current_class_type)
4016 val = IDENTIFIER_CLASS_VALUE (name);
4018 val = lookup_field (type, name, 0, prefer_type);
4026 /* This special lookup only applies to types. */
4027 else if (got_object && val && TREE_CODE (val) == TYPE_DECL)
4031 if (current_binding_level != global_binding_level
4032 && IDENTIFIER_LOCAL_VALUE (name))
4033 val = IDENTIFIER_LOCAL_VALUE (name);
4034 /* In C++ class fields are between local and global scope,
4035 just before the global scope. */
4036 else if (current_class_type && ! nonclass)
4038 val = IDENTIFIER_CLASS_VALUE (name);
4039 if (val == NULL_TREE
4040 && TYPE_BEING_DEFINED (current_class_type)
4041 && CLASSTYPE_LOCAL_TYPEDECLS (current_class_type))
4042 /* Try to find values from base classes if we are presently
4043 defining a type. We are presently only interested in
4045 val = lookup_field (current_class_type, name, 0, 1);
4047 /* yylex() calls this with -2, since we should never start digging for
4048 the nested name at the point where we haven't even, for example,
4049 created the COMPONENT_REF or anything like that. */
4050 if (val == NULL_TREE)
4051 val = lookup_nested_field (name, ! yylex);
4053 if (val == NULL_TREE)
4054 val = IDENTIFIER_GLOBAL_VALUE (name);
4057 val = IDENTIFIER_GLOBAL_VALUE (name);
4062 if (from_obj && from_obj != val)
4063 cp_error ("lookup in the scope of `%#T' does not match lookup in the current scope",
4066 if ((TREE_CODE (val) == TEMPLATE_DECL && looking_for_template)
4067 || TREE_CODE (val) == TYPE_DECL || prefer_type <= 0)
4069 else if (IDENTIFIER_HAS_TYPE_VALUE (name))
4070 val = TYPE_NAME (IDENTIFIER_TYPE_VALUE (name));
4071 else if (TREE_TYPE (val) == error_mark_node)
4072 val = error_mark_node;
4081 lookup_name_nonclass (name)
4084 return lookup_name_real (name, 0, 1);
4088 lookup_name (name, prefer_type)
4092 return lookup_name_real (name, prefer_type, 0);
4095 /* Similar to `lookup_name' but look only at current binding level. */
4098 lookup_name_current_level (name)
4101 register tree t = NULL_TREE;
4103 if (current_binding_level == global_binding_level)
4105 t = IDENTIFIER_GLOBAL_VALUE (name);
4107 /* extern "C" function() */
4108 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4111 else if (IDENTIFIER_LOCAL_VALUE (name) != NULL_TREE)
4113 struct binding_level *b = current_binding_level;
4116 for (t = b->names; t; t = TREE_CHAIN (t))
4117 if (DECL_NAME (t) == name || DECL_ASSEMBLER_NAME (t) == name)
4131 /* Arrange for the user to get a source line number, even when the
4132 compiler is going down in flames, so that she at least has a
4133 chance of working around problems in the compiler. We used to
4134 call error(), but that let the segmentation fault continue
4135 through; now, it's much more passive by asking them to send the
4136 maintainers mail about the problem. */
4142 signal (SIGSEGV, SIG_DFL);
4144 signal (SIGIOT, SIG_DFL);
4147 signal (SIGILL, SIG_DFL);
4150 signal (SIGABRT, SIG_DFL);
4153 signal (SIGBUS, SIG_DFL);
4155 my_friendly_abort (0);
4158 /* Array for holding types considered "built-in". These types
4159 are output in the module in which `main' is defined. */
4160 static tree *builtin_type_tdescs_arr;
4161 static int builtin_type_tdescs_len, builtin_type_tdescs_max;
4163 /* Push the declarations of builtin types into the namespace.
4164 RID_INDEX, if < RID_MAX is the index of the builtin type
4165 in the array RID_POINTERS. NAME is the name used when looking
4166 up the builtin type. TYPE is the _TYPE node for the builtin type. */
4169 record_builtin_type (rid_index, name, type)
4174 tree rname = NULL_TREE, tname = NULL_TREE;
4177 if ((int) rid_index < (int) RID_MAX)
4178 rname = ridpointers[(int) rid_index];
4180 tname = get_identifier (name);
4182 TYPE_BUILT_IN (type) = 1;
4186 #if 0 /* not yet, should get fixed properly later */
4187 tdecl = pushdecl (make_type_decl (tname, type));
4189 tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
4191 set_identifier_type_value (tname, NULL_TREE);
4192 if ((int) rid_index < (int) RID_MAX)
4193 IDENTIFIER_GLOBAL_VALUE (tname) = tdecl;
4195 if (rname != NULL_TREE)
4197 if (tname != NULL_TREE)
4199 set_identifier_type_value (rname, NULL_TREE);
4200 IDENTIFIER_GLOBAL_VALUE (rname) = tdecl;
4204 #if 0 /* not yet, should get fixed properly later */
4205 tdecl = pushdecl (make_type_decl (rname, type));
4207 tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
4209 set_identifier_type_value (rname, NULL_TREE);
4215 if (builtin_type_tdescs_len+5 >= builtin_type_tdescs_max)
4217 builtin_type_tdescs_max *= 2;
4218 builtin_type_tdescs_arr
4219 = (tree *)xrealloc (builtin_type_tdescs_arr,
4220 builtin_type_tdescs_max * sizeof (tree));
4222 builtin_type_tdescs_arr[builtin_type_tdescs_len++] = type;
4223 if (TREE_CODE (type) != POINTER_TYPE)
4225 builtin_type_tdescs_arr[builtin_type_tdescs_len++]
4226 = build_pointer_type (type);
4227 builtin_type_tdescs_arr[builtin_type_tdescs_len++]
4228 = build_pointer_type (build_type_variant (type, 1, 0));
4230 if (TREE_CODE (type) != VOID_TYPE)
4232 builtin_type_tdescs_arr[builtin_type_tdescs_len++]
4233 = build_reference_type (type);
4234 builtin_type_tdescs_arr[builtin_type_tdescs_len++]
4235 = build_reference_type (build_type_variant (type, 1, 0));
4241 output_builtin_tdesc_entries ()
4243 extern struct obstack permanent_obstack;
4245 /* If there's more than one main in this file, don't crash. */
4246 if (builtin_type_tdescs_arr == 0)
4249 push_obstacks (&permanent_obstack, &permanent_obstack);
4250 while (builtin_type_tdescs_len > 0)
4252 tree type = builtin_type_tdescs_arr[--builtin_type_tdescs_len];
4253 tree tdesc = build_t_desc (type, 0);
4254 TREE_ASM_WRITTEN (tdesc) = 0;
4255 build_t_desc (type, 2);
4257 free (builtin_type_tdescs_arr);
4258 builtin_type_tdescs_arr = 0;
4262 /* Push overloaded decl, in global scope, with one argument so it
4263 can be used as a callback from define_function. */
4265 push_overloaded_decl_1 (x)
4268 push_overloaded_decl (x, 0);
4271 #define builtin_function(NAME, TYPE, CODE, LIBNAME) \
4272 define_function (NAME, TYPE, CODE, (void (*)())pushdecl, LIBNAME)
4277 tree auto_function (name, type, code)
4279 enum built_in_function code;
4281 return define_function
4282 (IDENTIFIER_POINTER (name), type, code, (void (*)())push_overloaded_decl_1,
4283 IDENTIFIER_POINTER (build_decl_overload (name, TYPE_ARG_TYPES (type),
4287 /* Create the predefined scalar types of C,
4288 and some nodes representing standard constants (0, 1, (void *)0).
4289 Initialize the global binding level.
4290 Make definitions for built-in primitive functions. */
4293 init_decl_processing ()
4296 register tree endlink, int_endlink, double_endlink, ptr_endlink;
4298 /* Either char* or void*. */
4299 tree traditional_ptr_type_node;
4300 /* Data type of memcpy. */
4302 #if 0 /* Not yet. */
4303 /* Data type of strncpy. */
4306 int wchar_type_size;
4308 tree array_domain_type;
4309 extern int flag_strict_prototype;
4311 /* Have to make these distinct before we try using them. */
4312 lang_name_cplusplus = get_identifier ("C++");
4313 lang_name_c = get_identifier ("C");
4315 if (flag_strict_prototype == 2)
4318 strict_prototypes_lang_c = strict_prototypes_lang_cplusplus;
4321 strict_prototypes_lang_c = flag_strict_prototype;
4324 current_lang_name = lang_name_c;
4326 current_function_decl = NULL_TREE;
4327 named_labels = NULL_TREE;
4328 named_label_uses = NULL_TREE;
4329 current_binding_level = NULL_BINDING_LEVEL;
4330 free_binding_level = NULL_BINDING_LEVEL;
4332 /* Because most segmentation signals can be traced back into user
4333 code, catch them and at least give the user a chance of working
4334 around compiler bugs. */
4335 signal (SIGSEGV, signal_catch);
4337 /* We will also catch aborts in the back-end through signal_catch and
4338 give the user a chance to see where the error might be, and to defeat
4339 aborts in the back-end when there have been errors previously in their
4342 signal (SIGIOT, signal_catch);
4345 signal (SIGILL, signal_catch);
4348 signal (SIGABRT, signal_catch);
4351 signal (SIGBUS, signal_catch);
4354 gcc_obstack_init (&decl_obstack);
4357 builtin_type_tdescs_max = 100;
4358 builtin_type_tdescs_arr = (tree *)xmalloc (100 * sizeof (tree));
4361 /* Must lay these out before anything else gets laid out. */
4362 error_mark_node = make_node (ERROR_MARK);
4363 TREE_PERMANENT (error_mark_node) = 1;
4364 TREE_TYPE (error_mark_node) = error_mark_node;
4365 error_mark_list = build_tree_list (error_mark_node, error_mark_node);
4366 TREE_TYPE (error_mark_list) = error_mark_node;
4368 /* Make the binding_level structure for global names. */
4370 global_binding_level = current_binding_level;
4372 this_identifier = get_identifier (THIS_NAME);
4373 in_charge_identifier = get_identifier (IN_CHARGE_NAME);
4374 pfn_identifier = get_identifier (VTABLE_PFN_NAME);
4375 index_identifier = get_identifier (VTABLE_INDEX_NAME);
4376 delta_identifier = get_identifier (VTABLE_DELTA_NAME);
4377 delta2_identifier = get_identifier (VTABLE_DELTA2_NAME);
4378 pfn_or_delta2_identifier = get_identifier ("__pfn_or_delta2");
4380 /* Define `int' and `char' first so that dbx will output them first. */
4382 integer_type_node = make_signed_type (INT_TYPE_SIZE);
4383 record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
4385 /* Define `char', which is like either `signed char' or `unsigned char'
4386 but not the same as either. */
4390 ? make_signed_type (CHAR_TYPE_SIZE)
4391 : make_unsigned_type (CHAR_TYPE_SIZE));
4392 record_builtin_type (RID_CHAR, "char", char_type_node);
4394 long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
4395 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4397 unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
4398 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4400 long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
4401 record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
4402 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4404 long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
4405 record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
4407 long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
4408 record_builtin_type (RID_MAX, "long long unsigned int",
4409 long_long_unsigned_type_node);
4410 record_builtin_type (RID_MAX, "long long unsigned",
4411 long_long_unsigned_type_node);
4413 /* `unsigned long' is the standard type for sizeof.
4414 Traditionally, use a signed type.
4415 Note that stddef.h uses `unsigned long',
4416 and this must agree, even of long and int are the same size. */
4418 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE)));
4419 if (flag_traditional && TREE_UNSIGNED (sizetype))
4420 sizetype = signed_type (sizetype);
4423 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
4425 TREE_TYPE (TYPE_SIZE (integer_type_node)) = sizetype;
4426 TREE_TYPE (TYPE_SIZE (char_type_node)) = sizetype;
4427 TREE_TYPE (TYPE_SIZE (unsigned_type_node)) = sizetype;
4428 TREE_TYPE (TYPE_SIZE (long_unsigned_type_node)) = sizetype;
4429 TREE_TYPE (TYPE_SIZE (long_integer_type_node)) = sizetype;
4430 TREE_TYPE (TYPE_SIZE (long_long_integer_type_node)) = sizetype;
4431 TREE_TYPE (TYPE_SIZE (long_long_unsigned_type_node)) = sizetype;
4433 short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
4434 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4435 short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
4436 record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
4437 record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
4439 /* Define both `signed char' and `unsigned char'. */
4440 signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
4441 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4442 unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
4443 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4445 /* These are types that type_for_size and type_for_mode use. */
4446 intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode));
4447 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
4448 intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode));
4449 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
4450 intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode));
4451 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
4452 intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode));
4453 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
4454 unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode));
4455 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
4456 unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode));
4457 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
4458 unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode));
4459 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
4460 unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode));
4461 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
4463 float_type_node = make_node (REAL_TYPE);
4464 TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
4465 record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
4466 layout_type (float_type_node);
4468 double_type_node = make_node (REAL_TYPE);
4469 if (flag_short_double)
4470 TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
4472 TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
4473 record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
4474 layout_type (double_type_node);
4476 long_double_type_node = make_node (REAL_TYPE);
4477 TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
4478 record_builtin_type (RID_MAX, "long double", long_double_type_node);
4479 layout_type (long_double_type_node);
4481 integer_zero_node = build_int_2 (0, 0);
4482 TREE_TYPE (integer_zero_node) = integer_type_node;
4483 integer_one_node = build_int_2 (1, 0);
4484 TREE_TYPE (integer_one_node) = integer_type_node;
4485 integer_two_node = build_int_2 (2, 0);
4486 TREE_TYPE (integer_two_node) = integer_type_node;
4487 integer_three_node = build_int_2 (3, 0);
4488 TREE_TYPE (integer_three_node) = integer_type_node;
4490 boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
4491 TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
4492 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
4493 boolean_false_node = build_int_2 (0, 0);
4494 TREE_TYPE (boolean_false_node) = boolean_type_node;
4495 boolean_true_node = build_int_2 (1, 0);
4496 TREE_TYPE (boolean_true_node) = boolean_type_node;
4498 /* These are needed by stor-layout.c. */
4499 size_zero_node = size_int (0);
4500 size_one_node = size_int (1);
4502 void_type_node = make_node (VOID_TYPE);
4503 record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
4504 layout_type (void_type_node); /* Uses integer_zero_node. */
4505 void_list_node = build_tree_list (NULL_TREE, void_type_node);
4506 TREE_PARMLIST (void_list_node) = 1;
4508 null_pointer_node = build_int_2 (0, 0);
4509 TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
4510 layout_type (TREE_TYPE (null_pointer_node));
4512 /* Used for expressions that do nothing, but are not errors. */
4513 void_zero_node = build_int_2 (0, 0);
4514 TREE_TYPE (void_zero_node) = void_type_node;
4516 string_type_node = build_pointer_type (char_type_node);
4517 const_string_type_node =
4518 build_pointer_type (build_type_variant (char_type_node, 1, 0));
4519 record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
4521 /* Make a type to be the domain of a few array types
4522 whose domains don't really matter.
4523 200 is small enough that it always fits in size_t
4524 and large enough that it can hold most function names for the
4525 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4526 array_domain_type = build_index_type (build_int_2 (200, 0));
4528 /* make a type for arrays of characters.
4529 With luck nothing will ever really depend on the length of this
4531 char_array_type_node
4532 = build_array_type (char_type_node, array_domain_type);
4533 /* Likewise for arrays of ints. */
4535 = build_array_type (integer_type_node, array_domain_type);
4537 /* This is just some anonymous class type. Nobody should ever
4538 need to look inside this envelope. */
4539 class_star_type_node = build_pointer_type (make_lang_type (RECORD_TYPE));
4541 default_function_type
4542 = build_function_type (integer_type_node, NULL_TREE);
4543 build_pointer_type (default_function_type);
4545 ptr_type_node = build_pointer_type (void_type_node);
4546 const_ptr_type_node =
4547 build_pointer_type (build_type_variant (void_type_node, 1, 0));
4548 record_builtin_type (RID_MAX, NULL_PTR, ptr_type_node);
4549 endlink = void_list_node;
4550 int_endlink = tree_cons (NULL_TREE, integer_type_node, endlink);
4551 double_endlink = tree_cons (NULL_TREE, double_type_node, endlink);
4552 ptr_endlink = tree_cons (NULL_TREE, ptr_type_node, endlink);
4555 = build_function_type (double_type_node, double_endlink);
4557 double_ftype_double_double
4558 = build_function_type (double_type_node,
4559 tree_cons (NULL_TREE, double_type_node,
4563 = build_function_type (integer_type_node, int_endlink);
4566 = build_function_type (long_integer_type_node,
4567 tree_cons (NULL_TREE, long_integer_type_node,
4570 void_ftype_ptr_ptr_int
4571 = build_function_type (void_type_node,
4572 tree_cons (NULL_TREE, ptr_type_node,
4573 tree_cons (NULL_TREE, ptr_type_node,
4576 int_ftype_cptr_cptr_sizet
4577 = build_function_type (integer_type_node,
4578 tree_cons (NULL_TREE, const_ptr_type_node,
4579 tree_cons (NULL_TREE, const_ptr_type_node,
4580 tree_cons (NULL_TREE,
4584 void_ftype_ptr_int_int
4585 = build_function_type (void_type_node,
4586 tree_cons (NULL_TREE, ptr_type_node,
4587 tree_cons (NULL_TREE, integer_type_node,
4590 string_ftype_ptr_ptr /* strcpy prototype */
4591 = build_function_type (string_type_node,
4592 tree_cons (NULL_TREE, string_type_node,
4593 tree_cons (NULL_TREE,
4594 const_string_type_node,
4599 strncpy_ftype /* strncpy prototype */
4600 = build_function_type (string_type_node,
4601 tree_cons (NULL_TREE, string_type_node,
4602 tree_cons (NULL_TREE, const_string_type_node,
4603 tree_cons (NULL_TREE,
4608 int_ftype_string_string /* strcmp prototype */
4609 = build_function_type (integer_type_node,
4610 tree_cons (NULL_TREE, const_string_type_node,
4611 tree_cons (NULL_TREE,
4612 const_string_type_node,
4615 sizet_ftype_string /* strlen prototype */
4616 = build_function_type (sizetype,
4617 tree_cons (NULL_TREE, const_string_type_node,
4620 traditional_ptr_type_node
4621 = (flag_traditional ? string_type_node : ptr_type_node);
4623 memcpy_ftype /* memcpy prototype */
4624 = build_function_type (traditional_ptr_type_node,
4625 tree_cons (NULL_TREE, ptr_type_node,
4626 tree_cons (NULL_TREE, const_ptr_type_node,
4627 tree_cons (NULL_TREE,
4631 if (flag_huge_objects)
4632 delta_type_node = long_integer_type_node;
4634 delta_type_node = short_integer_type_node;
4636 builtin_function ("__builtin_constant_p", int_ftype_int,
4637 BUILT_IN_CONSTANT_P, NULL_PTR);
4639 builtin_return_address_fndecl =
4640 builtin_function ("__builtin_return_address",
4641 build_function_type (ptr_type_node,
4642 tree_cons (NULL_TREE,
4645 BUILT_IN_RETURN_ADDRESS, NULL_PTR);
4647 builtin_function ("__builtin_frame_address",
4648 build_function_type (ptr_type_node,
4649 tree_cons (NULL_TREE,
4652 BUILT_IN_FRAME_ADDRESS, NULL_PTR);
4655 builtin_function ("__builtin_alloca",
4656 build_function_type (ptr_type_node,
4657 tree_cons (NULL_TREE,
4660 BUILT_IN_ALLOCA, "alloca");
4661 /* Define alloca, ffs as builtins.
4662 Declare _exit just to mark it as volatile. */
4663 if (! flag_no_builtin && !flag_no_nonansi_builtin)
4665 temp = builtin_function ("alloca",
4666 build_function_type (ptr_type_node,
4667 tree_cons (NULL_TREE,
4670 BUILT_IN_ALLOCA, NULL_PTR);
4671 /* Suppress error if redefined as a non-function. */
4672 DECL_BUILT_IN_NONANSI (temp) = 1;
4673 temp = builtin_function ("ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
4674 /* Suppress error if redefined as a non-function. */
4675 DECL_BUILT_IN_NONANSI (temp) = 1;
4676 temp = builtin_function ("_exit", build_function_type (void_type_node,
4678 NOT_BUILT_IN, NULL_PTR);
4679 TREE_THIS_VOLATILE (temp) = 1;
4680 TREE_SIDE_EFFECTS (temp) = 1;
4681 /* Suppress error if redefined as a non-function. */
4682 DECL_BUILT_IN_NONANSI (temp) = 1;
4685 builtin_function ("__builtin_abs", int_ftype_int,
4686 BUILT_IN_ABS, NULL_PTR);
4687 builtin_function ("__builtin_fabs", double_ftype_double,
4688 BUILT_IN_FABS, NULL_PTR);
4689 builtin_function ("__builtin_labs", long_ftype_long,
4690 BUILT_IN_LABS, NULL_PTR);
4691 builtin_function ("__builtin_ffs", int_ftype_int,
4692 BUILT_IN_FFS, NULL_PTR);
4693 builtin_function ("__builtin_fsqrt", double_ftype_double,
4694 BUILT_IN_FSQRT, NULL_PTR);
4695 builtin_function ("__builtin_sin", double_ftype_double,
4696 BUILT_IN_SIN, "sin");
4697 builtin_function ("__builtin_cos", double_ftype_double,
4698 BUILT_IN_COS, "cos");
4699 builtin_function ("__builtin_saveregs",
4700 build_function_type (ptr_type_node, NULL_TREE),
4701 BUILT_IN_SAVEREGS, NULL_PTR);
4702 /* EXPAND_BUILTIN_VARARGS is obsolete. */
4704 builtin_function ("__builtin_varargs",
4705 build_function_type (ptr_type_node,
4706 tree_cons (NULL_TREE,
4709 BUILT_IN_VARARGS, NULL_PTR);
4711 builtin_function ("__builtin_classify_type", default_function_type,
4712 BUILT_IN_CLASSIFY_TYPE, NULL_PTR);
4713 builtin_function ("__builtin_next_arg",
4714 build_function_type (ptr_type_node, NULL_TREE),
4715 BUILT_IN_NEXT_ARG, NULL_PTR);
4716 builtin_function ("__builtin_args_info",
4717 build_function_type (integer_type_node,
4718 tree_cons (NULL_TREE,
4721 BUILT_IN_ARGS_INFO, NULL_PTR);
4723 /* Untyped call and return. */
4724 builtin_function ("__builtin_apply_args",
4725 build_function_type (ptr_type_node, NULL_TREE),
4726 BUILT_IN_APPLY_ARGS, NULL_PTR);
4728 temp = tree_cons (NULL_TREE,
4729 build_pointer_type (build_function_type (void_type_node,
4731 tree_cons (NULL_TREE,
4733 tree_cons (NULL_TREE,
4736 builtin_function ("__builtin_apply",
4737 build_function_type (ptr_type_node, temp),
4738 BUILT_IN_APPLY, NULL_PTR);
4739 builtin_function ("__builtin_return",
4740 build_function_type (void_type_node,
4741 tree_cons (NULL_TREE,
4744 BUILT_IN_RETURN, NULL_PTR);
4746 /* Currently under experimentation. */
4747 builtin_function ("__builtin_memcpy", memcpy_ftype,
4748 BUILT_IN_MEMCPY, "memcpy");
4749 builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet,
4750 BUILT_IN_MEMCMP, "memcmp");
4751 builtin_function ("__builtin_strcmp", int_ftype_string_string,
4752 BUILT_IN_STRCMP, "strcmp");
4753 builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr,
4754 BUILT_IN_STRCPY, "strcpy");
4757 builtin_function ("__builtin_strncpy", strncpy_ftype,
4758 BUILT_IN_STRNCPY, "strncpy");
4760 builtin_function ("__builtin_strlen", sizet_ftype_string,
4761 BUILT_IN_STRLEN, "strlen");
4763 if (!flag_no_builtin)
4765 #if 0 /* These do not work well with libg++. */
4766 builtin_function ("abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
4767 builtin_function ("fabs", double_ftype_double, BUILT_IN_FABS, NULL_PTR);
4768 builtin_function ("labs", long_ftype_long, BUILT_IN_LABS, NULL_PTR);
4770 builtin_function ("memcpy", memcpy_ftype, BUILT_IN_MEMCPY, NULL_PTR);
4771 builtin_function ("memcmp", int_ftype_cptr_cptr_sizet, BUILT_IN_MEMCMP,
4773 builtin_function ("strcmp", int_ftype_string_string, BUILT_IN_STRCMP, NULL_PTR);
4774 builtin_function ("strcpy", string_ftype_ptr_ptr, BUILT_IN_STRCPY,
4778 builtin_function ("strncpy", strncpy_ftype, BUILT_IN_STRNCPY, NULL_PTR);
4780 builtin_function ("strlen", sizet_ftype_string, BUILT_IN_STRLEN, NULL_PTR);
4781 builtin_function ("sin", double_ftype_double, BUILT_IN_SIN, NULL_PTR);
4782 builtin_function ("cos", double_ftype_double, BUILT_IN_COS, NULL_PTR);
4784 /* Declare these functions volatile
4785 to avoid spurious "control drops through" warnings. */
4786 temp = builtin_function ("abort",
4787 build_function_type (void_type_node, endlink),
4788 NOT_BUILT_IN, NULL_PTR);
4789 TREE_THIS_VOLATILE (temp) = 1;
4790 TREE_SIDE_EFFECTS (temp) = 1;
4791 /* Well, these are actually ANSI, but we can't set DECL_BUILT_IN on
4793 DECL_BUILT_IN_NONANSI (temp) = 1;
4794 temp = builtin_function ("exit", build_function_type (void_type_node,
4796 NOT_BUILT_IN, NULL_PTR);
4797 TREE_THIS_VOLATILE (temp) = 1;
4798 TREE_SIDE_EFFECTS (temp) = 1;
4799 DECL_BUILT_IN_NONANSI (temp) = 1;
4803 /* Support for these has not been written in either expand_builtin
4804 or build_function_call. */
4805 builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV, 0);
4806 builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV, 0);
4807 builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR,
4809 builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL, 0);
4810 builtin_function ("__builtin_fmod", double_ftype_double_double,
4812 builtin_function ("__builtin_frem", double_ftype_double_double,
4814 builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int, BUILT_IN_MEMSET,
4816 builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP,
4818 builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN,
4822 /* C++ extensions */
4824 unknown_type_node = make_node (UNKNOWN_TYPE);
4825 #if 0 /* not yet, should get fixed properly later */
4826 pushdecl (make_type_decl (get_identifier ("unknown type"),
4827 unknown_type_node));
4829 decl = pushdecl (build_decl (TYPE_DECL, get_identifier ("unknown type"),
4830 unknown_type_node));
4831 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
4832 DECL_IGNORED_P (decl) = 1;
4833 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
4835 TYPE_SIZE (unknown_type_node) = TYPE_SIZE (void_type_node);
4836 TYPE_ALIGN (unknown_type_node) = 1;
4837 TYPE_MODE (unknown_type_node) = TYPE_MODE (void_type_node);
4838 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4839 TREE_TYPE (unknown_type_node) = unknown_type_node;
4840 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same result. */
4841 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
4842 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
4844 /* This is for handling opaque types in signatures. */
4845 opaque_type_node = copy_node (ptr_type_node);
4846 TYPE_MAIN_VARIANT (opaque_type_node) = opaque_type_node;
4847 record_builtin_type (RID_MAX, 0, opaque_type_node);
4849 /* This is special for C++ so functions can be overloaded. */
4851 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE)));
4852 wchar_type_size = TYPE_PRECISION (wchar_type_node);
4853 signed_wchar_type_node = make_signed_type (wchar_type_size);
4854 unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
4856 = TREE_UNSIGNED (wchar_type_node)
4857 ? unsigned_wchar_type_node
4858 : signed_wchar_type_node;
4859 record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
4861 /* Artificial declaration of wchar_t -- can be bashed */
4862 wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
4864 pushdecl (wchar_decl_node);
4866 /* This is for wide string constants. */
4867 wchar_array_type_node
4868 = build_array_type (wchar_type_node, array_domain_type);
4870 /* This is a hack that should go away when we deliver the
4874 builtin_function ("__gc_main", default_function_type, NOT_BUILT_IN, 0);
4875 pushdecl (lookup_name (get_identifier ("__gc_main"), 0));
4878 if (flag_vtable_thunks)
4880 /* Make sure we get a unique function type, so we can give
4881 its pointer type a name. (This wins for gdb.) */
4882 tree vfunc_type = make_node (FUNCTION_TYPE);
4883 TREE_TYPE (vfunc_type) = integer_type_node;
4884 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
4885 layout_type (vfunc_type);
4887 vtable_entry_type = build_pointer_type (vfunc_type);
4891 vtable_entry_type = make_lang_type (RECORD_TYPE);
4892 fields[0] = build_lang_field_decl (FIELD_DECL, delta_identifier,
4894 fields[1] = build_lang_field_decl (FIELD_DECL, index_identifier,
4896 fields[2] = build_lang_field_decl (FIELD_DECL, pfn_identifier,
4898 finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
4901 /* Make this part of an invisible union. */
4902 fields[3] = copy_node (fields[2]);
4903 TREE_TYPE (fields[3]) = delta_type_node;
4904 DECL_NAME (fields[3]) = delta2_identifier;
4905 DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
4906 DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
4907 TREE_UNSIGNED (fields[3]) = 0;
4908 TREE_CHAIN (fields[2]) = fields[3];
4909 vtable_entry_type = build_type_variant (vtable_entry_type, 1, 0);
4911 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
4914 = build_array_type (vtable_entry_type, NULL_TREE);
4915 layout_type (vtbl_type_node);
4916 vtbl_type_node = cp_build_type_variant (vtbl_type_node, 1, 0);
4917 record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
4919 /* Simplify life by making a "sigtable_entry_type". Give its
4920 fields names so that the debugger can use them. */
4922 if (flag_handle_signatures)
4924 sigtable_entry_type = make_lang_type (RECORD_TYPE);
4925 fields[0] = build_lang_field_decl (FIELD_DECL,
4926 get_identifier (SIGTABLE_CODE_NAME),
4927 short_integer_type_node);
4928 fields[1] = build_lang_field_decl (FIELD_DECL,
4929 get_identifier (SIGTABLE_OFFSET_NAME),
4930 short_integer_type_node);
4931 fields[2] = build_lang_field_decl (FIELD_DECL,
4932 get_identifier (SIGTABLE_PFN_NAME),
4934 finish_builtin_type (sigtable_entry_type, SIGTABLE_PTR_TYPE, fields, 2,
4936 sigtable_entry_type = build_type_variant (sigtable_entry_type, 1, 0);
4937 record_builtin_type (RID_MAX, SIGTABLE_PTR_TYPE, sigtable_entry_type);
4943 /* Must build __t_desc type. Currently, type descriptors look like this:
4950 struct __t_desc *points_to;
4951 int ivars_count, meths_count;
4952 struct __i_desc *ivars[];
4953 struct __m_desc *meths[];
4954 struct __t_desc *parents[];
4955 struct __t_desc *vbases[];
4959 ...as per Linton's paper. */
4961 __t_desc_type_node = make_lang_type (RECORD_TYPE);
4962 __i_desc_type_node = make_lang_type (RECORD_TYPE);
4963 __m_desc_type_node = make_lang_type (RECORD_TYPE);
4964 __t_desc_array_type =
4965 build_array_type (TYPE_POINTER_TO (__t_desc_type_node), NULL_TREE);
4966 __i_desc_array_type =
4967 build_array_type (TYPE_POINTER_TO (__i_desc_type_node), NULL_TREE);
4968 __m_desc_array_type =
4969 build_array_type (TYPE_POINTER_TO (__m_desc_type_node), NULL_TREE);
4971 fields[0] = build_lang_field_decl (FIELD_DECL, get_identifier ("name"),
4973 fields[1] = build_lang_field_decl (FIELD_DECL, get_identifier ("size"),
4974 unsigned_type_node);
4975 fields[2] = build_lang_field_decl (FIELD_DECL, get_identifier ("bits"),
4976 unsigned_type_node);
4977 fields[3] = build_lang_field_decl (FIELD_DECL,
4978 get_identifier ("points_to"),
4979 TYPE_POINTER_TO (__t_desc_type_node));
4980 fields[4] = build_lang_field_decl (FIELD_DECL,
4981 get_identifier ("ivars_count"),
4983 fields[5] = build_lang_field_decl (FIELD_DECL,
4984 get_identifier ("meths_count"),
4986 fields[6] = build_lang_field_decl (FIELD_DECL, get_identifier ("ivars"),
4987 build_pointer_type (__i_desc_array_type));
4988 fields[7] = build_lang_field_decl (FIELD_DECL, get_identifier ("meths"),
4989 build_pointer_type (__m_desc_array_type));
4990 fields[8] = build_lang_field_decl (FIELD_DECL, get_identifier ("parents"),
4991 build_pointer_type (__t_desc_array_type));
4992 fields[9] = build_lang_field_decl (FIELD_DECL, get_identifier ("vbases"),
4993 build_pointer_type (__t_desc_array_type));
4994 fields[10] = build_lang_field_decl (FIELD_DECL, get_identifier ("offsets"),
4995 build_pointer_type (integer_type_node));
4996 finish_builtin_type (__t_desc_type_node, "__t_desc", fields, 10, integer_type_node);
4998 /* ivar descriptors look like this:
5004 struct __t_desc *type;
5008 fields[0] = build_lang_field_decl (FIELD_DECL, get_identifier ("name"),
5010 fields[1] = build_lang_field_decl (FIELD_DECL, get_identifier ("offset"),
5012 fields[2] = build_lang_field_decl (FIELD_DECL, get_identifier ("type"),
5013 TYPE_POINTER_TO (__t_desc_type_node));
5014 finish_builtin_type (__i_desc_type_node, "__i_desc", fields, 2,
5017 /* method descriptors look like this:
5023 struct __t_desc *vcontext;
5024 struct __t_desc *return_type;
5027 short required_parms;
5028 struct __t_desc *parm_types[];
5032 fields[0] = build_lang_field_decl (FIELD_DECL, get_identifier ("name"),
5034 fields[1] = build_lang_field_decl (FIELD_DECL, get_identifier ("vindex"),
5036 fields[2] = build_lang_field_decl (FIELD_DECL, get_identifier ("vcontext"),
5037 TYPE_POINTER_TO (__t_desc_type_node));
5038 fields[3] = build_lang_field_decl (FIELD_DECL, get_identifier ("return_type"),
5039 TYPE_POINTER_TO (__t_desc_type_node));
5040 fields[4] = build_lang_field_decl (FIELD_DECL, get_identifier ("address"),
5041 build_pointer_type (default_function_type));
5042 fields[5] = build_lang_field_decl (FIELD_DECL, get_identifier ("parm_count"),
5043 short_integer_type_node);
5044 fields[6] = build_lang_field_decl (FIELD_DECL, get_identifier ("required_parms"),
5045 short_integer_type_node);
5046 fields[7] = build_lang_field_decl (FIELD_DECL, get_identifier ("parm_types"),
5047 build_pointer_type (build_array_type (TYPE_POINTER_TO (__t_desc_type_node), NULL_TREE)));
5048 finish_builtin_type (__m_desc_type_node, "__m_desc", fields, 7,
5054 int i = builtin_type_tdescs_len;
5057 tree tdesc = build_t_desc (builtin_type_tdescs_arr[--i], 0);
5058 TREE_ASM_WRITTEN (tdesc) = 1;
5059 TREE_PUBLIC (TREE_OPERAND (tdesc, 0)) = 1;
5062 #endif /*flag_rtti*/
5065 current_lang_name = lang_name_cplusplus;
5067 auto_function (ansi_opname[(int) NEW_EXPR],
5068 build_function_type (ptr_type_node,
5069 tree_cons (NULL_TREE, sizetype,
5072 auto_function (ansi_opname[(int) VEC_NEW_EXPR],
5073 build_function_type (ptr_type_node,
5074 tree_cons (NULL_TREE, sizetype,
5077 auto_function (ansi_opname[(int) DELETE_EXPR],
5078 build_function_type (void_type_node,
5079 tree_cons (NULL_TREE, ptr_type_node,
5082 auto_function (ansi_opname[(int) VEC_DELETE_EXPR],
5083 build_function_type (void_type_node,
5084 tree_cons (NULL_TREE, ptr_type_node,
5089 = define_function ("__pure_virtual",
5090 build_function_type (void_type_node, void_list_node),
5091 NOT_BUILT_IN, 0, 0);
5093 /* Perform other language dependent initializations. */
5094 init_class_processing ();
5095 init_init_processing ();
5096 init_search_processing ();
5098 if (flag_handle_exceptions)
5099 init_exception_processing ();
5101 init_gc_processing ();
5104 flag_inline_functions = 0;
5106 /* This causes uneccessary emission of inline functions. */
5107 flag_default_inline = 0;
5113 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
5114 declare_function_name ();
5116 /* Prepare to check format strings against argument lists. */
5117 init_function_format_info ();
5120 /* initialize type descriptor type node of various rtti type. */
5127 tdecl = lookup_name (get_identifier ("type_info"), 0);
5128 if (tdecl == NULL_TREE)
5130 __t_desc_type_node = TREE_TYPE(tdecl);
5131 __tp_desc_type_node = build_pointer_type (__t_desc_type_node);
5134 tdecl = lookup_name (get_identifier ("__baselist_type_info"), 0);
5135 if (tdecl == NULL_TREE)
5137 __baselist_desc_type_node = TREE_TYPE (tdecl);
5140 tdecl = lookup_name (get_identifier ("__builtin_type_info"), 0);
5141 if (tdecl == NULL_TREE)
5143 __bltn_desc_type_node = TREE_TYPE (tdecl);
5145 tdecl = lookup_name (get_identifier ("__user_type_info"), 0);
5146 if (tdecl == NULL_TREE)
5148 __user_desc_type_node = TREE_TYPE (tdecl);
5150 tdecl = lookup_name (get_identifier ("__class_type_info"), 0);
5151 if (tdecl == NULL_TREE)
5153 __class_desc_type_node = TREE_TYPE (tdecl);
5155 tdecl = lookup_field (__class_desc_type_node,
5156 get_identifier ("access_mode"), 0, 0);
5157 if (tdecl == NULL_TREE)
5159 __access_mode_type_node = TREE_TYPE (tdecl);
5161 tdecl = lookup_name (get_identifier ("__attr_type_info"), 0);
5162 if (tdecl == NULL_TREE)
5164 __attr_desc_type_node = TREE_TYPE (tdecl);
5166 tdecl = lookup_name (get_identifier ("__pointer_type_info"), 0);
5167 if (tdecl == NULL_TREE)
5169 __ptr_desc_type_node = TREE_TYPE (tdecl);
5171 tdecl = lookup_name (get_identifier ("__func_type_info"), 0);
5172 if (tdecl == NULL_TREE)
5174 __func_desc_type_node = TREE_TYPE (tdecl);
5176 tdecl = lookup_name (get_identifier ("__ptmf_type_info"), 0);
5177 if (tdecl == NULL_TREE)
5179 __ptmf_desc_type_node = TREE_TYPE (tdecl);
5181 tdecl = lookup_name (get_identifier ("__ptmd_type_info"), 0);
5182 if (tdecl == NULL_TREE)
5184 __ptmd_desc_type_node = TREE_TYPE (tdecl);
5188 /* Make a definition for a builtin function named NAME and whose data type
5189 is TYPE. TYPE should be a function type with argument types.
5190 FUNCTION_CODE tells later passes how to compile calls to this function.
5191 See tree.h for its possible values.
5193 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
5194 the name to be called if we can't opencode the function. */
5197 define_function (name, type, function_code, pfn, library_name)
5200 enum built_in_function function_code;
5204 tree decl = build_lang_decl (FUNCTION_DECL, get_identifier (name), type);
5205 DECL_EXTERNAL (decl) = 1;
5206 TREE_PUBLIC (decl) = 1;
5207 DECL_INTERFACE_KNOWN (decl) = 1;
5209 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
5210 we cannot change DECL_ASSEMBLER_NAME until we have installed this
5211 function in the namespace. */
5212 if (pfn) (*pfn) (decl);
5214 DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
5215 make_function_rtl (decl);
5216 if (function_code != NOT_BUILT_IN)
5218 DECL_BUILT_IN (decl) = 1;
5219 DECL_FUNCTION_CODE (decl) = function_code;
5224 /* Called when a declaration is seen that contains no names to declare.
5225 If its type is a reference to a structure, union or enum inherited
5226 from a containing scope, shadow that tag name for the current scope
5227 with a forward reference.
5228 If its type defines a new named structure or union
5229 or defines an enum, it is valid but we need not do anything here.
5230 Otherwise, it is an error.
5232 C++: may have to grok the declspecs to learn about static,
5233 complain for anonymous unions. */
5236 shadow_tag (declspecs)
5240 tree ob_modifier = NULL_TREE;
5242 register enum tree_code code, ok_code = ERROR_MARK;
5243 register tree t = NULL_TREE;
5245 for (link = declspecs; link; link = TREE_CHAIN (link))
5247 register tree value = TREE_VALUE (link);
5249 code = TREE_CODE (value);
5250 if (IS_AGGR_TYPE_CODE (code) || code == ENUMERAL_TYPE)
5252 my_friendly_assert (TYPE_NAME (value) != NULL_TREE, 261);
5254 if (code == ENUMERAL_TYPE && TYPE_SIZE (value) == 0)
5255 cp_error ("forward declaration of `%#T'", value);
5261 else if (value == ridpointers[(int) RID_STATIC]
5262 || value == ridpointers[(int) RID_EXTERN]
5263 || value == ridpointers[(int) RID_AUTO]
5264 || value == ridpointers[(int) RID_REGISTER]
5265 || value == ridpointers[(int) RID_INLINE]
5266 || value == ridpointers[(int) RID_VIRTUAL]
5267 || value == ridpointers[(int) RID_EXPLICIT])
5268 ob_modifier = value;
5271 /* This is where the variables in an anonymous union are
5272 declared. An anonymous union declaration looks like:
5274 because there is no declarator after the union, the parser
5275 sends that declaration here. */
5276 if (ok_code == UNION_TYPE
5278 && ((TREE_CODE (TYPE_NAME (t)) == IDENTIFIER_NODE
5279 && ANON_AGGRNAME_P (TYPE_NAME (t)))
5280 || (TREE_CODE (TYPE_NAME (t)) == TYPE_DECL
5281 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))))
5283 /* ANSI C++ June 5 1992 WP 9.5.3. Anonymous unions may not have
5284 function members. */
5285 if (TYPE_FIELDS (t))
5287 tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
5289 finish_anon_union (decl);
5292 error ("anonymous union cannot have a function member");
5296 /* Anonymous unions are objects, that's why we only check for
5297 inappropriate specifiers in this branch. */
5301 if (ob_modifier == ridpointers[(int) RID_INLINE]
5302 || ob_modifier == ridpointers[(int) RID_VIRTUAL])
5303 cp_error ("`%D' can only be specified for functions", ob_modifier);
5304 else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
5305 cp_error ("`%D' can only be specified for constructors",
5308 cp_error ("`%D' can only be specified for objects and functions",
5313 pedwarn ("abstract declarator used as declaration");
5314 else if (found_tag > 1)
5315 pedwarn ("multiple types in one declaration");
5319 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
5322 groktypename (typename)
5325 if (TREE_CODE (typename) != TREE_LIST)
5327 return grokdeclarator (TREE_VALUE (typename),
5328 TREE_PURPOSE (typename),
5329 TYPENAME, 0, NULL_TREE);
5332 /* Decode a declarator in an ordinary declaration or data definition.
5333 This is called as soon as the type information and variable name
5334 have been parsed, before parsing the initializer if any.
5335 Here we create the ..._DECL node, fill in its type,
5336 and put it on the list of decls for the current context.
5337 The ..._DECL node is returned as the value.
5339 Exception: for arrays where the length is not specified,
5340 the type is left null, to be filled in by `finish_decl'.
5342 Function definitions do not come here; they go to start_function
5343 instead. However, external and forward declarations of functions
5344 do go through here. Structure field declarations are done by
5345 grokfield and not through here. */
5347 /* Set this to zero to debug not using the temporary obstack
5348 to parse initializers. */
5349 int debug_temp_inits = 1;
5352 start_decl (declarator, declspecs, initialized, raises)
5353 tree declarator, declspecs;
5358 register tree type, tem;
5360 extern int have_extern_spec;
5361 extern int used_extern_spec;
5363 int init_written = initialized;
5365 /* This should only be done once on the top most decl. */
5366 if (have_extern_spec && !used_extern_spec)
5368 declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
5370 used_extern_spec = 1;
5373 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized, raises);
5374 if (decl == NULL_TREE || decl == void_type_node)
5377 type = TREE_TYPE (decl);
5379 /* Don't lose if destructors must be executed at file-level. */
5380 if (TREE_STATIC (decl)
5381 && TYPE_NEEDS_DESTRUCTOR (type)
5382 && !TREE_PERMANENT (decl))
5384 push_obstacks (&permanent_obstack, &permanent_obstack);
5385 decl = copy_node (decl);
5386 if (TREE_CODE (type) == ARRAY_TYPE)
5388 tree itype = TYPE_DOMAIN (type);
5389 if (itype && ! TREE_PERMANENT (itype))
5391 itype = build_index_type (copy_to_permanent (TYPE_MAX_VALUE (itype)));
5392 type = build_cplus_array_type (TREE_TYPE (type), itype);
5393 TREE_TYPE (decl) = type;
5399 /* Corresponding pop_obstacks is done in `finish_decl'. */
5400 push_obstacks_nochange ();
5403 = (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
5404 ? DECL_CLASS_CONTEXT (decl)
5405 : DECL_CONTEXT (decl);
5407 if (processing_template_decl)
5410 if (TREE_CODE (decl) == FUNCTION_DECL)
5412 /* Declarator is a call_expr; extract arguments from it, since
5413 grokdeclarator didn't do it. */
5415 args = copy_to_permanent (last_function_parms);
5416 if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
5418 tree t = TREE_TYPE (decl);
5420 t = TYPE_METHOD_BASETYPE (t); /* type method belongs to */
5421 if (TREE_CODE (t) != UNINSTANTIATED_P_TYPE)
5423 t = build_pointer_type (t); /* base type of `this' */
5425 /* I suspect this is wrong. */
5426 t = build_type_variant (t, flag_this_is_variable <= 0,
5427 0); /* type of `this' */
5429 t = build_type_variant (t, 0, 0); /* type of `this' */
5431 t = build (PARM_DECL, t, this_identifier);
5432 TREE_CHAIN (t) = args;
5436 DECL_ARGUMENTS (decl) = args;
5438 d = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), TREE_TYPE (decl));
5439 TREE_PUBLIC (d) = TREE_PUBLIC (decl);
5440 TREE_STATIC (d) = TREE_STATIC (decl);
5441 DECL_EXTERNAL (d) = (DECL_EXTERNAL (decl)
5442 && !(context && !DECL_THIS_EXTERN (decl)));
5443 DECL_TEMPLATE_RESULT (d) = decl;
5447 /* If this type of object needs a cleanup, and control may
5448 jump past it, make a new binding level so that it is cleaned
5449 up only when it is initialized first. */
5450 if (TYPE_NEEDS_DESTRUCTOR (type)
5451 && current_binding_level->more_cleanups_ok == 0)
5452 pushlevel_temporary (1);
5455 /* Is it valid for this decl to have an initializer at all?
5456 If not, set INITIALIZED to zero, which will indirectly
5457 tell `finish_decl' to ignore the initializer once it is parsed. */
5458 switch (TREE_CODE (decl))
5461 /* typedef foo = bar means give foo the same type as bar.
5462 We haven't parsed bar yet, so `finish_decl' will fix that up.
5463 Any other case of an initialization in a TYPE_DECL is an error. */
5464 if (pedantic || list_length (declspecs) > 1)
5466 cp_error ("typedef `%D' is initialized", decl);
5472 cp_error ("function `%#D' is initialized like a variable", decl);
5477 /* Don't allow initializations for incomplete types except for
5478 arrays which might be completed by the initialization. */
5479 if (type == error_mark_node)
5480 ; /* Don't complain again. */
5481 else if (TYPE_SIZE (type) != NULL_TREE)
5482 ; /* A complete type is ok. */
5483 else if (TREE_CODE (type) != ARRAY_TYPE)
5485 cp_error ("variable `%#D' has initializer but incomplete type",
5489 else if (TYPE_SIZE (TREE_TYPE (type)) == NULL_TREE)
5491 cp_error ("elements of array `%#D' have incomplete type", decl);
5497 && TREE_CODE (decl) != TYPE_DECL
5498 && TREE_CODE (decl) != TEMPLATE_DECL
5499 && IS_AGGR_TYPE (type) && ! DECL_EXTERNAL (decl))
5501 if (TYPE_SIZE (type) == NULL_TREE)
5503 cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
5505 /* Change the type so that assemble_variable will give
5506 DECL an rtl we can live with: (mem (const_int 0)). */
5507 TREE_TYPE (decl) = error_mark_node;
5508 type = error_mark_node;
5512 /* If any base type in the hierarchy of TYPE needs a constructor,
5513 then we set initialized to 1. This way any nodes which are
5514 created for the purposes of initializing this aggregate
5515 will live as long as it does. This is necessary for global
5516 aggregates which do not have their initializers processed until
5517 the end of the file. */
5518 initialized = TYPE_NEEDS_CONSTRUCTING (type);
5524 if (current_binding_level != global_binding_level
5525 && DECL_EXTERNAL (decl))
5526 cp_warning ("declaration of `%#D' has `extern' and is initialized",
5528 DECL_EXTERNAL (decl) = 0;
5529 if (current_binding_level == global_binding_level)
5530 TREE_STATIC (decl) = 1;
5532 /* Tell `pushdecl' this is an initialized decl
5533 even though we don't yet have the initializer expression.
5534 Also tell `finish_decl' it may store the real initializer. */
5535 DECL_INITIAL (decl) = error_mark_node;
5538 if (context && TYPE_SIZE (context) != NULL_TREE)
5540 if (TREE_CODE (decl) == VAR_DECL)
5542 tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
5543 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
5544 cp_error ("`%#D' is not a static member of `%#T'", decl, context);
5545 else if (duplicate_decls (decl, field))
5549 /* If it was not explicitly declared `extern',
5550 revoke any previous claims of DECL_EXTERNAL. */
5551 if (DECL_THIS_EXTERN (decl) == 0)
5552 DECL_EXTERNAL (decl) = 0;
5553 if (DECL_LANG_SPECIFIC (decl))
5554 DECL_IN_AGGR_P (decl) = 0;
5555 pushclass (context, 2);
5558 /* Add this decl to the current binding level, but not if it
5559 comes from another scope, e.g. a static member variable.
5560 TEM may equal DECL or it may be a previous decl of the same name. */
5562 if ((TREE_CODE (decl) != PARM_DECL && DECL_CONTEXT (decl) != NULL_TREE)
5563 || (TREE_CODE (decl) == TEMPLATE_DECL && !global_bindings_p ())
5564 || TREE_CODE (type) == LANG_TYPE)
5567 tem = pushdecl (decl);
5569 /* Tell the back-end to use or not use .common as appropriate. If we say
5570 -fconserve-space, we want this to save space, at the expense of wrong
5571 semantics. If we say -fno-conserve-space, we want this to produce
5572 errors about redefs; to do this we force variables into the data
5573 segment. Common storage is okay for non-public uninitialized data;
5574 the linker can't match it with storage from other files, and we may
5575 save some disk space. */
5576 DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
5579 /* We don't do this yet for GNU C++. */
5580 /* For a local variable, define the RTL now. */
5581 if (current_binding_level != global_binding_level
5582 /* But not if this is a duplicate decl
5583 and we preserved the rtl from the previous one
5584 (which may or may not happen). */
5585 && DECL_RTL (tem) == NULL_RTX)
5587 if (TYPE_SIZE (TREE_TYPE (tem)) != NULL_TREE)
5589 else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
5590 && DECL_INITIAL (tem) != NULL_TREE)
5595 if (TREE_CODE (decl) == TEMPLATE_DECL)
5597 tree result = DECL_TEMPLATE_RESULT (decl);
5598 if (DECL_CONTEXT (result) != NULL_TREE)
5601 type = DECL_CONTEXT (result);
5603 if (TREE_CODE (type) != UNINSTANTIATED_P_TYPE)
5605 cp_error ("declaration of `%D' in non-template type `%T'",
5610 if (TREE_CODE (result) == FUNCTION_DECL)
5612 else if (TREE_CODE (result) == VAR_DECL)
5615 tree tmpl = UPT_TEMPLATE (type);
5617 fprintf (stderr, "%s:%d: adding ", __FILE__, __LINE__);
5618 print_node_brief (stderr, "", DECL_NAME (tem), 0);
5619 fprintf (stderr, " to class %s\n",
5620 IDENTIFIER_POINTER (DECL_NAME (tmpl)));
5621 DECL_TEMPLATE_MEMBERS (tmpl)
5622 = perm_tree_cons (DECL_NAME (tem), tem,
5623 DECL_TEMPLATE_MEMBERS (tmpl));
5626 sorry ("static data member templates");
5631 my_friendly_abort (13);
5633 else if (TREE_CODE (result) == FUNCTION_DECL)
5634 /*tem = push_overloaded_decl (tem, 0)*/;
5635 else if (TREE_CODE (result) == VAR_DECL)
5637 cp_error ("data template `%#D' must be member of a class template",
5641 else if (TREE_CODE (result) == TYPE_DECL)
5643 cp_error ("invalid template `%#D'", result);
5647 my_friendly_abort (14);
5651 && ! (TREE_CODE (tem) == PARM_DECL
5652 || (TREE_READONLY (tem)
5653 && (TREE_CODE (tem) == VAR_DECL
5654 || TREE_CODE (tem) == FIELD_DECL))))
5656 /* When parsing and digesting the initializer,
5657 use temporary storage. Do this even if we will ignore the value. */
5658 if (current_binding_level == global_binding_level && debug_temp_inits)
5660 if (TYPE_NEEDS_CONSTRUCTING (type)
5661 || TREE_CODE (type) == REFERENCE_TYPE)
5662 /* In this case, the initializer must lay down in permanent
5663 storage, since it will be saved until `finish_file' is run. */
5666 temporary_allocation ();
5671 cadillac_start_decl (tem);
5678 make_temporary_for_reference (decl, ctor_call, init, cleanupp)
5679 tree decl, ctor_call, init;
5682 tree type = TREE_TYPE (decl);
5683 tree target_type = TREE_TYPE (type);
5688 tmp_addr = TREE_VALUE (TREE_OPERAND (ctor_call, 1));
5689 if (TREE_CODE (tmp_addr) == NOP_EXPR)
5690 tmp_addr = TREE_OPERAND (tmp_addr, 0);
5691 my_friendly_assert (TREE_CODE (tmp_addr) == ADDR_EXPR, 146);
5692 tmp = TREE_OPERAND (tmp_addr, 0);
5696 tmp = get_temp_name (target_type,
5697 current_binding_level == global_binding_level);
5698 tmp_addr = build_unary_op (ADDR_EXPR, tmp, 0);
5701 TREE_TYPE (tmp_addr) = build_pointer_type (target_type);
5702 DECL_INITIAL (decl) = convert (TYPE_POINTER_TO (target_type), tmp_addr);
5703 TREE_TYPE (DECL_INITIAL (decl)) = type;
5704 if (TYPE_NEEDS_CONSTRUCTING (target_type))
5706 if (current_binding_level == global_binding_level)
5708 /* lay this variable out now. Otherwise `output_addressed_constants'
5709 gets confused by its initializer. */
5710 make_decl_rtl (tmp, NULL_PTR, 1);
5711 static_aggregates = perm_tree_cons (init, tmp, static_aggregates);
5715 if (ctor_call != NULL_TREE)
5718 init = build_method_call (tmp, constructor_name_full (target_type),
5719 build_tree_list (NULL_TREE, init),
5720 NULL_TREE, LOOKUP_NORMAL);
5721 DECL_INITIAL (decl) = build (COMPOUND_EXPR, type, init,
5722 DECL_INITIAL (decl));
5723 *cleanupp = maybe_build_cleanup (tmp);
5728 DECL_INITIAL (tmp) = init;
5729 TREE_STATIC (tmp) = current_binding_level == global_binding_level;
5730 finish_decl (tmp, init, NULL_TREE, 0, LOOKUP_ONLYCONVERTING);
5732 if (TREE_STATIC (tmp))
5733 preserve_initializer ();
5737 /* Handle initialization of references.
5738 These three arguments from from `finish_decl', and have the
5739 same meaning here that they do there. */
5740 /* quotes on semantics can be found in ARM 8.4.3. */
5742 grok_reference_init (decl, type, init, cleanupp)
5743 tree decl, type, init;
5748 if (init == NULL_TREE)
5750 if ((DECL_LANG_SPECIFIC (decl) == 0
5751 || DECL_IN_AGGR_P (decl) == 0)
5752 && ! DECL_THIS_EXTERN (decl))
5754 cp_error ("`%D' declared as reference but not initialized", decl);
5755 if (TREE_CODE (decl) == VAR_DECL)
5756 SET_DECL_REFERENCE_SLOT (decl, error_mark_node);
5761 if (init == error_mark_node)
5764 if (TREE_CODE (type) == REFERENCE_TYPE
5765 && TREE_CODE (init) == CONSTRUCTOR)
5767 cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl);
5771 if (TREE_CODE (init) == TREE_LIST)
5772 init = build_compound_expr (init);
5774 if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
5775 init = convert_from_reference (init);
5777 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
5778 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
5780 /* Note: default conversion is only called in very special cases. */
5781 init = default_conversion (init);
5784 tmp = convert_to_reference
5785 (type, init, CONV_IMPLICIT, LOOKUP_SPECULATIVELY|LOOKUP_NORMAL, decl);
5787 if (tmp == error_mark_node)
5789 else if (tmp != NULL_TREE)
5791 tree subtype = TREE_TYPE (type);
5794 /* Associate the cleanup with the reference so that we
5795 don't get burned by "aggressive" cleanup policy. */
5796 if (TYPE_NEEDS_DESTRUCTOR (subtype))
5798 if (TREE_CODE (init) == WITH_CLEANUP_EXPR)
5800 *cleanupp = TREE_OPERAND (init, 2);
5801 TREE_OPERAND (init, 2) = error_mark_node;
5805 if (TREE_CODE (tmp) == ADDR_EXPR)
5806 tmp = TREE_OPERAND (tmp, 0);
5807 if (TREE_CODE (tmp) == TARGET_EXPR)
5809 *cleanupp = build_delete
5810 (TYPE_POINTER_TO (subtype),
5811 build_unary_op (ADDR_EXPR, TREE_OPERAND (tmp, 0), 0),
5812 integer_two_node, LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0);
5813 TREE_OPERAND (tmp, 2) = error_mark_node;
5818 DECL_INITIAL (decl) = save_expr (init);
5822 cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
5826 /* ?? Can this be optimized in some cases to
5827 hand back the DECL_INITIAL slot?? */
5828 if (TYPE_SIZE (TREE_TYPE (type)))
5830 init = convert_from_reference (decl);
5831 if (TREE_PERMANENT (decl))
5832 init = copy_to_permanent (init);
5833 SET_DECL_REFERENCE_SLOT (decl, init);
5836 if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
5838 expand_static_init (decl, DECL_INITIAL (decl));
5839 DECL_INITIAL (decl) = NULL_TREE;
5844 if (TREE_CODE (decl) == VAR_DECL)
5845 SET_DECL_REFERENCE_SLOT (decl, error_mark_node);
5849 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
5850 mucking with forces it does not comprehend (i.e. initialization with a
5851 constructor). If we are at global scope and won't go into COMMON, fill
5852 it in with a dummy CONSTRUCTOR to force the variable into .data;
5853 otherwise we can use error_mark_node. */
5856 obscure_complex_init (decl, init)
5859 if (! flag_no_inline && TREE_STATIC (decl))
5861 if (extract_init (decl, init))
5865 if (current_binding_level == global_binding_level
5866 && ! DECL_COMMON (decl))
5867 DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
5870 DECL_INITIAL (decl) = error_mark_node;
5875 /* Finish processing of a declaration;
5876 install its line number and initial value.
5877 If the length of an array type is not known before,
5878 it must be determined now, from the initial value, or it is an error.
5880 Call `pop_obstacks' iff NEED_POP is nonzero.
5882 For C++, `finish_decl' must be fairly evasive: it must keep initializers
5883 for aggregates that have constructors alive on the permanent obstack,
5884 so that the global initializing functions can be written at the end.
5886 INIT0 holds the value of an initializer that should be allowed to escape
5889 FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
5890 if the (init) syntax was used.
5892 For functions that take default parameters, DECL points to its
5893 "maximal" instantiation. `finish_decl' must then also declared its
5894 subsequently lower and lower forms of instantiation, checking for
5895 ambiguity as it goes. This can be sped up later. */
5898 finish_decl (decl, init, asmspec_tree, need_pop, flags)
5905 tree cleanup = NULL_TREE, ttype;
5907 int temporary = allocation_temporary_p ();
5908 char *asmspec = NULL;
5909 int was_readonly = 0;
5911 /* If this is 0, then we did not change obstacks. */
5915 error ("assignment (not initialization) in declaration");
5919 /* If a name was specified, get the string. */
5921 asmspec = TREE_STRING_POINTER (asmspec_tree);
5923 /* If the type of the thing we are declaring either has
5924 a constructor, or has a virtual function table pointer,
5925 AND its initialization was accepted by `start_decl',
5926 then we stayed on the permanent obstack through the
5927 declaration, otherwise, changed obstacks as GCC would. */
5929 type = TREE_TYPE (decl);
5931 if (type == error_mark_node)
5933 if (current_binding_level == global_binding_level && temporary)
5934 end_temporary_allocation ();
5939 was_incomplete = (DECL_SIZE (decl) == NULL_TREE);
5941 /* Take care of TYPE_DECLs up front. */
5942 if (TREE_CODE (decl) == TYPE_DECL)
5944 if (init && DECL_INITIAL (decl))
5946 /* typedef foo = bar; store the type of bar as the type of foo. */
5947 TREE_TYPE (decl) = type = TREE_TYPE (init);
5948 DECL_INITIAL (decl) = init = NULL_TREE;
5950 if (type != error_mark_node
5951 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
5953 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
5954 cp_warning ("shadowing previous type declaration of `%#D'", decl);
5955 set_identifier_type_value (DECL_NAME (decl), type);
5956 CLASSTYPE_GOT_SEMICOLON (type) = 1;
5958 GNU_xref_decl (current_function_decl, decl);
5959 rest_of_decl_compilation (decl, NULL_PTR,
5960 DECL_CONTEXT (decl) == NULL_TREE, 0);
5963 if (TREE_CODE (decl) != FUNCTION_DECL)
5965 ttype = target_type (type);
5967 Leave this out until we can figure out why it was
5968 needed/desirable in the first place. Then put a comment
5969 here explaining why. Or just delete the code if no ill
5971 if (TYPE_NAME (ttype)
5972 && TREE_CODE (TYPE_NAME (ttype)) == TYPE_DECL
5973 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (ttype)))
5975 tree old_id = TYPE_IDENTIFIER (ttype);
5976 char *newname = (char *)alloca (IDENTIFIER_LENGTH (old_id) + 2);
5977 /* Need to preserve template data for UPT nodes. */
5978 tree old_template = IDENTIFIER_TEMPLATE (old_id);
5980 bcopy (IDENTIFIER_POINTER (old_id), newname + 1,
5981 IDENTIFIER_LENGTH (old_id) + 1);
5982 old_id = get_identifier (newname);
5983 lookup_tag_reverse (ttype, old_id);
5984 TYPE_IDENTIFIER (ttype) = old_id;
5985 IDENTIFIER_TEMPLATE (old_id) = old_template;
5990 if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
5991 && TYPE_NEEDS_CONSTRUCTING (type))
5994 /* Currently, GNU C++ puts constants in text space, making them
5995 impossible to initialize. In the future, one would hope for
5996 an operating system which understood the difference between
5997 initialization and the running of a program. */
5999 TREE_READONLY (decl) = 0;
6002 if (TREE_CODE (decl) == FIELD_DECL)
6004 if (init && init != error_mark_node)
6005 my_friendly_assert (TREE_PERMANENT (init), 147);
6009 /* This must override the asm specifier which was placed
6010 by grokclassfn. Lay this out fresh. */
6011 DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
6012 DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
6013 make_decl_rtl (decl, asmspec, 0);
6016 /* If `start_decl' didn't like having an initialization, ignore it now. */
6017 else if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
6019 else if (DECL_EXTERNAL (decl))
6021 else if (TREE_CODE (type) == REFERENCE_TYPE
6022 || (TYPE_LANG_SPECIFIC (type) && IS_SIGNATURE_REFERENCE (type)))
6024 if (TREE_STATIC (decl))
6025 make_decl_rtl (decl, NULL_PTR,
6026 current_binding_level == global_binding_level
6027 || pseudo_global_level_p ());
6028 grok_reference_init (decl, type, init, &cleanup);
6032 GNU_xref_decl (current_function_decl, decl);
6034 if (TREE_CODE (decl) == FIELD_DECL)
6036 else if (TREE_CODE (decl) == CONST_DECL)
6038 my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
6040 DECL_INITIAL (decl) = init;
6042 /* This will keep us from needing to worry about our obstacks. */
6043 my_friendly_assert (init != NULL_TREE, 149);
6048 if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
6050 if (TREE_CODE (type) == ARRAY_TYPE)
6051 init = digest_init (type, init, (tree *) 0);
6052 else if (TREE_CODE (init) == CONSTRUCTOR)
6054 if (TYPE_NEEDS_CONSTRUCTING (type))
6056 cp_error ("`%D' must be initialized by constructor, not by `{...}'",
6058 init = error_mark_node;
6061 goto dont_use_constructor;
6064 /* fix this in `build_functional_cast' instead.
6065 Here's the trigger code:
6070 ostream (int, char *);
6077 int buf_size = 1024;
6078 static char buf[buf_size];
6079 const char *debug(int i) {
6081 ostream o = ostream(buf_size, b);
6087 else if (TREE_CODE (init) == TARGET_EXPR
6088 && TREE_CODE (TREE_OPERAND (init, 1) == NEW_EXPR))
6090 /* User wrote something like `foo x = foo (args)' */
6091 my_friendly_assert (TREE_CODE (TREE_OPERAND (init, 0)) == VAR_DECL, 150);
6092 my_friendly_assert (DECL_NAME (TREE_OPERAND (init, 0)) == NULL_TREE, 151);
6094 /* User wrote exactly `foo x = foo (args)' */
6095 if (TYPE_MAIN_VARIANT (type) == TREE_TYPE (init))
6097 init = build (CALL_EXPR, TREE_TYPE (init),
6098 TREE_OPERAND (TREE_OPERAND (init, 1), 0),
6099 TREE_OPERAND (TREE_OPERAND (init, 1), 1), 0);
6100 TREE_SIDE_EFFECTS (init) = 1;
6107 dont_use_constructor:
6108 if (TREE_CODE (init) != TREE_VEC)
6109 init = store_init_value (decl, init);
6113 /* We must hide the initializer so that expand_decl
6114 won't try to do something it does not understand. */
6115 init = obscure_complex_init (decl, init);
6117 else if (DECL_EXTERNAL (decl))
6119 else if (TREE_CODE_CLASS (TREE_CODE (type)) == 't'
6120 && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
6123 while (TREE_CODE (ctype) == ARRAY_TYPE)
6124 ctype = TREE_TYPE (ctype);
6125 if (! TYPE_NEEDS_CONSTRUCTING (ctype))
6127 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (ctype))
6128 cp_error ("structure `%D' with uninitialized const members", decl);
6129 if (CLASSTYPE_REF_FIELDS_NEED_INIT (ctype))
6130 cp_error ("structure `%D' with uninitialized reference members",
6134 if (TREE_CODE (decl) == VAR_DECL
6135 && !DECL_INITIAL (decl)
6136 && !TYPE_NEEDS_CONSTRUCTING (type)
6137 && (TYPE_READONLY (type) || TREE_READONLY (decl)))
6138 cp_error ("uninitialized const `%D'", decl);
6140 if (TYPE_SIZE (type) != NULL_TREE
6141 && TYPE_NEEDS_CONSTRUCTING (type))
6142 init = obscure_complex_init (decl, NULL_TREE);
6144 else if (TREE_CODE (decl) == VAR_DECL
6145 && TREE_CODE (type) != REFERENCE_TYPE
6146 && (TYPE_READONLY (type) || TREE_READONLY (decl)))
6148 /* ``Unless explicitly declared extern, a const object does not have
6149 external linkage and must be initialized. ($8.4; $12.1)'' ARM 7.1.6
6150 However, if it's `const int foo = 1; const int foo;', don't complain
6151 about the second decl, since it does have an initializer before.
6152 We deliberately don't complain about arrays, because they're
6153 supposed to be initialized by a constructor. */
6154 if (! DECL_INITIAL (decl)
6155 && TREE_CODE (type) != ARRAY_TYPE
6156 && (!pedantic || !current_class_type))
6157 cp_error ("uninitialized const `%#D'", decl);
6160 /* For top-level declaration, the initial value was read in
6161 the temporary obstack. MAXINDEX, rtl, etc. to be made below
6162 must go in the permanent obstack; but don't discard the
6163 temporary data yet. */
6165 if (current_binding_level == global_binding_level && temporary)
6166 end_temporary_allocation ();
6168 /* Deduce size of array from initialization, if not already known. */
6170 if (TREE_CODE (type) == ARRAY_TYPE
6171 && TYPE_DOMAIN (type) == NULL_TREE
6172 && TREE_CODE (decl) != TYPE_DECL)
6175 = (TREE_STATIC (decl)
6176 /* Even if pedantic, an external linkage array
6177 may have incomplete type at first. */
6178 ? pedantic && ! DECL_EXTERNAL (decl)
6179 : !DECL_EXTERNAL (decl));
6180 tree initializer = init ? init : DECL_INITIAL (decl);
6181 int failure = complete_array_type (type, initializer, do_default);
6184 cp_error ("initializer fails to determine size of `%D'", decl);
6189 cp_error ("array size missing in `%D'", decl);
6190 /* If a `static' var's size isn't known, make it extern as
6191 well as static, so it does not get allocated. If it's not
6192 `static', then don't mark it extern; finish_incomplete_decl
6193 will give it a default size and it will get allocated. */
6194 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
6195 DECL_EXTERNAL (decl) = 1;
6198 if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
6199 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
6201 cp_error ("zero-size array `%D'", decl);
6203 layout_decl (decl, 0);
6206 if (TREE_CODE (decl) == VAR_DECL)
6208 if (DECL_SIZE (decl) == NULL_TREE
6209 && TYPE_SIZE (TREE_TYPE (decl)) != NULL_TREE)
6210 layout_decl (decl, 0);
6212 if (TREE_STATIC (decl) && DECL_SIZE (decl) == NULL_TREE)
6214 /* A static variable with an incomplete type:
6215 that is an error if it is initialized.
6216 Otherwise, let it through, but if it is not `extern'
6217 then it may cause an error message later. */
6218 if (DECL_INITIAL (decl) != NULL_TREE)
6219 cp_error ("storage size of `%D' isn't known", decl);
6222 else if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
6224 /* An automatic variable with an incomplete type: that is an error.
6225 Don't talk about array types here, since we took care of that
6226 message in grokdeclarator. */
6227 cp_error ("storage size of `%D' isn't known", decl);
6228 TREE_TYPE (decl) = error_mark_node;
6230 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
6231 /* Let debugger know it should output info for this type. */
6232 note_debug_info_needed (ttype);
6234 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
6235 && DECL_SIZE (decl) != NULL_TREE
6236 && ! TREE_CONSTANT (DECL_SIZE (decl)))
6238 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
6239 constant_expression_warning (DECL_SIZE (decl));
6241 cp_error ("storage size of `%D' isn't constant", decl);
6244 if (!DECL_EXTERNAL (decl) && TYPE_NEEDS_DESTRUCTOR (type))
6246 int yes = suspend_momentary ();
6248 /* If INIT comes from a functional cast, use the cleanup
6249 we built for that. Otherwise, make our own cleanup. */
6250 if (init && TREE_CODE (init) == WITH_CLEANUP_EXPR
6251 && comptypes (TREE_TYPE (decl), TREE_TYPE (init), 1))
6253 cleanup = TREE_OPERAND (init, 2);
6254 init = TREE_OPERAND (init, 0);
6255 current_binding_level->have_cleanups = 1;
6258 cleanup = maybe_build_cleanup (decl);
6259 resume_momentary (yes);
6262 /* PARM_DECLs get cleanups, too. */
6263 else if (TREE_CODE (decl) == PARM_DECL && TYPE_NEEDS_DESTRUCTOR (type))
6266 end_temporary_allocation ();
6267 cleanup = maybe_build_cleanup (decl);
6269 resume_temporary_allocation ();
6272 /* Output the assembler code and/or RTL code for variables and functions,
6273 unless the type is an undefined structure or union.
6274 If not, it will get done when the type is completed. */
6276 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
6277 || TREE_CODE (decl) == RESULT_DECL)
6279 /* ??? FIXME: What about nested classes? */
6280 int toplev = (current_binding_level == global_binding_level
6281 || pseudo_global_level_p ());
6283 = ((flag_traditional
6284 || (TREE_STATIC (decl) && TYPE_NEEDS_DESTRUCTOR (type)))
6285 && allocation_temporary_p ());
6288 end_temporary_allocation ();
6290 if (TREE_CODE (decl) == VAR_DECL
6291 && current_binding_level != global_binding_level
6292 && ! TREE_STATIC (decl)
6293 && type_needs_gc_entry (type))
6294 DECL_GC_OFFSET (decl) = size_int (++current_function_obstack_index);
6296 if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
6297 make_decl_rtl (decl, NULL_PTR, toplev);
6298 else if (TREE_CODE (decl) == VAR_DECL
6299 && TREE_READONLY (decl)
6300 && DECL_INITIAL (decl) != NULL_TREE
6301 && DECL_INITIAL (decl) != error_mark_node
6302 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
6304 DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
6307 DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
6310 && TREE_STATIC (decl)
6311 && ! TREE_SIDE_EFFECTS (decl)
6312 && ! TREE_PUBLIC (decl)
6313 && ! DECL_EXTERNAL (decl)
6314 && ! TYPE_NEEDS_DESTRUCTOR (type)
6315 && DECL_MODE (decl) != BLKmode)
6317 /* If this variable is really a constant, then fill its DECL_RTL
6318 slot with something which won't take up storage.
6319 If something later should take its address, we can always give
6320 it legitimate RTL at that time. */
6321 DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
6322 store_expr (DECL_INITIAL (decl), DECL_RTL (decl), 0);
6323 TREE_ASM_WRITTEN (decl) = 1;
6325 else if (toplev && ! TREE_PUBLIC (decl))
6327 /* If this is a static const, change its apparent linkage
6328 if it belongs to a #pragma interface. */
6329 if (!interface_unknown)
6331 TREE_PUBLIC (decl) = 1;
6332 DECL_EXTERNAL (decl) = interface_only;
6334 make_decl_rtl (decl, asmspec, toplev);
6337 rest_of_decl_compilation (decl, asmspec, toplev, 0);
6339 else if (TREE_CODE (decl) == VAR_DECL
6340 && DECL_LANG_SPECIFIC (decl)
6341 && DECL_IN_AGGR_P (decl))
6343 if (TREE_STATIC (decl))
6345 if (init == NULL_TREE
6346 #ifdef DEFAULT_STATIC_DEFS
6347 /* If this code is dead, then users must
6348 explicitly declare static member variables
6349 outside the class def'n as well. */
6350 && TYPE_NEEDS_CONSTRUCTING (type)
6354 DECL_EXTERNAL (decl) = 1;
6355 make_decl_rtl (decl, asmspec, 1);
6358 rest_of_decl_compilation (decl, asmspec, toplev, 0);
6361 /* Just a constant field. Should not need any rtl. */
6365 rest_of_decl_compilation (decl, asmspec, toplev, 0);
6368 resume_temporary_allocation ();
6370 if (type != error_mark_node
6371 && TYPE_LANG_SPECIFIC (type)
6372 && CLASSTYPE_ABSTRACT_VIRTUALS (type))
6373 abstract_virtuals_error (decl, type);
6374 else if ((TREE_CODE (type) == FUNCTION_TYPE
6375 || TREE_CODE (type) == METHOD_TYPE)
6376 && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
6377 && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (type)))
6378 abstract_virtuals_error (decl, TREE_TYPE (type));
6380 if (TYPE_LANG_SPECIFIC (type) && IS_SIGNATURE (type))
6381 signature_error (decl, type);
6382 else if ((TREE_CODE (type) == FUNCTION_TYPE
6383 || TREE_CODE (type) == METHOD_TYPE)
6384 && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
6385 && IS_SIGNATURE (TREE_TYPE (type)))
6386 signature_error (decl, TREE_TYPE (type));
6388 if (TREE_CODE (decl) == FUNCTION_DECL)
6390 else if (DECL_EXTERNAL (decl))
6392 else if (TREE_STATIC (decl) && type != error_mark_node)
6394 /* Cleanups for static variables are handled by `finish_file'. */
6395 if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE)
6396 expand_static_init (decl, init);
6397 else if (TYPE_NEEDS_DESTRUCTOR (type))
6398 static_aggregates = perm_tree_cons (NULL_TREE, decl,
6401 /* Make entry in appropriate vector. */
6402 if (flag_gc && type_needs_gc_entry (type))
6403 build_static_gc_entry (decl, type);
6407 tree old_cleanups = cleanups_this_call;
6408 /* This is a declared decl which must live until the
6409 end of the binding contour. It may need a cleanup. */
6411 /* Recompute the RTL of a local array now
6412 if it used to be an incomplete type. */
6413 if (was_incomplete && ! TREE_STATIC (decl))
6415 /* If we used it already as memory, it must stay in memory. */
6416 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
6417 /* If it's still incomplete now, no init will save it. */
6418 if (DECL_SIZE (decl) == NULL_TREE)
6419 DECL_INITIAL (decl) = NULL_TREE;
6422 else if (! TREE_ASM_WRITTEN (decl)
6423 && (TYPE_SIZE (type) != NULL_TREE
6424 || TREE_CODE (type) == ARRAY_TYPE))
6426 /* Do this here, because we did not expand this decl's
6427 rtl in start_decl. */
6428 if (DECL_RTL (decl) == NULL_RTX)
6432 /* XXX: Why don't we use decl here? */
6433 /* Ans: Because it was already expanded? */
6434 if (! expand_decl_cleanup (NULL_TREE, cleanup))
6435 cp_error ("parser lost in parsing declaration of `%D'",
6437 /* Cleanup used up here. */
6438 cleanup = NULL_TREE;
6442 if (DECL_SIZE (decl) && type != error_mark_node)
6444 /* Compute and store the initial value. */
6445 expand_decl_init (decl);
6447 if (init || TYPE_NEEDS_CONSTRUCTING (type))
6449 emit_line_note (DECL_SOURCE_FILE (decl),
6450 DECL_SOURCE_LINE (decl));
6451 expand_aggr_init (decl, init, 0, flags);
6454 /* Set this to 0 so we can tell whether an aggregate which
6455 was initialized was ever used. Don't do this if it has a
6456 destructor, so we don't complain about the 'resource
6457 allocation is initialization' idiom. */
6458 if (TYPE_NEEDS_CONSTRUCTING (type) && cleanup == NULL_TREE)
6459 TREE_USED (decl) = 0;
6461 /* Store the cleanup, if there was one. */
6464 if (! expand_decl_cleanup (decl, cleanup))
6465 cp_error ("parser lost in parsing declaration of `%D'",
6469 /* Cleanup any temporaries needed for the initial value. */
6470 expand_cleanups_to (old_cleanups);
6474 /* Undo call to `pushclass' that was done in `start_decl'
6475 due to initialization of qualified member variable.
6476 I.e., Foo::x = 10; */
6478 tree context = DECL_CONTEXT (decl);
6480 && TREE_CODE_CLASS (TREE_CODE (context)) == 't'
6481 && (TREE_CODE (decl) == VAR_DECL
6482 /* We also have a pushclass done that we need to undo here
6483 if we're at top level and declare a method. */
6484 || (TREE_CODE (decl) == FUNCTION_DECL
6485 /* If size hasn't been set, we're still defining it,
6486 and therefore inside the class body; don't pop
6487 the binding level.. */
6488 && TYPE_SIZE (context) != NULL_TREE
6489 /* The binding level gets popped elsewhere for a
6490 friend declaration inside another class. */
6492 && TYPE_IDENTIFIER (context) == current_class_name
6494 && context == current_class_type
6502 /* If requested, warn about definitions of large data objects. */
6504 if (warn_larger_than
6505 && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
6506 && !DECL_EXTERNAL (decl))
6508 register tree decl_size = DECL_SIZE (decl);
6510 if (decl_size && TREE_CODE (decl_size) == INTEGER_CST)
6512 unsigned units = TREE_INT_CST_LOW (decl_size) / BITS_PER_UNIT;
6514 if (units > larger_than_size)
6515 warning_with_decl (decl, "size of `%s' is %u bytes", units);
6521 /* Resume permanent allocation, if not within a function. */
6522 /* The corresponding push_obstacks_nochange is in start_decl,
6523 start_method, groktypename, and in grokfield. */
6528 TREE_READONLY (decl) = 1;
6531 cadillac_finish_decl (decl);
6535 expand_static_init (decl, init)
6539 tree oldstatic = value_member (decl, static_aggregates);
6544 if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
6545 cp_error ("multiple initializations given for `%D'", decl);
6547 else if (current_binding_level != global_binding_level
6548 && current_binding_level->pseudo_global == 0)
6550 /* Emit code to perform this initialization but once. */
6553 /* Remember this information until end of file. */
6554 push_obstacks (&permanent_obstack, &permanent_obstack);
6556 /* Emit code to perform this initialization but once. */
6557 temp = get_temp_name (integer_type_node, 1);
6558 rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
6559 expand_start_cond (build_binary_op (EQ_EXPR, temp,
6560 integer_zero_node, 1), 0);
6561 old_cleanups = cleanups_this_call;
6562 expand_assignment (temp, integer_one_node, 0, 0);
6563 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
6564 || TREE_CODE (init) == TREE_LIST)
6566 expand_aggr_init (decl, init, 0, 0);
6567 do_pending_stack_adjust ();
6570 expand_assignment (decl, init, 0, 0);
6571 /* Cleanup any temporaries needed for the initial value. */
6572 expand_cleanups_to (old_cleanups);
6574 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
6576 static_aggregates = perm_tree_cons (temp, decl, static_aggregates);
6577 TREE_STATIC (static_aggregates) = 1;
6580 /* Resume old (possibly temporary) allocation. */
6585 /* This code takes into account memory allocation
6586 policy of `start_decl'. Namely, if TYPE_NEEDS_CONSTRUCTING
6587 does not hold for this object, then we must make permanent
6588 the storage currently in the temporary obstack. */
6589 if (! TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
6590 preserve_initializer ();
6591 static_aggregates = perm_tree_cons (init, decl, static_aggregates);
6595 /* Make TYPE a complete type based on INITIAL_VALUE.
6596 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6597 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
6600 complete_array_type (type, initial_value, do_default)
6601 tree type, initial_value;
6604 register tree maxindex = NULL_TREE;
6609 /* Note MAXINDEX is really the maximum index,
6610 one less than the size. */
6611 if (TREE_CODE (initial_value) == STRING_CST)
6614 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
6615 maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
6618 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
6620 tree elts = CONSTRUCTOR_ELTS (initial_value);
6621 maxindex = size_binop (MINUS_EXPR, integer_zero_node, size_one_node);
6622 for (; elts; elts = TREE_CHAIN (elts))
6624 if (TREE_PURPOSE (elts))
6625 maxindex = TREE_PURPOSE (elts);
6627 maxindex = size_binop (PLUS_EXPR, maxindex, size_one_node);
6629 maxindex = copy_node (maxindex);
6633 /* Make an error message unless that happened already. */
6634 if (initial_value != error_mark_node)
6637 /* Prevent further error messages. */
6638 maxindex = build_int_2 (0, 0);
6645 maxindex = build_int_2 (0, 0);
6653 TYPE_DOMAIN (type) = build_index_type (maxindex);
6654 if (!TREE_TYPE (maxindex))
6655 TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
6657 itype = TREE_TYPE (initial_value);
6660 if (itype && !TYPE_DOMAIN (itype))
6661 TYPE_DOMAIN (itype) = TYPE_DOMAIN (type);
6664 /* Lay out the type now that we can get the real answer. */
6671 /* Return zero if something is declared to be a member of type
6672 CTYPE when in the context of CUR_TYPE. STRING is the error
6673 message to print in that case. Otherwise, quietly return 1. */
6675 member_function_or_else (ctype, cur_type, string)
6676 tree ctype, cur_type;
6679 if (ctype && ctype != cur_type)
6681 error (string, TYPE_NAME_STRING (ctype));
6687 /* Subroutine of `grokdeclarator'. */
6689 /* Generate errors possibly applicable for a given set of specifiers.
6690 This is for ARM $7.1.2. */
6692 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
6695 int virtualp, quals, friendp, raises, inlinep;
6698 cp_error ("`%D' declared as a `virtual' %s", object, type);
6700 cp_error ("`%D' declared as an `inline' %s", object, type);
6702 cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
6705 cp_error_at ("invalid friend declaration", object);
6707 cp_error_at ("invalid exception specifications", object);
6710 /* CTYPE is class type, or null if non-class.
6711 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
6713 DECLARATOR is the function's name.
6714 VIRTUALP is truthvalue of whether the function is virtual or not.
6715 FLAGS are to be passed through to `grokclassfn'.
6716 QUALS are qualifiers indicating whether the function is `const'
6718 RAISES is a list of exceptions that this function can raise.
6719 CHECK is 1 if we must find this method in CTYPE, 0 if we should
6720 not look, and -1 if we should not call `grokclassfn' at all. */
6722 grokfndecl (ctype, type, declarator, virtualp, flags, quals,
6723 raises, check, publicp, inlinep)
6727 enum overload_flags flags;
6729 int check, publicp, inlinep;
6732 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
6735 cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
6736 ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
6742 type = build_exception_variant (ctype, type, raises);
6743 raises = TYPE_RAISES_EXCEPTIONS (type);
6745 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
6746 /* propagate volatile out from type to decl */
6747 if (TYPE_VOLATILE (type))
6748 TREE_THIS_VOLATILE (decl) = 1;
6750 /* Should probably propagate const out from type to decl I bet (mrs). */
6753 DECL_STATIC_FUNCTION_P (decl) = 1;
6754 DECL_CONTEXT (decl) = ctype;
6755 DECL_CLASS_CONTEXT (decl) = ctype;
6758 /* All function decls start out public; we'll fix their linkage later (at
6759 definition or EOF) if appropriate. */
6760 TREE_PUBLIC (decl) = 1;
6762 if (ctype == NULL_TREE && ! strcmp (IDENTIFIER_POINTER (declarator), "main"))
6765 error ("cannot declare `main' to be inline");
6767 error ("cannot declare `main' to be static");
6773 DECL_C_STATIC (decl) = 1;
6776 DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
6778 DECL_EXTERNAL (decl) = 1;
6779 if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
6781 cp_error ("%smember function `%D' cannot have `%T' method qualifier",
6782 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
6786 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
6787 grok_op_properties (decl, virtualp, check < 0);
6789 /* Caller will do the rest of this. */
6793 if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
6796 /* Just handle constructors here. We could do this
6797 inside the following if stmt, but I think
6798 that the code is more legible by breaking this
6799 case out. See comments below for what each of
6800 the following calls is supposed to do. */
6801 DECL_CONSTRUCTOR_P (decl) = 1;
6803 grokclassfn (ctype, declarator, decl, flags, quals);
6805 check_classfn (ctype, declarator, decl);
6806 if (! grok_ctor_properties (ctype, decl))
6809 if (check == 0 && ! current_function_decl)
6811 /* FIXME: this should only need to look at
6812 IDENTIFIER_GLOBAL_VALUE. */
6813 tmp = lookup_name (DECL_ASSEMBLER_NAME (decl), 0);
6814 if (tmp == NULL_TREE)
6815 IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl)) = decl;
6816 else if (TREE_CODE (tmp) != TREE_CODE (decl))
6817 cp_error ("inconsistent declarations for `%D'", decl);
6820 duplicate_decls (decl, tmp);
6822 /* avoid creating circularities. */
6823 DECL_CHAIN (decl) = NULL_TREE;
6825 make_decl_rtl (decl, NULL_PTR, 1);
6832 /* Function gets the ugly name, field gets the nice one.
6833 This call may change the type of the function (because
6834 of default parameters)! */
6835 if (ctype != NULL_TREE)
6836 grokclassfn (ctype, cname, decl, flags, quals);
6838 if (ctype != NULL_TREE && check)
6839 check_classfn (ctype, cname, decl);
6841 if (ctype == NULL_TREE || check)
6844 /* Now install the declaration of this function so that others may
6845 find it (esp. its DECL_FRIENDLIST). Don't do this for local class
6847 if (! current_function_decl)
6849 /* FIXME: this should only need to look at
6850 IDENTIFIER_GLOBAL_VALUE. */
6851 tmp = lookup_name (DECL_ASSEMBLER_NAME (decl), 0);
6852 if (tmp == NULL_TREE)
6853 IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl)) = decl;
6854 else if (TREE_CODE (tmp) != TREE_CODE (decl))
6855 cp_error ("inconsistent declarations for `%D'", decl);
6858 duplicate_decls (decl, tmp);
6860 /* avoid creating circularities. */
6861 DECL_CHAIN (decl) = NULL_TREE;
6863 make_decl_rtl (decl, NULL_PTR, 1);
6866 /* If this declaration supersedes the declaration of
6867 a method declared virtual in the base class, then
6868 mark this field as being virtual as well. */
6870 tree binfos = BINFO_BASETYPES (TYPE_BINFO (ctype));
6871 int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
6873 for (i = 0; i < n_baselinks; i++)
6875 tree base_binfo = TREE_VEC_ELT (binfos, i);
6876 if (TYPE_VIRTUAL_P (BINFO_TYPE (base_binfo))
6877 || flag_all_virtual == 1)
6879 tmp = get_matching_virtual (base_binfo, decl,
6880 flags == DTOR_FLAG);
6883 /* If this function overrides some virtual in some base
6884 class, then the function itself is also necessarily
6885 virtual, even if the user didn't explicitly say so. */
6886 DECL_VIRTUAL_P (decl) = 1;
6888 /* The TMP we really want is the one from the deepest
6889 baseclass on this path, taking care not to
6890 duplicate if we have already found it (via another
6891 path to its virtual baseclass. */
6894 cp_error ("method `%D' may not be declared static",
6896 cp_error_at ("(since `%D' declared virtual in base class.)",
6903 /* The argument types may have changed... */
6904 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
6905 tree base_variant = TREE_TYPE (TREE_VALUE (argtypes));
6907 argtypes = commonparms (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (tmp))),
6908 TREE_CHAIN (argtypes));
6909 /* But the return type has not. */
6910 type = build_cplus_method_type (base_variant, TREE_TYPE (type), argtypes);
6913 type = build_exception_variant (ctype, type, raises);
6914 raises = TYPE_RAISES_EXCEPTIONS (type);
6916 TREE_TYPE (decl) = type;
6918 = tree_cons (NULL_TREE, tmp, DECL_VINDEX (decl));
6927 if (DECL_VINDEX (decl) == NULL_TREE)
6928 DECL_VINDEX (decl) = error_mark_node;
6929 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
6930 if (ctype && CLASSTYPE_VTABLE_NEEDS_WRITING (ctype)
6931 /* If this function is derived from a template, don't
6932 make it public. This shouldn't be here, but there's
6933 no good way to override the interface pragmas for one
6934 function or class only. Bletch. */
6935 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (ctype)) == NULL_TREE
6936 && (write_virtuals == 2
6937 || (write_virtuals == 3
6938 && CLASSTYPE_INTERFACE_KNOWN (ctype))))
6939 TREE_PUBLIC (decl) = 1;
6946 grokvardecl (type, declarator, specbits, initialized)
6949 RID_BIT_TYPE specbits;
6954 if (TREE_CODE (type) == OFFSET_TYPE)
6956 /* If you declare a static member so that it
6957 can be initialized, the code will reach here. */
6958 tree basetype = TYPE_OFFSET_BASETYPE (type);
6959 type = TREE_TYPE (type);
6960 decl = build_lang_field_decl (VAR_DECL, declarator, type);
6961 DECL_CONTEXT (decl) = basetype;
6962 DECL_CLASS_CONTEXT (decl) = basetype;
6963 DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
6966 decl = build_decl (VAR_DECL, declarator, type);
6968 DECL_ASSEMBLER_NAME (decl) = current_namespace_id (DECL_ASSEMBLER_NAME (decl));
6970 if (RIDBIT_SETP (RID_EXTERN, specbits))
6972 DECL_THIS_EXTERN (decl) = 1;
6973 DECL_EXTERNAL (decl) = !initialized;
6976 /* In class context, static means one per class,
6977 public access, and static storage. */
6978 if (DECL_FIELD_CONTEXT (decl) != NULL_TREE
6979 && IS_AGGR_TYPE (DECL_FIELD_CONTEXT (decl)))
6981 TREE_PUBLIC (decl) = 1;
6982 TREE_STATIC (decl) = 1;
6983 DECL_EXTERNAL (decl) = 0;
6985 /* At top level, either `static' or no s.c. makes a definition
6986 (perhaps tentative), and absence of `static' makes it public. */
6987 else if (current_binding_level == global_binding_level)
6989 TREE_PUBLIC (decl) = RIDBIT_NOTSETP (RID_STATIC, specbits);
6990 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
6992 /* Not at top level, only `static' makes a static definition. */
6995 TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
6996 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
7001 /* Create a canonical pointer to member function type. */
7004 build_ptrmemfunc_type (type)
7011 /* If a canonical type already exists for this type, use it. We use
7012 this method instead of type_hash_canon, because it only does a
7013 simple equality check on the list of field members. */
7015 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
7018 push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
7020 u = make_lang_type (UNION_TYPE);
7021 fields[0] = build_lang_field_decl (FIELD_DECL, pfn_identifier, type);
7022 fields[1] = build_lang_field_decl (FIELD_DECL, delta2_identifier,
7024 finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
7025 TYPE_NAME (u) = NULL_TREE;
7027 t = make_lang_type (RECORD_TYPE);
7029 /* Let the front-end know this is a pointer to member function. */
7030 TYPE_PTRMEMFUNC_FLAG (t) = 1;
7031 /* and not really an aggregate. */
7032 IS_AGGR_TYPE (t) = 0;
7034 fields[0] = build_lang_field_decl (FIELD_DECL, delta_identifier,
7036 fields[1] = build_lang_field_decl (FIELD_DECL, index_identifier,
7038 fields[2] = build_lang_field_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
7039 finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
7043 /* Zap out the name so that the back-end will give us the debugging
7044 information for this anonymous RECORD_TYPE. */
7045 TYPE_NAME (t) = NULL_TREE;
7047 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
7049 /* Seems to be wanted. */
7050 CLASSTYPE_GOT_SEMICOLON (t) = 1;
7054 /* Given declspecs and a declarator,
7055 determine the name and type of the object declared
7056 and construct a ..._DECL node for it.
7057 (In one case we can return a ..._TYPE node instead.
7058 For invalid input we sometimes return 0.)
7060 DECLSPECS is a chain of tree_list nodes whose value fields
7061 are the storage classes and type specifiers.
7063 DECL_CONTEXT says which syntactic context this declaration is in:
7064 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
7065 FUNCDEF for a function definition. Like NORMAL but a few different
7066 error messages in each case. Return value may be zero meaning
7067 this definition is too screwy to try to parse.
7068 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
7069 handle member functions (which have FIELD context).
7070 Return value may be zero meaning this definition is too screwy to
7072 PARM for a parameter declaration (either within a function prototype
7073 or before a function body). Make a PARM_DECL, or return void_type_node.
7074 CATCHPARM for a parameter declaration before a catch clause.
7075 TYPENAME if for a typename (in a cast or sizeof).
7076 Don't make a DECL node; just return the ..._TYPE node.
7077 FIELD for a struct or union field; make a FIELD_DECL.
7078 BITFIELD for a field with specified width.
7079 INITIALIZED is 1 if the decl has an initializer.
7081 In the TYPENAME case, DECLARATOR is really an absolute declarator.
7082 It may also be so in the PARM case, for a prototype where the
7083 argument type is specified but not the name.
7085 This function is where the complicated C meanings of `static'
7086 and `extern' are interpreted.
7088 For C++, if there is any monkey business to do, the function which
7089 calls this one must do it, i.e., prepending instance variables,
7090 renaming overloaded function names, etc.
7092 Note that for this C++, it is an error to define a method within a class
7093 which does not belong to that class.
7095 Except in the case where SCOPE_REFs are implicitly known (such as
7096 methods within a class being redundantly qualified),
7097 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
7098 (class_name::decl_name). The caller must also deal with this.
7100 If a constructor or destructor is seen, and the context is FIELD,
7101 then the type gains the attribute TREE_HAS_x. If such a declaration
7102 is erroneous, NULL_TREE is returned.
7104 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
7105 function, these are the qualifiers to give to the `this' pointer.
7107 May return void_type_node if the declarator turned out to be a friend.
7108 See grokfield for details. */
7110 enum return_types { return_normal, return_ctor, return_dtor, return_conversion };
7113 grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
7116 enum decl_context decl_context;
7120 RID_BIT_TYPE specbits;
7123 tree type = NULL_TREE;
7127 int virtualp, explicitp, friendp, inlinep, staticp;
7128 int explicit_int = 0;
7129 int explicit_char = 0;
7130 int opaque_typedef = 0;
7131 tree typedef_decl = NULL_TREE;
7133 tree typedef_type = NULL_TREE;
7134 int funcdef_flag = 0;
7135 enum tree_code innermost_code = ERROR_MARK;
7137 int size_varies = 0;
7138 tree decl_machine_attr = NULL_TREE;
7139 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
7140 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
7141 tree init = NULL_TREE;
7143 /* Keep track of what sort of function is being processed
7144 so that we can warn about default return values, or explicit
7145 return values which do not match prescribed defaults. */
7146 enum return_types return_type = return_normal;
7148 tree dname = NULL_TREE;
7149 tree ctype = current_class_type;
7150 tree ctor_return_type = NULL_TREE;
7151 enum overload_flags flags = NO_SPECIAL;
7152 tree quals = NULL_TREE;
7154 RIDBIT_RESET_ALL (specbits);
7155 if (decl_context == FUNCDEF)
7156 funcdef_flag = 1, decl_context = NORMAL;
7157 else if (decl_context == MEMFUNCDEF)
7158 funcdef_flag = -1, decl_context = FIELD;
7159 else if (decl_context == BITFIELD)
7160 bitfield = 1, decl_context = FIELD;
7162 if (flag_traditional && allocation_temporary_p ())
7163 end_temporary_allocation ();
7165 /* Look inside a declarator for the name being declared
7166 and get it as a string, for an error message. */
7168 tree last = NULL_TREE;
7169 register tree decl = declarator;
7173 switch (TREE_CODE (decl))
7177 decl = TREE_OPERAND (decl, 0);
7180 case BIT_NOT_EXPR: /* for C++ destructors! */
7182 tree name = TREE_OPERAND (decl, 0);
7183 tree rename = NULL_TREE;
7185 my_friendly_assert (flags == NO_SPECIAL, 152);
7187 return_type = return_dtor;
7188 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
7189 if (ctype == NULL_TREE)
7191 if (current_class_type == NULL_TREE)
7193 error ("destructors must be member functions");
7198 tree t = constructor_name (current_class_name);
7205 tree t = constructor_name (ctype);
7212 error ("destructor `%s' must match class name `%s'",
7213 IDENTIFIER_POINTER (name),
7214 IDENTIFIER_POINTER (rename));
7215 TREE_OPERAND (decl, 0) = rename;
7221 case ADDR_EXPR: /* C++ reference declaration */
7226 innermost_code = TREE_CODE (decl);
7228 decl = TREE_OPERAND (decl, 0);
7232 if (parmlist_is_exprlist (TREE_OPERAND (decl, 1)))
7234 /* This is actually a variable declaration using constructor
7235 syntax. We need to call start_decl and finish_decl so we
7236 can get the variable initialized... */
7239 /* We need to insinuate ourselves into the declarator in place
7240 of the CALL_EXPR. */
7241 TREE_OPERAND (last, 0) = TREE_OPERAND (decl, 0);
7243 declarator = TREE_OPERAND (decl, 0);
7245 init = TREE_OPERAND (decl, 1);
7247 decl = start_decl (declarator, declspecs, 1, NULL_TREE);
7248 finish_decl (decl, init, NULL_TREE, 1, 0);
7251 innermost_code = TREE_CODE (decl);
7252 if (decl_context == FIELD && ctype == NULL_TREE)
7253 ctype = current_class_type;
7255 && TREE_OPERAND (decl, 0) == constructor_name_full (ctype))
7256 TREE_OPERAND (decl, 0) = constructor_name (ctype);
7257 decl = TREE_OPERAND (decl, 0);
7258 if (ctype != NULL_TREE
7259 && decl != NULL_TREE && flags != DTOR_FLAG
7260 && decl == constructor_name (ctype))
7262 return_type = return_ctor;
7263 ctor_return_type = ctype;
7268 case IDENTIFIER_NODE:
7272 if (! IDENTIFIER_OPNAME_P (dname)
7273 /* Linux headers use '__op'. Arrgh. */
7274 || IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname))
7275 name = IDENTIFIER_POINTER (dname);
7278 if (IDENTIFIER_TYPENAME_P (dname))
7280 my_friendly_assert (flags == NO_SPECIAL, 154);
7281 flags = TYPENAME_FLAG;
7282 ctor_return_type = TREE_TYPE (dname);
7283 return_type = return_conversion;
7285 name = operator_name_string (dname);
7292 /* Parse error puts this typespec where
7293 a declarator should go. */
7294 error ("declarator name missing");
7295 dname = TYPE_NAME (decl);
7296 if (dname && TREE_CODE (dname) == TYPE_DECL)
7297 dname = DECL_NAME (dname);
7298 name = dname ? IDENTIFIER_POINTER (dname) : "<nameless>";
7299 declspecs = temp_tree_cons (NULL_TREE, decl, declspecs);
7306 /* Perform error checking, and convert class names to types.
7307 We may call grokdeclarator multiple times for the same
7308 tree structure, so only do the conversion once. In this
7309 case, we have exactly what we want for `ctype'. */
7310 tree cname = TREE_OPERAND (decl, 0);
7311 if (cname == NULL_TREE)
7313 /* Can't use IS_AGGR_TYPE because CNAME might not be a type. */
7314 else if (IS_AGGR_TYPE_CODE (TREE_CODE (cname))
7315 || TREE_CODE (cname) == UNINSTANTIATED_P_TYPE)
7317 else if (! is_aggr_typedef (cname, 1))
7319 TREE_OPERAND (decl, 0) = NULL_TREE;
7321 /* Must test TREE_OPERAND (decl, 1), in case user gives
7322 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
7323 else if (TREE_OPERAND (decl, 1)
7324 && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
7326 TREE_OPERAND (decl, 0) = IDENTIFIER_TYPE_VALUE (cname);
7328 else if (ctype == NULL_TREE)
7330 ctype = IDENTIFIER_TYPE_VALUE (cname);
7331 TREE_OPERAND (decl, 0) = ctype;
7333 else if (TREE_COMPLEXITY (decl) == current_class_depth)
7334 TREE_OPERAND (decl, 0) = ctype;
7337 if (! UNIQUELY_DERIVED_FROM_P (IDENTIFIER_TYPE_VALUE (cname),
7340 cp_error ("type `%T' is not derived from type `%T'",
7341 IDENTIFIER_TYPE_VALUE (cname), ctype);
7342 TREE_OPERAND (decl, 0) = NULL_TREE;
7346 ctype = IDENTIFIER_TYPE_VALUE (cname);
7347 TREE_OPERAND (decl, 0) = ctype;
7352 && TREE_OPERAND (decl, 1) == constructor_name_full (ctype))
7353 TREE_OPERAND (decl, 1) = constructor_name (ctype);
7354 decl = TREE_OPERAND (decl, 1);
7357 if (TREE_CODE (decl) == IDENTIFIER_NODE
7358 && constructor_name (ctype) == decl)
7360 return_type = return_ctor;
7361 ctor_return_type = ctype;
7363 else if (TREE_CODE (decl) == BIT_NOT_EXPR
7364 && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
7365 && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
7366 || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
7368 return_type = return_dtor;
7369 ctor_return_type = ctype;
7371 decl = TREE_OPERAND (decl, 0) = constructor_name (ctype);
7382 return 0; /* We used to do a 155 abort here. */
7388 /* A function definition's declarator must have the form of
7389 a function declarator. */
7391 if (funcdef_flag && innermost_code != CALL_EXPR)
7394 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
7395 && innermost_code != CALL_EXPR
7396 && ! (ctype && declspecs == NULL_TREE))
7398 cp_error ("declaration of `%D' as non-function", dname);
7399 return void_type_node;
7402 /* Anything declared one level down from the top level
7403 must be one of the parameters of a function
7404 (because the body is at least two levels down). */
7406 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
7407 by not allowing C++ class definitions to specify their parameters
7408 with xdecls (must be spec.d in the parmlist).
7410 Since we now wait to push a class scope until we are sure that
7411 we are in a legitimate method context, we must set oldcname
7412 explicitly (since current_class_name is not yet alive). */
7414 if (decl_context == NORMAL
7415 && current_binding_level->level_chain == global_binding_level)
7416 decl_context = PARM;
7418 /* Look through the decl specs and record which ones appear.
7419 Some typespecs are defined as built-in typenames.
7420 Others, the ones that are modifiers of other types,
7421 are represented by bits in SPECBITS: set the bits for
7422 the modifiers that appear. Storage class keywords are also in SPECBITS.
7424 If there is a typedef name or a type, store the type in TYPE.
7425 This includes builtin typedefs such as `int'.
7427 Set EXPLICIT_INT if the type is `int' or `char' and did not
7428 come from a user typedef.
7430 Set LONGLONG if `long' is mentioned twice.
7432 For C++, constructors and destructors have their own fast treatment. */
7434 for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
7439 /* Certain parse errors slip through. For example,
7440 `int class;' is not caught by the parser. Try
7441 weakly to recover here. */
7442 if (TREE_CODE (spec) != TREE_LIST)
7445 id = TREE_VALUE (spec);
7447 if (TREE_CODE (id) == IDENTIFIER_NODE)
7449 if (id == ridpointers[(int) RID_INT]
7450 || id == ridpointers[(int) RID_CHAR]
7451 || id == ridpointers[(int) RID_BOOL]
7452 || id == ridpointers[(int) RID_WCHAR])
7456 if (id == ridpointers[(int) RID_BOOL])
7457 error ("`bool' is now a keyword");
7459 cp_error ("extraneous `%T' ignored", id);
7463 if (id == ridpointers[(int) RID_INT])
7465 else if (id == ridpointers[(int) RID_CHAR])
7467 type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
7471 /* C++ aggregate types. */
7472 if (IDENTIFIER_HAS_TYPE_VALUE (id))
7475 cp_error ("multiple declarations `%T' and `%T'", type, id);
7477 type = IDENTIFIER_TYPE_VALUE (id);
7481 for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
7483 if (ridpointers[i] == id)
7485 if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
7487 if (pedantic && ! in_system_header)
7488 pedwarn ("ANSI C++ does not support `long long'");
7490 error ("`long long long' is too long for GCC");
7494 else if (RIDBIT_SETP (i, specbits))
7495 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
7496 RIDBIT_SET (i, specbits);
7502 error ("two or more data types in declaration of `%s'", name);
7503 else if (TREE_CODE (id) == IDENTIFIER_NODE)
7505 register tree t = lookup_name (id, 1);
7506 if (!t || TREE_CODE (t) != TYPE_DECL)
7507 error ("`%s' fails to be a typedef or built in type",
7508 IDENTIFIER_POINTER (id));
7511 type = TREE_TYPE (t);
7512 decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
7516 else if (TREE_CODE (id) != ERROR_MARK)
7517 /* Can't change CLASS nodes into RECORD nodes here! */
7523 typedef_type = type;
7525 /* No type at all: default to `int', and set EXPLICIT_INT
7526 because it was not a user-defined typedef.
7527 Except when we have a `typedef' inside a signature, in
7528 which case the type defaults to `unknown type' and is
7529 instantiated when assigning to a signature pointer or ref. */
7531 if (type == NULL_TREE
7532 && (RIDBIT_SETP (RID_SIGNED, specbits)
7533 || RIDBIT_SETP (RID_UNSIGNED, specbits)
7534 || RIDBIT_SETP (RID_LONG, specbits)
7535 || RIDBIT_SETP (RID_SHORT, specbits)))
7537 /* These imply 'int'. */
7538 type = integer_type_node;
7542 if (type == NULL_TREE)
7545 if (return_type == return_dtor)
7546 type = void_type_node;
7547 else if (return_type == return_ctor)
7548 type = TYPE_POINTER_TO (ctor_return_type);
7549 else if (return_type == return_conversion)
7550 type = ctor_return_type;
7551 else if (current_class_type
7552 && IS_SIGNATURE (current_class_type)
7553 && (RIDBIT_SETP (RID_TYPEDEF, specbits)
7554 || SIGNATURE_GROKKING_TYPEDEF (current_class_type))
7555 && (decl_context == FIELD || decl_context == NORMAL))
7559 type = copy_node (opaque_type_node);
7561 /* access declaration */
7562 else if (decl_context == FIELD && declarator
7563 && TREE_CODE (declarator) == SCOPE_REF)
7564 type = void_type_node;
7569 if (warn_return_type
7570 && return_type == return_normal)
7571 /* Save warning until we know what is really going on. */
7572 warn_about_return_type = 1;
7574 else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
7575 pedwarn ("ANSI C++ forbids typedef which does not specify a type");
7576 else if (declspecs == NULL_TREE &&
7577 (innermost_code != CALL_EXPR || pedantic))
7578 cp_pedwarn ("ANSI C++ forbids declaration `%D' with no type or storage class",
7580 type = integer_type_node;
7583 else if (return_type == return_dtor)
7585 error ("return type specification for destructor invalid");
7586 type = void_type_node;
7588 else if (return_type == return_ctor)
7590 error ("return type specification for constructor invalid");
7591 type = TYPE_POINTER_TO (ctor_return_type);
7593 else if (return_type == return_conversion)
7595 if (comptypes (type, ctor_return_type, 1) == 0)
7596 cp_error ("operator `%T' declared to return `%T'",
7597 ctor_return_type, type);
7599 cp_pedwarn ("return type specified for `operator %T'",
7602 type = ctor_return_type;
7604 /* Catch typedefs that only specify a type, like 'typedef int;'. */
7605 else if (RIDBIT_SETP (RID_TYPEDEF, specbits) && declarator == NULL_TREE)
7607 /* Template "this is a type" syntax; just ignore for now. */
7608 if (processing_template_defn)
7609 return void_type_node;
7614 /* Now process the modifiers that were specified
7615 and check for invalid combinations. */
7617 /* Long double is a special combination. */
7619 if (RIDBIT_SETP (RID_LONG, specbits)
7620 && TYPE_MAIN_VARIANT (type) == double_type_node)
7622 RIDBIT_RESET (RID_LONG, specbits);
7623 type = build_type_variant (long_double_type_node, TYPE_READONLY (type),
7624 TYPE_VOLATILE (type));
7627 /* Check all other uses of type modifiers. */
7629 if (RIDBIT_SETP (RID_UNSIGNED, specbits)
7630 || RIDBIT_SETP (RID_SIGNED, specbits)
7631 || RIDBIT_SETP (RID_LONG, specbits)
7632 || RIDBIT_SETP (RID_SHORT, specbits))
7636 if (TREE_CODE (type) == REAL_TYPE)
7637 error ("short, signed or unsigned invalid for `%s'", name);
7638 else if (TREE_CODE (type) != INTEGER_TYPE)
7639 error ("long, short, signed or unsigned invalid for `%s'", name);
7640 else if (RIDBIT_SETP (RID_LONG, specbits)
7641 && RIDBIT_SETP (RID_SHORT, specbits))
7642 error ("long and short specified together for `%s'", name);
7643 else if ((RIDBIT_SETP (RID_LONG, specbits)
7644 || RIDBIT_SETP (RID_SHORT, specbits))
7646 error ("long or short specified with char for `%s'", name);
7647 else if ((RIDBIT_SETP (RID_LONG, specbits)
7648 || RIDBIT_SETP (RID_SHORT, specbits))
7649 && TREE_CODE (type) == REAL_TYPE)
7650 error ("long or short specified with floating type for `%s'", name);
7651 else if (RIDBIT_SETP (RID_SIGNED, specbits)
7652 && RIDBIT_SETP (RID_UNSIGNED, specbits))
7653 error ("signed and unsigned given together for `%s'", name);
7657 if (!explicit_int && !explicit_char && pedantic)
7659 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
7661 if (flag_pedantic_errors)
7666 /* Discard the type modifiers if they are invalid. */
7669 RIDBIT_RESET (RID_UNSIGNED, specbits);
7670 RIDBIT_RESET (RID_SIGNED, specbits);
7671 RIDBIT_RESET (RID_LONG, specbits);
7672 RIDBIT_RESET (RID_SHORT, specbits);
7677 /* Decide whether an integer type is signed or not.
7678 Optionally treat bitfields as signed by default. */
7679 if (RIDBIT_SETP (RID_UNSIGNED, specbits)
7680 /* Traditionally, all bitfields are unsigned. */
7681 || (bitfield && flag_traditional)
7682 || (bitfield && ! flag_signed_bitfields
7683 && (explicit_int || explicit_char
7684 /* A typedef for plain `int' without `signed'
7685 can be controlled just like plain `int'. */
7686 || ! (typedef_decl != NULL_TREE
7687 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
7688 && TREE_CODE (type) != ENUMERAL_TYPE
7689 && RIDBIT_NOTSETP (RID_SIGNED, specbits)))
7692 type = long_long_unsigned_type_node;
7693 else if (RIDBIT_SETP (RID_LONG, specbits))
7694 type = long_unsigned_type_node;
7695 else if (RIDBIT_SETP (RID_SHORT, specbits))
7696 type = short_unsigned_type_node;
7697 else if (type == char_type_node)
7698 type = unsigned_char_type_node;
7699 else if (typedef_decl)
7700 type = unsigned_type (type);
7702 type = unsigned_type_node;
7704 else if (RIDBIT_SETP (RID_SIGNED, specbits)
7705 && type == char_type_node)
7706 type = signed_char_type_node;
7708 type = long_long_integer_type_node;
7709 else if (RIDBIT_SETP (RID_LONG, specbits))
7710 type = long_integer_type_node;
7711 else if (RIDBIT_SETP (RID_SHORT, specbits))
7712 type = short_integer_type_node;
7714 /* Set CONSTP if this declaration is `const', whether by
7715 explicit specification or via a typedef.
7716 Likewise for VOLATILEP. */
7718 constp = !! RIDBIT_SETP (RID_CONST, specbits) + TYPE_READONLY (type);
7719 volatilep = !! RIDBIT_SETP (RID_VOLATILE, specbits) + TYPE_VOLATILE (type);
7721 inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
7723 /* This sort of redundancy is blessed in a footnote to the Sep 94 WP. */
7725 warning ("duplicate `const'");
7727 warning ("duplicate `volatile'");
7729 virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
7730 RIDBIT_RESET (RID_VIRTUAL, specbits);
7731 explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
7732 RIDBIT_RESET (RID_EXPLICIT, specbits);
7734 if (RIDBIT_SETP (RID_STATIC, specbits))
7735 staticp = 1 + (decl_context == FIELD);
7737 if (virtualp && staticp == 2)
7739 cp_error ("member `%D' cannot be declared both virtual and static",
7743 friendp = RIDBIT_SETP (RID_FRIEND, specbits);
7744 RIDBIT_RESET (RID_FRIEND, specbits);
7746 if (RIDBIT_SETP (RID_MUTABLE, specbits))
7748 if (decl_context == PARM)
7750 error ("non-member `%s' cannot be declared `mutable'", name);
7751 RIDBIT_RESET (RID_MUTABLE, specbits);
7753 else if (friendp || decl_context == TYPENAME)
7755 error ("non-object member `%s' cannot be declared `mutable'", name);
7756 RIDBIT_RESET (RID_MUTABLE, specbits);
7760 error ("const `%s' cannot be declared `mutable'", name);
7761 RIDBIT_RESET (RID_MUTABLE, specbits);
7765 error ("static `%s' cannot be declared `mutable'", name);
7766 RIDBIT_RESET (RID_MUTABLE, specbits);
7769 if (RIDBIT_SETP (RID_TYPEDEF, specbits))
7771 error ("non-object member `%s' cannot be declared `mutable'", name);
7772 RIDBIT_RESET (RID_MUTABLE, specbits);
7774 /* Because local typedefs are parsed twice, we don't want this
7776 else if (decl_context != FIELD)
7778 error ("non-member `%s' cannot be declared `mutable'", name);
7779 RIDBIT_RESET (RID_MUTABLE, specbits);
7784 /* Warn if two storage classes are given. Default to `auto'. */
7786 if (RIDBIT_ANY_SET (specbits))
7788 if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
7789 if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
7790 if (decl_context == PARM && nclasses > 0)
7791 error ("storage class specifiers invalid in parameter declarations");
7792 if (RIDBIT_SETP (RID_TYPEDEF, specbits))
7794 if (decl_context == PARM)
7795 error ("typedef declaration invalid in parameter declaration");
7798 if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
7799 if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
7802 /* Give error if `virtual' is used outside of class declaration. */
7804 && (current_class_name == NULL_TREE || decl_context != FIELD))
7806 error ("virtual outside class declaration");
7809 if (current_class_name == NULL_TREE && RIDBIT_SETP (RID_MUTABLE, specbits))
7811 error ("only members can be declared mutable");
7812 RIDBIT_RESET (RID_MUTABLE, specbits);
7815 /* Static anonymous unions are dealt with here. */
7816 if (staticp && decl_context == TYPENAME
7817 && TREE_CODE (declspecs) == TREE_LIST
7818 && TREE_CODE (TREE_VALUE (declspecs)) == UNION_TYPE
7819 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (TREE_VALUE (declspecs))))
7820 decl_context = FIELD;
7822 /* Give error if `const,' `volatile,' `inline,' `friend,' or `virtual'
7823 is used in a signature member function declaration. */
7824 if (decl_context == FIELD
7825 && IS_SIGNATURE (current_class_type)
7826 && RIDBIT_NOTSETP(RID_TYPEDEF, specbits)
7827 && !SIGNATURE_GROKKING_TYPEDEF (current_class_type))
7831 error ("`const' specified for signature member function `%s'", name);
7836 error ("`volatile' specified for signature member function `%s'",
7842 error ("`inline' specified for signature member function `%s'", name);
7843 /* Later, we'll make signature member functions inline. */
7848 error ("`friend' declaration in signature definition");
7853 error ("`virtual' specified for signature member function `%s'",
7855 /* Later, we'll make signature member functions virtual. */
7860 /* Warn about storage classes that are invalid for certain
7861 kinds of declarations (parameters, typenames, etc.). */
7864 error ("multiple storage classes in declaration of `%s'", name);
7865 else if (decl_context != NORMAL && nclasses > 0)
7867 if ((decl_context == PARM || decl_context == CATCHPARM)
7868 && (RIDBIT_SETP (RID_REGISTER, specbits)
7869 || RIDBIT_SETP (RID_AUTO, specbits)))
7871 else if (decl_context == FIELD
7872 && RIDBIT_SETP (RID_TYPEDEF, specbits))
7874 /* Processing a typedef declaration nested within a class type
7876 register tree scanner;
7877 register tree previous_declspec;
7881 error ("typedef declaration includes an initializer");
7883 /* To process a class-local typedef declaration, we descend down
7884 the chain of declspecs looking for the `typedef' spec. When
7885 we find it, we replace it with `static', and then recursively
7886 call `grokdeclarator' with the original declarator and with
7887 the newly adjusted declspecs. This call should return a
7888 FIELD_DECL node with the TREE_TYPE (and other parts) set
7889 appropriately. We can then just change the TREE_CODE on that
7890 from FIELD_DECL to TYPE_DECL and we're done. */
7892 for (previous_declspec = NULL_TREE, scanner = declspecs;
7894 previous_declspec = scanner, scanner = TREE_CHAIN (scanner))
7896 if (TREE_VALUE (scanner) == ridpointers[(int) RID_TYPEDEF])
7900 if (previous_declspec)
7901 TREE_CHAIN (previous_declspec) = TREE_CHAIN (scanner);
7903 declspecs = TREE_CHAIN (scanner);
7905 declspecs = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC],
7908 /* In the recursive call to grokdeclarator we need to know
7909 whether we are working on a signature-local typedef. */
7910 if (IS_SIGNATURE (current_class_type))
7911 SIGNATURE_GROKKING_TYPEDEF (current_class_type) = 1;
7914 grokdeclarator (declarator, declspecs, FIELD, 0, NULL_TREE);
7916 if (previous_declspec)
7917 TREE_CHAIN (previous_declspec) = scanner;
7919 if (loc_typedecl != error_mark_node)
7921 register int i = sizeof (struct lang_decl_flags) / sizeof (int);
7924 TREE_SET_CODE (loc_typedecl, TYPE_DECL);
7925 /* This is the same field as DECL_ARGUMENTS, which is set for
7926 function typedefs by the above grokdeclarator. */
7927 DECL_NESTED_TYPENAME (loc_typedecl) = 0;
7929 pi = (int *) permalloc (sizeof (struct lang_decl_flags));
7932 DECL_LANG_SPECIFIC (loc_typedecl) = (struct lang_decl *) pi;
7935 if (IS_SIGNATURE (current_class_type))
7937 SIGNATURE_GROKKING_TYPEDEF (current_class_type) = 0;
7938 if (loc_typedecl != error_mark_node && opaque_typedef)
7939 SIGNATURE_HAS_OPAQUE_TYPEDECLS (current_class_type) = 1;
7942 return loc_typedecl;
7944 else if (decl_context == FIELD
7945 && (! IS_SIGNATURE (current_class_type)
7946 || SIGNATURE_GROKKING_TYPEDEF (current_class_type))
7947 /* C++ allows static class elements */
7948 && RIDBIT_SETP (RID_STATIC, specbits))
7949 /* C++ also allows inlines and signed and unsigned elements,
7950 but in those cases we don't come in here. */
7954 if (decl_context == FIELD)
7956 tree tmp = NULL_TREE;
7957 register int op = 0;
7961 tmp = TREE_OPERAND (declarator, 0);
7962 op = IDENTIFIER_OPNAME_P (tmp);
7964 error ("storage class specified for %s `%s'",
7965 IS_SIGNATURE (current_class_type)
7967 ? "signature member operator"
7968 : "signature member function")
7969 : (op ? "member operator" : "field"),
7970 op ? operator_name_string (tmp) : name);
7973 error (((decl_context == PARM || decl_context == CATCHPARM)
7974 ? "storage class specified for parameter `%s'"
7975 : "storage class specified for typename"), name);
7976 RIDBIT_RESET (RID_REGISTER, specbits);
7977 RIDBIT_RESET (RID_AUTO, specbits);
7978 RIDBIT_RESET (RID_EXTERN, specbits);
7980 if (decl_context == FIELD && IS_SIGNATURE (current_class_type))
7982 RIDBIT_RESET (RID_STATIC, specbits);
7987 else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
7989 if (current_binding_level == global_binding_level)
7991 /* It's common practice (and completely valid) to have a const
7992 be initialized and declared extern. */
7994 warning ("`%s' initialized and declared `extern'", name);
7997 error ("`%s' has both `extern' and initializer", name);
7999 else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
8000 && current_binding_level != global_binding_level)
8001 error ("nested function `%s' declared `extern'", name);
8002 else if (current_binding_level == global_binding_level)
8004 if (RIDBIT_SETP (RID_AUTO, specbits))
8005 error ("top-level declaration of `%s' specifies `auto'", name);
8007 if (RIDBIT_SETP (RID_REGISTER, specbits))
8008 error ("top-level declaration of `%s' specifies `register'", name);
8011 /* I'm not sure under what circumstances we should turn
8012 on the extern bit, and under what circumstances we should
8013 warn if other bits are turned on. */
8014 if (decl_context == NORMAL
8015 && RIDBIT_NOSETP (RID_EXTERN, specbits)
8016 && ! root_lang_context_p ())
8018 RIDBIT_SET (RID_EXTERN, specbits);
8023 /* Now figure out the structure of the declarator proper.
8024 Descend through it, creating more complex types, until we reach
8025 the declared identifier (or NULL_TREE, in an absolute declarator). */
8027 while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
8029 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
8030 an INDIRECT_REF (for *...),
8031 a CALL_EXPR (for ...(...)),
8032 an identifier (for the name being declared)
8033 or a null pointer (for the place in an absolute declarator
8034 where the name was omitted).
8035 For the last two cases, we have just exited the loop.
8037 For C++ it could also be
8038 a SCOPE_REF (for class :: ...). In this case, we have converted
8039 sensible names to types, and those are the values we use to
8040 qualify the member name.
8041 an ADDR_EXPR (for &...),
8042 a BIT_NOT_EXPR (for destructors)
8044 At this point, TYPE is the type of elements of an array,
8045 or for a function to return, or for a pointer to point to.
8046 After this sequence of ifs, TYPE is the type of the
8047 array or function or pointer, and DECLARATOR has had its
8048 outermost layer removed. */
8050 if (TREE_CODE (type) == ERROR_MARK)
8052 if (TREE_CODE (declarator) == SCOPE_REF)
8053 declarator = TREE_OPERAND (declarator, 1);
8055 declarator = TREE_OPERAND (declarator, 0);
8058 if (quals != NULL_TREE
8059 && (declarator == NULL_TREE
8060 || TREE_CODE (declarator) != SCOPE_REF))
8062 if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
8063 ctype = TYPE_METHOD_BASETYPE (type);
8064 if (ctype != NULL_TREE)
8066 #if 0 /* not yet, should get fixed properly later */
8067 tree dummy = make_type_decl (NULL_TREE, type);
8069 tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
8071 ctype = grok_method_quals (ctype, dummy, quals);
8072 type = TREE_TYPE (dummy);
8076 switch (TREE_CODE (declarator))
8080 register tree itype = NULL_TREE;
8081 register tree size = TREE_OPERAND (declarator, 1);
8082 /* The index is a signed object `sizetype' bits wide. */
8083 tree index_type = signed_type (sizetype);
8085 declarator = TREE_OPERAND (declarator, 0);
8087 /* Check for some types that there cannot be arrays of. */
8089 if (TYPE_MAIN_VARIANT (type) == void_type_node)
8091 cp_error ("declaration of `%D' as array of voids", dname);
8092 type = error_mark_node;
8095 if (TREE_CODE (type) == FUNCTION_TYPE)
8097 cp_error ("declaration of `%D' as array of functions", dname);
8098 type = error_mark_node;
8101 /* ARM $8.4.3: Since you can't have a pointer to a reference,
8102 you can't have arrays of references. If we allowed them,
8103 then we'd be saying x[i] is valid for an array x, but
8104 then you'd have to ask: what does `*(x + i)' mean? */
8105 if (TREE_CODE (type) == REFERENCE_TYPE)
8107 if (decl_context == TYPENAME)
8108 cp_error ("cannot make arrays of references");
8110 cp_error ("declaration of `%D' as array of references",
8112 type = error_mark_node;
8115 if (TREE_CODE (type) == OFFSET_TYPE)
8117 cp_error ("declaration of `%D' as array of data members",
8119 type = error_mark_node;
8122 if (TREE_CODE (type) == METHOD_TYPE)
8124 cp_error ("declaration of `%D' as array of function members",
8126 type = error_mark_node;
8129 if (size == error_mark_node)
8130 type = error_mark_node;
8132 if (type == error_mark_node)
8137 /* Must suspend_momentary here because the index
8138 type may need to live until the end of the function.
8139 For example, it is used in the declaration of a
8140 variable which requires destructing at the end of
8141 the function; then build_vec_delete will need this
8143 int yes = suspend_momentary ();
8144 /* might be a cast */
8145 if (TREE_CODE (size) == NOP_EXPR
8146 && TREE_TYPE (size) == TREE_TYPE (TREE_OPERAND (size, 0)))
8147 size = TREE_OPERAND (size, 0);
8149 /* If this is a template parameter, it'll be constant, but
8150 we don't know what the value is yet. */
8151 if (TREE_CODE (size) == TEMPLATE_CONST_PARM)
8152 goto dont_grok_size;
8154 if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
8155 && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE)
8157 cp_error ("size of array `%D' has non-integer type",
8159 size = integer_one_node;
8161 if (TREE_READONLY_DECL_P (size))
8162 size = decl_constant_value (size);
8163 if (pedantic && integer_zerop (size))
8164 cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", dname);
8165 if (TREE_CONSTANT (size))
8167 constant_expression_warning (size);
8168 if (INT_CST_LT (size, integer_zero_node))
8170 cp_error ("size of array `%D' is negative", dname);
8171 size = integer_one_node;
8179 cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
8182 cp_pedwarn ("ANSI C++ forbids variable-size array");
8184 /* Make sure the array size remains visibly nonconstant
8185 even if it is (eg) a const variable with known value. */
8191 fold (build_binary_op (MINUS_EXPR,
8192 convert (index_type, size),
8193 convert (index_type,
8194 integer_one_node), 1));
8195 if (! TREE_CONSTANT (itype))
8196 itype = variable_size (itype);
8197 itype = build_index_type (itype);
8198 resume_momentary (yes);
8201 /* Build the array type itself, then merge any constancy or
8202 volatility into the target type. We must do it in this order
8203 to ensure that the TYPE_MAIN_VARIANT field of the array type
8204 is set correctly. */
8206 type = build_cplus_array_type (type, itype);
8207 if (constp || volatilep)
8208 type = cp_build_type_variant (type, constp, volatilep);
8218 tree inner_parms = TREE_OPERAND (declarator, 1);
8219 tree inner_decl = TREE_OPERAND (declarator, 0);
8221 /* Declaring a function type.
8222 Make sure we have a valid type for the function to return. */
8224 /* Is this an error? Should they be merged into TYPE here? */
8225 if (pedantic && (constp || volatilep))
8226 pedwarn ("function declared to return const or volatile result");
8228 /* Merge any constancy or volatility into the function return
8231 if (constp || volatilep)
8233 type = cp_build_type_variant (type, constp, volatilep);
8234 if (IS_AGGR_TYPE (type))
8235 build_pointer_type (type);
8241 /* Warn about some types functions can't return. */
8243 if (TREE_CODE (type) == FUNCTION_TYPE)
8245 error ("`%s' declared as function returning a function", name);
8246 type = integer_type_node;
8248 if (TREE_CODE (type) == ARRAY_TYPE)
8250 error ("`%s' declared as function returning an array", name);
8251 type = integer_type_node;
8254 if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
8255 inner_decl = TREE_OPERAND (inner_decl, 1);
8257 /* Pick up type qualifiers which should be applied to `this'. */
8258 quals = TREE_OPERAND (declarator, 2);
8260 /* Say it's a definition only for the CALL_EXPR
8261 closest to the identifier. */
8263 inner_decl && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
8264 || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
8266 if (ctype == NULL_TREE
8267 && decl_context == FIELD
8269 && (friendp == 0 || dname == current_class_name))
8270 ctype = current_class_type;
8272 if (ctype && return_type == return_conversion)
8273 TYPE_HAS_CONVERSION (ctype) = 1;
8274 if (ctype && constructor_name (ctype) == dname)
8276 /* We are within a class's scope. If our declarator name
8277 is the same as the class name, and we are defining
8278 a function, then it is a constructor/destructor, and
8279 therefore returns a void type. */
8281 if (flags == DTOR_FLAG)
8283 /* ANSI C++ June 5 1992 WP 12.4.1. A destructor may
8284 not be declared const or volatile. A destructor
8285 may not be static. */
8287 error ("destructor cannot be static member function");
8290 error ("destructors cannot be declared `const' or `volatile'");
8291 return void_type_node;
8293 if (decl_context == FIELD)
8295 if (! member_function_or_else (ctype, current_class_type,
8296 "destructor for alien class `%s' cannot be a member"))
8297 return void_type_node;
8300 else /* it's a constructor. */
8304 /* ANSI C++ June 5 1992 WP 12.1.2. A constructor may
8305 not be declared const or volatile. A constructor may
8306 not be virtual. A constructor may not be static. */
8308 error ("constructor cannot be static member function");
8311 pedwarn ("constructors cannot be declared virtual");
8316 error ("constructors cannot be declared `const' or `volatile'");
8317 return void_type_node;
8320 RID_BIT_TYPE tmp_bits;
8321 bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof(RID_BIT_TYPE));
8322 RIDBIT_RESET (RID_INLINE, tmp_bits);
8323 RIDBIT_RESET (RID_STATIC, tmp_bits);
8324 if (RIDBIT_ANY_SET (tmp_bits))
8325 error ("return value type specifier for constructor ignored");
8327 type = TYPE_POINTER_TO (ctype);
8328 if (decl_context == FIELD &&
8329 IS_SIGNATURE (current_class_type))
8331 error ("constructor not allowed in signature");
8332 return void_type_node;
8334 else if (decl_context == FIELD)
8336 if (! member_function_or_else (ctype, current_class_type,
8337 "constructor for alien class `%s' cannot be member"))
8338 return void_type_node;
8339 TYPE_HAS_CONSTRUCTOR (ctype) = 1;
8340 if (return_type != return_ctor)
8344 if (decl_context == FIELD)
8350 error ("can't initialize friend function `%s'", name);
8353 /* Cannot be both friend and virtual. */
8354 error ("virtual functions cannot be friends");
8355 RIDBIT_RESET (RID_FRIEND, specbits);
8358 if (decl_context == NORMAL)
8359 error ("friend declaration not in class definition");
8360 if (current_function_decl && funcdef_flag)
8361 cp_error ("can't define friend function `%s' in a local class definition",
8365 /* Traditionally, declaring return type float means double. */
8367 if (flag_traditional
8368 && TYPE_MAIN_VARIANT (type) == float_type_node)
8370 type = build_type_variant (double_type_node,
8371 TYPE_READONLY (type),
8372 TYPE_VOLATILE (type));
8375 /* Construct the function type and go to the next
8376 inner layer of declarator. */
8378 declarator = TREE_OPERAND (declarator, 0);
8380 /* FIXME: This is where default args should be fully
8383 arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
8387 /* Get past destructors, etc.
8388 We know we have one because FLAGS will be non-zero.
8390 Complain about improper parameter lists here. */
8391 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
8393 declarator = TREE_OPERAND (declarator, 0);
8395 if (strict_prototype == 0 && arg_types == NULL_TREE)
8396 arg_types = void_list_node;
8397 else if (arg_types == NULL_TREE
8398 || arg_types != void_list_node)
8400 error ("destructors cannot be specified with parameters");
8401 arg_types = void_list_node;
8406 /* ANSI seems to say that `const int foo ();'
8407 does not make the function foo const. */
8408 type = build_function_type (type,
8409 flag_traditional ? 0 : arg_types);
8415 /* Filter out pointers-to-references and references-to-references.
8416 We can get these if a TYPE_DECL is used. */
8418 if (TREE_CODE (type) == REFERENCE_TYPE)
8420 error ("cannot declare %s to references",
8421 TREE_CODE (declarator) == ADDR_EXPR
8422 ? "references" : "pointers");
8423 declarator = TREE_OPERAND (declarator, 0);
8427 /* Merge any constancy or volatility into the target type
8430 if (constp || volatilep)
8432 /* A const or volatile signature pointer/reference is
8433 pointing to a const or volatile object, i.e., the
8434 `optr' is const or volatile, respectively, not the
8435 signature pointer/reference itself. */
8436 if (! IS_SIGNATURE (type))
8438 type = cp_build_type_variant (type, constp, volatilep);
8439 if (IS_AGGR_TYPE (type))
8440 build_pointer_type (type);
8446 if (IS_SIGNATURE (type))
8448 if (TREE_CODE (declarator) == ADDR_EXPR)
8450 if (CLASSTYPE_METHOD_VEC (type) == NULL_TREE
8451 && TYPE_SIZE (type))
8452 cp_warning ("empty signature `%T' used in signature reference declaration",
8455 type = build_signature_reference_type (type,
8458 sorry ("signature reference");
8464 if (CLASSTYPE_METHOD_VEC (type) == NULL_TREE
8465 && TYPE_SIZE (type))
8466 cp_warning ("empty signature `%T' used in signature pointer declaration",
8468 type = build_signature_pointer_type (type,
8474 else if (TREE_CODE (declarator) == ADDR_EXPR)
8476 if (TREE_CODE (type) == FUNCTION_TYPE)
8478 error ("cannot declare references to functions; use pointer to function instead");
8479 type = build_pointer_type (type);
8483 if (TYPE_MAIN_VARIANT (type) == void_type_node)
8484 error ("invalid type: `void &'");
8486 type = build_reference_type (type);
8489 else if (TREE_CODE (type) == METHOD_TYPE)
8491 type = build_ptrmemfunc_type (build_pointer_type (type));
8494 type = build_pointer_type (type);
8496 /* Process a list of type modifier keywords (such as
8497 const or volatile) that were given inside the `*' or `&'. */
8499 if (TREE_TYPE (declarator))
8501 register tree typemodlist;
8503 for (typemodlist = TREE_TYPE (declarator); typemodlist;
8504 typemodlist = TREE_CHAIN (typemodlist))
8506 if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_CONST])
8508 else if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_VOLATILE])
8513 error ("invalid type modifier within %s declarator",
8514 TREE_CODE (declarator) == ADDR_EXPR
8515 ? "reference" : "pointer");
8519 pedwarn ("duplicate `const'");
8521 pedwarn ("duplicate `volatile'");
8522 if (TREE_CODE (declarator) == ADDR_EXPR
8523 && (constp || volatilep))
8526 pedwarn ("discarding `const' applied to a reference");
8528 pedwarn ("discarding `volatile' applied to a reference");
8529 constp = volatilep = 0;
8532 declarator = TREE_OPERAND (declarator, 0);
8538 /* We have converted type names to NULL_TREE if the
8539 name was bogus, or to a _TYPE node, if not.
8541 The variable CTYPE holds the type we will ultimately
8542 resolve to. The code here just needs to build
8543 up appropriate member types. */
8544 tree sname = TREE_OPERAND (declarator, 1);
8545 /* Destructors can have their visibilities changed as well. */
8546 if (TREE_CODE (sname) == BIT_NOT_EXPR)
8547 sname = TREE_OPERAND (sname, 0);
8549 if (TREE_COMPLEXITY (declarator) == 0)
8550 /* This needs to be here, in case we are called
8551 multiple times. */ ;
8552 else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
8553 /* don't fall out into global scope. Hides real bug? --eichin */ ;
8554 else if (TREE_COMPLEXITY (declarator) == current_class_depth)
8556 /* This pop_nested_class corresponds to the
8557 push_nested_class used to push into class scope for
8558 parsing the argument list of a function decl, in
8560 pop_nested_class (1);
8561 TREE_COMPLEXITY (declarator) = current_class_depth;
8564 my_friendly_abort (16);
8566 if (TREE_OPERAND (declarator, 0) == NULL_TREE)
8568 /* We had a reference to a global decl, or
8569 perhaps we were given a non-aggregate typedef,
8570 in which case we cleared this out, and should just
8571 keep going as though it wasn't there. */
8575 ctype = TREE_OPERAND (declarator, 0);
8577 if (sname == NULL_TREE)
8580 if (TREE_CODE (sname) == IDENTIFIER_NODE)
8582 /* This is the `standard' use of the scoping operator:
8583 basetype :: member . */
8585 if (ctype == current_class_type)
8591 Is this ill-formed? */
8594 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
8597 else if (TREE_CODE (type) == FUNCTION_TYPE)
8599 if (current_class_type == NULL_TREE
8601 type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
8602 TREE_TYPE (type), TYPE_ARG_TYPES (type));
8605 cp_error ("cannot declare member function `%T::%s' within `%T'",
8606 ctype, name, current_class_type);
8607 return void_type_node;
8610 else if (TYPE_SIZE (ctype) != NULL_TREE
8611 || (RIDBIT_SETP (RID_TYPEDEF, specbits)))
8614 /* have to move this code elsewhere in this function.
8615 this code is used for i.e., typedef int A::M; M *pm;
8617 It is? How? jason 10/2/94 */
8619 if (explicit_int == -1 && decl_context == FIELD
8620 && funcdef_flag == 0)
8622 /* The code in here should only be used to build
8623 stuff that will be grokked as access decls. */
8624 t = lookup_field (ctype, sname, 0, 0);
8627 t = build_lang_field_decl (FIELD_DECL, build_nt (SCOPE_REF, ctype, t), type);
8628 DECL_INITIAL (t) = init;
8631 /* No such field, try member functions. */
8632 t = lookup_fnfields (TYPE_BINFO (ctype), sname, 0);
8635 if (flags == DTOR_FLAG)
8637 else if (CLASSTYPE_METHOD_VEC (ctype)
8638 && TREE_VALUE (t) == TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (ctype), 0))
8640 /* Don't include destructor with constructors. */
8641 t = DECL_CHAIN (TREE_VALUE (t));
8643 cp_error ("`%T' does not have any constructors",
8645 t = build_tree_list (NULL_TREE, t);
8647 t = build_lang_field_decl (FIELD_DECL, build_nt (SCOPE_REF, ctype, t), type);
8648 DECL_INITIAL (t) = init;
8653 ("field `%D' is not a member of structure `%T'",
8657 if (current_class_type)
8659 cp_error ("cannot declare member `%T::%s' within `%T'",
8660 ctype, name, current_class_type);
8661 return void_type_node;
8663 type = build_offset_type (ctype, type);
8665 else if (uses_template_parms (ctype))
8668 if (TREE_CODE (type) == FUNCTION_TYPE)
8670 type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
8672 TYPE_ARG_TYPES (type));
8678 cp_error ("structure `%T' not yet defined", ctype);
8679 return error_mark_node;
8684 else if (TREE_CODE (sname) == SCOPE_REF)
8685 my_friendly_abort (17);
8689 declarator = TREE_OPERAND (declarator, 1);
8690 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
8691 /* In this case, we will deal with it later. */
8695 if (TREE_CODE (type) == FUNCTION_TYPE)
8696 type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep), TREE_TYPE (type), TYPE_ARG_TYPES (type));
8698 type = build_offset_type (ctype, type);
8705 declarator = TREE_OPERAND (declarator, 0);
8711 declarator = NULL_TREE;
8715 declarator = NULL_TREE;
8719 my_friendly_abort (158);
8725 error ("only constructors can be declared `explicit'");
8729 /* Now TYPE has the actual type. */
8731 /* If this is declaring a typedef name, return a TYPE_DECL. */
8733 if (RIDBIT_SETP (RID_TYPEDEF, specbits))
8737 /* Note that the grammar rejects storage classes
8738 in typenames, fields or parameters. */
8739 if (constp || volatilep)
8740 type = cp_build_type_variant (type, constp, volatilep);
8742 /* If the user declares "struct {...} foo" then `foo' will have
8743 an anonymous name. Fill that name in now. Nothing can
8744 refer to it, so nothing needs know about the name change.
8745 The TYPE_NAME field was filled in by build_struct_xref. */
8746 if (type != error_mark_node
8748 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
8749 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type)))
8751 /* replace the anonymous name with the real name everywhere. */
8752 lookup_tag_reverse (type, declarator);
8753 TYPE_IDENTIFIER (type) = declarator;
8755 if (TYPE_LANG_SPECIFIC (type))
8756 TYPE_WAS_ANONYMOUS (type) = 1;
8759 tree d = TYPE_NAME (type), c = DECL_CONTEXT (d);
8762 set_nested_typename (d, 0, declarator, type);
8763 else if (TREE_CODE (c) == FUNCTION_DECL)
8764 set_nested_typename (d, DECL_ASSEMBLER_NAME (c),
8767 set_nested_typename (d, TYPE_NESTED_NAME (c), declarator, type);
8769 DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
8770 DECL_ASSEMBLER_NAME (d)
8771 = get_identifier (build_overload_name (type, 1, 1));
8775 #if 0 /* not yet, should get fixed properly later */
8776 decl = make_type_decl (declarator, type);
8778 decl = build_decl (TYPE_DECL, declarator, type);
8780 if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
8782 cp_error_at ("typedef name may not be class-qualified", decl);
8787 if (ctype == NULL_TREE)
8789 if (TREE_CODE (type) != METHOD_TYPE)
8790 cp_error_at ("invalid type qualifier for non-method type", decl);
8792 ctype = TYPE_METHOD_BASETYPE (type);
8794 if (ctype != NULL_TREE)
8795 grok_method_quals (ctype, decl, quals);
8798 if (RIDBIT_SETP (RID_SIGNED, specbits)
8799 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
8800 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
8802 if (RIDBIT_SETP (RID_MUTABLE, specbits))
8804 error ("non-object member `%s' cannot be declared mutable", name);
8810 /* Detect the case of an array type of unspecified size
8811 which came, as such, direct from a typedef name.
8812 We must copy the type, so that each identifier gets
8813 a distinct type, so that each identifier's size can be
8814 controlled separately by its own initializer. */
8816 if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
8817 && TYPE_DOMAIN (type) == NULL_TREE)
8819 type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
8822 /* If this is a type name (such as, in a cast or sizeof),
8823 compute the type and return it now. */
8825 if (decl_context == TYPENAME)
8827 /* Note that the grammar rejects storage classes
8828 in typenames, fields or parameters. */
8829 if (constp || volatilep)
8830 if (IS_SIGNATURE (type))
8831 error ("`const' or `volatile' specified with signature type");
8833 type = cp_build_type_variant (type, constp, volatilep);
8835 /* Special case: "friend class foo" looks like a TYPENAME context. */
8840 cp_error ("`volatile' specified for friend class declaration");
8845 cp_error ("`inline' specified for friend class declaration");
8849 /* Only try to do this stuff if we didn't already give up. */
8850 if (type != integer_type_node)
8852 /* A friendly class? */
8853 if (current_class_type)
8854 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
8856 error ("trying to make class `%s' a friend of global scope",
8857 TYPE_NAME_STRING (type));
8858 type = void_type_node;
8863 #if 0 /* not yet, should get fixed properly later */
8864 tree dummy = make_type_decl (declarator, type);
8866 tree dummy = build_decl (TYPE_DECL, declarator, type);
8868 if (ctype == NULL_TREE)
8870 my_friendly_assert (TREE_CODE (type) == METHOD_TYPE, 159);
8871 ctype = TYPE_METHOD_BASETYPE (type);
8873 grok_method_quals (ctype, dummy, quals);
8874 type = TREE_TYPE (dummy);
8879 else if (declarator == NULL_TREE && decl_context != PARM
8880 && decl_context != CATCHPARM
8881 && TREE_CODE (type) != UNION_TYPE
8884 cp_error ("abstract declarator `%T' used as declaration", type);
8885 declarator = make_anon_name ();
8888 /* `void' at top level (not within pointer)
8889 is allowed only in typedefs or type names.
8890 We don't complain about parms either, but that is because
8891 a better error message can be made later. */
8893 if (TYPE_MAIN_VARIANT (type) == void_type_node && decl_context != PARM)
8896 error ("unnamed variable or field declared void");
8897 else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
8899 if (IDENTIFIER_OPNAME_P (declarator))
8900 #if 0 /* How could this happen? */
8901 error ("operator `%s' declared void",
8902 operator_name_string (declarator));
8904 my_friendly_abort (356);
8907 error ("variable or field `%s' declared void", name);
8910 error ("variable or field declared void");
8911 type = integer_type_node;
8914 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
8915 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
8920 if (decl_context == PARM)
8923 error ("cannot use `::' in parameter declaration");
8925 /* A parameter declared as an array of T is really a pointer to T.
8926 One declared as a function is really a pointer to a function.
8927 One declared as a member is really a pointer to member. */
8929 if (TREE_CODE (type) == ARRAY_TYPE)
8931 /* Transfer const-ness of array into that of type pointed to. */
8932 type = build_pointer_type
8933 (cp_build_type_variant (TREE_TYPE (type), constp, volatilep));
8934 volatilep = constp = 0;
8936 else if (TREE_CODE (type) == FUNCTION_TYPE)
8937 type = build_pointer_type (type);
8938 else if (TREE_CODE (type) == OFFSET_TYPE)
8939 type = build_pointer_type (type);
8940 else if (type == void_type_node && declarator)
8942 error ("declaration of `%s' as void", name);
8946 decl = build_decl (PARM_DECL, declarator, type);
8948 bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
8949 inlinep, friendp, raises != NULL_TREE);
8950 if (current_class_type
8951 && IS_SIGNATURE (current_class_type))
8954 error ("parameter of signature member function declared `inline'");
8955 if (RIDBIT_SETP (RID_AUTO, specbits))
8956 error ("parameter of signature member function declared `auto'");
8957 if (RIDBIT_SETP (RID_REGISTER, specbits))
8958 error ("parameter of signature member function declared `register'");
8961 /* Compute the type actually passed in the parmlist,
8962 for the case where there is no prototype.
8963 (For example, shorts and chars are passed as ints.)
8964 When there is a prototype, this is overridden later. */
8966 DECL_ARG_TYPE (decl) = type_promotes_to (type);
8968 else if (decl_context == FIELD)
8970 if (type == error_mark_node)
8972 /* Happens when declaring arrays of sizes which
8973 are error_mark_node, for example. */
8976 else if (TREE_CODE (type) == FUNCTION_TYPE)
8982 if (ctype == NULL_TREE)
8983 ctype = current_class_type;
8985 if (ctype == NULL_TREE)
8987 cp_error ("can't make `%D' into a method -- not in a class",
8989 return void_type_node;
8992 /* ``A union may [ ... ] not [ have ] virtual functions.''
8994 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
8996 cp_error ("function `%D' declared virtual inside a union",
8998 return void_type_node;
9001 if (declarator == ansi_opname[(int) NEW_EXPR]
9002 || declarator == ansi_opname[(int) VEC_NEW_EXPR]
9003 || declarator == ansi_opname[(int) DELETE_EXPR]
9004 || declarator == ansi_opname[(int) VEC_DELETE_EXPR])
9008 cp_error ("`%D' cannot be declared virtual, since it is always static",
9013 else if (staticp < 2)
9014 type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
9015 TREE_TYPE (type), TYPE_ARG_TYPES (type));
9018 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
9019 publicp = (! friendp
9020 || RIDBIT_SETP (RID_EXTERN, specbits)
9021 || ! (funcdef_flag < 0 || inlinep));
9022 decl = grokfndecl (ctype, type, declarator,
9023 virtualp, flags, quals,
9024 raises, friendp ? -1 : 0, publicp, inlinep);
9025 if (decl == NULL_TREE)
9027 decl = build_decl_attribute_variant (decl, decl_machine_attr);
9030 DECL_NONCONVERTING_P (decl) = 1;
9032 else if (TREE_CODE (type) == METHOD_TYPE)
9034 /* We only get here for friend declarations of
9035 members of other classes. */
9036 /* All method decls are public, so tell grokfndecl to set
9037 TREE_PUBLIC, also. */
9038 decl = grokfndecl (ctype, type, declarator,
9039 virtualp, flags, quals,
9040 raises, friendp ? -1 : 0, 1, 0);
9041 if (decl == NULL_TREE)
9044 else if (TYPE_SIZE (type) == NULL_TREE && !staticp
9045 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
9048 cp_error ("field `%D' has incomplete type", declarator);
9050 cp_error ("name `%T' has incomplete type", type);
9052 /* If we're instantiating a template, tell them which
9053 instantiation made the field's type be incomplete. */
9054 if (current_class_type
9055 && TYPE_NAME (current_class_type)
9056 && IDENTIFIER_TEMPLATE (DECL_NAME (TYPE_NAME (current_class_type)))
9057 && declspecs && TREE_VALUE (declspecs)
9058 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
9059 cp_error (" in instantiation of template `%T'",
9060 current_class_type);
9062 type = error_mark_node;
9069 error ("`%s' is neither function nor method; cannot be declared friend",
9070 IDENTIFIER_POINTER (declarator));
9078 /* Friends are treated specially. */
9079 if (ctype == current_class_type)
9080 warning ("member functions are implicitly friends of their class");
9084 if (decl && DECL_NAME (decl))
9085 t = do_friend (ctype, declarator, decl,
9086 last_function_parms, flags, quals);
9087 if (t && funcdef_flag)
9090 return void_type_node;
9094 /* Structure field. It may not be a function, except for C++ */
9096 if (decl == NULL_TREE)
9100 /* Motion 10 at San Diego: If a static const integral data
9101 member is initialized with an integral constant
9102 expression, the initializer may appear either in the
9103 declaration (within the class), or in the definition,
9104 but not both. If it appears in the class, the member is
9105 a member constant. The file-scope definition is always
9112 cp_pedwarn ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
9115 else if (! INTEGRAL_TYPE_P (type))
9116 cp_pedwarn ("ANSI C++ forbids member constant `%D' of non-integral type `%T'", declarator, type);
9120 /* Note that initialization of const members is prohibited
9121 by the draft ANSI standard, though it appears to be in
9122 common practice. 12.6.2: The argument list is used to
9123 initialize the named nonstatic member.... This (or an
9124 initializer list) is the only way to initialize
9125 nonstatic const and reference members. */
9126 else if (pedantic || ! constp)
9127 cp_pedwarn ("ANSI C++ forbids initialization of %s `%D'",
9128 constp ? "const member" : "member", declarator);
9131 if (staticp || (constp && initialized))
9133 /* C++ allows static class members.
9134 All other work for this is done by grokfield.
9135 This VAR_DECL is built by build_lang_field_decl.
9136 All other VAR_DECLs are built by build_decl. */
9137 decl = build_lang_field_decl (VAR_DECL, declarator, type);
9138 TREE_STATIC (decl) = 1;
9139 /* In class context, 'static' means public access. */
9140 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = !!staticp;
9144 decl = build_lang_field_decl (FIELD_DECL, declarator, type);
9145 if (RIDBIT_SETP (RID_MUTABLE, specbits))
9147 DECL_MUTABLE_P (decl) = 1;
9148 RIDBIT_RESET (RID_MUTABLE, specbits);
9152 bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
9153 inlinep, friendp, raises != NULL_TREE);
9156 else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
9158 tree original_name = declarator;
9164 if (RIDBIT_SETP (RID_AUTO, specbits))
9165 error ("storage class `auto' invalid for function `%s'", name);
9166 else if (RIDBIT_SETP (RID_REGISTER, specbits))
9167 error ("storage class `register' invalid for function `%s'", name);
9169 /* Function declaration not at top level.
9170 Storage classes other than `extern' are not allowed
9171 and `extern' makes no difference. */
9172 if (current_binding_level != global_binding_level
9173 && ! processing_template_decl
9174 && (RIDBIT_SETP (RID_STATIC, specbits)
9175 || RIDBIT_SETP (RID_INLINE, specbits))
9178 if (RIDBIT_SETP (RID_STATIC, specbits))
9179 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
9181 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
9184 if (ctype == NULL_TREE)
9188 error ("virtual non-class function `%s'", name);
9192 if (current_lang_name == lang_name_cplusplus
9193 && ! (IDENTIFIER_LENGTH (original_name) == 4
9194 && IDENTIFIER_POINTER (original_name)[0] == 'm'
9195 && strcmp (IDENTIFIER_POINTER (original_name), "main") == 0)
9196 && ! (IDENTIFIER_LENGTH (original_name) > 10
9197 && IDENTIFIER_POINTER (original_name)[0] == '_'
9198 && IDENTIFIER_POINTER (original_name)[1] == '_'
9199 && strncmp (IDENTIFIER_POINTER (original_name)+2, "builtin_", 8) == 0))
9200 /* Plain overloading: will not be grok'd by grokclassfn. */
9201 declarator = build_decl_overload (dname, TYPE_ARG_TYPES (type), 0);
9203 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
9204 type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
9205 TREE_TYPE (type), TYPE_ARG_TYPES (type));
9207 /* Record presence of `static'. In C++, `inline' implies `static'. */
9208 publicp = (ctype != NULL_TREE
9209 || (!RIDBIT_SETP (RID_STATIC, specbits)
9210 && !RIDBIT_SETP (RID_INLINE, specbits)));
9212 decl = grokfndecl (ctype, type, original_name,
9213 virtualp, flags, quals,
9215 processing_template_decl ? 0 : friendp ? 2 : 1,
9217 if (decl == NULL_TREE)
9220 if (ctype == NULL_TREE && DECL_LANGUAGE (decl) != lang_c)
9221 DECL_ASSEMBLER_NAME (decl) = current_namespace_id (declarator);
9225 int illegal_static = 0;
9227 /* Don't allow a static member function in a class, and forbid
9228 declaring main to be static. */
9229 if (TREE_CODE (type) == METHOD_TYPE)
9231 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
9234 else if (current_function_decl)
9236 /* FIXME need arm citation */
9237 error ("cannot declare static function inside another function");
9244 RIDBIT_RESET (RID_STATIC, specbits);
9250 /* It's a variable. */
9252 if (decl_context == CATCHPARM)
9257 error ("cannot use `::' in parameter declaration");
9260 /* A parameter declared as an array of T is really a pointer to T.
9261 One declared as a function is really a pointer to a function.
9262 One declared as a member is really a pointer to member. */
9264 if (TREE_CODE (type) == ARRAY_TYPE)
9266 /* Transfer const-ness of array into that of type pointed to. */
9267 type = build_pointer_type
9268 (cp_build_type_variant (TREE_TYPE (type), constp, volatilep));
9269 volatilep = constp = 0;
9271 else if (TREE_CODE (type) == FUNCTION_TYPE)
9272 type = build_pointer_type (type);
9273 else if (TREE_CODE (type) == OFFSET_TYPE)
9274 type = build_pointer_type (type);
9277 /* An uninitialized decl with `extern' is a reference. */
9278 decl = grokvardecl (type, declarator, specbits, initialized);
9279 bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
9280 inlinep, friendp, raises != NULL_TREE);
9284 DECL_CONTEXT (decl) = ctype;
9287 cp_error ("static member `%D' re-declared as static",
9290 RIDBIT_RESET (RID_STATIC, specbits);
9292 if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
9294 cp_error ("static member `%D' declared `register'", decl);
9295 RIDBIT_RESET (RID_REGISTER, specbits);
9297 if (RIDBIT_SETP (RID_EXTERN, specbits))
9299 cp_error ("cannot explicitly declare member `%#D' to have extern linkage",
9301 RIDBIT_RESET (RID_EXTERN, specbits);
9306 if (RIDBIT_SETP (RID_MUTABLE, specbits))
9308 error ("`%s' cannot be declared mutable", name);
9311 /* Record `register' declaration for warnings on &
9312 and in case doing stupid register allocation. */
9314 if (RIDBIT_SETP (RID_REGISTER, specbits))
9315 DECL_REGISTER (decl) = 1;
9317 if (RIDBIT_SETP (RID_EXTERN, specbits))
9318 DECL_THIS_EXTERN (decl) = 1;
9320 if (RIDBIT_SETP (RID_STATIC, specbits))
9321 DECL_THIS_STATIC (decl) = 1;
9323 /* Record constancy and volatility. */
9326 TREE_READONLY (decl) = TREE_CODE (type) != REFERENCE_TYPE;
9329 TREE_SIDE_EFFECTS (decl) = 1;
9330 TREE_THIS_VOLATILE (decl) = 1;
9337 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
9338 An empty exprlist is a parmlist. An exprlist which
9339 contains only identifiers at the global level
9340 is a parmlist. Otherwise, it is an exprlist. */
9342 parmlist_is_exprlist (exprs)
9345 if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
9348 if (current_binding_level == global_binding_level)
9350 /* At the global level, if these are all identifiers,
9351 then it is a parmlist. */
9354 if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
9356 exprs = TREE_CHAIN (exprs);
9363 /* Subroutine of `grokparms'. In a fcn definition, arg types must
9366 C++: also subroutine of `start_function'. */
9368 require_complete_types_for_parms (parms)
9373 tree type = TREE_TYPE (parms);
9374 if (TYPE_SIZE (type) == NULL_TREE)
9376 if (DECL_NAME (parms))
9377 error ("parameter `%s' has incomplete type",
9378 IDENTIFIER_POINTER (DECL_NAME (parms)));
9380 error ("parameter has incomplete type");
9381 TREE_TYPE (parms) = error_mark_node;
9384 /* If the arg types are incomplete in a declaration,
9385 they must include undefined tags.
9386 These tags can never be defined in the scope of the declaration,
9387 so the types can never be completed,
9388 and no call can be compiled successfully. */
9389 /* This is not the right behavior for C++, but not having
9390 it is also probably wrong. */
9393 /* Now warn if is a pointer to an incomplete type. */
9394 while (TREE_CODE (type) == POINTER_TYPE
9395 || TREE_CODE (type) == REFERENCE_TYPE)
9396 type = TREE_TYPE (type);
9397 type = TYPE_MAIN_VARIANT (type);
9398 if (TYPE_SIZE (type) == NULL_TREE)
9400 if (DECL_NAME (parm) != NULL_TREE)
9401 warning ("parameter `%s' points to incomplete type",
9402 IDENTIFIER_POINTER (DECL_NAME (parm)));
9404 warning ("parameter points to incomplete type");
9408 parms = TREE_CHAIN (parms);
9412 /* Decode the list of parameter types for a function type.
9413 Given the list of things declared inside the parens,
9414 return a list of types.
9416 The list we receive can have three kinds of elements:
9417 an IDENTIFIER_NODE for names given without types,
9418 a TREE_LIST node for arguments given as typespecs or names with typespecs,
9419 or void_type_node, to mark the end of an argument list
9420 when additional arguments are not permitted (... was not used).
9422 FUNCDEF_FLAG is nonzero for a function definition, 0 for
9423 a mere declaration. A nonempty identifier-list gets an error message
9424 when FUNCDEF_FLAG is zero.
9425 If FUNCDEF_FLAG is 1, then parameter types must be complete.
9426 If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
9428 If all elements of the input list contain types,
9429 we return a list of the types.
9430 If all elements contain no type (except perhaps a void_type_node
9431 at the end), we return a null list.
9432 If some have types and some do not, it is an error, and we
9435 Also set last_function_parms to either
9436 a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
9437 A list of names is converted to a chain of PARM_DECLs
9438 by store_parm_decls so that ultimately it is always a chain of decls.
9440 Note that in C++, parameters can take default values. These default
9441 values are in the TREE_PURPOSE field of the TREE_LIST. It is
9442 an error to specify default values which are followed by parameters
9443 that have no default values, or an ELLIPSES. For simplicities sake,
9444 only parameters which are specified with their types can take on
9448 grokparms (first_parm, funcdef_flag)
9452 tree result = NULL_TREE;
9453 tree decls = NULL_TREE;
9455 if (first_parm != NULL_TREE
9456 && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
9459 pedwarn ("parameter names (without types) in function declaration");
9460 last_function_parms = first_parm;
9463 else if (first_parm != NULL_TREE
9464 && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
9465 && TREE_VALUE (first_parm) != void_type_node)
9466 my_friendly_abort (145);
9469 /* Types were specified. This is a list of declarators
9470 each represented as a TREE_LIST node. */
9471 register tree parm, chain;
9472 int any_init = 0, any_error = 0, saw_void = 0;
9474 if (first_parm != NULL_TREE)
9476 tree last_result = NULL_TREE;
9477 tree last_decl = NULL_TREE;
9479 for (parm = first_parm; parm != NULL_TREE; parm = chain)
9481 tree type, list_node = parm;
9482 register tree decl = TREE_VALUE (parm);
9483 tree init = TREE_PURPOSE (parm);
9485 chain = TREE_CHAIN (parm);
9486 /* @@ weak defense against parse errors. */
9487 if (decl != void_type_node && TREE_CODE (decl) != TREE_LIST)
9489 /* Give various messages as the need arises. */
9490 if (TREE_CODE (decl) == STRING_CST)
9491 error ("invalid string constant `%s'",
9492 TREE_STRING_POINTER (decl));
9493 else if (TREE_CODE (decl) == INTEGER_CST)
9494 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
9498 if (decl != void_type_node)
9500 /* @@ May need to fetch out a `raises' here. */
9501 decl = grokdeclarator (TREE_VALUE (decl),
9502 TREE_PURPOSE (decl),
9503 PARM, init != NULL_TREE, NULL_TREE);
9506 type = TREE_TYPE (decl);
9507 if (TYPE_MAIN_VARIANT (type) == void_type_node)
9508 decl = void_type_node;
9509 else if (TREE_CODE (type) == METHOD_TYPE)
9511 if (DECL_NAME (decl))
9512 /* Cannot use `error_with_decl' here because
9513 we don't have DECL_CONTEXT set up yet. */
9514 error ("parameter `%s' invalidly declared method type",
9515 IDENTIFIER_POINTER (DECL_NAME (decl)));
9517 error ("parameter invalidly declared method type");
9518 type = build_pointer_type (type);
9519 TREE_TYPE (decl) = type;
9521 else if (TREE_CODE (type) == OFFSET_TYPE)
9523 if (DECL_NAME (decl))
9524 error ("parameter `%s' invalidly declared offset type",
9525 IDENTIFIER_POINTER (DECL_NAME (decl)));
9527 error ("parameter invalidly declared offset type");
9528 type = build_pointer_type (type);
9529 TREE_TYPE (decl) = type;
9531 else if (TREE_CODE (type) == RECORD_TYPE
9532 && TYPE_LANG_SPECIFIC (type)
9533 && CLASSTYPE_ABSTRACT_VIRTUALS (type))
9535 abstract_virtuals_error (decl, type);
9536 any_error = 1; /* seems like a good idea */
9538 else if (TREE_CODE (type) == RECORD_TYPE
9539 && TYPE_LANG_SPECIFIC (type)
9540 && IS_SIGNATURE (type))
9542 signature_error (decl, type);
9543 any_error = 1; /* seems like a good idea */
9547 if (decl == void_type_node)
9549 if (result == NULL_TREE)
9551 result = void_list_node;
9552 last_result = result;
9556 TREE_CHAIN (last_result) = void_list_node;
9557 last_result = void_list_node;
9561 && (chain != void_list_node || TREE_CHAIN (chain)))
9562 error ("`void' in parameter list must be entire list");
9566 /* Since there is a prototype, args are passed in their own types. */
9567 DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
9568 #ifdef PROMOTE_PROTOTYPES
9569 if ((TREE_CODE (type) == INTEGER_TYPE
9570 || TREE_CODE (type) == ENUMERAL_TYPE)
9571 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
9572 DECL_ARG_TYPE (decl) = integer_type_node;
9579 if (TREE_CODE (init) == SAVE_EXPR)
9580 PARM_DECL_EXPR (init) = 1;
9581 else if (TREE_CODE (init) == VAR_DECL
9582 || TREE_CODE (init) == PARM_DECL)
9584 if (IDENTIFIER_LOCAL_VALUE (DECL_NAME (init)))
9586 /* ``Local variables may not be used in default
9587 argument expressions.'' dpANSI C++ 8.2.6 */
9588 /* If extern int i; within a function is not
9589 considered a local variable, then this code is
9591 cp_error ("local variable `%D' may not be used as a default argument", init);
9594 else if (TREE_READONLY_DECL_P (init))
9595 init = decl_constant_value (init);
9598 init = require_instantiated_type (type, init, integer_zero_node);
9600 #if 0 /* This is too early to check; trailing parms might be merged in by
9604 error ("all trailing parameters must have default arguments");
9612 if (decls == NULL_TREE)
9619 TREE_CHAIN (last_decl) = decl;
9622 if (TREE_PERMANENT (list_node))
9624 TREE_PURPOSE (list_node) = init;
9625 TREE_VALUE (list_node) = type;
9626 TREE_CHAIN (list_node) = NULL_TREE;
9629 list_node = saveable_tree_cons (init, type, NULL_TREE);
9630 if (result == NULL_TREE)
9633 last_result = result;
9637 TREE_CHAIN (last_result) = list_node;
9638 last_result = list_node;
9642 TREE_CHAIN (last_result) = NULL_TREE;
9643 /* If there are no parameters, and the function does not end
9644 with `...', then last_decl will be NULL_TREE. */
9645 if (last_decl != NULL_TREE)
9646 TREE_CHAIN (last_decl) = NULL_TREE;
9650 last_function_parms = decls;
9652 /* In a fcn definition, arg types must be complete. */
9653 if (funcdef_flag > 0)
9654 require_complete_types_for_parms (last_function_parms);
9659 /* These memoizing functions keep track of special properties which
9660 a class may have. `grok_ctor_properties' notices whether a class
9661 has a constructor of the form X(X&), and also complains
9662 if the class has a constructor of the form X(X).
9663 `grok_op_properties' takes notice of the various forms of
9664 operator= which are defined, as well as what sorts of type conversion
9665 may apply. Both functions take a FUNCTION_DECL as an argument. */
9667 grok_ctor_properties (ctype, decl)
9670 tree parmtypes = FUNCTION_ARG_CHAIN (decl);
9671 tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
9673 /* When a type has virtual baseclasses, a magical first int argument is
9674 added to any ctor so we can tell if the class has been initialized
9675 yet. This could screw things up in this function, so we deliberately
9676 ignore the leading int if we're in that situation. */
9678 && TREE_VALUE (parmtypes) == integer_type_node
9679 && TYPE_USES_VIRTUAL_BASECLASSES (ctype))
9681 parmtypes = TREE_CHAIN (parmtypes);
9682 parmtype = TREE_VALUE (parmtypes);
9685 if (TREE_CODE (parmtype) == REFERENCE_TYPE
9686 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype)
9688 if (TREE_CHAIN (parmtypes) == NULL_TREE
9689 || TREE_CHAIN (parmtypes) == void_list_node
9690 || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
9692 TYPE_HAS_INIT_REF (ctype) = 1;
9693 if (TYPE_READONLY (TREE_TYPE (parmtype)))
9694 TYPE_HAS_CONST_INIT_REF (ctype) = 1;
9697 TYPE_GETS_INIT_AGGR (ctype) = 1;
9699 else if (TYPE_MAIN_VARIANT (parmtype) == ctype)
9701 if (TREE_CHAIN (parmtypes) != NULL_TREE
9702 && TREE_CHAIN (parmtypes) == void_list_node)
9704 cp_error ("invalid constructor; you probably meant `%T (%T&)'",
9706 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
9711 TYPE_GETS_INIT_AGGR (ctype) = 1;
9713 else if (TREE_CODE (parmtype) == VOID_TYPE
9714 || TREE_PURPOSE (parmtypes) != NULL_TREE)
9715 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
9720 /* An operator with this name can be either unary or binary. */
9725 return (name == ansi_opname [(int) INDIRECT_REF]
9726 || name == ansi_opname [(int) ADDR_EXPR]
9727 || name == ansi_opname [(int) NEGATE_EXPR]
9728 || name == ansi_opname[(int) POSTINCREMENT_EXPR]
9729 || name == ansi_opname[(int) POSTDECREMENT_EXPR]
9730 || name == ansi_opname [(int) CONVERT_EXPR]);
9733 /* An operator with this name can only be unary. */
9738 return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
9739 || name == ansi_opname [(int) BIT_NOT_EXPR]
9740 || name == ansi_opname [(int) COMPONENT_REF]
9741 || OPERATOR_TYPENAME_P (name));
9744 /* Do a little sanity-checking on how they declared their operator. */
9746 grok_op_properties (decl, virtualp, friendp)
9748 int virtualp, friendp;
9750 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
9751 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
9752 tree name = DECL_NAME (decl);
9754 if (current_class_type == NULL_TREE)
9759 if (name == ansi_opname[(int) MODIFY_EXPR])
9760 TYPE_HAS_ASSIGNMENT (current_class_type) = 1;
9761 else if (name == ansi_opname[(int) CALL_EXPR])
9762 TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
9763 else if (name == ansi_opname[(int) ARRAY_REF])
9764 TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
9765 else if (name == ansi_opname[(int) COMPONENT_REF]
9766 || name == ansi_opname[(int) MEMBER_REF])
9767 TYPE_OVERLOADS_ARROW (current_class_type) = 1;
9768 else if (name == ansi_opname[(int) NEW_EXPR])
9769 TYPE_GETS_NEW (current_class_type) |= 1;
9770 else if (name == ansi_opname[(int) DELETE_EXPR])
9771 TYPE_GETS_DELETE (current_class_type) |= 1;
9772 else if (name == ansi_opname[(int) VEC_NEW_EXPR])
9773 TYPE_GETS_NEW (current_class_type) |= 2;
9774 else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
9775 TYPE_GETS_DELETE (current_class_type) |= 2;
9778 if (name == ansi_opname[(int) NEW_EXPR]
9779 || name == ansi_opname[(int) VEC_NEW_EXPR])
9781 /* When the compiler encounters the definition of A::operator new, it
9782 doesn't look at the class declaration to find out if it's static. */
9784 revert_static_member_fn (&decl, NULL, NULL);
9786 /* Take care of function decl if we had syntax errors. */
9787 if (argtypes == NULL_TREE)
9789 build_function_type (ptr_type_node,
9790 hash_tree_chain (integer_type_node,
9793 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
9795 else if (name == ansi_opname[(int) DELETE_EXPR]
9796 || name == ansi_opname[(int) VEC_DELETE_EXPR])
9799 revert_static_member_fn (&decl, NULL, NULL);
9801 if (argtypes == NULL_TREE)
9803 build_function_type (void_type_node,
9804 hash_tree_chain (ptr_type_node,
9808 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
9810 if (! friendp && name == ansi_opname[(int) VEC_DELETE_EXPR]
9811 && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
9813 TYPE_VEC_DELETE_TAKES_SIZE (current_class_type) = 1;
9818 /* An operator function must either be a non-static member function
9819 or have at least one parameter of a class, a reference to a class,
9820 an enumeration, or a reference to an enumeration. 13.4.0.6 */
9821 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
9823 if (OPERATOR_TYPENAME_P (name)
9824 || name == ansi_opname[(int) CALL_EXPR]
9825 || name == ansi_opname[(int) MODIFY_EXPR]
9826 || name == ansi_opname[(int) COMPONENT_REF]
9827 || name == ansi_opname[(int) ARRAY_REF])
9828 cp_error ("`%D' must be a nonstatic member function", decl);
9833 if (DECL_STATIC_FUNCTION_P (decl))
9834 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
9837 for (; TREE_VALUE (p) != void_type_node ; p = TREE_CHAIN (p))
9839 tree arg = TREE_VALUE (p);
9840 if (TREE_CODE (arg) == REFERENCE_TYPE)
9841 arg = TREE_TYPE (arg);
9843 /* This lets bad template code slip through. */
9844 if (IS_AGGR_TYPE (arg)
9845 || TREE_CODE (arg) == ENUMERAL_TYPE
9846 || TREE_CODE (arg) == TEMPLATE_TYPE_PARM)
9850 ("`%D' must have an argument of class or enumerated type",
9857 if (name == ansi_opname[(int) CALL_EXPR]
9858 || name == ansi_opname[(int) METHOD_CALL_EXPR])
9859 return; /* no restrictions on args */
9861 if (IDENTIFIER_TYPENAME_P (name))
9863 tree t = TREE_TYPE (name);
9864 if (TREE_CODE (t) == VOID_TYPE)
9865 pedwarn ("void is not a valid type conversion operator");
9868 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
9871 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
9873 if (t == current_class_type)
9874 what = "the same type";
9875 else if (IS_AGGR_TYPE (t)
9876 && DERIVED_FROM_P (t, current_class_type))
9877 what = "a base class";
9880 warning ("conversion to %s%s will never use a type conversion operator",
9881 ref ? "a reference to " : "", what);
9885 if (name == ansi_opname[(int) MODIFY_EXPR])
9889 if (list_length (argtypes) != 3 && methodp)
9891 cp_error ("`%D' must take exactly one argument", decl);
9894 parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
9896 if (copy_assignment_arg_p (parmtype, virtualp)
9899 TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
9900 if (TREE_CODE (parmtype) != REFERENCE_TYPE
9901 || TYPE_READONLY (TREE_TYPE (parmtype)))
9902 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
9903 #if 0 /* Too soon; done in grok_function_init */
9904 if (DECL_ABSTRACT_VIRTUAL_P (decl))
9905 TYPE_HAS_ABSTRACT_ASSIGN_REF (current_class_type) = 1;
9909 else if (name == ansi_opname[(int) COND_EXPR])
9912 pedwarn ("ANSI C++ prohibits overloading operator ?:");
9913 if (list_length (argtypes) != 4)
9914 cp_error ("`%D' must take exactly three arguments", decl);
9916 else if (ambi_op_p (name))
9918 if (list_length (argtypes) == 2)
9920 else if (list_length (argtypes) == 3)
9922 if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
9923 || name == ansi_opname[(int) POSTDECREMENT_EXPR])
9924 && TREE_VALUE (TREE_CHAIN (argtypes)) != integer_type_node)
9927 cp_error ("postfix `%D' must take `int' as its argument",
9931 ("postfix `%D' must take `int' as its second argument",
9938 cp_error ("`%D' must take either zero or one argument", decl);
9940 cp_error ("`%D' must take either one or two arguments", decl);
9943 else if (unary_op_p (name))
9945 if (list_length (argtypes) != 2)
9948 cp_error ("`%D' must take `void'", decl);
9950 cp_error ("`%D' must take exactly one argument", decl);
9953 else /* if (binary_op_p (name)) */
9955 if (list_length (argtypes) != 3)
9958 cp_error ("`%D' must take exactly one argument", decl);
9960 cp_error ("`%D' must take exactly two arguments", decl);
9966 for (; argtypes != void_list_node ; argtypes = TREE_CHAIN (argtypes))
9967 if (TREE_PURPOSE (argtypes))
9969 TREE_PURPOSE (argtypes) = NULL_TREE;
9970 if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
9971 || name == ansi_opname[(int) POSTDECREMENT_EXPR])
9974 cp_pedwarn ("`%D' cannot have default arguments", decl);
9977 cp_error ("`%D' cannot have default arguments", decl);
9982 /* Get the struct, enum or union (CODE says which) with tag NAME.
9983 Define the tag as a forward-reference if it is not defined.
9985 C++: If a class derivation is given, process it here, and report
9986 an error if multiple derivation declarations are not identical.
9988 If this is a definition, come in through xref_tag and only look in
9989 the current frame for the name (since C++ allows new names in any
9993 xref_tag (code_type_node, name, binfo, globalize)
9994 tree code_type_node;
9998 enum tag_types tag_code;
9999 enum tree_code code;
10002 register tree ref, t;
10003 struct binding_level *b = inner_binding_level;
10005 tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
10010 case signature_type:
10011 code = RECORD_TYPE;
10017 code = ENUMERAL_TYPE;
10020 my_friendly_abort (18);
10023 /* If a cross reference is requested, look up the type
10024 already defined for this tag and return it. */
10025 t = IDENTIFIER_TYPE_VALUE (name);
10026 if (t && TREE_CODE (t) != code)
10031 /* If we know we are defining this tag, only look it up in this scope
10032 * and don't try to find it as a type. */
10033 if (t && TYPE_CONTEXT(t) && TREE_MANGLED (name))
10036 ref = lookup_tag (code, name, b, 1);
10043 ref = lookup_tag (code, name, b, 0);
10047 /* Try finding it as a type declaration. If that wins, use it. */
10048 ref = lookup_name (name, 1);
10049 if (ref && TREE_CODE (ref) == TYPE_DECL
10050 && TREE_CODE (TREE_TYPE (ref)) == code)
10051 ref = TREE_TYPE (ref);
10057 push_obstacks_nochange ();
10061 /* If no such tag is yet defined, create a forward-reference node
10062 and record it as the "definition".
10063 When a real declaration of this type is found,
10064 the forward-reference will be altered into a real type. */
10066 /* In C++, since these migrate into the global scope, we must
10067 build them on the permanent obstack. */
10069 temp = allocation_temporary_p ();
10071 end_temporary_allocation ();
10073 if (code == ENUMERAL_TYPE)
10075 ref = make_node (ENUMERAL_TYPE);
10077 /* Give the type a default layout like unsigned int
10078 to avoid crashing if it does not get defined. */
10079 TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
10080 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
10081 TREE_UNSIGNED (ref) = 1;
10082 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
10083 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
10084 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
10086 /* Enable us to recognize when a type is created in class context.
10087 To do nested classes correctly, this should probably be cleared
10088 out when we leave this classes scope. Currently this in only
10089 done in `start_enum'. */
10091 pushtag (name, ref, globalize);
10093 cadillac_start_enum (ref);
10097 struct binding_level *old_b = class_binding_level;
10099 ref = make_lang_type (code);
10101 if (tag_code == signature_type)
10103 SET_SIGNATURE (ref);
10104 /* Since a signature type will be turned into the type
10105 of signature tables, it's not only an interface. */
10106 CLASSTYPE_INTERFACE_ONLY (ref) = 0;
10107 SET_CLASSTYPE_INTERFACE_KNOWN (ref);
10108 /* A signature doesn't have a vtable. */
10109 CLASSTYPE_VTABLE_NEEDS_WRITING (ref) = 0;
10112 #ifdef NONNESTED_CLASSES
10113 /* Class types don't nest the way enums do. */
10114 class_binding_level = (struct binding_level *)0;
10116 pushtag (name, ref, globalize);
10117 class_binding_level = old_b;
10120 cadillac_start_struct (ref);
10125 /* If it no longer looks like a nested type, make sure it's
10126 in global scope. */
10127 if (b == global_binding_level && !class_binding_level
10128 && IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE)
10129 IDENTIFIER_GLOBAL_VALUE (name) = TYPE_NAME (ref);
10135 tree tt2 = TYPE_BINFO_BASETYPES (ref);
10137 if (TYPE_BINFO_BASETYPES (ref))
10138 for (i = 0; tt1; i++, tt1 = TREE_CHAIN (tt1))
10139 if (TREE_VALUE (tt1) != TYPE_IDENTIFIER (BINFO_TYPE (TREE_VEC_ELT (tt2, i))))
10141 cp_error ("redeclaration of derivation chain of type `%#T'",
10146 if (tt1 == NULL_TREE)
10147 /* The user told us something we already knew. */
10150 /* In C++, since these migrate into the global scope, we must
10151 build them on the permanent obstack. */
10152 end_temporary_allocation ();
10158 xref_basetypes (code_type_node, name, ref, binfo);
10162 /* Until the type is defined, tentatively accept whatever
10163 structure tag the user hands us. */
10164 if (TYPE_SIZE (ref) == NULL_TREE
10165 && ref != current_class_type
10166 /* Have to check this, in case we have contradictory tag info. */
10167 && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
10169 if (tag_code == class_type)
10170 CLASSTYPE_DECLARED_CLASS (ref) = 1;
10171 else if (tag_code == record_type || tag_code == signature_type)
10172 CLASSTYPE_DECLARED_CLASS (ref) = 0;
10181 xref_basetypes (code_type_node, name, ref, binfo)
10182 tree code_type_node;
10186 /* In the declaration `A : X, Y, ... Z' we mark all the types
10187 (A, X, Y, ..., Z) so we can check for duplicates. */
10190 enum tag_types tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
10192 if (tag_code == union_type)
10194 cp_error ("derived union `%T' invalid", ref);
10198 len = list_length (binfo);
10199 push_obstacks (TYPE_OBSTACK (ref), TYPE_OBSTACK (ref));
10201 SET_CLASSTYPE_MARKED (ref);
10202 BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
10204 for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
10206 /* The base of a derived struct is public by default. */
10208 = (TREE_PURPOSE (binfo) == (tree)access_public
10209 || TREE_PURPOSE (binfo) == (tree)access_public_virtual
10210 || (tag_code != class_type
10211 && (TREE_PURPOSE (binfo) == (tree)access_default
10212 || TREE_PURPOSE (binfo) == (tree)access_default_virtual)));
10213 int via_protected = TREE_PURPOSE (binfo) == (tree)access_protected;
10215 = (TREE_PURPOSE (binfo) == (tree)access_private_virtual
10216 || TREE_PURPOSE (binfo) == (tree)access_public_virtual
10217 || TREE_PURPOSE (binfo) == (tree)access_default_virtual);
10218 tree basetype = TREE_TYPE (TREE_VALUE (binfo));
10221 GNU_xref_hier (IDENTIFIER_POINTER (name),
10222 IDENTIFIER_POINTER (TREE_VALUE (binfo)),
10223 via_public, via_virtual, 0);
10225 if (basetype && TREE_CODE (basetype) == TYPE_DECL)
10226 basetype = TREE_TYPE (basetype);
10227 if (!basetype || TREE_CODE (basetype) != RECORD_TYPE)
10229 cp_error ("base type `%T' fails to be a struct or class type",
10230 TREE_VALUE (binfo));
10234 /* This code replaces similar code in layout_basetypes. */
10235 else if (TYPE_INCOMPLETE (basetype))
10237 cp_error ("base class `%T' has incomplete type", basetype);
10243 if (CLASSTYPE_MARKED (basetype))
10245 if (basetype == ref)
10246 cp_error ("recursive type `%T' undefined", basetype);
10248 cp_error ("duplicate base type `%T' invalid", basetype);
10252 /* Note that the BINFO records which describe individual
10253 inheritances are *not* shared in the lattice! They
10254 cannot be shared because a given baseclass may be
10255 inherited with different `accessibility' by different
10256 derived classes. (Each BINFO record describing an
10257 individual inheritance contains flags which say what
10258 the `accessibility' of that particular inheritance is.) */
10260 base_binfo = make_binfo (integer_zero_node, basetype,
10261 TYPE_BINFO_VTABLE (basetype),
10262 TYPE_BINFO_VIRTUALS (basetype), NULL_TREE);
10264 TREE_VEC_ELT (binfos, i) = base_binfo;
10265 TREE_VIA_PUBLIC (base_binfo) = via_public;
10266 TREE_VIA_PROTECTED (base_binfo) = via_protected;
10267 TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
10268 BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
10270 SET_CLASSTYPE_MARKED (basetype);
10272 /* XYZZY TEST VIRTUAL BASECLASSES */
10273 if (CLASSTYPE_N_BASECLASSES (basetype) == NULL_TREE
10274 && TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype)
10275 && via_virtual == 0)
10277 warning ("making type `%s' a virtual baseclass",
10278 TYPE_NAME_STRING (basetype));
10282 /* We are free to modify these bits because they are meaningless
10283 at top level, and BASETYPE is a top-level type. */
10284 if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
10286 TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
10287 TYPE_USES_COMPLEX_INHERITANCE (ref) = 1;
10290 TYPE_OVERLOADS_METHOD_CALL_EXPR (ref) |= TYPE_OVERLOADS_METHOD_CALL_EXPR (basetype);
10291 TYPE_GETS_NEW (ref) |= TYPE_GETS_NEW (basetype);
10292 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
10293 CLASSTYPE_LOCAL_TYPEDECLS (ref) |= CLASSTYPE_LOCAL_TYPEDECLS (basetype);
10298 TREE_VEC_LENGTH (binfos) = i;
10300 BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
10303 TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
10305 TYPE_USES_MULTIPLE_INHERITANCE (ref)
10306 = TYPE_USES_MULTIPLE_INHERITANCE (BINFO_TYPE (TREE_VEC_ELT (binfos, 0)));
10307 if (TYPE_USES_MULTIPLE_INHERITANCE (ref))
10308 TYPE_USES_COMPLEX_INHERITANCE (ref) = 1;
10310 /* Unmark all the types. */
10312 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
10313 CLEAR_CLASSTYPE_MARKED (ref);
10319 static tree current_local_enum = NULL_TREE;
10321 /* Begin compiling the definition of an enumeration type.
10322 NAME is its name (or null if anonymous).
10323 Returns the type object, as yet incomplete.
10324 Also records info about it so that build_enumerator
10325 may be used to declare the individual values as they are read. */
10331 register tree enumtype = NULL_TREE;
10332 struct binding_level *b = inner_binding_level;
10334 /* If this is the real definition for a previous forward reference,
10335 fill in the contents in the same object that used to be the
10336 forward reference. */
10338 if (name != NULL_TREE)
10339 enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
10341 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
10342 cp_error ("multiple definition of enum `%T'", enumtype);
10345 enumtype = make_node (ENUMERAL_TYPE);
10346 pushtag (name, enumtype, 0);
10349 if (current_class_type)
10350 TREE_ADDRESSABLE (b->tags) = 1;
10351 current_local_enum = NULL_TREE;
10353 #if 0 /* This stuff gets cleared in finish_enum anyway. */
10354 if (TYPE_VALUES (enumtype) != NULL_TREE)
10355 /* Completely replace its old definition.
10356 The old enumerators remain defined, however. */
10357 TYPE_VALUES (enumtype) = NULL_TREE;
10359 /* Initially, set up this enum as like `int'
10360 so that we can create the enumerators' declarations and values.
10361 Later on, the precision of the type may be changed and
10362 it may be laid out again. */
10364 TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
10365 TYPE_SIZE (enumtype) = NULL_TREE;
10366 fixup_signed_type (enumtype);
10369 /* We copy this value because enumerated type constants
10370 are really of the type of the enumerator, not integer_type_node. */
10371 enum_next_value = copy_node (integer_zero_node);
10374 GNU_xref_decl (current_function_decl, enumtype);
10378 /* After processing and defining all the values of an enumeration type,
10379 install their decls in the enumeration type and finish it off.
10380 ENUMTYPE is the type object and VALUES a list of name-value pairs.
10381 Returns ENUMTYPE. */
10384 finish_enum (enumtype, values)
10385 register tree enumtype, values;
10387 register tree minnode, maxnode;
10388 /* Calculate the maximum value of any enumerator in this type. */
10392 register tree pair;
10393 register tree value = DECL_INITIAL (TREE_VALUE (values));
10395 /* Speed up the main loop by performing some precalculations */
10396 TREE_TYPE (TREE_VALUE (values)) = enumtype;
10397 TREE_TYPE (value) = enumtype;
10398 TREE_VALUE (values) = value;
10399 minnode = maxnode = value;
10401 for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
10403 value = DECL_INITIAL (TREE_VALUE (pair));
10404 TREE_TYPE (TREE_VALUE (pair)) = enumtype;
10405 TREE_TYPE (value) = enumtype;
10406 TREE_VALUE (pair) = value;
10407 if (tree_int_cst_lt (maxnode, value))
10409 else if (tree_int_cst_lt (value, minnode))
10414 maxnode = minnode = integer_zero_node;
10416 TYPE_VALUES (enumtype) = values;
10419 int unsignedp = tree_int_cst_sgn (minnode) >= 0;
10420 int lowprec = min_precision (minnode, unsignedp);
10421 int highprec = min_precision (maxnode, unsignedp);
10422 int precision = MAX (lowprec, highprec);
10424 TYPE_SIZE (enumtype) = NULL_TREE;
10426 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
10428 TYPE_PRECISION (enumtype) = precision;
10430 fixup_unsigned_type (enumtype);
10432 fixup_signed_type (enumtype);
10434 if (flag_short_enums || precision > TYPE_PRECISION (integer_type_node))
10435 /* Use the width of the narrowest normal C type which is wide enough. */
10436 TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
10439 TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
10441 TYPE_SIZE (enumtype) = 0;
10442 layout_type (enumtype);
10446 cadillac_finish_enum (enumtype);
10451 /* Fix up all variant types of this enum type. */
10452 for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
10453 tem = TYPE_NEXT_VARIANT (tem))
10455 TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
10456 TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
10457 TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
10458 TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
10459 TYPE_MODE (tem) = TYPE_MODE (enumtype);
10460 TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
10461 TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
10462 TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
10466 /* Finish debugging output for this type. */
10468 /* @@ Do we ever generate generate ENUMERAL_TYPE nodes for which debugging
10469 information should *not* be generated? I think not. */
10470 if (! DECL_IGNORED_P (TYPE_NAME (enumtype)))
10472 rest_of_type_compilation (enumtype, global_bindings_p ());
10477 /* Build and install a CONST_DECL for one value of the
10478 current enumeration type (one that was begun with start_enum).
10479 Return a tree-list containing the name and its value.
10480 Assignment of sequential values by default is handled here. */
10483 build_enumerator (name, value)
10487 /* Change this to zero if we find VALUE is not shareable. */
10490 /* Remove no-op casts from the value. */
10492 STRIP_TYPE_NOPS (value);
10494 /* Validate and default VALUE. */
10495 if (value != NULL_TREE)
10497 if (TREE_READONLY_DECL_P (value))
10499 value = decl_constant_value (value);
10503 if (TREE_CODE (value) == INTEGER_CST)
10505 value = default_conversion (value);
10506 constant_expression_warning (value);
10510 cp_error ("enumerator value for `%D' not integer constant", name);
10515 /* The order of things is reversed here so that we
10516 can check for possible sharing of enum values,
10517 to keep that from happening. */
10518 /* Default based on previous value. */
10519 if (value == NULL_TREE)
10521 value = enum_next_value;
10523 cp_error ("overflow in enumeration values at `%D'", name);
10526 /* Remove no-op casts from the value. */
10528 STRIP_TYPE_NOPS (value);
10530 /* Make up for hacks in lex.c. */
10531 if (value == integer_zero_node)
10532 value = build_int_2 (0, 0);
10533 else if (value == integer_one_node)
10534 value = build_int_2 (1, 0);
10535 else if (TREE_CODE (value) == INTEGER_CST
10537 || TREE_CODE (TREE_TYPE (value)) == ENUMERAL_TYPE))
10539 value = copy_node (value);
10540 TREE_TYPE (value) = integer_type_node;
10543 /* C++ associates enums with global, function, or class declarations. */
10545 decl = current_scope ();
10546 if (decl && decl == current_class_type)
10548 /* This enum declaration is local to the class, so we must put
10549 it in that class's list of decls. */
10550 decl = build_lang_field_decl (CONST_DECL, name, integer_type_node);
10551 DECL_INITIAL (decl) = value;
10552 TREE_READONLY (decl) = 1;
10553 pushdecl_class_level (decl);
10554 TREE_CHAIN (decl) = current_local_enum;
10555 current_local_enum = decl;
10559 /* It's a global enum, or it's local to a function. (Note local to
10560 a function could mean local to a class method. */
10561 decl = build_decl (CONST_DECL, name, integer_type_node);
10562 DECL_INITIAL (decl) = value;
10565 GNU_xref_decl (current_function_decl, decl);
10568 /* Set basis for default for next value. */
10569 enum_next_value = build_binary_op_nodefault (PLUS_EXPR, value,
10570 integer_one_node, PLUS_EXPR);
10571 enum_overflow = tree_int_cst_lt (enum_next_value, value);
10573 if (enum_next_value == integer_one_node)
10574 enum_next_value = copy_node (enum_next_value);
10576 result = saveable_tree_cons (name, decl, NULL_TREE);
10581 grok_enum_decls (type, decl)
10584 tree d = current_local_enum;
10586 if (d == NULL_TREE)
10591 TREE_TYPE (d) = type;
10592 if (TREE_CHAIN (d) == NULL_TREE)
10594 TREE_CHAIN (d) = decl;
10597 d = TREE_CHAIN (d);
10600 decl = current_local_enum;
10601 current_local_enum = NULL_TREE;
10606 /* Create the FUNCTION_DECL for a function definition.
10607 DECLSPECS and DECLARATOR are the parts of the declaration;
10608 they describe the function's name and the type it returns,
10609 but twisted together in a fashion that parallels the syntax of C.
10611 This function creates a binding context for the function body
10612 as well as setting up the FUNCTION_DECL in current_function_decl.
10614 Returns 1 on success. If the DECLARATOR is not suitable for a function
10615 (it defines a datum instead), we return 0, which tells
10616 yyparse to report a parse error.
10618 For C++, we must first check whether that datum makes any sense.
10619 For example, "class A local_a(1,2);" means that variable local_a
10620 is an aggregate of type A, which should have a constructor
10621 applied to it with the argument list [1, 2].
10623 @@ There is currently no way to retrieve the storage
10624 @@ allocated to FUNCTION (or all of its parms) if we return
10625 @@ something we had previously. */
10628 start_function (declspecs, declarator, raises, pre_parsed_p)
10629 tree declarator, declspecs, raises;
10632 tree decl1, olddecl;
10633 tree ctype = NULL_TREE;
10636 extern int have_extern_spec;
10637 extern int used_extern_spec;
10638 int doing_friend = 0;
10640 /* Sanity check. */
10641 my_friendly_assert (TREE_VALUE (void_list_node) == void_type_node, 160);
10642 my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
10644 /* Assume, until we see it does. */
10645 current_function_returns_value = 0;
10646 current_function_returns_null = 0;
10647 warn_about_return_type = 0;
10648 current_function_assigns_this = 0;
10649 current_function_just_assigned_this = 0;
10650 current_function_parms_stored = 0;
10651 original_result_rtx = NULL_RTX;
10652 current_function_obstack_index = 0;
10653 current_function_obstack_usage = 0;
10654 base_init_insns = NULL_RTX;
10655 protect_list = NULL_TREE;
10657 clear_temp_name ();
10659 /* This should only be done once on the top most decl. */
10660 if (have_extern_spec && !used_extern_spec)
10662 declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
10663 used_extern_spec = 1;
10668 decl1 = declarator;
10670 if (! DECL_ARGUMENTS (decl1)
10671 && !DECL_STATIC_FUNCTION_P (decl1)
10672 && DECL_CONTEXT (decl1)
10673 && DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl1)))
10674 && IDENTIFIER_TEMPLATE (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl1)))))
10676 cp_error ("redeclaration of `%#D'", decl1);
10677 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1)))
10678 cp_error_at ("previous declaration here", IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1)));
10679 else if (IDENTIFIER_GLOBAL_VALUE (DECL_NAME (decl1)))
10680 cp_error_at ("previous declaration here", IDENTIFIER_GLOBAL_VALUE (DECL_NAME (decl1)));
10683 last_function_parms = DECL_ARGUMENTS (decl1);
10684 last_function_parm_tags = NULL_TREE;
10685 fntype = TREE_TYPE (decl1);
10686 if (TREE_CODE (fntype) == METHOD_TYPE)
10687 ctype = TYPE_METHOD_BASETYPE (fntype);
10689 /* ANSI C++ June 5 1992 WP 11.4.5. A friend function defined in a
10690 class is in the (lexical) scope of the class in which it is
10692 if (!ctype && DECL_FRIEND_P (decl1))
10694 ctype = DECL_CLASS_CONTEXT (decl1);
10696 /* CTYPE could be null here if we're dealing with a template;
10697 for example, `inline friend float foo()' inside a template
10698 will have no CTYPE set. */
10699 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
10705 raises = TYPE_RAISES_EXCEPTIONS (fntype);
10707 /* In a fcn definition, arg types must be complete. */
10708 require_complete_types_for_parms (last_function_parms);
10712 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, raises);
10713 /* If the declarator is not suitable for a function definition,
10714 cause a syntax error. */
10715 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
10717 fntype = TREE_TYPE (decl1);
10719 restype = TREE_TYPE (fntype);
10720 if (IS_AGGR_TYPE (restype) && ! TYPE_PTRMEMFUNC_P (restype)
10721 && ! CLASSTYPE_GOT_SEMICOLON (restype))
10723 cp_error ("semicolon missing after declaration of `%#T'", restype);
10724 shadow_tag (build_tree_list (NULL_TREE, restype));
10725 CLASSTYPE_GOT_SEMICOLON (restype) = 1;
10726 if (TREE_CODE (fntype) == FUNCTION_TYPE)
10727 fntype = build_function_type (integer_type_node,
10728 TYPE_ARG_TYPES (fntype));
10730 fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
10732 TYPE_ARG_TYPES (fntype));
10733 TREE_TYPE (decl1) = fntype;
10736 if (TREE_CODE (fntype) == METHOD_TYPE)
10737 ctype = TYPE_METHOD_BASETYPE (fntype);
10738 else if (IDENTIFIER_LENGTH (DECL_NAME (decl1)) == 4
10739 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (decl1)), "main")
10740 && DECL_CONTEXT (decl1) == NULL_TREE)
10742 /* If this doesn't return integer_type, complain. */
10743 if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
10745 if (pedantic || warn_return_type)
10746 pedwarn ("return type for `main' changed to integer type");
10747 TREE_TYPE (decl1) = fntype = default_function_type;
10749 warn_about_return_type = 0;
10753 /* Warn if function was previously implicitly declared
10754 (but not if we warned then). */
10755 if (! warn_implicit
10756 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
10757 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
10759 current_function_decl = decl1;
10762 cadillac_start_function (decl1);
10764 announce_function (decl1);
10766 if (TYPE_SIZE (TREE_TYPE (fntype)) == NULL_TREE)
10768 if (IS_AGGR_TYPE (TREE_TYPE (fntype)))
10769 error_with_aggr_type (TREE_TYPE (fntype),
10770 "return-type `%s' is an incomplete type");
10772 error ("return-type is an incomplete type");
10774 /* Make it return void instead, but don't change the
10775 type of the DECL_RESULT, in case we have a named return value. */
10778 = build_cplus_method_type (build_type_variant (ctype,
10779 TREE_READONLY (decl1),
10780 TREE_SIDE_EFFECTS (decl1)),
10782 FUNCTION_ARG_CHAIN (decl1));
10785 = build_function_type (void_type_node,
10786 TYPE_ARG_TYPES (TREE_TYPE (decl1)));
10787 DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, TREE_TYPE (fntype));
10790 if (TYPE_LANG_SPECIFIC (TREE_TYPE (fntype))
10791 && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (fntype)))
10792 abstract_virtuals_error (decl1, TREE_TYPE (fntype));
10794 if (warn_about_return_type)
10795 warning ("return-type defaults to `int'");
10797 /* Make the init_value nonzero so pushdecl knows this is not tentative.
10798 error_mark_node is replaced below (in poplevel) with the BLOCK. */
10799 DECL_INITIAL (decl1) = error_mark_node;
10801 /* Didn't get anything from C. */
10802 olddecl = NULL_TREE;
10804 /* This function exists in static storage.
10805 (This does not mean `static' in the C sense!) */
10806 TREE_STATIC (decl1) = 1;
10808 if (DECL_INTERFACE_KNOWN (decl1))
10810 if (DECL_NOT_REALLY_EXTERN (decl1))
10811 DECL_EXTERNAL (decl1) = 0;
10813 /* If this function belongs to an interface, it is public.
10814 If it belongs to someone else's interface, it is also external.
10815 It doesn't matter whether it's inline or not. */
10816 else if (interface_unknown == 0)
10818 if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
10819 DECL_EXTERNAL (decl1)
10821 || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines));
10823 DECL_EXTERNAL (decl1) = 0;
10824 DECL_INTERFACE_KNOWN (decl1) = 1;
10828 /* This is a definition, not a reference.
10829 So clear DECL_EXTERNAL. */
10830 DECL_EXTERNAL (decl1) = 0;
10832 if (DECL_THIS_INLINE (decl1) && ! DECL_C_STATIC (decl1))
10833 DECL_DEFER_OUTPUT (decl1) = 1;
10836 DECL_INTERFACE_KNOWN (decl1) = 1;
10837 if (DECL_C_STATIC (decl1))
10838 TREE_PUBLIC (decl1) = 0;
10842 /* Record the decl so that the function name is defined.
10843 If we already have a decl for this name, and it is a FUNCTION_DECL,
10844 use the old decl. */
10846 if (pre_parsed_p == 0)
10848 current_function_decl = decl1 = pushdecl (decl1);
10849 DECL_MAIN_VARIANT (decl1) = decl1;
10850 fntype = TREE_TYPE (decl1);
10853 current_function_decl = decl1;
10855 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1))
10857 if (TREE_CODE (fntype) == METHOD_TYPE)
10858 TREE_TYPE (decl1) = fntype
10859 = build_function_type (TREE_TYPE (fntype),
10860 TREE_CHAIN (TYPE_ARG_TYPES (fntype)));
10861 last_function_parms = TREE_CHAIN (last_function_parms);
10862 DECL_ARGUMENTS (decl1) = last_function_parms;
10865 restype = TREE_TYPE (fntype);
10869 push_nested_class (ctype, 1);
10871 /* If we're compiling a friend function, neither of the variables
10872 current_class_decl nor current_class_type will have values. */
10873 if (! doing_friend)
10875 /* We know that this was set up by `grokclassfn'.
10876 We do not wait until `store_parm_decls', since evil
10877 parse errors may never get us to that point. Here
10878 we keep the consistency between `current_class_type'
10879 and `current_class_decl'. */
10880 current_class_decl = last_function_parms;
10881 my_friendly_assert (current_class_decl != NULL_TREE
10882 && TREE_CODE (current_class_decl) == PARM_DECL, 162);
10883 if (TREE_CODE (TREE_TYPE (current_class_decl)) == POINTER_TYPE)
10885 tree variant = TREE_TYPE (TREE_TYPE (current_class_decl));
10886 if (CLASSTYPE_INST_VAR (ctype) == NULL_TREE)
10888 /* Can't call build_indirect_ref here, because it has special
10889 logic to return C_C_D given this argument. */
10890 C_C_D = build1 (INDIRECT_REF, current_class_type, current_class_decl);
10891 CLASSTYPE_INST_VAR (ctype) = C_C_D;
10895 C_C_D = CLASSTYPE_INST_VAR (ctype);
10896 /* `current_class_decl' is different for every
10897 function we compile. */
10898 TREE_OPERAND (C_C_D, 0) = current_class_decl;
10900 TREE_READONLY (C_C_D) = TYPE_READONLY (variant);
10901 TREE_SIDE_EFFECTS (C_C_D) = TYPE_VOLATILE (variant);
10902 TREE_THIS_VOLATILE (C_C_D) = TYPE_VOLATILE (variant);
10905 C_C_D = current_class_decl;
10910 if (DECL_STATIC_FUNCTION_P (decl1))
10911 push_nested_class (DECL_CONTEXT (decl1), 2);
10913 push_memoized_context (0, 1);
10917 current_binding_level->parm_flag = 1;
10919 /* Save the parm names or decls from this function's declarator
10920 where store_parm_decls will find them. */
10921 current_function_parms = last_function_parms;
10922 current_function_parm_tags = last_function_parm_tags;
10924 GNU_xref_function (decl1, current_function_parms);
10926 make_function_rtl (decl1);
10928 /* Allocate further tree nodes temporarily during compilation
10929 of this function only. Tiemann moved up here from bottom of fn. */
10930 temporary_allocation ();
10932 /* Promote the value to int before returning it. */
10933 if (C_PROMOTING_INTEGER_TYPE_P (restype))
10935 /* It retains unsignedness if traditional or if it isn't
10936 really getting wider. */
10937 if (TREE_UNSIGNED (restype)
10938 && (flag_traditional
10939 || TYPE_PRECISION (restype)
10940 == TYPE_PRECISION (integer_type_node)))
10941 restype = unsigned_type_node;
10943 restype = integer_type_node;
10945 if (DECL_RESULT (decl1) == NULL_TREE)
10946 DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, restype);
10948 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1)))
10950 dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
10951 ctor_label = NULL_TREE;
10955 dtor_label = NULL_TREE;
10956 if (DECL_CONSTRUCTOR_P (decl1))
10957 ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
10960 /* If this fcn was already referenced via a block-scope `extern' decl
10961 (or an implicit decl), propagate certain information about the usage. */
10962 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
10963 TREE_ADDRESSABLE (decl1) = 1;
10968 /* Store the parameter declarations into the current function declaration.
10969 This is called after parsing the parameter declarations, before
10970 digesting the body of the function.
10972 Also install to binding contour return value identifier, if any. */
10975 store_parm_decls ()
10977 register tree fndecl = current_function_decl;
10978 register tree parm;
10979 int parms_have_cleanups = 0;
10981 /* This is either a chain of PARM_DECLs (when a prototype is used). */
10982 tree specparms = current_function_parms;
10984 /* This is a list of types declared among parms in a prototype. */
10985 tree parmtags = current_function_parm_tags;
10987 /* This is a chain of any other decls that came in among the parm
10988 declarations. If a parm is declared with enum {foo, bar} x;
10989 then CONST_DECLs for foo and bar are put here. */
10990 tree nonparms = NULL_TREE;
10992 if (current_binding_level == global_binding_level)
10993 fatal ("parse errors have confused me too much");
10995 /* Initialize RTL machinery. */
10996 init_function_start (fndecl, input_filename, lineno);
10998 /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function. */
10999 declare_function_name ();
11001 /* Create a binding level for the parms. */
11002 expand_start_bindings (0);
11004 if (specparms != NULL_TREE)
11006 /* This case is when the function was defined with an ANSI prototype.
11007 The parms already have decls, so we need not do anything here
11008 except record them as in effect
11009 and complain if any redundant old-style parm decls were written. */
11011 register tree next;
11013 /* Must clear this because it might contain TYPE_DECLs declared
11015 storedecls (NULL_TREE);
11016 for (parm = nreverse (specparms); parm; parm = next)
11018 next = TREE_CHAIN (parm);
11019 if (TREE_CODE (parm) == PARM_DECL)
11021 tree cleanup = maybe_build_cleanup (parm);
11022 if (DECL_NAME (parm) == NULL_TREE)
11025 cp_error_at ("parameter name omitted", parm);
11027 /* for C++, this is not an error. */
11031 else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
11032 cp_error ("parameter `%D' declared void", parm);
11035 /* Now fill in DECL_REFERENCE_SLOT for any of the parm decls.
11036 A parameter is assumed not to have any side effects.
11037 If this should change for any reason, then this
11038 will have to wrap the bashed reference type in a save_expr.
11040 Also, if the parameter type is declared to be an X
11041 and there is an X(X&) constructor, we cannot lay it
11042 into the stack (any more), so we make this parameter
11043 look like it is really of reference type. Functions
11044 which pass parameters to this function will know to
11045 create a temporary in their frame, and pass a reference
11048 if (TREE_CODE (TREE_TYPE (parm)) == REFERENCE_TYPE
11049 && TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm))))
11050 SET_DECL_REFERENCE_SLOT (parm, convert_from_reference (parm));
11056 expand_decl (parm);
11057 if (! expand_decl_cleanup (parm, cleanup))
11058 cp_error ("parser lost in parsing declaration of `%D'",
11060 parms_have_cleanups = 1;
11065 /* If we find an enum constant or a type tag,
11066 put it aside for the moment. */
11067 TREE_CHAIN (parm) = NULL_TREE;
11068 nonparms = chainon (nonparms, parm);
11072 /* Get the decls in their original chain order
11073 and record in the function. This is all and only the
11074 PARM_DECLs that were pushed into scope by the loop above. */
11075 DECL_ARGUMENTS (fndecl) = getdecls ();
11077 storetags (chainon (parmtags, gettags ()));
11080 DECL_ARGUMENTS (fndecl) = NULL_TREE;
11082 /* Now store the final chain of decls for the arguments
11083 as the decl-chain of the current lexical scope.
11084 Put the enumerators in as well, at the front so that
11085 DECL_ARGUMENTS is not modified. */
11087 storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
11089 /* Initialize the RTL code for the function. */
11090 DECL_SAVED_INSNS (fndecl) = NULL_RTX;
11091 expand_function_start (fndecl, parms_have_cleanups);
11093 /* Create a binding contour which can be used to catch
11094 cleanup-generated temporaries. Also, if the return value needs or
11095 has initialization, deal with that now. */
11096 if (parms_have_cleanups)
11099 expand_start_bindings (0);
11102 current_function_parms_stored = 1;
11106 maybe_gc_cleanup = build_tree_list (NULL_TREE, error_mark_node);
11107 if (! expand_decl_cleanup (NULL_TREE, maybe_gc_cleanup))
11108 cp_error ("parser lost in parsing declaration of `%D'", fndecl);
11111 /* If this function is `main', emit a call to `__main'
11112 to run global initializers, etc. */
11113 if (DECL_NAME (fndecl)
11114 && IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 4
11115 && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main") == 0
11116 && DECL_CONTEXT (fndecl) == NULL_TREE)
11118 expand_main_function ();
11121 expand_expr (build_function_call (lookup_name (get_identifier ("__gc_main"), 0), NULL_TREE),
11124 /* done at a differnet time */
11126 output_builtin_tdesc_entries ();
11131 /* Bind a name and initialization to the return value of
11132 the current function. */
11134 store_return_init (return_id, init)
11135 tree return_id, init;
11137 tree decl = DECL_RESULT (current_function_decl);
11140 /* Give this error as many times as there are occurrences,
11141 so that users can use Emacs compilation buffers to find
11142 and fix all such places. */
11143 pedwarn ("ANSI C++ does not permit named return values");
11145 if (return_id != NULL_TREE)
11147 if (DECL_NAME (decl) == NULL_TREE)
11149 DECL_NAME (decl) = return_id;
11150 DECL_ASSEMBLER_NAME (decl) = return_id;
11153 error ("return identifier `%s' already in place",
11154 IDENTIFIER_POINTER (DECL_NAME (decl)));
11157 /* Can't let this happen for constructors. */
11158 if (DECL_CONSTRUCTOR_P (current_function_decl))
11160 error ("can't redefine default return value for constructors");
11164 /* If we have a named return value, put that in our scope as well. */
11165 if (DECL_NAME (decl) != NULL_TREE)
11167 /* If this named return value comes in a register,
11168 put it in a pseudo-register. */
11169 if (DECL_REGISTER (decl))
11171 original_result_rtx = DECL_RTL (decl);
11172 DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
11175 /* Let `finish_decl' know that this initializer is ok. */
11176 DECL_INITIAL (decl) = init;
11178 finish_decl (decl, init, NULL_TREE, 0, LOOKUP_ONLYCONVERTING);
11183 /* Finish up a function declaration and compile that function
11184 all the way to assembler language output. The free the storage
11185 for the function definition.
11187 This is called after parsing the body of the function definition.
11188 LINENO is the current line number.
11190 C++: CALL_POPLEVEL is non-zero if an extra call to poplevel
11191 (and expand_end_bindings) must be made to take care of the binding
11192 contour for the base initializers. This is only relevant for
11196 finish_function (lineno, call_poplevel, nested)
11201 register tree fndecl = current_function_decl;
11202 tree fntype, ctype = NULL_TREE;
11203 rtx head, last_parm_insn, mark;
11204 /* Label to use if this function is supposed to return a value. */
11205 tree no_return_label = NULL_TREE;
11206 tree decls = NULL_TREE;
11208 /* When we get some parse errors, we can end up without a
11209 current_function_decl, so cope. */
11210 if (fndecl == NULL_TREE)
11213 fntype = TREE_TYPE (fndecl);
11215 /* TREE_READONLY (fndecl) = 1;
11216 This caused &foo to be of type ptr-to-const-function
11217 which then got a warning when stored in a ptr-to-function variable. */
11219 /* This happens on strange parse errors. */
11220 if (! current_function_parms_stored)
11223 store_parm_decls ();
11226 if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
11228 tree ttype = target_type (fntype);
11231 if (IS_AGGR_TYPE (ttype))
11232 /* Let debugger know it should output info for this type. */
11233 note_debug_info_needed (ttype);
11235 for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
11237 ttype = target_type (TREE_TYPE (parmdecl));
11238 if (IS_AGGR_TYPE (ttype))
11239 /* Let debugger know it should output info for this type. */
11240 note_debug_info_needed (ttype);
11244 /* Clean house because we will need to reorder insns here. */
11245 do_pending_stack_adjust ();
11249 tree binfo = TYPE_BINFO (current_class_type);
11250 tree cond = integer_one_node;
11251 tree exprstmt, vfields;
11252 tree in_charge_node = lookup_name (in_charge_identifier, 0);
11254 int ok_to_optimize_dtor = 0;
11256 if (current_function_assigns_this)
11257 cond = build (NE_EXPR, boolean_type_node,
11258 current_class_decl, integer_zero_node);
11261 int n_baseclasses = CLASSTYPE_N_BASECLASSES (current_class_type);
11263 /* If this destructor is empty, then we don't need to check
11264 whether `this' is NULL in some cases. */
11265 mark = get_last_insn ();
11266 last_parm_insn = get_first_nonparm_insn ();
11268 if ((flag_this_is_variable & 1) == 0)
11269 ok_to_optimize_dtor = 1;
11270 else if (mark == last_parm_insn)
11271 ok_to_optimize_dtor
11272 = (n_baseclasses == 0
11273 || (n_baseclasses == 1
11274 && TYPE_HAS_DESTRUCTOR (TYPE_BINFO_BASETYPE (current_class_type, 0))));
11277 /* These initializations might go inline. Protect
11278 the binding level of the parms. */
11280 expand_start_bindings (0);
11282 if (current_function_assigns_this)
11284 current_function_assigns_this = 0;
11285 current_function_just_assigned_this = 0;
11288 /* Generate the code to call destructor on base class.
11289 If this destructor belongs to a class with virtual
11290 functions, then set the virtual function table
11291 pointer to represent the type of our base class. */
11293 /* This side-effect makes call to `build_delete' generate the
11294 code we have to have at the end of this destructor. */
11295 TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
11297 /* These are two cases where we cannot delegate deletion. */
11298 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)
11299 || TYPE_GETS_REG_DELETE (current_class_type))
11300 exprstmt = build_delete (current_class_type, C_C_D, integer_zero_node,
11301 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
11303 exprstmt = build_delete (current_class_type, C_C_D, in_charge_node,
11304 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
11306 /* If we did not assign to this, then `this' is non-zero at
11307 the end of a destructor. As a special optimization, don't
11308 emit test if this is an empty destructor. If it does nothing,
11309 it does nothing. If it calls a base destructor, the base
11310 destructor will perform the test. */
11312 if (exprstmt != error_mark_node
11313 && (TREE_CODE (exprstmt) != NOP_EXPR
11314 || TREE_OPERAND (exprstmt, 0) != integer_zero_node
11315 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
11317 expand_label (dtor_label);
11318 if (cond != integer_one_node)
11319 expand_start_cond (cond, 0);
11320 if (exprstmt != void_zero_node)
11321 /* Don't call `expand_expr_stmt' if we're not going to do
11322 anything, since -Wall will give a diagnostic. */
11323 expand_expr_stmt (exprstmt);
11325 /* Run destructor on all virtual baseclasses. */
11326 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
11328 tree vbases = nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type)));
11329 expand_start_cond (build (BIT_AND_EXPR, integer_type_node,
11330 in_charge_node, integer_two_node), 0);
11333 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases)))
11335 tree ptr = convert_pointer_to_vbase (vbases, current_class_decl);
11336 expand_expr_stmt (build_delete (TYPE_POINTER_TO (BINFO_TYPE (vbases)),
11337 ptr, integer_zero_node,
11338 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_HAS_IN_CHARGE, 0));
11340 vbases = TREE_CHAIN (vbases);
11342 expand_end_cond ();
11345 do_pending_stack_adjust ();
11346 if (cond != integer_one_node)
11347 expand_end_cond ();
11350 TYPE_HAS_DESTRUCTOR (current_class_type) = 1;
11352 virtual_size = c_sizeof (current_class_type);
11354 /* At the end, call delete if that's what's requested. */
11355 if (TYPE_GETS_REG_DELETE (current_class_type))
11356 /* This NOP_EXPR means we are in a static call context. */
11359 (build_indirect_ref
11360 (build1 (NOP_EXPR, TYPE_POINTER_TO (current_class_type),
11363 ansi_opname[(int) DELETE_EXPR],
11364 tree_cons (NULL_TREE, current_class_decl,
11365 build_tree_list (NULL_TREE, virtual_size)),
11366 NULL_TREE, LOOKUP_NORMAL);
11367 else if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
11368 exprstmt = build_x_delete (ptr_type_node, current_class_decl, 0,
11371 exprstmt = NULL_TREE;
11375 cond = build (BIT_AND_EXPR, integer_type_node,
11376 in_charge_node, integer_one_node);
11377 expand_start_cond (cond, 0);
11378 expand_expr_stmt (exprstmt);
11379 expand_end_cond ();
11382 /* End of destructor. */
11383 expand_end_bindings (NULL_TREE, getdecls() != NULL_TREE, 0);
11384 poplevel (2, 0, 0); /* XXX change to 1 */
11386 /* Back to the top of destructor. */
11387 /* Dont execute destructor code if `this' is NULL. */
11388 mark = get_last_insn ();
11389 last_parm_insn = get_first_nonparm_insn ();
11390 if (last_parm_insn == NULL_RTX)
11391 last_parm_insn = mark;
11393 last_parm_insn = previous_insn (last_parm_insn);
11395 /* Make all virtual function table pointers in non-virtual base
11396 classes point to CURRENT_CLASS_TYPE's virtual function
11398 expand_direct_vtbls_init (binfo, binfo, 1, 0, current_class_decl);
11399 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
11400 expand_indirect_vtbls_init (binfo, C_C_D, current_class_decl, 0);
11401 if (! ok_to_optimize_dtor)
11403 cond = build_binary_op (NE_EXPR,
11404 current_class_decl, integer_zero_node, 1);
11405 expand_start_cond (cond, 0);
11407 if (mark != get_last_insn ())
11408 reorder_insns (next_insn (mark), get_last_insn (), last_parm_insn);
11409 if (! ok_to_optimize_dtor)
11410 expand_end_cond ();
11412 else if (current_function_assigns_this)
11414 /* Does not need to call emit_base_init, because
11415 that is done (if needed) just after assignment to this
11418 if (DECL_CONSTRUCTOR_P (current_function_decl))
11420 end_protect_partials ();
11421 expand_label (ctor_label);
11422 ctor_label = NULL_TREE;
11426 decls = getdecls ();
11427 expand_end_bindings (decls, decls != NULL_TREE, 0);
11428 poplevel (decls != NULL_TREE, 0, 0);
11430 c_expand_return (current_class_decl);
11432 else if (TYPE_MAIN_VARIANT (TREE_TYPE (
11433 DECL_RESULT (current_function_decl))) != void_type_node
11434 && return_label != NULL_RTX)
11435 no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
11437 current_function_assigns_this = 0;
11438 current_function_just_assigned_this = 0;
11439 base_init_insns = NULL_RTX;
11441 else if (DECL_CONSTRUCTOR_P (fndecl))
11443 tree allocated_this;
11444 tree cond, thenclause;
11445 /* Allow constructor for a type to get a new instance of the object
11446 using `build_new'. */
11447 tree abstract_virtuals = CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type);
11448 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type) = NULL_TREE;
11450 DECL_RETURNS_FIRST_ARG (fndecl) = 1;
11452 if (flag_this_is_variable > 0)
11454 cond = build_binary_op (EQ_EXPR,
11455 current_class_decl, integer_zero_node, 1);
11456 thenclause = build_modify_expr (current_class_decl, NOP_EXPR,
11457 build_new (NULL_TREE, current_class_type, void_type_node, 0));
11460 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type) = abstract_virtuals;
11462 /* must keep the first insn safe. */
11463 head = get_insns ();
11465 /* this note will come up to the top with us. */
11466 mark = get_last_insn ();
11468 if (flag_this_is_variable > 0)
11470 expand_start_cond (cond, 0);
11471 expand_expr_stmt (thenclause);
11472 expand_end_cond ();
11476 if (DECL_NAME (fndecl) == NULL_TREE
11477 && TREE_CHAIN (DECL_ARGUMENTS (fndecl)) != NULL_TREE)
11478 build_default_constructor (fndecl);
11481 /* Emit insns from `emit_base_init' which sets up virtual
11482 function table pointer(s). */
11483 emit_insns (base_init_insns);
11484 base_init_insns = NULL_RTX;
11486 /* This is where the body of the constructor begins.
11487 If there were no insns in this function body, then the
11488 last_parm_insn is also the last insn.
11490 If optimization is enabled, last_parm_insn may move, so
11491 we don't hold on to it (across emit_base_init). */
11492 last_parm_insn = get_first_nonparm_insn ();
11493 if (last_parm_insn == NULL_RTX)
11494 last_parm_insn = mark;
11496 last_parm_insn = previous_insn (last_parm_insn);
11498 if (mark != get_last_insn ())
11499 reorder_insns (next_insn (mark), get_last_insn (), last_parm_insn);
11501 end_protect_partials ();
11503 /* This is where the body of the constructor ends. */
11504 expand_label (ctor_label);
11505 ctor_label = NULL_TREE;
11509 decls = getdecls ();
11510 expand_end_bindings (decls, decls != NULL_TREE, 0);
11511 poplevel (decls != NULL_TREE, 1, 0);
11514 c_expand_return (current_class_decl);
11516 current_function_assigns_this = 0;
11517 current_function_just_assigned_this = 0;
11519 else if (IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 4
11520 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main")
11521 && DECL_CONTEXT (fndecl) == NULL_TREE)
11523 /* Make it so that `main' always returns 0 by default. */
11525 c_expand_return (integer_one_node);
11527 c_expand_return (integer_zero_node);
11530 else if (return_label != NULL_RTX
11531 && current_function_return_value == NULL_TREE
11532 && ! DECL_NAME (DECL_RESULT (current_function_decl)))
11533 no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
11536 expand_gc_prologue_and_epilogue ();
11538 /* That's the end of the vtable decl's life. Need to mark it such
11539 if doing stupid register allocation.
11541 Note that current_vtable_decl is really an INDIRECT_REF
11542 on top of a VAR_DECL here. */
11543 if (obey_regdecls && current_vtable_decl)
11544 use_variable (DECL_RTL (TREE_OPERAND (current_vtable_decl, 0)));
11546 /* If this function is supposed to return a value, ensure that
11547 we do not fall into the cleanups by mistake. The end of our
11548 function will look like this:
11550 user code (may have return stmt somewhere)
11551 goto no_return_label
11556 NOTE_INSN_FUNCTION_END
11560 If the user omits a return stmt in the USER CODE section, we
11561 will have a control path which reaches NOTE_INSN_FUNCTION_END.
11562 Otherwise, we won't. */
11563 if (no_return_label)
11565 DECL_CONTEXT (no_return_label) = fndecl;
11566 DECL_INITIAL (no_return_label) = error_mark_node;
11567 DECL_SOURCE_FILE (no_return_label) = input_filename;
11568 DECL_SOURCE_LINE (no_return_label) = lineno;
11569 expand_goto (no_return_label);
11574 /* remove the binding contour which is used
11575 to catch cleanup-generated temporaries. */
11576 expand_end_bindings (0, 0, 0);
11577 poplevel (0, 0, 0);
11581 /* Emit label at beginning of cleanup code for parameters. */
11582 emit_label (cleanup_label);
11584 /* Get return value into register if that's where it's supposed to be. */
11585 if (original_result_rtx)
11586 fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
11588 /* Finish building code that will trigger warnings if users forget
11589 to make their functions return values. */
11590 if (no_return_label || cleanup_label)
11591 emit_jump (return_label);
11592 if (no_return_label)
11594 /* We don't need to call `expand_*_return' here because we
11595 don't need any cleanups here--this path of code is only
11596 for error checking purposes. */
11597 expand_label (no_return_label);
11600 /* Generate rtl for function exit. */
11601 expand_function_end (input_filename, lineno, 1);
11603 if (flag_handle_exceptions)
11604 expand_exception_blocks();
11606 /* This must come after expand_function_end because cleanups might
11607 have declarations (from inline functions) that need to go into
11608 this function's blocks. */
11609 if (current_binding_level->parm_flag != 1)
11610 my_friendly_abort (122);
11611 poplevel (1, 0, 1);
11613 /* reset scope for C++: if we were in the scope of a class,
11614 then when we finish this function, we are not longer so.
11615 This cannot be done until we know for sure that no more
11616 class members will ever be referenced in this function
11617 (i.e., calls to destructors). */
11618 if (current_class_name)
11620 ctype = current_class_type;
11621 pop_nested_class (1);
11624 pop_memoized_context (1);
11626 /* Must mark the RESULT_DECL as being in this function. */
11627 DECL_CONTEXT (DECL_RESULT (fndecl)) = DECL_INITIAL (fndecl);
11629 /* Obey `register' declarations if `setjmp' is called in this fn. */
11630 if (flag_traditional && current_function_calls_setjmp)
11631 setjmp_protect (DECL_INITIAL (fndecl));
11633 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
11634 to the FUNCTION_DECL node itself. */
11635 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
11637 /* So we can tell if jump_optimize sets it to 1. */
11640 /* Run the optimizers and output the assembler code for this function. */
11641 rest_of_compilation (fndecl);
11643 if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
11645 /* Set DECL_EXTERNAL so that assemble_external will be called as
11646 necessary. We'll clear it again in finish_file. */
11647 if (! DECL_EXTERNAL (fndecl))
11648 DECL_NOT_REALLY_EXTERN (fndecl) = 1;
11649 DECL_EXTERNAL (fndecl) = 1;
11650 mark_inline_for_output (fndecl);
11653 if (ctype && TREE_ASM_WRITTEN (fndecl))
11654 note_debug_info_needed (ctype);
11656 current_function_returns_null |= can_reach_end;
11658 /* Since we don't normally go through c_expand_return for constructors,
11659 this normally gets the wrong value.
11660 Also, named return values have their return codes emitted after
11661 NOTE_INSN_FUNCTION_END, confusing jump.c. */
11662 if (DECL_CONSTRUCTOR_P (fndecl)
11663 || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
11664 current_function_returns_null = 0;
11666 if (TREE_THIS_VOLATILE (fndecl) && current_function_returns_null)
11667 cp_warning ("`noreturn' function `%D' does return", fndecl);
11668 else if ((warn_return_type || pedantic)
11669 && current_function_returns_null
11670 && TYPE_MAIN_VARIANT (TREE_TYPE (fntype)) != void_type_node)
11672 /* If this function returns non-void and control can drop through,
11674 cp_pedwarn ("control reaches end of non-void function `%D'", fndecl);
11676 /* With just -W, complain only if function returns both with
11677 and without a value. */
11678 else if (extra_warnings
11679 && current_function_returns_value && current_function_returns_null)
11680 warning ("this function may return with or without a value");
11682 /* Free all the tree nodes making up this function. */
11683 /* Switch back to allocating nodes permanently
11684 until we start another function. */
11686 permanent_allocation (1);
11689 cadillac_finish_function (fndecl);
11691 if (DECL_SAVED_INSNS (fndecl) == NULL_RTX)
11693 /* Stop pointing to the local nodes about to be freed. */
11694 /* But DECL_INITIAL must remain nonzero so we know this
11695 was an actual function definition. */
11696 DECL_INITIAL (fndecl) = error_mark_node;
11697 if (! DECL_CONSTRUCTOR_P (fndecl)
11698 || !TYPE_USES_VIRTUAL_BASECLASSES (TYPE_METHOD_BASETYPE (fntype)))
11699 DECL_ARGUMENTS (fndecl) = NULL_TREE;
11702 if (DECL_STATIC_CONSTRUCTOR (fndecl))
11703 static_ctors = perm_tree_cons (NULL_TREE, fndecl, static_ctors);
11704 if (DECL_STATIC_DESTRUCTOR (fndecl))
11705 static_dtors = perm_tree_cons (NULL_TREE, fndecl, static_dtors);
11709 /* Let the error reporting routines know that we're outside a
11710 function. For a nested function, this value is used in
11711 pop_cp_function_context and then reset via pop_function_context. */
11712 current_function_decl = NULL_TREE;
11715 named_label_uses = NULL_TREE;
11718 /* Create the FUNCTION_DECL for a function definition.
11719 LINE1 is the line number that the definition absolutely begins on.
11720 LINE2 is the line number that the name of the function appears on.
11721 DECLSPECS and DECLARATOR are the parts of the declaration;
11722 they describe the return type and the name of the function,
11723 but twisted together in a fashion that parallels the syntax of C.
11725 This function creates a binding context for the function body
11726 as well as setting up the FUNCTION_DECL in current_function_decl.
11728 Returns a FUNCTION_DECL on success.
11730 If the DECLARATOR is not suitable for a function (it defines a datum
11731 instead), we return 0, which tells yyparse to report a parse error.
11733 May return void_type_node indicating that this method is actually
11734 a friend. See grokfield for more details.
11736 Came here with a `.pushlevel' .
11738 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
11739 CHANGES TO CODE IN `grokfield'. */
11741 start_method (declspecs, declarator, raises)
11742 tree declarator, declspecs, raises;
11744 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0, raises);
11746 /* Something too ugly to handle. */
11747 if (fndecl == NULL_TREE)
11750 /* Pass friends other than inline friend functions back. */
11751 if (TYPE_MAIN_VARIANT (fndecl) == void_type_node)
11754 if (TREE_CODE (fndecl) != FUNCTION_DECL)
11755 /* Not a function, tell parser to report parse error. */
11758 if (IS_SIGNATURE (current_class_type))
11760 IS_DEFAULT_IMPLEMENTATION (fndecl) = 1;
11761 /* In case we need this info later. */
11762 HAS_DEFAULT_IMPLEMENTATION (current_class_type) = 1;
11765 if (DECL_IN_AGGR_P (fndecl))
11767 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
11769 if (DECL_CONTEXT (fndecl))
11770 cp_error ("`%D' is already defined in class %s", fndecl,
11771 TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
11773 return void_type_node;
11776 DECL_THIS_INLINE (fndecl) = 1;
11778 if (flag_default_inline)
11779 DECL_INLINE (fndecl) = 1;
11781 if (processing_template_defn)
11783 SET_DECL_IMPLICIT_INSTANTIATION (fndecl);
11784 repo_template_used (fndecl);
11787 /* We read in the parameters on the maybepermanent_obstack,
11788 but we won't be getting back to them until after we
11789 may have clobbered them. So the call to preserve_data
11790 will keep them safe. */
11793 if (! DECL_FRIEND_P (fndecl))
11795 if (DECL_CHAIN (fndecl) != NULL_TREE)
11797 /* Need a fresh node here so that we don't get circularity
11798 when we link these together. If FNDECL was a friend, then
11799 `pushdecl' does the right thing, which is nothing wrt its
11800 current value of DECL_CHAIN. */
11801 fndecl = copy_node (fndecl);
11803 if (TREE_CHAIN (fndecl))
11805 fndecl = copy_node (fndecl);
11806 TREE_CHAIN (fndecl) = NULL_TREE;
11809 if (DECL_CONSTRUCTOR_P (fndecl))
11811 if (! grok_ctor_properties (current_class_type, fndecl))
11812 return void_type_node;
11814 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
11815 grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
11818 finish_decl (fndecl, NULL_TREE, NULL_TREE, 0, 0);
11820 /* Make a place for the parms */
11822 current_binding_level->parm_flag = 1;
11824 DECL_IN_AGGR_P (fndecl) = 1;
11828 /* Go through the motions of finishing a function definition.
11829 We don't compile this method until after the whole class has
11832 FINISH_METHOD must return something that looks as though it
11833 came from GROKFIELD (since we are defining a method, after all).
11835 This is called after parsing the body of the function definition.
11836 STMTS is the chain of statements that makes up the function body.
11838 DECL is the ..._DECL that `start_method' provided. */
11841 finish_method (decl)
11844 register tree fndecl = decl;
11847 register tree link;
11849 if (TYPE_MAIN_VARIANT (decl) == void_type_node)
11852 old_initial = DECL_INITIAL (fndecl);
11854 /* Undo the level for the parms (from start_method).
11855 This is like poplevel, but it causes nothing to be
11856 saved. Saving information here confuses symbol-table
11857 output routines. Besides, this information will
11858 be correctly output when this method is actually
11861 /* Clear out the meanings of the local variables of this level;
11862 also record in each decl which block it belongs to. */
11864 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
11866 if (DECL_NAME (link) != NULL_TREE)
11867 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
11868 my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
11869 DECL_CONTEXT (link) = NULL_TREE;
11872 /* Restore all name-meanings of the outer levels
11873 that were shadowed by this level. */
11875 for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
11876 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
11877 for (link = current_binding_level->class_shadowed;
11878 link; link = TREE_CHAIN (link))
11879 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
11880 for (link = current_binding_level->type_shadowed;
11881 link; link = TREE_CHAIN (link))
11882 IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
11884 GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
11885 (HOST_WIDE_INT) current_binding_level->level_chain,
11886 current_binding_level->parm_flag,
11887 current_binding_level->keep,
11888 current_binding_level->tag_transparent);
11890 poplevel (0, 0, 0);
11892 DECL_INITIAL (fndecl) = old_initial;
11894 /* We used to check if the context of FNDECL was different from
11895 current_class_type as another way to get inside here. This didn't work
11896 for String.cc in libg++. */
11897 if (DECL_FRIEND_P (fndecl))
11899 CLASSTYPE_INLINE_FRIENDS (current_class_type)
11900 = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
11901 decl = void_type_node;
11907 /* Called when a new struct TYPE is defined.
11908 If this structure or union completes the type of any previous
11909 variable declaration, lay it out and output its rtl. */
11912 hack_incomplete_structures (type)
11917 if (current_binding_level->n_incomplete == 0)
11920 if (!type) /* Don't do this for class templates. */
11923 for (decl = current_binding_level->names; decl; decl = TREE_CHAIN (decl))
11924 if (TREE_TYPE (decl) == type
11925 || (TREE_TYPE (decl)
11926 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
11927 && TREE_TYPE (TREE_TYPE (decl)) == type))
11929 if (TREE_CODE (decl) == TYPE_DECL)
11930 layout_type (TREE_TYPE (decl));
11933 int toplevel = global_binding_level == current_binding_level;
11934 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
11935 && TREE_TYPE (TREE_TYPE (decl)) == type)
11936 layout_type (TREE_TYPE (decl));
11937 layout_decl (decl, 0);
11938 rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
11942 expand_decl (decl);
11943 cleanup = maybe_build_cleanup (decl);
11944 expand_decl_init (decl);
11945 if (! expand_decl_cleanup (decl, cleanup))
11946 cp_error ("parser lost in parsing declaration of `%D'",
11951 my_friendly_assert (current_binding_level->n_incomplete > 0, 164);
11953 --current_binding_level->n_incomplete;
11957 /* Nonzero if presently building a cleanup. Needed because
11958 SAVE_EXPRs are not the right things to use inside of cleanups.
11959 They are only ever evaluated once, where the cleanup
11960 might be evaluated several times. In this case, a later evaluation
11961 of the cleanup might fill in the SAVE_EXPR_RTL, and it will
11962 not be valid for an earlier cleanup. */
11964 int building_cleanup;
11966 /* If DECL is of a type which needs a cleanup, build that cleanup here.
11967 We don't build cleanups if just going for syntax checking, since
11968 fixup_cleanups does not know how to not handle them.
11970 Don't build these on the momentary obstack; they must live
11971 the life of the binding contour. */
11973 maybe_build_cleanup (decl)
11976 tree type = TREE_TYPE (decl);
11977 if (TYPE_NEEDS_DESTRUCTOR (type))
11979 int temp = 0, flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
11981 int old_building_cleanup = building_cleanup;
11982 building_cleanup = 1;
11984 if (TREE_CODE (decl) != PARM_DECL)
11985 temp = suspend_momentary ();
11987 if (TREE_CODE (type) == ARRAY_TYPE)
11991 mark_addressable (decl);
11992 rval = build_unary_op (ADDR_EXPR, decl, 0);
11995 /* Optimize for space over speed here. */
11996 if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
11997 || flag_expensive_optimizations)
11998 flags |= LOOKUP_NONVIRTUAL;
12000 rval = build_delete (TREE_TYPE (rval), rval, integer_two_node, flags, 0);
12002 if (TYPE_USES_VIRTUAL_BASECLASSES (type)
12003 && ! TYPE_HAS_DESTRUCTOR (type))
12004 rval = build_compound_expr (tree_cons (NULL_TREE, rval,
12005 build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
12007 if (TREE_CODE (decl) != PARM_DECL)
12008 resume_momentary (temp);
12010 building_cleanup = old_building_cleanup;
12017 /* Expand a C++ expression at the statement level.
12018 This is needed to ferret out nodes which have UNKNOWN_TYPE.
12019 The C++ type checker should get all of these out when
12020 expressions are combined with other, type-providing, expressions,
12021 leaving only orphan expressions, such as:
12023 &class::bar; / / takes its address, but does nothing with it.
12027 cplus_expand_expr_stmt (exp)
12030 if (TREE_TYPE (exp) == unknown_type_node)
12032 if (TREE_CODE (exp) == ADDR_EXPR || TREE_CODE (exp) == TREE_LIST)
12033 error ("address of overloaded function with no contextual type information");
12034 else if (TREE_CODE (exp) == COMPONENT_REF)
12035 warning ("useless reference to a member function name, did you forget the ()?");
12039 int remove_implicit_immediately = 0;
12041 if (TREE_CODE (exp) == FUNCTION_DECL)
12043 cp_warning ("reference, not call, to function `%D'", exp);
12044 warning ("at this point in file");
12048 /* We should do this eventually, but right now this causes regex.o from
12049 libg++ to miscompile, and tString to core dump. */
12050 exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
12052 expand_expr_stmt (break_out_cleanups (exp));
12055 /* Clean up any pending cleanups. This happens when a function call
12056 returns a cleanup-needing value that nobody uses. */
12057 expand_cleanups_to (NULL_TREE);
12060 /* When a stmt has been parsed, this function is called.
12062 Currently, this function only does something within a
12063 constructor's scope: if a stmt has just assigned to this,
12064 and we are in a derived class, we call `emit_base_init'. */
12069 extern struct nesting *cond_stack, *loop_stack, *case_stack;
12072 if (current_function_assigns_this
12073 || ! current_function_just_assigned_this)
12075 if (DECL_CONSTRUCTOR_P (current_function_decl))
12077 /* Constructors must wait until we are out of control
12078 zones before calling base constructors. */
12079 if (cond_stack || loop_stack || case_stack)
12081 emit_insns (base_init_insns);
12082 check_base_init (current_class_type);
12084 current_function_assigns_this = 1;
12087 cadillac_finish_stmt ();
12090 /* Change a static member function definition into a FUNCTION_TYPE, instead
12091 of the METHOD_TYPE that we create when it's originally parsed.
12093 WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
12094 (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
12095 other decls. Either pass the addresses of local variables or NULL. */
12098 revert_static_member_fn (decl, fn, argtypes)
12099 tree *decl, *fn, *argtypes;
12102 tree function = fn ? *fn : TREE_TYPE (*decl);
12103 tree args = argtypes ? *argtypes : TYPE_ARG_TYPES (function);
12105 args = TREE_CHAIN (args);
12106 tmp = build_function_type (TREE_TYPE (function), args);
12107 tmp = build_type_variant (tmp, TYPE_READONLY (function),
12108 TYPE_VOLATILE (function));
12109 tmp = build_exception_variant (TYPE_METHOD_BASETYPE (function), tmp,
12110 TYPE_RAISES_EXCEPTIONS (function));
12111 TREE_TYPE (*decl) = tmp;
12112 DECL_STATIC_FUNCTION_P (*decl) = 1;
12120 id_in_current_class (id)
12123 return !!purpose_member (id, class_binding_level->class_shadowed);
12130 int warn_about_return_type;
12132 int just_assigned_this;
12134 int temp_name_counter;
12136 tree shadowed_labels;
12141 rtx base_init_insns;
12142 struct cp_function *next;
12143 struct binding_level *binding_level;
12146 struct cp_function *cp_function_chain;
12148 extern int temp_name_counter;
12150 /* Save and reinitialize the variables
12151 used during compilation of a C++ function. */
12154 push_cp_function_context (context)
12157 struct cp_function *p
12158 = (struct cp_function *) xmalloc (sizeof (struct cp_function));
12160 push_function_context_to (context);
12162 p->next = cp_function_chain;
12163 cp_function_chain = p;
12165 p->named_labels = named_labels;
12166 p->shadowed_labels = shadowed_labels;
12167 p->returns_value = current_function_returns_value;
12168 p->returns_null = current_function_returns_null;
12169 p->warn_about_return_type = warn_about_return_type;
12170 p->binding_level = current_binding_level;
12171 p->ctor_label = ctor_label;
12172 p->dtor_label = dtor_label;
12173 p->assigns_this = current_function_assigns_this;
12174 p->just_assigned_this = current_function_just_assigned_this;
12175 p->parms_stored = current_function_parms_stored;
12176 p->result_rtx = original_result_rtx;
12177 p->base_init_insns = base_init_insns;
12178 p->protect_list = protect_list;
12179 p->temp_name_counter = temp_name_counter;
12182 /* Restore the variables used during compilation of a C++ function. */
12185 pop_cp_function_context (context)
12188 struct cp_function *p = cp_function_chain;
12191 /* Bring back all the labels that were shadowed. */
12192 for (link = shadowed_labels; link; link = TREE_CHAIN (link))
12193 if (DECL_NAME (TREE_VALUE (link)) != 0)
12194 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)),
12195 TREE_VALUE (link));
12198 if (DECL_SAVED_INSNS (current_function_decl) == 0)
12200 /* Stop pointing to the local nodes about to be freed. */
12201 /* But DECL_INITIAL must remain nonzero so we know this
12202 was an actual function definition. */
12203 DECL_INITIAL (current_function_decl) = error_mark_node;
12204 DECL_ARGUMENTS (current_function_decl) = 0;
12208 pop_function_context_from (context);
12210 cp_function_chain = p->next;
12212 named_labels = p->named_labels;
12213 shadowed_labels = p->shadowed_labels;
12214 current_function_returns_value = p->returns_value;
12215 current_function_returns_null = p->returns_null;
12216 warn_about_return_type = p->warn_about_return_type;
12217 current_binding_level = p->binding_level;
12218 ctor_label = p->ctor_label;
12219 dtor_label = p->dtor_label;
12220 protect_list = p->protect_list;
12221 current_function_assigns_this = p->assigns_this;
12222 current_function_just_assigned_this = p->just_assigned_this;
12223 current_function_parms_stored = p->parms_stored;
12224 original_result_rtx = p->result_rtx;
12225 base_init_insns = p->base_init_insns;
12226 temp_name_counter = p->temp_name_counter;