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, 2003, 2004, 2005, 2006, 2007
7 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 3, 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 COPYING3. If not see
25 <http://www.gnu.org/licenses/>. */
29 #include "coretypes.h"
34 #include "tree-inline.h"
35 #include "tree-mudflap.h"
44 #include "diagnostic.h"
46 #include "tree-iterator.h"
50 /* There routines provide a modular interface to perform many parsing
51 operations. They may therefore be used during actual parsing, or
52 during template instantiation, which may be regarded as a
53 degenerate form of parsing. */
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 tree finalize_nrv_r (tree *, int *, void *);
61 /* Deferred Access Checking Overview
62 ---------------------------------
64 Most C++ expressions and declarations require access checking
65 to be performed during parsing. However, in several cases,
66 this has to be treated differently.
68 For member declarations, access checking has to be deferred
69 until more information about the declaration is known. For
81 When we are parsing the function return type `A::X', we don't
82 really know if this is allowed until we parse the function name.
84 Furthermore, some contexts require that access checking is
85 never performed at all. These include class heads, and template
88 Typical use of access checking functions is described here:
90 1. When we enter a context that requires certain access checking
91 mode, the function `push_deferring_access_checks' is called with
92 DEFERRING argument specifying the desired mode. Access checking
93 may be performed immediately (dk_no_deferred), deferred
94 (dk_deferred), or not performed (dk_no_check).
96 2. When a declaration such as a type, or a variable, is encountered,
97 the function `perform_or_defer_access_check' is called. It
98 maintains a VEC of all deferred checks.
100 3. The global `current_class_type' or `current_function_decl' is then
101 setup by the parser. `enforce_access' relies on these information
104 4. Upon exiting the context mentioned in step 1,
105 `perform_deferred_access_checks' is called to check all declaration
106 stored in the VEC. `pop_deferring_access_checks' is then
107 called to restore the previous access checking mode.
109 In case of parsing error, we simply call `pop_deferring_access_checks'
110 without `perform_deferred_access_checks'. */
112 typedef struct deferred_access GTY(())
114 /* A VEC representing name-lookups for which we have deferred
115 checking access controls. We cannot check the accessibility of
116 names used in a decl-specifier-seq until we know what is being
117 declared because code like:
124 A::B* A::f() { return 0; }
126 is valid, even though `A::B' is not generally accessible. */
127 VEC (deferred_access_check,gc)* GTY(()) deferred_access_checks;
129 /* The current mode of access checks. */
130 enum deferring_kind deferring_access_checks_kind;
133 DEF_VEC_O (deferred_access);
134 DEF_VEC_ALLOC_O (deferred_access,gc);
136 /* Data for deferred access checking. */
137 static GTY(()) VEC(deferred_access,gc) *deferred_access_stack;
138 static GTY(()) unsigned deferred_access_no_check;
140 /* Save the current deferred access states and start deferred
141 access checking iff DEFER_P is true. */
144 push_deferring_access_checks (deferring_kind deferring)
146 /* For context like template instantiation, access checking
147 disabling applies to all nested context. */
148 if (deferred_access_no_check || deferring == dk_no_check)
149 deferred_access_no_check++;
152 deferred_access *ptr;
154 ptr = VEC_safe_push (deferred_access, gc, deferred_access_stack, NULL);
155 ptr->deferred_access_checks = NULL;
156 ptr->deferring_access_checks_kind = deferring;
160 /* Resume deferring access checks again after we stopped doing
164 resume_deferring_access_checks (void)
166 if (!deferred_access_no_check)
167 VEC_last (deferred_access, deferred_access_stack)
168 ->deferring_access_checks_kind = dk_deferred;
171 /* Stop deferring access checks. */
174 stop_deferring_access_checks (void)
176 if (!deferred_access_no_check)
177 VEC_last (deferred_access, deferred_access_stack)
178 ->deferring_access_checks_kind = dk_no_deferred;
181 /* Discard the current deferred access checks and restore the
185 pop_deferring_access_checks (void)
187 if (deferred_access_no_check)
188 deferred_access_no_check--;
190 VEC_pop (deferred_access, deferred_access_stack);
193 /* Returns a TREE_LIST representing the deferred checks.
194 The TREE_PURPOSE of each node is the type through which the
195 access occurred; the TREE_VALUE is the declaration named.
198 VEC (deferred_access_check,gc)*
199 get_deferred_access_checks (void)
201 if (deferred_access_no_check)
204 return (VEC_last (deferred_access, deferred_access_stack)
205 ->deferred_access_checks);
208 /* Take current deferred checks and combine with the
209 previous states if we also defer checks previously.
210 Otherwise perform checks now. */
213 pop_to_parent_deferring_access_checks (void)
215 if (deferred_access_no_check)
216 deferred_access_no_check--;
219 VEC (deferred_access_check,gc) *checks;
220 deferred_access *ptr;
222 checks = (VEC_last (deferred_access, deferred_access_stack)
223 ->deferred_access_checks);
225 VEC_pop (deferred_access, deferred_access_stack);
226 ptr = VEC_last (deferred_access, deferred_access_stack);
227 if (ptr->deferring_access_checks_kind == dk_no_deferred)
230 perform_access_checks (checks);
234 /* Merge with parent. */
236 deferred_access_check *chk, *probe;
239 VEC_iterate (deferred_access_check, checks, i, chk) ;
243 VEC_iterate (deferred_access_check,
244 ptr->deferred_access_checks, j, probe) ;
247 if (probe->binfo == chk->binfo &&
248 probe->decl == chk->decl &&
249 probe->diag_decl == chk->diag_decl)
252 /* Insert into parent's checks. */
253 VEC_safe_push (deferred_access_check, gc,
254 ptr->deferred_access_checks, chk);
261 /* Perform the access checks in CHECKS. The TREE_PURPOSE of each node
262 is the BINFO indicating the qualifying scope used to access the
263 DECL node stored in the TREE_VALUE of the node. */
266 perform_access_checks (VEC (deferred_access_check,gc)* checks)
269 deferred_access_check *chk;
274 for (i = 0 ; VEC_iterate (deferred_access_check, checks, i, chk) ; ++i)
275 enforce_access (chk->binfo, chk->decl, chk->diag_decl);
278 /* Perform the deferred access checks.
280 After performing the checks, we still have to keep the list
281 `deferred_access_stack->deferred_access_checks' since we may want
282 to check access for them again later in a different context.
289 A::X A::a, x; // No error for `A::a', error for `x'
291 We have to perform deferred access of `A::X', first with `A::a',
295 perform_deferred_access_checks (void)
297 perform_access_checks (get_deferred_access_checks ());
300 /* Defer checking the accessibility of DECL, when looked up in
301 BINFO. DIAG_DECL is the declaration to use to print diagnostics. */
304 perform_or_defer_access_check (tree binfo, tree decl, tree diag_decl)
307 deferred_access *ptr;
308 deferred_access_check *chk;
309 deferred_access_check *new_access;
312 /* Exit if we are in a context that no access checking is performed.
314 if (deferred_access_no_check)
317 gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
319 ptr = VEC_last (deferred_access, deferred_access_stack);
321 /* If we are not supposed to defer access checks, just check now. */
322 if (ptr->deferring_access_checks_kind == dk_no_deferred)
324 enforce_access (binfo, decl, diag_decl);
328 /* See if we are already going to perform this check. */
330 VEC_iterate (deferred_access_check,
331 ptr->deferred_access_checks, i, chk) ;
334 if (chk->decl == decl && chk->binfo == binfo &&
335 chk->diag_decl == diag_decl)
340 /* If not, record the check. */
342 VEC_safe_push (deferred_access_check, gc,
343 ptr->deferred_access_checks, 0);
344 new_access->binfo = binfo;
345 new_access->decl = decl;
346 new_access->diag_decl = diag_decl;
349 /* Returns nonzero if the current statement is a full expression,
350 i.e. temporaries created during that statement should be destroyed
351 at the end of the statement. */
354 stmts_are_full_exprs_p (void)
356 return current_stmt_tree ()->stmts_are_full_exprs_p;
359 /* T is a statement. Add it to the statement-tree. This is the C++
360 version. The C/ObjC frontends have a slightly different version of
366 enum tree_code code = TREE_CODE (t);
368 if (EXPR_P (t) && code != LABEL_EXPR)
370 if (!EXPR_HAS_LOCATION (t))
371 SET_EXPR_LOCATION (t, input_location);
373 /* When we expand a statement-tree, we must know whether or not the
374 statements are full-expressions. We record that fact here. */
375 STMT_IS_FULL_EXPR_P (t) = stmts_are_full_exprs_p ();
378 /* Add T to the statement-tree. Non-side-effect statements need to be
379 recorded during statement expressions. */
380 append_to_statement_list_force (t, &cur_stmt_list);
385 /* Returns the stmt_tree (if any) to which statements are currently
386 being added. If there is no active statement-tree, NULL is
390 current_stmt_tree (void)
393 ? &cfun->language->base.x_stmt_tree
394 : &scope_chain->x_stmt_tree);
397 /* If statements are full expressions, wrap STMT in a CLEANUP_POINT_EXPR. */
400 maybe_cleanup_point_expr (tree expr)
402 if (!processing_template_decl && stmts_are_full_exprs_p ())
403 expr = fold_build_cleanup_point_expr (TREE_TYPE (expr), expr);
407 /* Like maybe_cleanup_point_expr except have the type of the new expression be
408 void so we don't need to create a temporary variable to hold the inner
409 expression. The reason why we do this is because the original type might be
410 an aggregate and we cannot create a temporary variable for that type. */
413 maybe_cleanup_point_expr_void (tree expr)
415 if (!processing_template_decl && stmts_are_full_exprs_p ())
416 expr = fold_build_cleanup_point_expr (void_type_node, expr);
422 /* Create a declaration statement for the declaration given by the DECL. */
425 add_decl_expr (tree decl)
427 tree r = build_stmt (DECL_EXPR, decl);
428 if (DECL_INITIAL (decl)
429 || (DECL_SIZE (decl) && TREE_SIDE_EFFECTS (DECL_SIZE (decl))))
430 r = maybe_cleanup_point_expr_void (r);
434 /* Nonzero if TYPE is an anonymous union or struct type. We have to use a
435 flag for this because "A union for which objects or pointers are
436 declared is not an anonymous union" [class.union]. */
439 anon_aggr_type_p (tree node)
441 return ANON_AGGR_TYPE_P (node);
444 /* Finish a scope. */
447 do_poplevel (tree stmt_list)
451 if (stmts_are_full_exprs_p ())
452 block = poplevel (kept_level_p (), 1, 0);
454 stmt_list = pop_stmt_list (stmt_list);
456 if (!processing_template_decl)
458 stmt_list = c_build_bind_expr (block, stmt_list);
459 /* ??? See c_end_compound_stmt re statement expressions. */
465 /* Begin a new scope. */
468 do_pushlevel (scope_kind sk)
470 tree ret = push_stmt_list ();
471 if (stmts_are_full_exprs_p ())
472 begin_scope (sk, NULL);
476 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
477 when the current scope is exited. EH_ONLY is true when this is not
478 meant to apply to normal control flow transfer. */
481 push_cleanup (tree decl, tree cleanup, bool eh_only)
483 tree stmt = build_stmt (CLEANUP_STMT, NULL, cleanup, decl);
484 CLEANUP_EH_ONLY (stmt) = eh_only;
486 CLEANUP_BODY (stmt) = push_stmt_list ();
489 /* Begin a conditional that might contain a declaration. When generating
490 normal code, we want the declaration to appear before the statement
491 containing the conditional. When generating template code, we want the
492 conditional to be rendered as the raw DECL_EXPR. */
495 begin_cond (tree *cond_p)
497 if (processing_template_decl)
498 *cond_p = push_stmt_list ();
501 /* Finish such a conditional. */
504 finish_cond (tree *cond_p, tree expr)
506 if (processing_template_decl)
508 tree cond = pop_stmt_list (*cond_p);
509 if (TREE_CODE (cond) == DECL_EXPR)
512 check_for_bare_parameter_packs (expr);
517 /* If *COND_P specifies a conditional with a declaration, transform the
520 for (; A x = 42;) { }
522 while (true) { A x = 42; if (!x) break; }
523 for (;;) { A x = 42; if (!x) break; }
524 The statement list for BODY will be empty if the conditional did
525 not declare anything. */
528 simplify_loop_decl_cond (tree *cond_p, tree body)
532 if (!TREE_SIDE_EFFECTS (body))
536 *cond_p = boolean_true_node;
538 if_stmt = begin_if_stmt ();
539 cond = build_unary_op (TRUTH_NOT_EXPR, cond, 0);
540 finish_if_stmt_cond (cond, if_stmt);
541 finish_break_stmt ();
542 finish_then_clause (if_stmt);
543 finish_if_stmt (if_stmt);
546 /* Finish a goto-statement. */
549 finish_goto_stmt (tree destination)
551 if (TREE_CODE (destination) == IDENTIFIER_NODE)
552 destination = lookup_label (destination);
554 /* We warn about unused labels with -Wunused. That means we have to
555 mark the used labels as used. */
556 if (TREE_CODE (destination) == LABEL_DECL)
557 TREE_USED (destination) = 1;
560 /* The DESTINATION is being used as an rvalue. */
561 if (!processing_template_decl)
562 destination = decay_conversion (destination);
563 /* We don't inline calls to functions with computed gotos.
564 Those functions are typically up to some funny business,
565 and may be depending on the labels being at particular
566 addresses, or some such. */
567 DECL_UNINLINABLE (current_function_decl) = 1;
570 check_goto (destination);
572 return add_stmt (build_stmt (GOTO_EXPR, destination));
575 /* COND is the condition-expression for an if, while, etc.,
576 statement. Convert it to a boolean value, if appropriate. */
579 maybe_convert_cond (tree cond)
581 /* Empty conditions remain empty. */
585 /* Wait until we instantiate templates before doing conversion. */
586 if (processing_template_decl)
589 /* Do the conversion. */
590 cond = convert_from_reference (cond);
592 if (TREE_CODE (cond) == MODIFY_EXPR
593 && !TREE_NO_WARNING (cond)
596 warning (OPT_Wparentheses,
597 "suggest parentheses around assignment used as truth value");
598 TREE_NO_WARNING (cond) = 1;
601 return condition_conversion (cond);
604 /* Finish an expression-statement, whose EXPRESSION is as indicated. */
607 finish_expr_stmt (tree expr)
611 if (expr != NULL_TREE)
613 if (!processing_template_decl)
615 if (warn_sequence_point)
616 verify_sequence_points (expr);
617 expr = convert_to_void (expr, "statement");
619 else if (!type_dependent_expression_p (expr))
620 convert_to_void (build_non_dependent_expr (expr), "statement");
622 check_for_bare_parameter_packs (expr);
624 /* Simplification of inner statement expressions, compound exprs,
625 etc can result in us already having an EXPR_STMT. */
626 if (TREE_CODE (expr) != CLEANUP_POINT_EXPR)
628 if (TREE_CODE (expr) != EXPR_STMT)
629 expr = build_stmt (EXPR_STMT, expr);
630 expr = maybe_cleanup_point_expr_void (expr);
642 /* Begin an if-statement. Returns a newly created IF_STMT if
649 scope = do_pushlevel (sk_block);
650 r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
651 TREE_CHAIN (r) = scope;
652 begin_cond (&IF_COND (r));
656 /* Process the COND of an if-statement, which may be given by
660 finish_if_stmt_cond (tree cond, tree if_stmt)
662 finish_cond (&IF_COND (if_stmt), maybe_convert_cond (cond));
664 THEN_CLAUSE (if_stmt) = push_stmt_list ();
667 /* Finish the then-clause of an if-statement, which may be given by
671 finish_then_clause (tree if_stmt)
673 THEN_CLAUSE (if_stmt) = pop_stmt_list (THEN_CLAUSE (if_stmt));
677 /* Begin the else-clause of an if-statement. */
680 begin_else_clause (tree if_stmt)
682 ELSE_CLAUSE (if_stmt) = push_stmt_list ();
685 /* Finish the else-clause of an if-statement, which may be given by
689 finish_else_clause (tree if_stmt)
691 ELSE_CLAUSE (if_stmt) = pop_stmt_list (ELSE_CLAUSE (if_stmt));
694 /* Finish an if-statement. */
697 finish_if_stmt (tree if_stmt)
699 tree scope = TREE_CHAIN (if_stmt);
700 TREE_CHAIN (if_stmt) = NULL;
701 add_stmt (do_poplevel (scope));
703 empty_if_body_warning (THEN_CLAUSE (if_stmt), ELSE_CLAUSE (if_stmt));
706 /* Begin a while-statement. Returns a newly created WHILE_STMT if
710 begin_while_stmt (void)
713 r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
715 WHILE_BODY (r) = do_pushlevel (sk_block);
716 begin_cond (&WHILE_COND (r));
720 /* Process the COND of a while-statement, which may be given by
724 finish_while_stmt_cond (tree cond, tree while_stmt)
726 finish_cond (&WHILE_COND (while_stmt), maybe_convert_cond (cond));
727 simplify_loop_decl_cond (&WHILE_COND (while_stmt), WHILE_BODY (while_stmt));
730 /* Finish a while-statement, which may be given by WHILE_STMT. */
733 finish_while_stmt (tree while_stmt)
735 WHILE_BODY (while_stmt) = do_poplevel (WHILE_BODY (while_stmt));
739 /* Begin a do-statement. Returns a newly created DO_STMT if
745 tree r = build_stmt (DO_STMT, NULL_TREE, NULL_TREE);
747 DO_BODY (r) = push_stmt_list ();
751 /* Finish the body of a do-statement, which may be given by DO_STMT. */
754 finish_do_body (tree do_stmt)
756 tree body = DO_BODY (do_stmt) = pop_stmt_list (DO_BODY (do_stmt));
758 if (TREE_CODE (body) == STATEMENT_LIST && STATEMENT_LIST_TAIL (body))
759 body = STATEMENT_LIST_TAIL (body)->stmt;
761 if (IS_EMPTY_STMT (body))
762 warning (OPT_Wempty_body,
763 "suggest explicit braces around empty body in %<do%> statement");
766 /* Finish a do-statement, which may be given by DO_STMT, and whose
767 COND is as indicated. */
770 finish_do_stmt (tree cond, tree do_stmt)
772 cond = maybe_convert_cond (cond);
773 DO_COND (do_stmt) = cond;
777 /* Finish a return-statement. The EXPRESSION returned, if any, is as
781 finish_return_stmt (tree expr)
786 expr = check_return_expr (expr, &no_warning);
788 if (flag_openmp && !check_omp_return ())
789 return error_mark_node;
790 if (!processing_template_decl)
792 if (DECL_DESTRUCTOR_P (current_function_decl)
793 || (DECL_CONSTRUCTOR_P (current_function_decl)
794 && targetm.cxx.cdtor_returns_this ()))
796 /* Similarly, all destructors must run destructors for
797 base-classes before returning. So, all returns in a
798 destructor get sent to the DTOR_LABEL; finish_function emits
799 code to return a value there. */
800 return finish_goto_stmt (cdtor_label);
804 r = build_stmt (RETURN_EXPR, expr);
805 TREE_NO_WARNING (r) |= no_warning;
806 r = maybe_cleanup_point_expr_void (r);
813 /* Begin a for-statement. Returns a new FOR_STMT if appropriate. */
816 begin_for_stmt (void)
820 r = build_stmt (FOR_STMT, NULL_TREE, NULL_TREE,
821 NULL_TREE, NULL_TREE);
823 if (flag_new_for_scope > 0)
824 TREE_CHAIN (r) = do_pushlevel (sk_for);
826 if (processing_template_decl)
827 FOR_INIT_STMT (r) = push_stmt_list ();
832 /* Finish the for-init-statement of a for-statement, which may be
833 given by FOR_STMT. */
836 finish_for_init_stmt (tree for_stmt)
838 if (processing_template_decl)
839 FOR_INIT_STMT (for_stmt) = pop_stmt_list (FOR_INIT_STMT (for_stmt));
841 FOR_BODY (for_stmt) = do_pushlevel (sk_block);
842 begin_cond (&FOR_COND (for_stmt));
845 /* Finish the COND of a for-statement, which may be given by
849 finish_for_cond (tree cond, tree for_stmt)
851 finish_cond (&FOR_COND (for_stmt), maybe_convert_cond (cond));
852 simplify_loop_decl_cond (&FOR_COND (for_stmt), FOR_BODY (for_stmt));
855 /* Finish the increment-EXPRESSION in a for-statement, which may be
856 given by FOR_STMT. */
859 finish_for_expr (tree expr, tree for_stmt)
863 /* If EXPR is an overloaded function, issue an error; there is no
864 context available to use to perform overload resolution. */
865 if (type_unknown_p (expr))
867 cxx_incomplete_type_error (expr, TREE_TYPE (expr));
868 expr = error_mark_node;
870 if (!processing_template_decl)
872 if (warn_sequence_point)
873 verify_sequence_points (expr);
874 expr = convert_to_void (expr, "3rd expression in for");
876 else if (!type_dependent_expression_p (expr))
877 convert_to_void (build_non_dependent_expr (expr), "3rd expression in for");
878 expr = maybe_cleanup_point_expr_void (expr);
879 check_for_bare_parameter_packs (expr);
880 FOR_EXPR (for_stmt) = expr;
883 /* Finish the body of a for-statement, which may be given by
884 FOR_STMT. The increment-EXPR for the loop must be
888 finish_for_stmt (tree for_stmt)
890 FOR_BODY (for_stmt) = do_poplevel (FOR_BODY (for_stmt));
892 /* Pop the scope for the body of the loop. */
893 if (flag_new_for_scope > 0)
895 tree scope = TREE_CHAIN (for_stmt);
896 TREE_CHAIN (for_stmt) = NULL;
897 add_stmt (do_poplevel (scope));
903 /* Finish a break-statement. */
906 finish_break_stmt (void)
908 return add_stmt (build_stmt (BREAK_STMT));
911 /* Finish a continue-statement. */
914 finish_continue_stmt (void)
916 return add_stmt (build_stmt (CONTINUE_STMT));
919 /* Begin a switch-statement. Returns a new SWITCH_STMT if
923 begin_switch_stmt (void)
927 r = build_stmt (SWITCH_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
929 scope = do_pushlevel (sk_block);
930 TREE_CHAIN (r) = scope;
931 begin_cond (&SWITCH_STMT_COND (r));
936 /* Finish the cond of a switch-statement. */
939 finish_switch_cond (tree cond, tree switch_stmt)
941 tree orig_type = NULL;
942 if (!processing_template_decl)
946 /* Convert the condition to an integer or enumeration type. */
947 cond = build_expr_type_conversion (WANT_INT | WANT_ENUM, cond, true);
948 if (cond == NULL_TREE)
950 error ("switch quantity not an integer");
951 cond = error_mark_node;
953 orig_type = TREE_TYPE (cond);
954 if (cond != error_mark_node)
958 Integral promotions are performed. */
959 cond = perform_integral_promotions (cond);
960 cond = maybe_cleanup_point_expr (cond);
963 if (cond != error_mark_node)
965 index = get_unwidened (cond, NULL_TREE);
966 /* We can't strip a conversion from a signed type to an unsigned,
967 because if we did, int_fits_type_p would do the wrong thing
968 when checking case values for being in range,
969 and it's too hard to do the right thing. */
970 if (TYPE_UNSIGNED (TREE_TYPE (cond))
971 == TYPE_UNSIGNED (TREE_TYPE (index)))
975 finish_cond (&SWITCH_STMT_COND (switch_stmt), cond);
976 SWITCH_STMT_TYPE (switch_stmt) = orig_type;
977 add_stmt (switch_stmt);
978 push_switch (switch_stmt);
979 SWITCH_STMT_BODY (switch_stmt) = push_stmt_list ();
980 check_for_bare_parameter_packs (cond);
983 /* Finish the body of a switch-statement, which may be given by
984 SWITCH_STMT. The COND to switch on is indicated. */
987 finish_switch_stmt (tree switch_stmt)
991 SWITCH_STMT_BODY (switch_stmt) =
992 pop_stmt_list (SWITCH_STMT_BODY (switch_stmt));
996 scope = TREE_CHAIN (switch_stmt);
997 TREE_CHAIN (switch_stmt) = NULL;
998 add_stmt (do_poplevel (scope));
1001 /* Begin a try-block. Returns a newly-created TRY_BLOCK if
1005 begin_try_block (void)
1007 tree r = build_stmt (TRY_BLOCK, NULL_TREE, NULL_TREE);
1009 TRY_STMTS (r) = push_stmt_list ();
1013 /* Likewise, for a function-try-block. The block returned in
1014 *COMPOUND_STMT is an artificial outer scope, containing the
1015 function-try-block. */
1018 begin_function_try_block (tree *compound_stmt)
1021 /* This outer scope does not exist in the C++ standard, but we need
1022 a place to put __FUNCTION__ and similar variables. */
1023 *compound_stmt = begin_compound_stmt (0);
1024 r = begin_try_block ();
1025 FN_TRY_BLOCK_P (r) = 1;
1029 /* Finish a try-block, which may be given by TRY_BLOCK. */
1032 finish_try_block (tree try_block)
1034 TRY_STMTS (try_block) = pop_stmt_list (TRY_STMTS (try_block));
1035 TRY_HANDLERS (try_block) = push_stmt_list ();
1038 /* Finish the body of a cleanup try-block, which may be given by
1042 finish_cleanup_try_block (tree try_block)
1044 TRY_STMTS (try_block) = pop_stmt_list (TRY_STMTS (try_block));
1047 /* Finish an implicitly generated try-block, with a cleanup is given
1051 finish_cleanup (tree cleanup, tree try_block)
1053 TRY_HANDLERS (try_block) = cleanup;
1054 CLEANUP_P (try_block) = 1;
1057 /* Likewise, for a function-try-block. */
1060 finish_function_try_block (tree try_block)
1062 finish_try_block (try_block);
1063 /* FIXME : something queer about CTOR_INITIALIZER somehow following
1064 the try block, but moving it inside. */
1065 in_function_try_handler = 1;
1068 /* Finish a handler-sequence for a try-block, which may be given by
1072 finish_handler_sequence (tree try_block)
1074 TRY_HANDLERS (try_block) = pop_stmt_list (TRY_HANDLERS (try_block));
1075 check_handlers (TRY_HANDLERS (try_block));
1078 /* Finish the handler-seq for a function-try-block, given by
1079 TRY_BLOCK. COMPOUND_STMT is the outer block created by
1080 begin_function_try_block. */
1083 finish_function_handler_sequence (tree try_block, tree compound_stmt)
1085 in_function_try_handler = 0;
1086 finish_handler_sequence (try_block);
1087 finish_compound_stmt (compound_stmt);
1090 /* Begin a handler. Returns a HANDLER if appropriate. */
1093 begin_handler (void)
1097 r = build_stmt (HANDLER, NULL_TREE, NULL_TREE);
1100 /* Create a binding level for the eh_info and the exception object
1102 HANDLER_BODY (r) = do_pushlevel (sk_catch);
1107 /* Finish the handler-parameters for a handler, which may be given by
1108 HANDLER. DECL is the declaration for the catch parameter, or NULL
1109 if this is a `catch (...)' clause. */
1112 finish_handler_parms (tree decl, tree handler)
1114 tree type = NULL_TREE;
1115 if (processing_template_decl)
1119 decl = pushdecl (decl);
1120 decl = push_template_decl (decl);
1121 HANDLER_PARMS (handler) = decl;
1122 type = TREE_TYPE (decl);
1126 type = expand_start_catch_block (decl);
1127 HANDLER_TYPE (handler) = type;
1128 if (!processing_template_decl && type)
1129 mark_used (eh_type_info (type));
1132 /* Finish a handler, which may be given by HANDLER. The BLOCKs are
1133 the return value from the matching call to finish_handler_parms. */
1136 finish_handler (tree handler)
1138 if (!processing_template_decl)
1139 expand_end_catch_block ();
1140 HANDLER_BODY (handler) = do_poplevel (HANDLER_BODY (handler));
1143 /* Begin a compound statement. FLAGS contains some bits that control the
1144 behavior and context. If BCS_NO_SCOPE is set, the compound statement
1145 does not define a scope. If BCS_FN_BODY is set, this is the outermost
1146 block of a function. If BCS_TRY_BLOCK is set, this is the block
1147 created on behalf of a TRY statement. Returns a token to be passed to
1148 finish_compound_stmt. */
1151 begin_compound_stmt (unsigned int flags)
1155 if (flags & BCS_NO_SCOPE)
1157 r = push_stmt_list ();
1158 STATEMENT_LIST_NO_SCOPE (r) = 1;
1160 /* Normally, we try hard to keep the BLOCK for a statement-expression.
1161 But, if it's a statement-expression with a scopeless block, there's
1162 nothing to keep, and we don't want to accidentally keep a block
1163 *inside* the scopeless block. */
1164 keep_next_level (false);
1167 r = do_pushlevel (flags & BCS_TRY_BLOCK ? sk_try : sk_block);
1169 /* When processing a template, we need to remember where the braces were,
1170 so that we can set up identical scopes when instantiating the template
1171 later. BIND_EXPR is a handy candidate for this.
1172 Note that do_poplevel won't create a BIND_EXPR itself here (and thus
1173 result in nested BIND_EXPRs), since we don't build BLOCK nodes when
1174 processing templates. */
1175 if (processing_template_decl)
1177 r = build3 (BIND_EXPR, NULL, NULL, r, NULL);
1178 BIND_EXPR_TRY_BLOCK (r) = (flags & BCS_TRY_BLOCK) != 0;
1179 BIND_EXPR_BODY_BLOCK (r) = (flags & BCS_FN_BODY) != 0;
1180 TREE_SIDE_EFFECTS (r) = 1;
1186 /* Finish a compound-statement, which is given by STMT. */
1189 finish_compound_stmt (tree stmt)
1191 if (TREE_CODE (stmt) == BIND_EXPR)
1192 BIND_EXPR_BODY (stmt) = do_poplevel (BIND_EXPR_BODY (stmt));
1193 else if (STATEMENT_LIST_NO_SCOPE (stmt))
1194 stmt = pop_stmt_list (stmt);
1197 /* Destroy any ObjC "super" receivers that may have been
1199 objc_clear_super_receiver ();
1201 stmt = do_poplevel (stmt);
1204 /* ??? See c_end_compound_stmt wrt statement expressions. */
1209 /* Finish an asm-statement, whose components are a STRING, some
1210 OUTPUT_OPERANDS, some INPUT_OPERANDS, and some CLOBBERS. Also note
1211 whether the asm-statement should be considered volatile. */
1214 finish_asm_stmt (int volatile_p, tree string, tree output_operands,
1215 tree input_operands, tree clobbers)
1219 int ninputs = list_length (input_operands);
1220 int noutputs = list_length (output_operands);
1222 if (!processing_template_decl)
1224 const char *constraint;
1225 const char **oconstraints;
1226 bool allows_mem, allows_reg, is_inout;
1230 oconstraints = (const char **) alloca (noutputs * sizeof (char *));
1232 string = resolve_asm_operand_names (string, output_operands,
1235 for (i = 0, t = output_operands; t; t = TREE_CHAIN (t), ++i)
1237 operand = TREE_VALUE (t);
1239 /* ??? Really, this should not be here. Users should be using a
1240 proper lvalue, dammit. But there's a long history of using
1241 casts in the output operands. In cases like longlong.h, this
1242 becomes a primitive form of typechecking -- if the cast can be
1243 removed, then the output operand had a type of the proper width;
1244 otherwise we'll get an error. Gross, but ... */
1245 STRIP_NOPS (operand);
1247 if (!lvalue_or_else (operand, lv_asm))
1248 operand = error_mark_node;
1250 if (operand != error_mark_node
1251 && (TREE_READONLY (operand)
1252 || CP_TYPE_CONST_P (TREE_TYPE (operand))
1253 /* Functions are not modifiable, even though they are
1255 || TREE_CODE (TREE_TYPE (operand)) == FUNCTION_TYPE
1256 || TREE_CODE (TREE_TYPE (operand)) == METHOD_TYPE
1257 /* If it's an aggregate and any field is const, then it is
1258 effectively const. */
1259 || (CLASS_TYPE_P (TREE_TYPE (operand))
1260 && C_TYPE_FIELDS_READONLY (TREE_TYPE (operand)))))
1261 readonly_error (operand, "assignment (via 'asm' output)");
1263 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
1264 oconstraints[i] = constraint;
1266 if (parse_output_constraint (&constraint, i, ninputs, noutputs,
1267 &allows_mem, &allows_reg, &is_inout))
1269 /* If the operand is going to end up in memory,
1270 mark it addressable. */
1271 if (!allows_reg && !cxx_mark_addressable (operand))
1272 operand = error_mark_node;
1275 operand = error_mark_node;
1277 TREE_VALUE (t) = operand;
1280 for (i = 0, t = input_operands; t; ++i, t = TREE_CHAIN (t))
1282 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
1283 operand = decay_conversion (TREE_VALUE (t));
1285 /* If the type of the operand hasn't been determined (e.g.,
1286 because it involves an overloaded function), then issue
1287 an error message. There's no context available to
1288 resolve the overloading. */
1289 if (TREE_TYPE (operand) == unknown_type_node)
1291 error ("type of asm operand %qE could not be determined",
1293 operand = error_mark_node;
1296 if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
1297 oconstraints, &allows_mem, &allows_reg))
1299 /* If the operand is going to end up in memory,
1300 mark it addressable. */
1301 if (!allows_reg && allows_mem)
1303 /* Strip the nops as we allow this case. FIXME, this really
1304 should be rejected or made deprecated. */
1305 STRIP_NOPS (operand);
1306 if (!cxx_mark_addressable (operand))
1307 operand = error_mark_node;
1311 operand = error_mark_node;
1313 TREE_VALUE (t) = operand;
1317 r = build_stmt (ASM_EXPR, string,
1318 output_operands, input_operands,
1320 ASM_VOLATILE_P (r) = volatile_p || noutputs == 0;
1321 r = maybe_cleanup_point_expr_void (r);
1322 return add_stmt (r);
1325 /* Finish a label with the indicated NAME. */
1328 finish_label_stmt (tree name)
1330 tree decl = define_label (input_location, name);
1332 if (decl == error_mark_node)
1333 return error_mark_node;
1335 return add_stmt (build_stmt (LABEL_EXPR, decl));
1338 /* Finish a series of declarations for local labels. G++ allows users
1339 to declare "local" labels, i.e., labels with scope. This extension
1340 is useful when writing code involving statement-expressions. */
1343 finish_label_decl (tree name)
1345 if (!at_function_scope_p ())
1347 error ("__label__ declarations are only allowed in function scopes");
1351 add_decl_expr (declare_local_label (name));
1354 /* When DECL goes out of scope, make sure that CLEANUP is executed. */
1357 finish_decl_cleanup (tree decl, tree cleanup)
1359 push_cleanup (decl, cleanup, false);
1362 /* If the current scope exits with an exception, run CLEANUP. */
1365 finish_eh_cleanup (tree cleanup)
1367 push_cleanup (NULL, cleanup, true);
1370 /* The MEM_INITS is a list of mem-initializers, in reverse of the
1371 order they were written by the user. Each node is as for
1372 emit_mem_initializers. */
1375 finish_mem_initializers (tree mem_inits)
1377 /* Reorder the MEM_INITS so that they are in the order they appeared
1378 in the source program. */
1379 mem_inits = nreverse (mem_inits);
1381 if (processing_template_decl)
1385 for (mem = mem_inits; mem; mem = TREE_CHAIN (mem))
1387 /* If the TREE_PURPOSE is a TYPE_PACK_EXPANSION, skip the
1388 check for bare parameter packs in the TREE_VALUE, because
1389 any parameter packs in the TREE_VALUE have already been
1390 bound as part of the TREE_PURPOSE. See
1391 make_pack_expansion for more information. */
1392 if (TREE_CODE (TREE_PURPOSE (mem)) != TYPE_PACK_EXPANSION)
1393 check_for_bare_parameter_packs (TREE_VALUE (mem));
1396 add_stmt (build_min_nt (CTOR_INITIALIZER, mem_inits));
1399 emit_mem_initializers (mem_inits);
1402 /* Finish a parenthesized expression EXPR. */
1405 finish_parenthesized_expr (tree expr)
1408 /* This inhibits warnings in c_common_truthvalue_conversion. */
1409 TREE_NO_WARNING (expr) = 1;
1411 if (TREE_CODE (expr) == OFFSET_REF)
1412 /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
1413 enclosed in parentheses. */
1414 PTRMEM_OK_P (expr) = 0;
1416 if (TREE_CODE (expr) == STRING_CST)
1417 PAREN_STRING_LITERAL_P (expr) = 1;
1422 /* Finish a reference to a non-static data member (DECL) that is not
1423 preceded by `.' or `->'. */
1426 finish_non_static_data_member (tree decl, tree object, tree qualifying_scope)
1428 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
1432 if (current_function_decl
1433 && DECL_STATIC_FUNCTION_P (current_function_decl))
1434 error ("invalid use of member %q+D in static member function", decl);
1436 error ("invalid use of non-static data member %q+D", decl);
1437 error ("from this location");
1439 return error_mark_node;
1441 TREE_USED (current_class_ptr) = 1;
1442 if (processing_template_decl && !qualifying_scope)
1444 tree type = TREE_TYPE (decl);
1446 if (TREE_CODE (type) == REFERENCE_TYPE)
1447 type = TREE_TYPE (type);
1450 /* Set the cv qualifiers. */
1451 int quals = cp_type_quals (TREE_TYPE (current_class_ref));
1453 if (DECL_MUTABLE_P (decl))
1454 quals &= ~TYPE_QUAL_CONST;
1456 quals |= cp_type_quals (TREE_TYPE (decl));
1457 type = cp_build_qualified_type (type, quals);
1460 return build_min (COMPONENT_REF, type, object, decl, NULL_TREE);
1464 tree access_type = TREE_TYPE (object);
1465 tree lookup_context = context_for_name_lookup (decl);
1467 while (!DERIVED_FROM_P (lookup_context, access_type))
1469 access_type = TYPE_CONTEXT (access_type);
1470 while (access_type && DECL_P (access_type))
1471 access_type = DECL_CONTEXT (access_type);
1475 error ("object missing in reference to %q+D", decl);
1476 error ("from this location");
1477 return error_mark_node;
1481 /* If PROCESSING_TEMPLATE_DECL is nonzero here, then
1482 QUALIFYING_SCOPE is also non-null. Wrap this in a SCOPE_REF
1484 if (processing_template_decl)
1485 return build_qualified_name (TREE_TYPE (decl),
1488 /*template_p=*/false);
1490 perform_or_defer_access_check (TYPE_BINFO (access_type), decl,
1493 /* If the data member was named `C::M', convert `*this' to `C'
1495 if (qualifying_scope)
1497 tree binfo = NULL_TREE;
1498 object = build_scoped_ref (object, qualifying_scope,
1502 return build_class_member_access_expr (object, decl,
1503 /*access_path=*/NULL_TREE,
1504 /*preserve_reference=*/false);
1508 /* DECL was the declaration to which a qualified-id resolved. Issue
1509 an error message if it is not accessible. If OBJECT_TYPE is
1510 non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
1511 type of `*x', or `x', respectively. If the DECL was named as
1512 `A::B' then NESTED_NAME_SPECIFIER is `A'. */
1515 check_accessibility_of_qualified_id (tree decl,
1517 tree nested_name_specifier)
1520 tree qualifying_type = NULL_TREE;
1522 /* If we're not checking, return immediately. */
1523 if (deferred_access_no_check)
1526 /* Determine the SCOPE of DECL. */
1527 scope = context_for_name_lookup (decl);
1528 /* If the SCOPE is not a type, then DECL is not a member. */
1529 if (!TYPE_P (scope))
1531 /* Compute the scope through which DECL is being accessed. */
1533 /* OBJECT_TYPE might not be a class type; consider:
1535 class A { typedef int I; };
1539 In this case, we will have "A::I" as the DECL, but "I" as the
1541 && CLASS_TYPE_P (object_type)
1542 && DERIVED_FROM_P (scope, object_type))
1543 /* If we are processing a `->' or `.' expression, use the type of the
1545 qualifying_type = object_type;
1546 else if (nested_name_specifier)
1548 /* If the reference is to a non-static member of the
1549 current class, treat it as if it were referenced through
1551 if (DECL_NONSTATIC_MEMBER_P (decl)
1552 && current_class_ptr
1553 && DERIVED_FROM_P (scope, current_class_type))
1554 qualifying_type = current_class_type;
1555 /* Otherwise, use the type indicated by the
1556 nested-name-specifier. */
1558 qualifying_type = nested_name_specifier;
1561 /* Otherwise, the name must be from the current class or one of
1563 qualifying_type = currently_open_derived_class (scope);
1566 /* It is possible for qualifying type to be a TEMPLATE_TYPE_PARM
1567 or similar in a default argument value. */
1568 && CLASS_TYPE_P (qualifying_type)
1569 && !dependent_type_p (qualifying_type))
1570 perform_or_defer_access_check (TYPE_BINFO (qualifying_type), decl,
1574 /* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
1575 class named to the left of the "::" operator. DONE is true if this
1576 expression is a complete postfix-expression; it is false if this
1577 expression is followed by '->', '[', '(', etc. ADDRESS_P is true
1578 iff this expression is the operand of '&'. TEMPLATE_P is true iff
1579 the qualified-id was of the form "A::template B". TEMPLATE_ARG_P
1580 is true iff this qualified name appears as a template argument. */
1583 finish_qualified_id_expr (tree qualifying_class,
1588 bool template_arg_p)
1590 gcc_assert (TYPE_P (qualifying_class));
1592 if (error_operand_p (expr))
1593 return error_mark_node;
1595 if (DECL_P (expr) || BASELINK_P (expr))
1599 check_template_keyword (expr);
1601 /* If EXPR occurs as the operand of '&', use special handling that
1602 permits a pointer-to-member. */
1603 if (address_p && done)
1605 if (TREE_CODE (expr) == SCOPE_REF)
1606 expr = TREE_OPERAND (expr, 1);
1607 expr = build_offset_ref (qualifying_class, expr,
1608 /*address_p=*/true);
1612 /* Within the scope of a class, turn references to non-static
1613 members into expression of the form "this->...". */
1615 /* But, within a template argument, we do not want make the
1616 transformation, as there is no "this" pointer. */
1618 else if (TREE_CODE (expr) == FIELD_DECL)
1619 expr = finish_non_static_data_member (expr, current_class_ref,
1621 else if (BASELINK_P (expr) && !processing_template_decl)
1625 /* See if any of the functions are non-static members. */
1626 fns = BASELINK_FUNCTIONS (expr);
1627 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
1628 fns = TREE_OPERAND (fns, 0);
1629 /* If so, the expression may be relative to the current
1631 if (!shared_member_p (fns)
1632 && current_class_type
1633 && DERIVED_FROM_P (qualifying_class, current_class_type))
1634 expr = (build_class_member_access_expr
1635 (maybe_dummy_object (qualifying_class, NULL),
1637 BASELINK_ACCESS_BINFO (expr),
1638 /*preserve_reference=*/false));
1640 /* The expression is a qualified name whose address is not
1642 expr = build_offset_ref (qualifying_class, expr, /*address_p=*/false);
1648 /* Begin a statement-expression. The value returned must be passed to
1649 finish_stmt_expr. */
1652 begin_stmt_expr (void)
1654 return push_stmt_list ();
1657 /* Process the final expression of a statement expression. EXPR can be
1658 NULL, if the final expression is empty. Return a STATEMENT_LIST
1659 containing all the statements in the statement-expression, or
1660 ERROR_MARK_NODE if there was an error. */
1663 finish_stmt_expr_expr (tree expr, tree stmt_expr)
1665 if (error_operand_p (expr))
1667 /* The type of the statement-expression is the type of the last
1669 TREE_TYPE (stmt_expr) = error_mark_node;
1670 return error_mark_node;
1673 /* If the last statement does not have "void" type, then the value
1674 of the last statement is the value of the entire expression. */
1677 tree type = TREE_TYPE (expr);
1679 if (processing_template_decl)
1681 expr = build_stmt (EXPR_STMT, expr);
1682 expr = add_stmt (expr);
1683 /* Mark the last statement so that we can recognize it as such at
1684 template-instantiation time. */
1685 EXPR_STMT_STMT_EXPR_RESULT (expr) = 1;
1687 else if (VOID_TYPE_P (type))
1689 /* Just treat this like an ordinary statement. */
1690 expr = finish_expr_stmt (expr);
1694 /* It actually has a value we need to deal with. First, force it
1695 to be an rvalue so that we won't need to build up a copy
1696 constructor call later when we try to assign it to something. */
1697 expr = force_rvalue (expr);
1698 if (error_operand_p (expr))
1699 return error_mark_node;
1701 /* Update for array-to-pointer decay. */
1702 type = TREE_TYPE (expr);
1704 /* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
1705 normal statement, but don't convert to void or actually add
1707 if (TREE_CODE (expr) != CLEANUP_POINT_EXPR)
1708 expr = maybe_cleanup_point_expr (expr);
1712 /* The type of the statement-expression is the type of the last
1714 TREE_TYPE (stmt_expr) = type;
1720 /* Finish a statement-expression. EXPR should be the value returned
1721 by the previous begin_stmt_expr. Returns an expression
1722 representing the statement-expression. */
1725 finish_stmt_expr (tree stmt_expr, bool has_no_scope)
1730 if (error_operand_p (stmt_expr))
1731 return error_mark_node;
1733 gcc_assert (TREE_CODE (stmt_expr) == STATEMENT_LIST);
1735 type = TREE_TYPE (stmt_expr);
1736 result = pop_stmt_list (stmt_expr);
1737 TREE_TYPE (result) = type;
1739 if (processing_template_decl)
1741 result = build_min (STMT_EXPR, type, result);
1742 TREE_SIDE_EFFECTS (result) = 1;
1743 STMT_EXPR_NO_SCOPE (result) = has_no_scope;
1745 else if (CLASS_TYPE_P (type))
1747 /* Wrap the statement-expression in a TARGET_EXPR so that the
1748 temporary object created by the final expression is destroyed at
1749 the end of the full-expression containing the
1750 statement-expression. */
1751 result = force_target_expr (type, result);
1757 /* Perform Koenig lookup. FN is the postfix-expression representing
1758 the function (or functions) to call; ARGS are the arguments to the
1759 call. Returns the functions to be considered by overload
1763 perform_koenig_lookup (tree fn, tree args)
1765 tree identifier = NULL_TREE;
1766 tree functions = NULL_TREE;
1768 /* Find the name of the overloaded function. */
1769 if (TREE_CODE (fn) == IDENTIFIER_NODE)
1771 else if (is_overloaded_fn (fn))
1774 identifier = DECL_NAME (get_first_fn (functions));
1776 else if (DECL_P (fn))
1779 identifier = DECL_NAME (fn);
1782 /* A call to a namespace-scope function using an unqualified name.
1784 Do Koenig lookup -- unless any of the arguments are
1786 if (!any_type_dependent_arguments_p (args))
1788 fn = lookup_arg_dependent (identifier, functions, args);
1790 /* The unqualified name could not be resolved. */
1791 fn = unqualified_fn_lookup_error (identifier);
1797 /* Generate an expression for `FN (ARGS)'.
1799 If DISALLOW_VIRTUAL is true, the call to FN will be not generated
1800 as a virtual call, even if FN is virtual. (This flag is set when
1801 encountering an expression where the function name is explicitly
1802 qualified. For example a call to `X::f' never generates a virtual
1805 Returns code for the call. */
1808 finish_call_expr (tree fn, tree args, bool disallow_virtual, bool koenig_p)
1814 if (fn == error_mark_node || args == error_mark_node)
1815 return error_mark_node;
1817 /* ARGS should be a list of arguments. */
1818 gcc_assert (!args || TREE_CODE (args) == TREE_LIST);
1819 gcc_assert (!TYPE_P (fn));
1824 if (processing_template_decl)
1826 if (type_dependent_expression_p (fn)
1827 || any_type_dependent_arguments_p (args))
1829 result = build_nt_call_list (fn, args);
1830 KOENIG_LOOKUP_P (result) = koenig_p;
1833 if (!BASELINK_P (fn)
1834 && TREE_CODE (fn) != PSEUDO_DTOR_EXPR
1835 && TREE_TYPE (fn) != unknown_type_node)
1836 fn = build_non_dependent_expr (fn);
1837 args = build_non_dependent_args (orig_args);
1840 if (is_overloaded_fn (fn))
1841 fn = baselink_for_fns (fn);
1844 if (BASELINK_P (fn))
1848 /* A call to a member function. From [over.call.func]:
1850 If the keyword this is in scope and refers to the class of
1851 that member function, or a derived class thereof, then the
1852 function call is transformed into a qualified function call
1853 using (*this) as the postfix-expression to the left of the
1854 . operator.... [Otherwise] a contrived object of type T
1855 becomes the implied object argument.
1857 This paragraph is unclear about this situation:
1859 struct A { void f(); };
1860 struct B : public A {};
1861 struct C : public A { void g() { B::f(); }};
1863 In particular, for `B::f', this paragraph does not make clear
1864 whether "the class of that member function" refers to `A' or
1865 to `B'. We believe it refers to `B'. */
1866 if (current_class_type
1867 && DERIVED_FROM_P (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
1869 && current_class_ref)
1870 object = maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
1874 tree representative_fn;
1876 representative_fn = BASELINK_FUNCTIONS (fn);
1877 if (TREE_CODE (representative_fn) == TEMPLATE_ID_EXPR)
1878 representative_fn = TREE_OPERAND (representative_fn, 0);
1879 representative_fn = get_first_fn (representative_fn);
1880 object = build_dummy_object (DECL_CONTEXT (representative_fn));
1883 if (processing_template_decl)
1885 if (type_dependent_expression_p (object))
1886 return build_nt_call_list (orig_fn, orig_args);
1887 object = build_non_dependent_expr (object);
1890 result = build_new_method_call (object, fn, args, NULL_TREE,
1892 ? LOOKUP_NONVIRTUAL : 0),
1895 else if (is_overloaded_fn (fn))
1897 /* If the function is an overloaded builtin, resolve it. */
1898 if (TREE_CODE (fn) == FUNCTION_DECL
1899 && (DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
1900 || DECL_BUILT_IN_CLASS (fn) == BUILT_IN_MD))
1901 result = resolve_overloaded_builtin (fn, args);
1904 /* A call to a namespace-scope function. */
1905 result = build_new_function_call (fn, args, koenig_p);
1907 else if (TREE_CODE (fn) == PSEUDO_DTOR_EXPR)
1910 error ("arguments to destructor are not allowed");
1911 /* Mark the pseudo-destructor call as having side-effects so
1912 that we do not issue warnings about its use. */
1913 result = build1 (NOP_EXPR,
1915 TREE_OPERAND (fn, 0));
1916 TREE_SIDE_EFFECTS (result) = 1;
1918 else if (CLASS_TYPE_P (TREE_TYPE (fn)))
1919 /* If the "function" is really an object of class type, it might
1920 have an overloaded `operator ()'. */
1921 result = build_new_op (CALL_EXPR, LOOKUP_NORMAL, fn, args, NULL_TREE,
1922 /*overloaded_p=*/NULL);
1925 /* A call where the function is unknown. */
1926 result = build_function_call (fn, args);
1928 if (processing_template_decl)
1930 result = build_call_list (TREE_TYPE (result), orig_fn, orig_args);
1931 KOENIG_LOOKUP_P (result) = koenig_p;
1936 /* Finish a call to a postfix increment or decrement or EXPR. (Which
1937 is indicated by CODE, which should be POSTINCREMENT_EXPR or
1938 POSTDECREMENT_EXPR.) */
1941 finish_increment_expr (tree expr, enum tree_code code)
1943 return build_x_unary_op (code, expr);
1946 /* Finish a use of `this'. Returns an expression for `this'. */
1949 finish_this_expr (void)
1953 if (current_class_ptr)
1955 result = current_class_ptr;
1957 else if (current_function_decl
1958 && DECL_STATIC_FUNCTION_P (current_function_decl))
1960 error ("%<this%> is unavailable for static member functions");
1961 result = error_mark_node;
1965 if (current_function_decl)
1966 error ("invalid use of %<this%> in non-member function");
1968 error ("invalid use of %<this%> at top level");
1969 result = error_mark_node;
1975 /* Finish a pseudo-destructor expression. If SCOPE is NULL, the
1976 expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
1977 the TYPE for the type given. If SCOPE is non-NULL, the expression
1978 was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
1981 finish_pseudo_destructor_expr (tree object, tree scope, tree destructor)
1983 if (destructor == error_mark_node)
1984 return error_mark_node;
1986 gcc_assert (TYPE_P (destructor));
1988 if (!processing_template_decl)
1990 if (scope == error_mark_node)
1992 error ("invalid qualifying scope in pseudo-destructor name");
1993 return error_mark_node;
1995 if (scope && TYPE_P (scope) && !check_dtor_name (scope, destructor))
1997 error ("qualified type %qT does not match destructor name ~%qT",
1999 return error_mark_node;
2003 /* [expr.pseudo] says both:
2005 The type designated by the pseudo-destructor-name shall be
2006 the same as the object type.
2010 The cv-unqualified versions of the object type and of the
2011 type designated by the pseudo-destructor-name shall be the
2014 We implement the more generous second sentence, since that is
2015 what most other compilers do. */
2016 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object),
2019 error ("%qE is not of type %qT", object, destructor);
2020 return error_mark_node;
2024 return build3 (PSEUDO_DTOR_EXPR, void_type_node, object, scope, destructor);
2027 /* Finish an expression of the form CODE EXPR. */
2030 finish_unary_op_expr (enum tree_code code, tree expr)
2032 tree result = build_x_unary_op (code, expr);
2033 /* Inside a template, build_x_unary_op does not fold the
2034 expression. So check whether the result is folded before
2035 setting TREE_NEGATED_INT. */
2036 if (code == NEGATE_EXPR && TREE_CODE (expr) == INTEGER_CST
2037 && TREE_CODE (result) == INTEGER_CST
2038 && !TYPE_UNSIGNED (TREE_TYPE (result))
2039 && INT_CST_LT (result, integer_zero_node))
2041 /* RESULT may be a cached INTEGER_CST, so we must copy it before
2042 setting TREE_NEGATED_INT. */
2043 result = copy_node (result);
2044 TREE_NEGATED_INT (result) = 1;
2046 if (TREE_OVERFLOW_P (result) && !TREE_OVERFLOW_P (expr))
2047 overflow_warning (result);
2052 /* Finish a compound-literal expression. TYPE is the type to which
2053 the INITIALIZER_LIST is being cast. */
2056 finish_compound_literal (tree type, VEC(constructor_elt,gc) *initializer_list)
2059 tree compound_literal;
2061 if (!TYPE_OBJ_P (type))
2063 error ("compound literal of non-object type %qT", type);
2064 return error_mark_node;
2067 /* Build a CONSTRUCTOR for the INITIALIZER_LIST. */
2068 compound_literal = build_constructor (NULL_TREE, initializer_list);
2069 if (processing_template_decl)
2071 TREE_TYPE (compound_literal) = type;
2072 /* Mark the expression as a compound literal. */
2073 TREE_HAS_CONSTRUCTOR (compound_literal) = 1;
2074 return compound_literal;
2077 /* Create a temporary variable to represent the compound literal. */
2078 var = create_temporary_var (type);
2079 if (!current_function_decl)
2081 /* If this compound-literal appears outside of a function, then
2082 the corresponding variable has static storage duration, just
2083 like the variable in whose initializer it appears. */
2084 TREE_STATIC (var) = 1;
2085 /* The variable has internal linkage, since there is no need to
2086 reference it from another translation unit. */
2087 TREE_PUBLIC (var) = 0;
2088 /* It must have a name, so that the name mangler can mangle it. */
2089 DECL_NAME (var) = make_anon_name ();
2091 /* We must call pushdecl, since the gimplifier complains if the
2092 variable has not been declared via a BIND_EXPR. */
2094 /* Initialize the variable as we would any other variable with a
2095 brace-enclosed initializer. */
2096 cp_finish_decl (var, compound_literal,
2097 /*init_const_expr_p=*/false,
2098 /*asmspec_tree=*/NULL_TREE,
2099 LOOKUP_ONLYCONVERTING);
2103 /* Return the declaration for the function-name variable indicated by
2107 finish_fname (tree id)
2111 decl = fname_decl (C_RID_CODE (id), id);
2112 if (processing_template_decl)
2113 decl = DECL_NAME (decl);
2117 /* Finish a translation unit. */
2120 finish_translation_unit (void)
2122 /* In case there were missing closebraces,
2123 get us back to the global binding level. */
2125 while (current_namespace != global_namespace)
2128 /* Do file scope __FUNCTION__ et al. */
2129 finish_fname_decls ();
2132 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
2133 Returns the parameter. */
2136 finish_template_type_parm (tree aggr, tree identifier)
2138 if (aggr != class_type_node)
2140 pedwarn ("template type parameters must use the keyword %<class%> or %<typename%>");
2141 aggr = class_type_node;
2144 return build_tree_list (aggr, identifier);
2147 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
2148 Returns the parameter. */
2151 finish_template_template_parm (tree aggr, tree identifier)
2153 tree decl = build_decl (TYPE_DECL, identifier, NULL_TREE);
2154 tree tmpl = build_lang_decl (TEMPLATE_DECL, identifier, NULL_TREE);
2155 DECL_TEMPLATE_PARMS (tmpl) = current_template_parms;
2156 DECL_TEMPLATE_RESULT (tmpl) = decl;
2157 DECL_ARTIFICIAL (decl) = 1;
2158 end_template_decl ();
2160 gcc_assert (DECL_TEMPLATE_PARMS (tmpl));
2162 return finish_template_type_parm (aggr, tmpl);
2165 /* ARGUMENT is the default-argument value for a template template
2166 parameter. If ARGUMENT is invalid, issue error messages and return
2167 the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
2170 check_template_template_default_arg (tree argument)
2172 if (TREE_CODE (argument) != TEMPLATE_DECL
2173 && TREE_CODE (argument) != TEMPLATE_TEMPLATE_PARM
2174 && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
2176 if (TREE_CODE (argument) == TYPE_DECL)
2177 error ("invalid use of type %qT as a default value for a template "
2178 "template-parameter", TREE_TYPE (argument));
2180 error ("invalid default argument for a template template parameter");
2181 return error_mark_node;
2187 /* Begin a class definition, as indicated by T. */
2190 begin_class_definition (tree t, tree attributes)
2192 if (t == error_mark_node)
2193 return error_mark_node;
2195 if (processing_template_parmlist)
2197 error ("definition of %q#T inside template parameter list", t);
2198 return error_mark_node;
2200 /* A non-implicit typename comes from code like:
2202 template <typename T> struct A {
2203 template <typename U> struct A<T>::B ...
2205 This is erroneous. */
2206 else if (TREE_CODE (t) == TYPENAME_TYPE)
2208 error ("invalid definition of qualified type %qT", t);
2209 t = error_mark_node;
2212 if (t == error_mark_node || ! IS_AGGR_TYPE (t))
2214 t = make_aggr_type (RECORD_TYPE);
2215 pushtag (make_anon_name (), t, /*tag_scope=*/ts_current);
2218 /* Update the location of the decl. */
2219 DECL_SOURCE_LOCATION (TYPE_NAME (t)) = input_location;
2221 if (TYPE_BEING_DEFINED (t))
2223 t = make_aggr_type (TREE_CODE (t));
2224 pushtag (TYPE_IDENTIFIER (t), t, /*tag_scope=*/ts_current);
2226 maybe_process_partial_specialization (t);
2228 TYPE_BEING_DEFINED (t) = 1;
2230 cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
2232 if (flag_pack_struct)
2235 TYPE_PACKED (t) = 1;
2236 /* Even though the type is being defined for the first time
2237 here, there might have been a forward declaration, so there
2238 might be cv-qualified variants of T. */
2239 for (v = TYPE_NEXT_VARIANT (t); v; v = TYPE_NEXT_VARIANT (v))
2240 TYPE_PACKED (v) = 1;
2242 /* Reset the interface data, at the earliest possible
2243 moment, as it might have been set via a class foo;
2245 if (! TYPE_ANONYMOUS_P (t))
2247 struct c_fileinfo *finfo = get_fileinfo (input_filename);
2248 CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
2249 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2250 (t, finfo->interface_unknown);
2252 reset_specialization();
2254 /* Make a declaration for this class in its own scope. */
2255 build_self_reference ();
2260 /* Finish the member declaration given by DECL. */
2263 finish_member_declaration (tree decl)
2265 if (decl == error_mark_node || decl == NULL_TREE)
2268 if (decl == void_type_node)
2269 /* The COMPONENT was a friend, not a member, and so there's
2270 nothing for us to do. */
2273 /* We should see only one DECL at a time. */
2274 gcc_assert (TREE_CHAIN (decl) == NULL_TREE);
2276 /* Set up access control for DECL. */
2278 = (current_access_specifier == access_private_node);
2279 TREE_PROTECTED (decl)
2280 = (current_access_specifier == access_protected_node);
2281 if (TREE_CODE (decl) == TEMPLATE_DECL)
2283 TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl)) = TREE_PRIVATE (decl);
2284 TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl)) = TREE_PROTECTED (decl);
2287 /* Mark the DECL as a member of the current class. */
2288 DECL_CONTEXT (decl) = current_class_type;
2290 /* Check for bare parameter packs in the member variable declaration. */
2291 if (TREE_CODE (decl) == FIELD_DECL
2292 && !check_for_bare_parameter_packs (TREE_TYPE (decl)))
2293 TREE_TYPE (decl) = error_mark_node;
2297 A C language linkage is ignored for the names of class members
2298 and the member function type of class member functions. */
2299 if (DECL_LANG_SPECIFIC (decl) && DECL_LANGUAGE (decl) == lang_c)
2300 SET_DECL_LANGUAGE (decl, lang_cplusplus);
2302 /* Put functions on the TYPE_METHODS list and everything else on the
2303 TYPE_FIELDS list. Note that these are built up in reverse order.
2304 We reverse them (to obtain declaration order) in finish_struct. */
2305 if (TREE_CODE (decl) == FUNCTION_DECL
2306 || DECL_FUNCTION_TEMPLATE_P (decl))
2308 /* We also need to add this function to the
2309 CLASSTYPE_METHOD_VEC. */
2310 if (add_method (current_class_type, decl, NULL_TREE))
2312 TREE_CHAIN (decl) = TYPE_METHODS (current_class_type);
2313 TYPE_METHODS (current_class_type) = decl;
2315 maybe_add_class_template_decl_list (current_class_type, decl,
2319 /* Enter the DECL into the scope of the class. */
2320 else if ((TREE_CODE (decl) == USING_DECL && !DECL_DEPENDENT_P (decl))
2321 || pushdecl_class_level (decl))
2323 /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
2324 go at the beginning. The reason is that lookup_field_1
2325 searches the list in order, and we want a field name to
2326 override a type name so that the "struct stat hack" will
2327 work. In particular:
2329 struct S { enum E { }; int E } s;
2332 is valid. In addition, the FIELD_DECLs must be maintained in
2333 declaration order so that class layout works as expected.
2334 However, we don't need that order until class layout, so we
2335 save a little time by putting FIELD_DECLs on in reverse order
2336 here, and then reversing them in finish_struct_1. (We could
2337 also keep a pointer to the correct insertion points in the
2340 if (TREE_CODE (decl) == TYPE_DECL)
2341 TYPE_FIELDS (current_class_type)
2342 = chainon (TYPE_FIELDS (current_class_type), decl);
2345 TREE_CHAIN (decl) = TYPE_FIELDS (current_class_type);
2346 TYPE_FIELDS (current_class_type) = decl;
2349 maybe_add_class_template_decl_list (current_class_type, decl,
2354 note_decl_for_pch (decl);
2357 /* DECL has been declared while we are building a PCH file. Perform
2358 actions that we might normally undertake lazily, but which can be
2359 performed now so that they do not have to be performed in
2360 translation units which include the PCH file. */
2363 note_decl_for_pch (tree decl)
2365 gcc_assert (pch_file);
2367 /* There's a good chance that we'll have to mangle names at some
2368 point, even if only for emission in debugging information. */
2369 if ((TREE_CODE (decl) == VAR_DECL
2370 || TREE_CODE (decl) == FUNCTION_DECL)
2371 && !processing_template_decl)
2375 /* Finish processing a complete template declaration. The PARMS are
2376 the template parameters. */
2379 finish_template_decl (tree parms)
2382 end_template_decl ();
2384 end_specialization ();
2387 /* Finish processing a template-id (which names a type) of the form
2388 NAME < ARGS >. Return the TYPE_DECL for the type named by the
2389 template-id. If ENTERING_SCOPE is nonzero we are about to enter
2390 the scope of template-id indicated. */
2393 finish_template_type (tree name, tree args, int entering_scope)
2397 decl = lookup_template_class (name, args,
2398 NULL_TREE, NULL_TREE, entering_scope,
2399 tf_warning_or_error | tf_user);
2400 if (decl != error_mark_node)
2401 decl = TYPE_STUB_DECL (decl);
2406 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
2407 Return a TREE_LIST containing the ACCESS_SPECIFIER and the
2408 BASE_CLASS, or NULL_TREE if an error occurred. The
2409 ACCESS_SPECIFIER is one of
2410 access_{default,public,protected_private}_node. For a virtual base
2411 we set TREE_TYPE. */
2414 finish_base_specifier (tree base, tree access, bool virtual_p)
2418 if (base == error_mark_node)
2420 error ("invalid base-class specification");
2423 else if (! is_aggr_type (base, 1))
2427 if (cp_type_quals (base) != 0)
2429 error ("base class %qT has cv qualifiers", base);
2430 base = TYPE_MAIN_VARIANT (base);
2432 result = build_tree_list (access, base);
2434 TREE_TYPE (result) = integer_type_node;
2440 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is
2441 what we found when we tried to do the lookup. */
2444 qualified_name_lookup_error (tree scope, tree name, tree decl)
2446 if (scope == error_mark_node)
2447 ; /* We already complained. */
2448 else if (TYPE_P (scope))
2450 if (!COMPLETE_TYPE_P (scope))
2451 error ("incomplete type %qT used in nested name specifier", scope);
2452 else if (TREE_CODE (decl) == TREE_LIST)
2454 error ("reference to %<%T::%D%> is ambiguous", scope, name);
2455 print_candidates (decl);
2458 error ("%qD is not a member of %qT", name, scope);
2460 else if (scope != global_namespace)
2461 error ("%qD is not a member of %qD", name, scope);
2463 error ("%<::%D%> has not been declared", name);
2466 /* If FNS is a member function, a set of member functions, or a
2467 template-id referring to one or more member functions, return a
2468 BASELINK for FNS, incorporating the current access context.
2469 Otherwise, return FNS unchanged. */
2472 baselink_for_fns (tree fns)
2477 if (BASELINK_P (fns)
2478 || error_operand_p (fns))
2482 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2483 fn = TREE_OPERAND (fn, 0);
2484 fn = get_first_fn (fn);
2485 if (!DECL_FUNCTION_MEMBER_P (fn))
2488 cl = currently_open_derived_class (DECL_CONTEXT (fn));
2490 cl = DECL_CONTEXT (fn);
2491 cl = TYPE_BINFO (cl);
2492 return build_baselink (cl, cl, fns, /*optype=*/NULL_TREE);
2495 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
2496 id-expression. (See cp_parser_id_expression for details.) SCOPE,
2497 if non-NULL, is the type or namespace used to explicitly qualify
2498 ID_EXPRESSION. DECL is the entity to which that name has been
2501 *CONSTANT_EXPRESSION_P is true if we are presently parsing a
2502 constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
2503 be set to true if this expression isn't permitted in a
2504 constant-expression, but it is otherwise not set by this function.
2505 *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
2506 constant-expression, but a non-constant expression is also
2509 DONE is true if this expression is a complete postfix-expression;
2510 it is false if this expression is followed by '->', '[', '(', etc.
2511 ADDRESS_P is true iff this expression is the operand of '&'.
2512 TEMPLATE_P is true iff the qualified-id was of the form
2513 "A::template B". TEMPLATE_ARG_P is true iff this qualified name
2514 appears as a template argument.
2516 If an error occurs, and it is the kind of error that might cause
2517 the parser to abort a tentative parse, *ERROR_MSG is filled in. It
2518 is the caller's responsibility to issue the message. *ERROR_MSG
2519 will be a string with static storage duration, so the caller need
2522 Return an expression for the entity, after issuing appropriate
2523 diagnostics. This function is also responsible for transforming a
2524 reference to a non-static member into a COMPONENT_REF that makes
2525 the use of "this" explicit.
2527 Upon return, *IDK will be filled in appropriately. */
2530 finish_id_expression (tree id_expression,
2534 bool integral_constant_expression_p,
2535 bool allow_non_integral_constant_expression_p,
2536 bool *non_integral_constant_expression_p,
2540 bool template_arg_p,
2541 const char **error_msg)
2543 /* Initialize the output parameters. */
2544 *idk = CP_ID_KIND_NONE;
2547 if (id_expression == error_mark_node)
2548 return error_mark_node;
2549 /* If we have a template-id, then no further lookup is
2550 required. If the template-id was for a template-class, we
2551 will sometimes have a TYPE_DECL at this point. */
2552 else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2553 || TREE_CODE (decl) == TYPE_DECL)
2555 /* Look up the name. */
2558 if (decl == error_mark_node)
2560 /* Name lookup failed. */
2563 || (!dependent_type_p (scope)
2564 && !(TREE_CODE (id_expression) == IDENTIFIER_NODE
2565 && IDENTIFIER_TYPENAME_P (id_expression)
2566 && dependent_type_p (TREE_TYPE (id_expression))))))
2568 /* If the qualifying type is non-dependent (and the name
2569 does not name a conversion operator to a dependent
2570 type), issue an error. */
2571 qualified_name_lookup_error (scope, id_expression, decl);
2572 return error_mark_node;
2576 /* It may be resolved via Koenig lookup. */
2577 *idk = CP_ID_KIND_UNQUALIFIED;
2578 return id_expression;
2581 decl = id_expression;
2583 /* If DECL is a variable that would be out of scope under
2584 ANSI/ISO rules, but in scope in the ARM, name lookup
2585 will succeed. Issue a diagnostic here. */
2587 decl = check_for_out_of_scope_variable (decl);
2589 /* Remember that the name was used in the definition of
2590 the current class so that we can check later to see if
2591 the meaning would have been different after the class
2592 was entirely defined. */
2593 if (!scope && decl != error_mark_node)
2594 maybe_note_name_used_in_class (id_expression, decl);
2596 /* Disallow uses of local variables from containing functions. */
2597 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
2599 tree context = decl_function_context (decl);
2600 if (context != NULL_TREE && context != current_function_decl
2601 && ! TREE_STATIC (decl))
2603 error (TREE_CODE (decl) == VAR_DECL
2604 ? "use of %<auto%> variable from containing function"
2605 : "use of parameter from containing function");
2606 error (" %q+#D declared here", decl);
2607 return error_mark_node;
2612 /* If we didn't find anything, or what we found was a type,
2613 then this wasn't really an id-expression. */
2614 if (TREE_CODE (decl) == TEMPLATE_DECL
2615 && !DECL_FUNCTION_TEMPLATE_P (decl))
2617 *error_msg = "missing template arguments";
2618 return error_mark_node;
2620 else if (TREE_CODE (decl) == TYPE_DECL
2621 || TREE_CODE (decl) == NAMESPACE_DECL)
2623 *error_msg = "expected primary-expression";
2624 return error_mark_node;
2627 /* If the name resolved to a template parameter, there is no
2628 need to look it up again later. */
2629 if ((TREE_CODE (decl) == CONST_DECL && DECL_TEMPLATE_PARM_P (decl))
2630 || TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
2634 *idk = CP_ID_KIND_NONE;
2635 if (TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
2636 decl = TEMPLATE_PARM_DECL (decl);
2637 r = convert_from_reference (DECL_INITIAL (decl));
2639 if (integral_constant_expression_p
2640 && !dependent_type_p (TREE_TYPE (decl))
2641 && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r))))
2643 if (!allow_non_integral_constant_expression_p)
2644 error ("template parameter %qD of type %qT is not allowed in "
2645 "an integral constant expression because it is not of "
2646 "integral or enumeration type", decl, TREE_TYPE (decl));
2647 *non_integral_constant_expression_p = true;
2651 /* Similarly, we resolve enumeration constants to their
2652 underlying values. */
2653 else if (TREE_CODE (decl) == CONST_DECL)
2655 *idk = CP_ID_KIND_NONE;
2656 if (!processing_template_decl)
2658 used_types_insert (TREE_TYPE (decl));
2659 return DECL_INITIAL (decl);
2667 /* If the declaration was explicitly qualified indicate
2668 that. The semantics of `A::f(3)' are different than
2669 `f(3)' if `f' is virtual. */
2671 ? CP_ID_KIND_QUALIFIED
2672 : (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2673 ? CP_ID_KIND_TEMPLATE_ID
2674 : CP_ID_KIND_UNQUALIFIED));
2679 An id-expression is type-dependent if it contains an
2680 identifier that was declared with a dependent type.
2682 The standard is not very specific about an id-expression that
2683 names a set of overloaded functions. What if some of them
2684 have dependent types and some of them do not? Presumably,
2685 such a name should be treated as a dependent name. */
2686 /* Assume the name is not dependent. */
2687 dependent_p = false;
2688 if (!processing_template_decl)
2689 /* No names are dependent outside a template. */
2691 /* A template-id where the name of the template was not resolved
2692 is definitely dependent. */
2693 else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2694 && (TREE_CODE (TREE_OPERAND (decl, 0))
2695 == IDENTIFIER_NODE))
2697 /* For anything except an overloaded function, just check its
2699 else if (!is_overloaded_fn (decl))
2701 = dependent_type_p (TREE_TYPE (decl));
2702 /* For a set of overloaded functions, check each of the
2708 if (BASELINK_P (fns))
2709 fns = BASELINK_FUNCTIONS (fns);
2711 /* For a template-id, check to see if the template
2712 arguments are dependent. */
2713 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
2715 tree args = TREE_OPERAND (fns, 1);
2716 dependent_p = any_dependent_template_arguments_p (args);
2717 /* The functions are those referred to by the
2719 fns = TREE_OPERAND (fns, 0);
2722 /* If there are no dependent template arguments, go through
2723 the overloaded functions. */
2724 while (fns && !dependent_p)
2726 tree fn = OVL_CURRENT (fns);
2728 /* Member functions of dependent classes are
2730 if (TREE_CODE (fn) == FUNCTION_DECL
2731 && type_dependent_expression_p (fn))
2733 else if (TREE_CODE (fn) == TEMPLATE_DECL
2734 && dependent_template_p (fn))
2737 fns = OVL_NEXT (fns);
2741 /* If the name was dependent on a template parameter, we will
2742 resolve the name at instantiation time. */
2745 /* Create a SCOPE_REF for qualified names, if the scope is
2749 /* Since this name was dependent, the expression isn't
2750 constant -- yet. No error is issued because it might
2751 be constant when things are instantiated. */
2752 if (integral_constant_expression_p)
2753 *non_integral_constant_expression_p = true;
2756 if (address_p && done)
2757 decl = finish_qualified_id_expr (scope, decl,
2761 else if (dependent_type_p (scope))
2762 decl = build_qualified_name (/*type=*/NULL_TREE,
2766 else if (DECL_P (decl))
2767 decl = build_qualified_name (TREE_TYPE (decl),
2772 if (TREE_TYPE (decl))
2773 decl = convert_from_reference (decl);
2776 /* A TEMPLATE_ID already contains all the information we
2778 if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR)
2779 return id_expression;
2780 *idk = CP_ID_KIND_UNQUALIFIED_DEPENDENT;
2781 /* If we found a variable, then name lookup during the
2782 instantiation will always resolve to the same VAR_DECL
2783 (or an instantiation thereof). */
2784 if (TREE_CODE (decl) == VAR_DECL
2785 || TREE_CODE (decl) == PARM_DECL)
2786 return convert_from_reference (decl);
2787 /* The same is true for FIELD_DECL, but we also need to
2788 make sure that the syntax is correct. */
2789 else if (TREE_CODE (decl) == FIELD_DECL)
2791 /* Since SCOPE is NULL here, this is an unqualified name.
2792 Access checking has been performed during name lookup
2793 already. Turn off checking to avoid duplicate errors. */
2794 push_deferring_access_checks (dk_no_check);
2795 decl = finish_non_static_data_member
2796 (decl, current_class_ref,
2797 /*qualifying_scope=*/NULL_TREE);
2798 pop_deferring_access_checks ();
2801 return id_expression;
2804 /* Only certain kinds of names are allowed in constant
2805 expression. Enumerators and template parameters have already
2806 been handled above. */
2807 if (integral_constant_expression_p
2808 && ! DECL_INTEGRAL_CONSTANT_VAR_P (decl)
2809 && ! builtin_valid_in_constant_expr_p (decl))
2811 if (!allow_non_integral_constant_expression_p)
2813 error ("%qD cannot appear in a constant-expression", decl);
2814 return error_mark_node;
2816 *non_integral_constant_expression_p = true;
2819 if (TREE_CODE (decl) == NAMESPACE_DECL)
2821 error ("use of namespace %qD as expression", decl);
2822 return error_mark_node;
2824 else if (DECL_CLASS_TEMPLATE_P (decl))
2826 error ("use of class template %qT as expression", decl);
2827 return error_mark_node;
2829 else if (TREE_CODE (decl) == TREE_LIST)
2831 /* Ambiguous reference to base members. */
2832 error ("request for member %qD is ambiguous in "
2833 "multiple inheritance lattice", id_expression);
2834 print_candidates (decl);
2835 return error_mark_node;
2838 /* Mark variable-like entities as used. Functions are similarly
2839 marked either below or after overload resolution. */
2840 if (TREE_CODE (decl) == VAR_DECL
2841 || TREE_CODE (decl) == PARM_DECL
2842 || TREE_CODE (decl) == RESULT_DECL)
2847 decl = (adjust_result_of_qualified_name_lookup
2848 (decl, scope, current_class_type));
2850 if (TREE_CODE (decl) == FUNCTION_DECL)
2853 if (TREE_CODE (decl) == FIELD_DECL || BASELINK_P (decl))
2854 decl = finish_qualified_id_expr (scope,
2862 tree r = convert_from_reference (decl);
2864 if (processing_template_decl && TYPE_P (scope))
2865 r = build_qualified_name (TREE_TYPE (r),
2871 else if (TREE_CODE (decl) == FIELD_DECL)
2873 /* Since SCOPE is NULL here, this is an unqualified name.
2874 Access checking has been performed during name lookup
2875 already. Turn off checking to avoid duplicate errors. */
2876 push_deferring_access_checks (dk_no_check);
2877 decl = finish_non_static_data_member (decl, current_class_ref,
2878 /*qualifying_scope=*/NULL_TREE);
2879 pop_deferring_access_checks ();
2881 else if (is_overloaded_fn (decl))
2886 if (TREE_CODE (first_fn) == TEMPLATE_ID_EXPR)
2887 first_fn = TREE_OPERAND (first_fn, 0);
2888 first_fn = get_first_fn (first_fn);
2889 if (TREE_CODE (first_fn) == TEMPLATE_DECL)
2890 first_fn = DECL_TEMPLATE_RESULT (first_fn);
2892 if (!really_overloaded_fn (decl))
2893 mark_used (first_fn);
2896 && TREE_CODE (first_fn) == FUNCTION_DECL
2897 && DECL_FUNCTION_MEMBER_P (first_fn)
2898 && !shared_member_p (decl))
2900 /* A set of member functions. */
2901 decl = maybe_dummy_object (DECL_CONTEXT (first_fn), 0);
2902 return finish_class_member_access_expr (decl, id_expression,
2903 /*template_p=*/false);
2906 decl = baselink_for_fns (decl);
2910 if (DECL_P (decl) && DECL_NONLOCAL (decl)
2911 && DECL_CLASS_SCOPE_P (decl)
2912 && DECL_CONTEXT (decl) != current_class_type)
2916 path = currently_open_derived_class (DECL_CONTEXT (decl));
2917 perform_or_defer_access_check (TYPE_BINFO (path), decl, decl);
2920 decl = convert_from_reference (decl);
2924 if (TREE_DEPRECATED (decl))
2925 warn_deprecated_use (decl);
2930 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
2931 use as a type-specifier. */
2934 finish_typeof (tree expr)
2938 if (type_dependent_expression_p (expr))
2940 type = make_aggr_type (TYPEOF_TYPE);
2941 TYPEOF_TYPE_EXPR (type) = expr;
2942 SET_TYPE_STRUCTURAL_EQUALITY (type);
2947 type = unlowered_expr_type (expr);
2949 if (!type || type == unknown_type_node)
2951 error ("type of %qE is unknown", expr);
2952 return error_mark_node;
2958 /* Perform C++-specific checks for __builtin_offsetof before calling
2962 finish_offsetof (tree expr)
2964 if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
2966 error ("cannot apply %<offsetof%> to destructor %<~%T%>",
2967 TREE_OPERAND (expr, 2));
2968 return error_mark_node;
2970 if (TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE
2971 || TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE
2972 || TREE_CODE (TREE_TYPE (expr)) == UNKNOWN_TYPE)
2974 if (TREE_CODE (expr) == COMPONENT_REF
2975 || TREE_CODE (expr) == COMPOUND_EXPR)
2976 expr = TREE_OPERAND (expr, 1);
2977 error ("cannot apply %<offsetof%> to member function %qD", expr);
2978 return error_mark_node;
2980 return fold_offsetof (expr, NULL_TREE);
2983 /* Called from expand_body via walk_tree. Replace all AGGR_INIT_EXPRs
2984 with equivalent CALL_EXPRs. */
2987 simplify_aggr_init_exprs_r (tree* tp,
2989 void* data ATTRIBUTE_UNUSED)
2991 /* We don't need to walk into types; there's nothing in a type that
2992 needs simplification. (And, furthermore, there are places we
2993 actively don't want to go. For example, we don't want to wander
2994 into the default arguments for a FUNCTION_DECL that appears in a
3001 /* Only AGGR_INIT_EXPRs are interesting. */
3002 else if (TREE_CODE (*tp) != AGGR_INIT_EXPR)
3005 simplify_aggr_init_expr (tp);
3007 /* Keep iterating. */
3011 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
3012 function is broken out from the above for the benefit of the tree-ssa
3016 simplify_aggr_init_expr (tree *tp)
3018 tree aggr_init_expr = *tp;
3020 /* Form an appropriate CALL_EXPR. */
3021 tree fn = AGGR_INIT_EXPR_FN (aggr_init_expr);
3022 tree slot = AGGR_INIT_EXPR_SLOT (aggr_init_expr);
3023 tree type = TREE_TYPE (slot);
3026 enum style_t { ctor, arg, pcc } style;
3028 if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr))
3030 #ifdef PCC_STATIC_STRUCT_RETURN
3036 gcc_assert (TREE_ADDRESSABLE (type));
3040 call_expr = build_call_array (TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
3042 aggr_init_expr_nargs (aggr_init_expr),
3043 AGGR_INIT_EXPR_ARGP (aggr_init_expr));
3047 /* Replace the first argument to the ctor with the address of the
3049 cxx_mark_addressable (slot);
3050 CALL_EXPR_ARG (call_expr, 0) =
3051 build1 (ADDR_EXPR, build_pointer_type (type), slot);
3053 else if (style == arg)
3055 /* Just mark it addressable here, and leave the rest to
3056 expand_call{,_inline}. */
3057 cxx_mark_addressable (slot);
3058 CALL_EXPR_RETURN_SLOT_OPT (call_expr) = true;
3059 call_expr = build2 (MODIFY_EXPR, TREE_TYPE (call_expr), slot, call_expr);
3061 else if (style == pcc)
3063 /* If we're using the non-reentrant PCC calling convention, then we
3064 need to copy the returned value out of the static buffer into the
3066 push_deferring_access_checks (dk_no_check);
3067 call_expr = build_aggr_init (slot, call_expr,
3068 DIRECT_BIND | LOOKUP_ONLYCONVERTING);
3069 pop_deferring_access_checks ();
3070 call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (slot), call_expr, slot);
3076 /* Emit all thunks to FN that should be emitted when FN is emitted. */
3079 emit_associated_thunks (tree fn)
3081 /* When we use vcall offsets, we emit thunks with the virtual
3082 functions to which they thunk. The whole point of vcall offsets
3083 is so that you can know statically the entire set of thunks that
3084 will ever be needed for a given virtual function, thereby
3085 enabling you to output all the thunks with the function itself. */
3086 if (DECL_VIRTUAL_P (fn))
3090 for (thunk = DECL_THUNKS (fn); thunk; thunk = TREE_CHAIN (thunk))
3092 if (!THUNK_ALIAS (thunk))
3094 use_thunk (thunk, /*emit_p=*/1);
3095 if (DECL_RESULT_THUNK_P (thunk))
3099 for (probe = DECL_THUNKS (thunk);
3100 probe; probe = TREE_CHAIN (probe))
3101 use_thunk (probe, /*emit_p=*/1);
3105 gcc_assert (!DECL_THUNKS (thunk));
3110 /* Generate RTL for FN. */
3113 expand_body (tree fn)
3115 tree saved_function;
3117 /* Compute the appropriate object-file linkage for inline
3119 if (DECL_DECLARED_INLINE_P (fn))
3120 import_export_decl (fn);
3122 /* If FN is external, then there's no point in generating RTL for
3123 it. This situation can arise with an inline function under
3124 `-fexternal-templates'; we instantiate the function, even though
3125 we're not planning on emitting it, in case we get a chance to
3127 if (DECL_EXTERNAL (fn))
3130 /* ??? When is this needed? */
3131 saved_function = current_function_decl;
3133 /* Emit any thunks that should be emitted at the same time as FN. */
3134 emit_associated_thunks (fn);
3136 /* This function is only called from cgraph, or recursively from
3137 emit_associated_thunks. In neither case should we be currently
3138 generating trees for a function. */
3139 gcc_assert (function_depth == 0);
3143 current_function_decl = saved_function;
3145 if (DECL_CLONED_FUNCTION_P (fn))
3147 /* If this is a clone, go through the other clones now and mark
3148 their parameters used. We have to do that here, as we don't
3149 know whether any particular clone will be expanded, and
3150 therefore cannot pick one arbitrarily. */
3153 for (probe = TREE_CHAIN (DECL_CLONED_FUNCTION (fn));
3154 probe && DECL_CLONED_FUNCTION_P (probe);
3155 probe = TREE_CHAIN (probe))
3159 for (parms = DECL_ARGUMENTS (probe);
3160 parms; parms = TREE_CHAIN (parms))
3161 TREE_USED (parms) = 1;
3166 /* Generate RTL for FN. */
3169 expand_or_defer_fn (tree fn)
3171 /* When the parser calls us after finishing the body of a template
3172 function, we don't really want to expand the body. */
3173 if (processing_template_decl)
3175 /* Normally, collection only occurs in rest_of_compilation. So,
3176 if we don't collect here, we never collect junk generated
3177 during the processing of templates until we hit a
3178 non-template function. It's not safe to do this inside a
3179 nested class, though, as the parser may have local state that
3180 is not a GC root. */
3181 if (!function_depth)
3186 /* Replace AGGR_INIT_EXPRs with appropriate CALL_EXPRs. */
3187 walk_tree_without_duplicates (&DECL_SAVED_TREE (fn),
3188 simplify_aggr_init_exprs_r,
3191 /* If this is a constructor or destructor body, we have to clone
3193 if (maybe_clone_body (fn))
3195 /* We don't want to process FN again, so pretend we've written
3196 it out, even though we haven't. */
3197 TREE_ASM_WRITTEN (fn) = 1;
3201 /* We make a decision about linkage for these functions at the end
3202 of the compilation. Until that point, we do not want the back
3203 end to output them -- but we do want it to see the bodies of
3204 these functions so that it can inline them as appropriate. */
3205 if (DECL_DECLARED_INLINE_P (fn) || DECL_IMPLICIT_INSTANTIATION (fn))
3207 if (DECL_INTERFACE_KNOWN (fn))
3208 /* We've already made a decision as to how this function will
3212 DECL_EXTERNAL (fn) = 1;
3213 DECL_NOT_REALLY_EXTERN (fn) = 1;
3214 note_vague_linkage_fn (fn);
3215 /* A non-template inline function with external linkage will
3216 always be COMDAT. As we must eventually determine the
3217 linkage of all functions, and as that causes writes to
3218 the data mapped in from the PCH file, it's advantageous
3219 to mark the functions at this point. */
3220 if (!DECL_IMPLICIT_INSTANTIATION (fn))
3222 /* This function must have external linkage, as
3223 otherwise DECL_INTERFACE_KNOWN would have been
3225 gcc_assert (TREE_PUBLIC (fn));
3226 comdat_linkage (fn);
3227 DECL_INTERFACE_KNOWN (fn) = 1;
3231 import_export_decl (fn);
3233 /* If the user wants us to keep all inline functions, then mark
3234 this function as needed so that finish_file will make sure to
3236 if (flag_keep_inline_functions && DECL_DECLARED_INLINE_P (fn))
3240 /* There's no reason to do any of the work here if we're only doing
3241 semantic analysis; this code just generates RTL. */
3242 if (flag_syntax_only)
3247 /* Expand or defer, at the whim of the compilation unit manager. */
3248 cgraph_finalize_function (fn, function_depth > 1);
3260 /* Helper function for walk_tree, used by finalize_nrv below. */
3263 finalize_nrv_r (tree* tp, int* walk_subtrees, void* data)
3265 struct nrv_data *dp = (struct nrv_data *)data;
3268 /* No need to walk into types. There wouldn't be any need to walk into
3269 non-statements, except that we have to consider STMT_EXPRs. */
3272 /* Change all returns to just refer to the RESULT_DECL; this is a nop,
3273 but differs from using NULL_TREE in that it indicates that we care
3274 about the value of the RESULT_DECL. */
3275 else if (TREE_CODE (*tp) == RETURN_EXPR)
3276 TREE_OPERAND (*tp, 0) = dp->result;
3277 /* Change all cleanups for the NRV to only run when an exception is
3279 else if (TREE_CODE (*tp) == CLEANUP_STMT
3280 && CLEANUP_DECL (*tp) == dp->var)
3281 CLEANUP_EH_ONLY (*tp) = 1;
3282 /* Replace the DECL_EXPR for the NRV with an initialization of the
3283 RESULT_DECL, if needed. */
3284 else if (TREE_CODE (*tp) == DECL_EXPR
3285 && DECL_EXPR_DECL (*tp) == dp->var)
3288 if (DECL_INITIAL (dp->var)
3289 && DECL_INITIAL (dp->var) != error_mark_node)
3291 init = build2 (INIT_EXPR, void_type_node, dp->result,
3292 DECL_INITIAL (dp->var));
3293 DECL_INITIAL (dp->var) = error_mark_node;
3296 init = build_empty_stmt ();
3297 SET_EXPR_LOCUS (init, EXPR_LOCUS (*tp));
3300 /* And replace all uses of the NRV with the RESULT_DECL. */
3301 else if (*tp == dp->var)
3304 /* Avoid walking into the same tree more than once. Unfortunately, we
3305 can't just use walk_tree_without duplicates because it would only call
3306 us for the first occurrence of dp->var in the function body. */
3307 slot = htab_find_slot (dp->visited, *tp, INSERT);
3313 /* Keep iterating. */
3317 /* Called from finish_function to implement the named return value
3318 optimization by overriding all the RETURN_EXPRs and pertinent
3319 CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
3320 RESULT_DECL for the function. */
3323 finalize_nrv (tree *tp, tree var, tree result)
3325 struct nrv_data data;
3327 /* Copy debugging information from VAR to RESULT. */
3328 DECL_NAME (result) = DECL_NAME (var);
3329 DECL_ARTIFICIAL (result) = DECL_ARTIFICIAL (var);
3330 DECL_IGNORED_P (result) = DECL_IGNORED_P (var);
3331 DECL_SOURCE_LOCATION (result) = DECL_SOURCE_LOCATION (var);
3332 DECL_ABSTRACT_ORIGIN (result) = DECL_ABSTRACT_ORIGIN (var);
3333 /* Don't forget that we take its address. */
3334 TREE_ADDRESSABLE (result) = TREE_ADDRESSABLE (var);
3337 data.result = result;
3338 data.visited = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
3339 walk_tree (tp, finalize_nrv_r, &data, 0);
3340 htab_delete (data.visited);
3343 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
3344 Remove any elements from the list that are invalid. */
3347 finish_omp_clauses (tree clauses)
3349 bitmap_head generic_head, firstprivate_head, lastprivate_head;
3350 tree c, t, *pc = &clauses;
3353 bitmap_obstack_initialize (NULL);
3354 bitmap_initialize (&generic_head, &bitmap_default_obstack);
3355 bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
3356 bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);
3358 for (pc = &clauses, c = clauses; c ; c = *pc)
3360 bool remove = false;
3362 switch (OMP_CLAUSE_CODE (c))
3364 case OMP_CLAUSE_SHARED:
3366 goto check_dup_generic;
3367 case OMP_CLAUSE_PRIVATE:
3369 goto check_dup_generic;
3370 case OMP_CLAUSE_REDUCTION:
3372 goto check_dup_generic;
3373 case OMP_CLAUSE_COPYPRIVATE:
3374 name = "copyprivate";
3375 goto check_dup_generic;
3376 case OMP_CLAUSE_COPYIN:
3378 goto check_dup_generic;
3380 t = OMP_CLAUSE_DECL (c);
3381 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3383 if (processing_template_decl)
3386 error ("%qD is not a variable in clause %qs", t, name);
3388 error ("%qE is not a variable in clause %qs", t, name);
3391 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
3392 || bitmap_bit_p (&firstprivate_head, DECL_UID (t))
3393 || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
3395 error ("%qD appears more than once in data clauses", t);
3399 bitmap_set_bit (&generic_head, DECL_UID (t));
3402 case OMP_CLAUSE_FIRSTPRIVATE:
3403 t = OMP_CLAUSE_DECL (c);
3404 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3406 if (processing_template_decl)
3408 error ("%qE is not a variable in clause %<firstprivate%>", t);
3411 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
3412 || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
3414 error ("%qE appears more than once in data clauses", t);
3418 bitmap_set_bit (&firstprivate_head, DECL_UID (t));
3421 case OMP_CLAUSE_LASTPRIVATE:
3422 t = OMP_CLAUSE_DECL (c);
3423 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3425 if (processing_template_decl)
3427 error ("%qE is not a variable in clause %<lastprivate%>", t);
3430 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
3431 || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
3433 error ("%qE appears more than once in data clauses", t);
3437 bitmap_set_bit (&lastprivate_head, DECL_UID (t));
3441 t = OMP_CLAUSE_IF_EXPR (c);
3442 t = maybe_convert_cond (t);
3443 if (t == error_mark_node)
3445 OMP_CLAUSE_IF_EXPR (c) = t;
3448 case OMP_CLAUSE_NUM_THREADS:
3449 t = OMP_CLAUSE_NUM_THREADS_EXPR (c);
3450 if (t == error_mark_node)
3452 else if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
3453 && !type_dependent_expression_p (t))
3455 error ("num_threads expression must be integral");
3460 case OMP_CLAUSE_SCHEDULE:
3461 t = OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c);
3464 else if (t == error_mark_node)
3466 else if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
3467 && !type_dependent_expression_p (t))
3469 error ("schedule chunk size expression must be integral");
3474 case OMP_CLAUSE_NOWAIT:
3475 case OMP_CLAUSE_ORDERED:
3476 case OMP_CLAUSE_DEFAULT:
3484 *pc = OMP_CLAUSE_CHAIN (c);
3486 pc = &OMP_CLAUSE_CHAIN (c);
3489 for (pc = &clauses, c = clauses; c ; c = *pc)
3491 enum tree_code c_kind = OMP_CLAUSE_CODE (c);
3492 bool remove = false;
3493 bool need_complete_non_reference = false;
3494 bool need_default_ctor = false;
3495 bool need_copy_ctor = false;
3496 bool need_copy_assignment = false;
3497 bool need_implicitly_determined = false;
3498 tree type, inner_type;
3502 case OMP_CLAUSE_SHARED:
3504 need_implicitly_determined = true;
3506 case OMP_CLAUSE_PRIVATE:
3508 need_complete_non_reference = true;
3509 need_default_ctor = true;
3510 need_implicitly_determined = true;
3512 case OMP_CLAUSE_FIRSTPRIVATE:
3513 name = "firstprivate";
3514 need_complete_non_reference = true;
3515 need_copy_ctor = true;
3516 need_implicitly_determined = true;
3518 case OMP_CLAUSE_LASTPRIVATE:
3519 name = "lastprivate";
3520 need_complete_non_reference = true;
3521 need_copy_assignment = true;
3522 need_implicitly_determined = true;
3524 case OMP_CLAUSE_REDUCTION:
3526 need_implicitly_determined = true;
3528 case OMP_CLAUSE_COPYPRIVATE:
3529 name = "copyprivate";
3530 need_copy_assignment = true;
3532 case OMP_CLAUSE_COPYIN:
3534 need_copy_assignment = true;
3537 pc = &OMP_CLAUSE_CHAIN (c);
3541 t = OMP_CLAUSE_DECL (c);
3542 if (processing_template_decl
3543 && TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3545 pc = &OMP_CLAUSE_CHAIN (c);
3551 case OMP_CLAUSE_LASTPRIVATE:
3552 if (!bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
3553 need_default_ctor = true;
3556 case OMP_CLAUSE_REDUCTION:
3557 if (AGGREGATE_TYPE_P (TREE_TYPE (t))
3558 || POINTER_TYPE_P (TREE_TYPE (t)))
3560 error ("%qE has invalid type for %<reduction%>", t);
3563 else if (FLOAT_TYPE_P (TREE_TYPE (t)))
3565 enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c);
3573 error ("%qE has invalid type for %<reduction(%s)%>",
3574 t, operator_name_info[r_code].name);
3580 case OMP_CLAUSE_COPYIN:
3581 if (TREE_CODE (t) != VAR_DECL || !DECL_THREAD_LOCAL_P (t))
3583 error ("%qE must be %<threadprivate%> for %<copyin%>", t);
3592 if (need_complete_non_reference)
3594 t = require_complete_type (t);
3595 if (t == error_mark_node)
3597 else if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
3599 error ("%qE has reference type for %qs", t, name);
3603 if (need_implicitly_determined)
3605 const char *share_name = NULL;
3607 if (TREE_CODE (t) == VAR_DECL && DECL_THREAD_LOCAL_P (t))
3608 share_name = "threadprivate";
3609 else switch (cxx_omp_predetermined_sharing (t))
3611 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
3613 case OMP_CLAUSE_DEFAULT_SHARED:
3614 share_name = "shared";
3616 case OMP_CLAUSE_DEFAULT_PRIVATE:
3617 share_name = "private";
3624 error ("%qE is predetermined %qs for %qs",
3625 t, share_name, name);
3630 /* We're interested in the base element, not arrays. */
3631 inner_type = type = TREE_TYPE (t);
3632 while (TREE_CODE (inner_type) == ARRAY_TYPE)
3633 inner_type = TREE_TYPE (inner_type);
3635 /* Check for special function availability by building a call to one.
3636 Save the results, because later we won't be in the right context
3637 for making these queries. */
3638 if (CLASS_TYPE_P (inner_type)
3639 && (need_default_ctor || need_copy_ctor || need_copy_assignment)
3640 && !type_dependent_expression_p (t))
3642 int save_errorcount = errorcount;
3645 /* Always allocate 3 elements for simplicity. These are the
3646 function decls for the ctor, dtor, and assignment op.
3647 This layout is known to the three lang hooks,
3648 cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
3649 and cxx_omp_clause_assign_op. */
3650 info = make_tree_vec (3);
3651 CP_OMP_CLAUSE_INFO (c) = info;
3653 if (need_default_ctor
3655 && !TYPE_HAS_TRIVIAL_INIT_REF (inner_type)))
3657 if (need_default_ctor)
3661 t = build_int_cst (build_pointer_type (inner_type), 0);
3662 t = build1 (INDIRECT_REF, inner_type, t);
3663 t = build_tree_list (NULL, t);
3665 t = build_special_member_call (NULL_TREE,
3666 complete_ctor_identifier,
3667 t, inner_type, LOOKUP_NORMAL);
3668 t = get_callee_fndecl (t);
3669 TREE_VEC_ELT (info, 0) = t;
3672 if ((need_default_ctor || need_copy_ctor)
3673 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_type))
3675 t = build_int_cst (build_pointer_type (inner_type), 0);
3676 t = build1 (INDIRECT_REF, inner_type, t);
3677 t = build_special_member_call (t, complete_dtor_identifier,
3678 NULL, inner_type, LOOKUP_NORMAL);
3679 t = get_callee_fndecl (t);
3680 TREE_VEC_ELT (info, 1) = t;
3683 if (need_copy_assignment
3684 && !TYPE_HAS_TRIVIAL_ASSIGN_REF (inner_type))
3686 t = build_int_cst (build_pointer_type (inner_type), 0);
3687 t = build1 (INDIRECT_REF, inner_type, t);
3688 t = build_special_member_call (t, ansi_assopname (NOP_EXPR),
3689 build_tree_list (NULL, t),
3690 inner_type, LOOKUP_NORMAL);
3692 /* We'll have called convert_from_reference on the call, which
3693 may well have added an indirect_ref. It's unneeded here,
3694 and in the way, so kill it. */
3695 if (TREE_CODE (t) == INDIRECT_REF)
3696 t = TREE_OPERAND (t, 0);
3698 t = get_callee_fndecl (t);
3699 TREE_VEC_ELT (info, 2) = t;
3702 if (errorcount != save_errorcount)
3707 *pc = OMP_CLAUSE_CHAIN (c);
3709 pc = &OMP_CLAUSE_CHAIN (c);
3712 bitmap_obstack_release (NULL);
3716 /* For all variables in the tree_list VARS, mark them as thread local. */
3719 finish_omp_threadprivate (tree vars)
3723 /* Mark every variable in VARS to be assigned thread local storage. */
3724 for (t = vars; t; t = TREE_CHAIN (t))
3726 tree v = TREE_PURPOSE (t);
3728 /* If V had already been marked threadprivate, it doesn't matter
3729 whether it had been used prior to this point. */
3731 && (DECL_LANG_SPECIFIC (v) == NULL
3732 || !CP_DECL_THREADPRIVATE_P (v)))
3733 error ("%qE declared %<threadprivate%> after first use", v);
3734 else if (! TREE_STATIC (v) && ! DECL_EXTERNAL (v))
3735 error ("automatic variable %qE cannot be %<threadprivate%>", v);
3736 else if (! COMPLETE_TYPE_P (TREE_TYPE (v)))
3737 error ("%<threadprivate%> %qE has incomplete type", v);
3738 else if (TREE_STATIC (v) && TYPE_P (CP_DECL_CONTEXT (v)))
3739 error ("%<threadprivate%> %qE is not file, namespace "
3740 "or block scope variable", v);
3743 /* Allocate a LANG_SPECIFIC structure for V, if needed. */
3744 if (DECL_LANG_SPECIFIC (v) == NULL)
3746 retrofit_lang_decl (v);
3748 /* Make sure that DECL_DISCRIMINATOR_P continues to be true
3749 after the allocation of the lang_decl structure. */
3750 if (DECL_DISCRIMINATOR_P (v))
3751 DECL_LANG_SPECIFIC (v)->decl_flags.u2sel = 1;
3754 if (! DECL_THREAD_LOCAL_P (v))
3756 DECL_TLS_MODEL (v) = decl_default_tls_model (v);
3757 /* If rtl has been already set for this var, call
3758 make_decl_rtl once again, so that encode_section_info
3759 has a chance to look at the new decl flags. */
3760 if (DECL_RTL_SET_P (v))
3763 CP_DECL_THREADPRIVATE_P (v) = 1;
3768 /* Build an OpenMP structured block. */
3771 begin_omp_structured_block (void)
3773 return do_pushlevel (sk_omp);
3777 finish_omp_structured_block (tree block)
3779 return do_poplevel (block);
3782 /* Similarly, except force the retention of the BLOCK. */
3785 begin_omp_parallel (void)
3787 keep_next_level (true);
3788 return begin_omp_structured_block ();
3792 finish_omp_parallel (tree clauses, tree body)
3796 body = finish_omp_structured_block (body);
3798 stmt = make_node (OMP_PARALLEL);
3799 TREE_TYPE (stmt) = void_type_node;
3800 OMP_PARALLEL_CLAUSES (stmt) = clauses;
3801 OMP_PARALLEL_BODY (stmt) = body;
3803 return add_stmt (stmt);
3806 /* Build and validate an OMP_FOR statement. CLAUSES, BODY, COND, INCR
3807 are directly for their associated operands in the statement. DECL
3808 and INIT are a combo; if DECL is NULL then INIT ought to be a
3809 MODIFY_EXPR, and the DECL should be extracted. PRE_BODY are
3810 optional statements that need to go before the loop into its
3814 finish_omp_for (location_t locus, tree decl, tree init, tree cond,
3815 tree incr, tree body, tree pre_body)
3822 switch (TREE_CODE (init))
3825 decl = TREE_OPERAND (init, 0);
3826 init = TREE_OPERAND (init, 1);
3829 if (TREE_CODE (TREE_OPERAND (init, 1)) == NOP_EXPR)
3831 decl = TREE_OPERAND (init, 0);
3832 init = TREE_OPERAND (init, 2);
3841 error ("expected iteration declaration or initialization");
3846 if (type_dependent_expression_p (decl)
3847 || type_dependent_expression_p (init)
3848 || (cond && type_dependent_expression_p (cond))
3849 || (incr && type_dependent_expression_p (incr)))
3855 error ("%Hmissing controlling predicate", &locus);
3861 error ("%Hmissing increment expression", &locus);
3865 stmt = make_node (OMP_FOR);
3867 /* This is really just a place-holder. We'll be decomposing this
3868 again and going through the build_modify_expr path below when
3869 we instantiate the thing. */
3870 init = build2 (MODIFY_EXPR, void_type_node, decl, init);
3872 TREE_TYPE (stmt) = void_type_node;
3873 OMP_FOR_INIT (stmt) = init;
3874 OMP_FOR_COND (stmt) = cond;
3875 OMP_FOR_INCR (stmt) = incr;
3876 OMP_FOR_BODY (stmt) = body;
3877 OMP_FOR_PRE_BODY (stmt) = pre_body;
3879 SET_EXPR_LOCATION (stmt, locus);
3880 return add_stmt (stmt);
3885 error ("expected iteration declaration or initialization");
3889 if (pre_body == NULL || IS_EMPTY_STMT (pre_body))
3891 else if (! processing_template_decl)
3893 add_stmt (pre_body);
3897 init = fold_build_cleanup_point_expr (TREE_TYPE (init), init);
3898 init = build_modify_expr (decl, NOP_EXPR, init);
3899 if (cond && TREE_SIDE_EFFECTS (cond) && COMPARISON_CLASS_P (cond))
3901 int n = TREE_SIDE_EFFECTS (TREE_OPERAND (cond, 1)) != 0;
3902 tree t = TREE_OPERAND (cond, n);
3904 TREE_OPERAND (cond, n)
3905 = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
3907 omp_for = c_finish_omp_for (locus, decl, init, cond, incr, body, pre_body);
3909 && TREE_CODE (OMP_FOR_INCR (omp_for)) == MODIFY_EXPR
3910 && TREE_SIDE_EFFECTS (TREE_OPERAND (OMP_FOR_INCR (omp_for), 1))
3911 && BINARY_CLASS_P (TREE_OPERAND (OMP_FOR_INCR (omp_for), 1)))
3913 tree t = TREE_OPERAND (OMP_FOR_INCR (omp_for), 1);
3914 int n = TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)) != 0;
3917 = fold_build_cleanup_point_expr (TREE_TYPE (TREE_OPERAND (t, n)),
3918 TREE_OPERAND (t, n));
3924 finish_omp_atomic (enum tree_code code, tree lhs, tree rhs)
3928 if (processing_template_decl
3929 && (type_dependent_expression_p (lhs)
3930 || type_dependent_expression_p (rhs)))
3931 stmt = build2 (OMP_ATOMIC, void_type_node, integer_zero_node,
3932 build2 (code, void_type_node, lhs, rhs));
3935 /* Even in a template, we can detect invalid uses of the atomic
3936 pragma if neither LHS nor RHS is type-dependent. */
3937 if (processing_template_decl)
3939 lhs = build_non_dependent_expr (lhs);
3940 rhs = build_non_dependent_expr (rhs);
3943 stmt = c_finish_omp_atomic (code, lhs, rhs);
3946 if (stmt != error_mark_node)
3951 finish_omp_barrier (void)
3953 tree fn = built_in_decls[BUILT_IN_GOMP_BARRIER];
3954 tree stmt = finish_call_expr (fn, NULL, false, false);
3955 finish_expr_stmt (stmt);
3959 finish_omp_flush (void)
3961 tree fn = built_in_decls[BUILT_IN_SYNCHRONIZE];
3962 tree stmt = finish_call_expr (fn, NULL, false, false);
3963 finish_expr_stmt (stmt);
3966 /* True if OpenMP sharing attribute of DECL is predetermined. */
3968 enum omp_clause_default_kind
3969 cxx_omp_predetermined_sharing (tree decl)
3971 enum omp_clause_default_kind kind;
3973 kind = c_omp_predetermined_sharing (decl);
3974 if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
3977 /* Static data members are predetermined as shared. */
3978 if (TREE_STATIC (decl))
3980 tree ctx = CP_DECL_CONTEXT (decl);
3981 if (TYPE_P (ctx) && IS_AGGR_TYPE (ctx))
3982 return OMP_CLAUSE_DEFAULT_SHARED;
3985 return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
3989 init_cp_semantics (void)
3993 /* Build a STATIC_ASSERT for a static assertion with the condition
3994 CONDITION and the message text MESSAGE. LOCATION is the location
3995 of the static assertion in the source code. When MEMBER_P, this
3996 static assertion is a member of a class. */
3998 finish_static_assert (tree condition, tree message, location_t location,
4001 if (type_dependent_expression_p (condition)
4002 || value_dependent_expression_p (condition))
4004 /* We're in a template; build a STATIC_ASSERT and put it in
4008 assertion = make_node (STATIC_ASSERT);
4009 STATIC_ASSERT_CONDITION (assertion) = condition;
4010 STATIC_ASSERT_MESSAGE (assertion) = message;
4011 STATIC_ASSERT_SOURCE_LOCATION (assertion) = location;
4014 maybe_add_class_template_decl_list (current_class_type,
4018 add_stmt (assertion);
4023 /* Fold the expression and convert it to a boolean value. */
4024 condition = fold_non_dependent_expr (condition);
4025 condition = cp_convert (boolean_type_node, condition);
4027 if (TREE_CODE (condition) == INTEGER_CST && !integer_zerop (condition))
4028 /* Do nothing; the condition is satisfied. */
4032 location_t saved_loc = input_location;
4034 input_location = location;
4035 if (TREE_CODE (condition) == INTEGER_CST
4036 && integer_zerop (condition))
4037 /* Report the error. */
4038 error ("static assertion failed: %E", message);
4039 else if (condition && condition != error_mark_node)
4040 error ("non-constant condition for static assertion");
4041 input_location = saved_loc;
4045 /* Implements the C++0x decltype keyword. Returns the type of EXPR,
4046 suitable for use as a type-specifier.
4048 ID_EXPRESSION_OR_MEMBER_ACCESS_P is true when EXPR was parsed as an
4049 id-expression or a class member access, FALSE when it was parsed as
4050 a full expression. */
4052 finish_decltype_type (tree expr, bool id_expression_or_member_access_p)
4054 tree orig_expr = expr;
4057 if (type_dependent_expression_p (expr))
4059 type = make_aggr_type (DECLTYPE_TYPE);
4060 DECLTYPE_TYPE_EXPR (type) = expr;
4061 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type)
4062 = id_expression_or_member_access_p;
4063 SET_TYPE_STRUCTURAL_EQUALITY (type);
4068 /* The type denoted by decltype(e) is defined as follows: */
4070 if (id_expression_or_member_access_p)
4072 /* If e is an id-expression or a class member access (5.2.5
4073 [expr.ref]), decltype(e) is defined as the type of the entity
4074 named by e. If there is no such entity, or e names a set of
4075 overloaded functions, the program is ill-formed. */
4076 if (TREE_CODE (expr) == IDENTIFIER_NODE)
4077 expr = lookup_name (expr);
4079 if (TREE_CODE (expr) == INDIRECT_REF)
4080 /* This can happen when the expression is, e.g., "a.b". Just
4081 look at the underlying operand. */
4082 expr = TREE_OPERAND (expr, 0);
4084 if (TREE_CODE (expr) == OFFSET_REF
4085 || TREE_CODE (expr) == MEMBER_REF)
4086 /* We're only interested in the field itself. If it is a
4087 BASELINK, we will need to see through it in the next
4089 expr = TREE_OPERAND (expr, 1);
4091 if (TREE_CODE (expr) == BASELINK)
4092 /* See through BASELINK nodes to the underlying functions. */
4093 expr = BASELINK_FUNCTIONS (expr);
4095 if (TREE_CODE (expr) == OVERLOAD)
4097 if (OVL_CHAIN (expr))
4099 error ("%qE refers to a set of overloaded functions", orig_expr);
4100 return error_mark_node;
4103 /* An overload set containing only one function: just look
4104 at that function. */
4105 expr = OVL_FUNCTION (expr);
4108 switch (TREE_CODE (expr))
4111 if (DECL_C_BIT_FIELD (expr))
4113 type = DECL_BIT_FIELD_TYPE (expr);
4116 /* Fall through for fields that aren't bitfields. */
4123 type = TREE_TYPE (expr);
4127 type = error_mark_node;
4131 type = is_bitfield_expr_with_lowered_type (expr);
4133 type = TREE_TYPE (TREE_OPERAND (expr, 1));
4140 /* We can get here when the id-expression refers to an
4142 type = TREE_TYPE (expr);
4146 gcc_assert (TYPE_P (expr) || DECL_P (expr));
4147 error ("argument to decltype must be an expression");
4148 return error_mark_node;
4155 if (TREE_CODE (expr) == CALL_EXPR
4156 && (fndecl = get_callee_fndecl (expr))
4157 && (fndecl != error_mark_node))
4158 /* If e is a function call (5.2.2 [expr.call]) or an
4159 invocation of an overloaded operator (parentheses around e
4160 are ignored), decltype(e) is defined as the return type of
4162 type = TREE_TYPE (TREE_TYPE (fndecl));
4165 type = is_bitfield_expr_with_lowered_type (expr);
4168 /* Bitfields are special, because their type encodes the
4169 number of bits they store. If the expression referenced a
4170 bitfield, TYPE now has the declared type of that
4172 type = cp_build_qualified_type (type,
4173 cp_type_quals (TREE_TYPE (expr)));
4175 if (real_lvalue_p (expr))
4176 type = build_reference_type (type);
4180 /* Otherwise, where T is the type of e, if e is an lvalue,
4181 decltype(e) is defined as T&, otherwise decltype(e) is
4183 type = TREE_TYPE (expr);
4184 if (expr == current_class_ptr)
4185 /* If the expression is just "this", we want the
4186 cv-unqualified pointer for the "this" type. */
4187 type = TYPE_MAIN_VARIANT (type);
4188 else if (real_lvalue_p (expr))
4190 if (TREE_CODE (type) != REFERENCE_TYPE)
4191 type = build_reference_type (type);
4194 type = non_reference (type);
4199 if (!type || type == unknown_type_node)
4201 error ("type of %qE is unknown", expr);
4202 return error_mark_node;
4208 /* Called from trait_expr_value to evaluate either __has_nothrow_assign or
4209 __has_nothrow_copy, depending on assign_p. */
4212 classtype_has_nothrow_assign_or_copy_p (tree type, bool assign_p)
4219 ix = lookup_fnfields_1 (type, ansi_assopname (NOP_EXPR));
4222 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix);
4224 else if (TYPE_HAS_INIT_REF (type))
4226 /* If construction of the copy constructor was postponed, create
4228 if (CLASSTYPE_LAZY_COPY_CTOR (type))
4229 lazily_declare_fn (sfk_copy_constructor, type);
4230 fns = CLASSTYPE_CONSTRUCTORS (type);
4235 for (; fns; fns = OVL_NEXT (fns))
4236 if (!TREE_NOTHROW (OVL_CURRENT (fns)))
4242 /* Actually evaluates the trait. */
4245 trait_expr_value (cp_trait_kind kind, tree type1, tree type2)
4247 enum tree_code type_code1;
4250 type_code1 = TREE_CODE (type1);
4254 case CPTK_HAS_NOTHROW_ASSIGN:
4255 return (!CP_TYPE_CONST_P (type1) && type_code1 != REFERENCE_TYPE
4256 && (trait_expr_value (CPTK_HAS_TRIVIAL_ASSIGN, type1, type2)
4257 || (CLASS_TYPE_P (type1)
4258 && classtype_has_nothrow_assign_or_copy_p (type1,
4261 case CPTK_HAS_TRIVIAL_ASSIGN:
4262 return (!CP_TYPE_CONST_P (type1) && type_code1 != REFERENCE_TYPE
4263 && (pod_type_p (type1)
4264 || (CLASS_TYPE_P (type1)
4265 && TYPE_HAS_TRIVIAL_ASSIGN_REF (type1))));
4267 case CPTK_HAS_NOTHROW_CONSTRUCTOR:
4268 type1 = strip_array_types (type1);
4269 return (trait_expr_value (CPTK_HAS_TRIVIAL_CONSTRUCTOR, type1, type2)
4270 || (CLASS_TYPE_P (type1)
4271 && (t = locate_ctor (type1, NULL)) && TREE_NOTHROW (t)));
4273 case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
4274 type1 = strip_array_types (type1);
4275 return (pod_type_p (type1)
4276 || (CLASS_TYPE_P (type1) && TYPE_HAS_TRIVIAL_DFLT (type1)));
4278 case CPTK_HAS_NOTHROW_COPY:
4279 return (trait_expr_value (CPTK_HAS_TRIVIAL_COPY, type1, type2)
4280 || (CLASS_TYPE_P (type1)
4281 && classtype_has_nothrow_assign_or_copy_p (type1, false)));
4283 case CPTK_HAS_TRIVIAL_COPY:
4284 return (pod_type_p (type1) || type_code1 == REFERENCE_TYPE
4285 || (CLASS_TYPE_P (type1) && TYPE_HAS_TRIVIAL_INIT_REF (type1)));
4287 case CPTK_HAS_TRIVIAL_DESTRUCTOR:
4288 type1 = strip_array_types (type1);
4289 return (pod_type_p (type1)
4290 || (CLASS_TYPE_P (type1)
4291 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type1)));
4293 case CPTK_HAS_VIRTUAL_DESTRUCTOR:
4294 return (CLASS_TYPE_P (type1)
4295 && (t = locate_dtor (type1, NULL)) && DECL_VIRTUAL_P (t));
4297 case CPTK_IS_ABSTRACT:
4298 return (CLASS_TYPE_P (type1) && CLASSTYPE_PURE_VIRTUALS (type1));
4300 case CPTK_IS_BASE_OF:
4301 return (NON_UNION_CLASS_TYPE_P (type1) && NON_UNION_CLASS_TYPE_P (type2)
4302 && DERIVED_FROM_P (type1, type2));
4305 return (NON_UNION_CLASS_TYPE_P (type1));
4307 case CPTK_IS_CONVERTIBLE_TO:
4312 return (NON_UNION_CLASS_TYPE_P (type1) && CLASSTYPE_EMPTY_P (type1));
4315 return (type_code1 == ENUMERAL_TYPE);
4318 return (pod_type_p (type1));
4320 case CPTK_IS_POLYMORPHIC:
4321 return (CLASS_TYPE_P (type1) && TYPE_POLYMORPHIC_P (type1));
4324 return (type_code1 == UNION_TYPE);
4332 /* Process a trait expression. */
4335 finish_trait_expr (cp_trait_kind kind, tree type1, tree type2)
4337 gcc_assert (kind == CPTK_HAS_NOTHROW_ASSIGN
4338 || kind == CPTK_HAS_NOTHROW_CONSTRUCTOR
4339 || kind == CPTK_HAS_NOTHROW_COPY
4340 || kind == CPTK_HAS_TRIVIAL_ASSIGN
4341 || kind == CPTK_HAS_TRIVIAL_CONSTRUCTOR
4342 || kind == CPTK_HAS_TRIVIAL_COPY
4343 || kind == CPTK_HAS_TRIVIAL_DESTRUCTOR
4344 || kind == CPTK_HAS_VIRTUAL_DESTRUCTOR
4345 || kind == CPTK_IS_ABSTRACT
4346 || kind == CPTK_IS_BASE_OF
4347 || kind == CPTK_IS_CLASS
4348 || kind == CPTK_IS_CONVERTIBLE_TO
4349 || kind == CPTK_IS_EMPTY
4350 || kind == CPTK_IS_ENUM
4351 || kind == CPTK_IS_POD
4352 || kind == CPTK_IS_POLYMORPHIC
4353 || kind == CPTK_IS_UNION);
4355 if (kind == CPTK_IS_CONVERTIBLE_TO)
4357 sorry ("__is_convertible_to");
4358 return error_mark_node;
4361 if (type1 == error_mark_node
4362 || ((kind == CPTK_IS_BASE_OF || kind == CPTK_IS_CONVERTIBLE_TO)
4363 && type2 == error_mark_node))
4364 return error_mark_node;
4366 if (processing_template_decl)
4368 tree trait_expr = make_node (TRAIT_EXPR);
4369 TREE_TYPE (trait_expr) = boolean_type_node;
4370 TRAIT_EXPR_TYPE1 (trait_expr) = type1;
4371 TRAIT_EXPR_TYPE2 (trait_expr) = type2;
4372 TRAIT_EXPR_KIND (trait_expr) = kind;
4376 complete_type (type1);
4378 complete_type (type2);
4380 /* The only required diagnostic. */
4381 if (kind == CPTK_IS_BASE_OF
4382 && NON_UNION_CLASS_TYPE_P (type1) && NON_UNION_CLASS_TYPE_P (type2)
4383 && !same_type_ignoring_top_level_qualifiers_p (type1, type2)
4384 && !COMPLETE_TYPE_P (type2))
4386 error ("incomplete type %qT not allowed", type2);
4387 return error_mark_node;
4390 return (trait_expr_value (kind, type1, type2)
4391 ? boolean_true_node : boolean_false_node);
4394 #include "gt-cp-semantics.h"