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 FOR_EXPR (for_stmt) = expr;
684 /* Finish the body of a for-statement, which may be given by
685 FOR_STMT. The increment-EXPR for the loop must be
689 finish_for_stmt (tree for_stmt)
691 /* Pop the scope for the body of the loop. */
693 RECHAIN_STMTS (for_stmt, FOR_BODY (for_stmt));
694 if (NEW_FOR_SCOPE_P (for_stmt))
699 /* Finish a break-statement. */
702 finish_break_stmt (void)
704 return add_stmt (build_break_stmt ());
707 /* Finish a continue-statement. */
710 finish_continue_stmt (void)
712 return add_stmt (build_continue_stmt ());
715 /* Begin a switch-statement. Returns a new SWITCH_STMT if
719 begin_switch_stmt (void)
722 do_pushlevel (sk_block);
723 r = build_stmt (SWITCH_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
728 /* Finish the cond of a switch-statement. */
731 finish_switch_cond (tree cond, tree switch_stmt)
733 tree orig_type = NULL;
734 if (!processing_template_decl)
738 /* Convert the condition to an integer or enumeration type. */
739 cond = build_expr_type_conversion (WANT_INT | WANT_ENUM, cond, true);
740 if (cond == NULL_TREE)
742 error ("switch quantity not an integer");
743 cond = error_mark_node;
745 orig_type = TREE_TYPE (cond);
746 if (cond != error_mark_node)
750 Integral promotions are performed. */
751 cond = perform_integral_promotions (cond);
752 cond = fold (build1 (CLEANUP_POINT_EXPR, TREE_TYPE (cond), cond));
755 if (cond != error_mark_node)
757 index = get_unwidened (cond, NULL_TREE);
758 /* We can't strip a conversion from a signed type to an unsigned,
759 because if we did, int_fits_type_p would do the wrong thing
760 when checking case values for being in range,
761 and it's too hard to do the right thing. */
762 if (TREE_UNSIGNED (TREE_TYPE (cond))
763 == TREE_UNSIGNED (TREE_TYPE (index)))
767 FINISH_COND (cond, switch_stmt, SWITCH_COND (switch_stmt));
768 SWITCH_TYPE (switch_stmt) = orig_type;
769 push_switch (switch_stmt);
772 /* Finish the body of a switch-statement, which may be given by
773 SWITCH_STMT. The COND to switch on is indicated. */
776 finish_switch_stmt (tree switch_stmt)
778 RECHAIN_STMTS (switch_stmt, SWITCH_BODY (switch_stmt));
784 /* Generate the RTL for T, which is a TRY_BLOCK. */
787 genrtl_try_block (tree t)
791 expand_eh_region_start ();
792 expand_stmt (TRY_STMTS (t));
793 expand_eh_region_end_cleanup (TRY_HANDLERS (t));
797 if (!FN_TRY_BLOCK_P (t))
798 emit_line_note (input_location);
800 expand_eh_region_start ();
801 expand_stmt (TRY_STMTS (t));
803 if (FN_TRY_BLOCK_P (t))
805 expand_start_all_catch ();
806 in_function_try_handler = 1;
807 expand_stmt (TRY_HANDLERS (t));
808 in_function_try_handler = 0;
809 expand_end_all_catch ();
813 expand_start_all_catch ();
814 expand_stmt (TRY_HANDLERS (t));
815 expand_end_all_catch ();
820 /* Generate the RTL for T, which is an EH_SPEC_BLOCK. */
823 genrtl_eh_spec_block (tree t)
825 expand_eh_region_start ();
826 expand_stmt (EH_SPEC_STMTS (t));
827 expand_eh_region_end_allowed (EH_SPEC_RAISES (t),
828 build_call (call_unexpected_node,
829 tree_cons (NULL_TREE,
834 /* Begin a try-block. Returns a newly-created TRY_BLOCK if
838 begin_try_block (void)
840 tree r = build_stmt (TRY_BLOCK, NULL_TREE, NULL_TREE);
845 /* Likewise, for a function-try-block. */
848 begin_function_try_block (void)
850 tree r = build_stmt (TRY_BLOCK, NULL_TREE, NULL_TREE);
851 FN_TRY_BLOCK_P (r) = 1;
856 /* Finish a try-block, which may be given by TRY_BLOCK. */
859 finish_try_block (tree try_block)
861 RECHAIN_STMTS (try_block, TRY_STMTS (try_block));
864 /* Finish the body of a cleanup try-block, which may be given by
868 finish_cleanup_try_block (tree try_block)
870 RECHAIN_STMTS (try_block, TRY_STMTS (try_block));
873 /* Finish an implicitly generated try-block, with a cleanup is given
877 finish_cleanup (tree cleanup, tree try_block)
879 TRY_HANDLERS (try_block) = cleanup;
880 CLEANUP_P (try_block) = 1;
883 /* Likewise, for a function-try-block. */
886 finish_function_try_block (tree try_block)
888 if (TREE_CHAIN (try_block)
889 && TREE_CODE (TREE_CHAIN (try_block)) == CTOR_INITIALIZER)
891 /* Chain the compound statement after the CTOR_INITIALIZER. */
892 TREE_CHAIN (TREE_CHAIN (try_block)) = last_tree;
893 /* And make the CTOR_INITIALIZER the body of the try-block. */
894 RECHAIN_STMTS (try_block, TRY_STMTS (try_block));
897 RECHAIN_STMTS (try_block, TRY_STMTS (try_block));
898 in_function_try_handler = 1;
901 /* Finish a handler-sequence for a try-block, which may be given by
905 finish_handler_sequence (tree try_block)
907 RECHAIN_STMTS (try_block, TRY_HANDLERS (try_block));
908 check_handlers (TRY_HANDLERS (try_block));
911 /* Likewise, for a function-try-block. */
914 finish_function_handler_sequence (tree try_block)
916 in_function_try_handler = 0;
917 RECHAIN_STMTS (try_block, TRY_HANDLERS (try_block));
918 check_handlers (TRY_HANDLERS (try_block));
921 /* Generate the RTL for T, which is a HANDLER. */
924 genrtl_handler (tree t)
926 genrtl_do_pushlevel ();
927 if (!processing_template_decl)
928 expand_start_catch (HANDLER_TYPE (t));
929 expand_stmt (HANDLER_BODY (t));
930 if (!processing_template_decl)
934 /* Begin a handler. Returns a HANDLER if appropriate. */
940 r = build_stmt (HANDLER, NULL_TREE, NULL_TREE);
942 /* Create a binding level for the eh_info and the exception object
944 do_pushlevel (sk_catch);
948 /* Finish the handler-parameters for a handler, which may be given by
949 HANDLER. DECL is the declaration for the catch parameter, or NULL
950 if this is a `catch (...)' clause. */
953 finish_handler_parms (tree decl, tree handler)
955 tree type = NULL_TREE;
956 if (processing_template_decl)
960 decl = pushdecl (decl);
961 decl = push_template_decl (decl);
962 add_decl_stmt (decl);
963 RECHAIN_STMTS (handler, HANDLER_PARMS (handler));
964 type = TREE_TYPE (decl);
968 type = expand_start_catch_block (decl);
970 HANDLER_TYPE (handler) = type;
971 if (!processing_template_decl && type)
972 mark_used (eh_type_info (type));
975 /* Finish a handler, which may be given by HANDLER. The BLOCKs are
976 the return value from the matching call to finish_handler_parms. */
979 finish_handler (tree handler)
981 if (!processing_template_decl)
982 expand_end_catch_block ();
984 RECHAIN_STMTS (handler, HANDLER_BODY (handler));
987 /* Begin a compound-statement. If HAS_NO_SCOPE is true, the
988 compound-statement does not define a scope. Returns a new
992 begin_compound_stmt (bool has_no_scope)
997 r = build_stmt (COMPOUND_STMT, NULL_TREE);
999 if (last_tree && TREE_CODE (last_tree) == TRY_BLOCK)
1004 COMPOUND_STMT_NO_SCOPE (r) = 1;
1006 last_expr_type = NULL_TREE;
1009 do_pushlevel (is_try ? sk_try : sk_block);
1011 /* Normally, we try hard to keep the BLOCK for a
1012 statement-expression. But, if it's a statement-expression with
1013 a scopeless block, there's nothing to keep, and we don't want
1014 to accidentally keep a block *inside* the scopeless block. */
1015 keep_next_level (false);
1020 /* Finish a compound-statement, which is given by COMPOUND_STMT. */
1023 finish_compound_stmt (tree compound_stmt)
1028 if (COMPOUND_STMT_NO_SCOPE (compound_stmt))
1033 RECHAIN_STMTS (compound_stmt, COMPOUND_BODY (compound_stmt));
1035 /* When we call finish_stmt we will lose LAST_EXPR_TYPE. But, since
1036 the precise purpose of that variable is store the type of the
1037 last expression statement within the last compound statement, we
1038 preserve the value. */
1046 /* Finish an asm-statement, whose components are a CV_QUALIFIER, a
1047 STRING, some OUTPUT_OPERANDS, some INPUT_OPERANDS, and some
1051 finish_asm_stmt (tree cv_qualifier,
1053 tree output_operands,
1054 tree input_operands,
1060 if (cv_qualifier != NULL_TREE
1061 && cv_qualifier != ridpointers[(int) RID_VOLATILE])
1063 warning ("%s qualifier ignored on asm",
1064 IDENTIFIER_POINTER (cv_qualifier));
1065 cv_qualifier = NULL_TREE;
1068 if (!processing_template_decl)
1074 for (t = input_operands; t; t = TREE_CHAIN (t))
1076 tree converted_operand
1077 = decay_conversion (TREE_VALUE (t));
1079 /* If the type of the operand hasn't been determined (e.g.,
1080 because it involves an overloaded function), then issue
1081 an error message. There's no context available to
1082 resolve the overloading. */
1083 if (TREE_TYPE (converted_operand) == unknown_type_node)
1085 error ("type of asm operand `%E' could not be determined",
1087 converted_operand = error_mark_node;
1089 TREE_VALUE (t) = converted_operand;
1092 ninputs = list_length (input_operands);
1093 noutputs = list_length (output_operands);
1095 for (i = 0, t = output_operands; t; t = TREE_CHAIN (t), ++i)
1100 const char *constraint;
1103 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
1104 operand = TREE_VALUE (t);
1106 if (!parse_output_constraint (&constraint,
1107 i, ninputs, noutputs,
1112 /* By marking this operand as erroneous, we will not try
1113 to process this operand again in expand_asm_operands. */
1114 TREE_VALUE (t) = error_mark_node;
1118 /* If the operand is a DECL that is going to end up in
1119 memory, assume it is addressable. This is a bit more
1120 conservative than it would ideally be; the exact test is
1121 buried deep in expand_asm_operands and depends on the
1122 DECL_RTL for the OPERAND -- which we don't have at this
1124 if (!allows_reg && DECL_P (operand))
1125 cxx_mark_addressable (operand);
1129 r = build_stmt (ASM_STMT, cv_qualifier, string,
1130 output_operands, input_operands,
1132 return add_stmt (r);
1135 /* Finish a label with the indicated NAME. */
1138 finish_label_stmt (tree name)
1140 tree decl = define_label (input_location, name);
1141 return add_stmt (build_stmt (LABEL_STMT, decl));
1144 /* Finish a series of declarations for local labels. G++ allows users
1145 to declare "local" labels, i.e., labels with scope. This extension
1146 is useful when writing code involving statement-expressions. */
1149 finish_label_decl (tree name)
1151 tree decl = declare_local_label (name);
1152 add_decl_stmt (decl);
1155 /* When DECL goes out of scope, make sure that CLEANUP is executed. */
1158 finish_decl_cleanup (tree decl, tree cleanup)
1160 add_stmt (build_stmt (CLEANUP_STMT, decl, cleanup));
1163 /* If the current scope exits with an exception, run CLEANUP. */
1166 finish_eh_cleanup (tree cleanup)
1168 tree r = build_stmt (CLEANUP_STMT, NULL_TREE, cleanup);
1169 CLEANUP_EH_ONLY (r) = 1;
1173 /* The MEM_INITS is a list of mem-initializers, in reverse of the
1174 order they were written by the user. Each node is as for
1175 emit_mem_initializers. */
1178 finish_mem_initializers (tree mem_inits)
1180 /* Reorder the MEM_INITS so that they are in the order they appeared
1181 in the source program. */
1182 mem_inits = nreverse (mem_inits);
1184 if (processing_template_decl)
1185 add_stmt (build_min_nt (CTOR_INITIALIZER, mem_inits));
1187 emit_mem_initializers (mem_inits);
1190 /* Returns the stack of SCOPE_STMTs for the current function. */
1193 current_scope_stmt_stack (void)
1195 return &cfun->language->base.x_scope_stmt_stack;
1198 /* Finish a parenthesized expression EXPR. */
1201 finish_parenthesized_expr (tree expr)
1203 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (expr))))
1204 /* This inhibits warnings in c_common_truthvalue_conversion. */
1205 C_SET_EXP_ORIGINAL_CODE (expr, ERROR_MARK);
1207 if (TREE_CODE (expr) == OFFSET_REF)
1208 /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
1209 enclosed in parentheses. */
1210 PTRMEM_OK_P (expr) = 0;
1214 /* Finish a reference to a non-static data member (DECL) that is not
1215 preceded by `.' or `->'. */
1218 finish_non_static_data_member (tree decl, tree object, tree qualifying_scope)
1220 my_friendly_assert (TREE_CODE (decl) == FIELD_DECL, 20020909);
1224 if (current_function_decl
1225 && DECL_STATIC_FUNCTION_P (current_function_decl))
1226 cp_error_at ("invalid use of member `%D' in static member function",
1229 cp_error_at ("invalid use of non-static data member `%D'", decl);
1230 error ("from this location");
1232 return error_mark_node;
1234 TREE_USED (current_class_ptr) = 1;
1235 if (processing_template_decl && !qualifying_scope)
1237 tree type = TREE_TYPE (decl);
1239 if (TREE_CODE (type) == REFERENCE_TYPE)
1240 type = TREE_TYPE (type);
1243 /* Set the cv qualifiers. */
1244 int quals = cp_type_quals (TREE_TYPE (current_class_ref));
1246 if (DECL_MUTABLE_P (decl))
1247 quals &= ~TYPE_QUAL_CONST;
1249 quals |= cp_type_quals (TREE_TYPE (decl));
1250 type = cp_build_qualified_type (type, quals);
1253 return build_min (COMPONENT_REF, type, object, decl);
1257 tree access_type = TREE_TYPE (object);
1258 tree lookup_context = context_for_name_lookup (decl);
1260 while (!DERIVED_FROM_P (lookup_context, access_type))
1262 access_type = TYPE_CONTEXT (access_type);
1263 while (access_type && DECL_P (access_type))
1264 access_type = DECL_CONTEXT (access_type);
1268 cp_error_at ("object missing in reference to `%D'", decl);
1269 error ("from this location");
1270 return error_mark_node;
1274 /* If PROCESSING_TEMPLATE_DECL is nonzero here, then
1275 QUALIFYING_SCOPE is also non-null. Wrap this in a SCOPE_REF
1277 if (processing_template_decl)
1278 return build_min (SCOPE_REF, TREE_TYPE (decl),
1279 qualifying_scope, DECL_NAME (decl));
1281 perform_or_defer_access_check (TYPE_BINFO (access_type), decl);
1283 /* If the data member was named `C::M', convert `*this' to `C'
1285 if (qualifying_scope)
1287 tree binfo = NULL_TREE;
1288 object = build_scoped_ref (object, qualifying_scope,
1292 return build_class_member_access_expr (object, decl,
1293 /*access_path=*/NULL_TREE,
1294 /*preserve_reference=*/false);
1298 /* DECL was the declaration to which a qualified-id resolved. Issue
1299 an error message if it is not accessible. If OBJECT_TYPE is
1300 non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
1301 type of `*x', or `x', respectively. If the DECL was named as
1302 `A::B' then NESTED_NAME_SPECIFIER is `A'. */
1305 check_accessibility_of_qualified_id (tree decl,
1307 tree nested_name_specifier)
1310 tree qualifying_type = NULL_TREE;
1312 /* Determine the SCOPE of DECL. */
1313 scope = context_for_name_lookup (decl);
1314 /* If the SCOPE is not a type, then DECL is not a member. */
1315 if (!TYPE_P (scope))
1317 /* Compute the scope through which DECL is being accessed. */
1319 /* OBJECT_TYPE might not be a class type; consider:
1321 class A { typedef int I; };
1325 In this case, we will have "A::I" as the DECL, but "I" as the
1327 && CLASS_TYPE_P (object_type)
1328 && DERIVED_FROM_P (scope, object_type))
1329 /* If we are processing a `->' or `.' expression, use the type of the
1331 qualifying_type = object_type;
1332 else if (nested_name_specifier)
1334 /* If the reference is to a non-static member of the
1335 current class, treat it as if it were referenced through
1337 if (DECL_NONSTATIC_MEMBER_P (decl)
1338 && current_class_ptr
1339 && DERIVED_FROM_P (scope, current_class_type))
1340 qualifying_type = current_class_type;
1341 /* Otherwise, use the type indicated by the
1342 nested-name-specifier. */
1344 qualifying_type = nested_name_specifier;
1347 /* Otherwise, the name must be from the current class or one of
1349 qualifying_type = currently_open_derived_class (scope);
1351 if (qualifying_type)
1352 perform_or_defer_access_check (TYPE_BINFO (qualifying_type), decl);
1355 /* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
1356 class named to the left of the "::" operator. DONE is true if this
1357 expression is a complete postfix-expression; it is false if this
1358 expression is followed by '->', '[', '(', etc. ADDRESS_P is true
1359 iff this expression is the operand of '&'. */
1362 finish_qualified_id_expr (tree qualifying_class, tree expr, bool done,
1365 if (error_operand_p (expr))
1366 return error_mark_node;
1368 /* If EXPR occurs as the operand of '&', use special handling that
1369 permits a pointer-to-member. */
1370 if (address_p && done)
1372 if (TREE_CODE (expr) == SCOPE_REF)
1373 expr = TREE_OPERAND (expr, 1);
1374 expr = build_offset_ref (qualifying_class, expr,
1375 /*address_p=*/true);
1379 if (TREE_CODE (expr) == FIELD_DECL)
1380 expr = finish_non_static_data_member (expr, current_class_ref,
1382 else if (BASELINK_P (expr) && !processing_template_decl)
1387 /* See if any of the functions are non-static members. */
1388 fns = BASELINK_FUNCTIONS (expr);
1389 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
1390 fns = TREE_OPERAND (fns, 0);
1391 for (fn = fns; fn; fn = OVL_NEXT (fn))
1392 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1394 /* If so, the expression may be relative to the current
1396 if (fn && current_class_type
1397 && DERIVED_FROM_P (qualifying_class, current_class_type))
1398 expr = (build_class_member_access_expr
1399 (maybe_dummy_object (qualifying_class, NULL),
1401 BASELINK_ACCESS_BINFO (expr),
1402 /*preserve_reference=*/false));
1404 /* The expression is a qualified name whose address is not
1406 expr = build_offset_ref (qualifying_class, expr, /*address_p=*/false);
1412 /* Begin a statement-expression. The value returned must be passed to
1413 finish_stmt_expr. */
1416 begin_stmt_expr (void)
1418 /* If we're outside a function, we won't have a statement-tree to
1419 work with. But, if we see a statement-expression we need to
1421 if (! cfun && !last_tree)
1422 begin_stmt_tree (&scope_chain->x_saved_tree);
1424 last_expr_type = NULL_TREE;
1426 keep_next_level (true);
1431 /* Process the final expression of a statement expression. EXPR can be
1432 NULL, if the final expression is empty. Build up a TARGET_EXPR so
1433 that the result value can be safely returned to the enclosing
1437 finish_stmt_expr_expr (tree expr)
1439 tree result = NULL_TREE;
1440 tree type = void_type_node;
1444 type = TREE_TYPE (expr);
1446 if (!processing_template_decl && !VOID_TYPE_P (TREE_TYPE (expr)))
1448 if (TREE_CODE (type) == ARRAY_TYPE
1449 || TREE_CODE (type) == FUNCTION_TYPE)
1450 expr = decay_conversion (expr);
1452 expr = convert_from_reference (expr);
1453 expr = require_complete_type (expr);
1455 /* Build a TARGET_EXPR for this aggregate. finish_stmt_expr
1456 will then pull it apart so the lifetime of the target is
1457 within the scope of the expression containing this statement
1459 if (TREE_CODE (expr) == TARGET_EXPR)
1461 else if (!IS_AGGR_TYPE (type) || TYPE_HAS_TRIVIAL_INIT_REF (type))
1462 expr = build_target_expr_with_type (expr, type);
1465 /* Copy construct. */
1466 expr = build_special_member_call
1467 (NULL_TREE, complete_ctor_identifier,
1468 build_tree_list (NULL_TREE, expr),
1469 TYPE_BINFO (type), LOOKUP_NORMAL);
1470 expr = build_cplus_new (type, expr);
1471 my_friendly_assert (TREE_CODE (expr) == TARGET_EXPR, 20030729);
1475 if (expr != error_mark_node)
1477 result = build_stmt (EXPR_STMT, expr);
1484 /* Remember the last expression so that finish_stmt_expr can pull it
1486 last_expr_type = result ? result : void_type_node;
1491 /* Finish a statement-expression. EXPR should be the value returned
1492 by the previous begin_stmt_expr. Returns an expression
1493 representing the statement-expression. */
1496 finish_stmt_expr (tree rtl_expr, bool has_no_scope)
1499 tree result_stmt = last_expr_type;
1502 if (!last_expr_type)
1503 type = void_type_node;
1506 if (result_stmt == void_type_node)
1508 type = void_type_node;
1509 result_stmt = NULL_TREE;
1512 type = TREE_TYPE (EXPR_STMT_EXPR (result_stmt));
1515 result = build_min (STMT_EXPR, type, last_tree);
1516 TREE_SIDE_EFFECTS (result) = 1;
1517 STMT_EXPR_NO_SCOPE (result) = has_no_scope;
1519 last_expr_type = NULL_TREE;
1521 /* Remove the compound statement from the tree structure; it is
1522 now saved in the STMT_EXPR. */
1523 last_tree = rtl_expr;
1524 TREE_CHAIN (last_tree) = NULL_TREE;
1526 /* If we created a statement-tree for this statement-expression,
1529 && TREE_CHAIN (scope_chain->x_saved_tree) == NULL_TREE)
1530 finish_stmt_tree (&scope_chain->x_saved_tree);
1532 if (processing_template_decl)
1535 if (!VOID_TYPE_P (type))
1537 /* Pull out the TARGET_EXPR that is the final expression. Put
1538 the target's init_expr as the final expression and then put
1539 the statement expression itself as the target's init
1540 expr. Finally, return the target expression. */
1541 tree last_expr = EXPR_STMT_EXPR (result_stmt);
1543 my_friendly_assert (TREE_CODE (last_expr) == TARGET_EXPR, 20030729);
1544 EXPR_STMT_EXPR (result_stmt) = TREE_OPERAND (last_expr, 1);
1545 TREE_OPERAND (last_expr, 1) = result;
1551 /* Perform Koenig lookup. FN is the postfix-expression representing
1552 the function (or functions) to call; ARGS are the arguments to the
1553 call. Returns the functions to be considered by overload
1557 perform_koenig_lookup (tree fn, tree args)
1559 tree identifier = NULL_TREE;
1560 tree functions = NULL_TREE;
1562 /* Find the name of the overloaded function. */
1563 if (TREE_CODE (fn) == IDENTIFIER_NODE)
1565 else if (is_overloaded_fn (fn))
1568 identifier = DECL_NAME (get_first_fn (functions));
1570 else if (DECL_P (fn))
1573 identifier = DECL_NAME (fn);
1576 /* A call to a namespace-scope function using an unqualified name.
1578 Do Koenig lookup -- unless any of the arguments are
1580 if (!any_type_dependent_arguments_p (args))
1582 fn = lookup_arg_dependent (identifier, functions, args);
1584 /* The unqualified name could not be resolved. */
1585 fn = unqualified_fn_lookup_error (identifier);
1593 /* Generate an expression for `FN (ARGS)'.
1595 If DISALLOW_VIRTUAL is true, the call to FN will be not generated
1596 as a virtual call, even if FN is virtual. (This flag is set when
1597 encountering an expression where the function name is explicitly
1598 qualified. For example a call to `X::f' never generates a virtual
1601 Returns code for the call. */
1604 finish_call_expr (tree fn, tree args, bool disallow_virtual, bool koenig_p)
1610 if (fn == error_mark_node || args == error_mark_node)
1611 return error_mark_node;
1613 /* ARGS should be a list of arguments. */
1614 my_friendly_assert (!args || TREE_CODE (args) == TREE_LIST,
1620 if (processing_template_decl)
1622 if (type_dependent_expression_p (fn)
1623 || any_type_dependent_arguments_p (args))
1625 result = build_nt (CALL_EXPR, fn, args);
1626 KOENIG_LOOKUP_P (result) = koenig_p;
1629 if (!BASELINK_P (fn)
1630 && TREE_CODE (fn) != PSEUDO_DTOR_EXPR
1631 && TREE_TYPE (fn) != unknown_type_node)
1632 fn = build_non_dependent_expr (fn);
1633 args = build_non_dependent_args (orig_args);
1636 /* A reference to a member function will appear as an overloaded
1637 function (rather than a BASELINK) if an unqualified name was used
1639 if (!BASELINK_P (fn) && is_overloaded_fn (fn))
1643 if (TREE_CODE (f) == TEMPLATE_ID_EXPR)
1644 f = TREE_OPERAND (f, 0);
1645 f = get_first_fn (f);
1646 if (DECL_FUNCTION_MEMBER_P (f))
1648 tree type = currently_open_derived_class (DECL_CONTEXT (f));
1650 type = DECL_CONTEXT (f);
1651 fn = build_baselink (TYPE_BINFO (type),
1653 fn, /*optype=*/NULL_TREE);
1658 if (BASELINK_P (fn))
1662 /* A call to a member function. From [over.call.func]:
1664 If the keyword this is in scope and refers to the class of
1665 that member function, or a derived class thereof, then the
1666 function call is transformed into a qualified function call
1667 using (*this) as the postfix-expression to the left of the
1668 . operator.... [Otherwise] a contrived object of type T
1669 becomes the implied object argument.
1671 This paragraph is unclear about this situation:
1673 struct A { void f(); };
1674 struct B : public A {};
1675 struct C : public A { void g() { B::f(); }};
1677 In particular, for `B::f', this paragraph does not make clear
1678 whether "the class of that member function" refers to `A' or
1679 to `B'. We believe it refers to `B'. */
1680 if (current_class_type
1681 && DERIVED_FROM_P (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
1683 && current_class_ref)
1684 object = maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
1688 tree representative_fn;
1690 representative_fn = BASELINK_FUNCTIONS (fn);
1691 if (TREE_CODE (representative_fn) == TEMPLATE_ID_EXPR)
1692 representative_fn = TREE_OPERAND (representative_fn, 0);
1693 representative_fn = get_first_fn (representative_fn);
1694 object = build_dummy_object (DECL_CONTEXT (representative_fn));
1697 if (processing_template_decl)
1699 if (type_dependent_expression_p (object))
1700 return build_nt (CALL_EXPR, orig_fn, orig_args);
1701 object = build_non_dependent_expr (object);
1704 result = build_new_method_call (object, fn, args, NULL_TREE,
1706 ? LOOKUP_NONVIRTUAL : 0));
1708 else if (is_overloaded_fn (fn))
1709 /* A call to a namespace-scope function. */
1710 result = build_new_function_call (fn, args);
1711 else if (TREE_CODE (fn) == PSEUDO_DTOR_EXPR)
1714 error ("arguments to destructor are not allowed");
1715 /* Mark the pseudo-destructor call as having side-effects so
1716 that we do not issue warnings about its use. */
1717 result = build1 (NOP_EXPR,
1719 TREE_OPERAND (fn, 0));
1720 TREE_SIDE_EFFECTS (result) = 1;
1722 else if (CLASS_TYPE_P (TREE_TYPE (fn)))
1723 /* If the "function" is really an object of class type, it might
1724 have an overloaded `operator ()'. */
1725 result = build_new_op (CALL_EXPR, LOOKUP_NORMAL, fn, args, NULL_TREE);
1727 /* A call where the function is unknown. */
1728 result = build_function_call (fn, args);
1730 if (processing_template_decl)
1732 result = build (CALL_EXPR, TREE_TYPE (result), orig_fn, orig_args);
1733 KOENIG_LOOKUP_P (result) = koenig_p;
1738 /* Finish a call to a postfix increment or decrement or EXPR. (Which
1739 is indicated by CODE, which should be POSTINCREMENT_EXPR or
1740 POSTDECREMENT_EXPR.) */
1743 finish_increment_expr (tree expr, enum tree_code code)
1745 return build_x_unary_op (code, expr);
1748 /* Finish a use of `this'. Returns an expression for `this'. */
1751 finish_this_expr (void)
1755 if (current_class_ptr)
1757 result = current_class_ptr;
1759 else if (current_function_decl
1760 && DECL_STATIC_FUNCTION_P (current_function_decl))
1762 error ("`this' is unavailable for static member functions");
1763 result = error_mark_node;
1767 if (current_function_decl)
1768 error ("invalid use of `this' in non-member function");
1770 error ("invalid use of `this' at top level");
1771 result = error_mark_node;
1777 /* Finish a member function call using OBJECT and ARGS as arguments to
1778 FN. Returns an expression for the call. */
1781 finish_object_call_expr (tree fn, tree object, tree args)
1783 if (DECL_DECLARES_TYPE_P (fn))
1785 if (processing_template_decl)
1786 /* This can happen on code like:
1789 template <class T> void f(T t) {
1793 We just grab the underlying IDENTIFIER. */
1794 fn = DECL_NAME (fn);
1797 error ("calling type `%T' like a method", fn);
1798 return error_mark_node;
1802 if (processing_template_decl)
1803 return build_nt (CALL_EXPR,
1804 build_nt (COMPONENT_REF, object, fn),
1808 return build_method_call (object, fn, args, NULL_TREE, LOOKUP_NORMAL);
1810 return build_new_method_call (object, fn, args, NULL_TREE, LOOKUP_NORMAL);
1813 /* Finish a pseudo-destructor expression. If SCOPE is NULL, the
1814 expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
1815 the TYPE for the type given. If SCOPE is non-NULL, the expression
1816 was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
1819 finish_pseudo_destructor_expr (tree object, tree scope, tree destructor)
1821 if (destructor == error_mark_node)
1822 return error_mark_node;
1824 my_friendly_assert (TYPE_P (destructor), 20010905);
1826 if (!processing_template_decl)
1828 if (scope == error_mark_node)
1830 error ("invalid qualifying scope in pseudo-destructor name");
1831 return error_mark_node;
1834 if (!same_type_p (TREE_TYPE (object), destructor))
1836 error ("`%E' is not of type `%T'", object, destructor);
1837 return error_mark_node;
1841 return build (PSEUDO_DTOR_EXPR, void_type_node, object, scope, destructor);
1844 /* Finish an expression of the form CODE EXPR. */
1847 finish_unary_op_expr (enum tree_code code, tree expr)
1849 tree result = build_x_unary_op (code, expr);
1850 /* Inside a template, build_x_unary_op does not fold the
1851 expression. So check whether the result is folded before
1852 setting TREE_NEGATED_INT. */
1853 if (code == NEGATE_EXPR && TREE_CODE (expr) == INTEGER_CST
1854 && TREE_CODE (result) == INTEGER_CST
1855 && !TREE_UNSIGNED (TREE_TYPE (result))
1856 && INT_CST_LT (result, integer_zero_node))
1857 TREE_NEGATED_INT (result) = 1;
1858 overflow_warning (result);
1862 /* Finish a compound-literal expression. TYPE is the type to which
1863 the INITIALIZER_LIST is being cast. */
1866 finish_compound_literal (tree type, tree initializer_list)
1868 tree compound_literal;
1870 /* Build a CONSTRUCTOR for the INITIALIZER_LIST. */
1871 compound_literal = build_constructor (NULL_TREE, initializer_list);
1872 /* Mark it as a compound-literal. */
1873 TREE_HAS_CONSTRUCTOR (compound_literal) = 1;
1874 if (processing_template_decl)
1875 TREE_TYPE (compound_literal) = type;
1878 /* Check the initialization. */
1879 compound_literal = digest_init (type, compound_literal, NULL);
1880 /* If the TYPE was an array type with an unknown bound, then we can
1881 figure out the dimension now. For example, something like:
1885 implies that the array has two elements. */
1886 if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
1887 complete_array_type (type, compound_literal, 1);
1890 return compound_literal;
1893 /* Return the declaration for the function-name variable indicated by
1897 finish_fname (tree id)
1901 decl = fname_decl (C_RID_CODE (id), id);
1902 if (processing_template_decl)
1903 decl = DECL_NAME (decl);
1907 /* Begin a function definition declared with DECL_SPECS, ATTRIBUTES,
1908 and DECLARATOR. Returns nonzero if the function-declaration is
1912 begin_function_definition (tree decl_specs, tree attributes, tree declarator)
1914 if (!start_function (decl_specs, declarator, attributes, SF_DEFAULT))
1917 /* The things we're about to see are not directly qualified by any
1918 template headers we've seen thus far. */
1919 reset_specialization ();
1924 /* Finish a translation unit. */
1927 finish_translation_unit (void)
1929 /* In case there were missing closebraces,
1930 get us back to the global binding level. */
1932 while (current_namespace != global_namespace)
1935 /* Do file scope __FUNCTION__ et al. */
1936 finish_fname_decls ();
1939 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
1940 Returns the parameter. */
1943 finish_template_type_parm (tree aggr, tree identifier)
1945 if (aggr != class_type_node)
1947 pedwarn ("template type parameters must use the keyword `class' or `typename'");
1948 aggr = class_type_node;
1951 return build_tree_list (aggr, identifier);
1954 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
1955 Returns the parameter. */
1958 finish_template_template_parm (tree aggr, tree identifier)
1960 tree decl = build_decl (TYPE_DECL, identifier, NULL_TREE);
1961 tree tmpl = build_lang_decl (TEMPLATE_DECL, identifier, NULL_TREE);
1962 DECL_TEMPLATE_PARMS (tmpl) = current_template_parms;
1963 DECL_TEMPLATE_RESULT (tmpl) = decl;
1964 DECL_ARTIFICIAL (decl) = 1;
1965 end_template_decl ();
1967 my_friendly_assert (DECL_TEMPLATE_PARMS (tmpl), 20010110);
1969 return finish_template_type_parm (aggr, tmpl);
1972 /* ARGUMENT is the default-argument value for a template template
1973 parameter. If ARGUMENT is invalid, issue error messages and return
1974 the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
1977 check_template_template_default_arg (tree argument)
1979 if (TREE_CODE (argument) != TEMPLATE_DECL
1980 && TREE_CODE (argument) != TEMPLATE_TEMPLATE_PARM
1981 && TREE_CODE (argument) != TYPE_DECL
1982 && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
1984 error ("invalid default template argument");
1985 return error_mark_node;
1991 /* Finish a parameter list, indicated by PARMS. If ELLIPSIS is
1992 nonzero, the parameter list was terminated by a `...'. */
1995 finish_parmlist (tree parms, int ellipsis)
1999 /* We mark the PARMS as a parmlist so that declarator processing can
2000 disambiguate certain constructs. */
2001 TREE_PARMLIST (parms) = 1;
2002 /* We do not append void_list_node here, but leave it to grokparms
2004 PARMLIST_ELLIPSIS_P (parms) = ellipsis;
2009 /* Begin a class definition, as indicated by T. */
2012 begin_class_definition (tree t)
2014 if (t == error_mark_node)
2015 return error_mark_node;
2017 if (processing_template_parmlist)
2019 error ("definition of `%#T' inside template parameter list", t);
2020 return error_mark_node;
2022 /* A non-implicit typename comes from code like:
2024 template <typename T> struct A {
2025 template <typename U> struct A<T>::B ...
2027 This is erroneous. */
2028 else if (TREE_CODE (t) == TYPENAME_TYPE)
2030 error ("invalid definition of qualified type `%T'", t);
2031 t = error_mark_node;
2034 if (t == error_mark_node || ! IS_AGGR_TYPE (t))
2036 t = make_aggr_type (RECORD_TYPE);
2037 pushtag (make_anon_name (), t, 0);
2040 /* If this type was already complete, and we see another definition,
2042 if (COMPLETE_TYPE_P (t))
2044 error ("redefinition of `%#T'", t);
2045 cp_error_at ("previous definition of `%#T'", t);
2046 return error_mark_node;
2049 /* Update the location of the decl. */
2050 DECL_SOURCE_LOCATION (TYPE_NAME (t)) = input_location;
2052 if (TYPE_BEING_DEFINED (t))
2054 t = make_aggr_type (TREE_CODE (t));
2055 pushtag (TYPE_IDENTIFIER (t), t, 0);
2057 maybe_process_partial_specialization (t);
2059 TYPE_BEING_DEFINED (t) = 1;
2060 TYPE_PACKED (t) = flag_pack_struct;
2061 /* Reset the interface data, at the earliest possible
2062 moment, as it might have been set via a class foo;
2064 if (! TYPE_ANONYMOUS_P (t))
2066 CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
2067 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2068 (t, interface_unknown);
2070 reset_specialization();
2072 /* Make a declaration for this class in its own scope. */
2073 build_self_reference ();
2078 /* Finish the member declaration given by DECL. */
2081 finish_member_declaration (tree decl)
2083 if (decl == error_mark_node || decl == NULL_TREE)
2086 if (decl == void_type_node)
2087 /* The COMPONENT was a friend, not a member, and so there's
2088 nothing for us to do. */
2091 /* We should see only one DECL at a time. */
2092 my_friendly_assert (TREE_CHAIN (decl) == NULL_TREE, 0);
2094 /* Set up access control for DECL. */
2096 = (current_access_specifier == access_private_node);
2097 TREE_PROTECTED (decl)
2098 = (current_access_specifier == access_protected_node);
2099 if (TREE_CODE (decl) == TEMPLATE_DECL)
2101 TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl)) = TREE_PRIVATE (decl);
2102 TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl)) = TREE_PROTECTED (decl);
2105 /* Mark the DECL as a member of the current class. */
2106 DECL_CONTEXT (decl) = current_class_type;
2110 A C language linkage is ignored for the names of class members
2111 and the member function type of class member functions. */
2112 if (DECL_LANG_SPECIFIC (decl) && DECL_LANGUAGE (decl) == lang_c)
2113 SET_DECL_LANGUAGE (decl, lang_cplusplus);
2115 /* Put functions on the TYPE_METHODS list and everything else on the
2116 TYPE_FIELDS list. Note that these are built up in reverse order.
2117 We reverse them (to obtain declaration order) in finish_struct. */
2118 if (TREE_CODE (decl) == FUNCTION_DECL
2119 || DECL_FUNCTION_TEMPLATE_P (decl))
2121 /* We also need to add this function to the
2122 CLASSTYPE_METHOD_VEC. */
2123 add_method (current_class_type, decl, /*error_p=*/0);
2125 TREE_CHAIN (decl) = TYPE_METHODS (current_class_type);
2126 TYPE_METHODS (current_class_type) = decl;
2128 maybe_add_class_template_decl_list (current_class_type, decl,
2131 /* Enter the DECL into the scope of the class. */
2132 else if ((TREE_CODE (decl) == USING_DECL && TREE_TYPE (decl))
2133 || pushdecl_class_level (decl))
2135 /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
2136 go at the beginning. The reason is that lookup_field_1
2137 searches the list in order, and we want a field name to
2138 override a type name so that the "struct stat hack" will
2139 work. In particular:
2141 struct S { enum E { }; int E } s;
2144 is valid. In addition, the FIELD_DECLs must be maintained in
2145 declaration order so that class layout works as expected.
2146 However, we don't need that order until class layout, so we
2147 save a little time by putting FIELD_DECLs on in reverse order
2148 here, and then reversing them in finish_struct_1. (We could
2149 also keep a pointer to the correct insertion points in the
2152 if (TREE_CODE (decl) == TYPE_DECL)
2153 TYPE_FIELDS (current_class_type)
2154 = chainon (TYPE_FIELDS (current_class_type), decl);
2157 TREE_CHAIN (decl) = TYPE_FIELDS (current_class_type);
2158 TYPE_FIELDS (current_class_type) = decl;
2161 maybe_add_class_template_decl_list (current_class_type, decl,
2166 /* Finish processing the declaration of a member class template
2167 TYPES whose template parameters are given by PARMS. */
2170 finish_member_class_template (tree types)
2174 /* If there are declared, but undefined, partial specializations
2175 mixed in with the typespecs they will not yet have passed through
2176 maybe_process_partial_specialization, so we do that here. */
2177 for (t = types; t != NULL_TREE; t = TREE_CHAIN (t))
2178 if (IS_AGGR_TYPE_CODE (TREE_CODE (TREE_VALUE (t))))
2179 maybe_process_partial_specialization (TREE_VALUE (t));
2181 grok_x_components (types);
2182 if (TYPE_CONTEXT (TREE_VALUE (types)) != current_class_type)
2183 /* The component was in fact a friend declaration. We avoid
2184 finish_member_template_decl performing certain checks by
2188 finish_member_template_decl (types);
2190 /* As with other component type declarations, we do
2191 not store the new DECL on the list of
2196 /* Finish processing a complete template declaration. The PARMS are
2197 the template parameters. */
2200 finish_template_decl (tree parms)
2203 end_template_decl ();
2205 end_specialization ();
2208 /* Finish processing a template-id (which names a type) of the form
2209 NAME < ARGS >. Return the TYPE_DECL for the type named by the
2210 template-id. If ENTERING_SCOPE is nonzero we are about to enter
2211 the scope of template-id indicated. */
2214 finish_template_type (tree name, tree args, int entering_scope)
2218 decl = lookup_template_class (name, args,
2219 NULL_TREE, NULL_TREE, entering_scope,
2220 tf_error | tf_warning | tf_user);
2221 if (decl != error_mark_node)
2222 decl = TYPE_STUB_DECL (decl);
2227 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
2228 Return a TREE_LIST containing the ACCESS_SPECIFIER and the
2229 BASE_CLASS, or NULL_TREE if an error occurred. The
2230 ACCESS_SPECIFIER is one of
2231 access_{default,public,protected_private}[_virtual]_node.*/
2234 finish_base_specifier (tree base, tree access, bool virtual_p)
2238 if (base == error_mark_node)
2240 error ("invalid base-class specification");
2243 else if (! is_aggr_type (base, 1))
2247 if (cp_type_quals (base) != 0)
2249 error ("base class `%T' has cv qualifiers", base);
2250 base = TYPE_MAIN_VARIANT (base);
2252 result = build_tree_list (access, base);
2253 TREE_VIA_VIRTUAL (result) = virtual_p;
2259 /* Called when multiple declarators are processed. If that is not
2260 permitted in this context, an error is issued. */
2263 check_multiple_declarators (void)
2267 In a template-declaration, explicit specialization, or explicit
2268 instantiation the init-declarator-list in the declaration shall
2269 contain at most one declarator.
2271 We don't just use PROCESSING_TEMPLATE_DECL for the first
2272 condition since that would disallow the perfectly valid code,
2273 like `template <class T> struct S { int i, j; };'. */
2274 if (at_function_scope_p ())
2275 /* It's OK to write `template <class T> void f() { int i, j;}'. */
2278 if (PROCESSING_REAL_TEMPLATE_DECL_P ()
2279 || processing_explicit_instantiation
2280 || processing_specialization)
2281 error ("multiple declarators in template declaration");
2284 /* Issue a diagnostic that NAME cannot be found in SCOPE. */
2287 qualified_name_lookup_error (tree scope, tree name)
2291 if (!COMPLETE_TYPE_P (scope))
2292 error ("incomplete type `%T' used in nested name specifier", scope);
2294 error ("`%D' is not a member of `%T'", name, scope);
2296 else if (scope != global_namespace)
2297 error ("`%D' is not a member of `%D'", name, scope);
2299 error ("`::%D' has not been declared", name);
2302 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
2303 id-expression. (See cp_parser_id_expression for details.) SCOPE,
2304 if non-NULL, is the type or namespace used to explicitly qualify
2305 ID_EXPRESSION. DECL is the entity to which that name has been
2308 *CONSTANT_EXPRESSION_P is true if we are presently parsing a
2309 constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
2310 be set to true if this expression isn't permitted in a
2311 constant-expression, but it is otherwise not set by this function.
2312 *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
2313 constant-expression, but a non-constant expression is also
2316 If an error occurs, and it is the kind of error that might cause
2317 the parser to abort a tentative parse, *ERROR_MSG is filled in. It
2318 is the caller's responsibility to issue the message. *ERROR_MSG
2319 will be a string with static storage duration, so the caller need
2322 Return an expression for the entity, after issuing appropriate
2323 diagnostics. This function is also responsible for transforming a
2324 reference to a non-static member into a COMPONENT_REF that makes
2325 the use of "this" explicit.
2327 Upon return, *IDK will be filled in appropriately. */
2330 finish_id_expression (tree id_expression,
2334 tree *qualifying_class,
2335 bool integral_constant_expression_p,
2336 bool allow_non_integral_constant_expression_p,
2337 bool *non_integral_constant_expression_p,
2338 const char **error_msg)
2340 /* Initialize the output parameters. */
2341 *idk = CP_ID_KIND_NONE;
2344 if (id_expression == error_mark_node)
2345 return error_mark_node;
2346 /* If we have a template-id, then no further lookup is
2347 required. If the template-id was for a template-class, we
2348 will sometimes have a TYPE_DECL at this point. */
2349 else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2350 || TREE_CODE (decl) == TYPE_DECL)
2352 /* Look up the name. */
2355 if (decl == error_mark_node)
2357 /* Name lookup failed. */
2358 if (scope && (!TYPE_P (scope) || !dependent_type_p (scope)))
2360 /* Qualified name lookup failed, and the qualifying name
2361 was not a dependent type. That is always an
2363 qualified_name_lookup_error (scope, id_expression);
2364 return error_mark_node;
2368 /* It may be resolved via Koenig lookup. */
2369 *idk = CP_ID_KIND_UNQUALIFIED;
2370 return id_expression;
2373 /* If DECL is a variable that would be out of scope under
2374 ANSI/ISO rules, but in scope in the ARM, name lookup
2375 will succeed. Issue a diagnostic here. */
2377 decl = check_for_out_of_scope_variable (decl);
2379 /* Remember that the name was used in the definition of
2380 the current class so that we can check later to see if
2381 the meaning would have been different after the class
2382 was entirely defined. */
2383 if (!scope && decl != error_mark_node)
2384 maybe_note_name_used_in_class (id_expression, decl);
2387 /* If we didn't find anything, or what we found was a type,
2388 then this wasn't really an id-expression. */
2389 if (TREE_CODE (decl) == TEMPLATE_DECL
2390 && !DECL_FUNCTION_TEMPLATE_P (decl))
2392 *error_msg = "missing template arguments";
2393 return error_mark_node;
2395 else if (TREE_CODE (decl) == TYPE_DECL
2396 || TREE_CODE (decl) == NAMESPACE_DECL)
2398 *error_msg = "expected primary-expression";
2399 return error_mark_node;
2402 /* If the name resolved to a template parameter, there is no
2403 need to look it up again later. */
2404 if ((TREE_CODE (decl) == CONST_DECL && DECL_TEMPLATE_PARM_P (decl))
2405 || TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
2407 *idk = CP_ID_KIND_NONE;
2408 if (TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
2409 decl = TEMPLATE_PARM_DECL (decl);
2410 if (integral_constant_expression_p
2411 && !dependent_type_p (TREE_TYPE (decl))
2412 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (decl)))
2414 if (!allow_non_integral_constant_expression_p)
2415 error ("template parameter `%D' of type `%T' is not allowed in "
2416 "an integral constant expression because it is not of "
2417 "integral or enumeration type", decl, TREE_TYPE (decl));
2418 *non_integral_constant_expression_p = true;
2420 return DECL_INITIAL (decl);
2422 /* Similarly, we resolve enumeration constants to their
2423 underlying values. */
2424 else if (TREE_CODE (decl) == CONST_DECL)
2426 *idk = CP_ID_KIND_NONE;
2427 if (!processing_template_decl)
2428 return DECL_INITIAL (decl);
2435 /* If the declaration was explicitly qualified indicate
2436 that. The semantics of `A::f(3)' are different than
2437 `f(3)' if `f' is virtual. */
2439 ? CP_ID_KIND_QUALIFIED
2440 : (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2441 ? CP_ID_KIND_TEMPLATE_ID
2442 : CP_ID_KIND_UNQUALIFIED));
2447 An id-expression is type-dependent if it contains an
2448 identifier that was declared with a dependent type.
2450 The standard is not very specific about an id-expression that
2451 names a set of overloaded functions. What if some of them
2452 have dependent types and some of them do not? Presumably,
2453 such a name should be treated as a dependent name. */
2454 /* Assume the name is not dependent. */
2455 dependent_p = false;
2456 if (!processing_template_decl)
2457 /* No names are dependent outside a template. */
2459 /* A template-id where the name of the template was not resolved
2460 is definitely dependent. */
2461 else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2462 && (TREE_CODE (TREE_OPERAND (decl, 0))
2463 == IDENTIFIER_NODE))
2465 /* For anything except an overloaded function, just check its
2467 else if (!is_overloaded_fn (decl))
2469 = dependent_type_p (TREE_TYPE (decl));
2470 /* For a set of overloaded functions, check each of the
2476 if (BASELINK_P (fns))
2477 fns = BASELINK_FUNCTIONS (fns);
2479 /* For a template-id, check to see if the template
2480 arguments are dependent. */
2481 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
2483 tree args = TREE_OPERAND (fns, 1);
2484 dependent_p = any_dependent_template_arguments_p (args);
2485 /* The functions are those referred to by the
2487 fns = TREE_OPERAND (fns, 0);
2490 /* If there are no dependent template arguments, go through
2491 the overloaded functions. */
2492 while (fns && !dependent_p)
2494 tree fn = OVL_CURRENT (fns);
2496 /* Member functions of dependent classes are
2498 if (TREE_CODE (fn) == FUNCTION_DECL
2499 && type_dependent_expression_p (fn))
2501 else if (TREE_CODE (fn) == TEMPLATE_DECL
2502 && dependent_template_p (fn))
2505 fns = OVL_NEXT (fns);
2509 /* If the name was dependent on a template parameter, we will
2510 resolve the name at instantiation time. */
2513 /* Create a SCOPE_REF for qualified names, if the scope is
2518 *qualifying_class = scope;
2519 /* Since this name was dependent, the expression isn't
2520 constant -- yet. No error is issued because it might
2521 be constant when things are instantiated. */
2522 if (integral_constant_expression_p)
2523 *non_integral_constant_expression_p = true;
2524 if (TYPE_P (scope) && dependent_type_p (scope))
2525 return build_nt (SCOPE_REF, scope, id_expression);
2526 else if (TYPE_P (scope) && DECL_P (decl))
2527 return build (SCOPE_REF, TREE_TYPE (decl), scope,
2532 /* A TEMPLATE_ID already contains all the information we
2534 if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR)
2535 return id_expression;
2536 /* Since this name was dependent, the expression isn't
2537 constant -- yet. No error is issued because it might be
2538 constant when things are instantiated. */
2539 if (integral_constant_expression_p)
2540 *non_integral_constant_expression_p = true;
2541 *idk = CP_ID_KIND_UNQUALIFIED_DEPENDENT;
2542 return id_expression;
2545 /* Only certain kinds of names are allowed in constant
2546 expression. Enumerators and template parameters
2547 have already been handled above. */
2548 if (integral_constant_expression_p)
2550 /* Const variables or static data members of integral or
2551 enumeration types initialized with constant expressions
2553 if (TREE_CODE (decl) == VAR_DECL
2554 && CP_TYPE_CONST_P (TREE_TYPE (decl))
2555 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (decl))
2556 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
2560 if (!allow_non_integral_constant_expression_p)
2562 error ("`%D' cannot appear in a constant-expression", decl);
2563 return error_mark_node;
2565 *non_integral_constant_expression_p = true;
2569 if (TREE_CODE (decl) == NAMESPACE_DECL)
2571 error ("use of namespace `%D' as expression", decl);
2572 return error_mark_node;
2574 else if (DECL_CLASS_TEMPLATE_P (decl))
2576 error ("use of class template `%T' as expression", decl);
2577 return error_mark_node;
2579 else if (TREE_CODE (decl) == TREE_LIST)
2581 /* Ambiguous reference to base members. */
2582 error ("request for member `%D' is ambiguous in "
2583 "multiple inheritance lattice", id_expression);
2584 print_candidates (decl);
2585 return error_mark_node;
2588 /* Mark variable-like entities as used. Functions are similarly
2589 marked either below or after overload resolution. */
2590 if (TREE_CODE (decl) == VAR_DECL
2591 || TREE_CODE (decl) == PARM_DECL
2592 || TREE_CODE (decl) == RESULT_DECL)
2597 decl = (adjust_result_of_qualified_name_lookup
2598 (decl, scope, current_class_type));
2600 if (TREE_CODE (decl) == FUNCTION_DECL)
2603 if (TREE_CODE (decl) == FIELD_DECL || BASELINK_P (decl))
2604 *qualifying_class = scope;
2605 else if (!processing_template_decl)
2606 decl = convert_from_reference (decl);
2607 else if (TYPE_P (scope))
2608 decl = build (SCOPE_REF, TREE_TYPE (decl), scope, decl);
2610 else if (TREE_CODE (decl) == FIELD_DECL)
2611 decl = finish_non_static_data_member (decl, current_class_ref,
2612 /*qualifying_scope=*/NULL_TREE);
2613 else if (is_overloaded_fn (decl))
2615 tree first_fn = OVL_CURRENT (decl);
2617 if (TREE_CODE (first_fn) == TEMPLATE_DECL)
2618 first_fn = DECL_TEMPLATE_RESULT (first_fn);
2620 if (!really_overloaded_fn (decl))
2621 mark_used (first_fn);
2623 if (TREE_CODE (first_fn) == FUNCTION_DECL
2624 && DECL_FUNCTION_MEMBER_P (first_fn))
2626 /* A set of member functions. */
2627 decl = maybe_dummy_object (DECL_CONTEXT (first_fn), 0);
2628 return finish_class_member_access_expr (decl, id_expression);
2633 if (TREE_CODE (decl) == VAR_DECL
2634 || TREE_CODE (decl) == PARM_DECL
2635 || TREE_CODE (decl) == RESULT_DECL)
2637 tree context = decl_function_context (decl);
2639 if (context != NULL_TREE && context != current_function_decl
2640 && ! TREE_STATIC (decl))
2642 error ("use of %s from containing function",
2643 (TREE_CODE (decl) == VAR_DECL
2644 ? "`auto' variable" : "parameter"));
2645 cp_error_at (" `%#D' declared here", decl);
2646 return error_mark_node;
2650 if (DECL_P (decl) && DECL_NONLOCAL (decl)
2651 && DECL_CLASS_SCOPE_P (decl)
2652 && DECL_CONTEXT (decl) != current_class_type)
2656 path = currently_open_derived_class (DECL_CONTEXT (decl));
2657 perform_or_defer_access_check (TYPE_BINFO (path), decl);
2660 if (! processing_template_decl)
2661 decl = convert_from_reference (decl);
2664 /* Resolve references to variables of anonymous unions
2665 into COMPONENT_REFs. */
2666 if (TREE_CODE (decl) == ALIAS_DECL)
2667 decl = DECL_INITIAL (decl);
2670 if (TREE_DEPRECATED (decl))
2671 warn_deprecated_use (decl);
2676 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
2677 use as a type-specifier. */
2680 finish_typeof (tree expr)
2684 if (type_dependent_expression_p (expr))
2686 type = make_aggr_type (TYPEOF_TYPE);
2687 TYPE_FIELDS (type) = expr;
2692 type = TREE_TYPE (expr);
2694 if (!type || type == unknown_type_node)
2696 error ("type of `%E' is unknown", expr);
2697 return error_mark_node;
2703 /* Generate RTL for the statement T, and its substatements, and any
2704 other statements at its nesting level. */
2707 cp_expand_stmt (tree t)
2709 switch (TREE_CODE (t))
2712 genrtl_try_block (t);
2716 genrtl_eh_spec_block (t);
2732 /* Called from expand_body via walk_tree. Replace all AGGR_INIT_EXPRs
2733 will equivalent CALL_EXPRs. */
2736 simplify_aggr_init_exprs_r (tree* tp,
2738 void* data ATTRIBUTE_UNUSED)
2740 /* We don't need to walk into types; there's nothing in a type that
2741 needs simplification. (And, furthermore, there are places we
2742 actively don't want to go. For example, we don't want to wander
2743 into the default arguments for a FUNCTION_DECL that appears in a
2750 /* Only AGGR_INIT_EXPRs are interesting. */
2751 else if (TREE_CODE (*tp) != AGGR_INIT_EXPR)
2754 simplify_aggr_init_expr (tp);
2756 /* Keep iterating. */
2760 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
2761 function is broken out from the above for the benefit of the tree-ssa
2765 simplify_aggr_init_expr (tree *tp)
2767 tree aggr_init_expr = *tp;
2769 /* Form an appropriate CALL_EXPR. */
2770 tree fn = TREE_OPERAND (aggr_init_expr, 0);
2771 tree args = TREE_OPERAND (aggr_init_expr, 1);
2772 tree slot = TREE_OPERAND (aggr_init_expr, 2);
2773 tree type = TREE_TYPE (aggr_init_expr);
2776 enum style_t { ctor, arg, pcc } style;
2778 if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr))
2780 #ifdef PCC_STATIC_STRUCT_RETURN
2784 else if (TREE_ADDRESSABLE (type))
2787 /* We shouldn't build an AGGR_INIT_EXPR if we don't need any special
2788 handling. See build_cplus_new. */
2791 if (style == ctor || style == arg)
2793 /* Pass the address of the slot. If this is a constructor, we
2794 replace the first argument; otherwise, we tack on a new one. */
2798 args = TREE_CHAIN (args);
2800 cxx_mark_addressable (slot);
2801 addr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (slot)), slot);
2804 /* The return type might have different cv-quals from the slot. */
2805 tree fntype = TREE_TYPE (TREE_TYPE (fn));
2806 #ifdef ENABLE_CHECKING
2807 if (TREE_CODE (fntype) != FUNCTION_TYPE
2808 && TREE_CODE (fntype) != METHOD_TYPE)
2811 addr = convert (build_pointer_type (TREE_TYPE (fntype)), addr);
2814 args = tree_cons (NULL_TREE, addr, args);
2817 call_expr = build (CALL_EXPR,
2818 TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
2819 fn, args, NULL_TREE);
2822 /* Tell the backend that we've added our return slot to the argument
2824 CALL_EXPR_HAS_RETURN_SLOT_ADDR (call_expr) = 1;
2825 else if (style == pcc)
2827 /* If we're using the non-reentrant PCC calling convention, then we
2828 need to copy the returned value out of the static buffer into the
2830 push_deferring_access_checks (dk_no_check);
2831 call_expr = build_aggr_init (slot, call_expr,
2832 DIRECT_BIND | LOOKUP_ONLYCONVERTING);
2833 pop_deferring_access_checks ();
2836 /* We want to use the value of the initialized location as the
2838 call_expr = build (COMPOUND_EXPR, type,
2841 /* Replace the AGGR_INIT_EXPR with the CALL_EXPR. */
2842 TREE_CHAIN (call_expr) = TREE_CHAIN (aggr_init_expr);
2846 /* Emit all thunks to FN that should be emitted when FN is emitted. */
2849 emit_associated_thunks (tree fn)
2851 /* When we use vcall offsets, we emit thunks with the virtual
2852 functions to which they thunk. The whole point of vcall offsets
2853 is so that you can know statically the entire set of thunks that
2854 will ever be needed for a given virtual function, thereby
2855 enabling you to output all the thunks with the function itself. */
2856 if (DECL_VIRTUAL_P (fn))
2860 for (thunk = DECL_THUNKS (fn); thunk; thunk = TREE_CHAIN (thunk))
2862 if (!THUNK_ALIAS (thunk))
2864 use_thunk (thunk, /*emit_p=*/1);
2865 if (DECL_RESULT_THUNK_P (thunk))
2869 for (probe = DECL_THUNKS (thunk);
2870 probe; probe = TREE_CHAIN (probe))
2871 use_thunk (probe, /*emit_p=*/1);
2875 my_friendly_assert (!DECL_THUNKS (thunk), 20031023);
2880 /* Generate RTL for FN. */
2883 expand_body (tree fn)
2885 tree saved_function;
2887 /* Compute the appropriate object-file linkage for inline
2889 if (DECL_DECLARED_INLINE_P (fn))
2890 import_export_decl (fn);
2892 /* If FN is external, then there's no point in generating RTL for
2893 it. This situation can arise with an inline function under
2894 `-fexternal-templates'; we instantiate the function, even though
2895 we're not planning on emitting it, in case we get a chance to
2897 if (DECL_EXTERNAL (fn))
2900 /* ??? When is this needed? */
2901 saved_function = current_function_decl;
2903 timevar_push (TV_INTEGRATION);
2904 optimize_function (fn);
2905 timevar_pop (TV_INTEGRATION);
2907 tree_rest_of_compilation (fn, function_depth > 1);
2909 current_function_decl = saved_function;
2911 extract_interface_info ();
2913 /* Emit any thunks that should be emitted at the same time as FN. */
2914 emit_associated_thunks (fn);
2916 /* If this function is marked with the constructor attribute, add it
2917 to the list of functions to be called along with constructors
2918 from static duration objects. */
2919 if (DECL_STATIC_CONSTRUCTOR (fn))
2920 static_ctors = tree_cons (NULL_TREE, fn, static_ctors);
2922 /* If this function is marked with the destructor attribute, add it
2923 to the list of functions to be called along with destructors from
2924 static duration objects. */
2925 if (DECL_STATIC_DESTRUCTOR (fn))
2926 static_dtors = tree_cons (NULL_TREE, fn, static_dtors);
2928 if (DECL_CLONED_FUNCTION_P (fn))
2930 /* If this is a clone, go through the other clones now and mark
2931 their parameters used. We have to do that here, as we don't
2932 know whether any particular clone will be expanded, and
2933 therefore cannot pick one arbitrarily. */
2936 for (probe = TREE_CHAIN (DECL_CLONED_FUNCTION (fn));
2937 probe && DECL_CLONED_FUNCTION_P (probe);
2938 probe = TREE_CHAIN (probe))
2942 for (parms = DECL_ARGUMENTS (probe);
2943 parms; parms = TREE_CHAIN (parms))
2944 TREE_USED (parms) = 1;
2949 /* Generate RTL for FN. */
2952 expand_or_defer_fn (tree fn)
2954 /* When the parser calls us after finishing the body of a template
2955 function, we don't really want to expand the body. When we're
2956 processing an in-class definition of an inline function,
2957 PROCESSING_TEMPLATE_DECL will no longer be set here, so we have
2958 to look at the function itself. */
2959 if (processing_template_decl
2960 || (DECL_LANG_SPECIFIC (fn)
2961 && DECL_TEMPLATE_INFO (fn)
2962 && uses_template_parms (DECL_TI_ARGS (fn))))
2964 /* Normally, collection only occurs in rest_of_compilation. So,
2965 if we don't collect here, we never collect junk generated
2966 during the processing of templates until we hit a
2967 non-template function. */
2972 /* Replace AGGR_INIT_EXPRs with appropriate CALL_EXPRs. */
2973 walk_tree_without_duplicates (&DECL_SAVED_TREE (fn),
2974 simplify_aggr_init_exprs_r,
2977 /* If this is a constructor or destructor body, we have to clone
2979 if (maybe_clone_body (fn))
2981 /* We don't want to process FN again, so pretend we've written
2982 it out, even though we haven't. */
2983 TREE_ASM_WRITTEN (fn) = 1;
2987 /* There's no reason to do any of the work here if we're only doing
2988 semantic analysis; this code just generates RTL. */
2989 if (flag_syntax_only)
2992 /* Compute the appropriate object-file linkage for inline functions. */
2993 if (DECL_DECLARED_INLINE_P (fn))
2994 import_export_decl (fn);
2998 /* Expand or defer, at the whim of the compilation unit manager. */
2999 cgraph_finalize_function (fn, function_depth > 1);
3004 /* Helper function for walk_tree, used by finish_function to override all
3005 the RETURN_STMTs and pertinent CLEANUP_STMTs for the named return
3006 value optimization. */
3009 nullify_returns_r (tree* tp, int* walk_subtrees, void* data)
3011 tree nrv = (tree) data;
3013 /* No need to walk into types. There wouldn't be any need to walk into
3014 non-statements, except that we have to consider STMT_EXPRs. */
3017 else if (TREE_CODE (*tp) == RETURN_STMT)
3018 RETURN_STMT_EXPR (*tp) = NULL_TREE;
3019 else if (TREE_CODE (*tp) == CLEANUP_STMT
3020 && CLEANUP_DECL (*tp) == nrv)
3021 CLEANUP_EH_ONLY (*tp) = 1;
3023 /* Keep iterating. */
3027 /* Start generating the RTL for FN. */
3030 cxx_expand_function_start (void)
3032 /* Give our named return value the same RTL as our RESULT_DECL. */
3033 if (current_function_return_value)
3034 COPY_DECL_RTL (DECL_RESULT (cfun->decl), current_function_return_value);
3037 /* Perform initialization related to this module. */
3040 init_cp_semantics (void)
3042 lang_expand_stmt = cp_expand_stmt;
3045 #include "gt-cp-semantics.h"