OSDN Git Service

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