OSDN Git Service

2788daaba1eb38ae065054e8b6e05335b1323506
[pf3gnuchains/gcc-fork.git] / gcc / cp / semantics.c
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.
5
6    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
7                  2008, 2009, 2010, 2011 Free Software Foundation, Inc.
8    Written by Mark Mitchell (mmitchell@usa.net) based on code found
9    formerly in parse.y and pt.c.
10
11    This file is part of GCC.
12
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)
16    any later version.
17
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.
22
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/>.  */
26
27 #include "config.h"
28 #include "system.h"
29 #include "coretypes.h"
30 #include "tm.h"
31 #include "tree.h"
32 #include "cp-tree.h"
33 #include "c-family/c-common.h"
34 #include "c-family/c-objc.h"
35 #include "tree-inline.h"
36 #include "tree-mudflap.h"
37 #include "intl.h"
38 #include "toplev.h"
39 #include "flags.h"
40 #include "output.h"
41 #include "timevar.h"
42 #include "diagnostic.h"
43 #include "cgraph.h"
44 #include "tree-iterator.h"
45 #include "vec.h"
46 #include "target.h"
47 #include "gimple.h"
48 #include "bitmap.h"
49
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.  */
54
55 static tree maybe_convert_cond (tree);
56 static tree finalize_nrv_r (tree *, int *, void *);
57 static tree capture_decltype (tree);
58
59
60 /* Deferred Access Checking Overview
61    ---------------------------------
62
63    Most C++ expressions and declarations require access checking
64    to be performed during parsing.  However, in several cases,
65    this has to be treated differently.
66
67    For member declarations, access checking has to be deferred
68    until more information about the declaration is known.  For
69    example:
70
71      class A {
72          typedef int X;
73        public:
74          X f();
75      };
76
77      A::X A::f();
78      A::X g();
79
80    When we are parsing the function return type `A::X', we don't
81    really know if this is allowed until we parse the function name.
82
83    Furthermore, some contexts require that access checking is
84    never performed at all.  These include class heads, and template
85    instantiations.
86
87    Typical use of access checking functions is described here:
88
89    1. When we enter a context that requires certain access checking
90       mode, the function `push_deferring_access_checks' is called with
91       DEFERRING argument specifying the desired mode.  Access checking
92       may be performed immediately (dk_no_deferred), deferred
93       (dk_deferred), or not performed (dk_no_check).
94
95    2. When a declaration such as a type, or a variable, is encountered,
96       the function `perform_or_defer_access_check' is called.  It
97       maintains a VEC of all deferred checks.
98
99    3. The global `current_class_type' or `current_function_decl' is then
100       setup by the parser.  `enforce_access' relies on these information
101       to check access.
102
103    4. Upon exiting the context mentioned in step 1,
104       `perform_deferred_access_checks' is called to check all declaration
105       stored in the VEC. `pop_deferring_access_checks' is then
106       called to restore the previous access checking mode.
107
108       In case of parsing error, we simply call `pop_deferring_access_checks'
109       without `perform_deferred_access_checks'.  */
110
111 typedef struct GTY(()) deferred_access {
112   /* A VEC representing name-lookups for which we have deferred
113      checking access controls.  We cannot check the accessibility of
114      names used in a decl-specifier-seq until we know what is being
115      declared because code like:
116
117        class A {
118          class B {};
119          B* f();
120        }
121
122        A::B* A::f() { return 0; }
123
124      is valid, even though `A::B' is not generally accessible.  */
125   VEC (deferred_access_check,gc)* GTY(()) deferred_access_checks;
126
127   /* The current mode of access checks.  */
128   enum deferring_kind deferring_access_checks_kind;
129
130 } deferred_access;
131 DEF_VEC_O (deferred_access);
132 DEF_VEC_ALLOC_O (deferred_access,gc);
133
134 /* Data for deferred access checking.  */
135 static GTY(()) VEC(deferred_access,gc) *deferred_access_stack;
136 static GTY(()) unsigned deferred_access_no_check;
137
138 /* Save the current deferred access states and start deferred
139    access checking iff DEFER_P is true.  */
140
141 void
142 push_deferring_access_checks (deferring_kind deferring)
143 {
144   /* For context like template instantiation, access checking
145      disabling applies to all nested context.  */
146   if (deferred_access_no_check || deferring == dk_no_check)
147     deferred_access_no_check++;
148   else
149     {
150       deferred_access *ptr;
151
152       ptr = VEC_safe_push (deferred_access, gc, deferred_access_stack, NULL);
153       ptr->deferred_access_checks = NULL;
154       ptr->deferring_access_checks_kind = deferring;
155     }
156 }
157
158 /* Resume deferring access checks again after we stopped doing
159    this previously.  */
160
161 void
162 resume_deferring_access_checks (void)
163 {
164   if (!deferred_access_no_check)
165     VEC_last (deferred_access, deferred_access_stack)
166       ->deferring_access_checks_kind = dk_deferred;
167 }
168
169 /* Stop deferring access checks.  */
170
171 void
172 stop_deferring_access_checks (void)
173 {
174   if (!deferred_access_no_check)
175     VEC_last (deferred_access, deferred_access_stack)
176       ->deferring_access_checks_kind = dk_no_deferred;
177 }
178
179 /* Discard the current deferred access checks and restore the
180    previous states.  */
181
182 void
183 pop_deferring_access_checks (void)
184 {
185   if (deferred_access_no_check)
186     deferred_access_no_check--;
187   else
188     VEC_pop (deferred_access, deferred_access_stack);
189 }
190
191 /* Returns a TREE_LIST representing the deferred checks.
192    The TREE_PURPOSE of each node is the type through which the
193    access occurred; the TREE_VALUE is the declaration named.
194    */
195
196 VEC (deferred_access_check,gc)*
197 get_deferred_access_checks (void)
198 {
199   if (deferred_access_no_check)
200     return NULL;
201   else
202     return (VEC_last (deferred_access, deferred_access_stack)
203             ->deferred_access_checks);
204 }
205
206 /* Take current deferred checks and combine with the
207    previous states if we also defer checks previously.
208    Otherwise perform checks now.  */
209
210 void
211 pop_to_parent_deferring_access_checks (void)
212 {
213   if (deferred_access_no_check)
214     deferred_access_no_check--;
215   else
216     {
217       VEC (deferred_access_check,gc) *checks;
218       deferred_access *ptr;
219
220       checks = (VEC_last (deferred_access, deferred_access_stack)
221                 ->deferred_access_checks);
222
223       VEC_pop (deferred_access, deferred_access_stack);
224       ptr = VEC_last (deferred_access, deferred_access_stack);
225       if (ptr->deferring_access_checks_kind == dk_no_deferred)
226         {
227           /* Check access.  */
228           perform_access_checks (checks);
229         }
230       else
231         {
232           /* Merge with parent.  */
233           int i, j;
234           deferred_access_check *chk, *probe;
235
236           FOR_EACH_VEC_ELT (deferred_access_check, checks, i, chk)
237             {
238               FOR_EACH_VEC_ELT (deferred_access_check,
239                                 ptr->deferred_access_checks, j, probe)
240                 {
241                   if (probe->binfo == chk->binfo &&
242                       probe->decl == chk->decl &&
243                       probe->diag_decl == chk->diag_decl)
244                     goto found;
245                 }
246               /* Insert into parent's checks.  */
247               VEC_safe_push (deferred_access_check, gc,
248                              ptr->deferred_access_checks, chk);
249             found:;
250             }
251         }
252     }
253 }
254
255 /* Perform the access checks in CHECKS.  The TREE_PURPOSE of each node
256    is the BINFO indicating the qualifying scope used to access the
257    DECL node stored in the TREE_VALUE of the node.  */
258
259 void
260 perform_access_checks (VEC (deferred_access_check,gc)* checks)
261 {
262   int i;
263   deferred_access_check *chk;
264
265   if (!checks)
266     return;
267
268   FOR_EACH_VEC_ELT (deferred_access_check, checks, i, chk)
269     enforce_access (chk->binfo, chk->decl, chk->diag_decl);
270 }
271
272 /* Perform the deferred access checks.
273
274    After performing the checks, we still have to keep the list
275    `deferred_access_stack->deferred_access_checks' since we may want
276    to check access for them again later in a different context.
277    For example:
278
279      class A {
280        typedef int X;
281        static X a;
282      };
283      A::X A::a, x;      // No error for `A::a', error for `x'
284
285    We have to perform deferred access of `A::X', first with `A::a',
286    next with `x'.  */
287
288 void
289 perform_deferred_access_checks (void)
290 {
291   perform_access_checks (get_deferred_access_checks ());
292 }
293
294 /* Defer checking the accessibility of DECL, when looked up in
295    BINFO. DIAG_DECL is the declaration to use to print diagnostics.  */
296
297 void
298 perform_or_defer_access_check (tree binfo, tree decl, tree diag_decl)
299 {
300   int i;
301   deferred_access *ptr;
302   deferred_access_check *chk;
303   deferred_access_check *new_access;
304
305
306   /* Exit if we are in a context that no access checking is performed.
307      */
308   if (deferred_access_no_check)
309     return;
310
311   gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
312
313   ptr = VEC_last (deferred_access, deferred_access_stack);
314
315   /* If we are not supposed to defer access checks, just check now.  */
316   if (ptr->deferring_access_checks_kind == dk_no_deferred)
317     {
318       enforce_access (binfo, decl, diag_decl);
319       return;
320     }
321
322   /* See if we are already going to perform this check.  */
323   FOR_EACH_VEC_ELT  (deferred_access_check,
324                      ptr->deferred_access_checks, i, chk)
325     {
326       if (chk->decl == decl && chk->binfo == binfo &&
327           chk->diag_decl == diag_decl)
328         {
329           return;
330         }
331     }
332   /* If not, record the check.  */
333   new_access =
334     VEC_safe_push (deferred_access_check, gc,
335                    ptr->deferred_access_checks, 0);
336   new_access->binfo = binfo;
337   new_access->decl = decl;
338   new_access->diag_decl = diag_decl;
339 }
340
341 /* Used by build_over_call in LOOKUP_SPECULATIVE mode: return whether DECL
342    is accessible in BINFO, and possibly complain if not.  If we're not
343    checking access, everything is accessible.  */
344
345 bool
346 speculative_access_check (tree binfo, tree decl, tree diag_decl,
347                           bool complain)
348 {
349   if (deferred_access_no_check)
350     return true;
351
352   /* If we're checking for implicit delete, we don't want access
353      control errors.  */
354   if (!accessible_p (binfo, decl, true))
355     {
356       /* Unless we're under maybe_explain_implicit_delete.  */
357       if (complain)
358         enforce_access (binfo, decl, diag_decl);
359       return false;
360     }
361
362   return true;
363 }
364
365 /* Returns nonzero if the current statement is a full expression,
366    i.e. temporaries created during that statement should be destroyed
367    at the end of the statement.  */
368
369 int
370 stmts_are_full_exprs_p (void)
371 {
372   return current_stmt_tree ()->stmts_are_full_exprs_p;
373 }
374
375 /* T is a statement.  Add it to the statement-tree.  This is the C++
376    version.  The C/ObjC frontends have a slightly different version of
377    this function.  */
378
379 tree
380 add_stmt (tree t)
381 {
382   enum tree_code code = TREE_CODE (t);
383
384   if (EXPR_P (t) && code != LABEL_EXPR)
385     {
386       if (!EXPR_HAS_LOCATION (t))
387         SET_EXPR_LOCATION (t, input_location);
388
389       /* When we expand a statement-tree, we must know whether or not the
390          statements are full-expressions.  We record that fact here.  */
391       STMT_IS_FULL_EXPR_P (t) = stmts_are_full_exprs_p ();
392     }
393
394   /* Add T to the statement-tree.  Non-side-effect statements need to be
395      recorded during statement expressions.  */
396   gcc_checking_assert (!VEC_empty (tree, stmt_list_stack));
397   append_to_statement_list_force (t, &cur_stmt_list);
398
399   return t;
400 }
401
402 /* Returns the stmt_tree to which statements are currently being added.  */
403
404 stmt_tree
405 current_stmt_tree (void)
406 {
407   return (cfun
408           ? &cfun->language->base.x_stmt_tree
409           : &scope_chain->x_stmt_tree);
410 }
411
412 /* If statements are full expressions, wrap STMT in a CLEANUP_POINT_EXPR.  */
413
414 static tree
415 maybe_cleanup_point_expr (tree expr)
416 {
417   if (!processing_template_decl && stmts_are_full_exprs_p ())
418     expr = fold_build_cleanup_point_expr (TREE_TYPE (expr), expr);
419   return expr;
420 }
421
422 /* Like maybe_cleanup_point_expr except have the type of the new expression be
423    void so we don't need to create a temporary variable to hold the inner
424    expression.  The reason why we do this is because the original type might be
425    an aggregate and we cannot create a temporary variable for that type.  */
426
427 tree
428 maybe_cleanup_point_expr_void (tree expr)
429 {
430   if (!processing_template_decl && stmts_are_full_exprs_p ())
431     expr = fold_build_cleanup_point_expr (void_type_node, expr);
432   return expr;
433 }
434
435
436
437 /* Create a declaration statement for the declaration given by the DECL.  */
438
439 void
440 add_decl_expr (tree decl)
441 {
442   tree r = build_stmt (input_location, DECL_EXPR, decl);
443   if (DECL_INITIAL (decl)
444       || (DECL_SIZE (decl) && TREE_SIDE_EFFECTS (DECL_SIZE (decl))))
445     r = maybe_cleanup_point_expr_void (r);
446   add_stmt (r);
447 }
448
449 /* Finish a scope.  */
450
451 tree
452 do_poplevel (tree stmt_list)
453 {
454   tree block = NULL;
455
456   if (stmts_are_full_exprs_p ())
457     block = poplevel (kept_level_p (), 1, 0);
458
459   stmt_list = pop_stmt_list (stmt_list);
460
461   if (!processing_template_decl)
462     {
463       stmt_list = c_build_bind_expr (input_location, block, stmt_list);
464       /* ??? See c_end_compound_stmt re statement expressions.  */
465     }
466
467   return stmt_list;
468 }
469
470 /* Begin a new scope.  */
471
472 static tree
473 do_pushlevel (scope_kind sk)
474 {
475   tree ret = push_stmt_list ();
476   if (stmts_are_full_exprs_p ())
477     begin_scope (sk, NULL);
478   return ret;
479 }
480
481 /* Queue a cleanup.  CLEANUP is an expression/statement to be executed
482    when the current scope is exited.  EH_ONLY is true when this is not
483    meant to apply to normal control flow transfer.  */
484
485 void
486 push_cleanup (tree decl, tree cleanup, bool eh_only)
487 {
488   tree stmt = build_stmt (input_location, CLEANUP_STMT, NULL, cleanup, decl);
489   CLEANUP_EH_ONLY (stmt) = eh_only;
490   add_stmt (stmt);
491   CLEANUP_BODY (stmt) = push_stmt_list ();
492 }
493
494 /* Begin a conditional that might contain a declaration.  When generating
495    normal code, we want the declaration to appear before the statement
496    containing the conditional.  When generating template code, we want the
497    conditional to be rendered as the raw DECL_EXPR.  */
498
499 static void
500 begin_cond (tree *cond_p)
501 {
502   if (processing_template_decl)
503     *cond_p = push_stmt_list ();
504 }
505
506 /* Finish such a conditional.  */
507
508 static void
509 finish_cond (tree *cond_p, tree expr)
510 {
511   if (processing_template_decl)
512     {
513       tree cond = pop_stmt_list (*cond_p);
514       if (TREE_CODE (cond) == DECL_EXPR)
515         expr = cond;
516
517       if (check_for_bare_parameter_packs (expr))
518         *cond_p = error_mark_node;
519     }
520   *cond_p = expr;
521 }
522
523 /* If *COND_P specifies a conditional with a declaration, transform the
524    loop such that
525             while (A x = 42) { }
526             for (; A x = 42;) { }
527    becomes
528             while (true) { A x = 42; if (!x) break; }
529             for (;;) { A x = 42; if (!x) break; }
530    The statement list for BODY will be empty if the conditional did
531    not declare anything.  */
532
533 static void
534 simplify_loop_decl_cond (tree *cond_p, tree body)
535 {
536   tree cond, if_stmt;
537
538   if (!TREE_SIDE_EFFECTS (body))
539     return;
540
541   cond = *cond_p;
542   *cond_p = boolean_true_node;
543
544   if_stmt = begin_if_stmt ();
545   cond = cp_build_unary_op (TRUTH_NOT_EXPR, cond, 0, tf_warning_or_error);
546   finish_if_stmt_cond (cond, if_stmt);
547   finish_break_stmt ();
548   finish_then_clause (if_stmt);
549   finish_if_stmt (if_stmt);
550 }
551
552 /* Finish a goto-statement.  */
553
554 tree
555 finish_goto_stmt (tree destination)
556 {
557   if (TREE_CODE (destination) == IDENTIFIER_NODE)
558     destination = lookup_label (destination);
559
560   /* We warn about unused labels with -Wunused.  That means we have to
561      mark the used labels as used.  */
562   if (TREE_CODE (destination) == LABEL_DECL)
563     TREE_USED (destination) = 1;
564   else
565     {
566       destination = mark_rvalue_use (destination);
567       if (!processing_template_decl)
568         {
569           destination = cp_convert (ptr_type_node, destination);
570           if (error_operand_p (destination))
571             return NULL_TREE;
572         }
573     }
574
575   check_goto (destination);
576
577   return add_stmt (build_stmt (input_location, GOTO_EXPR, destination));
578 }
579
580 /* COND is the condition-expression for an if, while, etc.,
581    statement.  Convert it to a boolean value, if appropriate.
582    In addition, verify sequence points if -Wsequence-point is enabled.  */
583
584 static tree
585 maybe_convert_cond (tree cond)
586 {
587   /* Empty conditions remain empty.  */
588   if (!cond)
589     return NULL_TREE;
590
591   /* Wait until we instantiate templates before doing conversion.  */
592   if (processing_template_decl)
593     return cond;
594
595   if (warn_sequence_point)
596     verify_sequence_points (cond);
597
598   /* Do the conversion.  */
599   cond = convert_from_reference (cond);
600
601   if (TREE_CODE (cond) == MODIFY_EXPR
602       && !TREE_NO_WARNING (cond)
603       && warn_parentheses)
604     {
605       warning (OPT_Wparentheses,
606                "suggest parentheses around assignment used as truth value");
607       TREE_NO_WARNING (cond) = 1;
608     }
609
610   return condition_conversion (cond);
611 }
612
613 /* Finish an expression-statement, whose EXPRESSION is as indicated.  */
614
615 tree
616 finish_expr_stmt (tree expr)
617 {
618   tree r = NULL_TREE;
619
620   if (expr != NULL_TREE)
621     {
622       if (!processing_template_decl)
623         {
624           if (warn_sequence_point)
625             verify_sequence_points (expr);
626           expr = convert_to_void (expr, ICV_STATEMENT, tf_warning_or_error);
627         }
628       else if (!type_dependent_expression_p (expr))
629         convert_to_void (build_non_dependent_expr (expr), ICV_STATEMENT, 
630                          tf_warning_or_error);
631
632       if (check_for_bare_parameter_packs (expr))
633         expr = error_mark_node;
634
635       /* Simplification of inner statement expressions, compound exprs,
636          etc can result in us already having an EXPR_STMT.  */
637       if (TREE_CODE (expr) != CLEANUP_POINT_EXPR)
638         {
639           if (TREE_CODE (expr) != EXPR_STMT)
640             expr = build_stmt (input_location, EXPR_STMT, expr);
641           expr = maybe_cleanup_point_expr_void (expr);
642         }
643
644       r = add_stmt (expr);
645     }
646
647   finish_stmt ();
648
649   return r;
650 }
651
652
653 /* Begin an if-statement.  Returns a newly created IF_STMT if
654    appropriate.  */
655
656 tree
657 begin_if_stmt (void)
658 {
659   tree r, scope;
660   scope = do_pushlevel (sk_cond);
661   r = build_stmt (input_location, IF_STMT, NULL_TREE,
662                   NULL_TREE, NULL_TREE, scope);
663   begin_cond (&IF_COND (r));
664   return r;
665 }
666
667 /* Process the COND of an if-statement, which may be given by
668    IF_STMT.  */
669
670 void
671 finish_if_stmt_cond (tree cond, tree if_stmt)
672 {
673   finish_cond (&IF_COND (if_stmt), maybe_convert_cond (cond));
674   add_stmt (if_stmt);
675   THEN_CLAUSE (if_stmt) = push_stmt_list ();
676 }
677
678 /* Finish the then-clause of an if-statement, which may be given by
679    IF_STMT.  */
680
681 tree
682 finish_then_clause (tree if_stmt)
683 {
684   THEN_CLAUSE (if_stmt) = pop_stmt_list (THEN_CLAUSE (if_stmt));
685   return if_stmt;
686 }
687
688 /* Begin the else-clause of an if-statement.  */
689
690 void
691 begin_else_clause (tree if_stmt)
692 {
693   ELSE_CLAUSE (if_stmt) = push_stmt_list ();
694 }
695
696 /* Finish the else-clause of an if-statement, which may be given by
697    IF_STMT.  */
698
699 void
700 finish_else_clause (tree if_stmt)
701 {
702   ELSE_CLAUSE (if_stmt) = pop_stmt_list (ELSE_CLAUSE (if_stmt));
703 }
704
705 /* Finish an if-statement.  */
706
707 void
708 finish_if_stmt (tree if_stmt)
709 {
710   tree scope = IF_SCOPE (if_stmt);
711   IF_SCOPE (if_stmt) = NULL;
712   add_stmt (do_poplevel (scope));
713   finish_stmt ();
714 }
715
716 /* Begin a while-statement.  Returns a newly created WHILE_STMT if
717    appropriate.  */
718
719 tree
720 begin_while_stmt (void)
721 {
722   tree r;
723   r = build_stmt (input_location, WHILE_STMT, NULL_TREE, NULL_TREE);
724   add_stmt (r);
725   WHILE_BODY (r) = do_pushlevel (sk_block);
726   begin_cond (&WHILE_COND (r));
727   return r;
728 }
729
730 /* Process the COND of a while-statement, which may be given by
731    WHILE_STMT.  */
732
733 void
734 finish_while_stmt_cond (tree cond, tree while_stmt)
735 {
736   finish_cond (&WHILE_COND (while_stmt), maybe_convert_cond (cond));
737   simplify_loop_decl_cond (&WHILE_COND (while_stmt), WHILE_BODY (while_stmt));
738 }
739
740 /* Finish a while-statement, which may be given by WHILE_STMT.  */
741
742 void
743 finish_while_stmt (tree while_stmt)
744 {
745   WHILE_BODY (while_stmt) = do_poplevel (WHILE_BODY (while_stmt));
746   finish_stmt ();
747 }
748
749 /* Begin a do-statement.  Returns a newly created DO_STMT if
750    appropriate.  */
751
752 tree
753 begin_do_stmt (void)
754 {
755   tree r = build_stmt (input_location, DO_STMT, NULL_TREE, NULL_TREE);
756   add_stmt (r);
757   DO_BODY (r) = push_stmt_list ();
758   return r;
759 }
760
761 /* Finish the body of a do-statement, which may be given by DO_STMT.  */
762
763 void
764 finish_do_body (tree do_stmt)
765 {
766   tree body = DO_BODY (do_stmt) = pop_stmt_list (DO_BODY (do_stmt));
767
768   if (TREE_CODE (body) == STATEMENT_LIST && STATEMENT_LIST_TAIL (body))
769     body = STATEMENT_LIST_TAIL (body)->stmt;
770
771   if (IS_EMPTY_STMT (body))
772     warning (OPT_Wempty_body,
773             "suggest explicit braces around empty body in %<do%> statement");
774 }
775
776 /* Finish a do-statement, which may be given by DO_STMT, and whose
777    COND is as indicated.  */
778
779 void
780 finish_do_stmt (tree cond, tree do_stmt)
781 {
782   cond = maybe_convert_cond (cond);
783   DO_COND (do_stmt) = cond;
784   finish_stmt ();
785 }
786
787 /* Finish a return-statement.  The EXPRESSION returned, if any, is as
788    indicated.  */
789
790 tree
791 finish_return_stmt (tree expr)
792 {
793   tree r;
794   bool no_warning;
795
796   expr = check_return_expr (expr, &no_warning);
797
798   if (flag_openmp && !check_omp_return ())
799     return error_mark_node;
800   if (!processing_template_decl)
801     {
802       if (warn_sequence_point)
803         verify_sequence_points (expr);
804       
805       if (DECL_DESTRUCTOR_P (current_function_decl)
806           || (DECL_CONSTRUCTOR_P (current_function_decl)
807               && targetm.cxx.cdtor_returns_this ()))
808         {
809           /* Similarly, all destructors must run destructors for
810              base-classes before returning.  So, all returns in a
811              destructor get sent to the DTOR_LABEL; finish_function emits
812              code to return a value there.  */
813           return finish_goto_stmt (cdtor_label);
814         }
815     }
816
817   r = build_stmt (input_location, RETURN_EXPR, expr);
818   TREE_NO_WARNING (r) |= no_warning;
819   r = maybe_cleanup_point_expr_void (r);
820   r = add_stmt (r);
821   finish_stmt ();
822
823   return r;
824 }
825
826 /* Begin the scope of a for-statement or a range-for-statement.
827    Both the returned trees are to be used in a call to
828    begin_for_stmt or begin_range_for_stmt.  */
829
830 tree
831 begin_for_scope (tree *init)
832 {
833   tree scope = NULL_TREE;
834   if (flag_new_for_scope > 0)
835     scope = do_pushlevel (sk_for);
836
837   if (processing_template_decl)
838     *init = push_stmt_list ();
839   else
840     *init = NULL_TREE;
841
842   return scope;
843 }
844
845 /* Begin a for-statement.  Returns a new FOR_STMT.
846    SCOPE and INIT should be the return of begin_for_scope,
847    or both NULL_TREE  */
848
849 tree
850 begin_for_stmt (tree scope, tree init)
851 {
852   tree r;
853
854   r = build_stmt (input_location, FOR_STMT, NULL_TREE, NULL_TREE,
855                   NULL_TREE, NULL_TREE, NULL_TREE);
856
857   if (scope == NULL_TREE)
858     {
859       gcc_assert (!init || !(flag_new_for_scope > 0));
860       if (!init)
861         scope = begin_for_scope (&init);
862     }
863   FOR_INIT_STMT (r) = init;
864   FOR_SCOPE (r) = scope;
865
866   return r;
867 }
868
869 /* Finish the for-init-statement of a for-statement, which may be
870    given by FOR_STMT.  */
871
872 void
873 finish_for_init_stmt (tree for_stmt)
874 {
875   if (processing_template_decl)
876     FOR_INIT_STMT (for_stmt) = pop_stmt_list (FOR_INIT_STMT (for_stmt));
877   add_stmt (for_stmt);
878   FOR_BODY (for_stmt) = do_pushlevel (sk_block);
879   begin_cond (&FOR_COND (for_stmt));
880 }
881
882 /* Finish the COND of a for-statement, which may be given by
883    FOR_STMT.  */
884
885 void
886 finish_for_cond (tree cond, tree for_stmt)
887 {
888   finish_cond (&FOR_COND (for_stmt), maybe_convert_cond (cond));
889   simplify_loop_decl_cond (&FOR_COND (for_stmt), FOR_BODY (for_stmt));
890 }
891
892 /* Finish the increment-EXPRESSION in a for-statement, which may be
893    given by FOR_STMT.  */
894
895 void
896 finish_for_expr (tree expr, tree for_stmt)
897 {
898   if (!expr)
899     return;
900   /* If EXPR is an overloaded function, issue an error; there is no
901      context available to use to perform overload resolution.  */
902   if (type_unknown_p (expr))
903     {
904       cxx_incomplete_type_error (expr, TREE_TYPE (expr));
905       expr = error_mark_node;
906     }
907   if (!processing_template_decl)
908     {
909       if (warn_sequence_point)
910         verify_sequence_points (expr);
911       expr = convert_to_void (expr, ICV_THIRD_IN_FOR,
912                               tf_warning_or_error);
913     }
914   else if (!type_dependent_expression_p (expr))
915     convert_to_void (build_non_dependent_expr (expr), ICV_THIRD_IN_FOR,
916                      tf_warning_or_error);
917   expr = maybe_cleanup_point_expr_void (expr);
918   if (check_for_bare_parameter_packs (expr))
919     expr = error_mark_node;
920   FOR_EXPR (for_stmt) = expr;
921 }
922
923 /* Finish the body of a for-statement, which may be given by
924    FOR_STMT.  The increment-EXPR for the loop must be
925    provided.
926    It can also finish RANGE_FOR_STMT. */
927
928 void
929 finish_for_stmt (tree for_stmt)
930 {
931   if (TREE_CODE (for_stmt) == RANGE_FOR_STMT)
932     RANGE_FOR_BODY (for_stmt) = do_poplevel (RANGE_FOR_BODY (for_stmt));
933   else
934     FOR_BODY (for_stmt) = do_poplevel (FOR_BODY (for_stmt));
935
936   /* Pop the scope for the body of the loop.  */
937   if (flag_new_for_scope > 0)
938     {
939       tree scope;
940       tree *scope_ptr = (TREE_CODE (for_stmt) == RANGE_FOR_STMT
941                          ? &RANGE_FOR_SCOPE (for_stmt)
942                          : &FOR_SCOPE (for_stmt));
943       scope = *scope_ptr;
944       *scope_ptr = NULL;
945       add_stmt (do_poplevel (scope));
946     }
947
948   finish_stmt ();
949 }
950
951 /* Begin a range-for-statement.  Returns a new RANGE_FOR_STMT.
952    SCOPE and INIT should be the return of begin_for_scope,
953    or both NULL_TREE  .
954    To finish it call finish_for_stmt(). */
955
956 tree
957 begin_range_for_stmt (tree scope, tree init)
958 {
959   tree r;
960
961   r = build_stmt (input_location, RANGE_FOR_STMT,
962                   NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE);
963
964   if (scope == NULL_TREE)
965     {
966       gcc_assert (!init || !(flag_new_for_scope > 0));
967       if (!init)
968         scope = begin_for_scope (&init);
969     }
970
971   /* RANGE_FOR_STMTs do not use nor save the init tree, so we
972      pop it now.  */
973   if (init)
974     pop_stmt_list (init);
975   RANGE_FOR_SCOPE (r) = scope;
976
977   return r;
978 }
979
980 /* Finish the head of a range-based for statement, which may
981    be given by RANGE_FOR_STMT. DECL must be the declaration
982    and EXPR must be the loop expression. */
983
984 void
985 finish_range_for_decl (tree range_for_stmt, tree decl, tree expr)
986 {
987   RANGE_FOR_DECL (range_for_stmt) = decl;
988   RANGE_FOR_EXPR (range_for_stmt) = expr;
989   add_stmt (range_for_stmt);
990   RANGE_FOR_BODY (range_for_stmt) = do_pushlevel (sk_block);
991 }
992
993 /* Finish a break-statement.  */
994
995 tree
996 finish_break_stmt (void)
997 {
998   return add_stmt (build_stmt (input_location, BREAK_STMT));
999 }
1000
1001 /* Finish a continue-statement.  */
1002
1003 tree
1004 finish_continue_stmt (void)
1005 {
1006   return add_stmt (build_stmt (input_location, CONTINUE_STMT));
1007 }
1008
1009 /* Begin a switch-statement.  Returns a new SWITCH_STMT if
1010    appropriate.  */
1011
1012 tree
1013 begin_switch_stmt (void)
1014 {
1015   tree r, scope;
1016
1017   scope = do_pushlevel (sk_cond);
1018   r = build_stmt (input_location, SWITCH_STMT, NULL_TREE, NULL_TREE, NULL_TREE, scope);
1019
1020   begin_cond (&SWITCH_STMT_COND (r));
1021
1022   return r;
1023 }
1024
1025 /* Finish the cond of a switch-statement.  */
1026
1027 void
1028 finish_switch_cond (tree cond, tree switch_stmt)
1029 {
1030   tree orig_type = NULL;
1031   if (!processing_template_decl)
1032     {
1033       /* Convert the condition to an integer or enumeration type.  */
1034       cond = build_expr_type_conversion (WANT_INT | WANT_ENUM, cond, true);
1035       if (cond == NULL_TREE)
1036         {
1037           error ("switch quantity not an integer");
1038           cond = error_mark_node;
1039         }
1040       orig_type = TREE_TYPE (cond);
1041       if (cond != error_mark_node)
1042         {
1043           /* [stmt.switch]
1044
1045              Integral promotions are performed.  */
1046           cond = perform_integral_promotions (cond);
1047           cond = maybe_cleanup_point_expr (cond);
1048         }
1049     }
1050   if (check_for_bare_parameter_packs (cond))
1051     cond = error_mark_node;
1052   else if (!processing_template_decl && warn_sequence_point)
1053     verify_sequence_points (cond);
1054
1055   finish_cond (&SWITCH_STMT_COND (switch_stmt), cond);
1056   SWITCH_STMT_TYPE (switch_stmt) = orig_type;
1057   add_stmt (switch_stmt);
1058   push_switch (switch_stmt);
1059   SWITCH_STMT_BODY (switch_stmt) = push_stmt_list ();
1060 }
1061
1062 /* Finish the body of a switch-statement, which may be given by
1063    SWITCH_STMT.  The COND to switch on is indicated.  */
1064
1065 void
1066 finish_switch_stmt (tree switch_stmt)
1067 {
1068   tree scope;
1069
1070   SWITCH_STMT_BODY (switch_stmt) =
1071     pop_stmt_list (SWITCH_STMT_BODY (switch_stmt));
1072   pop_switch ();
1073   finish_stmt ();
1074
1075   scope = SWITCH_STMT_SCOPE (switch_stmt);
1076   SWITCH_STMT_SCOPE (switch_stmt) = NULL;
1077   add_stmt (do_poplevel (scope));
1078 }
1079
1080 /* Begin a try-block.  Returns a newly-created TRY_BLOCK if
1081    appropriate.  */
1082
1083 tree
1084 begin_try_block (void)
1085 {
1086   tree r = build_stmt (input_location, TRY_BLOCK, NULL_TREE, NULL_TREE);
1087   add_stmt (r);
1088   TRY_STMTS (r) = push_stmt_list ();
1089   return r;
1090 }
1091
1092 /* Likewise, for a function-try-block.  The block returned in
1093    *COMPOUND_STMT is an artificial outer scope, containing the
1094    function-try-block.  */
1095
1096 tree
1097 begin_function_try_block (tree *compound_stmt)
1098 {
1099   tree r;
1100   /* This outer scope does not exist in the C++ standard, but we need
1101      a place to put __FUNCTION__ and similar variables.  */
1102   *compound_stmt = begin_compound_stmt (0);
1103   r = begin_try_block ();
1104   FN_TRY_BLOCK_P (r) = 1;
1105   return r;
1106 }
1107
1108 /* Finish a try-block, which may be given by TRY_BLOCK.  */
1109
1110 void
1111 finish_try_block (tree try_block)
1112 {
1113   TRY_STMTS (try_block) = pop_stmt_list (TRY_STMTS (try_block));
1114   TRY_HANDLERS (try_block) = push_stmt_list ();
1115 }
1116
1117 /* Finish the body of a cleanup try-block, which may be given by
1118    TRY_BLOCK.  */
1119
1120 void
1121 finish_cleanup_try_block (tree try_block)
1122 {
1123   TRY_STMTS (try_block) = pop_stmt_list (TRY_STMTS (try_block));
1124 }
1125
1126 /* Finish an implicitly generated try-block, with a cleanup is given
1127    by CLEANUP.  */
1128
1129 void
1130 finish_cleanup (tree cleanup, tree try_block)
1131 {
1132   TRY_HANDLERS (try_block) = cleanup;
1133   CLEANUP_P (try_block) = 1;
1134 }
1135
1136 /* Likewise, for a function-try-block.  */
1137
1138 void
1139 finish_function_try_block (tree try_block)
1140 {
1141   finish_try_block (try_block);
1142   /* FIXME : something queer about CTOR_INITIALIZER somehow following
1143      the try block, but moving it inside.  */
1144   in_function_try_handler = 1;
1145 }
1146
1147 /* Finish a handler-sequence for a try-block, which may be given by
1148    TRY_BLOCK.  */
1149
1150 void
1151 finish_handler_sequence (tree try_block)
1152 {
1153   TRY_HANDLERS (try_block) = pop_stmt_list (TRY_HANDLERS (try_block));
1154   check_handlers (TRY_HANDLERS (try_block));
1155 }
1156
1157 /* Finish the handler-seq for a function-try-block, given by
1158    TRY_BLOCK.  COMPOUND_STMT is the outer block created by
1159    begin_function_try_block.  */
1160
1161 void
1162 finish_function_handler_sequence (tree try_block, tree compound_stmt)
1163 {
1164   in_function_try_handler = 0;
1165   finish_handler_sequence (try_block);
1166   finish_compound_stmt (compound_stmt);
1167 }
1168
1169 /* Begin a handler.  Returns a HANDLER if appropriate.  */
1170
1171 tree
1172 begin_handler (void)
1173 {
1174   tree r;
1175
1176   r = build_stmt (input_location, HANDLER, NULL_TREE, NULL_TREE);
1177   add_stmt (r);
1178
1179   /* Create a binding level for the eh_info and the exception object
1180      cleanup.  */
1181   HANDLER_BODY (r) = do_pushlevel (sk_catch);
1182
1183   return r;
1184 }
1185
1186 /* Finish the handler-parameters for a handler, which may be given by
1187    HANDLER.  DECL is the declaration for the catch parameter, or NULL
1188    if this is a `catch (...)' clause.  */
1189
1190 void
1191 finish_handler_parms (tree decl, tree handler)
1192 {
1193   tree type = NULL_TREE;
1194   if (processing_template_decl)
1195     {
1196       if (decl)
1197         {
1198           decl = pushdecl (decl);
1199           decl = push_template_decl (decl);
1200           HANDLER_PARMS (handler) = decl;
1201           type = TREE_TYPE (decl);
1202         }
1203     }
1204   else
1205     type = expand_start_catch_block (decl);
1206   HANDLER_TYPE (handler) = type;
1207   if (!processing_template_decl && type)
1208     mark_used (eh_type_info (type));
1209 }
1210
1211 /* Finish a handler, which may be given by HANDLER.  The BLOCKs are
1212    the return value from the matching call to finish_handler_parms.  */
1213
1214 void
1215 finish_handler (tree handler)
1216 {
1217   if (!processing_template_decl)
1218     expand_end_catch_block ();
1219   HANDLER_BODY (handler) = do_poplevel (HANDLER_BODY (handler));
1220 }
1221
1222 /* Begin a compound statement.  FLAGS contains some bits that control the
1223    behavior and context.  If BCS_NO_SCOPE is set, the compound statement
1224    does not define a scope.  If BCS_FN_BODY is set, this is the outermost
1225    block of a function.  If BCS_TRY_BLOCK is set, this is the block
1226    created on behalf of a TRY statement.  Returns a token to be passed to
1227    finish_compound_stmt.  */
1228
1229 tree
1230 begin_compound_stmt (unsigned int flags)
1231 {
1232   tree r;
1233
1234   if (flags & BCS_NO_SCOPE)
1235     {
1236       r = push_stmt_list ();
1237       STATEMENT_LIST_NO_SCOPE (r) = 1;
1238
1239       /* Normally, we try hard to keep the BLOCK for a statement-expression.
1240          But, if it's a statement-expression with a scopeless block, there's
1241          nothing to keep, and we don't want to accidentally keep a block
1242          *inside* the scopeless block.  */
1243       keep_next_level (false);
1244     }
1245   else
1246     r = do_pushlevel (flags & BCS_TRY_BLOCK ? sk_try : sk_block);
1247
1248   /* When processing a template, we need to remember where the braces were,
1249      so that we can set up identical scopes when instantiating the template
1250      later.  BIND_EXPR is a handy candidate for this.
1251      Note that do_poplevel won't create a BIND_EXPR itself here (and thus
1252      result in nested BIND_EXPRs), since we don't build BLOCK nodes when
1253      processing templates.  */
1254   if (processing_template_decl)
1255     {
1256       r = build3 (BIND_EXPR, NULL, NULL, r, NULL);
1257       BIND_EXPR_TRY_BLOCK (r) = (flags & BCS_TRY_BLOCK) != 0;
1258       BIND_EXPR_BODY_BLOCK (r) = (flags & BCS_FN_BODY) != 0;
1259       TREE_SIDE_EFFECTS (r) = 1;
1260     }
1261
1262   return r;
1263 }
1264
1265 /* Finish a compound-statement, which is given by STMT.  */
1266
1267 void
1268 finish_compound_stmt (tree stmt)
1269 {
1270   if (TREE_CODE (stmt) == BIND_EXPR)
1271     {
1272       tree body = do_poplevel (BIND_EXPR_BODY (stmt));
1273       /* If the STATEMENT_LIST is empty and this BIND_EXPR isn't special,
1274          discard the BIND_EXPR so it can be merged with the containing
1275          STATEMENT_LIST.  */
1276       if (TREE_CODE (body) == STATEMENT_LIST
1277           && STATEMENT_LIST_HEAD (body) == NULL
1278           && !BIND_EXPR_BODY_BLOCK (stmt)
1279           && !BIND_EXPR_TRY_BLOCK (stmt))
1280         stmt = body;
1281       else
1282         BIND_EXPR_BODY (stmt) = body;
1283     }
1284   else if (STATEMENT_LIST_NO_SCOPE (stmt))
1285     stmt = pop_stmt_list (stmt);
1286   else
1287     {
1288       /* Destroy any ObjC "super" receivers that may have been
1289          created.  */
1290       objc_clear_super_receiver ();
1291
1292       stmt = do_poplevel (stmt);
1293     }
1294
1295   /* ??? See c_end_compound_stmt wrt statement expressions.  */
1296   add_stmt (stmt);
1297   finish_stmt ();
1298 }
1299
1300 /* Finish an asm-statement, whose components are a STRING, some
1301    OUTPUT_OPERANDS, some INPUT_OPERANDS, some CLOBBERS and some
1302    LABELS.  Also note whether the asm-statement should be
1303    considered volatile.  */
1304
1305 tree
1306 finish_asm_stmt (int volatile_p, tree string, tree output_operands,
1307                  tree input_operands, tree clobbers, tree labels)
1308 {
1309   tree r;
1310   tree t;
1311   int ninputs = list_length (input_operands);
1312   int noutputs = list_length (output_operands);
1313
1314   if (!processing_template_decl)
1315     {
1316       const char *constraint;
1317       const char **oconstraints;
1318       bool allows_mem, allows_reg, is_inout;
1319       tree operand;
1320       int i;
1321
1322       oconstraints = XALLOCAVEC (const char *, noutputs);
1323
1324       string = resolve_asm_operand_names (string, output_operands,
1325                                           input_operands, labels);
1326
1327       for (i = 0, t = output_operands; t; t = TREE_CHAIN (t), ++i)
1328         {
1329           operand = TREE_VALUE (t);
1330
1331           /* ??? Really, this should not be here.  Users should be using a
1332              proper lvalue, dammit.  But there's a long history of using
1333              casts in the output operands.  In cases like longlong.h, this
1334              becomes a primitive form of typechecking -- if the cast can be
1335              removed, then the output operand had a type of the proper width;
1336              otherwise we'll get an error.  Gross, but ...  */
1337           STRIP_NOPS (operand);
1338
1339           operand = mark_lvalue_use (operand);
1340
1341           if (!lvalue_or_else (operand, lv_asm, tf_warning_or_error))
1342             operand = error_mark_node;
1343
1344           if (operand != error_mark_node
1345               && (TREE_READONLY (operand)
1346                   || CP_TYPE_CONST_P (TREE_TYPE (operand))
1347                   /* Functions are not modifiable, even though they are
1348                      lvalues.  */
1349                   || TREE_CODE (TREE_TYPE (operand)) == FUNCTION_TYPE
1350                   || TREE_CODE (TREE_TYPE (operand)) == METHOD_TYPE
1351                   /* If it's an aggregate and any field is const, then it is
1352                      effectively const.  */
1353                   || (CLASS_TYPE_P (TREE_TYPE (operand))
1354                       && C_TYPE_FIELDS_READONLY (TREE_TYPE (operand)))))
1355             cxx_readonly_error (operand, lv_asm);
1356
1357           constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
1358           oconstraints[i] = constraint;
1359
1360           if (parse_output_constraint (&constraint, i, ninputs, noutputs,
1361                                        &allows_mem, &allows_reg, &is_inout))
1362             {
1363               /* If the operand is going to end up in memory,
1364                  mark it addressable.  */
1365               if (!allows_reg && !cxx_mark_addressable (operand))
1366                 operand = error_mark_node;
1367             }
1368           else
1369             operand = error_mark_node;
1370
1371           TREE_VALUE (t) = operand;
1372         }
1373
1374       for (i = 0, t = input_operands; t; ++i, t = TREE_CHAIN (t))
1375         {
1376           constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
1377           operand = decay_conversion (TREE_VALUE (t));
1378
1379           /* If the type of the operand hasn't been determined (e.g.,
1380              because it involves an overloaded function), then issue
1381              an error message.  There's no context available to
1382              resolve the overloading.  */
1383           if (TREE_TYPE (operand) == unknown_type_node)
1384             {
1385               error ("type of asm operand %qE could not be determined",
1386                      TREE_VALUE (t));
1387               operand = error_mark_node;
1388             }
1389
1390           if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
1391                                       oconstraints, &allows_mem, &allows_reg))
1392             {
1393               /* If the operand is going to end up in memory,
1394                  mark it addressable.  */
1395               if (!allows_reg && allows_mem)
1396                 {
1397                   /* Strip the nops as we allow this case.  FIXME, this really
1398                      should be rejected or made deprecated.  */
1399                   STRIP_NOPS (operand);
1400                   if (!cxx_mark_addressable (operand))
1401                     operand = error_mark_node;
1402                 }
1403             }
1404           else
1405             operand = error_mark_node;
1406
1407           TREE_VALUE (t) = operand;
1408         }
1409     }
1410
1411   r = build_stmt (input_location, ASM_EXPR, string,
1412                   output_operands, input_operands,
1413                   clobbers, labels);
1414   ASM_VOLATILE_P (r) = volatile_p || noutputs == 0;
1415   r = maybe_cleanup_point_expr_void (r);
1416   return add_stmt (r);
1417 }
1418
1419 /* Finish a label with the indicated NAME.  Returns the new label.  */
1420
1421 tree
1422 finish_label_stmt (tree name)
1423 {
1424   tree decl = define_label (input_location, name);
1425
1426   if (decl == error_mark_node)
1427     return error_mark_node;
1428
1429   add_stmt (build_stmt (input_location, LABEL_EXPR, decl));
1430
1431   return decl;
1432 }
1433
1434 /* Finish a series of declarations for local labels.  G++ allows users
1435    to declare "local" labels, i.e., labels with scope.  This extension
1436    is useful when writing code involving statement-expressions.  */
1437
1438 void
1439 finish_label_decl (tree name)
1440 {
1441   if (!at_function_scope_p ())
1442     {
1443       error ("__label__ declarations are only allowed in function scopes");
1444       return;
1445     }
1446
1447   add_decl_expr (declare_local_label (name));
1448 }
1449
1450 /* When DECL goes out of scope, make sure that CLEANUP is executed.  */
1451
1452 void
1453 finish_decl_cleanup (tree decl, tree cleanup)
1454 {
1455   push_cleanup (decl, cleanup, false);
1456 }
1457
1458 /* If the current scope exits with an exception, run CLEANUP.  */
1459
1460 void
1461 finish_eh_cleanup (tree cleanup)
1462 {
1463   push_cleanup (NULL, cleanup, true);
1464 }
1465
1466 /* The MEM_INITS is a list of mem-initializers, in reverse of the
1467    order they were written by the user.  Each node is as for
1468    emit_mem_initializers.  */
1469
1470 void
1471 finish_mem_initializers (tree mem_inits)
1472 {
1473   /* Reorder the MEM_INITS so that they are in the order they appeared
1474      in the source program.  */
1475   mem_inits = nreverse (mem_inits);
1476
1477   if (processing_template_decl)
1478     {
1479       tree mem;
1480
1481       for (mem = mem_inits; mem; mem = TREE_CHAIN (mem))
1482         {
1483           /* If the TREE_PURPOSE is a TYPE_PACK_EXPANSION, skip the
1484              check for bare parameter packs in the TREE_VALUE, because
1485              any parameter packs in the TREE_VALUE have already been
1486              bound as part of the TREE_PURPOSE.  See
1487              make_pack_expansion for more information.  */
1488           if (TREE_CODE (TREE_PURPOSE (mem)) != TYPE_PACK_EXPANSION
1489               && check_for_bare_parameter_packs (TREE_VALUE (mem)))
1490             TREE_VALUE (mem) = error_mark_node;
1491         }
1492
1493       add_stmt (build_min_nt (CTOR_INITIALIZER, mem_inits));
1494     }
1495   else
1496     emit_mem_initializers (mem_inits);
1497 }
1498
1499 /* Finish a parenthesized expression EXPR.  */
1500
1501 tree
1502 finish_parenthesized_expr (tree expr)
1503 {
1504   if (EXPR_P (expr))
1505     /* This inhibits warnings in c_common_truthvalue_conversion.  */
1506     TREE_NO_WARNING (expr) = 1;
1507
1508   if (TREE_CODE (expr) == OFFSET_REF
1509       || TREE_CODE (expr) == SCOPE_REF)
1510     /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
1511        enclosed in parentheses.  */
1512     PTRMEM_OK_P (expr) = 0;
1513
1514   if (TREE_CODE (expr) == STRING_CST)
1515     PAREN_STRING_LITERAL_P (expr) = 1;
1516
1517   return expr;
1518 }
1519
1520 /* Finish a reference to a non-static data member (DECL) that is not
1521    preceded by `.' or `->'.  */
1522
1523 tree
1524 finish_non_static_data_member (tree decl, tree object, tree qualifying_scope)
1525 {
1526   gcc_assert (TREE_CODE (decl) == FIELD_DECL);
1527
1528   if (!object)
1529     {
1530       tree scope = qualifying_scope;
1531       if (scope == NULL_TREE)
1532         scope = context_for_name_lookup (decl);
1533       object = maybe_dummy_object (scope, NULL);
1534     }
1535
1536   if (object == error_mark_node)
1537     return error_mark_node;
1538
1539   /* DR 613: Can use non-static data members without an associated
1540      object in sizeof/decltype/alignof.  */
1541   if (is_dummy_object (object) && cp_unevaluated_operand == 0
1542       && (!processing_template_decl || !current_class_ref))
1543     {
1544       if (current_function_decl
1545           && DECL_STATIC_FUNCTION_P (current_function_decl))
1546         error ("invalid use of member %q+D in static member function", decl);
1547       else
1548         error ("invalid use of non-static data member %q+D", decl);
1549       error ("from this location");
1550
1551       return error_mark_node;
1552     }
1553
1554   if (current_class_ptr)
1555     TREE_USED (current_class_ptr) = 1;
1556   if (processing_template_decl && !qualifying_scope)
1557     {
1558       tree type = TREE_TYPE (decl);
1559
1560       if (TREE_CODE (type) == REFERENCE_TYPE)
1561         /* Quals on the object don't matter.  */;
1562       else
1563         {
1564           /* Set the cv qualifiers.  */
1565           int quals = (current_class_ref
1566                        ? cp_type_quals (TREE_TYPE (current_class_ref))
1567                        : TYPE_UNQUALIFIED);
1568
1569           if (DECL_MUTABLE_P (decl))
1570             quals &= ~TYPE_QUAL_CONST;
1571
1572           quals |= cp_type_quals (TREE_TYPE (decl));
1573           type = cp_build_qualified_type (type, quals);
1574         }
1575
1576       return (convert_from_reference
1577               (build_min (COMPONENT_REF, type, object, decl, NULL_TREE)));
1578     }
1579   /* If PROCESSING_TEMPLATE_DECL is nonzero here, then
1580      QUALIFYING_SCOPE is also non-null.  Wrap this in a SCOPE_REF
1581      for now.  */
1582   else if (processing_template_decl)
1583     return build_qualified_name (TREE_TYPE (decl),
1584                                  qualifying_scope,
1585                                  DECL_NAME (decl),
1586                                  /*template_p=*/false);
1587   else
1588     {
1589       tree access_type = TREE_TYPE (object);
1590
1591       perform_or_defer_access_check (TYPE_BINFO (access_type), decl,
1592                                      decl);
1593
1594       /* If the data member was named `C::M', convert `*this' to `C'
1595          first.  */
1596       if (qualifying_scope)
1597         {
1598           tree binfo = NULL_TREE;
1599           object = build_scoped_ref (object, qualifying_scope,
1600                                      &binfo);
1601         }
1602
1603       return build_class_member_access_expr (object, decl,
1604                                              /*access_path=*/NULL_TREE,
1605                                              /*preserve_reference=*/false,
1606                                              tf_warning_or_error);
1607     }
1608 }
1609
1610 /* If we are currently parsing a template and we encountered a typedef
1611    TYPEDEF_DECL that is being accessed though CONTEXT, this function
1612    adds the typedef to a list tied to the current template.
1613    At tempate instantiatin time, that list is walked and access check
1614    performed for each typedef.
1615    LOCATION is the location of the usage point of TYPEDEF_DECL.  */
1616
1617 void
1618 add_typedef_to_current_template_for_access_check (tree typedef_decl,
1619                                                   tree context,
1620                                                   location_t location)
1621 {
1622     tree template_info = NULL;
1623     tree cs = current_scope ();
1624
1625     if (!is_typedef_decl (typedef_decl)
1626         || !context
1627         || !CLASS_TYPE_P (context)
1628         || !cs)
1629       return;
1630
1631     if (CLASS_TYPE_P (cs) || TREE_CODE (cs) == FUNCTION_DECL)
1632       template_info = get_template_info (cs);
1633
1634     if (template_info
1635         && TI_TEMPLATE (template_info)
1636         && !currently_open_class (context))
1637       append_type_to_template_for_access_check (cs, typedef_decl,
1638                                                 context, location);
1639 }
1640
1641 /* DECL was the declaration to which a qualified-id resolved.  Issue
1642    an error message if it is not accessible.  If OBJECT_TYPE is
1643    non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
1644    type of `*x', or `x', respectively.  If the DECL was named as
1645    `A::B' then NESTED_NAME_SPECIFIER is `A'.  */
1646
1647 void
1648 check_accessibility_of_qualified_id (tree decl,
1649                                      tree object_type,
1650                                      tree nested_name_specifier)
1651 {
1652   tree scope;
1653   tree qualifying_type = NULL_TREE;
1654
1655   /* If we are parsing a template declaration and if decl is a typedef,
1656      add it to a list tied to the template.
1657      At template instantiation time, that list will be walked and
1658      access check performed.  */
1659   add_typedef_to_current_template_for_access_check (decl,
1660                                                     nested_name_specifier
1661                                                     ? nested_name_specifier
1662                                                     : DECL_CONTEXT (decl),
1663                                                     input_location);
1664
1665   /* If we're not checking, return immediately.  */
1666   if (deferred_access_no_check)
1667     return;
1668
1669   /* Determine the SCOPE of DECL.  */
1670   scope = context_for_name_lookup (decl);
1671   /* If the SCOPE is not a type, then DECL is not a member.  */
1672   if (!TYPE_P (scope))
1673     return;
1674   /* Compute the scope through which DECL is being accessed.  */
1675   if (object_type
1676       /* OBJECT_TYPE might not be a class type; consider:
1677
1678            class A { typedef int I; };
1679            I *p;
1680            p->A::I::~I();
1681
1682          In this case, we will have "A::I" as the DECL, but "I" as the
1683          OBJECT_TYPE.  */
1684       && CLASS_TYPE_P (object_type)
1685       && DERIVED_FROM_P (scope, object_type))
1686     /* If we are processing a `->' or `.' expression, use the type of the
1687        left-hand side.  */
1688     qualifying_type = object_type;
1689   else if (nested_name_specifier)
1690     {
1691       /* If the reference is to a non-static member of the
1692          current class, treat it as if it were referenced through
1693          `this'.  */
1694       if (DECL_NONSTATIC_MEMBER_P (decl)
1695           && current_class_ptr
1696           && DERIVED_FROM_P (scope, current_class_type))
1697         qualifying_type = current_class_type;
1698       /* Otherwise, use the type indicated by the
1699          nested-name-specifier.  */
1700       else
1701         qualifying_type = nested_name_specifier;
1702     }
1703   else
1704     /* Otherwise, the name must be from the current class or one of
1705        its bases.  */
1706     qualifying_type = currently_open_derived_class (scope);
1707
1708   if (qualifying_type 
1709       /* It is possible for qualifying type to be a TEMPLATE_TYPE_PARM
1710          or similar in a default argument value.  */
1711       && CLASS_TYPE_P (qualifying_type)
1712       && !dependent_type_p (qualifying_type))
1713     perform_or_defer_access_check (TYPE_BINFO (qualifying_type), decl,
1714                                    decl);
1715 }
1716
1717 /* EXPR is the result of a qualified-id.  The QUALIFYING_CLASS was the
1718    class named to the left of the "::" operator.  DONE is true if this
1719    expression is a complete postfix-expression; it is false if this
1720    expression is followed by '->', '[', '(', etc.  ADDRESS_P is true
1721    iff this expression is the operand of '&'.  TEMPLATE_P is true iff
1722    the qualified-id was of the form "A::template B".  TEMPLATE_ARG_P
1723    is true iff this qualified name appears as a template argument.  */
1724
1725 tree
1726 finish_qualified_id_expr (tree qualifying_class,
1727                           tree expr,
1728                           bool done,
1729                           bool address_p,
1730                           bool template_p,
1731                           bool template_arg_p)
1732 {
1733   gcc_assert (TYPE_P (qualifying_class));
1734
1735   if (error_operand_p (expr))
1736     return error_mark_node;
1737
1738   if (DECL_P (expr) || BASELINK_P (expr))
1739     mark_used (expr);
1740
1741   if (template_p)
1742     check_template_keyword (expr);
1743
1744   /* If EXPR occurs as the operand of '&', use special handling that
1745      permits a pointer-to-member.  */
1746   if (address_p && done)
1747     {
1748       if (TREE_CODE (expr) == SCOPE_REF)
1749         expr = TREE_OPERAND (expr, 1);
1750       expr = build_offset_ref (qualifying_class, expr,
1751                                /*address_p=*/true);
1752       return expr;
1753     }
1754
1755   /* Within the scope of a class, turn references to non-static
1756      members into expression of the form "this->...".  */
1757   if (template_arg_p)
1758     /* But, within a template argument, we do not want make the
1759        transformation, as there is no "this" pointer.  */
1760     ;
1761   else if (TREE_CODE (expr) == FIELD_DECL)
1762     {
1763       push_deferring_access_checks (dk_no_check);
1764       expr = finish_non_static_data_member (expr, NULL_TREE,
1765                                             qualifying_class);
1766       pop_deferring_access_checks ();
1767     }
1768   else if (BASELINK_P (expr) && !processing_template_decl)
1769     {
1770       tree ob;
1771
1772       /* See if any of the functions are non-static members.  */
1773       /* If so, the expression may be relative to 'this'.  */
1774       if (!shared_member_p (expr)
1775           && (ob = maybe_dummy_object (qualifying_class, NULL),
1776               !is_dummy_object (ob)))
1777         expr = (build_class_member_access_expr
1778                 (ob,
1779                  expr,
1780                  BASELINK_ACCESS_BINFO (expr),
1781                  /*preserve_reference=*/false,
1782                  tf_warning_or_error));
1783       else if (done)
1784         /* The expression is a qualified name whose address is not
1785            being taken.  */
1786         expr = build_offset_ref (qualifying_class, expr, /*address_p=*/false);
1787     }
1788
1789   return expr;
1790 }
1791
1792 /* Begin a statement-expression.  The value returned must be passed to
1793    finish_stmt_expr.  */
1794
1795 tree
1796 begin_stmt_expr (void)
1797 {
1798   return push_stmt_list ();
1799 }
1800
1801 /* Process the final expression of a statement expression. EXPR can be
1802    NULL, if the final expression is empty.  Return a STATEMENT_LIST
1803    containing all the statements in the statement-expression, or
1804    ERROR_MARK_NODE if there was an error.  */
1805
1806 tree
1807 finish_stmt_expr_expr (tree expr, tree stmt_expr)
1808 {
1809   if (error_operand_p (expr))
1810     {
1811       /* The type of the statement-expression is the type of the last
1812          expression.  */
1813       TREE_TYPE (stmt_expr) = error_mark_node;
1814       return error_mark_node;
1815     }
1816
1817   /* If the last statement does not have "void" type, then the value
1818      of the last statement is the value of the entire expression.  */
1819   if (expr)
1820     {
1821       tree type = TREE_TYPE (expr);
1822
1823       if (processing_template_decl)
1824         {
1825           expr = build_stmt (input_location, EXPR_STMT, expr);
1826           expr = add_stmt (expr);
1827           /* Mark the last statement so that we can recognize it as such at
1828              template-instantiation time.  */
1829           EXPR_STMT_STMT_EXPR_RESULT (expr) = 1;
1830         }
1831       else if (VOID_TYPE_P (type))
1832         {
1833           /* Just treat this like an ordinary statement.  */
1834           expr = finish_expr_stmt (expr);
1835         }
1836       else
1837         {
1838           /* It actually has a value we need to deal with.  First, force it
1839              to be an rvalue so that we won't need to build up a copy
1840              constructor call later when we try to assign it to something.  */
1841           expr = force_rvalue (expr, tf_warning_or_error);
1842           if (error_operand_p (expr))
1843             return error_mark_node;
1844
1845           /* Update for array-to-pointer decay.  */
1846           type = TREE_TYPE (expr);
1847
1848           /* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
1849              normal statement, but don't convert to void or actually add
1850              the EXPR_STMT.  */
1851           if (TREE_CODE (expr) != CLEANUP_POINT_EXPR)
1852             expr = maybe_cleanup_point_expr (expr);
1853           add_stmt (expr);
1854         }
1855
1856       /* The type of the statement-expression is the type of the last
1857          expression.  */
1858       TREE_TYPE (stmt_expr) = type;
1859     }
1860
1861   return stmt_expr;
1862 }
1863
1864 /* Finish a statement-expression.  EXPR should be the value returned
1865    by the previous begin_stmt_expr.  Returns an expression
1866    representing the statement-expression.  */
1867
1868 tree
1869 finish_stmt_expr (tree stmt_expr, bool has_no_scope)
1870 {
1871   tree type;
1872   tree result;
1873
1874   if (error_operand_p (stmt_expr))
1875     {
1876       pop_stmt_list (stmt_expr);
1877       return error_mark_node;
1878     }
1879
1880   gcc_assert (TREE_CODE (stmt_expr) == STATEMENT_LIST);
1881
1882   type = TREE_TYPE (stmt_expr);
1883   result = pop_stmt_list (stmt_expr);
1884   TREE_TYPE (result) = type;
1885
1886   if (processing_template_decl)
1887     {
1888       result = build_min (STMT_EXPR, type, result);
1889       TREE_SIDE_EFFECTS (result) = 1;
1890       STMT_EXPR_NO_SCOPE (result) = has_no_scope;
1891     }
1892   else if (CLASS_TYPE_P (type))
1893     {
1894       /* Wrap the statement-expression in a TARGET_EXPR so that the
1895          temporary object created by the final expression is destroyed at
1896          the end of the full-expression containing the
1897          statement-expression.  */
1898       result = force_target_expr (type, result, tf_warning_or_error);
1899     }
1900
1901   return result;
1902 }
1903
1904 /* Returns the expression which provides the value of STMT_EXPR.  */
1905
1906 tree
1907 stmt_expr_value_expr (tree stmt_expr)
1908 {
1909   tree t = STMT_EXPR_STMT (stmt_expr);
1910
1911   if (TREE_CODE (t) == BIND_EXPR)
1912     t = BIND_EXPR_BODY (t);
1913
1914   if (TREE_CODE (t) == STATEMENT_LIST && STATEMENT_LIST_TAIL (t))
1915     t = STATEMENT_LIST_TAIL (t)->stmt;
1916
1917   if (TREE_CODE (t) == EXPR_STMT)
1918     t = EXPR_STMT_EXPR (t);
1919
1920   return t;
1921 }
1922
1923 /* Return TRUE iff EXPR_STMT is an empty list of
1924    expression statements.  */
1925
1926 bool
1927 empty_expr_stmt_p (tree expr_stmt)
1928 {
1929   tree body = NULL_TREE;
1930
1931   if (expr_stmt == void_zero_node)
1932     return true;
1933
1934   if (expr_stmt)
1935     {
1936       if (TREE_CODE (expr_stmt) == EXPR_STMT)
1937         body = EXPR_STMT_EXPR (expr_stmt);
1938       else if (TREE_CODE (expr_stmt) == STATEMENT_LIST)
1939         body = expr_stmt;
1940     }
1941
1942   if (body)
1943     {
1944       if (TREE_CODE (body) == STATEMENT_LIST)
1945         return tsi_end_p (tsi_start (body));
1946       else
1947         return empty_expr_stmt_p (body);
1948     }
1949   return false;
1950 }
1951
1952 /* Perform Koenig lookup.  FN is the postfix-expression representing
1953    the function (or functions) to call; ARGS are the arguments to the
1954    call; if INCLUDE_STD then the `std' namespace is automatically
1955    considered an associated namespace (used in range-based for loops).
1956    Returns the functions to be considered by overload resolution.  */
1957
1958 tree
1959 perform_koenig_lookup (tree fn, VEC(tree,gc) *args, bool include_std,
1960                        tsubst_flags_t complain)
1961 {
1962   tree identifier = NULL_TREE;
1963   tree functions = NULL_TREE;
1964   tree tmpl_args = NULL_TREE;
1965   bool template_id = false;
1966
1967   if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
1968     {
1969       /* Use a separate flag to handle null args.  */
1970       template_id = true;
1971       tmpl_args = TREE_OPERAND (fn, 1);
1972       fn = TREE_OPERAND (fn, 0);
1973     }
1974
1975   /* Find the name of the overloaded function.  */
1976   if (TREE_CODE (fn) == IDENTIFIER_NODE)
1977     identifier = fn;
1978   else if (is_overloaded_fn (fn))
1979     {
1980       functions = fn;
1981       identifier = DECL_NAME (get_first_fn (functions));
1982     }
1983   else if (DECL_P (fn))
1984     {
1985       functions = fn;
1986       identifier = DECL_NAME (fn);
1987     }
1988
1989   /* A call to a namespace-scope function using an unqualified name.
1990
1991      Do Koenig lookup -- unless any of the arguments are
1992      type-dependent.  */
1993   if (!any_type_dependent_arguments_p (args)
1994       && !any_dependent_template_arguments_p (tmpl_args))
1995     {
1996       fn = lookup_arg_dependent (identifier, functions, args, include_std);
1997       if (!fn)
1998         {
1999           /* The unqualified name could not be resolved.  */
2000           if (complain)
2001             fn = unqualified_fn_lookup_error (identifier);
2002           else
2003             fn = identifier;
2004         }
2005     }
2006
2007   if (fn && template_id)
2008     fn = build2 (TEMPLATE_ID_EXPR, unknown_type_node, fn, tmpl_args);
2009   
2010   return fn;
2011 }
2012
2013 /* Generate an expression for `FN (ARGS)'.  This may change the
2014    contents of ARGS.
2015
2016    If DISALLOW_VIRTUAL is true, the call to FN will be not generated
2017    as a virtual call, even if FN is virtual.  (This flag is set when
2018    encountering an expression where the function name is explicitly
2019    qualified.  For example a call to `X::f' never generates a virtual
2020    call.)
2021
2022    Returns code for the call.  */
2023
2024 tree
2025 finish_call_expr (tree fn, VEC(tree,gc) **args, bool disallow_virtual,
2026                   bool koenig_p, tsubst_flags_t complain)
2027 {
2028   tree result;
2029   tree orig_fn;
2030   VEC(tree,gc) *orig_args = NULL;
2031
2032   if (fn == error_mark_node)
2033     return error_mark_node;
2034
2035   gcc_assert (!TYPE_P (fn));
2036
2037   orig_fn = fn;
2038
2039   if (processing_template_decl)
2040     {
2041       /* If the call expression is dependent, build a CALL_EXPR node
2042          with no type; type_dependent_expression_p recognizes
2043          expressions with no type as being dependent.  */
2044       if (type_dependent_expression_p (fn)
2045           || any_type_dependent_arguments_p (*args)
2046           /* For a non-static member function that doesn't have an
2047              explicit object argument, we need to specifically
2048              test the type dependency of the "this" pointer because it
2049              is not included in *ARGS even though it is considered to
2050              be part of the list of arguments.  Note that this is
2051              related to CWG issues 515 and 1005.  */
2052           || (TREE_CODE (fn) != COMPONENT_REF
2053               && non_static_member_function_p (fn)
2054               && current_class_ref
2055               && type_dependent_expression_p (current_class_ref)))
2056         {
2057           result = build_nt_call_vec (fn, *args);
2058           KOENIG_LOOKUP_P (result) = koenig_p;
2059           if (cfun)
2060             {
2061               do
2062                 {
2063                   tree fndecl = OVL_CURRENT (fn);
2064                   if (TREE_CODE (fndecl) != FUNCTION_DECL
2065                       || !TREE_THIS_VOLATILE (fndecl))
2066                     break;
2067                   fn = OVL_NEXT (fn);
2068                 }
2069               while (fn);
2070               if (!fn)
2071                 current_function_returns_abnormally = 1;
2072             }
2073           return result;
2074         }
2075       orig_args = make_tree_vector_copy (*args);
2076       if (!BASELINK_P (fn)
2077           && TREE_CODE (fn) != PSEUDO_DTOR_EXPR
2078           && TREE_TYPE (fn) != unknown_type_node)
2079         fn = build_non_dependent_expr (fn);
2080       make_args_non_dependent (*args);
2081     }
2082
2083   if (TREE_CODE (fn) == COMPONENT_REF)
2084     {
2085       tree member = TREE_OPERAND (fn, 1);
2086       if (BASELINK_P (member))
2087         {
2088           tree object = TREE_OPERAND (fn, 0);
2089           return build_new_method_call (object, member,
2090                                         args, NULL_TREE,
2091                                         (disallow_virtual
2092                                          ? LOOKUP_NORMAL | LOOKUP_NONVIRTUAL
2093                                          : LOOKUP_NORMAL),
2094                                         /*fn_p=*/NULL,
2095                                         complain);
2096         }
2097     }
2098
2099   if (is_overloaded_fn (fn))
2100     fn = baselink_for_fns (fn);
2101
2102   result = NULL_TREE;
2103   if (BASELINK_P (fn))
2104     {
2105       tree object;
2106
2107       /* A call to a member function.  From [over.call.func]:
2108
2109            If the keyword this is in scope and refers to the class of
2110            that member function, or a derived class thereof, then the
2111            function call is transformed into a qualified function call
2112            using (*this) as the postfix-expression to the left of the
2113            . operator.... [Otherwise] a contrived object of type T
2114            becomes the implied object argument.
2115
2116         In this situation:
2117
2118           struct A { void f(); };
2119           struct B : public A {};
2120           struct C : public A { void g() { B::f(); }};
2121
2122         "the class of that member function" refers to `A'.  But 11.2
2123         [class.access.base] says that we need to convert 'this' to B* as
2124         part of the access, so we pass 'B' to maybe_dummy_object.  */
2125
2126       object = maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
2127                                    NULL);
2128
2129       if (processing_template_decl)
2130         {
2131           if (type_dependent_expression_p (object))
2132             {
2133               tree ret = build_nt_call_vec (orig_fn, orig_args);
2134               release_tree_vector (orig_args);
2135               return ret;
2136             }
2137           object = build_non_dependent_expr (object);
2138         }
2139
2140       result = build_new_method_call (object, fn, args, NULL_TREE,
2141                                       (disallow_virtual
2142                                        ? LOOKUP_NORMAL|LOOKUP_NONVIRTUAL
2143                                        : LOOKUP_NORMAL),
2144                                       /*fn_p=*/NULL,
2145                                       complain);
2146     }
2147   else if (is_overloaded_fn (fn))
2148     {
2149       /* If the function is an overloaded builtin, resolve it.  */
2150       if (TREE_CODE (fn) == FUNCTION_DECL
2151           && (DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
2152               || DECL_BUILT_IN_CLASS (fn) == BUILT_IN_MD))
2153         result = resolve_overloaded_builtin (input_location, fn, *args);
2154
2155       if (!result)
2156         /* A call to a namespace-scope function.  */
2157         result = build_new_function_call (fn, args, koenig_p, complain);
2158     }
2159   else if (TREE_CODE (fn) == PSEUDO_DTOR_EXPR)
2160     {
2161       if (!VEC_empty (tree, *args))
2162         error ("arguments to destructor are not allowed");
2163       /* Mark the pseudo-destructor call as having side-effects so
2164          that we do not issue warnings about its use.  */
2165       result = build1 (NOP_EXPR,
2166                        void_type_node,
2167                        TREE_OPERAND (fn, 0));
2168       TREE_SIDE_EFFECTS (result) = 1;
2169     }
2170   else if (CLASS_TYPE_P (TREE_TYPE (fn)))
2171     /* If the "function" is really an object of class type, it might
2172        have an overloaded `operator ()'.  */
2173     result = build_op_call (fn, args, complain);
2174
2175   if (!result)
2176     /* A call where the function is unknown.  */
2177     result = cp_build_function_call_vec (fn, args, complain);
2178
2179   if (processing_template_decl && result != error_mark_node)
2180     {
2181       if (TREE_CODE (result) == INDIRECT_REF)
2182         result = TREE_OPERAND (result, 0);
2183       result = build_call_vec (TREE_TYPE (result), orig_fn, orig_args);
2184       SET_EXPR_LOCATION (result, input_location);
2185       KOENIG_LOOKUP_P (result) = koenig_p;
2186       release_tree_vector (orig_args);
2187       result = convert_from_reference (result);
2188     }
2189
2190   if (koenig_p)
2191     {
2192       /* Free garbage OVERLOADs from arg-dependent lookup.  */
2193       tree next = NULL_TREE;
2194       for (fn = orig_fn;
2195            fn && TREE_CODE (fn) == OVERLOAD && OVL_ARG_DEPENDENT (fn);
2196            fn = next)
2197         {
2198           if (processing_template_decl)
2199             /* In a template, we'll re-use them at instantiation time.  */
2200             OVL_ARG_DEPENDENT (fn) = false;
2201           else
2202             {
2203               next = OVL_CHAIN (fn);
2204               ggc_free (fn);
2205             }
2206         }
2207     }
2208
2209   return result;
2210 }
2211
2212 /* Finish a call to a postfix increment or decrement or EXPR.  (Which
2213    is indicated by CODE, which should be POSTINCREMENT_EXPR or
2214    POSTDECREMENT_EXPR.)  */
2215
2216 tree
2217 finish_increment_expr (tree expr, enum tree_code code)
2218 {
2219   return build_x_unary_op (code, expr, tf_warning_or_error);
2220 }
2221
2222 /* Finish a use of `this'.  Returns an expression for `this'.  */
2223
2224 tree
2225 finish_this_expr (void)
2226 {
2227   tree result;
2228
2229   if (current_class_ptr)
2230     {
2231       tree type = TREE_TYPE (current_class_ref);
2232
2233       /* In a lambda expression, 'this' refers to the captured 'this'.  */
2234       if (LAMBDA_TYPE_P (type))
2235         result = lambda_expr_this_capture (CLASSTYPE_LAMBDA_EXPR (type));
2236       else
2237         result = current_class_ptr;
2238
2239     }
2240   else if (current_function_decl
2241            && DECL_STATIC_FUNCTION_P (current_function_decl))
2242     {
2243       error ("%<this%> is unavailable for static member functions");
2244       result = error_mark_node;
2245     }
2246   else
2247     {
2248       if (current_function_decl)
2249         error ("invalid use of %<this%> in non-member function");
2250       else
2251         error ("invalid use of %<this%> at top level");
2252       result = error_mark_node;
2253     }
2254
2255   return result;
2256 }
2257
2258 /* Finish a pseudo-destructor expression.  If SCOPE is NULL, the
2259    expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
2260    the TYPE for the type given.  If SCOPE is non-NULL, the expression
2261    was of the form `OBJECT.SCOPE::~DESTRUCTOR'.  */
2262
2263 tree
2264 finish_pseudo_destructor_expr (tree object, tree scope, tree destructor)
2265 {
2266   if (object == error_mark_node || destructor == error_mark_node)
2267     return error_mark_node;
2268
2269   gcc_assert (TYPE_P (destructor));
2270
2271   if (!processing_template_decl)
2272     {
2273       if (scope == error_mark_node)
2274         {
2275           error ("invalid qualifying scope in pseudo-destructor name");
2276           return error_mark_node;
2277         }
2278       if (scope && TYPE_P (scope) && !check_dtor_name (scope, destructor))
2279         {
2280           error ("qualified type %qT does not match destructor name ~%qT",
2281                  scope, destructor);
2282           return error_mark_node;
2283         }
2284
2285
2286       /* [expr.pseudo] says both:
2287
2288            The type designated by the pseudo-destructor-name shall be
2289            the same as the object type.
2290
2291          and:
2292
2293            The cv-unqualified versions of the object type and of the
2294            type designated by the pseudo-destructor-name shall be the
2295            same type.
2296
2297          We implement the more generous second sentence, since that is
2298          what most other compilers do.  */
2299       if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object),
2300                                                       destructor))
2301         {
2302           error ("%qE is not of type %qT", object, destructor);
2303           return error_mark_node;
2304         }
2305     }
2306
2307   return build3 (PSEUDO_DTOR_EXPR, void_type_node, object, scope, destructor);
2308 }
2309
2310 /* Finish an expression of the form CODE EXPR.  */
2311
2312 tree
2313 finish_unary_op_expr (enum tree_code code, tree expr)
2314 {
2315   tree result = build_x_unary_op (code, expr, tf_warning_or_error);
2316   if (TREE_OVERFLOW_P (result) && !TREE_OVERFLOW_P (expr))
2317     overflow_warning (input_location, result);
2318
2319   return result;
2320 }
2321
2322 /* Finish a compound-literal expression.  TYPE is the type to which
2323    the CONSTRUCTOR in COMPOUND_LITERAL is being cast.  */
2324
2325 tree
2326 finish_compound_literal (tree type, tree compound_literal,
2327                          tsubst_flags_t complain)
2328 {
2329   if (type == error_mark_node)
2330     return error_mark_node;
2331
2332   if (TREE_CODE (type) == REFERENCE_TYPE)
2333     {
2334       compound_literal
2335         = finish_compound_literal (TREE_TYPE (type), compound_literal,
2336                                    complain);
2337       return cp_build_c_cast (type, compound_literal, complain);
2338     }
2339
2340   if (!TYPE_OBJ_P (type))
2341     {
2342       if (complain & tf_error)
2343         error ("compound literal of non-object type %qT", type);
2344       return error_mark_node;
2345     }
2346
2347   if (processing_template_decl)
2348     {
2349       TREE_TYPE (compound_literal) = type;
2350       /* Mark the expression as a compound literal.  */
2351       TREE_HAS_CONSTRUCTOR (compound_literal) = 1;
2352       return compound_literal;
2353     }
2354
2355   type = complete_type (type);
2356
2357   if (TYPE_NON_AGGREGATE_CLASS (type))
2358     {
2359       /* Trying to deal with a CONSTRUCTOR instead of a TREE_LIST
2360          everywhere that deals with function arguments would be a pain, so
2361          just wrap it in a TREE_LIST.  The parser set a flag so we know
2362          that it came from T{} rather than T({}).  */
2363       CONSTRUCTOR_IS_DIRECT_INIT (compound_literal) = 1;
2364       compound_literal = build_tree_list (NULL_TREE, compound_literal);
2365       return build_functional_cast (type, compound_literal, complain);
2366     }
2367
2368   if (TREE_CODE (type) == ARRAY_TYPE
2369       && check_array_initializer (NULL_TREE, type, compound_literal))
2370     return error_mark_node;
2371   compound_literal = reshape_init (type, compound_literal, complain);
2372   if (SCALAR_TYPE_P (type)
2373       && !BRACE_ENCLOSED_INITIALIZER_P (compound_literal)
2374       && (complain & tf_warning_or_error))
2375     check_narrowing (type, compound_literal);
2376   if (TREE_CODE (type) == ARRAY_TYPE
2377       && TYPE_DOMAIN (type) == NULL_TREE)
2378     {
2379       cp_complete_array_type_or_error (&type, compound_literal,
2380                                        false, complain);
2381       if (type == error_mark_node)
2382         return error_mark_node;
2383     }
2384   compound_literal = digest_init (type, compound_literal, complain);
2385   if (TREE_CODE (compound_literal) == CONSTRUCTOR)
2386     TREE_HAS_CONSTRUCTOR (compound_literal) = true;
2387   /* Put static/constant array temporaries in static variables, but always
2388      represent class temporaries with TARGET_EXPR so we elide copies.  */
2389   if ((!at_function_scope_p () || CP_TYPE_CONST_P (type))
2390       && TREE_CODE (type) == ARRAY_TYPE
2391       && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2392       && initializer_constant_valid_p (compound_literal, type))
2393     {
2394       tree decl = create_temporary_var (type);
2395       DECL_INITIAL (decl) = compound_literal;
2396       TREE_STATIC (decl) = 1;
2397       if (literal_type_p (type) && CP_TYPE_CONST_NON_VOLATILE_P (type))
2398         {
2399           /* 5.19 says that a constant expression can include an
2400              lvalue-rvalue conversion applied to "a glvalue of literal type
2401              that refers to a non-volatile temporary object initialized
2402              with a constant expression".  Rather than try to communicate
2403              that this VAR_DECL is a temporary, just mark it constexpr.  */
2404           DECL_DECLARED_CONSTEXPR_P (decl) = true;
2405           DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = true;
2406           TREE_CONSTANT (decl) = true;
2407         }
2408       cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
2409       decl = pushdecl_top_level (decl);
2410       DECL_NAME (decl) = make_anon_name ();
2411       SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
2412       return decl;
2413     }
2414   else
2415     return get_target_expr_sfinae (compound_literal, complain);
2416 }
2417
2418 /* Return the declaration for the function-name variable indicated by
2419    ID.  */
2420
2421 tree
2422 finish_fname (tree id)
2423 {
2424   tree decl;
2425
2426   decl = fname_decl (input_location, C_RID_CODE (id), id);
2427   if (processing_template_decl && current_function_decl)
2428     decl = DECL_NAME (decl);
2429   return decl;
2430 }
2431
2432 /* Finish a translation unit.  */
2433
2434 void
2435 finish_translation_unit (void)
2436 {
2437   /* In case there were missing closebraces,
2438      get us back to the global binding level.  */
2439   pop_everything ();
2440   while (current_namespace != global_namespace)
2441     pop_namespace ();
2442
2443   /* Do file scope __FUNCTION__ et al.  */
2444   finish_fname_decls ();
2445 }
2446
2447 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
2448    Returns the parameter.  */
2449
2450 tree
2451 finish_template_type_parm (tree aggr, tree identifier)
2452 {
2453   if (aggr != class_type_node)
2454     {
2455       permerror (input_location, "template type parameters must use the keyword %<class%> or %<typename%>");
2456       aggr = class_type_node;
2457     }
2458
2459   return build_tree_list (aggr, identifier);
2460 }
2461
2462 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
2463    Returns the parameter.  */
2464
2465 tree
2466 finish_template_template_parm (tree aggr, tree identifier)
2467 {
2468   tree decl = build_decl (input_location,
2469                           TYPE_DECL, identifier, NULL_TREE);
2470   tree tmpl = build_lang_decl (TEMPLATE_DECL, identifier, NULL_TREE);
2471   DECL_TEMPLATE_PARMS (tmpl) = current_template_parms;
2472   DECL_TEMPLATE_RESULT (tmpl) = decl;
2473   DECL_ARTIFICIAL (decl) = 1;
2474   end_template_decl ();
2475
2476   gcc_assert (DECL_TEMPLATE_PARMS (tmpl));
2477
2478   check_default_tmpl_args (decl, DECL_TEMPLATE_PARMS (tmpl), 
2479                            /*is_primary=*/true, /*is_partial=*/false,
2480                            /*is_friend=*/0);
2481
2482   return finish_template_type_parm (aggr, tmpl);
2483 }
2484
2485 /* ARGUMENT is the default-argument value for a template template
2486    parameter.  If ARGUMENT is invalid, issue error messages and return
2487    the ERROR_MARK_NODE.  Otherwise, ARGUMENT itself is returned.  */
2488
2489 tree
2490 check_template_template_default_arg (tree argument)
2491 {
2492   if (TREE_CODE (argument) != TEMPLATE_DECL
2493       && TREE_CODE (argument) != TEMPLATE_TEMPLATE_PARM
2494       && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
2495     {
2496       if (TREE_CODE (argument) == TYPE_DECL)
2497         error ("invalid use of type %qT as a default value for a template "
2498                "template-parameter", TREE_TYPE (argument));
2499       else
2500         error ("invalid default argument for a template template parameter");
2501       return error_mark_node;
2502     }
2503
2504   return argument;
2505 }
2506
2507 /* Begin a class definition, as indicated by T.  */
2508
2509 tree
2510 begin_class_definition (tree t, tree attributes)
2511 {
2512   if (error_operand_p (t) || error_operand_p (TYPE_MAIN_DECL (t)))
2513     return error_mark_node;
2514
2515   if (processing_template_parmlist)
2516     {
2517       error ("definition of %q#T inside template parameter list", t);
2518       return error_mark_node;
2519     }
2520
2521   /* According to the C++ ABI, decimal classes defined in ISO/IEC TR 24733
2522      are passed the same as decimal scalar types.  */
2523   if (TREE_CODE (t) == RECORD_TYPE
2524       && !processing_template_decl)
2525     {
2526       tree ns = TYPE_CONTEXT (t);
2527       if (ns && TREE_CODE (ns) == NAMESPACE_DECL
2528           && DECL_CONTEXT (ns) == std_node
2529           && DECL_NAME (ns)
2530           && !strcmp (IDENTIFIER_POINTER (DECL_NAME (ns)), "decimal"))
2531         {
2532           const char *n = TYPE_NAME_STRING (t);
2533           if ((strcmp (n, "decimal32") == 0)
2534               || (strcmp (n, "decimal64") == 0)
2535               || (strcmp (n, "decimal128") == 0))
2536             TYPE_TRANSPARENT_AGGR (t) = 1;
2537         }
2538     }
2539
2540   /* A non-implicit typename comes from code like:
2541
2542        template <typename T> struct A {
2543          template <typename U> struct A<T>::B ...
2544
2545      This is erroneous.  */
2546   else if (TREE_CODE (t) == TYPENAME_TYPE)
2547     {
2548       error ("invalid definition of qualified type %qT", t);
2549       t = error_mark_node;
2550     }
2551
2552   if (t == error_mark_node || ! MAYBE_CLASS_TYPE_P (t))
2553     {
2554       t = make_class_type (RECORD_TYPE);
2555       pushtag (make_anon_name (), t, /*tag_scope=*/ts_current);
2556     }
2557
2558   if (TYPE_BEING_DEFINED (t))
2559     {
2560       t = make_class_type (TREE_CODE (t));
2561       pushtag (TYPE_IDENTIFIER (t), t, /*tag_scope=*/ts_current);
2562     }
2563   maybe_process_partial_specialization (t);
2564   pushclass (t);
2565   TYPE_BEING_DEFINED (t) = 1;
2566
2567   cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
2568   fixup_attribute_variants (t);
2569
2570   if (flag_pack_struct)
2571     {
2572       tree v;
2573       TYPE_PACKED (t) = 1;
2574       /* Even though the type is being defined for the first time
2575          here, there might have been a forward declaration, so there
2576          might be cv-qualified variants of T.  */
2577       for (v = TYPE_NEXT_VARIANT (t); v; v = TYPE_NEXT_VARIANT (v))
2578         TYPE_PACKED (v) = 1;
2579     }
2580   /* Reset the interface data, at the earliest possible
2581      moment, as it might have been set via a class foo;
2582      before.  */
2583   if (! TYPE_ANONYMOUS_P (t))
2584     {
2585       struct c_fileinfo *finfo = get_fileinfo (input_filename);
2586       CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
2587       SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2588         (t, finfo->interface_unknown);
2589     }
2590   reset_specialization();
2591
2592   /* Make a declaration for this class in its own scope.  */
2593   build_self_reference ();
2594
2595   return t;
2596 }
2597
2598 /* Finish the member declaration given by DECL.  */
2599
2600 void
2601 finish_member_declaration (tree decl)
2602 {
2603   if (decl == error_mark_node || decl == NULL_TREE)
2604     return;
2605
2606   if (decl == void_type_node)
2607     /* The COMPONENT was a friend, not a member, and so there's
2608        nothing for us to do.  */
2609     return;
2610
2611   /* We should see only one DECL at a time.  */
2612   gcc_assert (DECL_CHAIN (decl) == NULL_TREE);
2613
2614   /* Set up access control for DECL.  */
2615   TREE_PRIVATE (decl)
2616     = (current_access_specifier == access_private_node);
2617   TREE_PROTECTED (decl)
2618     = (current_access_specifier == access_protected_node);
2619   if (TREE_CODE (decl) == TEMPLATE_DECL)
2620     {
2621       TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl)) = TREE_PRIVATE (decl);
2622       TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl)) = TREE_PROTECTED (decl);
2623     }
2624
2625   /* Mark the DECL as a member of the current class.  */
2626   DECL_CONTEXT (decl) = current_class_type;
2627
2628   /* Check for bare parameter packs in the member variable declaration.  */
2629   if (TREE_CODE (decl) == FIELD_DECL)
2630     {
2631       if (check_for_bare_parameter_packs (TREE_TYPE (decl)))
2632         TREE_TYPE (decl) = error_mark_node;
2633       if (check_for_bare_parameter_packs (DECL_ATTRIBUTES (decl)))
2634         DECL_ATTRIBUTES (decl) = NULL_TREE;
2635     }
2636
2637   /* [dcl.link]
2638
2639      A C language linkage is ignored for the names of class members
2640      and the member function type of class member functions.  */
2641   if (DECL_LANG_SPECIFIC (decl) && DECL_LANGUAGE (decl) == lang_c)
2642     SET_DECL_LANGUAGE (decl, lang_cplusplus);
2643
2644   /* Put functions on the TYPE_METHODS list and everything else on the
2645      TYPE_FIELDS list.  Note that these are built up in reverse order.
2646      We reverse them (to obtain declaration order) in finish_struct.  */
2647   if (TREE_CODE (decl) == FUNCTION_DECL
2648       || DECL_FUNCTION_TEMPLATE_P (decl))
2649     {
2650       /* We also need to add this function to the
2651          CLASSTYPE_METHOD_VEC.  */
2652       if (add_method (current_class_type, decl, NULL_TREE))
2653         {
2654           DECL_CHAIN (decl) = TYPE_METHODS (current_class_type);
2655           TYPE_METHODS (current_class_type) = decl;
2656
2657           maybe_add_class_template_decl_list (current_class_type, decl,
2658                                               /*friend_p=*/0);
2659         }
2660     }
2661   /* Enter the DECL into the scope of the class.  */
2662   else if (pushdecl_class_level (decl))
2663     {
2664       if (TREE_CODE (decl) == USING_DECL)
2665         {
2666           /* We need to add the target functions to the
2667              CLASSTYPE_METHOD_VEC if an enclosing scope is a template
2668              class, so that this function be found by lookup_fnfields_1
2669              when the using declaration is not instantiated yet.  */
2670
2671           tree target_decl = strip_using_decl (decl);
2672           if (dependent_type_p (current_class_type)
2673               && is_overloaded_fn (target_decl))
2674             {
2675               tree t = target_decl;
2676               for (; t; t = OVL_NEXT (t))
2677                 add_method (current_class_type, OVL_CURRENT (t), decl);
2678             }
2679
2680           /* For now, ignore class-scope USING_DECLS, so that
2681              debugging backends do not see them. */
2682           DECL_IGNORED_P (decl) = 1;
2683         }
2684
2685       /* All TYPE_DECLs go at the end of TYPE_FIELDS.  Ordinary fields
2686          go at the beginning.  The reason is that lookup_field_1
2687          searches the list in order, and we want a field name to
2688          override a type name so that the "struct stat hack" will
2689          work.  In particular:
2690
2691            struct S { enum E { }; int E } s;
2692            s.E = 3;
2693
2694          is valid.  In addition, the FIELD_DECLs must be maintained in
2695          declaration order so that class layout works as expected.
2696          However, we don't need that order until class layout, so we
2697          save a little time by putting FIELD_DECLs on in reverse order
2698          here, and then reversing them in finish_struct_1.  (We could
2699          also keep a pointer to the correct insertion points in the
2700          list.)  */
2701
2702       if (TREE_CODE (decl) == TYPE_DECL)
2703         TYPE_FIELDS (current_class_type)
2704           = chainon (TYPE_FIELDS (current_class_type), decl);
2705       else
2706         {
2707           DECL_CHAIN (decl) = TYPE_FIELDS (current_class_type);
2708           TYPE_FIELDS (current_class_type) = decl;
2709         }
2710
2711       maybe_add_class_template_decl_list (current_class_type, decl,
2712                                           /*friend_p=*/0);
2713     }
2714
2715   if (pch_file)
2716     note_decl_for_pch (decl);
2717 }
2718
2719 /* DECL has been declared while we are building a PCH file.  Perform
2720    actions that we might normally undertake lazily, but which can be
2721    performed now so that they do not have to be performed in
2722    translation units which include the PCH file.  */
2723
2724 void
2725 note_decl_for_pch (tree decl)
2726 {
2727   gcc_assert (pch_file);
2728
2729   /* There's a good chance that we'll have to mangle names at some
2730      point, even if only for emission in debugging information.  */
2731   if ((TREE_CODE (decl) == VAR_DECL
2732        || TREE_CODE (decl) == FUNCTION_DECL)
2733       && !processing_template_decl)
2734     mangle_decl (decl);
2735 }
2736
2737 /* Finish processing a complete template declaration.  The PARMS are
2738    the template parameters.  */
2739
2740 void
2741 finish_template_decl (tree parms)
2742 {
2743   if (parms)
2744     end_template_decl ();
2745   else
2746     end_specialization ();
2747 }
2748
2749 /* Finish processing a template-id (which names a type) of the form
2750    NAME < ARGS >.  Return the TYPE_DECL for the type named by the
2751    template-id.  If ENTERING_SCOPE is nonzero we are about to enter
2752    the scope of template-id indicated.  */
2753
2754 tree
2755 finish_template_type (tree name, tree args, int entering_scope)
2756 {
2757   tree type;
2758
2759   type = lookup_template_class (name, args,
2760                                 NULL_TREE, NULL_TREE, entering_scope,
2761                                 tf_warning_or_error | tf_user);
2762   if (type == error_mark_node)
2763     return type;
2764   else if (CLASS_TYPE_P (type) && !alias_type_or_template_p (type))
2765     return TYPE_STUB_DECL (type);
2766   else
2767     return TYPE_NAME (type);
2768 }
2769
2770 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
2771    Return a TREE_LIST containing the ACCESS_SPECIFIER and the
2772    BASE_CLASS, or NULL_TREE if an error occurred.  The
2773    ACCESS_SPECIFIER is one of
2774    access_{default,public,protected_private}_node.  For a virtual base
2775    we set TREE_TYPE.  */
2776
2777 tree
2778 finish_base_specifier (tree base, tree access, bool virtual_p)
2779 {
2780   tree result;
2781
2782   if (base == error_mark_node)
2783     {
2784       error ("invalid base-class specification");
2785       result = NULL_TREE;
2786     }
2787   else if (! MAYBE_CLASS_TYPE_P (base))
2788     {
2789       error ("%qT is not a class type", base);
2790       result = NULL_TREE;
2791     }
2792   else
2793     {
2794       if (cp_type_quals (base) != 0)
2795         {
2796           /* DR 484: Can a base-specifier name a cv-qualified
2797              class type?  */
2798           base = TYPE_MAIN_VARIANT (base);
2799         }
2800       result = build_tree_list (access, base);
2801       if (virtual_p)
2802         TREE_TYPE (result) = integer_type_node;
2803     }
2804
2805   return result;
2806 }
2807
2808 /* If FNS is a member function, a set of member functions, or a
2809    template-id referring to one or more member functions, return a
2810    BASELINK for FNS, incorporating the current access context.
2811    Otherwise, return FNS unchanged.  */
2812
2813 tree
2814 baselink_for_fns (tree fns)
2815 {
2816   tree fn;
2817   tree cl;
2818
2819   if (BASELINK_P (fns) 
2820       || error_operand_p (fns))
2821     return fns;
2822   
2823   fn = fns;
2824   if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2825     fn = TREE_OPERAND (fn, 0);
2826   fn = get_first_fn (fn);
2827   if (!DECL_FUNCTION_MEMBER_P (fn))
2828     return fns;
2829
2830   cl = currently_open_derived_class (DECL_CONTEXT (fn));
2831   if (!cl)
2832     cl = DECL_CONTEXT (fn);
2833   cl = TYPE_BINFO (cl);
2834   return build_baselink (cl, cl, fns, /*optype=*/NULL_TREE);
2835 }
2836
2837 /* Returns true iff DECL is an automatic variable from a function outside
2838    the current one.  */
2839
2840 static bool
2841 outer_automatic_var_p (tree decl)
2842 {
2843   return ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
2844           && DECL_FUNCTION_SCOPE_P (decl)
2845           && !TREE_STATIC (decl)
2846           && DECL_CONTEXT (decl) != current_function_decl);
2847 }
2848
2849 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
2850    id-expression.  (See cp_parser_id_expression for details.)  SCOPE,
2851    if non-NULL, is the type or namespace used to explicitly qualify
2852    ID_EXPRESSION.  DECL is the entity to which that name has been
2853    resolved.
2854
2855    *CONSTANT_EXPRESSION_P is true if we are presently parsing a
2856    constant-expression.  In that case, *NON_CONSTANT_EXPRESSION_P will
2857    be set to true if this expression isn't permitted in a
2858    constant-expression, but it is otherwise not set by this function.
2859    *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
2860    constant-expression, but a non-constant expression is also
2861    permissible.
2862
2863    DONE is true if this expression is a complete postfix-expression;
2864    it is false if this expression is followed by '->', '[', '(', etc.
2865    ADDRESS_P is true iff this expression is the operand of '&'.
2866    TEMPLATE_P is true iff the qualified-id was of the form
2867    "A::template B".  TEMPLATE_ARG_P is true iff this qualified name
2868    appears as a template argument.
2869
2870    If an error occurs, and it is the kind of error that might cause
2871    the parser to abort a tentative parse, *ERROR_MSG is filled in.  It
2872    is the caller's responsibility to issue the message.  *ERROR_MSG
2873    will be a string with static storage duration, so the caller need
2874    not "free" it.
2875
2876    Return an expression for the entity, after issuing appropriate
2877    diagnostics.  This function is also responsible for transforming a
2878    reference to a non-static member into a COMPONENT_REF that makes
2879    the use of "this" explicit.
2880
2881    Upon return, *IDK will be filled in appropriately.  */
2882 tree
2883 finish_id_expression (tree id_expression,
2884                       tree decl,
2885                       tree scope,
2886                       cp_id_kind *idk,
2887                       bool integral_constant_expression_p,
2888                       bool allow_non_integral_constant_expression_p,
2889                       bool *non_integral_constant_expression_p,
2890                       bool template_p,
2891                       bool done,
2892                       bool address_p,
2893                       bool template_arg_p,
2894                       const char **error_msg,
2895                       location_t location)
2896 {
2897   decl = strip_using_decl (decl);
2898
2899   /* Initialize the output parameters.  */
2900   *idk = CP_ID_KIND_NONE;
2901   *error_msg = NULL;
2902
2903   if (id_expression == error_mark_node)
2904     return error_mark_node;
2905   /* If we have a template-id, then no further lookup is
2906      required.  If the template-id was for a template-class, we
2907      will sometimes have a TYPE_DECL at this point.  */
2908   else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2909            || TREE_CODE (decl) == TYPE_DECL)
2910     ;
2911   /* Look up the name.  */
2912   else
2913     {
2914       if (decl == error_mark_node)
2915         {
2916           /* Name lookup failed.  */
2917           if (scope
2918               && (!TYPE_P (scope)
2919                   || (!dependent_type_p (scope)
2920                       && !(TREE_CODE (id_expression) == IDENTIFIER_NODE
2921                            && IDENTIFIER_TYPENAME_P (id_expression)
2922                            && dependent_type_p (TREE_TYPE (id_expression))))))
2923             {
2924               /* If the qualifying type is non-dependent (and the name
2925                  does not name a conversion operator to a dependent
2926                  type), issue an error.  */
2927               qualified_name_lookup_error (scope, id_expression, decl, location);
2928               return error_mark_node;
2929             }
2930           else if (!scope)
2931             {
2932               /* It may be resolved via Koenig lookup.  */
2933               *idk = CP_ID_KIND_UNQUALIFIED;
2934               return id_expression;
2935             }
2936           else
2937             decl = id_expression;
2938         }
2939       /* If DECL is a variable that would be out of scope under
2940          ANSI/ISO rules, but in scope in the ARM, name lookup
2941          will succeed.  Issue a diagnostic here.  */
2942       else
2943         decl = check_for_out_of_scope_variable (decl);
2944
2945       /* Remember that the name was used in the definition of
2946          the current class so that we can check later to see if
2947          the meaning would have been different after the class
2948          was entirely defined.  */
2949       if (!scope && decl != error_mark_node
2950           && TREE_CODE (id_expression) == IDENTIFIER_NODE)
2951         maybe_note_name_used_in_class (id_expression, decl);
2952
2953       /* Disallow uses of local variables from containing functions, except
2954          within lambda-expressions.  */
2955       if (outer_automatic_var_p (decl)
2956           /* It's not a use (3.2) if we're in an unevaluated context.  */
2957           && !cp_unevaluated_operand)
2958         {
2959           tree context = DECL_CONTEXT (decl);
2960           tree containing_function = current_function_decl;
2961           tree lambda_stack = NULL_TREE;
2962           tree lambda_expr = NULL_TREE;
2963           tree initializer = convert_from_reference (decl);
2964
2965           /* Mark it as used now even if the use is ill-formed.  */
2966           mark_used (decl);
2967
2968           /* Core issue 696: "[At the July 2009 meeting] the CWG expressed
2969              support for an approach in which a reference to a local
2970              [constant] automatic variable in a nested class or lambda body
2971              would enter the expression as an rvalue, which would reduce
2972              the complexity of the problem"
2973
2974              FIXME update for final resolution of core issue 696.  */
2975           if (decl_constant_var_p (decl))
2976             return integral_constant_value (decl);
2977
2978           /* If we are in a lambda function, we can move out until we hit
2979              1. the context,
2980              2. a non-lambda function, or
2981              3. a non-default capturing lambda function.  */
2982           while (context != containing_function
2983                  && LAMBDA_FUNCTION_P (containing_function))
2984             {
2985               lambda_expr = CLASSTYPE_LAMBDA_EXPR
2986                 (DECL_CONTEXT (containing_function));
2987
2988               if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr)
2989                   == CPLD_NONE)
2990                 break;
2991
2992               lambda_stack = tree_cons (NULL_TREE,
2993                                         lambda_expr,
2994                                         lambda_stack);
2995
2996               containing_function
2997                 = decl_function_context (containing_function);
2998             }
2999
3000           if (context == containing_function)
3001             {
3002               decl = add_default_capture (lambda_stack,
3003                                           /*id=*/DECL_NAME (decl),
3004                                           initializer);
3005             }
3006           else if (lambda_expr)
3007             {
3008               error ("%qD is not captured", decl);
3009               return error_mark_node;
3010             }
3011           else
3012             {
3013               error (TREE_CODE (decl) == VAR_DECL
3014                      ? G_("use of %<auto%> variable from containing function")
3015                      : G_("use of parameter from containing function"));
3016               error ("  %q+#D declared here", decl);
3017               return error_mark_node;
3018             }
3019         }
3020
3021       /* Also disallow uses of function parameters outside the function
3022          body, except inside an unevaluated context (i.e. decltype).  */
3023       if (TREE_CODE (decl) == PARM_DECL
3024           && DECL_CONTEXT (decl) == NULL_TREE
3025           && !cp_unevaluated_operand)
3026         {
3027           error ("use of parameter %qD outside function body", decl);
3028           return error_mark_node;
3029         }
3030     }
3031
3032   /* If we didn't find anything, or what we found was a type,
3033      then this wasn't really an id-expression.  */
3034   if (TREE_CODE (decl) == TEMPLATE_DECL
3035       && !DECL_FUNCTION_TEMPLATE_P (decl))
3036     {
3037       *error_msg = "missing template arguments";
3038       return error_mark_node;
3039     }
3040   else if (TREE_CODE (decl) == TYPE_DECL
3041            || TREE_CODE (decl) == NAMESPACE_DECL)
3042     {
3043       *error_msg = "expected primary-expression";
3044       return error_mark_node;
3045     }
3046
3047   /* If the name resolved to a template parameter, there is no
3048      need to look it up again later.  */
3049   if ((TREE_CODE (decl) == CONST_DECL && DECL_TEMPLATE_PARM_P (decl))
3050       || TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
3051     {
3052       tree r;
3053
3054       *idk = CP_ID_KIND_NONE;
3055       if (TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
3056         decl = TEMPLATE_PARM_DECL (decl);
3057       r = convert_from_reference (DECL_INITIAL (decl));
3058
3059       if (integral_constant_expression_p
3060           && !dependent_type_p (TREE_TYPE (decl))
3061           && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r))))
3062         {
3063           if (!allow_non_integral_constant_expression_p)
3064             error ("template parameter %qD of type %qT is not allowed in "
3065                    "an integral constant expression because it is not of "
3066                    "integral or enumeration type", decl, TREE_TYPE (decl));
3067           *non_integral_constant_expression_p = true;
3068         }
3069       return r;
3070     }
3071   /* Similarly, we resolve enumeration constants to their
3072      underlying values.  */
3073   else if (TREE_CODE (decl) == CONST_DECL)
3074     {
3075       *idk = CP_ID_KIND_NONE;
3076       if (!processing_template_decl)
3077         {
3078           used_types_insert (TREE_TYPE (decl));
3079           return DECL_INITIAL (decl);
3080         }
3081       return decl;
3082     }
3083   else
3084     {
3085       bool dependent_p;
3086
3087       /* If the declaration was explicitly qualified indicate
3088          that.  The semantics of `A::f(3)' are different than
3089          `f(3)' if `f' is virtual.  */
3090       *idk = (scope
3091               ? CP_ID_KIND_QUALIFIED
3092               : (TREE_CODE (decl) == TEMPLATE_ID_EXPR
3093                  ? CP_ID_KIND_TEMPLATE_ID
3094                  : CP_ID_KIND_UNQUALIFIED));
3095
3096
3097       /* [temp.dep.expr]
3098
3099          An id-expression is type-dependent if it contains an
3100          identifier that was declared with a dependent type.
3101
3102          The standard is not very specific about an id-expression that
3103          names a set of overloaded functions.  What if some of them
3104          have dependent types and some of them do not?  Presumably,
3105          such a name should be treated as a dependent name.  */
3106       /* Assume the name is not dependent.  */
3107       dependent_p = false;
3108       if (!processing_template_decl)
3109         /* No names are dependent outside a template.  */
3110         ;
3111       /* A template-id where the name of the template was not resolved
3112          is definitely dependent.  */
3113       else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
3114                && (TREE_CODE (TREE_OPERAND (decl, 0))
3115                    == IDENTIFIER_NODE))
3116         dependent_p = true;
3117       /* For anything except an overloaded function, just check its
3118          type.  */
3119       else if (!is_overloaded_fn (decl))
3120         dependent_p
3121           = dependent_type_p (TREE_TYPE (decl));
3122       /* For a set of overloaded functions, check each of the
3123          functions.  */
3124       else
3125         {
3126           tree fns = decl;
3127
3128           if (BASELINK_P (fns))
3129             fns = BASELINK_FUNCTIONS (fns);
3130
3131           /* For a template-id, check to see if the template
3132              arguments are dependent.  */
3133           if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
3134             {
3135               tree args = TREE_OPERAND (fns, 1);
3136               dependent_p = any_dependent_template_arguments_p (args);
3137               /* The functions are those referred to by the
3138                  template-id.  */
3139               fns = TREE_OPERAND (fns, 0);
3140             }
3141
3142           /* If there are no dependent template arguments, go through
3143              the overloaded functions.  */
3144           while (fns && !dependent_p)
3145             {
3146               tree fn = OVL_CURRENT (fns);
3147
3148               /* Member functions of dependent classes are
3149                  dependent.  */
3150               if (TREE_CODE (fn) == FUNCTION_DECL
3151                   && type_dependent_expression_p (fn))
3152                 dependent_p = true;
3153               else if (TREE_CODE (fn) == TEMPLATE_DECL
3154                        && dependent_template_p (fn))
3155                 dependent_p = true;
3156
3157               fns = OVL_NEXT (fns);
3158             }
3159         }
3160
3161       /* If the name was dependent on a template parameter, we will
3162          resolve the name at instantiation time.  */
3163       if (dependent_p)
3164         {
3165           /* Create a SCOPE_REF for qualified names, if the scope is
3166              dependent.  */
3167           if (scope)
3168             {
3169               if (TYPE_P (scope))
3170                 {
3171                   if (address_p && done)
3172                     decl = finish_qualified_id_expr (scope, decl,
3173                                                      done, address_p,
3174                                                      template_p,
3175                                                      template_arg_p);
3176                   else
3177                     {
3178                       tree type = NULL_TREE;
3179                       if (DECL_P (decl) && !dependent_scope_p (scope))
3180                         type = TREE_TYPE (decl);
3181                       decl = build_qualified_name (type,
3182                                                    scope,
3183                                                    id_expression,
3184                                                    template_p);
3185                     }
3186                 }
3187               if (TREE_TYPE (decl))
3188                 decl = convert_from_reference (decl);
3189               return decl;
3190             }
3191           /* A TEMPLATE_ID already contains all the information we
3192              need.  */
3193           if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR)
3194             return id_expression;
3195           *idk = CP_ID_KIND_UNQUALIFIED_DEPENDENT;
3196           /* If we found a variable, then name lookup during the
3197              instantiation will always resolve to the same VAR_DECL
3198              (or an instantiation thereof).  */
3199           if (TREE_CODE (decl) == VAR_DECL
3200               || TREE_CODE (decl) == PARM_DECL)
3201             {
3202               mark_used (decl);
3203               return convert_from_reference (decl);
3204             }
3205           /* The same is true for FIELD_DECL, but we also need to
3206              make sure that the syntax is correct.  */
3207           else if (TREE_CODE (decl) == FIELD_DECL)
3208             {
3209               /* Since SCOPE is NULL here, this is an unqualified name.
3210                  Access checking has been performed during name lookup
3211                  already.  Turn off checking to avoid duplicate errors.  */
3212               push_deferring_access_checks (dk_no_check);
3213               decl = finish_non_static_data_member
3214                        (decl, NULL_TREE,
3215                         /*qualifying_scope=*/NULL_TREE);
3216               pop_deferring_access_checks ();
3217               return decl;
3218             }
3219           return id_expression;
3220         }
3221
3222       if (TREE_CODE (decl) == NAMESPACE_DECL)
3223         {
3224           error ("use of namespace %qD as expression", decl);
3225           return error_mark_node;
3226         }
3227       else if (DECL_CLASS_TEMPLATE_P (decl))
3228         {
3229           error ("use of class template %qT as expression", decl);
3230           return error_mark_node;
3231         }
3232       else if (TREE_CODE (decl) == TREE_LIST)
3233         {
3234           /* Ambiguous reference to base members.  */
3235           error ("request for member %qD is ambiguous in "
3236                  "multiple inheritance lattice", id_expression);
3237           print_candidates (decl);
3238           return error_mark_node;
3239         }
3240
3241       /* Mark variable-like entities as used.  Functions are similarly
3242          marked either below or after overload resolution.  */
3243       if (TREE_CODE (decl) == VAR_DECL
3244           || TREE_CODE (decl) == PARM_DECL
3245           || TREE_CODE (decl) == RESULT_DECL)
3246         mark_used (decl);
3247
3248       /* Only certain kinds of names are allowed in constant
3249          expression.  Enumerators and template parameters have already
3250          been handled above.  */
3251       if (! error_operand_p (decl)
3252           && integral_constant_expression_p
3253           && ! decl_constant_var_p (decl)
3254           && ! builtin_valid_in_constant_expr_p (decl))
3255         {
3256           if (!allow_non_integral_constant_expression_p)
3257             {
3258               error ("%qD cannot appear in a constant-expression", decl);
3259               return error_mark_node;
3260             }
3261           *non_integral_constant_expression_p = true;
3262         }
3263
3264       if (scope)
3265         {
3266           decl = (adjust_result_of_qualified_name_lookup
3267                   (decl, scope, current_nonlambda_class_type()));
3268
3269           if (TREE_CODE (decl) == FUNCTION_DECL)
3270             mark_used (decl);
3271
3272           if (TREE_CODE (decl) == FIELD_DECL || BASELINK_P (decl))
3273             decl = finish_qualified_id_expr (scope,
3274                                              decl,
3275                                              done,
3276                                              address_p,
3277                                              template_p,
3278                                              template_arg_p);
3279           else
3280             {
3281               tree r = convert_from_reference (decl);
3282
3283               /* In a template, return a SCOPE_REF for most qualified-ids
3284                  so that we can check access at instantiation time.  But if
3285                  we're looking at a member of the current instantiation, we
3286                  know we have access and building up the SCOPE_REF confuses
3287                  non-type template argument handling.  */
3288               if (processing_template_decl && TYPE_P (scope)
3289                   && !currently_open_class (scope))
3290                 r = build_qualified_name (TREE_TYPE (r),
3291                                           scope, decl,
3292                                           template_p);
3293               decl = r;
3294             }
3295         }
3296       else if (TREE_CODE (decl) == FIELD_DECL)
3297         {
3298           /* Since SCOPE is NULL here, this is an unqualified name.
3299              Access checking has been performed during name lookup
3300              already.  Turn off checking to avoid duplicate errors.  */
3301           push_deferring_access_checks (dk_no_check);
3302           decl = finish_non_static_data_member (decl, NULL_TREE,
3303                                                 /*qualifying_scope=*/NULL_TREE);
3304           pop_deferring_access_checks ();
3305         }
3306       else if (is_overloaded_fn (decl))
3307         {
3308           tree first_fn;
3309
3310           first_fn = get_first_fn (decl);
3311           if (TREE_CODE (first_fn) == TEMPLATE_DECL)
3312             first_fn = DECL_TEMPLATE_RESULT (first_fn);
3313
3314           if (!really_overloaded_fn (decl)
3315               && !mark_used (first_fn))
3316             return error_mark_node;
3317
3318           if (!template_arg_p
3319               && TREE_CODE (first_fn) == FUNCTION_DECL
3320               && DECL_FUNCTION_MEMBER_P (first_fn)
3321               && !shared_member_p (decl))
3322             {
3323               /* A set of member functions.  */
3324               decl = maybe_dummy_object (DECL_CONTEXT (first_fn), 0);
3325               return finish_class_member_access_expr (decl, id_expression,
3326                                                       /*template_p=*/false,
3327                                                       tf_warning_or_error);
3328             }
3329
3330           decl = baselink_for_fns (decl);
3331         }
3332       else
3333         {
3334           if (DECL_P (decl) && DECL_NONLOCAL (decl)
3335               && DECL_CLASS_SCOPE_P (decl))
3336             {
3337               tree context = context_for_name_lookup (decl); 
3338               if (context != current_class_type)
3339                 {
3340                   tree path = currently_open_derived_class (context);
3341                   perform_or_defer_access_check (TYPE_BINFO (path),
3342                                                  decl, decl);
3343                 }
3344             }
3345
3346           decl = convert_from_reference (decl);
3347         }
3348     }
3349
3350   if (TREE_DEPRECATED (decl))
3351     warn_deprecated_use (decl, NULL_TREE);
3352
3353   return decl;
3354 }
3355
3356 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
3357    use as a type-specifier.  */
3358
3359 tree
3360 finish_typeof (tree expr)
3361 {
3362   tree type;
3363
3364   if (type_dependent_expression_p (expr))
3365     {
3366       type = cxx_make_type (TYPEOF_TYPE);
3367       TYPEOF_TYPE_EXPR (type) = expr;
3368       SET_TYPE_STRUCTURAL_EQUALITY (type);
3369
3370       return type;
3371     }
3372
3373   expr = mark_type_use (expr);
3374
3375   type = unlowered_expr_type (expr);
3376
3377   if (!type || type == unknown_type_node)
3378     {
3379       error ("type of %qE is unknown", expr);
3380       return error_mark_node;
3381     }
3382
3383   return type;
3384 }
3385
3386 /* Implement the __underlying_type keyword: Return the underlying
3387    type of TYPE, suitable for use as a type-specifier.  */
3388
3389 tree
3390 finish_underlying_type (tree type)
3391 {
3392   tree underlying_type;
3393
3394   if (processing_template_decl)
3395     {
3396       underlying_type = cxx_make_type (UNDERLYING_TYPE);
3397       UNDERLYING_TYPE_TYPE (underlying_type) = type;
3398       SET_TYPE_STRUCTURAL_EQUALITY (underlying_type);
3399
3400       return underlying_type;
3401     }
3402
3403   complete_type (type);
3404
3405   if (TREE_CODE (type) != ENUMERAL_TYPE)
3406     {
3407       error ("%qT is not an enumeration type", type);
3408       return error_mark_node;
3409     }
3410
3411   underlying_type = ENUM_UNDERLYING_TYPE (type);
3412
3413   /* Fixup necessary in this case because ENUM_UNDERLYING_TYPE
3414      includes TYPE_MIN_VALUE and TYPE_MAX_VALUE information.
3415      See finish_enum_value_list for details.  */
3416   if (!ENUM_FIXED_UNDERLYING_TYPE_P (type))
3417     underlying_type
3418       = c_common_type_for_mode (TYPE_MODE (underlying_type),
3419                                 TYPE_UNSIGNED (underlying_type));
3420
3421   return underlying_type;
3422 }
3423
3424 /* Implement the __direct_bases keyword: Return the direct base classes
3425    of type */
3426
3427 tree
3428 calculate_direct_bases (tree type)
3429 {
3430   VEC(tree, gc) *vector = make_tree_vector();
3431   tree bases_vec = NULL_TREE;
3432   VEC(tree, none) *base_binfos;
3433   tree binfo;
3434   unsigned i;
3435
3436   complete_type (type);
3437
3438   if (!NON_UNION_CLASS_TYPE_P (type))
3439     return make_tree_vec (0);
3440
3441   base_binfos = BINFO_BASE_BINFOS (TYPE_BINFO (type));
3442
3443   /* Virtual bases are initialized first */
3444   for (i = 0; VEC_iterate (tree, base_binfos, i, binfo); i++)
3445     {
3446       if (BINFO_VIRTUAL_P (binfo))
3447        {
3448          VEC_safe_push (tree, gc, vector, binfo);
3449        }
3450     }
3451
3452   /* Now non-virtuals */
3453   for (i = 0; VEC_iterate (tree, base_binfos, i, binfo); i++)
3454     {
3455       if (!BINFO_VIRTUAL_P (binfo))
3456        {
3457          VEC_safe_push (tree, gc, vector, binfo);
3458        }
3459     }
3460
3461
3462   bases_vec = make_tree_vec (VEC_length (tree, vector));
3463
3464   for (i = 0; i < VEC_length (tree, vector); ++i)
3465     {
3466       TREE_VEC_ELT (bases_vec, i) = BINFO_TYPE (VEC_index (tree, vector, i));
3467     }
3468   return bases_vec;
3469 }
3470
3471 /* Implement the __bases keyword: Return the base classes
3472    of type */
3473
3474 /* Find morally non-virtual base classes by walking binfo hierarchy */
3475 /* Virtual base classes are handled separately in finish_bases */
3476
3477 static tree
3478 dfs_calculate_bases_pre (tree binfo, ATTRIBUTE_UNUSED void *data_)
3479 {
3480   /* Don't walk bases of virtual bases */
3481   return BINFO_VIRTUAL_P (binfo) ? dfs_skip_bases : NULL_TREE;
3482 }
3483
3484 static tree
3485 dfs_calculate_bases_post (tree binfo, void *data_)
3486 {
3487   VEC(tree, gc) **data = (VEC(tree, gc) **) data_;
3488   if (!BINFO_VIRTUAL_P (binfo))
3489     {
3490       VEC_safe_push (tree, gc, *data, BINFO_TYPE (binfo));
3491     }
3492   return NULL_TREE;
3493 }
3494
3495 /* Calculates the morally non-virtual base classes of a class */
3496 static VEC(tree, gc) *
3497 calculate_bases_helper (tree type)
3498 {
3499   VEC(tree, gc) *vector = make_tree_vector();
3500
3501   /* Now add non-virtual base classes in order of construction */
3502   dfs_walk_all (TYPE_BINFO (type),
3503                 dfs_calculate_bases_pre, dfs_calculate_bases_post, &vector);
3504   return vector;
3505 }
3506
3507 tree
3508 calculate_bases (tree type)
3509 {
3510   VEC(tree, gc) *vector = make_tree_vector();
3511   tree bases_vec = NULL_TREE;
3512   unsigned i;
3513   VEC(tree, gc) *vbases;
3514   VEC(tree, gc) *nonvbases;
3515   tree binfo;
3516
3517   complete_type (type);
3518
3519   if (!NON_UNION_CLASS_TYPE_P (type))
3520     return make_tree_vec (0);
3521
3522   /* First go through virtual base classes */
3523   for (vbases = CLASSTYPE_VBASECLASSES (type), i = 0;
3524        VEC_iterate (tree, vbases, i, binfo); i++)
3525     {
3526       VEC(tree, gc) *vbase_bases = calculate_bases_helper (BINFO_TYPE (binfo));
3527       VEC_safe_splice (tree, gc, vector, vbase_bases);
3528       release_tree_vector (vbase_bases);
3529     }
3530
3531   /* Now for the non-virtual bases */
3532   nonvbases = calculate_bases_helper (type);
3533   VEC_safe_splice (tree, gc, vector, nonvbases);
3534   release_tree_vector (nonvbases);
3535
3536   /* Last element is entire class, so don't copy */
3537   bases_vec = make_tree_vec (VEC_length (tree, vector) - 1);
3538
3539   for (i = 0; i < VEC_length (tree, vector) - 1; ++i)
3540     {
3541       TREE_VEC_ELT (bases_vec, i) = VEC_index (tree, vector, i);
3542     }
3543   release_tree_vector (vector);
3544   return bases_vec;
3545 }
3546
3547 tree
3548 finish_bases (tree type, bool direct)
3549 {
3550   tree bases = NULL_TREE;
3551
3552   if (!processing_template_decl)
3553     {
3554       /* Parameter packs can only be used in templates */
3555       error ("Parameter pack __bases only valid in template declaration");
3556       return error_mark_node;
3557     }
3558
3559   bases = cxx_make_type (BASES);
3560   BASES_TYPE (bases) = type;
3561   BASES_DIRECT (bases) = direct;
3562   SET_TYPE_STRUCTURAL_EQUALITY (bases);
3563
3564   return bases;
3565 }
3566
3567 /* Perform C++-specific checks for __builtin_offsetof before calling
3568    fold_offsetof.  */
3569
3570 tree
3571 finish_offsetof (tree expr)
3572 {
3573   if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
3574     {
3575       error ("cannot apply %<offsetof%> to destructor %<~%T%>",
3576               TREE_OPERAND (expr, 2));
3577       return error_mark_node;
3578     }
3579   if (TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE
3580       || TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE
3581       || TREE_TYPE (expr) == unknown_type_node)
3582     {
3583       if (TREE_CODE (expr) == COMPONENT_REF
3584           || TREE_CODE (expr) == COMPOUND_EXPR)
3585         expr = TREE_OPERAND (expr, 1);
3586       error ("cannot apply %<offsetof%> to member function %qD", expr);
3587       return error_mark_node;
3588     }
3589   if (REFERENCE_REF_P (expr))
3590     expr = TREE_OPERAND (expr, 0);
3591   if (TREE_CODE (expr) == COMPONENT_REF)
3592     {
3593       tree object = TREE_OPERAND (expr, 0);
3594       if (!complete_type_or_else (TREE_TYPE (object), object))
3595         return error_mark_node;
3596     }
3597   return fold_offsetof (expr);
3598 }
3599
3600 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR.  This
3601    function is broken out from the above for the benefit of the tree-ssa
3602    project.  */
3603
3604 void
3605 simplify_aggr_init_expr (tree *tp)
3606 {
3607   tree aggr_init_expr = *tp;
3608
3609   /* Form an appropriate CALL_EXPR.  */
3610   tree fn = AGGR_INIT_EXPR_FN (aggr_init_expr);
3611   tree slot = AGGR_INIT_EXPR_SLOT (aggr_init_expr);
3612   tree type = TREE_TYPE (slot);
3613
3614   tree call_expr;
3615   enum style_t { ctor, arg, pcc } style;
3616
3617   if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr))
3618     style = ctor;
3619 #ifdef PCC_STATIC_STRUCT_RETURN
3620   else if (1)
3621     style = pcc;
3622 #endif
3623   else
3624     {
3625       gcc_assert (TREE_ADDRESSABLE (type));
3626       style = arg;
3627     }
3628
3629   call_expr = build_call_array_loc (input_location,
3630                                     TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
3631                                     fn,
3632                                     aggr_init_expr_nargs (aggr_init_expr),
3633                                     AGGR_INIT_EXPR_ARGP (aggr_init_expr));
3634   TREE_NOTHROW (call_expr) = TREE_NOTHROW (aggr_init_expr);
3635
3636   if (style == ctor)
3637     {
3638       /* Replace the first argument to the ctor with the address of the
3639          slot.  */
3640       cxx_mark_addressable (slot);
3641       CALL_EXPR_ARG (call_expr, 0) =
3642         build1 (ADDR_EXPR, build_pointer_type (type), slot);
3643     }
3644   else if (style == arg)
3645     {
3646       /* Just mark it addressable here, and leave the rest to
3647          expand_call{,_inline}.  */
3648       cxx_mark_addressable (slot);
3649       CALL_EXPR_RETURN_SLOT_OPT (call_expr) = true;
3650       call_expr = build2 (INIT_EXPR, TREE_TYPE (call_expr), slot, call_expr);
3651     }
3652   else if (style == pcc)
3653     {
3654       /* If we're using the non-reentrant PCC calling convention, then we
3655          need to copy the returned value out of the static buffer into the
3656          SLOT.  */
3657       push_deferring_access_checks (dk_no_check);
3658       call_expr = build_aggr_init (slot, call_expr,
3659                                    DIRECT_BIND | LOOKUP_ONLYCONVERTING,
3660                                    tf_warning_or_error);
3661       pop_deferring_access_checks ();
3662       call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (slot), call_expr, slot);
3663     }
3664
3665   if (AGGR_INIT_ZERO_FIRST (aggr_init_expr))
3666     {
3667       tree init = build_zero_init (type, NULL_TREE,
3668                                    /*static_storage_p=*/false);
3669       init = build2 (INIT_EXPR, void_type_node, slot, init);
3670       call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (call_expr),
3671                           init, call_expr);
3672     }
3673
3674   *tp = call_expr;
3675 }
3676
3677 /* Emit all thunks to FN that should be emitted when FN is emitted.  */
3678
3679 void
3680 emit_associated_thunks (tree fn)
3681 {
3682   /* When we use vcall offsets, we emit thunks with the virtual
3683      functions to which they thunk. The whole point of vcall offsets
3684      is so that you can know statically the entire set of thunks that
3685      will ever be needed for a given virtual function, thereby
3686      enabling you to output all the thunks with the function itself.  */
3687   if (DECL_VIRTUAL_P (fn)
3688       /* Do not emit thunks for extern template instantiations.  */
3689       && ! DECL_REALLY_EXTERN (fn))
3690     {
3691       tree thunk;
3692
3693       for (thunk = DECL_THUNKS (fn); thunk; thunk = DECL_CHAIN (thunk))
3694         {
3695           if (!THUNK_ALIAS (thunk))
3696             {
3697               use_thunk (thunk, /*emit_p=*/1);
3698               if (DECL_RESULT_THUNK_P (thunk))
3699                 {
3700                   tree probe;
3701
3702                   for (probe = DECL_THUNKS (thunk);
3703                        probe; probe = DECL_CHAIN (probe))
3704                     use_thunk (probe, /*emit_p=*/1);
3705                 }
3706             }
3707           else
3708             gcc_assert (!DECL_THUNKS (thunk));
3709         }
3710     }
3711 }
3712
3713 /* Returns true iff FUN is an instantiation of a constexpr function
3714    template.  */
3715
3716 static inline bool
3717 is_instantiation_of_constexpr (tree fun)
3718 {
3719   return (DECL_TEMPLOID_INSTANTIATION (fun)
3720           && DECL_DECLARED_CONSTEXPR_P (DECL_TEMPLATE_RESULT
3721                                         (DECL_TI_TEMPLATE (fun))));
3722 }
3723
3724 /* Generate RTL for FN.  */
3725
3726 bool
3727 expand_or_defer_fn_1 (tree fn)
3728 {
3729   /* When the parser calls us after finishing the body of a template
3730      function, we don't really want to expand the body.  */
3731   if (processing_template_decl)
3732     {
3733       /* Normally, collection only occurs in rest_of_compilation.  So,
3734          if we don't collect here, we never collect junk generated
3735          during the processing of templates until we hit a
3736          non-template function.  It's not safe to do this inside a
3737          nested class, though, as the parser may have local state that
3738          is not a GC root.  */
3739       if (!function_depth)
3740         ggc_collect ();
3741       return false;
3742     }
3743
3744   gcc_assert (DECL_SAVED_TREE (fn));
3745
3746   /* If this is a constructor or destructor body, we have to clone
3747      it.  */
3748   if (maybe_clone_body (fn))
3749     {
3750       /* We don't want to process FN again, so pretend we've written
3751          it out, even though we haven't.  */
3752       TREE_ASM_WRITTEN (fn) = 1;
3753       /* If this is an instantiation of a constexpr function, keep
3754          DECL_SAVED_TREE for explain_invalid_constexpr_fn.  */
3755       if (!is_instantiation_of_constexpr (fn))
3756         DECL_SAVED_TREE (fn) = NULL_TREE;
3757       return false;
3758     }
3759
3760   /* We make a decision about linkage for these functions at the end
3761      of the compilation.  Until that point, we do not want the back
3762      end to output them -- but we do want it to see the bodies of
3763      these functions so that it can inline them as appropriate.  */
3764   if (DECL_DECLARED_INLINE_P (fn) || DECL_IMPLICIT_INSTANTIATION (fn))
3765     {
3766       if (DECL_INTERFACE_KNOWN (fn))
3767         /* We've already made a decision as to how this function will
3768            be handled.  */;
3769       else if (!at_eof)
3770         {
3771           DECL_EXTERNAL (fn) = 1;
3772           DECL_NOT_REALLY_EXTERN (fn) = 1;
3773           note_vague_linkage_fn (fn);
3774           /* A non-template inline function with external linkage will
3775              always be COMDAT.  As we must eventually determine the
3776              linkage of all functions, and as that causes writes to
3777              the data mapped in from the PCH file, it's advantageous
3778              to mark the functions at this point.  */
3779           if (!DECL_IMPLICIT_INSTANTIATION (fn))
3780             {
3781               /* This function must have external linkage, as
3782                  otherwise DECL_INTERFACE_KNOWN would have been
3783                  set.  */
3784               gcc_assert (TREE_PUBLIC (fn));
3785               comdat_linkage (fn);
3786               DECL_INTERFACE_KNOWN (fn) = 1;
3787             }
3788         }
3789       else
3790         import_export_decl (fn);
3791
3792       /* If the user wants us to keep all inline functions, then mark
3793          this function as needed so that finish_file will make sure to
3794          output it later.  Similarly, all dllexport'd functions must
3795          be emitted; there may be callers in other DLLs.  */
3796       if ((flag_keep_inline_functions
3797            && DECL_DECLARED_INLINE_P (fn)
3798            && !DECL_REALLY_EXTERN (fn))
3799           || (flag_keep_inline_dllexport
3800               && lookup_attribute ("dllexport", DECL_ATTRIBUTES (fn))))
3801         {
3802           mark_needed (fn);
3803           DECL_EXTERNAL (fn) = 0;
3804         }
3805     }
3806
3807   /* There's no reason to do any of the work here if we're only doing
3808      semantic analysis; this code just generates RTL.  */
3809   if (flag_syntax_only)
3810     return false;
3811
3812   return true;
3813 }
3814
3815 void
3816 expand_or_defer_fn (tree fn)
3817 {
3818   if (expand_or_defer_fn_1 (fn))
3819     {
3820       function_depth++;
3821
3822       /* Expand or defer, at the whim of the compilation unit manager.  */
3823       cgraph_finalize_function (fn, function_depth > 1);
3824       emit_associated_thunks (fn);
3825
3826       function_depth--;
3827     }
3828 }
3829
3830 struct nrv_data
3831 {
3832   tree var;
3833   tree result;
3834   htab_t visited;
3835 };
3836
3837 /* Helper function for walk_tree, used by finalize_nrv below.  */
3838
3839 static tree
3840 finalize_nrv_r (tree* tp, int* walk_subtrees, void* data)
3841 {
3842   struct nrv_data *dp = (struct nrv_data *)data;
3843   void **slot;
3844
3845   /* No need to walk into types.  There wouldn't be any need to walk into
3846      non-statements, except that we have to consider STMT_EXPRs.  */
3847   if (TYPE_P (*tp))
3848     *walk_subtrees = 0;
3849   /* Change all returns to just refer to the RESULT_DECL; this is a nop,
3850      but differs from using NULL_TREE in that it indicates that we care
3851      about the value of the RESULT_DECL.  */
3852   else if (TREE_CODE (*tp) == RETURN_EXPR)
3853     TREE_OPERAND (*tp, 0) = dp->result;
3854   /* Change all cleanups for the NRV to only run when an exception is
3855      thrown.  */
3856   else if (TREE_CODE (*tp) == CLEANUP_STMT
3857            && CLEANUP_DECL (*tp) == dp->var)
3858     CLEANUP_EH_ONLY (*tp) = 1;
3859   /* Replace the DECL_EXPR for the NRV with an initialization of the
3860      RESULT_DECL, if needed.  */
3861   else if (TREE_CODE (*tp) == DECL_EXPR
3862            && DECL_EXPR_DECL (*tp) == dp->var)
3863     {
3864       tree init;
3865       if (DECL_INITIAL (dp->var)
3866           && DECL_INITIAL (dp->var) != error_mark_node)
3867         init = build2 (INIT_EXPR, void_type_node, dp->result,
3868                        DECL_INITIAL (dp->var));
3869       else
3870         init = build_empty_stmt (EXPR_LOCATION (*tp));
3871       DECL_INITIAL (dp->var) = NULL_TREE;
3872       SET_EXPR_LOCATION (init, EXPR_LOCATION (*tp));
3873       *tp = init;
3874     }
3875   /* And replace all uses of the NRV with the RESULT_DECL.  */
3876   else if (*tp == dp->var)
3877     *tp = dp->result;
3878
3879   /* Avoid walking into the same tree more than once.  Unfortunately, we
3880      can't just use walk_tree_without duplicates because it would only call
3881      us for the first occurrence of dp->var in the function body.  */
3882   slot = htab_find_slot (dp->visited, *tp, INSERT);
3883   if (*slot)
3884     *walk_subtrees = 0;
3885   else
3886     *slot = *tp;
3887
3888   /* Keep iterating.  */
3889   return NULL_TREE;
3890 }
3891
3892 /* Called from finish_function to implement the named return value
3893    optimization by overriding all the RETURN_EXPRs and pertinent
3894    CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
3895    RESULT_DECL for the function.  */
3896
3897 void
3898 finalize_nrv (tree *tp, tree var, tree result)
3899 {
3900   struct nrv_data data;
3901
3902   /* Copy name from VAR to RESULT.  */
3903   DECL_NAME (result) = DECL_NAME (var);
3904   /* Don't forget that we take its address.  */
3905   TREE_ADDRESSABLE (result) = TREE_ADDRESSABLE (var);
3906   /* Finally set DECL_VALUE_EXPR to avoid assigning
3907      a stack slot at -O0 for the original var and debug info
3908      uses RESULT location for VAR.  */
3909   SET_DECL_VALUE_EXPR (var, result);
3910   DECL_HAS_VALUE_EXPR_P (var) = 1;
3911
3912   data.var = var;
3913   data.result = result;
3914   data.visited = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
3915   cp_walk_tree (tp, finalize_nrv_r, &data, 0);
3916   htab_delete (data.visited);
3917 }
3918 \f
3919 /* Create CP_OMP_CLAUSE_INFO for clause C.  Returns true if it is invalid.  */
3920
3921 bool
3922 cxx_omp_create_clause_info (tree c, tree type, bool need_default_ctor,
3923                             bool need_copy_ctor, bool need_copy_assignment)
3924 {
3925   int save_errorcount = errorcount;
3926   tree info, t;
3927
3928   /* Always allocate 3 elements for simplicity.  These are the
3929      function decls for the ctor, dtor, and assignment op.
3930      This layout is known to the three lang hooks,
3931      cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
3932      and cxx_omp_clause_assign_op.  */
3933   info = make_tree_vec (3);
3934   CP_OMP_CLAUSE_INFO (c) = info;
3935
3936   if (need_default_ctor || need_copy_ctor)
3937     {
3938       if (need_default_ctor)
3939         t = get_default_ctor (type);
3940       else
3941         t = get_copy_ctor (type, tf_warning_or_error);
3942
3943       if (t && !trivial_fn_p (t))
3944         TREE_VEC_ELT (info, 0) = t;
3945     }
3946
3947   if ((need_default_ctor || need_copy_ctor)
3948       && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3949     TREE_VEC_ELT (info, 1) = get_dtor (type, tf_warning_or_error);
3950
3951   if (need_copy_assignment)
3952     {
3953       t = get_copy_assign (type);
3954
3955       if (t && !trivial_fn_p (t))
3956         TREE_VEC_ELT (info, 2) = t;
3957     }
3958
3959   return errorcount != save_errorcount;
3960 }
3961
3962 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
3963    Remove any elements from the list that are invalid.  */
3964
3965 tree
3966 finish_omp_clauses (tree clauses)
3967 {
3968   bitmap_head generic_head, firstprivate_head, lastprivate_head;
3969   tree c, t, *pc = &clauses;
3970   const char *name;
3971
3972   bitmap_obstack_initialize (NULL);
3973   bitmap_initialize (&generic_head, &bitmap_default_obstack);
3974   bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
3975   bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);
3976
3977   for (pc = &clauses, c = clauses; c ; c = *pc)
3978     {
3979       bool remove = false;
3980
3981       switch (OMP_CLAUSE_CODE (c))
3982         {
3983         case OMP_CLAUSE_SHARED:
3984           name = "shared";
3985           goto check_dup_generic;
3986         case OMP_CLAUSE_PRIVATE:
3987           name = "private";
3988           goto check_dup_generic;
3989         case OMP_CLAUSE_REDUCTION:
3990           name = "reduction";
3991           goto check_dup_generic;
3992         case OMP_CLAUSE_COPYPRIVATE:
3993           name = "copyprivate";
3994           goto check_dup_generic;
3995         case OMP_CLAUSE_COPYIN:
3996           name = "copyin";
3997           goto check_dup_generic;
3998         check_dup_generic:
3999           t = OMP_CLAUSE_DECL (c);
4000           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
4001             {
4002               if (processing_template_decl)
4003                 break;
4004               if (DECL_P (t))
4005                 error ("%qD is not a variable in clause %qs", t, name);
4006               else
4007                 error ("%qE is not a variable in clause %qs", t, name);
4008               remove = true;
4009             }
4010           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
4011                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t))
4012                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
4013             {
4014               error ("%qD appears more than once in data clauses", t);
4015               remove = true;
4016             }
4017           else
4018             bitmap_set_bit (&generic_head, DECL_UID (t));
4019           break;
4020
4021         case OMP_CLAUSE_FIRSTPRIVATE:
4022           t = OMP_CLAUSE_DECL (c);
4023           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
4024             {
4025               if (processing_template_decl)
4026                 break;
4027               if (DECL_P (t))
4028                 error ("%qD is not a variable in clause %<firstprivate%>", t);
4029               else
4030                 error ("%qE is not a variable in clause %<firstprivate%>", t);
4031               remove = true;
4032             }
4033           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
4034                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
4035             {
4036               error ("%qD appears more than once in data clauses", t);
4037               remove = true;
4038             }
4039           else
4040             bitmap_set_bit (&firstprivate_head, DECL_UID (t));
4041           break;
4042
4043         case OMP_CLAUSE_LASTPRIVATE:
4044           t = OMP_CLAUSE_DECL (c);
4045           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
4046             {
4047               if (processing_template_decl)
4048                 break;
4049               if (DECL_P (t))
4050                 error ("%qD is not a variable in clause %<lastprivate%>", t);
4051               else
4052                 error ("%qE is not a variable in clause %<lastprivate%>", t);
4053               remove = true;
4054             }
4055           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
4056                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
4057             {
4058               error ("%qD appears more than once in data clauses", t);
4059               remove = true;
4060             }
4061           else
4062             bitmap_set_bit (&lastprivate_head, DECL_UID (t));
4063           break;
4064
4065         case OMP_CLAUSE_IF:
4066           t = OMP_CLAUSE_IF_EXPR (c);
4067           t = maybe_convert_cond (t);
4068           if (t == error_mark_node)
4069             remove = true;
4070           OMP_CLAUSE_IF_EXPR (c) = t;
4071           break;
4072
4073         case OMP_CLAUSE_FINAL:
4074           t = OMP_CLAUSE_FINAL_EXPR (c);
4075           t = maybe_convert_cond (t);
4076           if (t == error_mark_node)
4077             remove = true;
4078           OMP_CLAUSE_FINAL_EXPR (c) = t;
4079           break;
4080
4081         case OMP_CLAUSE_NUM_THREADS:
4082           t = OMP_CLAUSE_NUM_THREADS_EXPR (c);
4083           if (t == error_mark_node)
4084             remove = true;
4085           else if (!type_dependent_expression_p (t)
4086                    && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
4087             {
4088               error ("num_threads expression must be integral");
4089               remove = true;
4090             }
4091           else
4092             OMP_CLAUSE_NUM_THREADS_EXPR (c) = mark_rvalue_use (t);
4093           break;
4094
4095         case OMP_CLAUSE_SCHEDULE:
4096           t = OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c);
4097           if (t == NULL)
4098             ;
4099           else if (t == error_mark_node)
4100             remove = true;
4101           else if (!type_dependent_expression_p (t)
4102                    && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
4103             {
4104               error ("schedule chunk size expression must be integral");
4105               remove = true;
4106             }
4107           else
4108             OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = mark_rvalue_use (t);
4109           break;
4110
4111         case OMP_CLAUSE_NOWAIT:
4112         case OMP_CLAUSE_ORDERED:
4113         case OMP_CLAUSE_DEFAULT:
4114         case OMP_CLAUSE_UNTIED:
4115         case OMP_CLAUSE_COLLAPSE:
4116         case OMP_CLAUSE_MERGEABLE:
4117           break;
4118
4119         default:
4120           gcc_unreachable ();
4121         }
4122
4123       if (remove)
4124         *pc = OMP_CLAUSE_CHAIN (c);
4125       else
4126         pc = &OMP_CLAUSE_CHAIN (c);
4127     }
4128
4129   for (pc = &clauses, c = clauses; c ; c = *pc)
4130     {
4131       enum omp_clause_code c_kind = OMP_CLAUSE_CODE (c);
4132       bool remove = false;
4133       bool need_complete_non_reference = false;
4134       bool need_default_ctor = false;
4135       bool need_copy_ctor = false;
4136       bool need_copy_assignment = false;
4137       bool need_implicitly_determined = false;
4138       tree type, inner_type;
4139
4140       switch (c_kind)
4141         {
4142         case OMP_CLAUSE_SHARED:
4143           name = "shared";
4144           need_implicitly_determined = true;
4145           break;
4146         case OMP_CLAUSE_PRIVATE:
4147           name = "private";
4148           need_complete_non_reference = true;
4149           need_default_ctor = true;
4150           need_implicitly_determined = true;
4151           break;
4152         case OMP_CLAUSE_FIRSTPRIVATE:
4153           name = "firstprivate";
4154           need_complete_non_reference = true;
4155           need_copy_ctor = true;
4156           need_implicitly_determined = true;
4157           break;
4158         case OMP_CLAUSE_LASTPRIVATE:
4159           name = "lastprivate";
4160           need_complete_non_reference = true;
4161           need_copy_assignment = true;
4162           need_implicitly_determined = true;