OSDN Git Service

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