OSDN Git Service

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