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 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. */
139 void push_deferring_access_checks (deferring_kind deferring
)
143 /* For context like template instantiation, access checking
144 disabling applies to all nested context. */
145 if (deferred_access_stack
146 && deferred_access_stack
->deferring_access_checks_kind
== dk_no_check
)
147 deferring
= dk_no_check
;
149 /* Recycle previously used free store if available. */
150 if (deferred_access_free_list
)
152 d
= deferred_access_free_list
;
153 deferred_access_free_list
= d
->next
;
156 d
= ggc_alloc (sizeof (deferred_access
));
158 d
->next
= deferred_access_stack
;
159 d
->deferred_access_checks
= NULL_TREE
;
160 d
->deferring_access_checks_kind
= deferring
;
161 deferred_access_stack
= d
;
164 /* Resume deferring access checks again after we stopped doing
167 void resume_deferring_access_checks (void)
169 if (deferred_access_stack
->deferring_access_checks_kind
== dk_no_deferred
)
170 deferred_access_stack
->deferring_access_checks_kind
= dk_deferred
;
173 /* Stop deferring access checks. */
175 void stop_deferring_access_checks (void)
177 if (deferred_access_stack
->deferring_access_checks_kind
== dk_deferred
)
178 deferred_access_stack
->deferring_access_checks_kind
= dk_no_deferred
;
181 /* Discard the current deferred access checks and restore the
184 void pop_deferring_access_checks (void)
186 deferred_access
*d
= deferred_access_stack
;
187 deferred_access_stack
= d
->next
;
189 /* Remove references to access checks TREE_LIST. */
190 d
->deferred_access_checks
= NULL_TREE
;
192 /* Store in free list for later use. */
193 d
->next
= deferred_access_free_list
;
194 deferred_access_free_list
= d
;
197 /* Returns a TREE_LIST representing the deferred checks.
198 The TREE_PURPOSE of each node is the type through which the
199 access occurred; the TREE_VALUE is the declaration named.
202 tree
get_deferred_access_checks (void)
204 return deferred_access_stack
->deferred_access_checks
;
207 /* Take current deferred checks and combine with the
208 previous states if we also defer checks previously.
209 Otherwise perform checks now. */
211 void pop_to_parent_deferring_access_checks (void)
213 tree deferred_check
= get_deferred_access_checks ();
214 deferred_access
*d1
= deferred_access_stack
;
215 deferred_access
*d2
= deferred_access_stack
->next
;
216 deferred_access
*d3
= deferred_access_stack
->next
->next
;
218 /* Temporary swap the order of the top two states, just to make
219 sure the garbage collector will not reclaim the memory during
221 deferred_access_stack
= d2
;
225 for ( ; deferred_check
; deferred_check
= TREE_CHAIN (deferred_check
))
226 /* Perform deferred check if required. */
227 perform_or_defer_access_check (TREE_PURPOSE (deferred_check
),
228 TREE_VALUE (deferred_check
));
230 deferred_access_stack
= d1
;
233 pop_deferring_access_checks ();
236 /* Perform the deferred access checks.
238 After performing the checks, we still have to keep the list
239 `deferred_access_stack->deferred_access_checks' since we may want
240 to check access for them again later in a different context.
247 A::X A::a, x; // No error for `A::a', error for `x'
249 We have to perform deferred access of `A::X', first with `A::a',
252 void perform_deferred_access_checks (void)
255 for (deferred_check
= deferred_access_stack
->deferred_access_checks
;
257 deferred_check
= TREE_CHAIN (deferred_check
))
259 enforce_access (TREE_PURPOSE (deferred_check
),
260 TREE_VALUE (deferred_check
));
263 /* Defer checking the accessibility of DECL, when looked up in
266 void perform_or_defer_access_check (tree binfo
, tree decl
)
270 my_friendly_assert (TREE_CODE (binfo
) == TREE_VEC
, 20030623);
272 /* If we are not supposed to defer access checks, just check now. */
273 if (deferred_access_stack
->deferring_access_checks_kind
== dk_no_deferred
)
275 enforce_access (binfo
, decl
);
278 /* Exit if we are in a context that no access checking is performed. */
279 else if (deferred_access_stack
->deferring_access_checks_kind
== dk_no_check
)
282 /* See if we are already going to perform this check. */
283 for (check
= deferred_access_stack
->deferred_access_checks
;
285 check
= TREE_CHAIN (check
))
286 if (TREE_VALUE (check
) == decl
&& TREE_PURPOSE (check
) == binfo
)
288 /* If not, record the check. */
289 deferred_access_stack
->deferred_access_checks
290 = tree_cons (binfo
, decl
,
291 deferred_access_stack
->deferred_access_checks
);
294 /* Returns nonzero if the current statement is a full expression,
295 i.e. temporaries created during that statement should be destroyed
296 at the end of the statement. */
299 stmts_are_full_exprs_p (void)
301 return current_stmt_tree ()->stmts_are_full_exprs_p
;
304 /* Returns the stmt_tree (if any) to which statements are currently
305 being added. If there is no active statement-tree, NULL is
309 current_stmt_tree (void)
312 ? &cfun
->language
->base
.x_stmt_tree
313 : &scope_chain
->x_stmt_tree
);
316 /* Nonzero if TYPE is an anonymous union or struct type. We have to use a
317 flag for this because "A union for which objects or pointers are
318 declared is not an anonymous union" [class.union]. */
321 anon_aggr_type_p (tree node
)
323 return ANON_AGGR_TYPE_P (node
);
326 /* Finish a scope. */
331 tree block
= NULL_TREE
;
333 if (stmts_are_full_exprs_p ())
335 tree scope_stmts
= NULL_TREE
;
337 block
= poplevel (kept_level_p (), 1, 0);
338 if (!processing_template_decl
)
340 /* This needs to come after the poplevel so that partial scopes
341 are properly nested. */
342 scope_stmts
= add_scope_stmt (/*begin_p=*/0, /*partial_p=*/0);
345 SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts
)) = block
;
346 SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts
)) = block
;
354 /* Begin a new scope. */
357 do_pushlevel (scope_kind sk
)
359 if (stmts_are_full_exprs_p ())
361 if (!processing_template_decl
)
362 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/0);
363 begin_scope (sk
, NULL
);
367 /* Finish a goto-statement. */
370 finish_goto_stmt (tree destination
)
372 if (TREE_CODE (destination
) == IDENTIFIER_NODE
)
373 destination
= lookup_label (destination
);
375 /* We warn about unused labels with -Wunused. That means we have to
376 mark the used labels as used. */
377 if (TREE_CODE (destination
) == LABEL_DECL
)
378 TREE_USED (destination
) = 1;
381 /* The DESTINATION is being used as an rvalue. */
382 if (!processing_template_decl
)
383 destination
= decay_conversion (destination
);
384 /* We don't inline calls to functions with computed gotos.
385 Those functions are typically up to some funny business,
386 and may be depending on the labels being at particular
387 addresses, or some such. */
388 DECL_UNINLINABLE (current_function_decl
) = 1;
391 check_goto (destination
);
393 return add_stmt (build_stmt (GOTO_STMT
, destination
));
396 /* COND is the condition-expression for an if, while, etc.,
397 statement. Convert it to a boolean value, if appropriate. */
400 maybe_convert_cond (tree cond
)
402 /* Empty conditions remain empty. */
406 /* Wait until we instantiate templates before doing conversion. */
407 if (processing_template_decl
)
410 /* Do the conversion. */
411 cond
= convert_from_reference (cond
);
412 return condition_conversion (cond
);
415 /* Finish an expression-statement, whose EXPRESSION is as indicated. */
418 finish_expr_stmt (tree expr
)
422 if (expr
!= NULL_TREE
)
424 if (!processing_template_decl
)
425 expr
= convert_to_void (expr
, "statement");
426 else if (!type_dependent_expression_p (expr
))
427 convert_to_void (build_non_dependent_expr (expr
), "statement");
429 r
= add_stmt (build_stmt (EXPR_STMT
, expr
));
438 /* Begin an if-statement. Returns a newly created IF_STMT if
445 do_pushlevel (sk_block
);
446 r
= build_stmt (IF_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
451 /* Process the COND of an if-statement, which may be given by
455 finish_if_stmt_cond (tree cond
, tree if_stmt
)
457 cond
= maybe_convert_cond (cond
);
458 FINISH_COND (cond
, if_stmt
, IF_COND (if_stmt
));
461 /* Finish the then-clause of an if-statement, which may be given by
465 finish_then_clause (tree if_stmt
)
467 RECHAIN_STMTS (if_stmt
, THEN_CLAUSE (if_stmt
));
471 /* Begin the else-clause of an if-statement. */
474 begin_else_clause (void)
478 /* Finish the else-clause of an if-statement, which may be given by
482 finish_else_clause (tree if_stmt
)
484 RECHAIN_STMTS (if_stmt
, ELSE_CLAUSE (if_stmt
));
487 /* Finish an if-statement. */
490 finish_if_stmt (void)
496 /* Begin a while-statement. Returns a newly created WHILE_STMT if
500 begin_while_stmt (void)
503 r
= build_stmt (WHILE_STMT
, NULL_TREE
, NULL_TREE
);
505 do_pushlevel (sk_block
);
509 /* Process the COND of a while-statement, which may be given by
513 finish_while_stmt_cond (tree cond
, tree while_stmt
)
515 cond
= maybe_convert_cond (cond
);
516 if (processing_template_decl
)
517 /* Don't mess with condition decls in a template. */
518 FINISH_COND (cond
, while_stmt
, WHILE_COND (while_stmt
));
519 else if (getdecls () == NULL_TREE
)
520 /* It was a simple condition; install it. */
521 WHILE_COND (while_stmt
) = cond
;
524 /* If there was a declaration in the condition, we can't leave it
528 while (true) { A x = 42; if (!x) break; } */
530 WHILE_COND (while_stmt
) = boolean_true_node
;
532 if_stmt
= begin_if_stmt ();
533 cond
= build_unary_op (TRUTH_NOT_EXPR
, cond
, 0);
534 finish_if_stmt_cond (cond
, if_stmt
);
535 finish_break_stmt ();
536 finish_then_clause (if_stmt
);
541 /* Finish a while-statement, which may be given by WHILE_STMT. */
544 finish_while_stmt (tree while_stmt
)
547 RECHAIN_STMTS (while_stmt
, WHILE_BODY (while_stmt
));
551 /* Begin a do-statement. Returns a newly created DO_STMT if
557 tree r
= build_stmt (DO_STMT
, NULL_TREE
, NULL_TREE
);
562 /* Finish the body of a do-statement, which may be given by DO_STMT. */
565 finish_do_body (tree do_stmt
)
567 RECHAIN_STMTS (do_stmt
, DO_BODY (do_stmt
));
570 /* Finish a do-statement, which may be given by DO_STMT, and whose
571 COND is as indicated. */
574 finish_do_stmt (tree cond
, tree do_stmt
)
576 cond
= maybe_convert_cond (cond
);
577 DO_COND (do_stmt
) = cond
;
581 /* Finish a return-statement. The EXPRESSION returned, if any, is as
585 finish_return_stmt (tree expr
)
589 expr
= check_return_expr (expr
);
590 if (!processing_template_decl
)
592 if (DECL_DESTRUCTOR_P (current_function_decl
))
594 /* Similarly, all destructors must run destructors for
595 base-classes before returning. So, all returns in a
596 destructor get sent to the DTOR_LABEL; finish_function emits
597 code to return a value there. */
598 return finish_goto_stmt (dtor_label
);
601 r
= add_stmt (build_stmt (RETURN_STMT
, expr
));
607 /* Begin a for-statement. Returns a new FOR_STMT if appropriate. */
610 begin_for_stmt (void)
614 r
= build_stmt (FOR_STMT
, NULL_TREE
, NULL_TREE
,
615 NULL_TREE
, NULL_TREE
);
616 NEW_FOR_SCOPE_P (r
) = flag_new_for_scope
> 0;
617 if (NEW_FOR_SCOPE_P (r
))
618 do_pushlevel (sk_for
);
624 /* Finish the for-init-statement of a for-statement, which may be
625 given by FOR_STMT. */
628 finish_for_init_stmt (tree for_stmt
)
630 if (last_tree
!= for_stmt
)
631 RECHAIN_STMTS (for_stmt
, FOR_INIT_STMT (for_stmt
));
632 do_pushlevel (sk_block
);
635 /* Finish the COND of a for-statement, which may be given by
639 finish_for_cond (tree cond
, tree for_stmt
)
641 cond
= maybe_convert_cond (cond
);
642 if (processing_template_decl
)
643 /* Don't mess with condition decls in a template. */
644 FINISH_COND (cond
, for_stmt
, FOR_COND (for_stmt
));
645 else if (getdecls () == NULL_TREE
)
646 /* It was a simple condition; install it. */
647 FOR_COND (for_stmt
) = cond
;
650 /* If there was a declaration in the condition, we can't leave it
652 for (; A x = 42;) { }
654 for (;;) { A x = 42; if (!x) break; } */
656 FOR_COND (for_stmt
) = NULL_TREE
;
658 if_stmt
= begin_if_stmt ();
659 cond
= build_unary_op (TRUTH_NOT_EXPR
, cond
, 0);
660 finish_if_stmt_cond (cond
, if_stmt
);
661 finish_break_stmt ();
662 finish_then_clause (if_stmt
);
667 /* Finish the increment-EXPRESSION in a for-statement, which may be
668 given by FOR_STMT. */
671 finish_for_expr (tree expr
, tree for_stmt
)
673 FOR_EXPR (for_stmt
) = expr
;
676 /* Finish the body of a for-statement, which may be given by
677 FOR_STMT. The increment-EXPR for the loop must be
681 finish_for_stmt (tree for_stmt
)
683 /* Pop the scope for the body of the loop. */
685 RECHAIN_STMTS (for_stmt
, FOR_BODY (for_stmt
));
686 if (NEW_FOR_SCOPE_P (for_stmt
))
691 /* Finish a break-statement. */
694 finish_break_stmt (void)
696 return add_stmt (build_break_stmt ());
699 /* Finish a continue-statement. */
702 finish_continue_stmt (void)
704 return add_stmt (build_continue_stmt ());
707 /* Begin a switch-statement. Returns a new SWITCH_STMT if
711 begin_switch_stmt (void)
714 do_pushlevel (sk_block
);
715 r
= build_stmt (SWITCH_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
720 /* Finish the cond of a switch-statement. */
723 finish_switch_cond (tree cond
, tree switch_stmt
)
725 tree orig_type
= NULL
;
726 if (!processing_template_decl
)
730 /* Convert the condition to an integer or enumeration type. */
731 cond
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, cond
, true);
732 if (cond
== NULL_TREE
)
734 error ("switch quantity not an integer");
735 cond
= error_mark_node
;
737 orig_type
= TREE_TYPE (cond
);
738 if (cond
!= error_mark_node
)
742 Integral promotions are performed. */
743 cond
= perform_integral_promotions (cond
);
744 cond
= fold (build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (cond
), cond
));
747 if (cond
!= error_mark_node
)
749 index
= get_unwidened (cond
, NULL_TREE
);
750 /* We can't strip a conversion from a signed type to an unsigned,
751 because if we did, int_fits_type_p would do the wrong thing
752 when checking case values for being in range,
753 and it's too hard to do the right thing. */
754 if (TREE_UNSIGNED (TREE_TYPE (cond
))
755 == TREE_UNSIGNED (TREE_TYPE (index
)))
759 FINISH_COND (cond
, switch_stmt
, SWITCH_COND (switch_stmt
));
760 SWITCH_TYPE (switch_stmt
) = orig_type
;
761 push_switch (switch_stmt
);
764 /* Finish the body of a switch-statement, which may be given by
765 SWITCH_STMT. The COND to switch on is indicated. */
768 finish_switch_stmt (tree switch_stmt
)
770 RECHAIN_STMTS (switch_stmt
, SWITCH_BODY (switch_stmt
));
776 /* Generate the RTL for T, which is a TRY_BLOCK. */
779 genrtl_try_block (tree t
)
783 expand_eh_region_start ();
784 expand_stmt (TRY_STMTS (t
));
785 expand_eh_region_end_cleanup (TRY_HANDLERS (t
));
789 if (!FN_TRY_BLOCK_P (t
))
790 emit_line_note (input_location
);
792 expand_eh_region_start ();
793 expand_stmt (TRY_STMTS (t
));
795 if (FN_TRY_BLOCK_P (t
))
797 expand_start_all_catch ();
798 in_function_try_handler
= 1;
799 expand_stmt (TRY_HANDLERS (t
));
800 in_function_try_handler
= 0;
801 expand_end_all_catch ();
805 expand_start_all_catch ();
806 expand_stmt (TRY_HANDLERS (t
));
807 expand_end_all_catch ();
812 /* Generate the RTL for T, which is an EH_SPEC_BLOCK. */
815 genrtl_eh_spec_block (tree t
)
817 expand_eh_region_start ();
818 expand_stmt (EH_SPEC_STMTS (t
));
819 expand_eh_region_end_allowed (EH_SPEC_RAISES (t
),
820 build_call (call_unexpected_node
,
821 tree_cons (NULL_TREE
,
826 /* Begin a try-block. Returns a newly-created TRY_BLOCK if
830 begin_try_block (void)
832 tree r
= build_stmt (TRY_BLOCK
, NULL_TREE
, NULL_TREE
);
837 /* Likewise, for a function-try-block. */
840 begin_function_try_block (void)
842 tree r
= build_stmt (TRY_BLOCK
, NULL_TREE
, NULL_TREE
);
843 FN_TRY_BLOCK_P (r
) = 1;
848 /* Finish a try-block, which may be given by TRY_BLOCK. */
851 finish_try_block (tree try_block
)
853 RECHAIN_STMTS (try_block
, TRY_STMTS (try_block
));
856 /* Finish the body of a cleanup try-block, which may be given by
860 finish_cleanup_try_block (tree try_block
)
862 RECHAIN_STMTS (try_block
, TRY_STMTS (try_block
));
865 /* Finish an implicitly generated try-block, with a cleanup is given
869 finish_cleanup (tree cleanup
, tree try_block
)
871 TRY_HANDLERS (try_block
) = cleanup
;
872 CLEANUP_P (try_block
) = 1;
875 /* Likewise, for a function-try-block. */
878 finish_function_try_block (tree try_block
)
880 if (TREE_CHAIN (try_block
)
881 && TREE_CODE (TREE_CHAIN (try_block
)) == CTOR_INITIALIZER
)
883 /* Chain the compound statement after the CTOR_INITIALIZER. */
884 TREE_CHAIN (TREE_CHAIN (try_block
)) = last_tree
;
885 /* And make the CTOR_INITIALIZER the body of the try-block. */
886 RECHAIN_STMTS (try_block
, TRY_STMTS (try_block
));
889 RECHAIN_STMTS (try_block
, TRY_STMTS (try_block
));
890 in_function_try_handler
= 1;
893 /* Finish a handler-sequence for a try-block, which may be given by
897 finish_handler_sequence (tree try_block
)
899 RECHAIN_STMTS (try_block
, TRY_HANDLERS (try_block
));
900 check_handlers (TRY_HANDLERS (try_block
));
903 /* Likewise, for a function-try-block. */
906 finish_function_handler_sequence (tree try_block
)
908 in_function_try_handler
= 0;
909 RECHAIN_STMTS (try_block
, TRY_HANDLERS (try_block
));
910 check_handlers (TRY_HANDLERS (try_block
));
913 /* Generate the RTL for T, which is a HANDLER. */
916 genrtl_handler (tree t
)
918 genrtl_do_pushlevel ();
919 if (!processing_template_decl
)
920 expand_start_catch (HANDLER_TYPE (t
));
921 expand_stmt (HANDLER_BODY (t
));
922 if (!processing_template_decl
)
926 /* Begin a handler. Returns a HANDLER if appropriate. */
932 r
= build_stmt (HANDLER
, NULL_TREE
, NULL_TREE
);
934 /* Create a binding level for the eh_info and the exception object
936 do_pushlevel (sk_catch
);
940 /* Finish the handler-parameters for a handler, which may be given by
941 HANDLER. DECL is the declaration for the catch parameter, or NULL
942 if this is a `catch (...)' clause. */
945 finish_handler_parms (tree decl
, tree handler
)
947 tree type
= NULL_TREE
;
948 if (processing_template_decl
)
952 decl
= pushdecl (decl
);
953 decl
= push_template_decl (decl
);
954 add_decl_stmt (decl
);
955 RECHAIN_STMTS (handler
, HANDLER_PARMS (handler
));
956 type
= TREE_TYPE (decl
);
960 type
= expand_start_catch_block (decl
);
962 HANDLER_TYPE (handler
) = type
;
964 mark_used (eh_type_info (type
));
967 /* Finish a handler, which may be given by HANDLER. The BLOCKs are
968 the return value from the matching call to finish_handler_parms. */
971 finish_handler (tree handler
)
973 if (!processing_template_decl
)
974 expand_end_catch_block ();
976 RECHAIN_STMTS (handler
, HANDLER_BODY (handler
));
979 /* Begin a compound-statement. If HAS_NO_SCOPE is true, the
980 compound-statement does not define a scope. Returns a new
984 begin_compound_stmt (bool has_no_scope
)
989 r
= build_stmt (COMPOUND_STMT
, NULL_TREE
);
991 if (last_tree
&& TREE_CODE (last_tree
) == TRY_BLOCK
)
996 COMPOUND_STMT_NO_SCOPE (r
) = 1;
998 last_expr_type
= NULL_TREE
;
1001 do_pushlevel (is_try
? sk_try
: sk_block
);
1003 /* Normally, we try hard to keep the BLOCK for a
1004 statement-expression. But, if it's a statement-expression with
1005 a scopeless block, there's nothing to keep, and we don't want
1006 to accidentally keep a block *inside* the scopeless block. */
1007 keep_next_level (false);
1012 /* Finish a compound-statement, which is given by COMPOUND_STMT. */
1015 finish_compound_stmt (tree compound_stmt
)
1020 if (COMPOUND_STMT_NO_SCOPE (compound_stmt
))
1025 RECHAIN_STMTS (compound_stmt
, COMPOUND_BODY (compound_stmt
));
1027 /* When we call finish_stmt we will lose LAST_EXPR_TYPE. But, since
1028 the precise purpose of that variable is store the type of the
1029 last expression statement within the last compound statement, we
1030 preserve the value. */
1038 /* Finish an asm-statement, whose components are a CV_QUALIFIER, a
1039 STRING, some OUTPUT_OPERANDS, some INPUT_OPERANDS, and some
1043 finish_asm_stmt (tree cv_qualifier
,
1045 tree output_operands
,
1046 tree input_operands
,
1052 if (cv_qualifier
!= NULL_TREE
1053 && cv_qualifier
!= ridpointers
[(int) RID_VOLATILE
])
1055 warning ("%s qualifier ignored on asm",
1056 IDENTIFIER_POINTER (cv_qualifier
));
1057 cv_qualifier
= NULL_TREE
;
1060 if (!processing_template_decl
)
1066 for (t
= input_operands
; t
; t
= TREE_CHAIN (t
))
1068 tree converted_operand
1069 = decay_conversion (TREE_VALUE (t
));
1071 /* If the type of the operand hasn't been determined (e.g.,
1072 because it involves an overloaded function), then issue
1073 an error message. There's no context available to
1074 resolve the overloading. */
1075 if (TREE_TYPE (converted_operand
) == unknown_type_node
)
1077 error ("type of asm operand `%E' could not be determined",
1079 converted_operand
= error_mark_node
;
1081 TREE_VALUE (t
) = converted_operand
;
1084 ninputs
= list_length (input_operands
);
1085 noutputs
= list_length (output_operands
);
1087 for (i
= 0, t
= output_operands
; t
; t
= TREE_CHAIN (t
), ++i
)
1092 const char *constraint
;
1095 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1096 operand
= TREE_VALUE (t
);
1098 if (!parse_output_constraint (&constraint
,
1099 i
, ninputs
, noutputs
,
1104 /* By marking this operand as erroneous, we will not try
1105 to process this operand again in expand_asm_operands. */
1106 TREE_VALUE (t
) = error_mark_node
;
1110 /* If the operand is a DECL that is going to end up in
1111 memory, assume it is addressable. This is a bit more
1112 conservative than it would ideally be; the exact test is
1113 buried deep in expand_asm_operands and depends on the
1114 DECL_RTL for the OPERAND -- which we don't have at this
1116 if (!allows_reg
&& DECL_P (operand
))
1117 cxx_mark_addressable (operand
);
1121 r
= build_stmt (ASM_STMT
, cv_qualifier
, string
,
1122 output_operands
, input_operands
,
1124 return add_stmt (r
);
1127 /* Finish a label with the indicated NAME. */
1130 finish_label_stmt (tree name
)
1132 tree decl
= define_label (input_location
, name
);
1133 return add_stmt (build_stmt (LABEL_STMT
, decl
));
1136 /* Finish a series of declarations for local labels. G++ allows users
1137 to declare "local" labels, i.e., labels with scope. This extension
1138 is useful when writing code involving statement-expressions. */
1141 finish_label_decl (tree name
)
1143 tree decl
= declare_local_label (name
);
1144 add_decl_stmt (decl
);
1147 /* When DECL goes out of scope, make sure that CLEANUP is executed. */
1150 finish_decl_cleanup (tree decl
, tree cleanup
)
1152 add_stmt (build_stmt (CLEANUP_STMT
, decl
, cleanup
));
1155 /* If the current scope exits with an exception, run CLEANUP. */
1158 finish_eh_cleanup (tree cleanup
)
1160 tree r
= build_stmt (CLEANUP_STMT
, NULL_TREE
, cleanup
);
1161 CLEANUP_EH_ONLY (r
) = 1;
1165 /* The MEM_INITS is a list of mem-initializers, in reverse of the
1166 order they were written by the user. Each node is as for
1167 emit_mem_initializers. */
1170 finish_mem_initializers (tree mem_inits
)
1172 /* Reorder the MEM_INITS so that they are in the order they appeared
1173 in the source program. */
1174 mem_inits
= nreverse (mem_inits
);
1176 if (processing_template_decl
)
1177 add_stmt (build_min_nt (CTOR_INITIALIZER
, mem_inits
));
1179 emit_mem_initializers (mem_inits
);
1182 /* Returns the stack of SCOPE_STMTs for the current function. */
1185 current_scope_stmt_stack (void)
1187 return &cfun
->language
->base
.x_scope_stmt_stack
;
1190 /* Finish a parenthesized expression EXPR. */
1193 finish_parenthesized_expr (tree expr
)
1195 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (expr
))))
1196 /* This inhibits warnings in c_common_truthvalue_conversion. */
1197 C_SET_EXP_ORIGINAL_CODE (expr
, ERROR_MARK
);
1199 if (TREE_CODE (expr
) == OFFSET_REF
)
1200 /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
1201 enclosed in parentheses. */
1202 PTRMEM_OK_P (expr
) = 0;
1206 /* Finish a reference to a non-static data member (DECL) that is not
1207 preceded by `.' or `->'. */
1210 finish_non_static_data_member (tree decl
, tree object
, tree qualifying_scope
)
1212 my_friendly_assert (TREE_CODE (decl
) == FIELD_DECL
, 20020909);
1216 if (current_function_decl
1217 && DECL_STATIC_FUNCTION_P (current_function_decl
))
1218 cp_error_at ("invalid use of member `%D' in static member function",
1221 cp_error_at ("invalid use of non-static data member `%D'", decl
);
1222 error ("from this location");
1224 return error_mark_node
;
1226 TREE_USED (current_class_ptr
) = 1;
1227 if (processing_template_decl
)
1229 tree type
= TREE_TYPE (decl
);
1231 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1232 type
= TREE_TYPE (type
);
1235 /* Set the cv qualifiers */
1236 int quals
= cp_type_quals (TREE_TYPE (current_class_ref
));
1238 if (DECL_MUTABLE_P (decl
))
1239 quals
&= ~TYPE_QUAL_CONST
;
1241 quals
|= cp_type_quals (TREE_TYPE (decl
));
1242 type
= cp_build_qualified_type (type
, quals
);
1245 return build_min (COMPONENT_REF
, type
, object
, decl
);
1249 tree access_type
= TREE_TYPE (object
);
1250 tree lookup_context
= context_for_name_lookup (decl
);
1252 while (!DERIVED_FROM_P (lookup_context
, access_type
))
1254 access_type
= TYPE_CONTEXT (access_type
);
1255 while (access_type
&& DECL_P (access_type
))
1256 access_type
= DECL_CONTEXT (access_type
);
1260 cp_error_at ("object missing in reference to `%D'", decl
);
1261 error ("from this location");
1262 return error_mark_node
;
1266 perform_or_defer_access_check (TYPE_BINFO (access_type
), decl
);
1268 /* If the data member was named `C::M', convert `*this' to `C'
1270 if (qualifying_scope
)
1272 tree binfo
= NULL_TREE
;
1273 object
= build_scoped_ref (object
, qualifying_scope
,
1277 return build_class_member_access_expr (object
, decl
,
1278 /*access_path=*/NULL_TREE
,
1279 /*preserve_reference=*/false);
1283 /* DECL was the declaration to which a qualified-id resolved. Issue
1284 an error message if it is not accessible. If OBJECT_TYPE is
1285 non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
1286 type of `*x', or `x', respectively. If the DECL was named as
1287 `A::B' then NESTED_NAME_SPECIFIER is `A'. */
1290 check_accessibility_of_qualified_id (tree decl
,
1292 tree nested_name_specifier
)
1295 tree qualifying_type
= NULL_TREE
;
1297 /* Determine the SCOPE of DECL. */
1298 scope
= context_for_name_lookup (decl
);
1299 /* If the SCOPE is not a type, then DECL is not a member. */
1300 if (!TYPE_P (scope
))
1302 /* Compute the scope through which DECL is being accessed. */
1304 /* OBJECT_TYPE might not be a class type; consider:
1306 class A { typedef int I; };
1310 In this case, we will have "A::I" as the DECL, but "I" as the
1312 && CLASS_TYPE_P (object_type
)
1313 && DERIVED_FROM_P (scope
, object_type
))
1314 /* If we are processing a `->' or `.' expression, use the type of the
1316 qualifying_type
= object_type
;
1317 else if (nested_name_specifier
)
1319 /* If the reference is to a non-static member of the
1320 current class, treat it as if it were referenced through
1322 if (DECL_NONSTATIC_MEMBER_P (decl
)
1323 && current_class_ptr
1324 && DERIVED_FROM_P (scope
, current_class_type
))
1325 qualifying_type
= current_class_type
;
1326 /* Otherwise, use the type indicated by the
1327 nested-name-specifier. */
1329 qualifying_type
= nested_name_specifier
;
1332 /* Otherwise, the name must be from the current class or one of
1334 qualifying_type
= currently_open_derived_class (scope
);
1336 if (qualifying_type
)
1337 perform_or_defer_access_check (TYPE_BINFO (qualifying_type
), decl
);
1340 /* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
1341 class named to the left of the "::" operator. DONE is true if this
1342 expression is a complete postfix-expression; it is false if this
1343 expression is followed by '->', '[', '(', etc. ADDRESS_P is true
1344 iff this expression is the operand of '&'. */
1347 finish_qualified_id_expr (tree qualifying_class
, tree expr
, bool done
,
1350 if (error_operand_p (expr
))
1351 return error_mark_node
;
1353 /* If EXPR occurs as the operand of '&', use special handling that
1354 permits a pointer-to-member. */
1355 if (address_p
&& done
)
1357 if (TREE_CODE (expr
) == SCOPE_REF
)
1358 expr
= TREE_OPERAND (expr
, 1);
1359 expr
= build_offset_ref (qualifying_class
, expr
,
1360 /*address_p=*/true);
1364 if (TREE_CODE (expr
) == FIELD_DECL
)
1365 expr
= finish_non_static_data_member (expr
, current_class_ref
,
1367 else if (BASELINK_P (expr
) && !processing_template_decl
)
1372 /* See if any of the functions are non-static members. */
1373 fns
= BASELINK_FUNCTIONS (expr
);
1374 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
1375 fns
= TREE_OPERAND (fns
, 0);
1376 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
1377 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1379 /* If so, the expression may be relative to the current
1381 if (fn
&& current_class_type
1382 && DERIVED_FROM_P (qualifying_class
, current_class_type
))
1383 expr
= (build_class_member_access_expr
1384 (maybe_dummy_object (qualifying_class
, NULL
),
1386 BASELINK_ACCESS_BINFO (expr
),
1387 /*preserve_reference=*/false));
1389 /* The expression is a qualified name whose address is not
1391 expr
= build_offset_ref (qualifying_class
, expr
, /*address_p=*/false);
1397 /* Begin a statement-expression. The value returned must be passed to
1398 finish_stmt_expr. */
1401 begin_stmt_expr (void)
1403 /* If we're outside a function, we won't have a statement-tree to
1404 work with. But, if we see a statement-expression we need to
1406 if (! cfun
&& !last_tree
)
1407 begin_stmt_tree (&scope_chain
->x_saved_tree
);
1409 last_expr_type
= NULL_TREE
;
1411 keep_next_level (true);
1416 /* Process the final expression of a statement expression. EXPR can be
1417 NULL, if the final expression is empty. Build up a TARGET_EXPR so
1418 that the result value can be safely returned to the enclosing
1422 finish_stmt_expr_expr (tree expr
)
1424 tree result
= NULL_TREE
;
1425 tree type
= void_type_node
;
1429 type
= TREE_TYPE (expr
);
1431 if (!processing_template_decl
&& !VOID_TYPE_P (TREE_TYPE (expr
)))
1433 if (TREE_CODE (type
) == ARRAY_TYPE
1434 || TREE_CODE (type
) == FUNCTION_TYPE
)
1435 expr
= decay_conversion (expr
);
1437 expr
= convert_from_reference (expr
);
1438 expr
= require_complete_type (expr
);
1440 /* Build a TARGET_EXPR for this aggregate. finish_stmt_expr
1441 will then pull it apart so the lifetime of the target is
1442 within the scope of the expression containing this statement
1444 if (TREE_CODE (expr
) == TARGET_EXPR
)
1446 else if (!IS_AGGR_TYPE (type
) || TYPE_HAS_TRIVIAL_INIT_REF (type
))
1447 expr
= build_target_expr_with_type (expr
, type
);
1450 /* Copy construct. */
1451 expr
= build_special_member_call
1452 (NULL_TREE
, complete_ctor_identifier
,
1453 build_tree_list (NULL_TREE
, expr
),
1454 TYPE_BINFO (type
), LOOKUP_NORMAL
);
1455 expr
= build_cplus_new (type
, expr
);
1456 my_friendly_assert (TREE_CODE (expr
) == TARGET_EXPR
, 20030729);
1460 if (expr
!= error_mark_node
)
1462 result
= build_stmt (EXPR_STMT
, expr
);
1469 /* Remember the last expression so that finish_stmt_expr can pull it
1471 last_expr_type
= result
? result
: void_type_node
;
1476 /* Finish a statement-expression. EXPR should be the value returned
1477 by the previous begin_stmt_expr. Returns an expression
1478 representing the statement-expression. */
1481 finish_stmt_expr (tree rtl_expr
, bool has_no_scope
)
1484 tree result_stmt
= last_expr_type
;
1487 if (!last_expr_type
)
1488 type
= void_type_node
;
1491 if (result_stmt
== void_type_node
)
1493 type
= void_type_node
;
1494 result_stmt
= NULL_TREE
;
1497 type
= TREE_TYPE (EXPR_STMT_EXPR (result_stmt
));
1500 result
= build_min (STMT_EXPR
, type
, last_tree
);
1501 TREE_SIDE_EFFECTS (result
) = 1;
1502 STMT_EXPR_NO_SCOPE (result
) = has_no_scope
;
1504 last_expr_type
= NULL_TREE
;
1506 /* Remove the compound statement from the tree structure; it is
1507 now saved in the STMT_EXPR. */
1508 last_tree
= rtl_expr
;
1509 TREE_CHAIN (last_tree
) = NULL_TREE
;
1511 /* If we created a statement-tree for this statement-expression,
1514 && TREE_CHAIN (scope_chain
->x_saved_tree
) == NULL_TREE
)
1515 finish_stmt_tree (&scope_chain
->x_saved_tree
);
1517 if (processing_template_decl
)
1520 if (!VOID_TYPE_P (type
))
1522 /* Pull out the TARGET_EXPR that is the final expression. Put
1523 the target's init_expr as the final expression and then put
1524 the statement expression itself as the target's init
1525 expr. Finally, return the target expression. */
1526 tree last_expr
= EXPR_STMT_EXPR (result_stmt
);
1528 my_friendly_assert (TREE_CODE (last_expr
) == TARGET_EXPR
, 20030729);
1529 EXPR_STMT_EXPR (result_stmt
) = TREE_OPERAND (last_expr
, 1);
1530 TREE_OPERAND (last_expr
, 1) = result
;
1536 /* Perform Koenig lookup. FN is the postfix-expression representing
1537 the function (or functions) to call; ARGS are the arguments to the
1538 call. Returns the functions to be considered by overload
1542 perform_koenig_lookup (tree fn
, tree args
)
1544 tree identifier
= NULL_TREE
;
1545 tree functions
= NULL_TREE
;
1547 /* Find the name of the overloaded function. */
1548 if (TREE_CODE (fn
) == IDENTIFIER_NODE
)
1550 else if (is_overloaded_fn (fn
))
1553 identifier
= DECL_NAME (get_first_fn (functions
));
1555 else if (DECL_P (fn
))
1558 identifier
= DECL_NAME (fn
);
1561 /* A call to a namespace-scope function using an unqualified name.
1563 Do Koenig lookup -- unless any of the arguments are
1565 if (!any_type_dependent_arguments_p (args
))
1567 fn
= lookup_arg_dependent (identifier
, functions
, args
);
1569 /* The unqualified name could not be resolved. */
1570 fn
= unqualified_fn_lookup_error (identifier
);
1578 /* Generate an expression for `FN (ARGS)'.
1580 If DISALLOW_VIRTUAL is true, the call to FN will be not generated
1581 as a virtual call, even if FN is virtual. (This flag is set when
1582 encountering an expression where the function name is explicitly
1583 qualified. For example a call to `X::f' never generates a virtual
1586 Returns code for the call. */
1589 finish_call_expr (tree fn
, tree args
, bool disallow_virtual
, bool koenig_p
)
1595 if (fn
== error_mark_node
|| args
== error_mark_node
)
1596 return error_mark_node
;
1598 /* ARGS should be a list of arguments. */
1599 my_friendly_assert (!args
|| TREE_CODE (args
) == TREE_LIST
,
1605 if (processing_template_decl
)
1607 if (type_dependent_expression_p (fn
)
1608 || any_type_dependent_arguments_p (args
))
1610 result
= build_nt (CALL_EXPR
, fn
, args
);
1611 KOENIG_LOOKUP_P (result
) = koenig_p
;
1614 if (!BASELINK_P (fn
)
1615 && TREE_CODE (fn
) != PSEUDO_DTOR_EXPR
1616 && TREE_TYPE (fn
) != unknown_type_node
)
1617 fn
= build_non_dependent_expr (fn
);
1618 args
= build_non_dependent_args (orig_args
);
1621 /* A reference to a member function will appear as an overloaded
1622 function (rather than a BASELINK) if an unqualified name was used
1624 if (!BASELINK_P (fn
) && is_overloaded_fn (fn
))
1628 if (TREE_CODE (f
) == TEMPLATE_ID_EXPR
)
1629 f
= TREE_OPERAND (f
, 0);
1630 f
= get_first_fn (f
);
1631 if (DECL_FUNCTION_MEMBER_P (f
))
1633 tree type
= currently_open_derived_class (DECL_CONTEXT (f
));
1634 fn
= build_baselink (TYPE_BINFO (type
),
1636 fn
, /*optype=*/NULL_TREE
);
1641 if (BASELINK_P (fn
))
1645 /* A call to a member function. From [over.call.func]:
1647 If the keyword this is in scope and refers to the class of
1648 that member function, or a derived class thereof, then the
1649 function call is transformed into a qualified function call
1650 using (*this) as the postfix-expression to the left of the
1651 . operator.... [Otherwise] a contrived object of type T
1652 becomes the implied object argument.
1654 This paragraph is unclear about this situation:
1656 struct A { void f(); };
1657 struct B : public A {};
1658 struct C : public A { void g() { B::f(); }};
1660 In particular, for `B::f', this paragraph does not make clear
1661 whether "the class of that member function" refers to `A' or
1662 to `B'. We believe it refers to `B'. */
1663 if (current_class_type
1664 && DERIVED_FROM_P (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn
)),
1666 && current_class_ref
)
1667 object
= maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn
)),
1671 tree representative_fn
;
1673 representative_fn
= BASELINK_FUNCTIONS (fn
);
1674 if (TREE_CODE (representative_fn
) == TEMPLATE_ID_EXPR
)
1675 representative_fn
= TREE_OPERAND (representative_fn
, 0);
1676 representative_fn
= get_first_fn (representative_fn
);
1677 object
= build_dummy_object (DECL_CONTEXT (representative_fn
));
1680 if (processing_template_decl
)
1682 if (type_dependent_expression_p (object
))
1683 return build_nt (CALL_EXPR
, orig_fn
, orig_args
);
1684 object
= build_non_dependent_expr (object
);
1687 result
= build_new_method_call (object
, fn
, args
, NULL_TREE
,
1689 ? LOOKUP_NONVIRTUAL
: 0));
1691 else if (is_overloaded_fn (fn
))
1692 /* A call to a namespace-scope function. */
1693 result
= build_new_function_call (fn
, args
);
1694 else if (TREE_CODE (fn
) == PSEUDO_DTOR_EXPR
)
1697 error ("arguments to destructor are not allowed");
1698 /* Mark the pseudo-destructor call as having side-effects so
1699 that we do not issue warnings about its use. */
1700 result
= build1 (NOP_EXPR
,
1702 TREE_OPERAND (fn
, 0));
1703 TREE_SIDE_EFFECTS (result
) = 1;
1705 else if (CLASS_TYPE_P (TREE_TYPE (fn
)))
1706 /* If the "function" is really an object of class type, it might
1707 have an overloaded `operator ()'. */
1708 result
= build_new_op (CALL_EXPR
, LOOKUP_NORMAL
, fn
, args
, NULL_TREE
);
1710 /* A call where the function is unknown. */
1711 result
= build_function_call (fn
, args
);
1713 if (processing_template_decl
)
1715 result
= build (CALL_EXPR
, TREE_TYPE (result
), orig_fn
, orig_args
);
1716 KOENIG_LOOKUP_P (result
) = koenig_p
;
1721 /* Finish a call to a postfix increment or decrement or EXPR. (Which
1722 is indicated by CODE, which should be POSTINCREMENT_EXPR or
1723 POSTDECREMENT_EXPR.) */
1726 finish_increment_expr (tree expr
, enum tree_code code
)
1728 return build_x_unary_op (code
, expr
);
1731 /* Finish a use of `this'. Returns an expression for `this'. */
1734 finish_this_expr (void)
1738 if (current_class_ptr
)
1740 result
= current_class_ptr
;
1742 else if (current_function_decl
1743 && DECL_STATIC_FUNCTION_P (current_function_decl
))
1745 error ("`this' is unavailable for static member functions");
1746 result
= error_mark_node
;
1750 if (current_function_decl
)
1751 error ("invalid use of `this' in non-member function");
1753 error ("invalid use of `this' at top level");
1754 result
= error_mark_node
;
1760 /* Finish a member function call using OBJECT and ARGS as arguments to
1761 FN. Returns an expression for the call. */
1764 finish_object_call_expr (tree fn
, tree object
, tree args
)
1766 if (DECL_DECLARES_TYPE_P (fn
))
1768 if (processing_template_decl
)
1769 /* This can happen on code like:
1772 template <class T> void f(T t) {
1776 We just grab the underlying IDENTIFIER. */
1777 fn
= DECL_NAME (fn
);
1780 error ("calling type `%T' like a method", fn
);
1781 return error_mark_node
;
1785 if (processing_template_decl
)
1786 return build_nt (CALL_EXPR
,
1787 build_nt (COMPONENT_REF
, object
, fn
),
1791 return build_method_call (object
, fn
, args
, NULL_TREE
, LOOKUP_NORMAL
);
1793 return build_new_method_call (object
, fn
, args
, NULL_TREE
, LOOKUP_NORMAL
);
1796 /* Finish a pseudo-destructor expression. If SCOPE is NULL, the
1797 expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
1798 the TYPE for the type given. If SCOPE is non-NULL, the expression
1799 was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
1802 finish_pseudo_destructor_expr (tree object
, tree scope
, tree destructor
)
1804 if (destructor
== error_mark_node
)
1805 return error_mark_node
;
1807 my_friendly_assert (TYPE_P (destructor
), 20010905);
1809 if (!processing_template_decl
)
1811 if (scope
== error_mark_node
)
1813 error ("invalid qualifying scope in pseudo-destructor name");
1814 return error_mark_node
;
1817 if (!same_type_p (TREE_TYPE (object
), destructor
))
1819 error ("`%E' is not of type `%T'", object
, destructor
);
1820 return error_mark_node
;
1824 return build (PSEUDO_DTOR_EXPR
, void_type_node
, object
, scope
, destructor
);
1827 /* Finish an expression of the form CODE EXPR. */
1830 finish_unary_op_expr (enum tree_code code
, tree expr
)
1832 tree result
= build_x_unary_op (code
, expr
);
1833 /* Inside a template, build_x_unary_op does not fold the
1834 expression. So check whether the result is folded before
1835 setting TREE_NEGATED_INT. */
1836 if (code
== NEGATE_EXPR
&& TREE_CODE (expr
) == INTEGER_CST
1837 && TREE_CODE (result
) == INTEGER_CST
1838 && !TREE_UNSIGNED (TREE_TYPE (result
))
1839 && INT_CST_LT (result
, integer_zero_node
))
1840 TREE_NEGATED_INT (result
) = 1;
1841 overflow_warning (result
);
1845 /* Finish a compound-literal expression. TYPE is the type to which
1846 the INITIALIZER_LIST is being cast. */
1849 finish_compound_literal (tree type
, tree initializer_list
)
1851 tree compound_literal
;
1853 /* Build a CONSTRUCTOR for the INITIALIZER_LIST. */
1854 compound_literal
= build_constructor (NULL_TREE
, initializer_list
);
1855 /* Mark it as a compound-literal. */
1856 TREE_HAS_CONSTRUCTOR (compound_literal
) = 1;
1857 if (processing_template_decl
)
1858 TREE_TYPE (compound_literal
) = type
;
1861 /* Check the initialization. */
1862 compound_literal
= digest_init (type
, compound_literal
, NULL
);
1863 /* If the TYPE was an array type with an unknown bound, then we can
1864 figure out the dimension now. For example, something like:
1868 implies that the array has two elements. */
1869 if (TREE_CODE (type
) == ARRAY_TYPE
&& !COMPLETE_TYPE_P (type
))
1870 complete_array_type (type
, compound_literal
, 1);
1873 return compound_literal
;
1876 /* Return the declaration for the function-name variable indicated by
1880 finish_fname (tree id
)
1884 decl
= fname_decl (C_RID_CODE (id
), id
);
1885 if (processing_template_decl
)
1886 decl
= DECL_NAME (decl
);
1890 /* Begin a function definition declared with DECL_SPECS, ATTRIBUTES,
1891 and DECLARATOR. Returns nonzero if the function-declaration is
1895 begin_function_definition (tree decl_specs
, tree attributes
, tree declarator
)
1897 if (!start_function (decl_specs
, declarator
, attributes
, SF_DEFAULT
))
1900 /* The things we're about to see are not directly qualified by any
1901 template headers we've seen thus far. */
1902 reset_specialization ();
1907 /* Finish a translation unit. */
1910 finish_translation_unit (void)
1912 /* In case there were missing closebraces,
1913 get us back to the global binding level. */
1915 while (current_namespace
!= global_namespace
)
1918 /* Do file scope __FUNCTION__ et al. */
1919 finish_fname_decls ();
1922 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
1923 Returns the parameter. */
1926 finish_template_type_parm (tree aggr
, tree identifier
)
1928 if (aggr
!= class_type_node
)
1930 pedwarn ("template type parameters must use the keyword `class' or `typename'");
1931 aggr
= class_type_node
;
1934 return build_tree_list (aggr
, identifier
);
1937 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
1938 Returns the parameter. */
1941 finish_template_template_parm (tree aggr
, tree identifier
)
1943 tree decl
= build_decl (TYPE_DECL
, identifier
, NULL_TREE
);
1944 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, identifier
, NULL_TREE
);
1945 DECL_TEMPLATE_PARMS (tmpl
) = current_template_parms
;
1946 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
1947 DECL_ARTIFICIAL (decl
) = 1;
1948 end_template_decl ();
1950 my_friendly_assert (DECL_TEMPLATE_PARMS (tmpl
), 20010110);
1952 return finish_template_type_parm (aggr
, tmpl
);
1955 /* ARGUMENT is the default-argument value for a template template
1956 parameter. If ARGUMENT is invalid, issue error messages and return
1957 the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
1960 check_template_template_default_arg (tree argument
)
1962 if (TREE_CODE (argument
) != TEMPLATE_DECL
1963 && TREE_CODE (argument
) != TEMPLATE_TEMPLATE_PARM
1964 && TREE_CODE (argument
) != TYPE_DECL
1965 && TREE_CODE (argument
) != UNBOUND_CLASS_TEMPLATE
)
1967 error ("invalid default template argument");
1968 return error_mark_node
;
1974 /* Finish a parameter list, indicated by PARMS. If ELLIPSIS is
1975 nonzero, the parameter list was terminated by a `...'. */
1978 finish_parmlist (tree parms
, int ellipsis
)
1982 /* We mark the PARMS as a parmlist so that declarator processing can
1983 disambiguate certain constructs. */
1984 TREE_PARMLIST (parms
) = 1;
1985 /* We do not append void_list_node here, but leave it to grokparms
1987 PARMLIST_ELLIPSIS_P (parms
) = ellipsis
;
1992 /* Begin a class definition, as indicated by T. */
1995 begin_class_definition (tree t
)
1997 if (t
== error_mark_node
)
1998 return error_mark_node
;
2000 if (processing_template_parmlist
)
2002 error ("definition of `%#T' inside template parameter list", t
);
2003 return error_mark_node
;
2005 /* A non-implicit typename comes from code like:
2007 template <typename T> struct A {
2008 template <typename U> struct A<T>::B ...
2010 This is erroneous. */
2011 else if (TREE_CODE (t
) == TYPENAME_TYPE
)
2013 error ("invalid definition of qualified type `%T'", t
);
2014 t
= error_mark_node
;
2017 if (t
== error_mark_node
|| ! IS_AGGR_TYPE (t
))
2019 t
= make_aggr_type (RECORD_TYPE
);
2020 pushtag (make_anon_name (), t
, 0);
2023 /* If this type was already complete, and we see another definition,
2025 if (COMPLETE_TYPE_P (t
))
2027 error ("redefinition of `%#T'", t
);
2028 cp_error_at ("previous definition of `%#T'", t
);
2029 return error_mark_node
;
2032 /* Update the location of the decl. */
2033 DECL_SOURCE_LOCATION (TYPE_NAME (t
)) = input_location
;
2035 if (TYPE_BEING_DEFINED (t
))
2037 t
= make_aggr_type (TREE_CODE (t
));
2038 pushtag (TYPE_IDENTIFIER (t
), t
, 0);
2040 maybe_process_partial_specialization (t
);
2042 TYPE_BEING_DEFINED (t
) = 1;
2043 TYPE_PACKED (t
) = flag_pack_struct
;
2044 /* Reset the interface data, at the earliest possible
2045 moment, as it might have been set via a class foo;
2047 if (! TYPE_ANONYMOUS_P (t
))
2049 CLASSTYPE_INTERFACE_ONLY (t
) = interface_only
;
2050 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2051 (t
, interface_unknown
);
2053 reset_specialization();
2055 /* Make a declaration for this class in its own scope. */
2056 build_self_reference ();
2061 /* Finish the member declaration given by DECL. */
2064 finish_member_declaration (tree decl
)
2066 if (decl
== error_mark_node
|| decl
== NULL_TREE
)
2069 if (decl
== void_type_node
)
2070 /* The COMPONENT was a friend, not a member, and so there's
2071 nothing for us to do. */
2074 /* We should see only one DECL at a time. */
2075 my_friendly_assert (TREE_CHAIN (decl
) == NULL_TREE
, 0);
2077 /* Set up access control for DECL. */
2079 = (current_access_specifier
== access_private_node
);
2080 TREE_PROTECTED (decl
)
2081 = (current_access_specifier
== access_protected_node
);
2082 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2084 TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl
)) = TREE_PRIVATE (decl
);
2085 TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl
)) = TREE_PROTECTED (decl
);
2088 /* Mark the DECL as a member of the current class. */
2089 DECL_CONTEXT (decl
) = current_class_type
;
2093 A C language linkage is ignored for the names of class members
2094 and the member function type of class member functions. */
2095 if (DECL_LANG_SPECIFIC (decl
) && DECL_LANGUAGE (decl
) == lang_c
)
2096 SET_DECL_LANGUAGE (decl
, lang_cplusplus
);
2098 /* Put functions on the TYPE_METHODS list and everything else on the
2099 TYPE_FIELDS list. Note that these are built up in reverse order.
2100 We reverse them (to obtain declaration order) in finish_struct. */
2101 if (TREE_CODE (decl
) == FUNCTION_DECL
2102 || DECL_FUNCTION_TEMPLATE_P (decl
))
2104 /* We also need to add this function to the
2105 CLASSTYPE_METHOD_VEC. */
2106 add_method (current_class_type
, decl
, /*error_p=*/0);
2108 TREE_CHAIN (decl
) = TYPE_METHODS (current_class_type
);
2109 TYPE_METHODS (current_class_type
) = decl
;
2111 maybe_add_class_template_decl_list (current_class_type
, decl
,
2114 /* Enter the DECL into the scope of the class. */
2115 else if ((TREE_CODE (decl
) == USING_DECL
&& TREE_TYPE (decl
))
2116 || pushdecl_class_level (decl
))
2118 /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
2119 go at the beginning. The reason is that lookup_field_1
2120 searches the list in order, and we want a field name to
2121 override a type name so that the "struct stat hack" will
2122 work. In particular:
2124 struct S { enum E { }; int E } s;
2127 is valid. In addition, the FIELD_DECLs must be maintained in
2128 declaration order so that class layout works as expected.
2129 However, we don't need that order until class layout, so we
2130 save a little time by putting FIELD_DECLs on in reverse order
2131 here, and then reversing them in finish_struct_1. (We could
2132 also keep a pointer to the correct insertion points in the
2135 if (TREE_CODE (decl
) == TYPE_DECL
)
2136 TYPE_FIELDS (current_class_type
)
2137 = chainon (TYPE_FIELDS (current_class_type
), decl
);
2140 TREE_CHAIN (decl
) = TYPE_FIELDS (current_class_type
);
2141 TYPE_FIELDS (current_class_type
) = decl
;
2144 maybe_add_class_template_decl_list (current_class_type
, decl
,
2149 /* Finish processing the declaration of a member class template
2150 TYPES whose template parameters are given by PARMS. */
2153 finish_member_class_template (tree types
)
2157 /* If there are declared, but undefined, partial specializations
2158 mixed in with the typespecs they will not yet have passed through
2159 maybe_process_partial_specialization, so we do that here. */
2160 for (t
= types
; t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
2161 if (IS_AGGR_TYPE_CODE (TREE_CODE (TREE_VALUE (t
))))
2162 maybe_process_partial_specialization (TREE_VALUE (t
));
2164 grok_x_components (types
);
2165 if (TYPE_CONTEXT (TREE_VALUE (types
)) != current_class_type
)
2166 /* The component was in fact a friend declaration. We avoid
2167 finish_member_template_decl performing certain checks by
2171 finish_member_template_decl (types
);
2173 /* As with other component type declarations, we do
2174 not store the new DECL on the list of
2179 /* Finish processing a complete template declaration. The PARMS are
2180 the template parameters. */
2183 finish_template_decl (tree parms
)
2186 end_template_decl ();
2188 end_specialization ();
2191 /* Finish processing a template-id (which names a type) of the form
2192 NAME < ARGS >. Return the TYPE_DECL for the type named by the
2193 template-id. If ENTERING_SCOPE is nonzero we are about to enter
2194 the scope of template-id indicated. */
2197 finish_template_type (tree name
, tree args
, int entering_scope
)
2201 decl
= lookup_template_class (name
, args
,
2202 NULL_TREE
, NULL_TREE
, entering_scope
,
2203 tf_error
| tf_warning
| tf_user
);
2204 if (decl
!= error_mark_node
)
2205 decl
= TYPE_STUB_DECL (decl
);
2210 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
2211 Return a TREE_LIST containing the ACCESS_SPECIFIER and the
2212 BASE_CLASS, or NULL_TREE if an error occurred. The
2213 ACCESS_SPECIFIER is one of
2214 access_{default,public,protected_private}[_virtual]_node.*/
2217 finish_base_specifier (tree base
, tree access
, bool virtual_p
)
2221 if (base
== error_mark_node
)
2223 error ("invalid base-class specification");
2226 else if (! is_aggr_type (base
, 1))
2230 if (cp_type_quals (base
) != 0)
2232 error ("base class `%T' has cv qualifiers", base
);
2233 base
= TYPE_MAIN_VARIANT (base
);
2235 result
= build_tree_list (access
, base
);
2236 TREE_VIA_VIRTUAL (result
) = virtual_p
;
2242 /* Called when multiple declarators are processed. If that is not
2243 permitted in this context, an error is issued. */
2246 check_multiple_declarators (void)
2250 In a template-declaration, explicit specialization, or explicit
2251 instantiation the init-declarator-list in the declaration shall
2252 contain at most one declarator.
2254 We don't just use PROCESSING_TEMPLATE_DECL for the first
2255 condition since that would disallow the perfectly valid code,
2256 like `template <class T> struct S { int i, j; };'. */
2257 if (at_function_scope_p ())
2258 /* It's OK to write `template <class T> void f() { int i, j;}'. */
2261 if (PROCESSING_REAL_TEMPLATE_DECL_P ()
2262 || processing_explicit_instantiation
2263 || processing_specialization
)
2264 error ("multiple declarators in template declaration");
2267 /* Issue a diagnostic that NAME cannot be found in SCOPE. */
2270 qualified_name_lookup_error (tree scope
, tree name
)
2274 if (!COMPLETE_TYPE_P (scope
))
2275 error ("incomplete type `%T' used in nested name specifier", scope
);
2277 error ("`%D' is not a member of `%T'", name
, scope
);
2279 else if (scope
!= global_namespace
)
2280 error ("`%D' is not a member of `%D'", name
, scope
);
2282 error ("`::%D' has not been declared", name
);
2285 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
2286 id-expression. (See cp_parser_id_expression for details.) SCOPE,
2287 if non-NULL, is the type or namespace used to explicitly qualify
2288 ID_EXPRESSION. DECL is the entity to which that name has been
2291 *CONSTANT_EXPRESSION_P is true if we are presently parsing a
2292 constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
2293 be set to true if this expression isn't permitted in a
2294 constant-expression, but it is otherwise not set by this function.
2295 *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
2296 constant-expression, but a non-constant expression is also
2299 If an error occurs, and it is the kind of error that might cause
2300 the parser to abort a tentative parse, *ERROR_MSG is filled in. It
2301 is the caller's responsibility to issue the message. *ERROR_MSG
2302 will be a string with static storage duration, so the caller need
2305 Return an expression for the entity, after issuing appropriate
2306 diagnostics. This function is also responsible for transforming a
2307 reference to a non-static member into a COMPONENT_REF that makes
2308 the use of "this" explicit.
2310 Upon return, *IDK will be filled in appropriately. */
2313 finish_id_expression (tree id_expression
,
2317 tree
*qualifying_class
,
2318 bool constant_expression_p
,
2319 bool allow_non_constant_expression_p
,
2320 bool *non_constant_expression_p
,
2321 const char **error_msg
)
2323 /* Initialize the output parameters. */
2324 *idk
= CP_ID_KIND_NONE
;
2327 if (id_expression
== error_mark_node
)
2328 return error_mark_node
;
2329 /* If we have a template-id, then no further lookup is
2330 required. If the template-id was for a template-class, we
2331 will sometimes have a TYPE_DECL at this point. */
2332 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
2333 || TREE_CODE (decl
) == TYPE_DECL
)
2335 /* Look up the name. */
2338 if (decl
== error_mark_node
)
2340 /* Name lookup failed. */
2341 if (scope
&& (!TYPE_P (scope
) || !dependent_type_p (scope
)))
2343 /* Qualified name lookup failed, and the qualifying name
2344 was not a dependent type. That is always an
2346 qualified_name_lookup_error (scope
, id_expression
);
2347 return error_mark_node
;
2351 /* It may be resolved via Koenig lookup. */
2352 *idk
= CP_ID_KIND_UNQUALIFIED
;
2353 return id_expression
;
2356 /* If DECL is a variable that would be out of scope under
2357 ANSI/ISO rules, but in scope in the ARM, name lookup
2358 will succeed. Issue a diagnostic here. */
2360 decl
= check_for_out_of_scope_variable (decl
);
2362 /* Remember that the name was used in the definition of
2363 the current class so that we can check later to see if
2364 the meaning would have been different after the class
2365 was entirely defined. */
2366 if (!scope
&& decl
!= error_mark_node
)
2367 maybe_note_name_used_in_class (id_expression
, decl
);
2370 /* If we didn't find anything, or what we found was a type,
2371 then this wasn't really an id-expression. */
2372 if (TREE_CODE (decl
) == TEMPLATE_DECL
2373 && !DECL_FUNCTION_TEMPLATE_P (decl
))
2375 *error_msg
= "missing template arguments";
2376 return error_mark_node
;
2378 else if (TREE_CODE (decl
) == TYPE_DECL
2379 || TREE_CODE (decl
) == NAMESPACE_DECL
)
2381 *error_msg
= "expected primary-expression";
2382 return error_mark_node
;
2385 /* If the name resolved to a template parameter, there is no
2386 need to look it up again later. Similarly, we resolve
2387 enumeration constants to their underlying values. */
2388 if (TREE_CODE (decl
) == CONST_DECL
)
2390 *idk
= CP_ID_KIND_NONE
;
2391 if (DECL_TEMPLATE_PARM_P (decl
) || !processing_template_decl
)
2392 return DECL_INITIAL (decl
);
2399 /* If the declaration was explicitly qualified indicate
2400 that. The semantics of `A::f(3)' are different than
2401 `f(3)' if `f' is virtual. */
2403 ? CP_ID_KIND_QUALIFIED
2404 : (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
2405 ? CP_ID_KIND_TEMPLATE_ID
2406 : CP_ID_KIND_UNQUALIFIED
));
2411 An id-expression is type-dependent if it contains an
2412 identifier that was declared with a dependent type.
2414 The standard is not very specific about an id-expression that
2415 names a set of overloaded functions. What if some of them
2416 have dependent types and some of them do not? Presumably,
2417 such a name should be treated as a dependent name. */
2418 /* Assume the name is not dependent. */
2419 dependent_p
= false;
2420 if (!processing_template_decl
)
2421 /* No names are dependent outside a template. */
2423 /* A template-id where the name of the template was not resolved
2424 is definitely dependent. */
2425 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
2426 && (TREE_CODE (TREE_OPERAND (decl
, 0))
2427 == IDENTIFIER_NODE
))
2429 /* For anything except an overloaded function, just check its
2431 else if (!is_overloaded_fn (decl
))
2433 = dependent_type_p (TREE_TYPE (decl
));
2434 /* For a set of overloaded functions, check each of the
2440 if (BASELINK_P (fns
))
2441 fns
= BASELINK_FUNCTIONS (fns
);
2443 /* For a template-id, check to see if the template
2444 arguments are dependent. */
2445 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
2447 tree args
= TREE_OPERAND (fns
, 1);
2448 dependent_p
= any_dependent_template_arguments_p (args
);
2449 /* The functions are those referred to by the
2451 fns
= TREE_OPERAND (fns
, 0);
2454 /* If there are no dependent template arguments, go through
2455 the overloaded functions. */
2456 while (fns
&& !dependent_p
)
2458 tree fn
= OVL_CURRENT (fns
);
2460 /* Member functions of dependent classes are
2462 if (TREE_CODE (fn
) == FUNCTION_DECL
2463 && type_dependent_expression_p (fn
))
2465 else if (TREE_CODE (fn
) == TEMPLATE_DECL
2466 && dependent_template_p (fn
))
2469 fns
= OVL_NEXT (fns
);
2473 /* If the name was dependent on a template parameter, we will
2474 resolve the name at instantiation time. */
2477 /* Create a SCOPE_REF for qualified names, if the scope is
2482 *qualifying_class
= scope
;
2483 /* Since this name was dependent, the expression isn't
2484 constant -- yet. No error is issued because it might
2485 be constant when things are instantiated. */
2486 if (constant_expression_p
)
2487 *non_constant_expression_p
= true;
2488 if (TYPE_P (scope
) && dependent_type_p (scope
))
2489 return build_nt (SCOPE_REF
, scope
, id_expression
);
2490 else if (TYPE_P (scope
) && DECL_P (decl
))
2491 return build (SCOPE_REF
, TREE_TYPE (decl
), scope
,
2496 /* A TEMPLATE_ID already contains all the information we
2498 if (TREE_CODE (id_expression
) == TEMPLATE_ID_EXPR
)
2499 return id_expression
;
2500 /* Since this name was dependent, the expression isn't
2501 constant -- yet. No error is issued because it might be
2502 constant when things are instantiated. */
2503 if (constant_expression_p
)
2504 *non_constant_expression_p
= true;
2505 *idk
= CP_ID_KIND_UNQUALIFIED_DEPENDENT
;
2506 return id_expression
;
2509 /* Only certain kinds of names are allowed in constant
2510 expression. Enumerators have already been handled above. */
2511 if (constant_expression_p
)
2513 /* Non-type template parameters of integral or enumeration
2515 if (TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
2516 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (decl
)))
2518 /* Const variables or static data members of integral or
2519 enumeration types initialized with constant expressions
2521 else if (TREE_CODE (decl
) == VAR_DECL
2522 && CP_TYPE_CONST_P (TREE_TYPE (decl
))
2523 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (decl
))
2524 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
))
2528 if (!allow_non_constant_expression_p
)
2530 error ("`%D' cannot appear in a constant-expression", decl
);
2531 return error_mark_node
;
2533 *non_constant_expression_p
= true;
2537 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2539 error ("use of namespace `%D' as expression", decl
);
2540 return error_mark_node
;
2542 else if (DECL_CLASS_TEMPLATE_P (decl
))
2544 error ("use of class template `%T' as expression", decl
);
2545 return error_mark_node
;
2547 else if (TREE_CODE (decl
) == TREE_LIST
)
2549 /* Ambiguous reference to base members. */
2550 error ("request for member `%D' is ambiguous in "
2551 "multiple inheritance lattice", id_expression
);
2552 print_candidates (decl
);
2553 return error_mark_node
;
2556 /* Mark variable-like entities as used. Functions are similarly
2557 marked either below or after overload resolution. */
2558 if (TREE_CODE (decl
) == VAR_DECL
2559 || TREE_CODE (decl
) == PARM_DECL
2560 || TREE_CODE (decl
) == RESULT_DECL
)
2565 decl
= (adjust_result_of_qualified_name_lookup
2566 (decl
, scope
, current_class_type
));
2568 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2571 if (TREE_CODE (decl
) == FIELD_DECL
|| BASELINK_P (decl
))
2572 *qualifying_class
= scope
;
2573 else if (!processing_template_decl
)
2574 decl
= convert_from_reference (decl
);
2575 else if (TYPE_P (scope
))
2576 decl
= build (SCOPE_REF
, TREE_TYPE (decl
), scope
, decl
);
2578 else if (TREE_CODE (decl
) == FIELD_DECL
)
2579 decl
= finish_non_static_data_member (decl
, current_class_ref
,
2580 /*qualifying_scope=*/NULL_TREE
);
2581 else if (is_overloaded_fn (decl
))
2583 tree first_fn
= OVL_CURRENT (decl
);
2585 if (TREE_CODE (first_fn
) == TEMPLATE_DECL
)
2586 first_fn
= DECL_TEMPLATE_RESULT (first_fn
);
2588 if (!really_overloaded_fn (decl
))
2589 mark_used (first_fn
);
2591 if (TREE_CODE (first_fn
) == FUNCTION_DECL
2592 && DECL_FUNCTION_MEMBER_P (first_fn
))
2594 /* A set of member functions. */
2595 decl
= maybe_dummy_object (DECL_CONTEXT (first_fn
), 0);
2596 return finish_class_member_access_expr (decl
, id_expression
);
2601 if (TREE_CODE (decl
) == VAR_DECL
2602 || TREE_CODE (decl
) == PARM_DECL
2603 || TREE_CODE (decl
) == RESULT_DECL
)
2605 tree context
= decl_function_context (decl
);
2607 if (context
!= NULL_TREE
&& context
!= current_function_decl
2608 && ! TREE_STATIC (decl
))
2610 error ("use of %s from containing function",
2611 (TREE_CODE (decl
) == VAR_DECL
2612 ? "`auto' variable" : "parameter"));
2613 cp_error_at (" `%#D' declared here", decl
);
2614 return error_mark_node
;
2618 if (DECL_P (decl
) && DECL_NONLOCAL (decl
)
2619 && DECL_CLASS_SCOPE_P (decl
)
2620 && DECL_CONTEXT (decl
) != current_class_type
)
2624 path
= currently_open_derived_class (DECL_CONTEXT (decl
));
2625 perform_or_defer_access_check (TYPE_BINFO (path
), decl
);
2628 if (! processing_template_decl
)
2629 decl
= convert_from_reference (decl
);
2632 /* Resolve references to variables of anonymous unions
2633 into COMPONENT_REFs. */
2634 if (TREE_CODE (decl
) == ALIAS_DECL
)
2635 decl
= DECL_INITIAL (decl
);
2638 if (TREE_DEPRECATED (decl
))
2639 warn_deprecated_use (decl
);
2644 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
2645 use as a type-specifier. */
2648 finish_typeof (tree expr
)
2652 if (type_dependent_expression_p (expr
))
2654 type
= make_aggr_type (TYPEOF_TYPE
);
2655 TYPE_FIELDS (type
) = expr
;
2660 type
= TREE_TYPE (expr
);
2662 if (!type
|| type
== unknown_type_node
)
2664 error ("type of `%E' is unknown", expr
);
2665 return error_mark_node
;
2671 /* Generate RTL for the statement T, and its substatements, and any
2672 other statements at its nesting level. */
2675 cp_expand_stmt (tree t
)
2677 switch (TREE_CODE (t
))
2680 genrtl_try_block (t
);
2684 genrtl_eh_spec_block (t
);
2700 /* Called from expand_body via walk_tree. Replace all AGGR_INIT_EXPRs
2701 will equivalent CALL_EXPRs. */
2704 simplify_aggr_init_exprs_r (tree
* tp
,
2706 void* data ATTRIBUTE_UNUSED
)
2708 /* We don't need to walk into types; there's nothing in a type that
2709 needs simplification. (And, furthermore, there are places we
2710 actively don't want to go. For example, we don't want to wander
2711 into the default arguments for a FUNCTION_DECL that appears in a
2718 /* Only AGGR_INIT_EXPRs are interesting. */
2719 else if (TREE_CODE (*tp
) != AGGR_INIT_EXPR
)
2722 simplify_aggr_init_expr (tp
);
2724 /* Keep iterating. */
2728 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
2729 function is broken out from the above for the benefit of the tree-ssa
2733 simplify_aggr_init_expr (tree
*tp
)
2735 tree aggr_init_expr
= *tp
;
2737 /* Form an appropriate CALL_EXPR. */
2738 tree fn
= TREE_OPERAND (aggr_init_expr
, 0);
2739 tree args
= TREE_OPERAND (aggr_init_expr
, 1);
2740 tree slot
= TREE_OPERAND (aggr_init_expr
, 2);
2741 tree type
= TREE_TYPE (aggr_init_expr
);
2744 enum style_t
{ ctor
, arg
, pcc
} style
;
2746 if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr
))
2748 #ifdef PCC_STATIC_STRUCT_RETURN
2752 else if (TREE_ADDRESSABLE (type
))
2755 /* We shouldn't build an AGGR_INIT_EXPR if we don't need any special
2756 handling. See build_cplus_new. */
2759 if (style
== ctor
|| style
== arg
)
2761 /* Pass the address of the slot. If this is a constructor, we
2762 replace the first argument; otherwise, we tack on a new one. */
2766 args
= TREE_CHAIN (args
);
2768 cxx_mark_addressable (slot
);
2769 addr
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (slot
)), slot
);
2772 /* The return type might have different cv-quals from the slot. */
2773 tree fntype
= TREE_TYPE (TREE_TYPE (fn
));
2774 #ifdef ENABLE_CHECKING
2775 if (TREE_CODE (fntype
) != FUNCTION_TYPE
2776 && TREE_CODE (fntype
) != METHOD_TYPE
)
2779 addr
= convert (build_pointer_type (TREE_TYPE (fntype
)), addr
);
2782 args
= tree_cons (NULL_TREE
, addr
, args
);
2785 call_expr
= build (CALL_EXPR
,
2786 TREE_TYPE (TREE_TYPE (TREE_TYPE (fn
))),
2787 fn
, args
, NULL_TREE
);
2790 /* Tell the backend that we've added our return slot to the argument
2792 CALL_EXPR_HAS_RETURN_SLOT_ADDR (call_expr
) = 1;
2793 else if (style
== pcc
)
2795 /* If we're using the non-reentrant PCC calling convention, then we
2796 need to copy the returned value out of the static buffer into the
2798 push_deferring_access_checks (dk_no_check
);
2799 call_expr
= build_aggr_init (slot
, call_expr
,
2800 DIRECT_BIND
| LOOKUP_ONLYCONVERTING
);
2801 pop_deferring_access_checks ();
2804 /* We want to use the value of the initialized location as the
2806 call_expr
= build (COMPOUND_EXPR
, type
,
2809 /* Replace the AGGR_INIT_EXPR with the CALL_EXPR. */
2810 TREE_CHAIN (call_expr
) = TREE_CHAIN (aggr_init_expr
);
2814 /* Emit all thunks to FN that should be emitted when FN is emitted. */
2817 emit_associated_thunks (tree fn
)
2819 /* When we use vcall offsets, we emit thunks with the virtual
2820 functions to which they thunk. The whole point of vcall offsets
2821 is so that you can know statically the entire set of thunks that
2822 will ever be needed for a given virtual function, thereby
2823 enabling you to output all the thunks with the function itself. */
2824 if (DECL_VIRTUAL_P (fn
))
2828 for (thunk
= DECL_THUNKS (fn
); thunk
; thunk
= TREE_CHAIN (thunk
))
2830 if (!THUNK_ALIAS_P (thunk
))
2832 use_thunk (thunk
, /*emit_p=*/1);
2833 if (DECL_RESULT_THUNK_P (thunk
))
2837 for (probe
= DECL_THUNKS (thunk
);
2838 probe
; probe
= TREE_CHAIN (probe
))
2839 use_thunk (probe
, /*emit_p=*/1);
2843 my_friendly_assert (!DECL_THUNKS (thunk
), 20031023);
2848 /* Generate RTL for FN. */
2851 expand_body (tree fn
)
2853 tree saved_function
;
2855 /* Compute the appropriate object-file linkage for inline
2857 if (DECL_DECLARED_INLINE_P (fn
))
2858 import_export_decl (fn
);
2860 /* If FN is external, then there's no point in generating RTL for
2861 it. This situation can arise with an inline function under
2862 `-fexternal-templates'; we instantiate the function, even though
2863 we're not planning on emitting it, in case we get a chance to
2865 if (DECL_EXTERNAL (fn
))
2868 /* ??? When is this needed? */
2869 saved_function
= current_function_decl
;
2871 timevar_push (TV_INTEGRATION
);
2872 optimize_function (fn
);
2873 timevar_pop (TV_INTEGRATION
);
2875 tree_rest_of_compilation (fn
, function_depth
> 1);
2877 current_function_decl
= saved_function
;
2879 extract_interface_info ();
2881 /* Emit any thunks that should be emitted at the same time as FN. */
2882 emit_associated_thunks (fn
);
2884 /* If this function is marked with the constructor attribute, add it
2885 to the list of functions to be called along with constructors
2886 from static duration objects. */
2887 if (DECL_STATIC_CONSTRUCTOR (fn
))
2888 static_ctors
= tree_cons (NULL_TREE
, fn
, static_ctors
);
2890 /* If this function is marked with the destructor attribute, add it
2891 to the list of functions to be called along with destructors from
2892 static duration objects. */
2893 if (DECL_STATIC_DESTRUCTOR (fn
))
2894 static_dtors
= tree_cons (NULL_TREE
, fn
, static_dtors
);
2896 if (DECL_CLONED_FUNCTION_P (fn
))
2898 /* If this is a clone, go through the other clones now and mark
2899 their parameters used. We have to do that here, as we don't
2900 know whether any particular clone will be expanded, and
2901 therefore cannot pick one arbitrarily. */
2904 for (probe
= TREE_CHAIN (DECL_CLONED_FUNCTION (fn
));
2905 probe
&& DECL_CLONED_FUNCTION_P (probe
);
2906 probe
= TREE_CHAIN (probe
))
2910 for (parms
= DECL_ARGUMENTS (probe
);
2911 parms
; parms
= TREE_CHAIN (parms
))
2912 TREE_USED (parms
) = 1;
2917 /* Generate RTL for FN. */
2920 expand_or_defer_fn (tree fn
)
2922 /* When the parser calls us after finishing the body of a template
2923 function, we don't really want to expand the body. When we're
2924 processing an in-class definition of an inline function,
2925 PROCESSING_TEMPLATE_DECL will no longer be set here, so we have
2926 to look at the function itself. */
2927 if (processing_template_decl
2928 || (DECL_LANG_SPECIFIC (fn
)
2929 && DECL_TEMPLATE_INFO (fn
)
2930 && uses_template_parms (DECL_TI_ARGS (fn
))))
2932 /* Normally, collection only occurs in rest_of_compilation. So,
2933 if we don't collect here, we never collect junk generated
2934 during the processing of templates until we hit a
2935 non-template function. */
2940 /* Replace AGGR_INIT_EXPRs with appropriate CALL_EXPRs. */
2941 walk_tree_without_duplicates (&DECL_SAVED_TREE (fn
),
2942 simplify_aggr_init_exprs_r
,
2945 /* If this is a constructor or destructor body, we have to clone
2947 if (maybe_clone_body (fn
))
2949 /* We don't want to process FN again, so pretend we've written
2950 it out, even though we haven't. */
2951 TREE_ASM_WRITTEN (fn
) = 1;
2955 /* There's no reason to do any of the work here if we're only doing
2956 semantic analysis; this code just generates RTL. */
2957 if (flag_syntax_only
)
2960 /* Compute the appropriate object-file linkage for inline functions. */
2961 if (DECL_DECLARED_INLINE_P (fn
))
2962 import_export_decl (fn
);
2966 /* Expand or defer, at the whim of the compilation unit manager. */
2967 cgraph_finalize_function (fn
, function_depth
> 1);
2972 /* Helper function for walk_tree, used by finish_function to override all
2973 the RETURN_STMTs and pertinent CLEANUP_STMTs for the named return
2974 value optimization. */
2977 nullify_returns_r (tree
* tp
, int* walk_subtrees
, void* data
)
2979 tree nrv
= (tree
) data
;
2981 /* No need to walk into types. There wouldn't be any need to walk into
2982 non-statements, except that we have to consider STMT_EXPRs. */
2985 else if (TREE_CODE (*tp
) == RETURN_STMT
)
2986 RETURN_STMT_EXPR (*tp
) = NULL_TREE
;
2987 else if (TREE_CODE (*tp
) == CLEANUP_STMT
2988 && CLEANUP_DECL (*tp
) == nrv
)
2989 CLEANUP_EH_ONLY (*tp
) = 1;
2991 /* Keep iterating. */
2995 /* Start generating the RTL for FN. */
2998 cxx_expand_function_start (void)
3000 /* Give our named return value the same RTL as our RESULT_DECL. */
3001 if (current_function_return_value
)
3002 COPY_DECL_RTL (DECL_RESULT (cfun
->decl
), current_function_return_value
);
3005 /* Perform initialization related to this module. */
3008 init_cp_semantics (void)
3010 lang_expand_stmt
= cp_expand_stmt
;
3013 #include "gt-cp-semantics.h"