OSDN Git Service

cbbcf96e2cc6defc0d4f6f70b77223b589af13d0
[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 (cl, cl, fns, /*optype=*/NULL_TREE);
2662 }
2663
2664 /* Returns true iff DECL is an automatic variable from a function outside
2665    the current one.  */
2666
2667 static bool
2668 outer_automatic_var_p (tree decl)
2669 {
2670   return ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
2671           && DECL_FUNCTION_SCOPE_P (decl)
2672           && !TREE_STATIC (decl)
2673           && DECL_CONTEXT (decl) != current_function_decl);
2674 }
2675
2676 /* Returns true iff DECL is a capture field from a lambda that is not our
2677    immediate context.  */
2678
2679 static bool
2680 outer_lambda_capture_p (tree decl)
2681 {
2682   return (TREE_CODE (decl) == FIELD_DECL
2683           && LAMBDA_TYPE_P (DECL_CONTEXT (decl))
2684           && (!current_class_type
2685               || !DERIVED_FROM_P (DECL_CONTEXT (decl), current_class_type)));
2686 }
2687
2688 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
2689    id-expression.  (See cp_parser_id_expression for details.)  SCOPE,
2690    if non-NULL, is the type or namespace used to explicitly qualify
2691    ID_EXPRESSION.  DECL is the entity to which that name has been
2692    resolved.
2693
2694    *CONSTANT_EXPRESSION_P is true if we are presently parsing a
2695    constant-expression.  In that case, *NON_CONSTANT_EXPRESSION_P will
2696    be set to true if this expression isn't permitted in a
2697    constant-expression, but it is otherwise not set by this function.
2698    *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
2699    constant-expression, but a non-constant expression is also
2700    permissible.
2701
2702    DONE is true if this expression is a complete postfix-expression;
2703    it is false if this expression is followed by '->', '[', '(', etc.
2704    ADDRESS_P is true iff this expression is the operand of '&'.
2705    TEMPLATE_P is true iff the qualified-id was of the form
2706    "A::template B".  TEMPLATE_ARG_P is true iff this qualified name
2707    appears as a template argument.
2708
2709    If an error occurs, and it is the kind of error that might cause
2710    the parser to abort a tentative parse, *ERROR_MSG is filled in.  It
2711    is the caller's responsibility to issue the message.  *ERROR_MSG
2712    will be a string with static storage duration, so the caller need
2713    not "free" it.
2714
2715    Return an expression for the entity, after issuing appropriate
2716    diagnostics.  This function is also responsible for transforming a
2717    reference to a non-static member into a COMPONENT_REF that makes
2718    the use of "this" explicit.
2719
2720    Upon return, *IDK will be filled in appropriately.  */
2721 tree
2722 finish_id_expression (tree id_expression,
2723                       tree decl,
2724                       tree scope,
2725                       cp_id_kind *idk,
2726                       bool integral_constant_expression_p,
2727                       bool allow_non_integral_constant_expression_p,
2728                       bool *non_integral_constant_expression_p,
2729                       bool template_p,
2730                       bool done,
2731                       bool address_p,
2732                       bool template_arg_p,
2733                       const char **error_msg,
2734                       location_t location)
2735 {
2736   /* Initialize the output parameters.  */
2737   *idk = CP_ID_KIND_NONE;
2738   *error_msg = NULL;
2739
2740   if (id_expression == error_mark_node)
2741     return error_mark_node;
2742   /* If we have a template-id, then no further lookup is
2743      required.  If the template-id was for a template-class, we
2744      will sometimes have a TYPE_DECL at this point.  */
2745   else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2746            || TREE_CODE (decl) == TYPE_DECL)
2747     ;
2748   /* Look up the name.  */
2749   else
2750     {
2751       if (decl == error_mark_node)
2752         {
2753           /* Name lookup failed.  */
2754           if (scope
2755               && (!TYPE_P (scope)
2756                   || (!dependent_type_p (scope)
2757                       && !(TREE_CODE (id_expression) == IDENTIFIER_NODE
2758                            && IDENTIFIER_TYPENAME_P (id_expression)
2759                            && dependent_type_p (TREE_TYPE (id_expression))))))
2760             {
2761               /* If the qualifying type is non-dependent (and the name
2762                  does not name a conversion operator to a dependent
2763                  type), issue an error.  */
2764               qualified_name_lookup_error (scope, id_expression, decl, location);
2765               return error_mark_node;
2766             }
2767           else if (!scope)
2768             {
2769               /* It may be resolved via Koenig lookup.  */
2770               *idk = CP_ID_KIND_UNQUALIFIED;
2771               return id_expression;
2772             }
2773           else
2774             decl = id_expression;
2775         }
2776       /* If DECL is a variable that would be out of scope under
2777          ANSI/ISO rules, but in scope in the ARM, name lookup
2778          will succeed.  Issue a diagnostic here.  */
2779       else
2780         decl = check_for_out_of_scope_variable (decl);
2781
2782       /* Remember that the name was used in the definition of
2783          the current class so that we can check later to see if
2784          the meaning would have been different after the class
2785          was entirely defined.  */
2786       if (!scope && decl != error_mark_node)
2787         maybe_note_name_used_in_class (id_expression, decl);
2788
2789       /* Disallow uses of local variables from containing functions, except
2790          within lambda-expressions.  */
2791       if ((outer_automatic_var_p (decl)
2792            || outer_lambda_capture_p (decl))
2793           /* It's not a use (3.2) if we're in an unevaluated context.  */
2794           && !cp_unevaluated_operand)
2795         {
2796           tree context = DECL_CONTEXT (decl);
2797           tree containing_function = current_function_decl;
2798           tree lambda_stack = NULL_TREE;
2799           tree lambda_expr = NULL_TREE;
2800           tree initializer = decl;
2801
2802           /* Core issue 696: "[At the July 2009 meeting] the CWG expressed
2803              support for an approach in which a reference to a local
2804              [constant] automatic variable in a nested class or lambda body
2805              would enter the expression as an rvalue, which would reduce
2806              the complexity of the problem"
2807
2808              FIXME update for final resolution of core issue 696.  */
2809           if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
2810             return integral_constant_value (decl);
2811
2812           if (TYPE_P (context))
2813             {
2814               /* Implicit capture of an explicit capture.  */
2815               context = lambda_function (context);
2816               initializer = thisify_lambda_field (decl);
2817             }
2818
2819           /* If we are in a lambda function, we can move out until we hit
2820              1. the context,
2821              2. a non-lambda function, or
2822              3. a non-default capturing lambda function.  */
2823           while (context != containing_function
2824                  && LAMBDA_FUNCTION_P (containing_function))
2825             {
2826               lambda_expr = CLASSTYPE_LAMBDA_EXPR
2827                 (DECL_CONTEXT (containing_function));
2828
2829               if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr)
2830                   == CPLD_NONE)
2831                 break;
2832
2833               lambda_stack = tree_cons (NULL_TREE,
2834                                         lambda_expr,
2835                                         lambda_stack);
2836
2837               containing_function
2838                 = decl_function_context (containing_function);
2839             }
2840
2841           if (context == containing_function)
2842             {
2843               decl = add_default_capture (lambda_stack,
2844                                           /*id=*/DECL_NAME (decl),
2845                                           initializer);
2846             }
2847           else if (lambda_expr)
2848             {
2849               error ("%qD is not captured", decl);
2850               return error_mark_node;
2851             }
2852           else
2853             {
2854               error (TREE_CODE (decl) == VAR_DECL
2855                      ? "use of %<auto%> variable from containing function"
2856                      : "use of parameter from containing function");
2857               error ("  %q+#D declared here", decl);
2858               return error_mark_node;
2859             }
2860         }
2861     }
2862
2863   /* If we didn't find anything, or what we found was a type,
2864      then this wasn't really an id-expression.  */
2865   if (TREE_CODE (decl) == TEMPLATE_DECL
2866       && !DECL_FUNCTION_TEMPLATE_P (decl))
2867     {
2868       *error_msg = "missing template arguments";
2869       return error_mark_node;
2870     }
2871   else if (TREE_CODE (decl) == TYPE_DECL
2872            || TREE_CODE (decl) == NAMESPACE_DECL)
2873     {
2874       *error_msg = "expected primary-expression";
2875       return error_mark_node;
2876     }
2877
2878   /* If the name resolved to a template parameter, there is no
2879      need to look it up again later.  */
2880   if ((TREE_CODE (decl) == CONST_DECL && DECL_TEMPLATE_PARM_P (decl))
2881       || TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
2882     {
2883       tree r;
2884
2885       *idk = CP_ID_KIND_NONE;
2886       if (TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
2887         decl = TEMPLATE_PARM_DECL (decl);
2888       r = convert_from_reference (DECL_INITIAL (decl));
2889
2890       if (integral_constant_expression_p
2891           && !dependent_type_p (TREE_TYPE (decl))
2892           && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r))))
2893         {
2894           if (!allow_non_integral_constant_expression_p)
2895             error ("template parameter %qD of type %qT is not allowed in "
2896                    "an integral constant expression because it is not of "
2897                    "integral or enumeration type", decl, TREE_TYPE (decl));
2898           *non_integral_constant_expression_p = true;
2899         }
2900       return r;
2901     }
2902   /* Similarly, we resolve enumeration constants to their
2903      underlying values.  */
2904   else if (TREE_CODE (decl) == CONST_DECL)
2905     {
2906       *idk = CP_ID_KIND_NONE;
2907       if (!processing_template_decl)
2908         {
2909           used_types_insert (TREE_TYPE (decl));
2910           return DECL_INITIAL (decl);
2911         }
2912       return decl;
2913     }
2914   else
2915     {
2916       bool dependent_p;
2917
2918       /* If the declaration was explicitly qualified indicate
2919          that.  The semantics of `A::f(3)' are different than
2920          `f(3)' if `f' is virtual.  */
2921       *idk = (scope
2922               ? CP_ID_KIND_QUALIFIED
2923               : (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2924                  ? CP_ID_KIND_TEMPLATE_ID
2925                  : CP_ID_KIND_UNQUALIFIED));
2926
2927
2928       /* [temp.dep.expr]
2929
2930          An id-expression is type-dependent if it contains an
2931          identifier that was declared with a dependent type.
2932
2933          The standard is not very specific about an id-expression that
2934          names a set of overloaded functions.  What if some of them
2935          have dependent types and some of them do not?  Presumably,
2936          such a name should be treated as a dependent name.  */
2937       /* Assume the name is not dependent.  */
2938       dependent_p = false;
2939       if (!processing_template_decl)
2940         /* No names are dependent outside a template.  */
2941         ;
2942       /* A template-id where the name of the template was not resolved
2943          is definitely dependent.  */
2944       else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2945                && (TREE_CODE (TREE_OPERAND (decl, 0))
2946                    == IDENTIFIER_NODE))
2947         dependent_p = true;
2948       /* For anything except an overloaded function, just check its
2949          type.  */
2950       else if (!is_overloaded_fn (decl))
2951         dependent_p
2952           = dependent_type_p (TREE_TYPE (decl));
2953       /* For a set of overloaded functions, check each of the
2954          functions.  */
2955       else
2956         {
2957           tree fns = decl;
2958
2959           if (BASELINK_P (fns))
2960             fns = BASELINK_FUNCTIONS (fns);
2961
2962           /* For a template-id, check to see if the template
2963              arguments are dependent.  */
2964           if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
2965             {
2966               tree args = TREE_OPERAND (fns, 1);
2967               dependent_p = any_dependent_template_arguments_p (args);
2968               /* The functions are those referred to by the
2969                  template-id.  */
2970               fns = TREE_OPERAND (fns, 0);
2971             }
2972
2973           /* If there are no dependent template arguments, go through
2974              the overloaded functions.  */
2975           while (fns && !dependent_p)
2976             {
2977               tree fn = OVL_CURRENT (fns);
2978
2979               /* Member functions of dependent classes are
2980                  dependent.  */
2981               if (TREE_CODE (fn) == FUNCTION_DECL
2982                   && type_dependent_expression_p (fn))
2983                 dependent_p = true;
2984               else if (TREE_CODE (fn) == TEMPLATE_DECL
2985                        && dependent_template_p (fn))
2986                 dependent_p = true;
2987
2988               fns = OVL_NEXT (fns);
2989             }
2990         }
2991
2992       /* If the name was dependent on a template parameter, we will
2993          resolve the name at instantiation time.  */
2994       if (dependent_p)
2995         {
2996           /* Create a SCOPE_REF for qualified names, if the scope is
2997              dependent.  */
2998           if (scope)
2999             {
3000               if (TYPE_P (scope))
3001                 {
3002                   if (address_p && done)
3003                     decl = finish_qualified_id_expr (scope, decl,
3004                                                      done, address_p,
3005                                                      template_p,
3006                                                      template_arg_p);
3007                   else
3008                     {
3009                       tree type = NULL_TREE;
3010                       if (DECL_P (decl) && !dependent_scope_p (scope))
3011                         type = TREE_TYPE (decl);
3012                       decl = build_qualified_name (type,
3013                                                    scope,
3014                                                    id_expression,
3015                                                    template_p);
3016                     }
3017                 }
3018               if (TREE_TYPE (decl))
3019                 decl = convert_from_reference (decl);
3020               return decl;
3021             }
3022           /* A TEMPLATE_ID already contains all the information we
3023              need.  */
3024           if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR)
3025             return id_expression;
3026           *idk = CP_ID_KIND_UNQUALIFIED_DEPENDENT;
3027           /* If we found a variable, then name lookup during the
3028              instantiation will always resolve to the same VAR_DECL
3029              (or an instantiation thereof).  */
3030           if (TREE_CODE (decl) == VAR_DECL
3031               || TREE_CODE (decl) == PARM_DECL)
3032             return convert_from_reference (decl);
3033           /* The same is true for FIELD_DECL, but we also need to
3034              make sure that the syntax is correct.  */
3035           else if (TREE_CODE (decl) == FIELD_DECL)
3036             {
3037               /* Since SCOPE is NULL here, this is an unqualified name.
3038                  Access checking has been performed during name lookup
3039                  already.  Turn off checking to avoid duplicate errors.  */
3040               push_deferring_access_checks (dk_no_check);
3041               decl = finish_non_static_data_member
3042                        (decl, NULL_TREE,
3043                         /*qualifying_scope=*/NULL_TREE);
3044               pop_deferring_access_checks ();
3045               return decl;
3046             }
3047           return id_expression;
3048         }
3049
3050       /* Only certain kinds of names are allowed in constant
3051          expression.  Enumerators and template parameters have already
3052          been handled above.  */
3053       if (integral_constant_expression_p
3054           && ! DECL_INTEGRAL_CONSTANT_VAR_P (decl)
3055           && ! builtin_valid_in_constant_expr_p (decl))
3056         {
3057           if (!allow_non_integral_constant_expression_p)
3058             {
3059               error ("%qD cannot appear in a constant-expression", decl);
3060               return error_mark_node;
3061             }
3062           *non_integral_constant_expression_p = true;
3063         }
3064
3065       if (TREE_CODE (decl) == NAMESPACE_DECL)
3066         {
3067           error ("use of namespace %qD as expression", decl);
3068           return error_mark_node;
3069         }
3070       else if (DECL_CLASS_TEMPLATE_P (decl))
3071         {
3072           error ("use of class template %qT as expression", decl);
3073           return error_mark_node;
3074         }
3075       else if (TREE_CODE (decl) == TREE_LIST)
3076         {
3077           /* Ambiguous reference to base members.  */
3078           error ("request for member %qD is ambiguous in "
3079                  "multiple inheritance lattice", id_expression);
3080           print_candidates (decl);
3081           return error_mark_node;
3082         }
3083
3084       /* Mark variable-like entities as used.  Functions are similarly
3085          marked either below or after overload resolution.  */
3086       if (TREE_CODE (decl) == VAR_DECL
3087           || TREE_CODE (decl) == PARM_DECL
3088           || TREE_CODE (decl) == RESULT_DECL)
3089         mark_used (decl);
3090
3091       if (scope)
3092         {
3093           decl = (adjust_result_of_qualified_name_lookup
3094                   (decl, scope, current_class_type));
3095
3096           if (TREE_CODE (decl) == FUNCTION_DECL)
3097             mark_used (decl);
3098
3099           if (TREE_CODE (decl) == FIELD_DECL || BASELINK_P (decl))
3100             decl = finish_qualified_id_expr (scope,
3101                                              decl,
3102                                              done,
3103                                              address_p,
3104                                              template_p,
3105                                              template_arg_p);
3106           else
3107             {
3108               tree r = convert_from_reference (decl);
3109
3110               if (processing_template_decl && TYPE_P (scope))
3111                 r = build_qualified_name (TREE_TYPE (r),
3112                                           scope, decl,
3113                                           template_p);
3114               decl = r;
3115             }
3116         }
3117       else if (TREE_CODE (decl) == FIELD_DECL)
3118         {
3119           /* Since SCOPE is NULL here, this is an unqualified name.
3120              Access checking has been performed during name lookup
3121              already.  Turn off checking to avoid duplicate errors.  */
3122           push_deferring_access_checks (dk_no_check);
3123           decl = finish_non_static_data_member (decl, NULL_TREE,
3124                                                 /*qualifying_scope=*/NULL_TREE);
3125           pop_deferring_access_checks ();
3126         }
3127       else if (is_overloaded_fn (decl))
3128         {
3129           tree first_fn;
3130
3131           first_fn = get_first_fn (decl);
3132           if (TREE_CODE (first_fn) == TEMPLATE_DECL)
3133             first_fn = DECL_TEMPLATE_RESULT (first_fn);
3134
3135           if (!really_overloaded_fn (decl))
3136             mark_used (first_fn);
3137
3138           if (!template_arg_p
3139               && TREE_CODE (first_fn) == FUNCTION_DECL
3140               && DECL_FUNCTION_MEMBER_P (first_fn)
3141               && !shared_member_p (decl))
3142             {
3143               /* A set of member functions.  */
3144               decl = maybe_dummy_object (DECL_CONTEXT (first_fn), 0);
3145               return finish_class_member_access_expr (decl, id_expression,
3146                                                       /*template_p=*/false,
3147                                                       tf_warning_or_error);
3148             }
3149
3150           decl = baselink_for_fns (decl);
3151         }
3152       else
3153         {
3154           if (DECL_P (decl) && DECL_NONLOCAL (decl)
3155               && DECL_CLASS_SCOPE_P (decl))
3156             {
3157               tree context = context_for_name_lookup (decl); 
3158               if (context != current_class_type)
3159                 {
3160                   tree path = currently_open_derived_class (context);
3161                   perform_or_defer_access_check (TYPE_BINFO (path),
3162                                                  decl, decl);
3163                 }
3164             }
3165
3166           decl = convert_from_reference (decl);
3167         }
3168     }
3169
3170   if (TREE_DEPRECATED (decl))
3171     warn_deprecated_use (decl, NULL_TREE);
3172
3173   return decl;
3174 }
3175
3176 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
3177    use as a type-specifier.  */
3178
3179 tree
3180 finish_typeof (tree expr)
3181 {
3182   tree type;
3183
3184   if (type_dependent_expression_p (expr))
3185     {
3186       type = cxx_make_type (TYPEOF_TYPE);
3187       TYPEOF_TYPE_EXPR (type) = expr;
3188       SET_TYPE_STRUCTURAL_EQUALITY (type);
3189
3190       return type;
3191     }
3192
3193   expr = mark_type_use (expr);
3194
3195   type = unlowered_expr_type (expr);
3196
3197   if (!type || type == unknown_type_node)
3198     {
3199       error ("type of %qE is unknown", expr);
3200       return error_mark_node;
3201     }
3202
3203   return type;
3204 }
3205
3206 /* Perform C++-specific checks for __builtin_offsetof before calling
3207    fold_offsetof.  */
3208
3209 tree
3210 finish_offsetof (tree expr)
3211 {
3212   if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
3213     {
3214       error ("cannot apply %<offsetof%> to destructor %<~%T%>",
3215               TREE_OPERAND (expr, 2));
3216       return error_mark_node;
3217     }
3218   if (TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE
3219       || TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE
3220       || TREE_CODE (TREE_TYPE (expr)) == UNKNOWN_TYPE)
3221     {
3222       if (TREE_CODE (expr) == COMPONENT_REF
3223           || TREE_CODE (expr) == COMPOUND_EXPR)
3224         expr = TREE_OPERAND (expr, 1);
3225       error ("cannot apply %<offsetof%> to member function %qD", expr);
3226       return error_mark_node;
3227     }
3228   if (TREE_CODE (expr) == INDIRECT_REF && REFERENCE_REF_P (expr))
3229     expr = TREE_OPERAND (expr, 0);
3230   return fold_offsetof (expr, NULL_TREE);
3231 }
3232
3233 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR.  This
3234    function is broken out from the above for the benefit of the tree-ssa
3235    project.  */
3236
3237 void
3238 simplify_aggr_init_expr (tree *tp)
3239 {
3240   tree aggr_init_expr = *tp;
3241
3242   /* Form an appropriate CALL_EXPR.  */
3243   tree fn = AGGR_INIT_EXPR_FN (aggr_init_expr);
3244   tree slot = AGGR_INIT_EXPR_SLOT (aggr_init_expr);
3245   tree type = TREE_TYPE (slot);
3246
3247   tree call_expr;
3248   enum style_t { ctor, arg, pcc } style;
3249
3250   if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr))
3251     style = ctor;
3252 #ifdef PCC_STATIC_STRUCT_RETURN
3253   else if (1)
3254     style = pcc;
3255 #endif
3256   else
3257     {
3258       gcc_assert (TREE_ADDRESSABLE (type));
3259       style = arg;
3260     }
3261
3262   call_expr = build_call_array_loc (input_location,
3263                                     TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
3264                                     fn,
3265                                     aggr_init_expr_nargs (aggr_init_expr),
3266                                     AGGR_INIT_EXPR_ARGP (aggr_init_expr));
3267
3268   if (style == ctor)
3269     {
3270       /* Replace the first argument to the ctor with the address of the
3271          slot.  */
3272       cxx_mark_addressable (slot);
3273       CALL_EXPR_ARG (call_expr, 0) =
3274         build1 (ADDR_EXPR, build_pointer_type (type), slot);
3275     }
3276   else if (style == arg)
3277     {
3278       /* Just mark it addressable here, and leave the rest to
3279          expand_call{,_inline}.  */
3280       cxx_mark_addressable (slot);
3281       CALL_EXPR_RETURN_SLOT_OPT (call_expr) = true;
3282       call_expr = build2 (INIT_EXPR, TREE_TYPE (call_expr), slot, call_expr);
3283     }
3284   else if (style == pcc)
3285     {
3286       /* If we're using the non-reentrant PCC calling convention, then we
3287          need to copy the returned value out of the static buffer into the
3288          SLOT.  */
3289       push_deferring_access_checks (dk_no_check);
3290       call_expr = build_aggr_init (slot, call_expr,
3291                                    DIRECT_BIND | LOOKUP_ONLYCONVERTING,
3292                                    tf_warning_or_error);
3293       pop_deferring_access_checks ();
3294       call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (slot), call_expr, slot);
3295     }
3296
3297   if (AGGR_INIT_ZERO_FIRST (aggr_init_expr))
3298     {
3299       tree init = build_zero_init (type, NULL_TREE,
3300                                    /*static_storage_p=*/false);
3301       init = build2 (INIT_EXPR, void_type_node, slot, init);
3302       call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (call_expr),
3303                           init, call_expr);
3304     }
3305
3306   *tp = call_expr;
3307 }
3308
3309 /* Emit all thunks to FN that should be emitted when FN is emitted.  */
3310
3311 void
3312 emit_associated_thunks (tree fn)
3313 {
3314   /* When we use vcall offsets, we emit thunks with the virtual
3315      functions to which they thunk. The whole point of vcall offsets
3316      is so that you can know statically the entire set of thunks that
3317      will ever be needed for a given virtual function, thereby
3318      enabling you to output all the thunks with the function itself.  */
3319   if (DECL_VIRTUAL_P (fn)
3320       /* Do not emit thunks for extern template instantiations.  */
3321       && ! DECL_REALLY_EXTERN (fn))
3322     {
3323       tree thunk;
3324
3325       for (thunk = DECL_THUNKS (fn); thunk; thunk = TREE_CHAIN (thunk))
3326         {
3327           if (!THUNK_ALIAS (thunk))
3328             {
3329               use_thunk (thunk, /*emit_p=*/1);
3330               if (DECL_RESULT_THUNK_P (thunk))
3331                 {
3332                   tree probe;
3333
3334                   for (probe = DECL_THUNKS (thunk);
3335                        probe; probe = TREE_CHAIN (probe))
3336                     use_thunk (probe, /*emit_p=*/1);
3337                 }
3338             }
3339           else
3340             gcc_assert (!DECL_THUNKS (thunk));
3341         }
3342     }
3343 }
3344
3345 /* Generate RTL for FN.  */
3346
3347 bool
3348 expand_or_defer_fn_1 (tree fn)
3349 {
3350   /* When the parser calls us after finishing the body of a template
3351      function, we don't really want to expand the body.  */
3352   if (processing_template_decl)
3353     {
3354       /* Normally, collection only occurs in rest_of_compilation.  So,
3355          if we don't collect here, we never collect junk generated
3356          during the processing of templates until we hit a
3357          non-template function.  It's not safe to do this inside a
3358          nested class, though, as the parser may have local state that
3359          is not a GC root.  */
3360       if (!function_depth)
3361         ggc_collect ();
3362       return false;
3363     }
3364
3365   gcc_assert (DECL_SAVED_TREE (fn));
3366
3367   /* If this is a constructor or destructor body, we have to clone
3368      it.  */
3369   if (maybe_clone_body (fn))
3370     {
3371       /* We don't want to process FN again, so pretend we've written
3372          it out, even though we haven't.  */
3373       TREE_ASM_WRITTEN (fn) = 1;
3374       DECL_SAVED_TREE (fn) = NULL_TREE;
3375       return false;
3376     }
3377
3378   /* We make a decision about linkage for these functions at the end
3379      of the compilation.  Until that point, we do not want the back
3380      end to output them -- but we do want it to see the bodies of
3381      these functions so that it can inline them as appropriate.  */
3382   if (DECL_DECLARED_INLINE_P (fn) || DECL_IMPLICIT_INSTANTIATION (fn))
3383     {
3384       if (DECL_INTERFACE_KNOWN (fn))
3385         /* We've already made a decision as to how this function will
3386            be handled.  */;
3387       else if (!at_eof)
3388         {
3389           DECL_EXTERNAL (fn) = 1;
3390           DECL_NOT_REALLY_EXTERN (fn) = 1;
3391           note_vague_linkage_fn (fn);
3392           /* A non-template inline function with external linkage will
3393              always be COMDAT.  As we must eventually determine the
3394              linkage of all functions, and as that causes writes to
3395              the data mapped in from the PCH file, it's advantageous
3396              to mark the functions at this point.  */
3397           if (!DECL_IMPLICIT_INSTANTIATION (fn))
3398             {
3399               /* This function must have external linkage, as
3400                  otherwise DECL_INTERFACE_KNOWN would have been
3401                  set.  */
3402               gcc_assert (TREE_PUBLIC (fn));
3403               comdat_linkage (fn);
3404               DECL_INTERFACE_KNOWN (fn) = 1;
3405             }
3406         }
3407       else
3408         import_export_decl (fn);
3409
3410       /* If the user wants us to keep all inline functions, then mark
3411          this function as needed so that finish_file will make sure to
3412          output it later.  Similarly, all dllexport'd functions must
3413          be emitted; there may be callers in other DLLs.  */
3414       if ((flag_keep_inline_functions
3415            && DECL_DECLARED_INLINE_P (fn)
3416            && !DECL_REALLY_EXTERN (fn))
3417           || lookup_attribute ("dllexport", DECL_ATTRIBUTES (fn)))
3418         mark_needed (fn);
3419     }
3420
3421   /* There's no reason to do any of the work here if we're only doing
3422      semantic analysis; this code just generates RTL.  */
3423   if (flag_syntax_only)
3424     return false;
3425
3426   return true;
3427 }
3428
3429 void
3430 expand_or_defer_fn (tree fn)
3431 {
3432   if (expand_or_defer_fn_1 (fn))
3433     {
3434       function_depth++;
3435
3436       /* Expand or defer, at the whim of the compilation unit manager.  */
3437       cgraph_finalize_function (fn, function_depth > 1);
3438       emit_associated_thunks (fn);
3439
3440       function_depth--;
3441     }
3442 }
3443
3444 struct nrv_data
3445 {
3446   tree var;
3447   tree result;
3448   htab_t visited;
3449 };
3450
3451 /* Helper function for walk_tree, used by finalize_nrv below.  */
3452
3453 static tree
3454 finalize_nrv_r (tree* tp, int* walk_subtrees, void* data)
3455 {
3456   struct nrv_data *dp = (struct nrv_data *)data;
3457   void **slot;
3458
3459   /* No need to walk into types.  There wouldn't be any need to walk into
3460      non-statements, except that we have to consider STMT_EXPRs.  */
3461   if (TYPE_P (*tp))
3462     *walk_subtrees = 0;
3463   /* Change all returns to just refer to the RESULT_DECL; this is a nop,
3464      but differs from using NULL_TREE in that it indicates that we care
3465      about the value of the RESULT_DECL.  */
3466   else if (TREE_CODE (*tp) == RETURN_EXPR)
3467     TREE_OPERAND (*tp, 0) = dp->result;
3468   /* Change all cleanups for the NRV to only run when an exception is
3469      thrown.  */
3470   else if (TREE_CODE (*tp) == CLEANUP_STMT
3471            && CLEANUP_DECL (*tp) == dp->var)
3472     CLEANUP_EH_ONLY (*tp) = 1;
3473   /* Replace the DECL_EXPR for the NRV with an initialization of the
3474      RESULT_DECL, if needed.  */
3475   else if (TREE_CODE (*tp) == DECL_EXPR
3476            && DECL_EXPR_DECL (*tp) == dp->var)
3477     {
3478       tree init;
3479       if (DECL_INITIAL (dp->var)
3480           && DECL_INITIAL (dp->var) != error_mark_node)
3481         init = build2 (INIT_EXPR, void_type_node, dp->result,
3482                        DECL_INITIAL (dp->var));
3483       else
3484         init = build_empty_stmt (EXPR_LOCATION (*tp));
3485       DECL_INITIAL (dp->var) = NULL_TREE;
3486       SET_EXPR_LOCATION (init, EXPR_LOCATION (*tp));
3487       *tp = init;
3488     }
3489   /* And replace all uses of the NRV with the RESULT_DECL.  */
3490   else if (*tp == dp->var)
3491     *tp = dp->result;
3492
3493   /* Avoid walking into the same tree more than once.  Unfortunately, we
3494      can't just use walk_tree_without duplicates because it would only call
3495      us for the first occurrence of dp->var in the function body.  */
3496   slot = htab_find_slot (dp->visited, *tp, INSERT);
3497   if (*slot)
3498     *walk_subtrees = 0;
3499   else
3500     *slot = *tp;
3501
3502   /* Keep iterating.  */
3503   return NULL_TREE;
3504 }
3505
3506 /* Called from finish_function to implement the named return value
3507    optimization by overriding all the RETURN_EXPRs and pertinent
3508    CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
3509    RESULT_DECL for the function.  */
3510
3511 void
3512 finalize_nrv (tree *tp, tree var, tree result)
3513 {
3514   struct nrv_data data;
3515
3516   /* Copy debugging information from VAR to RESULT.  */
3517   DECL_NAME (result) = DECL_NAME (var);
3518   DECL_ARTIFICIAL (result) = DECL_ARTIFICIAL (var);
3519   DECL_IGNORED_P (result) = DECL_IGNORED_P (var);
3520   DECL_SOURCE_LOCATION (result) = DECL_SOURCE_LOCATION (var);
3521   DECL_ABSTRACT_ORIGIN (result) = DECL_ABSTRACT_ORIGIN (var);
3522   /* Don't forget that we take its address.  */
3523   TREE_ADDRESSABLE (result) = TREE_ADDRESSABLE (var);
3524
3525   data.var = var;
3526   data.result = result;
3527   data.visited = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
3528   cp_walk_tree (tp, finalize_nrv_r, &data, 0);
3529   htab_delete (data.visited);
3530 }
3531 \f
3532 /* Return the declaration for the function called by CALL_EXPR T,
3533    TYPE is the class type of the clause decl.  */
3534
3535 static tree
3536 omp_clause_info_fndecl (tree t, tree type)
3537 {
3538   tree ret = get_callee_fndecl (t);
3539
3540   if (ret)
3541     return ret;
3542
3543   gcc_assert (TREE_CODE (t) == CALL_EXPR);
3544   t = CALL_EXPR_FN (t);
3545   STRIP_NOPS (t);
3546   if (TREE_CODE (t) == OBJ_TYPE_REF)
3547     {
3548       t = cp_fold_obj_type_ref (t, type);
3549       if (TREE_CODE (t) == ADDR_EXPR
3550           && TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL)
3551         return TREE_OPERAND (t, 0);
3552     }
3553
3554   return NULL_TREE;
3555 }
3556
3557 /* Create CP_OMP_CLAUSE_INFO for clause C.  Returns true if it is invalid.  */
3558
3559 bool
3560 cxx_omp_create_clause_info (tree c, tree type, bool need_default_ctor,
3561                             bool need_copy_ctor, bool need_copy_assignment)
3562 {
3563   int save_errorcount = errorcount;
3564   tree info, t;
3565
3566   /* Always allocate 3 elements for simplicity.  These are the
3567      function decls for the ctor, dtor, and assignment op.
3568      This layout is known to the three lang hooks,
3569      cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
3570      and cxx_omp_clause_assign_op.  */
3571   info = make_tree_vec (3);
3572   CP_OMP_CLAUSE_INFO (c) = info;
3573
3574   if (need_default_ctor
3575       || (need_copy_ctor && !TYPE_HAS_TRIVIAL_INIT_REF (type)))
3576     {
3577       VEC(tree,gc) *vec;
3578
3579       if (need_default_ctor)
3580         vec = NULL;
3581       else
3582         {
3583           t = build_int_cst (build_pointer_type (type), 0);
3584           t = build1 (INDIRECT_REF, type, t);
3585           vec = make_tree_vector_single (t);
3586         }
3587       t = build_special_member_call (NULL_TREE, complete_ctor_identifier,
3588                                      &vec, type, LOOKUP_NORMAL,
3589                                      tf_warning_or_error);
3590
3591       if (vec != NULL)
3592         release_tree_vector (vec);
3593
3594       if (targetm.cxx.cdtor_returns_this () || errorcount)
3595         /* Because constructors and destructors return this,
3596            the call will have been cast to "void".  Remove the
3597            cast here.  We would like to use STRIP_NOPS, but it
3598            wouldn't work here because TYPE_MODE (t) and
3599            TYPE_MODE (TREE_OPERAND (t, 0)) are different.
3600            They are VOIDmode and Pmode, respectively.  */
3601         if (TREE_CODE (t) == NOP_EXPR)
3602           t = TREE_OPERAND (t, 0);
3603
3604       TREE_VEC_ELT (info, 0) = get_callee_fndecl (t);
3605     }
3606
3607   if ((need_default_ctor || need_copy_ctor)
3608       && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3609     {
3610       t = build_int_cst (build_pointer_type (type), 0);
3611       t = build1 (INDIRECT_REF, type, t);
3612       t = build_special_member_call (t, complete_dtor_identifier,
3613                                      NULL, type, LOOKUP_NORMAL,
3614                                      tf_warning_or_error);
3615
3616       if (targetm.cxx.cdtor_returns_this () || errorcount)
3617         /* Because constructors and destructors return this,
3618            the call will have been cast to "void".  Remove the
3619            cast here.  We would like to use STRIP_NOPS, but it
3620            wouldn't work here because TYPE_MODE (t) and
3621            TYPE_MODE (TREE_OPERAND (t, 0)) are different.
3622            They are VOIDmode and Pmode, respectively.  */
3623         if (TREE_CODE (t) == NOP_EXPR)
3624           t = TREE_OPERAND (t, 0);
3625
3626       TREE_VEC_ELT (info, 1) = omp_clause_info_fndecl (t, type);
3627     }
3628
3629   if (need_copy_assignment && !TYPE_HAS_TRIVIAL_ASSIGN_REF (type))
3630     {
3631       VEC(tree,gc) *vec;
3632
3633       t = build_int_cst (build_pointer_type (type), 0);
3634       t = build1 (INDIRECT_REF, type, t);
3635       vec = make_tree_vector_single (t);
3636       t = build_special_member_call (t, ansi_assopname (NOP_EXPR),
3637                                      &vec, type, LOOKUP_NORMAL,
3638                                      tf_warning_or_error);
3639       release_tree_vector (vec);
3640
3641       /* We'll have called convert_from_reference on the call, which
3642          may well have added an indirect_ref.  It's unneeded here,
3643          and in the way, so kill it.  */
3644       if (TREE_CODE (t) == INDIRECT_REF)
3645         t = TREE_OPERAND (t, 0);
3646
3647       TREE_VEC_ELT (info, 2) = omp_clause_info_fndecl (t, type);
3648     }
3649
3650   return errorcount != save_errorcount;
3651 }
3652
3653 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
3654    Remove any elements from the list that are invalid.  */
3655
3656 tree
3657 finish_omp_clauses (tree clauses)
3658 {
3659   bitmap_head generic_head, firstprivate_head, lastprivate_head;
3660   tree c, t, *pc = &clauses;
3661   const char *name;
3662
3663   bitmap_obstack_initialize (NULL);
3664   bitmap_initialize (&generic_head, &bitmap_default_obstack);
3665   bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
3666   bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);
3667
3668   for (pc = &clauses, c = clauses; c ; c = *pc)
3669     {
3670       bool remove = false;
3671
3672       switch (OMP_CLAUSE_CODE (c))
3673         {
3674         case OMP_CLAUSE_SHARED:
3675           name = "shared";
3676           goto check_dup_generic;
3677         case OMP_CLAUSE_PRIVATE:
3678           name = "private";
3679           goto check_dup_generic;
3680         case OMP_CLAUSE_REDUCTION:
3681           name = "reduction";
3682           goto check_dup_generic;
3683         case OMP_CLAUSE_COPYPRIVATE:
3684           name = "copyprivate";
3685           goto check_dup_generic;
3686         case OMP_CLAUSE_COPYIN:
3687           name = "copyin";
3688           goto check_dup_generic;
3689         check_dup_generic:
3690           t = OMP_CLAUSE_DECL (c);
3691           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3692             {
3693               if (processing_template_decl)
3694                 break;
3695               if (DECL_P (t))
3696                 error ("%qD is not a variable in clause %qs", t, name);
3697               else
3698                 error ("%qE is not a variable in clause %qs", t, name);
3699               remove = true;
3700             }
3701           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
3702                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t))
3703                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
3704             {
3705               error ("%qD appears more than once in data clauses", t);
3706               remove = true;
3707             }
3708           else
3709             bitmap_set_bit (&generic_head, DECL_UID (t));
3710           break;
3711
3712         case OMP_CLAUSE_FIRSTPRIVATE:
3713           t = OMP_CLAUSE_DECL (c);
3714           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3715             {
3716               if (processing_template_decl)
3717                 break;
3718               if (DECL_P (t))
3719                 error ("%qD is not a variable in clause %<firstprivate%>", t);
3720               else
3721                 error ("%qE is not a variable in clause %<firstprivate%>", t);
3722               remove = true;
3723             }
3724           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
3725                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
3726             {
3727               error ("%qD appears more than once in data clauses", t);
3728               remove = true;
3729             }
3730           else
3731             bitmap_set_bit (&firstprivate_head, DECL_UID (t));
3732           break;
3733
3734         case OMP_CLAUSE_LASTPRIVATE:
3735           t = OMP_CLAUSE_DECL (c);
3736           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3737             {
3738               if (processing_template_decl)
3739                 break;
3740               if (DECL_P (t))
3741                 error ("%qD is not a variable in clause %<lastprivate%>", t);
3742               else
3743                 error ("%qE is not a variable in clause %<lastprivate%>", t);
3744               remove = true;
3745             }
3746           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
3747                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
3748             {
3749               error ("%qD appears more than once in data clauses", t);
3750               remove = true;
3751             }
3752           else
3753             bitmap_set_bit (&lastprivate_head, DECL_UID (t));
3754           break;
3755
3756         case OMP_CLAUSE_IF:
3757           t = OMP_CLAUSE_IF_EXPR (c);
3758           t = maybe_convert_cond (t);
3759           if (t == error_mark_node)
3760             remove = true;
3761           OMP_CLAUSE_IF_EXPR (c) = t;
3762           break;
3763
3764         case OMP_CLAUSE_NUM_THREADS:
3765           t = OMP_CLAUSE_NUM_THREADS_EXPR (c);
3766           if (t == error_mark_node)
3767             remove = true;
3768           else if (!type_dependent_expression_p (t)
3769                    && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
3770             {
3771               error ("num_threads expression must be integral");
3772               remove = true;
3773             }
3774           break;
3775
3776         case OMP_CLAUSE_SCHEDULE:
3777           t = OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c);
3778           if (t == NULL)
3779             ;
3780           else if (t == error_mark_node)
3781             remove = true;
3782           else if (!type_dependent_expression_p (t)
3783                    && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
3784             {
3785               error ("schedule chunk size expression must be integral");
3786               remove = true;
3787             }
3788           break;
3789
3790         case OMP_CLAUSE_NOWAIT:
3791         case OMP_CLAUSE_ORDERED:
3792         case OMP_CLAUSE_DEFAULT:
3793         case OMP_CLAUSE_UNTIED:
3794         case OMP_CLAUSE_COLLAPSE:
3795           break;
3796
3797         default:
3798           gcc_unreachable ();
3799         }
3800
3801       if (remove)
3802         *pc = OMP_CLAUSE_CHAIN (c);
3803       else
3804         pc = &OMP_CLAUSE_CHAIN (c);
3805     }
3806
3807   for (pc = &clauses, c = clauses; c ; c = *pc)
3808     {
3809       enum omp_clause_code c_kind = OMP_CLAUSE_CODE (c);
3810       bool remove = false;
3811       bool need_complete_non_reference = false;
3812       bool need_default_ctor = false;
3813       bool need_copy_ctor = false;
3814       bool need_copy_assignment = false;
3815       bool need_implicitly_determined = false;
3816       tree type, inner_type;
3817
3818       switch (c_kind)
3819         {
3820         case OMP_CLAUSE_SHARED:
3821           name = "shared";
3822           need_implicitly_determined = true;
3823           break;
3824         case OMP_CLAUSE_PRIVATE:
3825           name = "private";
3826           need_complete_non_reference = true;
3827           need_default_ctor = true;
3828           need_implicitly_determined = true;
3829           break;
3830         case OMP_CLAUSE_FIRSTPRIVATE:
3831           name = "firstprivate";
3832           need_complete_non_reference = true;
3833           need_copy_ctor = true;
3834           need_implicitly_determined = true;
3835           break;
3836         case OMP_CLAUSE_LASTPRIVATE:
3837           name = "lastprivate";
3838           need_complete_non_reference = true;
3839           need_copy_assignment = true;
3840           need_implicitly_determined = true;
3841           break;
3842         case OMP_CLAUSE_REDUCTION:
3843           name = "reduction";
3844           need_implicitly_determined = true;
3845           break;
3846         case OMP_CLAUSE_COPYPRIVATE:
3847           name = "copyprivate";
3848           need_copy_assignment = true;
3849           break;
3850         case OMP_CLAUSE_COPYIN:
3851           name = "copyin";
3852           need_copy_assignment = true;
3853           break;
3854         default:
3855           pc = &OMP_CLAUSE_CHAIN (c);
3856           continue;
3857         }
3858
3859       t = OMP_CLAUSE_DECL (c);
3860       if (processing_template_decl
3861           && TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3862         {
3863           pc = &OMP_CLAUSE_CHAIN (c);
3864           continue;
3865         }
3866
3867       switch (c_kind)
3868         {
3869         case OMP_CLAUSE_LASTPRIVATE:
3870           if (!bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
3871             need_default_ctor = true;
3872           break;
3873
3874         case OMP_CLAUSE_REDUCTION:
3875           if (AGGREGATE_TYPE_P (TREE_TYPE (t))
3876               || POINTER_TYPE_P (TREE_TYPE (t)))
3877             {
3878               error ("%qE has invalid type for %<reduction%>", t);
3879               remove = true;
3880             }
3881           else if (FLOAT_TYPE_P (TREE_TYPE (t)))
3882             {
3883               enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c);
3884               switch (r_code)
3885                 {
3886                 case PLUS_EXPR:
3887                 case MULT_EXPR:
3888                 case MINUS_EXPR:
3889                   break;
3890                 default:
3891                   error ("%qE has invalid type for %<reduction(%s)%>",
3892                          t, operator_name_info[r_code].name);
3893                   remove = true;
3894                 }
3895             }
3896           break;
3897
3898         case OMP_CLAUSE_COPYIN:
3899           if (TREE_CODE (t) != VAR_DECL || !DECL_THREAD_LOCAL_P (t))
3900             {
3901               error ("%qE must be %<threadprivate%> for %<copyin%>", t);
3902               remove = true;
3903             }
3904           break;
3905
3906         default:
3907           break;
3908         }
3909
3910       if (need_complete_non_reference)
3911         {
3912           t = require_complete_type (t);
3913           if (t == error_mark_node)
3914             remove = true;
3915           else if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
3916             {
3917               error ("%qE has reference type for %qs", t, name);
3918               remove = true;
3919             }
3920         }
3921       if (need_implicitly_determined)
3922         {
3923           const char *share_name = NULL;
3924
3925           if (TREE_CODE (t) == VAR_DECL && DECL_THREAD_LOCAL_P (t))
3926             share_name = "threadprivate";
3927           else switch (cxx_omp_predetermined_sharing (t))
3928             {
3929             case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
3930               break;
3931             case OMP_CLAUSE_DEFAULT_SHARED:
3932               share_name = "shared";
3933               break;
3934             case OMP_CLAUSE_DEFAULT_PRIVATE:
3935               share_name = "private";
3936               break;
3937             default:
3938               gcc_unreachable ();
3939             }
3940           if (share_name)
3941             {
3942               error ("%qE is predetermined %qs for %qs",
3943                      t, share_name, name);
3944               remove = true;
3945             }
3946         }
3947
3948       /* We're interested in the base element, not arrays.  */
3949       inner_type = type = TREE_TYPE (t);
3950       while (TREE_CODE (inner_type) == ARRAY_TYPE)
3951         inner_type = TREE_TYPE (inner_type);
3952
3953       /* Check for special function availability by building a call to one.
3954          Save the results, because later we won't be in the right context
3955          for making these queries.  */
3956       if (CLASS_TYPE_P (inner_type)
3957           && (need_default_ctor || need_copy_ctor || need_copy_assignment)
3958           && !type_dependent_expression_p (t)
3959           && cxx_omp_create_clause_info (c, inner_type, need_default_ctor,
3960                                          need_copy_ctor, need_copy_assignment))
3961         remove = true;
3962
3963       if (remove)
3964         *pc = OMP_CLAUSE_CHAIN (c);
3965       else
3966         pc = &OMP_CLAUSE_CHAIN (c);
3967     }
3968
3969   bitmap_obstack_release (NULL);
3970   return clauses;
3971 }
3972
3973 /* For all variables in the tree_list VARS, mark them as thread local.  */
3974
3975 void
3976 finish_omp_threadprivate (tree vars)
3977 {
3978   tree t;
3979
3980   /* Mark every variable in VARS to be assigned thread local storage.  */
3981   for (t = vars; t; t = TREE_CHAIN (t))
3982     {
3983       tree v = TREE_PURPOSE (t);
3984
3985       if (error_operand_p (v))
3986         ;
3987       else if (TREE_CODE (v) != VAR_DECL)
3988         error ("%<threadprivate%> %qD is not file, namespace "
3989                "or block scope variable", v);
3990       /* If V had already been marked threadprivate, it doesn't matter
3991          whether it had been used prior to this point.  */
3992       else if (TREE_USED (v)
3993           && (DECL_LANG_SPECIFIC (v) == NULL
3994               || !CP_DECL_THREADPRIVATE_P (v)))
3995         error ("%qE declared %<threadprivate%> after first use", v);
3996       else if (! TREE_STATIC (v) && ! DECL_EXTERNAL (v))
3997         error ("automatic variable %qE cannot be %<threadprivate%>", v);
3998       else if (! COMPLETE_TYPE_P (TREE_TYPE (v)))
3999         error ("%<threadprivate%> %qE has incomplete type", v);
4000       else if (TREE_STATIC (v) && TYPE_P (CP_DECL_CONTEXT (v))
4001                && CP_DECL_CONTEXT (v) != current_class_type)
4002         error ("%<threadprivate%> %qE directive not "
4003                "in %qT definition", v, CP_DECL_CONTEXT (v));
4004       else
4005         {
4006           /* Allocate a LANG_SPECIFIC structure for V, if needed.  */
4007           if (DECL_LANG_SPECIFIC (v) == NULL)
4008             {
4009               retrofit_lang_decl (v);
4010
4011               /* Make sure that DECL_DISCRIMINATOR_P continues to be true
4012                  after the allocation of the lang_decl structure.  */
4013               if (DECL_DISCRIMINATOR_P (v))
4014                 DECL_LANG_SPECIFIC (v)->u.base.u2sel = 1;
4015             }
4016
4017           if (! DECL_THREAD_LOCAL_P (v))
4018             {
4019               DECL_TLS_MODEL (v) = decl_default_tls_model (v);
4020               /* If rtl has been already set for this var, call
4021                  make_decl_rtl once again, so that encode_section_info
4022                  has a chance to look at the new decl flags.  */
4023               if (DECL_RTL_SET_P (v))
4024                 make_decl_rtl (v);
4025             }
4026           CP_DECL_THREADPRIVATE_P (v) = 1;
4027         }
4028     }
4029 }
4030
4031 /* Build an OpenMP structured block.  */
4032
4033 tree
4034 begin_omp_structured_block (void)
4035 {
4036   return do_pushlevel (sk_omp);
4037 }
4038
4039 tree
4040 finish_omp_structured_block (tree block)
4041 {
4042   return do_poplevel (block);
4043 }
4044
4045 /* Similarly, except force the retention of the BLOCK.  */
4046
4047 tree
4048 begin_omp_parallel (void)
4049 {
4050   keep_next_level (true);
4051   return begin_omp_structured_block ();
4052 }
4053
4054 tree
4055 finish_omp_parallel (tree clauses, tree body)
4056 {
4057   tree stmt;
4058
4059   body = finish_omp_structured_block (body);
4060
4061   stmt = make_node (OMP_PARALLEL);
4062   TREE_TYPE (stmt) = void_type_node;
4063   OMP_PARALLEL_CLAUSES (stmt) = clauses;
4064   OMP_PARALLEL_BODY (stmt) = body;
4065
4066   return add_stmt (stmt);
4067 }
4068
4069 tree
4070 begin_omp_task (void)
4071 {
4072   keep_next_level (true);
4073   return begin_omp_structured_block ();
4074 }
4075
4076 tree
4077 finish_omp_task (tree clauses, tree body)
4078 {
4079   tree stmt;
4080
4081   body = finish_omp_structured_block (body);
4082
4083   stmt = make_node (OMP_TASK);
4084   TREE_TYPE (stmt) = void_type_node;
4085   OMP_TASK_CLAUSES (stmt) = clauses;
4086   OMP_TASK_BODY (stmt) = body;
4087
4088   return add_stmt (stmt);
4089 }
4090
4091 /* Helper function for finish_omp_for.  Convert Ith random access iterator
4092    into integral iterator.  Return FALSE if successful.  */
4093
4094 static bool
4095 handle_omp_for_class_iterator (int i, location_t locus, tree declv, tree initv,
4096                                tree condv, tree incrv, tree *body,
4097                                tree *pre_body, tree clauses)
4098 {
4099   tree diff, iter_init, iter_incr = NULL, last;
4100   tree incr_var = NULL, orig_pre_body, orig_body, c;
4101   tree decl = TREE_VEC_ELT (declv, i);
4102   tree init = TREE_VEC_ELT (initv, i);
4103   tree cond = TREE_VEC_ELT (condv, i);
4104   tree incr = TREE_VEC_ELT (incrv, i);
4105   tree iter = decl;
4106   location_t elocus = locus;
4107
4108   if (init && EXPR_HAS_LOCATION (init))
4109     elocus = EXPR_LOCATION (init);
4110
4111   switch (TREE_CODE (cond))
4112     {
4113     case GT_EXPR:
4114     case GE_EXPR:
4115     case LT_EXPR:
4116     case LE_EXPR:
4117       if (TREE_OPERAND (cond, 1) == iter)
4118         cond = build2 (swap_tree_comparison (TREE_CODE (cond)),
4119                        TREE_TYPE (cond), iter, TREE_OPERAND (cond, 0));
4120       if (TREE_OPERAND (cond, 0) != iter)
4121         cond = error_mark_node;
4122       else
4123         {
4124           tree tem = build_x_binary_op (TREE_CODE (cond), iter, ERROR_MARK,
4125                                         TREE_OPERAND (cond, 1), ERROR_MARK,
4126                                         NULL, tf_warning_or_error);
4127           if (error_operand_p (tem))
4128             return true;
4129         }
4130       break;
4131     default:
4132       cond = error_mark_node;
4133       break;
4134     }
4135   if (cond == error_mark_node)
4136     {
4137       error_at (elocus, "invalid controlling predicate");
4138       return true;
4139     }
4140   diff = build_x_binary_op (MINUS_EXPR, TREE_OPERAND (cond, 1),
4141                             ERROR_MARK, iter, ERROR_MARK, NULL,
4142                             tf_warning_or_error);
4143   if (error_operand_p (diff))
4144     return true;
4145   if (TREE_CODE (TREE_TYPE (diff)) != INTEGER_TYPE)