1 /* Perform the semantic phase of parsing, i.e., the process of
2 building tree structure, checking semantic consistency, and
3 building RTL. These routines are used both during actual parsing
4 and during the instantiation of template functions.
6 Copyright (C) 1998, 1999, 2000, 2001, 2002,
7 2003, 2004 Free Software Foundation, Inc.
8 Written by Mark Mitchell (mmitchell@usa.net) based on code found
9 formerly in parse.y and pt.c.
11 This file is part of GCC.
13 GCC is free software; you can redistribute it and/or modify it
14 under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2, or (at your option)
18 GCC is distributed in the hope that it will be useful, but
19 WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with GCC; see the file COPYING. If not, write to the Free
25 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
30 #include "coretypes.h"
34 #include "tree-inline.h"
46 /* There routines provide a modular interface to perform many parsing
47 operations. They may therefore be used during actual parsing, or
48 during template instantiation, which may be regarded as a
49 degenerate form of parsing. Since the current g++ parser is
50 lacking in several respects, and will be reimplemented, we are
51 attempting to move most code that is not directly related to
52 parsing into this file; that will make implementing the new parser
53 much easier since it will be able to make use of these routines. */
55 static tree maybe_convert_cond (tree);
56 static tree simplify_aggr_init_exprs_r (tree *, int *, void *);
57 static void emit_associated_thunks (tree);
58 static void genrtl_try_block (tree);
59 static void genrtl_eh_spec_block (tree);
60 static void genrtl_handler (tree);
61 static void cp_expand_stmt (tree);
64 /* Finish processing the COND, the SUBSTMT condition for STMT. */
66 #define FINISH_COND(COND, STMT, SUBSTMT) \
68 if (last_tree != (STMT)) \
70 RECHAIN_STMTS (STMT, SUBSTMT); \
71 if (!processing_template_decl) \
73 (COND) = build_tree_list (SUBSTMT, COND); \
81 /* Deferred Access Checking Overview
82 ---------------------------------
84 Most C++ expressions and declarations require access checking
85 to be performed during parsing. However, in several cases,
86 this has to be treated differently.
88 For member declarations, access checking has to be deferred
89 until more information about the declaration is known. For
101 When we are parsing the function return type `A::X', we don't
102 really know if this is allowed until we parse the function name.
104 Furthermore, some contexts require that access checking is
105 never performed at all. These include class heads, and template
108 Typical use of access checking functions is described here:
110 1. When we enter a context that requires certain access checking
111 mode, the function `push_deferring_access_checks' is called with
112 DEFERRING argument specifying the desired mode. Access checking
113 may be performed immediately (dk_no_deferred), deferred
114 (dk_deferred), or not performed (dk_no_check).
116 2. When a declaration such as a type, or a variable, is encountered,
117 the function `perform_or_defer_access_check' is called. It
118 maintains a TREE_LIST of all deferred checks.
120 3. The global `current_class_type' or `current_function_decl' is then
121 setup by the parser. `enforce_access' relies on these information
124 4. Upon exiting the context mentioned in step 1,
125 `perform_deferred_access_checks' is called to check all declaration
126 stored in the TREE_LIST. `pop_deferring_access_checks' is then
127 called to restore the previous access checking mode.
129 In case of parsing error, we simply call `pop_deferring_access_checks'
130 without `perform_deferred_access_checks'. */
132 /* Data for deferred access checking. */
133 static GTY(()) deferred_access *deferred_access_stack;
134 static GTY(()) deferred_access *deferred_access_free_list;
136 /* Save the current deferred access states and start deferred
137 access checking iff DEFER_P is true. */
140 push_deferring_access_checks (deferring_kind deferring)
144 /* For context like template instantiation, access checking
145 disabling applies to all nested context. */
146 if (deferred_access_stack
147 && deferred_access_stack->deferring_access_checks_kind == dk_no_check)
148 deferring = dk_no_check;
150 /* Recycle previously used free store if available. */
151 if (deferred_access_free_list)
153 d = deferred_access_free_list;
154 deferred_access_free_list = d->next;
157 d = ggc_alloc (sizeof (deferred_access));
159 d->next = deferred_access_stack;
160 d->deferred_access_checks = NULL_TREE;
161 d->deferring_access_checks_kind = deferring;
162 deferred_access_stack = d;
165 /* Resume deferring access checks again after we stopped doing
169 resume_deferring_access_checks (void)
171 if (deferred_access_stack->deferring_access_checks_kind == dk_no_deferred)
172 deferred_access_stack->deferring_access_checks_kind = dk_deferred;
175 /* Stop deferring access checks. */
178 stop_deferring_access_checks (void)
180 if (deferred_access_stack->deferring_access_checks_kind == dk_deferred)
181 deferred_access_stack->deferring_access_checks_kind = dk_no_deferred;
184 /* Discard the current deferred access checks and restore the
188 pop_deferring_access_checks (void)
190 deferred_access *d = deferred_access_stack;
191 deferred_access_stack = d->next;
193 /* Remove references to access checks TREE_LIST. */
194 d->deferred_access_checks = NULL_TREE;
196 /* Store in free list for later use. */
197 d->next = deferred_access_free_list;
198 deferred_access_free_list = d;
201 /* Returns a TREE_LIST representing the deferred checks.
202 The TREE_PURPOSE of each node is the type through which the
203 access occurred; the TREE_VALUE is the declaration named.
207 get_deferred_access_checks (void)
209 return deferred_access_stack->deferred_access_checks;
212 /* Take current deferred checks and combine with the
213 previous states if we also defer checks previously.
214 Otherwise perform checks now. */
217 pop_to_parent_deferring_access_checks (void)
219 tree deferred_check = get_deferred_access_checks ();
220 deferred_access *d1 = deferred_access_stack;
221 deferred_access *d2 = deferred_access_stack->next;
222 deferred_access *d3 = deferred_access_stack->next->next;
224 /* Temporary swap the order of the top two states, just to make
225 sure the garbage collector will not reclaim the memory during
227 deferred_access_stack = d2;
231 for ( ; deferred_check; deferred_check = TREE_CHAIN (deferred_check))
232 /* Perform deferred check if required. */
233 perform_or_defer_access_check (TREE_PURPOSE (deferred_check),
234 TREE_VALUE (deferred_check));
236 deferred_access_stack = d1;
239 pop_deferring_access_checks ();
242 /* Perform the deferred access checks.
244 After performing the checks, we still have to keep the list
245 `deferred_access_stack->deferred_access_checks' since we may want
246 to check access for them again later in a different context.
253 A::X A::a, x; // No error for `A::a', error for `x'
255 We have to perform deferred access of `A::X', first with `A::a',
259 perform_deferred_access_checks (void)
262 for (deferred_check = deferred_access_stack->deferred_access_checks;
264 deferred_check = TREE_CHAIN (deferred_check))
266 enforce_access (TREE_PURPOSE (deferred_check),
267 TREE_VALUE (deferred_check));
270 /* Defer checking the accessibility of DECL, when looked up in
274 perform_or_defer_access_check (tree binfo, tree decl)
278 my_friendly_assert (TREE_CODE (binfo) == TREE_VEC, 20030623);
280 /* If we are not supposed to defer access checks, just check now. */
281 if (deferred_access_stack->deferring_access_checks_kind == dk_no_deferred)
283 enforce_access (binfo, decl);
286 /* Exit if we are in a context that no access checking is performed. */
287 else if (deferred_access_stack->deferring_access_checks_kind == dk_no_check)
290 /* See if we are already going to perform this check. */
291 for (check = deferred_access_stack->deferred_access_checks;
293 check = TREE_CHAIN (check))
294 if (TREE_VALUE (check) == decl && TREE_PURPOSE (check) == binfo)
296 /* If not, record the check. */
297 deferred_access_stack->deferred_access_checks
298 = tree_cons (binfo, decl,
299 deferred_access_stack->deferred_access_checks);
302 /* Returns nonzero if the current statement is a full expression,
303 i.e. temporaries created during that statement should be destroyed
304 at the end of the statement. */
307 stmts_are_full_exprs_p (void)
309 return current_stmt_tree ()->stmts_are_full_exprs_p;
312 /* Returns the stmt_tree (if any) to which statements are currently
313 being added. If there is no active statement-tree, NULL is
317 current_stmt_tree (void)
320 ? &cfun->language->base.x_stmt_tree
321 : &scope_chain->x_stmt_tree);
324 /* Nonzero if TYPE is an anonymous union or struct type. We have to use a
325 flag for this because "A union for which objects or pointers are
326 declared is not an anonymous union" [class.union]. */
329 anon_aggr_type_p (tree node)
331 return ANON_AGGR_TYPE_P (node);
334 /* Finish a scope. */
339 tree block = NULL_TREE;
341 if (stmts_are_full_exprs_p ())
343 tree scope_stmts = NULL_TREE;
345 block = poplevel (kept_level_p (), 1, 0);
346 if (!processing_template_decl)
348 /* This needs to come after the poplevel so that partial scopes
349 are properly nested. */
350 scope_stmts = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/0);
353 SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
354 SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
362 /* Begin a new scope. */
365 do_pushlevel (scope_kind sk)
367 if (stmts_are_full_exprs_p ())
369 if (!processing_template_decl)
370 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/0);
371 begin_scope (sk, NULL);
375 /* Finish a goto-statement. */
378 finish_goto_stmt (tree destination)
380 if (TREE_CODE (destination) == IDENTIFIER_NODE)
381 destination = lookup_label (destination);
383 /* We warn about unused labels with -Wunused. That means we have to
384 mark the used labels as used. */
385 if (TREE_CODE (destination) == LABEL_DECL)
386 TREE_USED (destination) = 1;
389 /* The DESTINATION is being used as an rvalue. */
390 if (!processing_template_decl)
391 destination = decay_conversion (destination);
392 /* We don't inline calls to functions with computed gotos.
393 Those functions are typically up to some funny business,
394 and may be depending on the labels being at particular
395 addresses, or some such. */
396 DECL_UNINLINABLE (current_function_decl) = 1;
399 check_goto (destination);
401 return add_stmt (build_stmt (GOTO_STMT, destination));
404 /* COND is the condition-expression for an if, while, etc.,
405 statement. Convert it to a boolean value, if appropriate. */
408 maybe_convert_cond (tree cond)
410 /* Empty conditions remain empty. */
414 /* Wait until we instantiate templates before doing conversion. */
415 if (processing_template_decl)
418 /* Do the conversion. */
419 cond = convert_from_reference (cond);
420 return condition_conversion (cond);
423 /* Finish an expression-statement, whose EXPRESSION is as indicated. */
426 finish_expr_stmt (tree expr)
430 if (expr != NULL_TREE)
432 if (!processing_template_decl)
433 expr = convert_to_void (expr, "statement");
434 else if (!type_dependent_expression_p (expr))
435 convert_to_void (build_non_dependent_expr (expr), "statement");
437 r = add_stmt (build_stmt (EXPR_STMT, expr));
446 /* Begin an if-statement. Returns a newly created IF_STMT if
453 do_pushlevel (sk_block);
454 r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
459 /* Process the COND of an if-statement, which may be given by
463 finish_if_stmt_cond (tree cond, tree if_stmt)
465 cond = maybe_convert_cond (cond);
466 FINISH_COND (cond, if_stmt, IF_COND (if_stmt));
469 /* Finish the then-clause of an if-statement, which may be given by
473 finish_then_clause (tree if_stmt)
475 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
479 /* Begin the else-clause of an if-statement. */
482 begin_else_clause (void)
486 /* Finish the else-clause of an if-statement, which may be given by
490 finish_else_clause (tree if_stmt)
492 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
495 /* Finish an if-statement. */
498 finish_if_stmt (void)
504 /* Begin a while-statement. Returns a newly created WHILE_STMT if
508 begin_while_stmt (void)
511 r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
513 do_pushlevel (sk_block);
517 /* Process the COND of a while-statement, which may be given by
521 finish_while_stmt_cond (tree cond, tree while_stmt)
523 cond = maybe_convert_cond (cond);
524 if (processing_template_decl)
525 /* Don't mess with condition decls in a template. */
526 FINISH_COND (cond, while_stmt, WHILE_COND (while_stmt));
527 else if (getdecls () == NULL_TREE)
528 /* It was a simple condition; install it. */
529 WHILE_COND (while_stmt) = cond;
532 /* If there was a declaration in the condition, we can't leave it
536 while (true) { A x = 42; if (!x) break; } */
538 WHILE_COND (while_stmt) = boolean_true_node;
540 if_stmt = begin_if_stmt ();
541 cond = build_unary_op (TRUTH_NOT_EXPR, cond, 0);
542 finish_if_stmt_cond (cond, if_stmt);
543 finish_break_stmt ();
544 finish_then_clause (if_stmt);
549 /* Finish a while-statement, which may be given by WHILE_STMT. */
552 finish_while_stmt (tree while_stmt)
555 RECHAIN_STMTS (while_stmt, WHILE_BODY (while_stmt));
559 /* Begin a do-statement. Returns a newly created DO_STMT if
565 tree r = build_stmt (DO_STMT, NULL_TREE, NULL_TREE);
570 /* Finish the body of a do-statement, which may be given by DO_STMT. */
573 finish_do_body (tree do_stmt)
575 RECHAIN_STMTS (do_stmt, DO_BODY (do_stmt));
578 /* Finish a do-statement, which may be given by DO_STMT, and whose
579 COND is as indicated. */
582 finish_do_stmt (tree cond, tree do_stmt)
584 cond = maybe_convert_cond (cond);
585 DO_COND (do_stmt) = cond;
589 /* Finish a return-statement. The EXPRESSION returned, if any, is as
593 finish_return_stmt (tree expr)
597 expr = check_return_expr (expr);
598 if (!processing_template_decl)
600 if (DECL_DESTRUCTOR_P (current_function_decl))
602 /* Similarly, all destructors must run destructors for
603 base-classes before returning. So, all returns in a
604 destructor get sent to the DTOR_LABEL; finish_function emits
605 code to return a value there. */
606 return finish_goto_stmt (dtor_label);
609 r = add_stmt (build_stmt (RETURN_STMT, expr));
615 /* Begin a for-statement. Returns a new FOR_STMT if appropriate. */
618 begin_for_stmt (void)
622 r = build_stmt (FOR_STMT, NULL_TREE, NULL_TREE,
623 NULL_TREE, NULL_TREE);
624 NEW_FOR_SCOPE_P (r) = flag_new_for_scope > 0;
625 if (NEW_FOR_SCOPE_P (r))
626 do_pushlevel (sk_for);
632 /* Finish the for-init-statement of a for-statement, which may be
633 given by FOR_STMT. */
636 finish_for_init_stmt (tree for_stmt)
638 if (last_tree != for_stmt)
639 RECHAIN_STMTS (for_stmt, FOR_INIT_STMT (for_stmt));
640 do_pushlevel (sk_block);
643 /* Finish the COND of a for-statement, which may be given by
647 finish_for_cond (tree cond, tree for_stmt)
649 cond = maybe_convert_cond (cond);
650 if (processing_template_decl)
651 /* Don't mess with condition decls in a template. */
652 FINISH_COND (cond, for_stmt, FOR_COND (for_stmt));
653 else if (getdecls () == NULL_TREE)
654 /* It was a simple condition; install it. */
655 FOR_COND (for_stmt) = cond;
658 /* If there was a declaration in the condition, we can't leave it
660 for (; A x = 42;) { }
662 for (;;) { A x = 42; if (!x) break; } */
664 FOR_COND (for_stmt) = NULL_TREE;
666 if_stmt = begin_if_stmt ();
667 cond = build_unary_op (TRUTH_NOT_EXPR, cond, 0);
668 finish_if_stmt_cond (cond, if_stmt);
669 finish_break_stmt ();
670 finish_then_clause (if_stmt);
675 /* Finish the increment-EXPRESSION in a for-statement, which may be
676 given by FOR_STMT. */
679 finish_for_expr (tree expr, tree for_stmt)
681 /* If EXPR is an overloaded function, issue an error; there is no
682 context available to use to perform overload resolution. */
683 if (expr && type_unknown_p (expr))
685 cxx_incomplete_type_error (expr, TREE_TYPE (expr));
686 expr = error_mark_node;
688 FOR_EXPR (for_stmt) = expr;
691 /* Finish the body of a for-statement, which may be given by
692 FOR_STMT. The increment-EXPR for the loop must be
696 finish_for_stmt (tree for_stmt)
698 /* Pop the scope for the body of the loop. */
700 RECHAIN_STMTS (for_stmt, FOR_BODY (for_stmt));
701 if (NEW_FOR_SCOPE_P (for_stmt))
706 /* Finish a break-statement. */
709 finish_break_stmt (void)
711 return add_stmt (build_break_stmt ());
714 /* Finish a continue-statement. */
717 finish_continue_stmt (void)
719 return add_stmt (build_continue_stmt ());
722 /* Begin a switch-statement. Returns a new SWITCH_STMT if
726 begin_switch_stmt (void)
729 do_pushlevel (sk_block);
730 r = build_stmt (SWITCH_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
735 /* Finish the cond of a switch-statement. */
738 finish_switch_cond (tree cond, tree switch_stmt)
740 tree orig_type = NULL;
741 if (!processing_template_decl)
745 /* Convert the condition to an integer or enumeration type. */
746 cond = build_expr_type_conversion (WANT_INT | WANT_ENUM, cond, true);
747 if (cond == NULL_TREE)
749 error ("switch quantity not an integer");
750 cond = error_mark_node;
752 orig_type = TREE_TYPE (cond);
753 if (cond != error_mark_node)
757 Integral promotions are performed. */
758 cond = perform_integral_promotions (cond);
759 cond = fold (build1 (CLEANUP_POINT_EXPR, TREE_TYPE (cond), cond));
762 if (cond != error_mark_node)
764 index = get_unwidened (cond, NULL_TREE);
765 /* We can't strip a conversion from a signed type to an unsigned,
766 because if we did, int_fits_type_p would do the wrong thing
767 when checking case values for being in range,
768 and it's too hard to do the right thing. */
769 if (TREE_UNSIGNED (TREE_TYPE (cond))
770 == TREE_UNSIGNED (TREE_TYPE (index)))
774 FINISH_COND (cond, switch_stmt, SWITCH_COND (switch_stmt));
775 SWITCH_TYPE (switch_stmt) = orig_type;
776 push_switch (switch_stmt);
779 /* Finish the body of a switch-statement, which may be given by
780 SWITCH_STMT. The COND to switch on is indicated. */
783 finish_switch_stmt (tree switch_stmt)
785 RECHAIN_STMTS (switch_stmt, SWITCH_BODY (switch_stmt));
791 /* Generate the RTL for T, which is a TRY_BLOCK. */
794 genrtl_try_block (tree t)
798 expand_eh_region_start ();
799 expand_stmt (TRY_STMTS (t));
800 expand_eh_region_end_cleanup (TRY_HANDLERS (t));
804 if (!FN_TRY_BLOCK_P (t))
805 emit_line_note (input_location);
807 expand_eh_region_start ();
808 expand_stmt (TRY_STMTS (t));
810 if (FN_TRY_BLOCK_P (t))
812 expand_start_all_catch ();
813 in_function_try_handler = 1;
814 expand_stmt (TRY_HANDLERS (t));
815 in_function_try_handler = 0;
816 expand_end_all_catch ();
820 expand_start_all_catch ();
821 expand_stmt (TRY_HANDLERS (t));
822 expand_end_all_catch ();
827 /* Generate the RTL for T, which is an EH_SPEC_BLOCK. */
830 genrtl_eh_spec_block (tree t)
832 expand_eh_region_start ();
833 expand_stmt (EH_SPEC_STMTS (t));
834 expand_eh_region_end_allowed (EH_SPEC_RAISES (t),
835 build_call (call_unexpected_node,
836 tree_cons (NULL_TREE,
841 /* Begin a try-block. Returns a newly-created TRY_BLOCK if
845 begin_try_block (void)
847 tree r = build_stmt (TRY_BLOCK, NULL_TREE, NULL_TREE);
852 /* Likewise, for a function-try-block. */
855 begin_function_try_block (void)
857 tree r = build_stmt (TRY_BLOCK, NULL_TREE, NULL_TREE);
858 FN_TRY_BLOCK_P (r) = 1;
863 /* Finish a try-block, which may be given by TRY_BLOCK. */
866 finish_try_block (tree try_block)
868 RECHAIN_STMTS (try_block, TRY_STMTS (try_block));
871 /* Finish the body of a cleanup try-block, which may be given by
875 finish_cleanup_try_block (tree try_block)
877 RECHAIN_STMTS (try_block, TRY_STMTS (try_block));
880 /* Finish an implicitly generated try-block, with a cleanup is given
884 finish_cleanup (tree cleanup, tree try_block)
886 TRY_HANDLERS (try_block) = cleanup;
887 CLEANUP_P (try_block) = 1;
890 /* Likewise, for a function-try-block. */
893 finish_function_try_block (tree try_block)
895 if (TREE_CHAIN (try_block)
896 && TREE_CODE (TREE_CHAIN (try_block)) == CTOR_INITIALIZER)
898 /* Chain the compound statement after the CTOR_INITIALIZER. */
899 TREE_CHAIN (TREE_CHAIN (try_block)) = last_tree;
900 /* And make the CTOR_INITIALIZER the body of the try-block. */
901 RECHAIN_STMTS (try_block, TRY_STMTS (try_block));
904 RECHAIN_STMTS (try_block, TRY_STMTS (try_block));
905 in_function_try_handler = 1;
908 /* Finish a handler-sequence for a try-block, which may be given by
912 finish_handler_sequence (tree try_block)
914 RECHAIN_STMTS (try_block, TRY_HANDLERS (try_block));
915 check_handlers (TRY_HANDLERS (try_block));
918 /* Likewise, for a function-try-block. */
921 finish_function_handler_sequence (tree try_block)
923 in_function_try_handler = 0;
924 RECHAIN_STMTS (try_block, TRY_HANDLERS (try_block));
925 check_handlers (TRY_HANDLERS (try_block));
928 /* Generate the RTL for T, which is a HANDLER. */
931 genrtl_handler (tree t)
933 genrtl_do_pushlevel ();
934 if (!processing_template_decl)
935 expand_start_catch (HANDLER_TYPE (t));
936 expand_stmt (HANDLER_BODY (t));
937 if (!processing_template_decl)
941 /* Begin a handler. Returns a HANDLER if appropriate. */
947 r = build_stmt (HANDLER, NULL_TREE, NULL_TREE);
949 /* Create a binding level for the eh_info and the exception object
951 do_pushlevel (sk_catch);
955 /* Finish the handler-parameters for a handler, which may be given by
956 HANDLER. DECL is the declaration for the catch parameter, or NULL
957 if this is a `catch (...)' clause. */
960 finish_handler_parms (tree decl, tree handler)
962 tree type = NULL_TREE;
963 if (processing_template_decl)
967 decl = pushdecl (decl);
968 decl = push_template_decl (decl);
969 add_decl_stmt (decl);
970 RECHAIN_STMTS (handler, HANDLER_PARMS (handler));
971 type = TREE_TYPE (decl);
975 type = expand_start_catch_block (decl);
977 HANDLER_TYPE (handler) = type;
978 if (!processing_template_decl && type)
979 mark_used (eh_type_info (type));
982 /* Finish a handler, which may be given by HANDLER. The BLOCKs are
983 the return value from the matching call to finish_handler_parms. */
986 finish_handler (tree handler)
988 if (!processing_template_decl)
989 expand_end_catch_block ();
991 RECHAIN_STMTS (handler, HANDLER_BODY (handler));
994 /* Begin a compound-statement. If HAS_NO_SCOPE is true, the
995 compound-statement does not define a scope. Returns a new
999 begin_compound_stmt (bool has_no_scope)
1004 r = build_stmt (COMPOUND_STMT, NULL_TREE);
1006 if (last_tree && TREE_CODE (last_tree) == TRY_BLOCK)
1011 COMPOUND_STMT_NO_SCOPE (r) = 1;
1013 last_expr_type = NULL_TREE;
1016 do_pushlevel (is_try ? sk_try : sk_block);
1018 /* Normally, we try hard to keep the BLOCK for a
1019 statement-expression. But, if it's a statement-expression with
1020 a scopeless block, there's nothing to keep, and we don't want
1021 to accidentally keep a block *inside* the scopeless block. */
1022 keep_next_level (false);
1027 /* Finish a compound-statement, which is given by COMPOUND_STMT. */
1030 finish_compound_stmt (tree compound_stmt)
1035 if (COMPOUND_STMT_NO_SCOPE (compound_stmt))
1040 RECHAIN_STMTS (compound_stmt, COMPOUND_BODY (compound_stmt));
1042 /* When we call finish_stmt we will lose LAST_EXPR_TYPE. But, since
1043 the precise purpose of that variable is store the type of the
1044 last expression statement within the last compound statement, we
1045 preserve the value. */
1053 /* Finish an asm-statement, whose components are a CV_QUALIFIER, a
1054 STRING, some OUTPUT_OPERANDS, some INPUT_OPERANDS, and some
1058 finish_asm_stmt (tree cv_qualifier,
1060 tree output_operands,
1061 tree input_operands,
1067 if (cv_qualifier != NULL_TREE
1068 && cv_qualifier != ridpointers[(int) RID_VOLATILE])
1070 warning ("%s qualifier ignored on asm",
1071 IDENTIFIER_POINTER (cv_qualifier));
1072 cv_qualifier = NULL_TREE;
1075 if (!processing_template_decl)
1081 for (t = input_operands; t; t = TREE_CHAIN (t))
1083 tree converted_operand
1084 = decay_conversion (TREE_VALUE (t));
1086 /* If the type of the operand hasn't been determined (e.g.,
1087 because it involves an overloaded function), then issue
1088 an error message. There's no context available to
1089 resolve the overloading. */
1090 if (TREE_TYPE (converted_operand) == unknown_type_node)
1092 error ("type of asm operand `%E' could not be determined",
1094 converted_operand = error_mark_node;
1096 TREE_VALUE (t) = converted_operand;
1099 ninputs = list_length (input_operands);
1100 noutputs = list_length (output_operands);
1102 for (i = 0, t = output_operands; t; t = TREE_CHAIN (t), ++i)
1107 const char *constraint;
1110 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
1111 operand = TREE_VALUE (t);
1113 if (!parse_output_constraint (&constraint,
1114 i, ninputs, noutputs,
1119 /* By marking this operand as erroneous, we will not try
1120 to process this operand again in expand_asm_operands. */
1121 TREE_VALUE (t) = error_mark_node;
1125 /* If the operand is a DECL that is going to end up in
1126 memory, assume it is addressable. This is a bit more
1127 conservative than it would ideally be; the exact test is
1128 buried deep in expand_asm_operands and depends on the
1129 DECL_RTL for the OPERAND -- which we don't have at this
1131 if (!allows_reg && DECL_P (operand))
1132 cxx_mark_addressable (operand);
1136 r = build_stmt (ASM_STMT, cv_qualifier, string,
1137 output_operands, input_operands,
1139 return add_stmt (r);
1142 /* Finish a label with the indicated NAME. */
1145 finish_label_stmt (tree name)
1147 tree decl = define_label (input_location, name);
1148 return add_stmt (build_stmt (LABEL_STMT, decl));
1151 /* Finish a series of declarations for local labels. G++ allows users
1152 to declare "local" labels, i.e., labels with scope. This extension
1153 is useful when writing code involving statement-expressions. */
1156 finish_label_decl (tree name)
1158 tree decl = declare_local_label (name);
1159 add_decl_stmt (decl);
1162 /* When DECL goes out of scope, make sure that CLEANUP is executed. */
1165 finish_decl_cleanup (tree decl, tree cleanup)
1167 add_stmt (build_stmt (CLEANUP_STMT, decl, cleanup));
1170 /* If the current scope exits with an exception, run CLEANUP. */
1173 finish_eh_cleanup (tree cleanup)
1175 tree r = build_stmt (CLEANUP_STMT, NULL_TREE, cleanup);
1176 CLEANUP_EH_ONLY (r) = 1;
1180 /* The MEM_INITS is a list of mem-initializers, in reverse of the
1181 order they were written by the user. Each node is as for
1182 emit_mem_initializers. */
1185 finish_mem_initializers (tree mem_inits)
1187 /* Reorder the MEM_INITS so that they are in the order they appeared
1188 in the source program. */
1189 mem_inits = nreverse (mem_inits);
1191 if (processing_template_decl)
1192 add_stmt (build_min_nt (CTOR_INITIALIZER, mem_inits));
1194 emit_mem_initializers (mem_inits);
1197 /* Returns the stack of SCOPE_STMTs for the current function. */
1200 current_scope_stmt_stack (void)
1202 return &cfun->language->base.x_scope_stmt_stack;
1205 /* Finish a parenthesized expression EXPR. */
1208 finish_parenthesized_expr (tree expr)
1210 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (expr))))
1211 /* This inhibits warnings in c_common_truthvalue_conversion. */
1212 C_SET_EXP_ORIGINAL_CODE (expr, ERROR_MARK);
1214 if (TREE_CODE (expr) == OFFSET_REF)
1215 /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
1216 enclosed in parentheses. */
1217 PTRMEM_OK_P (expr) = 0;
1221 /* Finish a reference to a non-static data member (DECL) that is not
1222 preceded by `.' or `->'. */
1225 finish_non_static_data_member (tree decl, tree object, tree qualifying_scope)
1227 my_friendly_assert (TREE_CODE (decl) == FIELD_DECL, 20020909);
1231 if (current_function_decl
1232 && DECL_STATIC_FUNCTION_P (current_function_decl))
1233 cp_error_at ("invalid use of member `%D' in static member function",
1236 cp_error_at ("invalid use of non-static data member `%D'", decl);
1237 error ("from this location");
1239 return error_mark_node;
1241 TREE_USED (current_class_ptr) = 1;
1242 if (processing_template_decl && !qualifying_scope)
1244 tree type = TREE_TYPE (decl);
1246 if (TREE_CODE (type) == REFERENCE_TYPE)
1247 type = TREE_TYPE (type);
1250 /* Set the cv qualifiers. */
1251 int quals = cp_type_quals (TREE_TYPE (current_class_ref));
1253 if (DECL_MUTABLE_P (decl))
1254 quals &= ~TYPE_QUAL_CONST;
1256 quals |= cp_type_quals (TREE_TYPE (decl));
1257 type = cp_build_qualified_type (type, quals);
1260 return build_min (COMPONENT_REF, type, object, decl);
1264 tree access_type = TREE_TYPE (object);
1265 tree lookup_context = context_for_name_lookup (decl);
1267 while (!DERIVED_FROM_P (lookup_context, access_type))
1269 access_type = TYPE_CONTEXT (access_type);
1270 while (access_type && DECL_P (access_type))
1271 access_type = DECL_CONTEXT (access_type);
1275 cp_error_at ("object missing in reference to `%D'", decl);
1276 error ("from this location");
1277 return error_mark_node;
1281 /* If PROCESSING_TEMPLATE_DECL is nonzero here, then
1282 QUALIFYING_SCOPE is also non-null. Wrap this in a SCOPE_REF
1284 if (processing_template_decl)
1285 return build_min (SCOPE_REF, TREE_TYPE (decl),
1286 qualifying_scope, DECL_NAME (decl));
1288 perform_or_defer_access_check (TYPE_BINFO (access_type), decl);
1290 /* If the data member was named `C::M', convert `*this' to `C'
1292 if (qualifying_scope)
1294 tree binfo = NULL_TREE;
1295 object = build_scoped_ref (object, qualifying_scope,
1299 return build_class_member_access_expr (object, decl,
1300 /*access_path=*/NULL_TREE,
1301 /*preserve_reference=*/false);
1305 /* DECL was the declaration to which a qualified-id resolved. Issue
1306 an error message if it is not accessible. If OBJECT_TYPE is
1307 non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
1308 type of `*x', or `x', respectively. If the DECL was named as
1309 `A::B' then NESTED_NAME_SPECIFIER is `A'. */
1312 check_accessibility_of_qualified_id (tree decl,
1314 tree nested_name_specifier)
1317 tree qualifying_type = NULL_TREE;
1319 /* Determine the SCOPE of DECL. */
1320 scope = context_for_name_lookup (decl);
1321 /* If the SCOPE is not a type, then DECL is not a member. */
1322 if (!TYPE_P (scope))
1324 /* Compute the scope through which DECL is being accessed. */
1326 /* OBJECT_TYPE might not be a class type; consider:
1328 class A { typedef int I; };
1332 In this case, we will have "A::I" as the DECL, but "I" as the
1334 && CLASS_TYPE_P (object_type)
1335 && DERIVED_FROM_P (scope, object_type))
1336 /* If we are processing a `->' or `.' expression, use the type of the
1338 qualifying_type = object_type;
1339 else if (nested_name_specifier)
1341 /* If the reference is to a non-static member of the
1342 current class, treat it as if it were referenced through
1344 if (DECL_NONSTATIC_MEMBER_P (decl)
1345 && current_class_ptr
1346 && DERIVED_FROM_P (scope, current_class_type))
1347 qualifying_type = current_class_type;
1348 /* Otherwise, use the type indicated by the
1349 nested-name-specifier. */
1351 qualifying_type = nested_name_specifier;
1354 /* Otherwise, the name must be from the current class or one of
1356 qualifying_type = currently_open_derived_class (scope);
1358 if (qualifying_type)
1359 perform_or_defer_access_check (TYPE_BINFO (qualifying_type), decl);
1362 /* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
1363 class named to the left of the "::" operator. DONE is true if this
1364 expression is a complete postfix-expression; it is false if this
1365 expression is followed by '->', '[', '(', etc. ADDRESS_P is true
1366 iff this expression is the operand of '&'. */
1369 finish_qualified_id_expr (tree qualifying_class, tree expr, bool done,
1372 if (error_operand_p (expr))
1373 return error_mark_node;
1375 /* If EXPR occurs as the operand of '&', use special handling that
1376 permits a pointer-to-member. */
1377 if (address_p && done)
1379 if (TREE_CODE (expr) == SCOPE_REF)
1380 expr = TREE_OPERAND (expr, 1);
1381 expr = build_offset_ref (qualifying_class, expr,
1382 /*address_p=*/true);
1386 if (TREE_CODE (expr) == FIELD_DECL)
1387 expr = finish_non_static_data_member (expr, current_class_ref,
1389 else if (BASELINK_P (expr) && !processing_template_decl)
1394 /* See if any of the functions are non-static members. */
1395 fns = BASELINK_FUNCTIONS (expr);
1396 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
1397 fns = TREE_OPERAND (fns, 0);
1398 for (fn = fns; fn; fn = OVL_NEXT (fn))
1399 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1401 /* If so, the expression may be relative to the current
1403 if (fn && current_class_type
1404 && DERIVED_FROM_P (qualifying_class, current_class_type))
1405 expr = (build_class_member_access_expr
1406 (maybe_dummy_object (qualifying_class, NULL),
1408 BASELINK_ACCESS_BINFO (expr),
1409 /*preserve_reference=*/false));
1411 /* The expression is a qualified name whose address is not
1413 expr = build_offset_ref (qualifying_class, expr, /*address_p=*/false);
1419 /* Begin a statement-expression. The value returned must be passed to
1420 finish_stmt_expr. */
1423 begin_stmt_expr (void)
1425 /* If we're outside a function, we won't have a statement-tree to
1426 work with. But, if we see a statement-expression we need to
1428 if (! cfun && !last_tree)
1429 begin_stmt_tree (&scope_chain->x_saved_tree);
1431 last_expr_type = NULL_TREE;
1433 keep_next_level (true);
1438 /* Process the final expression of a statement expression. EXPR can be
1439 NULL, if the final expression is empty. Build up a TARGET_EXPR so
1440 that the result value can be safely returned to the enclosing
1444 finish_stmt_expr_expr (tree expr)
1446 tree result = NULL_TREE;
1447 tree type = void_type_node;
1451 type = TREE_TYPE (expr);
1453 if (!processing_template_decl && !VOID_TYPE_P (TREE_TYPE (expr)))
1455 if (TREE_CODE (type) == ARRAY_TYPE
1456 || TREE_CODE (type) == FUNCTION_TYPE)
1457 expr = decay_conversion (expr);
1459 expr = convert_from_reference (expr);
1460 expr = require_complete_type (expr);
1462 /* Build a TARGET_EXPR for this aggregate. finish_stmt_expr
1463 will then pull it apart so the lifetime of the target is
1464 within the scope of the expression containing this statement
1466 if (TREE_CODE (expr) == TARGET_EXPR)
1468 else if (!IS_AGGR_TYPE (type) || TYPE_HAS_TRIVIAL_INIT_REF (type))
1469 expr = build_target_expr_with_type (expr, type);
1472 /* Copy construct. */
1473 expr = build_special_member_call
1474 (NULL_TREE, complete_ctor_identifier,
1475 build_tree_list (NULL_TREE, expr),
1476 TYPE_BINFO (type), LOOKUP_NORMAL);
1477 expr = build_cplus_new (type, expr);
1478 my_friendly_assert (TREE_CODE (expr) == TARGET_EXPR, 20030729);
1482 if (expr != error_mark_node)
1484 result = build_stmt (EXPR_STMT, expr);
1491 /* Remember the last expression so that finish_stmt_expr can pull it
1493 last_expr_type = result ? result : void_type_node;
1498 /* Finish a statement-expression. EXPR should be the value returned
1499 by the previous begin_stmt_expr. Returns an expression
1500 representing the statement-expression. */
1503 finish_stmt_expr (tree rtl_expr, bool has_no_scope)
1506 tree result_stmt = last_expr_type;
1509 if (!last_expr_type)
1510 type = void_type_node;
1513 if (result_stmt == void_type_node)
1515 type = void_type_node;
1516 result_stmt = NULL_TREE;
1519 type = TREE_TYPE (EXPR_STMT_EXPR (result_stmt));
1522 result = build_min (STMT_EXPR, type, last_tree);
1523 TREE_SIDE_EFFECTS (result) = 1;
1524 STMT_EXPR_NO_SCOPE (result) = has_no_scope;
1526 last_expr_type = NULL_TREE;
1528 /* Remove the compound statement from the tree structure; it is
1529 now saved in the STMT_EXPR. */
1530 last_tree = rtl_expr;
1531 TREE_CHAIN (last_tree) = NULL_TREE;
1533 /* If we created a statement-tree for this statement-expression,
1536 && TREE_CHAIN (scope_chain->x_saved_tree) == NULL_TREE)
1537 finish_stmt_tree (&scope_chain->x_saved_tree);
1539 if (processing_template_decl)
1542 if (!VOID_TYPE_P (type))
1544 /* Pull out the TARGET_EXPR that is the final expression. Put
1545 the target's init_expr as the final expression and then put
1546 the statement expression itself as the target's init
1547 expr. Finally, return the target expression. */
1548 tree last_expr = EXPR_STMT_EXPR (result_stmt);
1550 my_friendly_assert (TREE_CODE (last_expr) == TARGET_EXPR, 20030729);
1551 EXPR_STMT_EXPR (result_stmt) = TREE_OPERAND (last_expr, 1);
1552 TREE_OPERAND (last_expr, 1) = result;
1558 /* Perform Koenig lookup. FN is the postfix-expression representing
1559 the function (or functions) to call; ARGS are the arguments to the
1560 call. Returns the functions to be considered by overload
1564 perform_koenig_lookup (tree fn, tree args)
1566 tree identifier = NULL_TREE;
1567 tree functions = NULL_TREE;
1569 /* Find the name of the overloaded function. */
1570 if (TREE_CODE (fn) == IDENTIFIER_NODE)
1572 else if (is_overloaded_fn (fn))
1575 identifier = DECL_NAME (get_first_fn (functions));
1577 else if (DECL_P (fn))
1580 identifier = DECL_NAME (fn);
1583 /* A call to a namespace-scope function using an unqualified name.
1585 Do Koenig lookup -- unless any of the arguments are
1587 if (!any_type_dependent_arguments_p (args))
1589 fn = lookup_arg_dependent (identifier, functions, args);
1591 /* The unqualified name could not be resolved. */
1592 fn = unqualified_fn_lookup_error (identifier);
1600 /* Generate an expression for `FN (ARGS)'.
1602 If DISALLOW_VIRTUAL is true, the call to FN will be not generated
1603 as a virtual call, even if FN is virtual. (This flag is set when
1604 encountering an expression where the function name is explicitly
1605 qualified. For example a call to `X::f' never generates a virtual
1608 Returns code for the call. */
1611 finish_call_expr (tree fn, tree args, bool disallow_virtual, bool koenig_p)
1617 if (fn == error_mark_node || args == error_mark_node)
1618 return error_mark_node;
1620 /* ARGS should be a list of arguments. */
1621 my_friendly_assert (!args || TREE_CODE (args) == TREE_LIST,
1627 if (processing_template_decl)
1629 if (type_dependent_expression_p (fn)
1630 || any_type_dependent_arguments_p (args))
1632 result = build_nt (CALL_EXPR, fn, args);
1633 KOENIG_LOOKUP_P (result) = koenig_p;
1636 if (!BASELINK_P (fn)
1637 && TREE_CODE (fn) != PSEUDO_DTOR_EXPR
1638 && TREE_TYPE (fn) != unknown_type_node)
1639 fn = build_non_dependent_expr (fn);
1640 args = build_non_dependent_args (orig_args);
1643 /* A reference to a member function will appear as an overloaded
1644 function (rather than a BASELINK) if an unqualified name was used
1646 if (!BASELINK_P (fn) && is_overloaded_fn (fn))
1650 if (TREE_CODE (f) == TEMPLATE_ID_EXPR)
1651 f = TREE_OPERAND (f, 0);
1652 f = get_first_fn (f);
1653 if (DECL_FUNCTION_MEMBER_P (f))
1655 tree type = currently_open_derived_class (DECL_CONTEXT (f));
1657 type = DECL_CONTEXT (f);
1658 fn = build_baselink (TYPE_BINFO (type),
1660 fn, /*optype=*/NULL_TREE);
1665 if (BASELINK_P (fn))
1669 /* A call to a member function. From [over.call.func]:
1671 If the keyword this is in scope and refers to the class of
1672 that member function, or a derived class thereof, then the
1673 function call is transformed into a qualified function call
1674 using (*this) as the postfix-expression to the left of the
1675 . operator.... [Otherwise] a contrived object of type T
1676 becomes the implied object argument.
1678 This paragraph is unclear about this situation:
1680 struct A { void f(); };
1681 struct B : public A {};
1682 struct C : public A { void g() { B::f(); }};
1684 In particular, for `B::f', this paragraph does not make clear
1685 whether "the class of that member function" refers to `A' or
1686 to `B'. We believe it refers to `B'. */
1687 if (current_class_type
1688 && DERIVED_FROM_P (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
1690 && current_class_ref)
1691 object = maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
1695 tree representative_fn;
1697 representative_fn = BASELINK_FUNCTIONS (fn);
1698 if (TREE_CODE (representative_fn) == TEMPLATE_ID_EXPR)
1699 representative_fn = TREE_OPERAND (representative_fn, 0);
1700 representative_fn = get_first_fn (representative_fn);
1701 object = build_dummy_object (DECL_CONTEXT (representative_fn));
1704 if (processing_template_decl)
1706 if (type_dependent_expression_p (object))
1707 return build_nt (CALL_EXPR, orig_fn, orig_args);
1708 object = build_non_dependent_expr (object);
1711 result = build_new_method_call (object, fn, args, NULL_TREE,
1713 ? LOOKUP_NONVIRTUAL : 0));
1715 else if (is_overloaded_fn (fn))
1716 /* A call to a namespace-scope function. */
1717 result = build_new_function_call (fn, args);
1718 else if (TREE_CODE (fn) == PSEUDO_DTOR_EXPR)
1721 error ("arguments to destructor are not allowed");
1722 /* Mark the pseudo-destructor call as having side-effects so
1723 that we do not issue warnings about its use. */
1724 result = build1 (NOP_EXPR,
1726 TREE_OPERAND (fn, 0));
1727 TREE_SIDE_EFFECTS (result) = 1;
1729 else if (CLASS_TYPE_P (TREE_TYPE (fn)))
1730 /* If the "function" is really an object of class type, it might
1731 have an overloaded `operator ()'. */
1732 result = build_new_op (CALL_EXPR, LOOKUP_NORMAL, fn, args, NULL_TREE);
1734 /* A call where the function is unknown. */
1735 result = build_function_call (fn, args);
1737 if (processing_template_decl)
1739 result = build (CALL_EXPR, TREE_TYPE (result), orig_fn, orig_args);
1740 KOENIG_LOOKUP_P (result) = koenig_p;
1745 /* Finish a call to a postfix increment or decrement or EXPR. (Which
1746 is indicated by CODE, which should be POSTINCREMENT_EXPR or
1747 POSTDECREMENT_EXPR.) */
1750 finish_increment_expr (tree expr, enum tree_code code)
1752 return build_x_unary_op (code, expr);
1755 /* Finish a use of `this'. Returns an expression for `this'. */
1758 finish_this_expr (void)
1762 if (current_class_ptr)
1764 result = current_class_ptr;
1766 else if (current_function_decl
1767 && DECL_STATIC_FUNCTION_P (current_function_decl))
1769 error ("`this' is unavailable for static member functions");
1770 result = error_mark_node;
1774 if (current_function_decl)
1775 error ("invalid use of `this' in non-member function");
1777 error ("invalid use of `this' at top level");
1778 result = error_mark_node;
1784 /* Finish a pseudo-destructor expression. If SCOPE is NULL, the
1785 expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
1786 the TYPE for the type given. If SCOPE is non-NULL, the expression
1787 was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
1790 finish_pseudo_destructor_expr (tree object, tree scope, tree destructor)
1792 if (destructor == error_mark_node)
1793 return error_mark_node;
1795 my_friendly_assert (TYPE_P (destructor), 20010905);
1797 if (!processing_template_decl)
1799 if (scope == error_mark_node)
1801 error ("invalid qualifying scope in pseudo-destructor name");
1802 return error_mark_node;
1805 if (!same_type_p (TREE_TYPE (object), destructor))
1807 error ("`%E' is not of type `%T'", object, destructor);
1808 return error_mark_node;
1812 return build (PSEUDO_DTOR_EXPR, void_type_node, object, scope, destructor);
1815 /* Finish an expression of the form CODE EXPR. */
1818 finish_unary_op_expr (enum tree_code code, tree expr)
1820 tree result = build_x_unary_op (code, expr);
1821 /* Inside a template, build_x_unary_op does not fold the
1822 expression. So check whether the result is folded before
1823 setting TREE_NEGATED_INT. */
1824 if (code == NEGATE_EXPR && TREE_CODE (expr) == INTEGER_CST
1825 && TREE_CODE (result) == INTEGER_CST
1826 && !TREE_UNSIGNED (TREE_TYPE (result))
1827 && INT_CST_LT (result, integer_zero_node))
1828 TREE_NEGATED_INT (result) = 1;
1829 overflow_warning (result);
1833 /* Finish a compound-literal expression. TYPE is the type to which
1834 the INITIALIZER_LIST is being cast. */
1837 finish_compound_literal (tree type, tree initializer_list)
1839 tree compound_literal;
1841 /* Build a CONSTRUCTOR for the INITIALIZER_LIST. */
1842 compound_literal = build_constructor (NULL_TREE, initializer_list);
1843 /* Mark it as a compound-literal. */
1844 TREE_HAS_CONSTRUCTOR (compound_literal) = 1;
1845 if (processing_template_decl)
1846 TREE_TYPE (compound_literal) = type;
1849 /* Check the initialization. */
1850 compound_literal = digest_init (type, compound_literal, NULL);
1851 /* If the TYPE was an array type with an unknown bound, then we can
1852 figure out the dimension now. For example, something like:
1856 implies that the array has two elements. */
1857 if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
1858 complete_array_type (type, compound_literal, 1);
1861 return compound_literal;
1864 /* Return the declaration for the function-name variable indicated by
1868 finish_fname (tree id)
1872 decl = fname_decl (C_RID_CODE (id), id);
1873 if (processing_template_decl)
1874 decl = DECL_NAME (decl);
1878 /* Begin a function definition declared with DECL_SPECS, ATTRIBUTES,
1879 and DECLARATOR. Returns nonzero if the function-declaration is
1883 begin_function_definition (tree decl_specs, tree attributes, tree declarator)
1885 if (!start_function (decl_specs, declarator, attributes, SF_DEFAULT))
1888 /* The things we're about to see are not directly qualified by any
1889 template headers we've seen thus far. */
1890 reset_specialization ();
1895 /* Finish a translation unit. */
1898 finish_translation_unit (void)
1900 /* In case there were missing closebraces,
1901 get us back to the global binding level. */
1903 while (current_namespace != global_namespace)
1906 /* Do file scope __FUNCTION__ et al. */
1907 finish_fname_decls ();
1910 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
1911 Returns the parameter. */
1914 finish_template_type_parm (tree aggr, tree identifier)
1916 if (aggr != class_type_node)
1918 pedwarn ("template type parameters must use the keyword `class' or `typename'");
1919 aggr = class_type_node;
1922 return build_tree_list (aggr, identifier);
1925 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
1926 Returns the parameter. */
1929 finish_template_template_parm (tree aggr, tree identifier)
1931 tree decl = build_decl (TYPE_DECL, identifier, NULL_TREE);
1932 tree tmpl = build_lang_decl (TEMPLATE_DECL, identifier, NULL_TREE);
1933 DECL_TEMPLATE_PARMS (tmpl) = current_template_parms;
1934 DECL_TEMPLATE_RESULT (tmpl) = decl;
1935 DECL_ARTIFICIAL (decl) = 1;
1936 end_template_decl ();
1938 my_friendly_assert (DECL_TEMPLATE_PARMS (tmpl), 20010110);
1940 return finish_template_type_parm (aggr, tmpl);
1943 /* ARGUMENT is the default-argument value for a template template
1944 parameter. If ARGUMENT is invalid, issue error messages and return
1945 the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
1948 check_template_template_default_arg (tree argument)
1950 if (TREE_CODE (argument) != TEMPLATE_DECL
1951 && TREE_CODE (argument) != TEMPLATE_TEMPLATE_PARM
1952 && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
1954 if (TREE_CODE (argument) == TYPE_DECL)
1956 tree t = TREE_TYPE (argument);
1958 /* Try to emit a slightly smarter error message if we detect
1959 that the user is using a template instantiation. */
1960 if (CLASSTYPE_TEMPLATE_INFO (t)
1961 && CLASSTYPE_TEMPLATE_INSTANTIATION (t))
1962 error ("invalid use of type `%T' as a default value for a "
1963 "template template-parameter", t);
1965 error ("invalid use of `%D' as a default value for a template "
1966 "template-parameter", argument);
1969 error ("invalid default argument for a template template parameter");
1970 return error_mark_node;
1976 /* Finish a parameter list, indicated by PARMS. If ELLIPSIS is
1977 nonzero, the parameter list was terminated by a `...'. */
1980 finish_parmlist (tree parms, int ellipsis)
1984 /* We mark the PARMS as a parmlist so that declarator processing can
1985 disambiguate certain constructs. */
1986 TREE_PARMLIST (parms) = 1;
1987 /* We do not append void_list_node here, but leave it to grokparms
1989 PARMLIST_ELLIPSIS_P (parms) = ellipsis;
1994 /* Begin a class definition, as indicated by T. */
1997 begin_class_definition (tree t)
1999 if (t == error_mark_node)
2000 return error_mark_node;
2002 if (processing_template_parmlist)
2004 error ("definition of `%#T' inside template parameter list", t);
2005 return error_mark_node;
2007 /* A non-implicit typename comes from code like:
2009 template <typename T> struct A {
2010 template <typename U> struct A<T>::B ...
2012 This is erroneous. */
2013 else if (TREE_CODE (t) == TYPENAME_TYPE)
2015 error ("invalid definition of qualified type `%T'", t);
2016 t = error_mark_node;
2019 if (t == error_mark_node || ! IS_AGGR_TYPE (t))
2021 t = make_aggr_type (RECORD_TYPE);
2022 pushtag (make_anon_name (), t, 0);
2025 /* If this type was already complete, and we see another definition,
2027 if (COMPLETE_TYPE_P (t))
2029 error ("redefinition of `%#T'", t);
2030 cp_error_at ("previous definition of `%#T'", t);
2031 return error_mark_node;
2034 /* Update the location of the decl. */
2035 DECL_SOURCE_LOCATION (TYPE_NAME (t)) = input_location;
2037 if (TYPE_BEING_DEFINED (t))
2039 t = make_aggr_type (TREE_CODE (t));
2040 pushtag (TYPE_IDENTIFIER (t), t, 0);
2042 maybe_process_partial_specialization (t);
2044 TYPE_BEING_DEFINED (t) = 1;
2045 TYPE_PACKED (t) = flag_pack_struct;
2046 /* Reset the interface data, at the earliest possible
2047 moment, as it might have been set via a class foo;
2049 if (! TYPE_ANONYMOUS_P (t))
2051 CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
2052 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2053 (t, interface_unknown);
2055 reset_specialization();
2057 /* Make a declaration for this class in its own scope. */
2058 build_self_reference ();
2063 /* Finish the member declaration given by DECL. */
2066 finish_member_declaration (tree decl)
2068 if (decl == error_mark_node || decl == NULL_TREE)
2071 if (decl == void_type_node)
2072 /* The COMPONENT was a friend, not a member, and so there's
2073 nothing for us to do. */
2076 /* We should see only one DECL at a time. */
2077 my_friendly_assert (TREE_CHAIN (decl) == NULL_TREE, 0);
2079 /* Set up access control for DECL. */
2081 = (current_access_specifier == access_private_node);
2082 TREE_PROTECTED (decl)
2083 = (current_access_specifier == access_protected_node);
2084 if (TREE_CODE (decl) == TEMPLATE_DECL)
2086 TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl)) = TREE_PRIVATE (decl);
2087 TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl)) = TREE_PROTECTED (decl);
2090 /* Mark the DECL as a member of the current class. */
2091 DECL_CONTEXT (decl) = current_class_type;
2095 A C language linkage is ignored for the names of class members
2096 and the member function type of class member functions. */
2097 if (DECL_LANG_SPECIFIC (decl) && DECL_LANGUAGE (decl) == lang_c)
2098 SET_DECL_LANGUAGE (decl, lang_cplusplus);
2100 /* Put functions on the TYPE_METHODS list and everything else on the
2101 TYPE_FIELDS list. Note that these are built up in reverse order.
2102 We reverse them (to obtain declaration order) in finish_struct. */
2103 if (TREE_CODE (decl) == FUNCTION_DECL
2104 || DECL_FUNCTION_TEMPLATE_P (decl))
2106 /* We also need to add this function to the
2107 CLASSTYPE_METHOD_VEC. */
2108 add_method (current_class_type, decl, /*error_p=*/0);
2110 TREE_CHAIN (decl) = TYPE_METHODS (current_class_type);
2111 TYPE_METHODS (current_class_type) = decl;
2113 maybe_add_class_template_decl_list (current_class_type, decl,
2116 /* Enter the DECL into the scope of the class. */
2117 else if ((TREE_CODE (decl) == USING_DECL && TREE_TYPE (decl))
2118 || pushdecl_class_level (decl))
2120 /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
2121 go at the beginning. The reason is that lookup_field_1
2122 searches the list in order, and we want a field name to
2123 override a type name so that the "struct stat hack" will
2124 work. In particular:
2126 struct S { enum E { }; int E } s;
2129 is valid. In addition, the FIELD_DECLs must be maintained in
2130 declaration order so that class layout works as expected.
2131 However, we don't need that order until class layout, so we
2132 save a little time by putting FIELD_DECLs on in reverse order
2133 here, and then reversing them in finish_struct_1. (We could
2134 also keep a pointer to the correct insertion points in the
2137 if (TREE_CODE (decl) == TYPE_DECL)
2138 TYPE_FIELDS (current_class_type)
2139 = chainon (TYPE_FIELDS (current_class_type), decl);
2142 TREE_CHAIN (decl) = TYPE_FIELDS (current_class_type);
2143 TYPE_FIELDS (current_class_type) = decl;
2146 maybe_add_class_template_decl_list (current_class_type, decl,
2151 /* Finish processing the declaration of a member class template
2152 TYPES whose template parameters are given by PARMS. */
2155 finish_member_class_template (tree types)
2159 /* If there are declared, but undefined, partial specializations
2160 mixed in with the typespecs they will not yet have passed through
2161 maybe_process_partial_specialization, so we do that here. */
2162 for (t = types; t != NULL_TREE; t = TREE_CHAIN (t))
2163 if (IS_AGGR_TYPE_CODE (TREE_CODE (TREE_VALUE (t))))
2164 maybe_process_partial_specialization (TREE_VALUE (t));
2166 grok_x_components (types);
2167 if (TYPE_CONTEXT (TREE_VALUE (types)) != current_class_type)
2168 /* The component was in fact a friend declaration. We avoid
2169 finish_member_template_decl performing certain checks by
2173 finish_member_template_decl (types);
2175 /* As with other component type declarations, we do
2176 not store the new DECL on the list of
2181 /* Finish processing a complete template declaration. The PARMS are
2182 the template parameters. */
2185 finish_template_decl (tree parms)
2188 end_template_decl ();
2190 end_specialization ();
2193 /* Finish processing a template-id (which names a type) of the form
2194 NAME < ARGS >. Return the TYPE_DECL for the type named by the
2195 template-id. If ENTERING_SCOPE is nonzero we are about to enter
2196 the scope of template-id indicated. */
2199 finish_template_type (tree name, tree args, int entering_scope)
2203 decl = lookup_template_class (name, args,
2204 NULL_TREE, NULL_TREE, entering_scope,
2205 tf_error | tf_warning | tf_user);
2206 if (decl != error_mark_node)
2207 decl = TYPE_STUB_DECL (decl);
2212 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
2213 Return a TREE_LIST containing the ACCESS_SPECIFIER and the
2214 BASE_CLASS, or NULL_TREE if an error occurred. The
2215 ACCESS_SPECIFIER is one of
2216 access_{default,public,protected_private}[_virtual]_node.*/
2219 finish_base_specifier (tree base, tree access, bool virtual_p)
2223 if (base == error_mark_node)
2225 error ("invalid base-class specification");
2228 else if (! is_aggr_type (base, 1))
2232 if (cp_type_quals (base) != 0)
2234 error ("base class `%T' has cv qualifiers", base);
2235 base = TYPE_MAIN_VARIANT (base);
2237 result = build_tree_list (access, base);
2238 TREE_VIA_VIRTUAL (result) = virtual_p;
2244 /* Called when multiple declarators are processed. If that is not
2245 permitted in this context, an error is issued. */
2248 check_multiple_declarators (void)
2252 In a template-declaration, explicit specialization, or explicit
2253 instantiation the init-declarator-list in the declaration shall
2254 contain at most one declarator.
2256 We don't just use PROCESSING_TEMPLATE_DECL for the first
2257 condition since that would disallow the perfectly valid code,
2258 like `template <class T> struct S { int i, j; };'. */
2259 if (at_function_scope_p ())
2260 /* It's OK to write `template <class T> void f() { int i, j;}'. */
2263 if (PROCESSING_REAL_TEMPLATE_DECL_P ()
2264 || processing_explicit_instantiation
2265 || processing_specialization)
2266 error ("multiple declarators in template declaration");
2269 /* Issue a diagnostic that NAME cannot be found in SCOPE. */
2272 qualified_name_lookup_error (tree scope, tree name)
2276 if (!COMPLETE_TYPE_P (scope))
2277 error ("incomplete type `%T' used in nested name specifier", scope);
2279 error ("`%D' is not a member of `%T'", name, scope);
2281 else if (scope != global_namespace)
2282 error ("`%D' is not a member of `%D'", name, scope);
2284 error ("`::%D' has not been declared", name);
2287 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
2288 id-expression. (See cp_parser_id_expression for details.) SCOPE,
2289 if non-NULL, is the type or namespace used to explicitly qualify
2290 ID_EXPRESSION. DECL is the entity to which that name has been
2293 *CONSTANT_EXPRESSION_P is true if we are presently parsing a
2294 constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
2295 be set to true if this expression isn't permitted in a
2296 constant-expression, but it is otherwise not set by this function.
2297 *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
2298 constant-expression, but a non-constant expression is also
2301 If an error occurs, and it is the kind of error that might cause
2302 the parser to abort a tentative parse, *ERROR_MSG is filled in. It
2303 is the caller's responsibility to issue the message. *ERROR_MSG
2304 will be a string with static storage duration, so the caller need
2307 Return an expression for the entity, after issuing appropriate
2308 diagnostics. This function is also responsible for transforming a
2309 reference to a non-static member into a COMPONENT_REF that makes
2310 the use of "this" explicit.
2312 Upon return, *IDK will be filled in appropriately. */
2315 finish_id_expression (tree id_expression,
2319 tree *qualifying_class,
2320 bool integral_constant_expression_p,
2321 bool allow_non_integral_constant_expression_p,
2322 bool *non_integral_constant_expression_p,
2323 const char **error_msg)
2325 /* Initialize the output parameters. */
2326 *idk = CP_ID_KIND_NONE;
2329 if (id_expression == error_mark_node)
2330 return error_mark_node;
2331 /* If we have a template-id, then no further lookup is
2332 required. If the template-id was for a template-class, we
2333 will sometimes have a TYPE_DECL at this point. */
2334 else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2335 || TREE_CODE (decl) == TYPE_DECL)
2337 /* Look up the name. */
2340 if (decl == error_mark_node)
2342 /* Name lookup failed. */
2343 if (scope && (!TYPE_P (scope) || !dependent_type_p (scope)))
2345 /* Qualified name lookup failed, and the qualifying name
2346 was not a dependent type. That is always an
2348 qualified_name_lookup_error (scope, id_expression);
2349 return error_mark_node;
2353 /* It may be resolved via Koenig lookup. */
2354 *idk = CP_ID_KIND_UNQUALIFIED;
2355 return id_expression;
2358 /* If DECL is a variable that would be out of scope under
2359 ANSI/ISO rules, but in scope in the ARM, name lookup
2360 will succeed. Issue a diagnostic here. */
2362 decl = check_for_out_of_scope_variable (decl);
2364 /* Remember that the name was used in the definition of
2365 the current class so that we can check later to see if
2366 the meaning would have been different after the class
2367 was entirely defined. */
2368 if (!scope && decl != error_mark_node)
2369 maybe_note_name_used_in_class (id_expression, decl);
2372 /* If we didn't find anything, or what we found was a type,
2373 then this wasn't really an id-expression. */
2374 if (TREE_CODE (decl) == TEMPLATE_DECL
2375 && !DECL_FUNCTION_TEMPLATE_P (decl))
2377 *error_msg = "missing template arguments";
2378 return error_mark_node;
2380 else if (TREE_CODE (decl) == TYPE_DECL
2381 || TREE_CODE (decl) == NAMESPACE_DECL)
2383 *error_msg = "expected primary-expression";
2384 return error_mark_node;
2387 /* If the name resolved to a template parameter, there is no
2388 need to look it up again later. */
2389 if ((TREE_CODE (decl) == CONST_DECL && DECL_TEMPLATE_PARM_P (decl))
2390 || TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
2392 *idk = CP_ID_KIND_NONE;
2393 if (TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
2394 decl = TEMPLATE_PARM_DECL (decl);
2395 if (integral_constant_expression_p
2396 && !dependent_type_p (TREE_TYPE (decl))
2397 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (decl)))
2399 if (!allow_non_integral_constant_expression_p)
2400 error ("template parameter `%D' of type `%T' is not allowed in "
2401 "an integral constant expression because it is not of "
2402 "integral or enumeration type", decl, TREE_TYPE (decl));
2403 *non_integral_constant_expression_p = true;
2405 return DECL_INITIAL (decl);
2407 /* Similarly, we resolve enumeration constants to their
2408 underlying values. */
2409 else if (TREE_CODE (decl) == CONST_DECL)
2411 *idk = CP_ID_KIND_NONE;
2412 if (!processing_template_decl)
2413 return DECL_INITIAL (decl);
2420 /* If the declaration was explicitly qualified indicate
2421 that. The semantics of `A::f(3)' are different than
2422 `f(3)' if `f' is virtual. */
2424 ? CP_ID_KIND_QUALIFIED
2425 : (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2426 ? CP_ID_KIND_TEMPLATE_ID
2427 : CP_ID_KIND_UNQUALIFIED));
2432 An id-expression is type-dependent if it contains an
2433 identifier that was declared with a dependent type.
2435 The standard is not very specific about an id-expression that
2436 names a set of overloaded functions. What if some of them
2437 have dependent types and some of them do not? Presumably,
2438 such a name should be treated as a dependent name. */
2439 /* Assume the name is not dependent. */
2440 dependent_p = false;
2441 if (!processing_template_decl)
2442 /* No names are dependent outside a template. */
2444 /* A template-id where the name of the template was not resolved
2445 is definitely dependent. */
2446 else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2447 && (TREE_CODE (TREE_OPERAND (decl, 0))
2448 == IDENTIFIER_NODE))
2450 /* For anything except an overloaded function, just check its
2452 else if (!is_overloaded_fn (decl))
2454 = dependent_type_p (TREE_TYPE (decl));
2455 /* For a set of overloaded functions, check each of the
2461 if (BASELINK_P (fns))
2462 fns = BASELINK_FUNCTIONS (fns);
2464 /* For a template-id, check to see if the template
2465 arguments are dependent. */
2466 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
2468 tree args = TREE_OPERAND (fns, 1);
2469 dependent_p = any_dependent_template_arguments_p (args);
2470 /* The functions are those referred to by the
2472 fns = TREE_OPERAND (fns, 0);
2475 /* If there are no dependent template arguments, go through
2476 the overloaded functions. */
2477 while (fns && !dependent_p)
2479 tree fn = OVL_CURRENT (fns);
2481 /* Member functions of dependent classes are
2483 if (TREE_CODE (fn) == FUNCTION_DECL
2484 && type_dependent_expression_p (fn))
2486 else if (TREE_CODE (fn) == TEMPLATE_DECL
2487 && dependent_template_p (fn))
2490 fns = OVL_NEXT (fns);
2494 /* If the name was dependent on a template parameter, we will
2495 resolve the name at instantiation time. */
2498 /* Create a SCOPE_REF for qualified names, if the scope is
2503 *qualifying_class = scope;
2504 /* Since this name was dependent, the expression isn't
2505 constant -- yet. No error is issued because it might
2506 be constant when things are instantiated. */
2507 if (integral_constant_expression_p)
2508 *non_integral_constant_expression_p = true;
2509 if (TYPE_P (scope) && dependent_type_p (scope))
2510 return build_nt (SCOPE_REF, scope, id_expression);
2511 else if (TYPE_P (scope) && DECL_P (decl))
2512 return build (SCOPE_REF, TREE_TYPE (decl), scope,
2517 /* A TEMPLATE_ID already contains all the information we
2519 if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR)
2520 return id_expression;
2521 /* Since this name was dependent, the expression isn't
2522 constant -- yet. No error is issued because it might be
2523 constant when things are instantiated. */
2524 if (integral_constant_expression_p)
2525 *non_integral_constant_expression_p = true;
2526 *idk = CP_ID_KIND_UNQUALIFIED_DEPENDENT;
2527 /* If we found a variable, then name lookup during the
2528 instantiation will always resolve to the same VAR_DECL
2529 (or an instantiation thereof). */
2530 if (TREE_CODE (decl) == VAR_DECL)
2532 return id_expression;
2535 /* Only certain kinds of names are allowed in constant
2536 expression. Enumerators and template parameters
2537 have already been handled above. */
2538 if (integral_constant_expression_p)
2540 /* Const variables or static data members of integral or
2541 enumeration types initialized with constant expressions
2543 if (TREE_CODE (decl) == VAR_DECL
2544 && CP_TYPE_CONST_P (TREE_TYPE (decl))
2545 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (decl))
2546 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
2550 if (!allow_non_integral_constant_expression_p)
2552 error ("`%D' cannot appear in a constant-expression", decl);
2553 return error_mark_node;
2555 *non_integral_constant_expression_p = true;
2559 if (TREE_CODE (decl) == NAMESPACE_DECL)
2561 error ("use of namespace `%D' as expression", decl);
2562 return error_mark_node;
2564 else if (DECL_CLASS_TEMPLATE_P (decl))
2566 error ("use of class template `%T' as expression", decl);
2567 return error_mark_node;
2569 else if (TREE_CODE (decl) == TREE_LIST)
2571 /* Ambiguous reference to base members. */
2572 error ("request for member `%D' is ambiguous in "
2573 "multiple inheritance lattice", id_expression);
2574 print_candidates (decl);
2575 return error_mark_node;
2578 /* Mark variable-like entities as used. Functions are similarly
2579 marked either below or after overload resolution. */
2580 if (TREE_CODE (decl) == VAR_DECL
2581 || TREE_CODE (decl) == PARM_DECL
2582 || TREE_CODE (decl) == RESULT_DECL)
2587 decl = (adjust_result_of_qualified_name_lookup
2588 (decl, scope, current_class_type));
2590 if (TREE_CODE (decl) == FUNCTION_DECL)
2593 if (TREE_CODE (decl) == FIELD_DECL || BASELINK_P (decl))
2594 *qualifying_class = scope;
2595 else if (!processing_template_decl)
2596 decl = convert_from_reference (decl);
2597 else if (TYPE_P (scope))
2598 decl = build (SCOPE_REF, TREE_TYPE (decl), scope, decl);
2600 else if (TREE_CODE (decl) == FIELD_DECL)
2601 decl = finish_non_static_data_member (decl, current_class_ref,
2602 /*qualifying_scope=*/NULL_TREE);
2603 else if (is_overloaded_fn (decl))
2605 tree first_fn = OVL_CURRENT (decl);
2607 if (TREE_CODE (first_fn) == TEMPLATE_DECL)
2608 first_fn = DECL_TEMPLATE_RESULT (first_fn);
2610 if (!really_overloaded_fn (decl))
2611 mark_used (first_fn);
2613 if (TREE_CODE (first_fn) == FUNCTION_DECL
2614 && DECL_FUNCTION_MEMBER_P (first_fn))
2616 /* A set of member functions. */
2617 decl = maybe_dummy_object (DECL_CONTEXT (first_fn), 0);
2618 return finish_class_member_access_expr (decl, id_expression);
2623 if (TREE_CODE (decl) == VAR_DECL
2624 || TREE_CODE (decl) == PARM_DECL
2625 || TREE_CODE (decl) == RESULT_DECL)
2627 tree context = decl_function_context (decl);
2629 if (context != NULL_TREE && context != current_function_decl
2630 && ! TREE_STATIC (decl))
2632 error ("use of %s from containing function",
2633 (TREE_CODE (decl) == VAR_DECL
2634 ? "`auto' variable" : "parameter"));
2635 cp_error_at (" `%#D' declared here", decl);
2636 return error_mark_node;
2640 if (DECL_P (decl) && DECL_NONLOCAL (decl)
2641 && DECL_CLASS_SCOPE_P (decl)
2642 && DECL_CONTEXT (decl) != current_class_type)
2646 path = currently_open_derived_class (DECL_CONTEXT (decl));
2647 perform_or_defer_access_check (TYPE_BINFO (path), decl);
2650 if (! processing_template_decl)
2651 decl = convert_from_reference (decl);
2654 /* Resolve references to variables of anonymous unions
2655 into COMPONENT_REFs. */
2656 if (TREE_CODE (decl) == ALIAS_DECL)
2657 decl = DECL_INITIAL (decl);
2660 if (TREE_DEPRECATED (decl))
2661 warn_deprecated_use (decl);
2666 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
2667 use as a type-specifier. */
2670 finish_typeof (tree expr)
2674 if (type_dependent_expression_p (expr))
2676 type = make_aggr_type (TYPEOF_TYPE);
2677 TYPE_FIELDS (type) = expr;
2682 type = TREE_TYPE (expr);
2684 if (!type || type == unknown_type_node)
2686 error ("type of `%E' is unknown", expr);
2687 return error_mark_node;
2693 /* Generate RTL for the statement T, and its substatements, and any
2694 other statements at its nesting level. */
2697 cp_expand_stmt (tree t)
2699 switch (TREE_CODE (t))
2702 genrtl_try_block (t);
2706 genrtl_eh_spec_block (t);
2722 /* Called from expand_body via walk_tree. Replace all AGGR_INIT_EXPRs
2723 will equivalent CALL_EXPRs. */
2726 simplify_aggr_init_exprs_r (tree* tp,
2728 void* data ATTRIBUTE_UNUSED)
2730 /* We don't need to walk into types; there's nothing in a type that
2731 needs simplification. (And, furthermore, there are places we
2732 actively don't want to go. For example, we don't want to wander
2733 into the default arguments for a FUNCTION_DECL that appears in a
2740 /* Only AGGR_INIT_EXPRs are interesting. */
2741 else if (TREE_CODE (*tp) != AGGR_INIT_EXPR)
2744 simplify_aggr_init_expr (tp);
2746 /* Keep iterating. */
2750 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
2751 function is broken out from the above for the benefit of the tree-ssa
2755 simplify_aggr_init_expr (tree *tp)
2757 tree aggr_init_expr = *tp;
2759 /* Form an appropriate CALL_EXPR. */
2760 tree fn = TREE_OPERAND (aggr_init_expr, 0);
2761 tree args = TREE_OPERAND (aggr_init_expr, 1);
2762 tree slot = TREE_OPERAND (aggr_init_expr, 2);
2763 tree type = TREE_TYPE (aggr_init_expr);
2766 enum style_t { ctor, arg, pcc } style;
2768 if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr))
2770 #ifdef PCC_STATIC_STRUCT_RETURN
2774 else if (TREE_ADDRESSABLE (type))
2777 /* We shouldn't build an AGGR_INIT_EXPR if we don't need any special
2778 handling. See build_cplus_new. */
2781 if (style == ctor || style == arg)
2783 /* Pass the address of the slot. If this is a constructor, we
2784 replace the first argument; otherwise, we tack on a new one. */
2788 args = TREE_CHAIN (args);
2790 cxx_mark_addressable (slot);
2791 addr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (slot)), slot);
2794 /* The return type might have different cv-quals from the slot. */
2795 tree fntype = TREE_TYPE (TREE_TYPE (fn));
2796 #ifdef ENABLE_CHECKING
2797 if (TREE_CODE (fntype) != FUNCTION_TYPE
2798 && TREE_CODE (fntype) != METHOD_TYPE)
2801 addr = convert (build_pointer_type (TREE_TYPE (fntype)), addr);
2804 args = tree_cons (NULL_TREE, addr, args);
2807 call_expr = build (CALL_EXPR,
2808 TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
2809 fn, args, NULL_TREE);
2812 /* Tell the backend that we've added our return slot to the argument
2814 CALL_EXPR_HAS_RETURN_SLOT_ADDR (call_expr) = 1;
2815 else if (style == pcc)
2817 /* If we're using the non-reentrant PCC calling convention, then we
2818 need to copy the returned value out of the static buffer into the
2820 push_deferring_access_checks (dk_no_check);
2821 call_expr = build_aggr_init (slot, call_expr,
2822 DIRECT_BIND | LOOKUP_ONLYCONVERTING);
2823 pop_deferring_access_checks ();
2826 /* We want to use the value of the initialized location as the
2828 call_expr = build (COMPOUND_EXPR, type,
2831 /* Replace the AGGR_INIT_EXPR with the CALL_EXPR. */
2832 TREE_CHAIN (call_expr) = TREE_CHAIN (aggr_init_expr);
2836 /* Emit all thunks to FN that should be emitted when FN is emitted. */
2839 emit_associated_thunks (tree fn)
2841 /* When we use vcall offsets, we emit thunks with the virtual
2842 functions to which they thunk. The whole point of vcall offsets
2843 is so that you can know statically the entire set of thunks that
2844 will ever be needed for a given virtual function, thereby
2845 enabling you to output all the thunks with the function itself. */
2846 if (DECL_VIRTUAL_P (fn))
2850 for (thunk = DECL_THUNKS (fn); thunk; thunk = TREE_CHAIN (thunk))
2852 if (!THUNK_ALIAS (thunk))
2854 use_thunk (thunk, /*emit_p=*/1);
2855 if (DECL_RESULT_THUNK_P (thunk))
2859 for (probe = DECL_THUNKS (thunk);
2860 probe; probe = TREE_CHAIN (probe))
2861 use_thunk (probe, /*emit_p=*/1);
2865 my_friendly_assert (!DECL_THUNKS (thunk), 20031023);
2870 /* Generate RTL for FN. */
2873 expand_body (tree fn)
2875 tree saved_function;
2877 /* Compute the appropriate object-file linkage for inline
2879 if (DECL_DECLARED_INLINE_P (fn))
2880 import_export_decl (fn);
2882 /* If FN is external, then there's no point in generating RTL for
2883 it. This situation can arise with an inline function under
2884 `-fexternal-templates'; we instantiate the function, even though
2885 we're not planning on emitting it, in case we get a chance to
2887 if (DECL_EXTERNAL (fn))
2890 /* ??? When is this needed? */
2891 saved_function = current_function_decl;
2893 /* Emit any thunks that should be emitted at the same time as FN. */
2894 emit_associated_thunks (fn);
2896 timevar_push (TV_INTEGRATION);
2897 optimize_function (fn);
2898 timevar_pop (TV_INTEGRATION);
2900 tree_rest_of_compilation (fn, function_depth > 1);
2902 current_function_decl = saved_function;
2904 extract_interface_info ();
2906 /* If this function is marked with the constructor attribute, add it
2907 to the list of functions to be called along with constructors
2908 from static duration objects. */
2909 if (DECL_STATIC_CONSTRUCTOR (fn))
2910 static_ctors = tree_cons (NULL_TREE, fn, static_ctors);
2912 /* If this function is marked with the destructor attribute, add it
2913 to the list of functions to be called along with destructors from
2914 static duration objects. */
2915 if (DECL_STATIC_DESTRUCTOR (fn))
2916 static_dtors = tree_cons (NULL_TREE, fn, static_dtors);
2918 if (DECL_CLONED_FUNCTION_P (fn))
2920 /* If this is a clone, go through the other clones now and mark
2921 their parameters used. We have to do that here, as we don't
2922 know whether any particular clone will be expanded, and
2923 therefore cannot pick one arbitrarily. */
2926 for (probe = TREE_CHAIN (DECL_CLONED_FUNCTION (fn));
2927 probe && DECL_CLONED_FUNCTION_P (probe);
2928 probe = TREE_CHAIN (probe))
2932 for (parms = DECL_ARGUMENTS (probe);
2933 parms; parms = TREE_CHAIN (parms))
2934 TREE_USED (parms) = 1;
2939 /* Generate RTL for FN. */
2942 expand_or_defer_fn (tree fn)
2944 /* When the parser calls us after finishing the body of a template
2945 function, we don't really want to expand the body. */
2946 if (processing_template_decl)
2948 /* Normally, collection only occurs in rest_of_compilation. So,
2949 if we don't collect here, we never collect junk generated
2950 during the processing of templates until we hit a
2951 non-template function. */
2956 /* Replace AGGR_INIT_EXPRs with appropriate CALL_EXPRs. */
2957 walk_tree_without_duplicates (&DECL_SAVED_TREE (fn),
2958 simplify_aggr_init_exprs_r,
2961 /* If this is a constructor or destructor body, we have to clone
2963 if (maybe_clone_body (fn))
2965 /* We don't want to process FN again, so pretend we've written
2966 it out, even though we haven't. */
2967 TREE_ASM_WRITTEN (fn) = 1;
2971 /* There's no reason to do any of the work here if we're only doing
2972 semantic analysis; this code just generates RTL. */
2973 if (flag_syntax_only)
2976 /* Compute the appropriate object-file linkage for inline functions. */
2977 if (DECL_DECLARED_INLINE_P (fn))
2978 import_export_decl (fn);
2982 /* Expand or defer, at the whim of the compilation unit manager. */
2983 cgraph_finalize_function (fn, function_depth > 1);
2988 /* Helper function for walk_tree, used by finish_function to override all
2989 the RETURN_STMTs and pertinent CLEANUP_STMTs for the named return
2990 value optimization. */
2993 nullify_returns_r (tree* tp, int* walk_subtrees, void* data)
2995 tree nrv = (tree) data;
2997 /* No need to walk into types. There wouldn't be any need to walk into
2998 non-statements, except that we have to consider STMT_EXPRs. */
3001 else if (TREE_CODE (*tp) == RETURN_STMT)
3002 RETURN_STMT_EXPR (*tp) = NULL_TREE;
3003 else if (TREE_CODE (*tp) == CLEANUP_STMT
3004 && CLEANUP_DECL (*tp) == nrv)
3005 CLEANUP_EH_ONLY (*tp) = 1;
3007 /* Keep iterating. */
3011 /* Start generating the RTL for FN. */
3014 cxx_expand_function_start (void)
3016 /* Give our named return value the same RTL as our RESULT_DECL. */
3017 if (current_function_return_value)
3018 COPY_DECL_RTL (DECL_RESULT (cfun->decl), current_function_return_value);
3021 /* Perform initialization related to this module. */
3024 init_cp_semantics (void)
3026 lang_expand_stmt = cp_expand_stmt;
3029 #include "gt-cp-semantics.h"