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 (const_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 /* Returns the expression which provides the value of STMT_EXPR. */
1760 stmt_expr_value_expr (tree stmt_expr)
1762 tree t = STMT_EXPR_STMT (stmt_expr);
1764 if (TREE_CODE (t) == BIND_EXPR)
1765 t = BIND_EXPR_BODY (t);
1767 if (TREE_CODE (t) == STATEMENT_LIST)
1768 t = STATEMENT_LIST_TAIL (t)->stmt;
1770 if (TREE_CODE (t) == EXPR_STMT)
1771 t = EXPR_STMT_EXPR (t);
1776 /* Perform Koenig lookup. FN is the postfix-expression representing
1777 the function (or functions) to call; ARGS are the arguments to the
1778 call. Returns the functions to be considered by overload
1782 perform_koenig_lookup (tree fn, tree args)
1784 tree identifier = NULL_TREE;
1785 tree functions = NULL_TREE;
1787 /* Find the name of the overloaded function. */
1788 if (TREE_CODE (fn) == IDENTIFIER_NODE)
1790 else if (is_overloaded_fn (fn))
1793 identifier = DECL_NAME (get_first_fn (functions));
1795 else if (DECL_P (fn))
1798 identifier = DECL_NAME (fn);
1801 /* A call to a namespace-scope function using an unqualified name.
1803 Do Koenig lookup -- unless any of the arguments are
1805 if (!any_type_dependent_arguments_p (args))
1807 fn = lookup_arg_dependent (identifier, functions, args);
1809 /* The unqualified name could not be resolved. */
1810 fn = unqualified_fn_lookup_error (identifier);
1816 /* Generate an expression for `FN (ARGS)'.
1818 If DISALLOW_VIRTUAL is true, the call to FN will be not generated
1819 as a virtual call, even if FN is virtual. (This flag is set when
1820 encountering an expression where the function name is explicitly
1821 qualified. For example a call to `X::f' never generates a virtual
1824 Returns code for the call. */
1827 finish_call_expr (tree fn, tree args, bool disallow_virtual, bool koenig_p)
1833 if (fn == error_mark_node || args == error_mark_node)
1834 return error_mark_node;
1836 /* ARGS should be a list of arguments. */
1837 gcc_assert (!args || TREE_CODE (args) == TREE_LIST);
1838 gcc_assert (!TYPE_P (fn));
1843 if (processing_template_decl)
1845 if (type_dependent_expression_p (fn)
1846 || any_type_dependent_arguments_p (args))
1848 result = build_nt_call_list (fn, args);
1849 KOENIG_LOOKUP_P (result) = koenig_p;
1852 if (!BASELINK_P (fn)
1853 && TREE_CODE (fn) != PSEUDO_DTOR_EXPR
1854 && TREE_TYPE (fn) != unknown_type_node)
1855 fn = build_non_dependent_expr (fn);
1856 args = build_non_dependent_args (orig_args);
1859 if (is_overloaded_fn (fn))
1860 fn = baselink_for_fns (fn);
1863 if (BASELINK_P (fn))
1867 /* A call to a member function. From [over.call.func]:
1869 If the keyword this is in scope and refers to the class of
1870 that member function, or a derived class thereof, then the
1871 function call is transformed into a qualified function call
1872 using (*this) as the postfix-expression to the left of the
1873 . operator.... [Otherwise] a contrived object of type T
1874 becomes the implied object argument.
1876 This paragraph is unclear about this situation:
1878 struct A { void f(); };
1879 struct B : public A {};
1880 struct C : public A { void g() { B::f(); }};
1882 In particular, for `B::f', this paragraph does not make clear
1883 whether "the class of that member function" refers to `A' or
1884 to `B'. We believe it refers to `B'. */
1885 if (current_class_type
1886 && DERIVED_FROM_P (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
1888 && current_class_ref)
1889 object = maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
1893 tree representative_fn;
1895 representative_fn = BASELINK_FUNCTIONS (fn);
1896 if (TREE_CODE (representative_fn) == TEMPLATE_ID_EXPR)
1897 representative_fn = TREE_OPERAND (representative_fn, 0);
1898 representative_fn = get_first_fn (representative_fn);
1899 object = build_dummy_object (DECL_CONTEXT (representative_fn));
1902 if (processing_template_decl)
1904 if (type_dependent_expression_p (object))
1905 return build_nt_call_list (orig_fn, orig_args);
1906 object = build_non_dependent_expr (object);
1909 result = build_new_method_call (object, fn, args, NULL_TREE,
1911 ? LOOKUP_NONVIRTUAL : 0),
1914 else if (is_overloaded_fn (fn))
1916 /* If the function is an overloaded builtin, resolve it. */
1917 if (TREE_CODE (fn) == FUNCTION_DECL
1918 && (DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
1919 || DECL_BUILT_IN_CLASS (fn) == BUILT_IN_MD))
1920 result = resolve_overloaded_builtin (fn, args);
1923 /* A call to a namespace-scope function. */
1924 result = build_new_function_call (fn, args, koenig_p);
1926 else if (TREE_CODE (fn) == PSEUDO_DTOR_EXPR)
1929 error ("arguments to destructor are not allowed");
1930 /* Mark the pseudo-destructor call as having side-effects so
1931 that we do not issue warnings about its use. */
1932 result = build1 (NOP_EXPR,
1934 TREE_OPERAND (fn, 0));
1935 TREE_SIDE_EFFECTS (result) = 1;
1937 else if (CLASS_TYPE_P (TREE_TYPE (fn)))
1938 /* If the "function" is really an object of class type, it might
1939 have an overloaded `operator ()'. */
1940 result = build_new_op (CALL_EXPR, LOOKUP_NORMAL, fn, args, NULL_TREE,
1941 /*overloaded_p=*/NULL);
1944 /* A call where the function is unknown. */
1945 result = build_function_call (fn, args);
1947 if (processing_template_decl)
1949 result = build_call_list (TREE_TYPE (result), orig_fn, orig_args);
1950 KOENIG_LOOKUP_P (result) = koenig_p;
1955 /* Finish a call to a postfix increment or decrement or EXPR. (Which
1956 is indicated by CODE, which should be POSTINCREMENT_EXPR or
1957 POSTDECREMENT_EXPR.) */
1960 finish_increment_expr (tree expr, enum tree_code code)
1962 return build_x_unary_op (code, expr);
1965 /* Finish a use of `this'. Returns an expression for `this'. */
1968 finish_this_expr (void)
1972 if (current_class_ptr)
1974 result = current_class_ptr;
1976 else if (current_function_decl
1977 && DECL_STATIC_FUNCTION_P (current_function_decl))
1979 error ("%<this%> is unavailable for static member functions");
1980 result = error_mark_node;
1984 if (current_function_decl)
1985 error ("invalid use of %<this%> in non-member function");
1987 error ("invalid use of %<this%> at top level");
1988 result = error_mark_node;
1994 /* Finish a pseudo-destructor expression. If SCOPE is NULL, the
1995 expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
1996 the TYPE for the type given. If SCOPE is non-NULL, the expression
1997 was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
2000 finish_pseudo_destructor_expr (tree object, tree scope, tree destructor)
2002 if (destructor == error_mark_node)
2003 return error_mark_node;
2005 gcc_assert (TYPE_P (destructor));
2007 if (!processing_template_decl)
2009 if (scope == error_mark_node)
2011 error ("invalid qualifying scope in pseudo-destructor name");
2012 return error_mark_node;
2014 if (scope && TYPE_P (scope) && !check_dtor_name (scope, destructor))
2016 error ("qualified type %qT does not match destructor name ~%qT",
2018 return error_mark_node;
2022 /* [expr.pseudo] says both:
2024 The type designated by the pseudo-destructor-name shall be
2025 the same as the object type.
2029 The cv-unqualified versions of the object type and of the
2030 type designated by the pseudo-destructor-name shall be the
2033 We implement the more generous second sentence, since that is
2034 what most other compilers do. */
2035 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object),
2038 error ("%qE is not of type %qT", object, destructor);
2039 return error_mark_node;
2043 return build3 (PSEUDO_DTOR_EXPR, void_type_node, object, scope, destructor);
2046 /* Finish an expression of the form CODE EXPR. */
2049 finish_unary_op_expr (enum tree_code code, tree expr)
2051 tree result = build_x_unary_op (code, expr);
2052 /* Inside a template, build_x_unary_op does not fold the
2053 expression. So check whether the result is folded before
2054 setting TREE_NEGATED_INT. */
2055 if (code == NEGATE_EXPR && TREE_CODE (expr) == INTEGER_CST
2056 && TREE_CODE (result) == INTEGER_CST
2057 && !TYPE_UNSIGNED (TREE_TYPE (result))
2058 && INT_CST_LT (result, integer_zero_node))
2060 /* RESULT may be a cached INTEGER_CST, so we must copy it before
2061 setting TREE_NEGATED_INT. */
2062 result = copy_node (result);
2063 TREE_NEGATED_INT (result) = 1;
2065 if (TREE_OVERFLOW_P (result) && !TREE_OVERFLOW_P (expr))
2066 overflow_warning (result);
2071 /* Finish a compound-literal expression. TYPE is the type to which
2072 the INITIALIZER_LIST is being cast. */
2075 finish_compound_literal (tree type, VEC(constructor_elt,gc) *initializer_list)
2078 tree compound_literal;
2080 if (!TYPE_OBJ_P (type))
2082 error ("compound literal of non-object type %qT", type);
2083 return error_mark_node;
2086 /* Build a CONSTRUCTOR for the INITIALIZER_LIST. */
2087 compound_literal = build_constructor (NULL_TREE, initializer_list);
2088 if (processing_template_decl)
2090 TREE_TYPE (compound_literal) = type;
2091 /* Mark the expression as a compound literal. */
2092 TREE_HAS_CONSTRUCTOR (compound_literal) = 1;
2093 return compound_literal;
2096 /* Create a temporary variable to represent the compound literal. */
2097 var = create_temporary_var (type);
2098 if (!current_function_decl)
2100 /* If this compound-literal appears outside of a function, then
2101 the corresponding variable has static storage duration, just
2102 like the variable in whose initializer it appears. */
2103 TREE_STATIC (var) = 1;
2104 /* The variable has internal linkage, since there is no need to
2105 reference it from another translation unit. */
2106 TREE_PUBLIC (var) = 0;
2107 /* It must have a name, so that the name mangler can mangle it. */
2108 DECL_NAME (var) = make_anon_name ();
2110 /* We must call pushdecl, since the gimplifier complains if the
2111 variable has not been declared via a BIND_EXPR. */
2113 /* Initialize the variable as we would any other variable with a
2114 brace-enclosed initializer. */
2115 cp_finish_decl (var, compound_literal,
2116 /*init_const_expr_p=*/false,
2117 /*asmspec_tree=*/NULL_TREE,
2118 LOOKUP_ONLYCONVERTING);
2122 /* Return the declaration for the function-name variable indicated by
2126 finish_fname (tree id)
2130 decl = fname_decl (C_RID_CODE (id), id);
2131 if (processing_template_decl)
2132 decl = DECL_NAME (decl);
2136 /* Finish a translation unit. */
2139 finish_translation_unit (void)
2141 /* In case there were missing closebraces,
2142 get us back to the global binding level. */
2144 while (current_namespace != global_namespace)
2147 /* Do file scope __FUNCTION__ et al. */
2148 finish_fname_decls ();
2151 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
2152 Returns the parameter. */
2155 finish_template_type_parm (tree aggr, tree identifier)
2157 if (aggr != class_type_node)
2159 pedwarn ("template type parameters must use the keyword %<class%> or %<typename%>");
2160 aggr = class_type_node;
2163 return build_tree_list (aggr, identifier);
2166 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
2167 Returns the parameter. */
2170 finish_template_template_parm (tree aggr, tree identifier)
2172 tree decl = build_decl (TYPE_DECL, identifier, NULL_TREE);
2173 tree tmpl = build_lang_decl (TEMPLATE_DECL, identifier, NULL_TREE);
2174 DECL_TEMPLATE_PARMS (tmpl) = current_template_parms;
2175 DECL_TEMPLATE_RESULT (tmpl) = decl;
2176 DECL_ARTIFICIAL (decl) = 1;
2177 end_template_decl ();
2179 gcc_assert (DECL_TEMPLATE_PARMS (tmpl));
2181 return finish_template_type_parm (aggr, tmpl);
2184 /* ARGUMENT is the default-argument value for a template template
2185 parameter. If ARGUMENT is invalid, issue error messages and return
2186 the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
2189 check_template_template_default_arg (tree argument)
2191 if (TREE_CODE (argument) != TEMPLATE_DECL
2192 && TREE_CODE (argument) != TEMPLATE_TEMPLATE_PARM
2193 && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
2195 if (TREE_CODE (argument) == TYPE_DECL)
2196 error ("invalid use of type %qT as a default value for a template "
2197 "template-parameter", TREE_TYPE (argument));
2199 error ("invalid default argument for a template template parameter");
2200 return error_mark_node;
2206 /* Begin a class definition, as indicated by T. */
2209 begin_class_definition (tree t, tree attributes)
2211 if (t == error_mark_node)
2212 return error_mark_node;
2214 if (processing_template_parmlist)
2216 error ("definition of %q#T inside template parameter list", t);
2217 return error_mark_node;
2219 /* A non-implicit typename comes from code like:
2221 template <typename T> struct A {
2222 template <typename U> struct A<T>::B ...
2224 This is erroneous. */
2225 else if (TREE_CODE (t) == TYPENAME_TYPE)
2227 error ("invalid definition of qualified type %qT", t);
2228 t = error_mark_node;
2231 if (t == error_mark_node || ! IS_AGGR_TYPE (t))
2233 t = make_aggr_type (RECORD_TYPE);
2234 pushtag (make_anon_name (), t, /*tag_scope=*/ts_current);
2237 /* Update the location of the decl. */
2238 DECL_SOURCE_LOCATION (TYPE_NAME (t)) = input_location;
2240 if (TYPE_BEING_DEFINED (t))
2242 t = make_aggr_type (TREE_CODE (t));
2243 pushtag (TYPE_IDENTIFIER (t), t, /*tag_scope=*/ts_current);
2245 maybe_process_partial_specialization (t);
2247 TYPE_BEING_DEFINED (t) = 1;
2249 cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
2251 if (flag_pack_struct)
2254 TYPE_PACKED (t) = 1;
2255 /* Even though the type is being defined for the first time
2256 here, there might have been a forward declaration, so there
2257 might be cv-qualified variants of T. */
2258 for (v = TYPE_NEXT_VARIANT (t); v; v = TYPE_NEXT_VARIANT (v))
2259 TYPE_PACKED (v) = 1;
2261 /* Reset the interface data, at the earliest possible
2262 moment, as it might have been set via a class foo;
2264 if (! TYPE_ANONYMOUS_P (t))
2266 struct c_fileinfo *finfo = get_fileinfo (input_filename);
2267 CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
2268 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2269 (t, finfo->interface_unknown);
2271 reset_specialization();
2273 /* Make a declaration for this class in its own scope. */
2274 build_self_reference ();
2279 /* Finish the member declaration given by DECL. */
2282 finish_member_declaration (tree decl)
2284 if (decl == error_mark_node || decl == NULL_TREE)
2287 if (decl == void_type_node)
2288 /* The COMPONENT was a friend, not a member, and so there's
2289 nothing for us to do. */
2292 /* We should see only one DECL at a time. */
2293 gcc_assert (TREE_CHAIN (decl) == NULL_TREE);
2295 /* Set up access control for DECL. */
2297 = (current_access_specifier == access_private_node);
2298 TREE_PROTECTED (decl)
2299 = (current_access_specifier == access_protected_node);
2300 if (TREE_CODE (decl) == TEMPLATE_DECL)
2302 TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl)) = TREE_PRIVATE (decl);
2303 TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl)) = TREE_PROTECTED (decl);
2306 /* Mark the DECL as a member of the current class. */
2307 DECL_CONTEXT (decl) = current_class_type;
2309 /* Check for bare parameter packs in the member variable declaration. */
2310 if (TREE_CODE (decl) == FIELD_DECL
2311 && !check_for_bare_parameter_packs (TREE_TYPE (decl)))
2312 TREE_TYPE (decl) = error_mark_node;
2316 A C language linkage is ignored for the names of class members
2317 and the member function type of class member functions. */
2318 if (DECL_LANG_SPECIFIC (decl) && DECL_LANGUAGE (decl) == lang_c)
2319 SET_DECL_LANGUAGE (decl, lang_cplusplus);
2321 /* Put functions on the TYPE_METHODS list and everything else on the
2322 TYPE_FIELDS list. Note that these are built up in reverse order.
2323 We reverse them (to obtain declaration order) in finish_struct. */
2324 if (TREE_CODE (decl) == FUNCTION_DECL
2325 || DECL_FUNCTION_TEMPLATE_P (decl))
2327 /* We also need to add this function to the
2328 CLASSTYPE_METHOD_VEC. */
2329 if (add_method (current_class_type, decl, NULL_TREE))
2331 TREE_CHAIN (decl) = TYPE_METHODS (current_class_type);
2332 TYPE_METHODS (current_class_type) = decl;
2334 maybe_add_class_template_decl_list (current_class_type, decl,
2338 /* Enter the DECL into the scope of the class. */
2339 else if ((TREE_CODE (decl) == USING_DECL && !DECL_DEPENDENT_P (decl))
2340 || pushdecl_class_level (decl))
2342 /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
2343 go at the beginning. The reason is that lookup_field_1
2344 searches the list in order, and we want a field name to
2345 override a type name so that the "struct stat hack" will
2346 work. In particular:
2348 struct S { enum E { }; int E } s;
2351 is valid. In addition, the FIELD_DECLs must be maintained in
2352 declaration order so that class layout works as expected.
2353 However, we don't need that order until class layout, so we
2354 save a little time by putting FIELD_DECLs on in reverse order
2355 here, and then reversing them in finish_struct_1. (We could
2356 also keep a pointer to the correct insertion points in the
2359 if (TREE_CODE (decl) == TYPE_DECL)
2360 TYPE_FIELDS (current_class_type)
2361 = chainon (TYPE_FIELDS (current_class_type), decl);
2364 TREE_CHAIN (decl) = TYPE_FIELDS (current_class_type);
2365 TYPE_FIELDS (current_class_type) = decl;
2368 maybe_add_class_template_decl_list (current_class_type, decl,
2373 note_decl_for_pch (decl);
2376 /* DECL has been declared while we are building a PCH file. Perform
2377 actions that we might normally undertake lazily, but which can be
2378 performed now so that they do not have to be performed in
2379 translation units which include the PCH file. */
2382 note_decl_for_pch (tree decl)
2384 gcc_assert (pch_file);
2386 /* There's a good chance that we'll have to mangle names at some
2387 point, even if only for emission in debugging information. */
2388 if ((TREE_CODE (decl) == VAR_DECL
2389 || TREE_CODE (decl) == FUNCTION_DECL)
2390 && !processing_template_decl)
2394 /* Finish processing a complete template declaration. The PARMS are
2395 the template parameters. */
2398 finish_template_decl (tree parms)
2401 end_template_decl ();
2403 end_specialization ();
2406 /* Finish processing a template-id (which names a type) of the form
2407 NAME < ARGS >. Return the TYPE_DECL for the type named by the
2408 template-id. If ENTERING_SCOPE is nonzero we are about to enter
2409 the scope of template-id indicated. */
2412 finish_template_type (tree name, tree args, int entering_scope)
2416 decl = lookup_template_class (name, args,
2417 NULL_TREE, NULL_TREE, entering_scope,
2418 tf_warning_or_error | tf_user);
2419 if (decl != error_mark_node)
2420 decl = TYPE_STUB_DECL (decl);
2425 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
2426 Return a TREE_LIST containing the ACCESS_SPECIFIER and the
2427 BASE_CLASS, or NULL_TREE if an error occurred. The
2428 ACCESS_SPECIFIER is one of
2429 access_{default,public,protected_private}_node. For a virtual base
2430 we set TREE_TYPE. */
2433 finish_base_specifier (tree base, tree access, bool virtual_p)
2437 if (base == error_mark_node)
2439 error ("invalid base-class specification");
2442 else if (! is_aggr_type (base, 1))
2446 if (cp_type_quals (base) != 0)
2448 error ("base class %qT has cv qualifiers", base);
2449 base = TYPE_MAIN_VARIANT (base);
2451 result = build_tree_list (access, base);
2453 TREE_TYPE (result) = integer_type_node;
2459 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is
2460 what we found when we tried to do the lookup. */
2463 qualified_name_lookup_error (tree scope, tree name, tree decl)
2465 if (scope == error_mark_node)
2466 ; /* We already complained. */
2467 else if (TYPE_P (scope))
2469 if (!COMPLETE_TYPE_P (scope))
2470 error ("incomplete type %qT used in nested name specifier", scope);
2471 else if (TREE_CODE (decl) == TREE_LIST)
2473 error ("reference to %<%T::%D%> is ambiguous", scope, name);
2474 print_candidates (decl);
2477 error ("%qD is not a member of %qT", name, scope);
2479 else if (scope != global_namespace)
2480 error ("%qD is not a member of %qD", name, scope);
2482 error ("%<::%D%> has not been declared", name);
2485 /* If FNS is a member function, a set of member functions, or a
2486 template-id referring to one or more member functions, return a
2487 BASELINK for FNS, incorporating the current access context.
2488 Otherwise, return FNS unchanged. */
2491 baselink_for_fns (tree fns)
2496 if (BASELINK_P (fns)
2497 || error_operand_p (fns))
2501 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2502 fn = TREE_OPERAND (fn, 0);
2503 fn = get_first_fn (fn);
2504 if (!DECL_FUNCTION_MEMBER_P (fn))
2507 cl = currently_open_derived_class (DECL_CONTEXT (fn));
2509 cl = DECL_CONTEXT (fn);
2510 cl = TYPE_BINFO (cl);
2511 return build_baselink (cl, cl, fns, /*optype=*/NULL_TREE);
2514 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
2515 id-expression. (See cp_parser_id_expression for details.) SCOPE,
2516 if non-NULL, is the type or namespace used to explicitly qualify
2517 ID_EXPRESSION. DECL is the entity to which that name has been
2520 *CONSTANT_EXPRESSION_P is true if we are presently parsing a
2521 constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
2522 be set to true if this expression isn't permitted in a
2523 constant-expression, but it is otherwise not set by this function.
2524 *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
2525 constant-expression, but a non-constant expression is also
2528 DONE is true if this expression is a complete postfix-expression;
2529 it is false if this expression is followed by '->', '[', '(', etc.
2530 ADDRESS_P is true iff this expression is the operand of '&'.
2531 TEMPLATE_P is true iff the qualified-id was of the form
2532 "A::template B". TEMPLATE_ARG_P is true iff this qualified name
2533 appears as a template argument.
2535 If an error occurs, and it is the kind of error that might cause
2536 the parser to abort a tentative parse, *ERROR_MSG is filled in. It
2537 is the caller's responsibility to issue the message. *ERROR_MSG
2538 will be a string with static storage duration, so the caller need
2541 Return an expression for the entity, after issuing appropriate
2542 diagnostics. This function is also responsible for transforming a
2543 reference to a non-static member into a COMPONENT_REF that makes
2544 the use of "this" explicit.
2546 Upon return, *IDK will be filled in appropriately. */
2549 finish_id_expression (tree id_expression,
2553 bool integral_constant_expression_p,
2554 bool allow_non_integral_constant_expression_p,
2555 bool *non_integral_constant_expression_p,
2559 bool template_arg_p,
2560 const char **error_msg)
2562 /* Initialize the output parameters. */
2563 *idk = CP_ID_KIND_NONE;
2566 if (id_expression == error_mark_node)
2567 return error_mark_node;
2568 /* If we have a template-id, then no further lookup is
2569 required. If the template-id was for a template-class, we
2570 will sometimes have a TYPE_DECL at this point. */
2571 else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2572 || TREE_CODE (decl) == TYPE_DECL)
2574 /* Look up the name. */
2577 if (decl == error_mark_node)
2579 /* Name lookup failed. */
2582 || (!dependent_type_p (scope)
2583 && !(TREE_CODE (id_expression) == IDENTIFIER_NODE
2584 && IDENTIFIER_TYPENAME_P (id_expression)
2585 && dependent_type_p (TREE_TYPE (id_expression))))))
2587 /* If the qualifying type is non-dependent (and the name
2588 does not name a conversion operator to a dependent
2589 type), issue an error. */
2590 qualified_name_lookup_error (scope, id_expression, decl);
2591 return error_mark_node;
2595 /* It may be resolved via Koenig lookup. */
2596 *idk = CP_ID_KIND_UNQUALIFIED;
2597 return id_expression;
2600 decl = id_expression;
2602 /* If DECL is a variable that would be out of scope under
2603 ANSI/ISO rules, but in scope in the ARM, name lookup
2604 will succeed. Issue a diagnostic here. */
2606 decl = check_for_out_of_scope_variable (decl);
2608 /* Remember that the name was used in the definition of
2609 the current class so that we can check later to see if
2610 the meaning would have been different after the class
2611 was entirely defined. */
2612 if (!scope && decl != error_mark_node)
2613 maybe_note_name_used_in_class (id_expression, decl);
2615 /* Disallow uses of local variables from containing functions. */
2616 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
2618 tree context = decl_function_context (decl);
2619 if (context != NULL_TREE && context != current_function_decl
2620 && ! TREE_STATIC (decl))
2622 error (TREE_CODE (decl) == VAR_DECL
2623 ? "use of %<auto%> variable from containing function"
2624 : "use of parameter from containing function");
2625 error (" %q+#D declared here", decl);
2626 return error_mark_node;
2631 /* If we didn't find anything, or what we found was a type,
2632 then this wasn't really an id-expression. */
2633 if (TREE_CODE (decl) == TEMPLATE_DECL
2634 && !DECL_FUNCTION_TEMPLATE_P (decl))
2636 *error_msg = "missing template arguments";
2637 return error_mark_node;
2639 else if (TREE_CODE (decl) == TYPE_DECL
2640 || TREE_CODE (decl) == NAMESPACE_DECL)
2642 *error_msg = "expected primary-expression";
2643 return error_mark_node;
2646 /* If the name resolved to a template parameter, there is no
2647 need to look it up again later. */
2648 if ((TREE_CODE (decl) == CONST_DECL && DECL_TEMPLATE_PARM_P (decl))
2649 || TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
2653 *idk = CP_ID_KIND_NONE;
2654 if (TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
2655 decl = TEMPLATE_PARM_DECL (decl);
2656 r = convert_from_reference (DECL_INITIAL (decl));
2658 if (integral_constant_expression_p
2659 && !dependent_type_p (TREE_TYPE (decl))
2660 && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r))))
2662 if (!allow_non_integral_constant_expression_p)
2663 error ("template parameter %qD of type %qT is not allowed in "
2664 "an integral constant expression because it is not of "
2665 "integral or enumeration type", decl, TREE_TYPE (decl));
2666 *non_integral_constant_expression_p = true;
2670 /* Similarly, we resolve enumeration constants to their
2671 underlying values. */
2672 else if (TREE_CODE (decl) == CONST_DECL)
2674 *idk = CP_ID_KIND_NONE;
2675 if (!processing_template_decl)
2677 used_types_insert (TREE_TYPE (decl));
2678 return DECL_INITIAL (decl);
2686 /* If the declaration was explicitly qualified indicate
2687 that. The semantics of `A::f(3)' are different than
2688 `f(3)' if `f' is virtual. */
2690 ? CP_ID_KIND_QUALIFIED
2691 : (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2692 ? CP_ID_KIND_TEMPLATE_ID
2693 : CP_ID_KIND_UNQUALIFIED));
2698 An id-expression is type-dependent if it contains an
2699 identifier that was declared with a dependent type.
2701 The standard is not very specific about an id-expression that
2702 names a set of overloaded functions. What if some of them
2703 have dependent types and some of them do not? Presumably,
2704 such a name should be treated as a dependent name. */
2705 /* Assume the name is not dependent. */
2706 dependent_p = false;
2707 if (!processing_template_decl)
2708 /* No names are dependent outside a template. */
2710 /* A template-id where the name of the template was not resolved
2711 is definitely dependent. */
2712 else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2713 && (TREE_CODE (TREE_OPERAND (decl, 0))
2714 == IDENTIFIER_NODE))
2716 /* For anything except an overloaded function, just check its
2718 else if (!is_overloaded_fn (decl))
2720 = dependent_type_p (TREE_TYPE (decl));
2721 /* For a set of overloaded functions, check each of the
2727 if (BASELINK_P (fns))
2728 fns = BASELINK_FUNCTIONS (fns);
2730 /* For a template-id, check to see if the template
2731 arguments are dependent. */
2732 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
2734 tree args = TREE_OPERAND (fns, 1);
2735 dependent_p = any_dependent_template_arguments_p (args);
2736 /* The functions are those referred to by the
2738 fns = TREE_OPERAND (fns, 0);
2741 /* If there are no dependent template arguments, go through
2742 the overloaded functions. */
2743 while (fns && !dependent_p)
2745 tree fn = OVL_CURRENT (fns);
2747 /* Member functions of dependent classes are
2749 if (TREE_CODE (fn) == FUNCTION_DECL
2750 && type_dependent_expression_p (fn))
2752 else if (TREE_CODE (fn) == TEMPLATE_DECL
2753 && dependent_template_p (fn))
2756 fns = OVL_NEXT (fns);
2760 /* If the name was dependent on a template parameter, we will
2761 resolve the name at instantiation time. */
2764 /* Create a SCOPE_REF for qualified names, if the scope is
2768 /* Since this name was dependent, the expression isn't
2769 constant -- yet. No error is issued because it might
2770 be constant when things are instantiated. */
2771 if (integral_constant_expression_p)
2772 *non_integral_constant_expression_p = true;
2775 if (address_p && done)
2776 decl = finish_qualified_id_expr (scope, decl,
2780 else if (dependent_type_p (scope))
2781 decl = build_qualified_name (/*type=*/NULL_TREE,
2785 else if (DECL_P (decl))
2786 decl = build_qualified_name (TREE_TYPE (decl),
2791 if (TREE_TYPE (decl))
2792 decl = convert_from_reference (decl);
2795 /* A TEMPLATE_ID already contains all the information we
2797 if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR)
2798 return id_expression;
2799 *idk = CP_ID_KIND_UNQUALIFIED_DEPENDENT;
2800 /* If we found a variable, then name lookup during the
2801 instantiation will always resolve to the same VAR_DECL
2802 (or an instantiation thereof). */
2803 if (TREE_CODE (decl) == VAR_DECL
2804 || TREE_CODE (decl) == PARM_DECL)
2805 return convert_from_reference (decl);
2806 /* The same is true for FIELD_DECL, but we also need to
2807 make sure that the syntax is correct. */
2808 else if (TREE_CODE (decl) == FIELD_DECL)
2810 /* Since SCOPE is NULL here, this is an unqualified name.
2811 Access checking has been performed during name lookup
2812 already. Turn off checking to avoid duplicate errors. */
2813 push_deferring_access_checks (dk_no_check);
2814 decl = finish_non_static_data_member
2815 (decl, current_class_ref,
2816 /*qualifying_scope=*/NULL_TREE);
2817 pop_deferring_access_checks ();
2820 return id_expression;
2823 /* Only certain kinds of names are allowed in constant
2824 expression. Enumerators and template parameters have already
2825 been handled above. */
2826 if (integral_constant_expression_p
2827 && ! DECL_INTEGRAL_CONSTANT_VAR_P (decl)
2828 && ! builtin_valid_in_constant_expr_p (decl))
2830 if (!allow_non_integral_constant_expression_p)
2832 error ("%qD cannot appear in a constant-expression", decl);
2833 return error_mark_node;
2835 *non_integral_constant_expression_p = true;
2838 if (TREE_CODE (decl) == NAMESPACE_DECL)
2840 error ("use of namespace %qD as expression", decl);
2841 return error_mark_node;
2843 else if (DECL_CLASS_TEMPLATE_P (decl))
2845 error ("use of class template %qT as expression", decl);
2846 return error_mark_node;
2848 else if (TREE_CODE (decl) == TREE_LIST)
2850 /* Ambiguous reference to base members. */
2851 error ("request for member %qD is ambiguous in "
2852 "multiple inheritance lattice", id_expression);
2853 print_candidates (decl);
2854 return error_mark_node;
2857 /* Mark variable-like entities as used. Functions are similarly
2858 marked either below or after overload resolution. */
2859 if (TREE_CODE (decl) == VAR_DECL
2860 || TREE_CODE (decl) == PARM_DECL
2861 || TREE_CODE (decl) == RESULT_DECL)
2866 decl = (adjust_result_of_qualified_name_lookup
2867 (decl, scope, current_class_type));
2869 if (TREE_CODE (decl) == FUNCTION_DECL)
2872 if (TREE_CODE (decl) == FIELD_DECL || BASELINK_P (decl))
2873 decl = finish_qualified_id_expr (scope,
2881 tree r = convert_from_reference (decl);
2883 if (processing_template_decl && TYPE_P (scope))
2884 r = build_qualified_name (TREE_TYPE (r),
2890 else if (TREE_CODE (decl) == FIELD_DECL)
2892 /* Since SCOPE is NULL here, this is an unqualified name.
2893 Access checking has been performed during name lookup
2894 already. Turn off checking to avoid duplicate errors. */
2895 push_deferring_access_checks (dk_no_check);
2896 decl = finish_non_static_data_member (decl, current_class_ref,
2897 /*qualifying_scope=*/NULL_TREE);
2898 pop_deferring_access_checks ();
2900 else if (is_overloaded_fn (decl))
2905 if (TREE_CODE (first_fn) == TEMPLATE_ID_EXPR)
2906 first_fn = TREE_OPERAND (first_fn, 0);
2907 first_fn = get_first_fn (first_fn);
2908 if (TREE_CODE (first_fn) == TEMPLATE_DECL)
2909 first_fn = DECL_TEMPLATE_RESULT (first_fn);
2911 if (!really_overloaded_fn (decl))
2912 mark_used (first_fn);
2915 && TREE_CODE (first_fn) == FUNCTION_DECL
2916 && DECL_FUNCTION_MEMBER_P (first_fn)
2917 && !shared_member_p (decl))
2919 /* A set of member functions. */
2920 decl = maybe_dummy_object (DECL_CONTEXT (first_fn), 0);
2921 return finish_class_member_access_expr (decl, id_expression,
2922 /*template_p=*/false);
2925 decl = baselink_for_fns (decl);
2929 if (DECL_P (decl) && DECL_NONLOCAL (decl)
2930 && DECL_CLASS_SCOPE_P (decl)
2931 && context_for_name_lookup (decl) != current_class_type)
2935 path = currently_open_derived_class (DECL_CONTEXT (decl));
2936 perform_or_defer_access_check (TYPE_BINFO (path), decl, decl);
2939 decl = convert_from_reference (decl);
2943 if (TREE_DEPRECATED (decl))
2944 warn_deprecated_use (decl);
2949 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
2950 use as a type-specifier. */
2953 finish_typeof (tree expr)
2957 if (type_dependent_expression_p (expr))
2959 type = make_aggr_type (TYPEOF_TYPE);
2960 TYPEOF_TYPE_EXPR (type) = expr;
2961 SET_TYPE_STRUCTURAL_EQUALITY (type);
2966 type = unlowered_expr_type (expr);
2968 if (!type || type == unknown_type_node)
2970 error ("type of %qE is unknown", expr);
2971 return error_mark_node;
2977 /* Perform C++-specific checks for __builtin_offsetof before calling
2981 finish_offsetof (tree expr)
2983 if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
2985 error ("cannot apply %<offsetof%> to destructor %<~%T%>",
2986 TREE_OPERAND (expr, 2));
2987 return error_mark_node;
2989 if (TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE
2990 || TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE
2991 || TREE_CODE (TREE_TYPE (expr)) == UNKNOWN_TYPE)
2993 if (TREE_CODE (expr) == COMPONENT_REF
2994 || TREE_CODE (expr) == COMPOUND_EXPR)
2995 expr = TREE_OPERAND (expr, 1);
2996 error ("cannot apply %<offsetof%> to member function %qD", expr);
2997 return error_mark_node;
2999 return fold_offsetof (expr, NULL_TREE);
3002 /* Called from expand_body via walk_tree. Replace all AGGR_INIT_EXPRs
3003 with equivalent CALL_EXPRs. */
3006 simplify_aggr_init_exprs_r (tree* tp,
3008 void* data ATTRIBUTE_UNUSED)
3010 /* We don't need to walk into types; there's nothing in a type that
3011 needs simplification. (And, furthermore, there are places we
3012 actively don't want to go. For example, we don't want to wander
3013 into the default arguments for a FUNCTION_DECL that appears in a
3020 /* Only AGGR_INIT_EXPRs are interesting. */
3021 else if (TREE_CODE (*tp) != AGGR_INIT_EXPR)
3024 simplify_aggr_init_expr (tp);
3026 /* Keep iterating. */
3030 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
3031 function is broken out from the above for the benefit of the tree-ssa
3035 simplify_aggr_init_expr (tree *tp)
3037 tree aggr_init_expr = *tp;
3039 /* Form an appropriate CALL_EXPR. */
3040 tree fn = AGGR_INIT_EXPR_FN (aggr_init_expr);
3041 tree slot = AGGR_INIT_EXPR_SLOT (aggr_init_expr);
3042 tree type = TREE_TYPE (slot);
3045 enum style_t { ctor, arg, pcc } style;
3047 if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr))
3049 #ifdef PCC_STATIC_STRUCT_RETURN
3055 gcc_assert (TREE_ADDRESSABLE (type));
3059 call_expr = build_call_array (TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
3061 aggr_init_expr_nargs (aggr_init_expr),
3062 AGGR_INIT_EXPR_ARGP (aggr_init_expr));
3066 /* Replace the first argument to the ctor with the address of the
3068 cxx_mark_addressable (slot);
3069 CALL_EXPR_ARG (call_expr, 0) =
3070 build1 (ADDR_EXPR, build_pointer_type (type), slot);
3072 else if (style == arg)
3074 /* Just mark it addressable here, and leave the rest to
3075 expand_call{,_inline}. */
3076 cxx_mark_addressable (slot);
3077 CALL_EXPR_RETURN_SLOT_OPT (call_expr) = true;
3078 call_expr = build2 (MODIFY_EXPR, TREE_TYPE (call_expr), slot, call_expr);
3080 else if (style == pcc)
3082 /* If we're using the non-reentrant PCC calling convention, then we
3083 need to copy the returned value out of the static buffer into the
3085 push_deferring_access_checks (dk_no_check);
3086 call_expr = build_aggr_init (slot, call_expr,
3087 DIRECT_BIND | LOOKUP_ONLYCONVERTING);
3088 pop_deferring_access_checks ();
3089 call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (slot), call_expr, slot);
3095 /* Emit all thunks to FN that should be emitted when FN is emitted. */
3098 emit_associated_thunks (tree fn)
3100 /* When we use vcall offsets, we emit thunks with the virtual
3101 functions to which they thunk. The whole point of vcall offsets
3102 is so that you can know statically the entire set of thunks that
3103 will ever be needed for a given virtual function, thereby
3104 enabling you to output all the thunks with the function itself. */
3105 if (DECL_VIRTUAL_P (fn))
3109 for (thunk = DECL_THUNKS (fn); thunk; thunk = TREE_CHAIN (thunk))
3111 if (!THUNK_ALIAS (thunk))
3113 use_thunk (thunk, /*emit_p=*/1);
3114 if (DECL_RESULT_THUNK_P (thunk))
3118 for (probe = DECL_THUNKS (thunk);
3119 probe; probe = TREE_CHAIN (probe))
3120 use_thunk (probe, /*emit_p=*/1);
3124 gcc_assert (!DECL_THUNKS (thunk));
3129 /* Generate RTL for FN. */
3132 expand_body (tree fn)
3134 /* Emit any thunks that should be emitted at the same time as FN. */
3135 emit_associated_thunks (fn);
3137 /* This function is only called from cgraph, or recursively from
3138 emit_associated_thunks. In neither case should we be currently
3139 generating trees for a function. */
3140 gcc_assert (function_depth == 0);
3145 /* Generate RTL for FN. */
3148 expand_or_defer_fn (tree fn)
3150 /* When the parser calls us after finishing the body of a template
3151 function, we don't really want to expand the body. */
3152 if (processing_template_decl)
3154 /* Normally, collection only occurs in rest_of_compilation. So,
3155 if we don't collect here, we never collect junk generated
3156 during the processing of templates until we hit a
3157 non-template function. It's not safe to do this inside a
3158 nested class, though, as the parser may have local state that
3159 is not a GC root. */
3160 if (!function_depth)
3165 /* Replace AGGR_INIT_EXPRs with appropriate CALL_EXPRs. */
3166 cp_walk_tree_without_duplicates (&DECL_SAVED_TREE (fn),
3167 simplify_aggr_init_exprs_r,
3170 /* If this is a constructor or destructor body, we have to clone
3172 if (maybe_clone_body (fn))
3174 /* We don't want to process FN again, so pretend we've written
3175 it out, even though we haven't. */
3176 TREE_ASM_WRITTEN (fn) = 1;
3180 /* We make a decision about linkage for these functions at the end
3181 of the compilation. Until that point, we do not want the back
3182 end to output them -- but we do want it to see the bodies of
3183 these functions so that it can inline them as appropriate. */
3184 if (DECL_DECLARED_INLINE_P (fn) || DECL_IMPLICIT_INSTANTIATION (fn))
3186 if (DECL_INTERFACE_KNOWN (fn))
3187 /* We've already made a decision as to how this function will
3191 DECL_EXTERNAL (fn) = 1;
3192 DECL_NOT_REALLY_EXTERN (fn) = 1;
3193 note_vague_linkage_fn (fn);
3194 /* A non-template inline function with external linkage will
3195 always be COMDAT. As we must eventually determine the
3196 linkage of all functions, and as that causes writes to
3197 the data mapped in from the PCH file, it's advantageous
3198 to mark the functions at this point. */
3199 if (!DECL_IMPLICIT_INSTANTIATION (fn))
3201 /* This function must have external linkage, as
3202 otherwise DECL_INTERFACE_KNOWN would have been
3204 gcc_assert (TREE_PUBLIC (fn));
3205 comdat_linkage (fn);
3206 DECL_INTERFACE_KNOWN (fn) = 1;
3210 import_export_decl (fn);
3212 /* If the user wants us to keep all inline functions, then mark
3213 this function as needed so that finish_file will make sure to
3215 if (flag_keep_inline_functions && DECL_DECLARED_INLINE_P (fn))
3219 /* There's no reason to do any of the work here if we're only doing
3220 semantic analysis; this code just generates RTL. */
3221 if (flag_syntax_only)
3226 /* Expand or defer, at the whim of the compilation unit manager. */
3227 cgraph_finalize_function (fn, function_depth > 1);
3239 /* Helper function for walk_tree, used by finalize_nrv below. */
3242 finalize_nrv_r (tree* tp, int* walk_subtrees, void* data)
3244 struct nrv_data *dp = (struct nrv_data *)data;
3247 /* No need to walk into types. There wouldn't be any need to walk into
3248 non-statements, except that we have to consider STMT_EXPRs. */
3251 /* Change all returns to just refer to the RESULT_DECL; this is a nop,
3252 but differs from using NULL_TREE in that it indicates that we care
3253 about the value of the RESULT_DECL. */
3254 else if (TREE_CODE (*tp) == RETURN_EXPR)
3255 TREE_OPERAND (*tp, 0) = dp->result;
3256 /* Change all cleanups for the NRV to only run when an exception is
3258 else if (TREE_CODE (*tp) == CLEANUP_STMT
3259 && CLEANUP_DECL (*tp) == dp->var)
3260 CLEANUP_EH_ONLY (*tp) = 1;
3261 /* Replace the DECL_EXPR for the NRV with an initialization of the
3262 RESULT_DECL, if needed. */
3263 else if (TREE_CODE (*tp) == DECL_EXPR
3264 && DECL_EXPR_DECL (*tp) == dp->var)
3267 if (DECL_INITIAL (dp->var)
3268 && DECL_INITIAL (dp->var) != error_mark_node)
3270 init = build2 (INIT_EXPR, void_type_node, dp->result,
3271 DECL_INITIAL (dp->var));
3272 DECL_INITIAL (dp->var) = error_mark_node;
3275 init = build_empty_stmt ();
3276 SET_EXPR_LOCUS (init, EXPR_LOCUS (*tp));
3279 /* And replace all uses of the NRV with the RESULT_DECL. */
3280 else if (*tp == dp->var)
3283 /* Avoid walking into the same tree more than once. Unfortunately, we
3284 can't just use walk_tree_without duplicates because it would only call
3285 us for the first occurrence of dp->var in the function body. */
3286 slot = htab_find_slot (dp->visited, *tp, INSERT);
3292 /* Keep iterating. */
3296 /* Called from finish_function to implement the named return value
3297 optimization by overriding all the RETURN_EXPRs and pertinent
3298 CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
3299 RESULT_DECL for the function. */
3302 finalize_nrv (tree *tp, tree var, tree result)
3304 struct nrv_data data;
3306 /* Copy debugging information from VAR to RESULT. */
3307 DECL_NAME (result) = DECL_NAME (var);
3308 DECL_ARTIFICIAL (result) = DECL_ARTIFICIAL (var);
3309 DECL_IGNORED_P (result) = DECL_IGNORED_P (var);
3310 DECL_SOURCE_LOCATION (result) = DECL_SOURCE_LOCATION (var);
3311 DECL_ABSTRACT_ORIGIN (result) = DECL_ABSTRACT_ORIGIN (var);
3312 /* Don't forget that we take its address. */
3313 TREE_ADDRESSABLE (result) = TREE_ADDRESSABLE (var);
3316 data.result = result;
3317 data.visited = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
3318 cp_walk_tree (tp, finalize_nrv_r, &data, 0);
3319 htab_delete (data.visited);
3322 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
3323 Remove any elements from the list that are invalid. */
3326 finish_omp_clauses (tree clauses)
3328 bitmap_head generic_head, firstprivate_head, lastprivate_head;
3329 tree c, t, *pc = &clauses;
3332 bitmap_obstack_initialize (NULL);
3333 bitmap_initialize (&generic_head, &bitmap_default_obstack);
3334 bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
3335 bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);
3337 for (pc = &clauses, c = clauses; c ; c = *pc)
3339 bool remove = false;
3341 switch (OMP_CLAUSE_CODE (c))
3343 case OMP_CLAUSE_SHARED:
3345 goto check_dup_generic;
3346 case OMP_CLAUSE_PRIVATE:
3348 goto check_dup_generic;
3349 case OMP_CLAUSE_REDUCTION:
3351 goto check_dup_generic;
3352 case OMP_CLAUSE_COPYPRIVATE:
3353 name = "copyprivate";
3354 goto check_dup_generic;
3355 case OMP_CLAUSE_COPYIN:
3357 goto check_dup_generic;
3359 t = OMP_CLAUSE_DECL (c);
3360 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3362 if (processing_template_decl)
3365 error ("%qD is not a variable in clause %qs", t, name);
3367 error ("%qE is not a variable in clause %qs", t, name);
3370 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
3371 || bitmap_bit_p (&firstprivate_head, DECL_UID (t))
3372 || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
3374 error ("%qD appears more than once in data clauses", t);
3378 bitmap_set_bit (&generic_head, DECL_UID (t));
3381 case OMP_CLAUSE_FIRSTPRIVATE:
3382 t = OMP_CLAUSE_DECL (c);
3383 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3385 if (processing_template_decl)
3387 error ("%qE is not a variable in clause %<firstprivate%>", t);
3390 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
3391 || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
3393 error ("%qE appears more than once in data clauses", t);
3397 bitmap_set_bit (&firstprivate_head, DECL_UID (t));
3400 case OMP_CLAUSE_LASTPRIVATE:
3401 t = OMP_CLAUSE_DECL (c);
3402 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3404 if (processing_template_decl)
3406 error ("%qE is not a variable in clause %<lastprivate%>", t);
3409 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
3410 || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
3412 error ("%qE appears more than once in data clauses", t);
3416 bitmap_set_bit (&lastprivate_head, DECL_UID (t));
3420 t = OMP_CLAUSE_IF_EXPR (c);
3421 t = maybe_convert_cond (t);
3422 if (t == error_mark_node)
3424 OMP_CLAUSE_IF_EXPR (c) = t;
3427 case OMP_CLAUSE_NUM_THREADS:
3428 t = OMP_CLAUSE_NUM_THREADS_EXPR (c);
3429 if (t == error_mark_node)
3431 else if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
3432 && !type_dependent_expression_p (t))
3434 error ("num_threads expression must be integral");
3439 case OMP_CLAUSE_SCHEDULE:
3440 t = OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c);
3443 else if (t == error_mark_node)
3445 else if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
3446 && !type_dependent_expression_p (t))
3448 error ("schedule chunk size expression must be integral");
3453 case OMP_CLAUSE_NOWAIT:
3454 case OMP_CLAUSE_ORDERED:
3455 case OMP_CLAUSE_DEFAULT:
3463 *pc = OMP_CLAUSE_CHAIN (c);
3465 pc = &OMP_CLAUSE_CHAIN (c);
3468 for (pc = &clauses, c = clauses; c ; c = *pc)
3470 enum tree_code c_kind = OMP_CLAUSE_CODE (c);
3471 bool remove = false;
3472 bool need_complete_non_reference = false;
3473 bool need_default_ctor = false;
3474 bool need_copy_ctor = false;
3475 bool need_copy_assignment = false;
3476 bool need_implicitly_determined = false;
3477 tree type, inner_type;
3481 case OMP_CLAUSE_SHARED:
3483 need_implicitly_determined = true;
3485 case OMP_CLAUSE_PRIVATE:
3487 need_complete_non_reference = true;
3488 need_default_ctor = true;
3489 need_implicitly_determined = true;
3491 case OMP_CLAUSE_FIRSTPRIVATE:
3492 name = "firstprivate";
3493 need_complete_non_reference = true;
3494 need_copy_ctor = true;
3495 need_implicitly_determined = true;
3497 case OMP_CLAUSE_LASTPRIVATE:
3498 name = "lastprivate";
3499 need_complete_non_reference = true;
3500 need_copy_assignment = true;
3501 need_implicitly_determined = true;
3503 case OMP_CLAUSE_REDUCTION:
3505 need_implicitly_determined = true;
3507 case OMP_CLAUSE_COPYPRIVATE:
3508 name = "copyprivate";
3509 need_copy_assignment = true;
3511 case OMP_CLAUSE_COPYIN:
3513 need_copy_assignment = true;
3516 pc = &OMP_CLAUSE_CHAIN (c);
3520 t = OMP_CLAUSE_DECL (c);
3521 if (processing_template_decl
3522 && TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3524 pc = &OMP_CLAUSE_CHAIN (c);
3530 case OMP_CLAUSE_LASTPRIVATE:
3531 if (!bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
3532 need_default_ctor = true;
3535 case OMP_CLAUSE_REDUCTION:
3536 if (AGGREGATE_TYPE_P (TREE_TYPE (t))
3537 || POINTER_TYPE_P (TREE_TYPE (t)))
3539 error ("%qE has invalid type for %<reduction%>", t);
3542 else if (FLOAT_TYPE_P (TREE_TYPE (t)))
3544 enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c);
3552 error ("%qE has invalid type for %<reduction(%s)%>",
3553 t, operator_name_info[r_code].name);
3559 case OMP_CLAUSE_COPYIN:
3560 if (TREE_CODE (t) != VAR_DECL || !DECL_THREAD_LOCAL_P (t))
3562 error ("%qE must be %<threadprivate%> for %<copyin%>", t);
3571 if (need_complete_non_reference)
3573 t = require_complete_type (t);
3574 if (t == error_mark_node)
3576 else if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
3578 error ("%qE has reference type for %qs", t, name);
3582 if (need_implicitly_determined)
3584 const char *share_name = NULL;
3586 if (TREE_CODE (t) == VAR_DECL && DECL_THREAD_LOCAL_P (t))
3587 share_name = "threadprivate";
3588 else switch (cxx_omp_predetermined_sharing (t))
3590 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
3592 case OMP_CLAUSE_DEFAULT_SHARED:
3593 share_name = "shared";
3595 case OMP_CLAUSE_DEFAULT_PRIVATE:
3596 share_name = "private";
3603 error ("%qE is predetermined %qs for %qs",
3604 t, share_name, name);
3609 /* We're interested in the base element, not arrays. */
3610 inner_type = type = TREE_TYPE (t);
3611 while (TREE_CODE (inner_type) == ARRAY_TYPE)
3612 inner_type = TREE_TYPE (inner_type);
3614 /* Check for special function availability by building a call to one.
3615 Save the results, because later we won't be in the right context
3616 for making these queries. */
3617 if (CLASS_TYPE_P (inner_type)
3618 && (need_default_ctor || need_copy_ctor || need_copy_assignment)
3619 && !type_dependent_expression_p (t))
3621 int save_errorcount = errorcount;
3624 /* Always allocate 3 elements for simplicity. These are the
3625 function decls for the ctor, dtor, and assignment op.
3626 This layout is known to the three lang hooks,
3627 cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
3628 and cxx_omp_clause_assign_op. */
3629 info = make_tree_vec (3);
3630 CP_OMP_CLAUSE_INFO (c) = info;
3632 if (need_default_ctor
3634 && !TYPE_HAS_TRIVIAL_INIT_REF (inner_type)))
3636 if (need_default_ctor)
3640 t = build_int_cst (build_pointer_type (inner_type), 0);
3641 t = build1 (INDIRECT_REF, inner_type, t);
3642 t = build_tree_list (NULL, t);
3644 t = build_special_member_call (NULL_TREE,
3645 complete_ctor_identifier,
3646 t, inner_type, LOOKUP_NORMAL);
3648 if (targetm.cxx.cdtor_returns_this ())
3649 /* Because constructors and destructors return this,
3650 the call will have been cast to "void". Remove the
3651 cast here. We would like to use STRIP_NOPS, but it
3652 wouldn't work here because TYPE_MODE (t) and
3653 TYPE_MODE (TREE_OPERAND (t, 0)) are different.
3654 They are VOIDmode and Pmode, respectively. */
3655 if (TREE_CODE (t) == NOP_EXPR)
3656 t = TREE_OPERAND (t, 0);
3658 t = get_callee_fndecl (t);
3659 TREE_VEC_ELT (info, 0) = t;
3662 if ((need_default_ctor || need_copy_ctor)
3663 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_type))
3665 t = build_int_cst (build_pointer_type (inner_type), 0);
3666 t = build1 (INDIRECT_REF, inner_type, t);
3667 t = build_special_member_call (t, complete_dtor_identifier,
3668 NULL, inner_type, LOOKUP_NORMAL);
3670 if (targetm.cxx.cdtor_returns_this ())
3671 /* Because constructors and destructors return this,
3672 the call will have been cast to "void". Remove the
3673 cast here. We would like to use STRIP_NOPS, but it
3674 wouldn't work here because TYPE_MODE (t) and
3675 TYPE_MODE (TREE_OPERAND (t, 0)) are different.
3676 They are VOIDmode and Pmode, respectively. */
3677 if (TREE_CODE (t) == NOP_EXPR)
3678 t = TREE_OPERAND (t, 0);
3680 t = get_callee_fndecl (t);
3681 TREE_VEC_ELT (info, 1) = t;
3684 if (need_copy_assignment
3685 && !TYPE_HAS_TRIVIAL_ASSIGN_REF (inner_type))
3687 t = build_int_cst (build_pointer_type (inner_type), 0);
3688 t = build1 (INDIRECT_REF, inner_type, t);
3689 t = build_special_member_call (t, ansi_assopname (NOP_EXPR),
3690 build_tree_list (NULL, t),
3691 inner_type, LOOKUP_NORMAL);
3693 /* We'll have called convert_from_reference on the call, which
3694 may well have added an indirect_ref. It's unneeded here,
3695 and in the way, so kill it. */
3696 if (TREE_CODE (t) == INDIRECT_REF)
3697 t = TREE_OPERAND (t, 0);
3699 t = get_callee_fndecl (t);
3700 TREE_VEC_ELT (info, 2) = t;
3703 if (errorcount != save_errorcount)
3708 *pc = OMP_CLAUSE_CHAIN (c);
3710 pc = &OMP_CLAUSE_CHAIN (c);
3713 bitmap_obstack_release (NULL);
3717 /* For all variables in the tree_list VARS, mark them as thread local. */
3720 finish_omp_threadprivate (tree vars)
3724 /* Mark every variable in VARS to be assigned thread local storage. */
3725 for (t = vars; t; t = TREE_CHAIN (t))
3727 tree v = TREE_PURPOSE (t);
3729 /* If V had already been marked threadprivate, it doesn't matter
3730 whether it had been used prior to this point. */
3732 && (DECL_LANG_SPECIFIC (v) == NULL
3733 || !CP_DECL_THREADPRIVATE_P (v)))
3734 error ("%qE declared %<threadprivate%> after first use", v);
3735 else if (! TREE_STATIC (v) && ! DECL_EXTERNAL (v))
3736 error ("automatic variable %qE cannot be %<threadprivate%>", v);
3737 else if (! COMPLETE_TYPE_P (TREE_TYPE (v)))
3738 error ("%<threadprivate%> %qE has incomplete type", v);
3739 else if (TREE_STATIC (v) && TYPE_P (CP_DECL_CONTEXT (v)))
3740 error ("%<threadprivate%> %qE is not file, namespace "
3741 "or block scope variable", v);
3744 /* Allocate a LANG_SPECIFIC structure for V, if needed. */
3745 if (DECL_LANG_SPECIFIC (v) == NULL)
3747 retrofit_lang_decl (v);
3749 /* Make sure that DECL_DISCRIMINATOR_P continues to be true
3750 after the allocation of the lang_decl structure. */
3751 if (DECL_DISCRIMINATOR_P (v))
3752 DECL_LANG_SPECIFIC (v)->decl_flags.u2sel = 1;
3755 if (! DECL_THREAD_LOCAL_P (v))
3757 DECL_TLS_MODEL (v) = decl_default_tls_model (v);
3758 /* If rtl has been already set for this var, call
3759 make_decl_rtl once again, so that encode_section_info
3760 has a chance to look at the new decl flags. */
3761 if (DECL_RTL_SET_P (v))
3764 CP_DECL_THREADPRIVATE_P (v) = 1;
3769 /* Build an OpenMP structured block. */
3772 begin_omp_structured_block (void)
3774 return do_pushlevel (sk_omp);
3778 finish_omp_structured_block (tree block)
3780 return do_poplevel (block);
3783 /* Similarly, except force the retention of the BLOCK. */
3786 begin_omp_parallel (void)
3788 keep_next_level (true);
3789 return begin_omp_structured_block ();
3793 finish_omp_parallel (tree clauses, tree body)
3797 body = finish_omp_structured_block (body);
3799 stmt = make_node (OMP_PARALLEL);
3800 TREE_TYPE (stmt) = void_type_node;
3801 OMP_PARALLEL_CLAUSES (stmt) = clauses;
3802 OMP_PARALLEL_BODY (stmt) = body;
3804 return add_stmt (stmt);
3807 /* Build and validate an OMP_FOR statement. CLAUSES, BODY, COND, INCR
3808 are directly for their associated operands in the statement. DECL
3809 and INIT are a combo; if DECL is NULL then INIT ought to be a
3810 MODIFY_EXPR, and the DECL should be extracted. PRE_BODY are
3811 optional statements that need to go before the loop into its
3815 finish_omp_for (location_t locus, tree decl, tree init, tree cond,
3816 tree incr, tree body, tree pre_body)
3823 switch (TREE_CODE (init))
3826 decl = TREE_OPERAND (init, 0);
3827 init = TREE_OPERAND (init, 1);
3830 if (TREE_CODE (TREE_OPERAND (init, 1)) == NOP_EXPR)
3832 decl = TREE_OPERAND (init, 0);
3833 init = TREE_OPERAND (init, 2);
3842 error ("expected iteration declaration or initialization");
3847 if (type_dependent_expression_p (decl)
3848 || type_dependent_expression_p (init)
3849 || (cond && type_dependent_expression_p (cond))
3850 || (incr && type_dependent_expression_p (incr)))
3856 error ("%Hmissing controlling predicate", &locus);
3862 error ("%Hmissing increment expression", &locus);
3866 stmt = make_node (OMP_FOR);
3868 /* This is really just a place-holder. We'll be decomposing this
3869 again and going through the build_modify_expr path below when
3870 we instantiate the thing. */
3871 init = build2 (MODIFY_EXPR, void_type_node, decl, init);
3873 TREE_TYPE (stmt) = void_type_node;
3874 OMP_FOR_INIT (stmt) = init;
3875 OMP_FOR_COND (stmt) = cond;
3876 OMP_FOR_INCR (stmt) = incr;
3877 OMP_FOR_BODY (stmt) = body;
3878 OMP_FOR_PRE_BODY (stmt) = pre_body;
3880 SET_EXPR_LOCATION (stmt, locus);
3881 return add_stmt (stmt);
3886 error ("expected iteration declaration or initialization");
3890 if (pre_body == NULL || IS_EMPTY_STMT (pre_body))
3892 else if (! processing_template_decl)
3894 add_stmt (pre_body);
3898 init = fold_build_cleanup_point_expr (TREE_TYPE (init), init);
3899 init = build_modify_expr (decl, NOP_EXPR, init);
3900 if (cond && TREE_SIDE_EFFECTS (cond) && COMPARISON_CLASS_P (cond))
3902 int n = TREE_SIDE_EFFECTS (TREE_OPERAND (cond, 1)) != 0;
3903 tree t = TREE_OPERAND (cond, n);
3905 TREE_OPERAND (cond, n)
3906 = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
3908 omp_for = c_finish_omp_for (locus, decl, init, cond, incr, body, pre_body);
3910 && TREE_CODE (OMP_FOR_INCR (omp_for)) == MODIFY_EXPR
3911 && TREE_SIDE_EFFECTS (TREE_OPERAND (OMP_FOR_INCR (omp_for), 1))
3912 && BINARY_CLASS_P (TREE_OPERAND (OMP_FOR_INCR (omp_for), 1)))
3914 tree t = TREE_OPERAND (OMP_FOR_INCR (omp_for), 1);
3915 int n = TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)) != 0;
3918 = fold_build_cleanup_point_expr (TREE_TYPE (TREE_OPERAND (t, n)),
3919 TREE_OPERAND (t, n));
3925 finish_omp_atomic (enum tree_code code, tree lhs, tree rhs)
3929 if (processing_template_decl
3930 && (type_dependent_expression_p (lhs)
3931 || type_dependent_expression_p (rhs)))
3932 stmt = build2 (OMP_ATOMIC, void_type_node, integer_zero_node,
3933 build2 (code, void_type_node, lhs, rhs));
3936 /* Even in a template, we can detect invalid uses of the atomic
3937 pragma if neither LHS nor RHS is type-dependent. */
3938 if (processing_template_decl)
3940 lhs = build_non_dependent_expr (lhs);
3941 rhs = build_non_dependent_expr (rhs);
3944 stmt = c_finish_omp_atomic (code, lhs, rhs);
3947 if (stmt != error_mark_node)
3952 finish_omp_barrier (void)
3954 tree fn = built_in_decls[BUILT_IN_GOMP_BARRIER];
3955 tree stmt = finish_call_expr (fn, NULL, false, false);
3956 finish_expr_stmt (stmt);
3960 finish_omp_flush (void)
3962 tree fn = built_in_decls[BUILT_IN_SYNCHRONIZE];
3963 tree stmt = finish_call_expr (fn, NULL, false, false);
3964 finish_expr_stmt (stmt);
3967 /* True if OpenMP sharing attribute of DECL is predetermined. */
3969 enum omp_clause_default_kind
3970 cxx_omp_predetermined_sharing (tree decl)
3972 enum omp_clause_default_kind kind;
3974 kind = c_omp_predetermined_sharing (decl);
3975 if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
3978 /* Static data members are predetermined as shared. */
3979 if (TREE_STATIC (decl))
3981 tree ctx = CP_DECL_CONTEXT (decl);
3982 if (TYPE_P (ctx) && IS_AGGR_TYPE (ctx))
3983 return OMP_CLAUSE_DEFAULT_SHARED;
3986 return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
3990 init_cp_semantics (void)
3994 /* Build a STATIC_ASSERT for a static assertion with the condition
3995 CONDITION and the message text MESSAGE. LOCATION is the location
3996 of the static assertion in the source code. When MEMBER_P, this
3997 static assertion is a member of a class. */
3999 finish_static_assert (tree condition, tree message, location_t location,
4002 if (type_dependent_expression_p (condition)
4003 || value_dependent_expression_p (condition))
4005 /* We're in a template; build a STATIC_ASSERT and put it in
4009 assertion = make_node (STATIC_ASSERT);
4010 STATIC_ASSERT_CONDITION (assertion) = condition;
4011 STATIC_ASSERT_MESSAGE (assertion) = message;
4012 STATIC_ASSERT_SOURCE_LOCATION (assertion) = location;
4015 maybe_add_class_template_decl_list (current_class_type,
4019 add_stmt (assertion);
4024 /* Fold the expression and convert it to a boolean value. */
4025 condition = fold_non_dependent_expr (condition);
4026 condition = cp_convert (boolean_type_node, condition);
4028 if (TREE_CODE (condition) == INTEGER_CST && !integer_zerop (condition))
4029 /* Do nothing; the condition is satisfied. */
4033 location_t saved_loc = input_location;
4035 input_location = location;
4036 if (TREE_CODE (condition) == INTEGER_CST
4037 && integer_zerop (condition))
4038 /* Report the error. */
4039 error ("static assertion failed: %E", message);
4040 else if (condition && condition != error_mark_node)
4041 error ("non-constant condition for static assertion");
4042 input_location = saved_loc;
4046 /* Implements the C++0x decltype keyword. Returns the type of EXPR,
4047 suitable for use as a type-specifier.
4049 ID_EXPRESSION_OR_MEMBER_ACCESS_P is true when EXPR was parsed as an
4050 id-expression or a class member access, FALSE when it was parsed as
4051 a full expression. */
4053 finish_decltype_type (tree expr, bool id_expression_or_member_access_p)
4055 tree orig_expr = expr;
4058 if (type_dependent_expression_p (expr))
4060 type = make_aggr_type (DECLTYPE_TYPE);
4061 DECLTYPE_TYPE_EXPR (type) = expr;
4062 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type)
4063 = id_expression_or_member_access_p;
4064 SET_TYPE_STRUCTURAL_EQUALITY (type);
4069 /* The type denoted by decltype(e) is defined as follows: */
4071 if (id_expression_or_member_access_p)
4073 /* If e is an id-expression or a class member access (5.2.5
4074 [expr.ref]), decltype(e) is defined as the type of the entity
4075 named by e. If there is no such entity, or e names a set of
4076 overloaded functions, the program is ill-formed. */
4077 if (TREE_CODE (expr) == IDENTIFIER_NODE)
4078 expr = lookup_name (expr);
4080 if (TREE_CODE (expr) == INDIRECT_REF)
4081 /* This can happen when the expression is, e.g., "a.b". Just
4082 look at the underlying operand. */
4083 expr = TREE_OPERAND (expr, 0);
4085 if (TREE_CODE (expr) == OFFSET_REF
4086 || TREE_CODE (expr) == MEMBER_REF)
4087 /* We're only interested in the field itself. If it is a
4088 BASELINK, we will need to see through it in the next
4090 expr = TREE_OPERAND (expr, 1);
4092 if (TREE_CODE (expr) == BASELINK)
4093 /* See through BASELINK nodes to the underlying functions. */
4094 expr = BASELINK_FUNCTIONS (expr);
4096 if (TREE_CODE (expr) == OVERLOAD)
4098 if (OVL_CHAIN (expr))
4100 error ("%qE refers to a set of overloaded functions", orig_expr);
4101 return error_mark_node;
4104 /* An overload set containing only one function: just look
4105 at that function. */
4106 expr = OVL_FUNCTION (expr);
4109 switch (TREE_CODE (expr))
4112 if (DECL_C_BIT_FIELD (expr))
4114 type = DECL_BIT_FIELD_TYPE (expr);
4117 /* Fall through for fields that aren't bitfields. */
4124 type = TREE_TYPE (expr);
4128 type = error_mark_node;
4132 type = is_bitfield_expr_with_lowered_type (expr);
4134 type = TREE_TYPE (TREE_OPERAND (expr, 1));
4141 /* We can get here when the id-expression refers to an
4143 type = TREE_TYPE (expr);
4147 gcc_assert (TYPE_P (expr) || DECL_P (expr));
4148 error ("argument to decltype must be an expression");
4149 return error_mark_node;
4156 if (TREE_CODE (expr) == CALL_EXPR
4157 && (fndecl = get_callee_fndecl (expr))
4158 && (fndecl != error_mark_node))
4159 /* If e is a function call (5.2.2 [expr.call]) or an
4160 invocation of an overloaded operator (parentheses around e
4161 are ignored), decltype(e) is defined as the return type of
4163 type = TREE_TYPE (TREE_TYPE (fndecl));
4166 type = is_bitfield_expr_with_lowered_type (expr);
4169 /* Bitfields are special, because their type encodes the
4170 number of bits they store. If the expression referenced a
4171 bitfield, TYPE now has the declared type of that
4173 type = cp_build_qualified_type (type,
4174 cp_type_quals (TREE_TYPE (expr)));
4176 if (real_lvalue_p (expr))
4177 type = build_reference_type (type);
4181 /* Otherwise, where T is the type of e, if e is an lvalue,
4182 decltype(e) is defined as T&, otherwise decltype(e) is
4184 type = TREE_TYPE (expr);
4185 if (expr == current_class_ptr)
4186 /* If the expression is just "this", we want the
4187 cv-unqualified pointer for the "this" type. */
4188 type = TYPE_MAIN_VARIANT (type);
4189 else if (real_lvalue_p (expr))
4191 if (TREE_CODE (type) != REFERENCE_TYPE)
4192 type = build_reference_type (type);
4195 type = non_reference (type);
4200 if (!type || type == unknown_type_node)
4202 error ("type of %qE is unknown", expr);
4203 return error_mark_node;
4209 /* Called from trait_expr_value to evaluate either __has_nothrow_assign or
4210 __has_nothrow_copy, depending on assign_p. */
4213 classtype_has_nothrow_assign_or_copy_p (tree type, bool assign_p)
4220 ix = lookup_fnfields_1 (type, ansi_assopname (NOP_EXPR));
4223 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix);
4225 else if (TYPE_HAS_INIT_REF (type))
4227 /* If construction of the copy constructor was postponed, create
4229 if (CLASSTYPE_LAZY_COPY_CTOR (type))
4230 lazily_declare_fn (sfk_copy_constructor, type);
4231 fns = CLASSTYPE_CONSTRUCTORS (type);
4236 for (; fns; fns = OVL_NEXT (fns))
4237 if (!TREE_NOTHROW (OVL_CURRENT (fns)))
4243 /* Actually evaluates the trait. */
4246 trait_expr_value (cp_trait_kind kind, tree type1, tree type2)
4248 enum tree_code type_code1;
4251 type_code1 = TREE_CODE (type1);
4255 case CPTK_HAS_NOTHROW_ASSIGN:
4256 return (!CP_TYPE_CONST_P (type1) && type_code1 != REFERENCE_TYPE
4257 && (trait_expr_value (CPTK_HAS_TRIVIAL_ASSIGN, type1, type2)
4258 || (CLASS_TYPE_P (type1)
4259 && classtype_has_nothrow_assign_or_copy_p (type1,
4262 case CPTK_HAS_TRIVIAL_ASSIGN:
4263 return (!CP_TYPE_CONST_P (type1) && type_code1 != REFERENCE_TYPE
4264 && (pod_type_p (type1)
4265 || (CLASS_TYPE_P (type1)
4266 && TYPE_HAS_TRIVIAL_ASSIGN_REF (type1))));
4268 case CPTK_HAS_NOTHROW_CONSTRUCTOR:
4269 type1 = strip_array_types (type1);
4270 return (trait_expr_value (CPTK_HAS_TRIVIAL_CONSTRUCTOR, type1, type2)
4271 || (CLASS_TYPE_P (type1)
4272 && (t = locate_ctor (type1, NULL)) && TREE_NOTHROW (t)));
4274 case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
4275 type1 = strip_array_types (type1);
4276 return (pod_type_p (type1)
4277 || (CLASS_TYPE_P (type1) && TYPE_HAS_TRIVIAL_DFLT (type1)));
4279 case CPTK_HAS_NOTHROW_COPY:
4280 return (trait_expr_value (CPTK_HAS_TRIVIAL_COPY, type1, type2)
4281 || (CLASS_TYPE_P (type1)
4282 && classtype_has_nothrow_assign_or_copy_p (type1, false)));
4284 case CPTK_HAS_TRIVIAL_COPY:
4285 return (pod_type_p (type1) || type_code1 == REFERENCE_TYPE
4286 || (CLASS_TYPE_P (type1) && TYPE_HAS_TRIVIAL_INIT_REF (type1)));
4288 case CPTK_HAS_TRIVIAL_DESTRUCTOR:
4289 type1 = strip_array_types (type1);
4290 return (pod_type_p (type1)
4291 || (CLASS_TYPE_P (type1)
4292 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type1)));
4294 case CPTK_HAS_VIRTUAL_DESTRUCTOR:
4295 return (CLASS_TYPE_P (type1)
4296 && (t = locate_dtor (type1, NULL)) && DECL_VIRTUAL_P (t));
4298 case CPTK_IS_ABSTRACT:
4299 return (CLASS_TYPE_P (type1) && CLASSTYPE_PURE_VIRTUALS (type1));
4301 case CPTK_IS_BASE_OF:
4302 return (NON_UNION_CLASS_TYPE_P (type1) && NON_UNION_CLASS_TYPE_P (type2)
4303 && DERIVED_FROM_P (type1, type2));
4306 return (NON_UNION_CLASS_TYPE_P (type1));
4308 case CPTK_IS_CONVERTIBLE_TO:
4313 return (NON_UNION_CLASS_TYPE_P (type1) && CLASSTYPE_EMPTY_P (type1));
4316 return (type_code1 == ENUMERAL_TYPE);
4319 return (pod_type_p (type1));
4321 case CPTK_IS_POLYMORPHIC:
4322 return (CLASS_TYPE_P (type1) && TYPE_POLYMORPHIC_P (type1));
4325 return (type_code1 == UNION_TYPE);
4333 /* Process a trait expression. */
4336 finish_trait_expr (cp_trait_kind kind, tree type1, tree type2)
4338 gcc_assert (kind == CPTK_HAS_NOTHROW_ASSIGN
4339 || kind == CPTK_HAS_NOTHROW_CONSTRUCTOR
4340 || kind == CPTK_HAS_NOTHROW_COPY
4341 || kind == CPTK_HAS_TRIVIAL_ASSIGN
4342 || kind == CPTK_HAS_TRIVIAL_CONSTRUCTOR
4343 || kind == CPTK_HAS_TRIVIAL_COPY
4344 || kind == CPTK_HAS_TRIVIAL_DESTRUCTOR
4345 || kind == CPTK_HAS_VIRTUAL_DESTRUCTOR
4346 || kind == CPTK_IS_ABSTRACT
4347 || kind == CPTK_IS_BASE_OF
4348 || kind == CPTK_IS_CLASS
4349 || kind == CPTK_IS_CONVERTIBLE_TO
4350 || kind == CPTK_IS_EMPTY
4351 || kind == CPTK_IS_ENUM
4352 || kind == CPTK_IS_POD
4353 || kind == CPTK_IS_POLYMORPHIC
4354 || kind == CPTK_IS_UNION);
4356 if (kind == CPTK_IS_CONVERTIBLE_TO)
4358 sorry ("__is_convertible_to");
4359 return error_mark_node;
4362 if (type1 == error_mark_node
4363 || ((kind == CPTK_IS_BASE_OF || kind == CPTK_IS_CONVERTIBLE_TO)
4364 && type2 == error_mark_node))
4365 return error_mark_node;
4367 if (processing_template_decl)
4369 tree trait_expr = make_node (TRAIT_EXPR);
4370 TREE_TYPE (trait_expr) = boolean_type_node;
4371 TRAIT_EXPR_TYPE1 (trait_expr) = type1;
4372 TRAIT_EXPR_TYPE2 (trait_expr) = type2;
4373 TRAIT_EXPR_KIND (trait_expr) = kind;
4377 complete_type (type1);
4379 complete_type (type2);
4381 /* The only required diagnostic. */
4382 if (kind == CPTK_IS_BASE_OF
4383 && NON_UNION_CLASS_TYPE_P (type1) && NON_UNION_CLASS_TYPE_P (type2)
4384 && !same_type_ignoring_top_level_qualifiers_p (type1, type2)
4385 && !COMPLETE_TYPE_P (type2))
4387 error ("incomplete type %qT not allowed", type2);
4388 return error_mark_node;
4391 return (trait_expr_value (kind, type1, type2)
4392 ? boolean_true_node : boolean_false_node);
4395 #include "gt-cp-semantics.h"