OSDN Git Service

fb4ea0a79dfa5efe928ad41083026c1bfa9d1339
[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 has not 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         error ("invalid use of type %qT as a default value for a template "
2147                "template-parameter", TREE_TYPE (argument));
2148       else
2149         error ("invalid default argument for a template template parameter");
2150       return error_mark_node;
2151     }
2152
2153   return argument;
2154 }
2155
2156 /* Begin a class definition, as indicated by T.  */
2157
2158 tree
2159 begin_class_definition (tree t, tree attributes)
2160 {
2161   if (t == error_mark_node)
2162     return error_mark_node;
2163
2164   if (processing_template_parmlist)
2165     {
2166       error ("definition of %q#T inside template parameter list", t);
2167       return error_mark_node;
2168     }
2169   /* A non-implicit typename comes from code like:
2170
2171        template <typename T> struct A {
2172          template <typename U> struct A<T>::B ...
2173
2174      This is erroneous.  */
2175   else if (TREE_CODE (t) == TYPENAME_TYPE)
2176     {
2177       error ("invalid definition of qualified type %qT", t);
2178       t = error_mark_node;
2179     }
2180
2181   if (t == error_mark_node || ! IS_AGGR_TYPE (t))
2182     {
2183       t = make_aggr_type (RECORD_TYPE);
2184       pushtag (make_anon_name (), t, /*tag_scope=*/ts_current);
2185     }
2186
2187   /* Update the location of the decl.  */
2188   DECL_SOURCE_LOCATION (TYPE_NAME (t)) = input_location;
2189
2190   if (TYPE_BEING_DEFINED (t))
2191     {
2192       t = make_aggr_type (TREE_CODE (t));
2193       pushtag (TYPE_IDENTIFIER (t), t, /*tag_scope=*/ts_current);
2194     }
2195   maybe_process_partial_specialization (t);
2196   pushclass (t);
2197   TYPE_BEING_DEFINED (t) = 1;
2198
2199   cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
2200
2201   if (flag_pack_struct)
2202     {
2203       tree v;
2204       TYPE_PACKED (t) = 1;
2205       /* Even though the type is being defined for the first time
2206          here, there might have been a forward declaration, so there
2207          might be cv-qualified variants of T.  */
2208       for (v = TYPE_NEXT_VARIANT (t); v; v = TYPE_NEXT_VARIANT (v))
2209         TYPE_PACKED (v) = 1;
2210     }
2211   /* Reset the interface data, at the earliest possible
2212      moment, as it might have been set via a class foo;
2213      before.  */
2214   if (! TYPE_ANONYMOUS_P (t))
2215     {
2216       struct c_fileinfo *finfo = get_fileinfo (lbasename (input_filename));
2217       CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
2218       SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2219         (t, finfo->interface_unknown);
2220     }
2221   reset_specialization();
2222
2223   /* Make a declaration for this class in its own scope.  */
2224   build_self_reference ();
2225
2226   return t;
2227 }
2228
2229 /* Finish the member declaration given by DECL.  */
2230
2231 void
2232 finish_member_declaration (tree decl)
2233 {
2234   if (decl == error_mark_node || decl == NULL_TREE)
2235     return;
2236
2237   if (decl == void_type_node)
2238     /* The COMPONENT was a friend, not a member, and so there's
2239        nothing for us to do.  */
2240     return;
2241
2242   /* We should see only one DECL at a time.  */
2243   gcc_assert (TREE_CHAIN (decl) == NULL_TREE);
2244
2245   /* Set up access control for DECL.  */
2246   TREE_PRIVATE (decl)
2247     = (current_access_specifier == access_private_node);
2248   TREE_PROTECTED (decl)
2249     = (current_access_specifier == access_protected_node);
2250   if (TREE_CODE (decl) == TEMPLATE_DECL)
2251     {
2252       TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl)) = TREE_PRIVATE (decl);
2253       TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl)) = TREE_PROTECTED (decl);
2254     }
2255
2256   /* Mark the DECL as a member of the current class.  */
2257   DECL_CONTEXT (decl) = current_class_type;
2258
2259   /* [dcl.link]
2260
2261      A C language linkage is ignored for the names of class members
2262      and the member function type of class member functions.  */
2263   if (DECL_LANG_SPECIFIC (decl) && DECL_LANGUAGE (decl) == lang_c)
2264     SET_DECL_LANGUAGE (decl, lang_cplusplus);
2265
2266   /* Put functions on the TYPE_METHODS list and everything else on the
2267      TYPE_FIELDS list.  Note that these are built up in reverse order.
2268      We reverse them (to obtain declaration order) in finish_struct.  */
2269   if (TREE_CODE (decl) == FUNCTION_DECL
2270       || DECL_FUNCTION_TEMPLATE_P (decl))
2271     {
2272       /* We also need to add this function to the
2273          CLASSTYPE_METHOD_VEC.  */
2274       if (add_method (current_class_type, decl, NULL_TREE))
2275         {
2276           TREE_CHAIN (decl) = TYPE_METHODS (current_class_type);
2277           TYPE_METHODS (current_class_type) = decl;
2278
2279           maybe_add_class_template_decl_list (current_class_type, decl,
2280                                               /*friend_p=*/0);
2281         }
2282     }
2283   /* Enter the DECL into the scope of the class.  */
2284   else if ((TREE_CODE (decl) == USING_DECL && !DECL_DEPENDENT_P (decl))
2285            || pushdecl_class_level (decl))
2286     {
2287       /* All TYPE_DECLs go at the end of TYPE_FIELDS.  Ordinary fields
2288          go at the beginning.  The reason is that lookup_field_1
2289          searches the list in order, and we want a field name to
2290          override a type name so that the "struct stat hack" will
2291          work.  In particular:
2292
2293            struct S { enum E { }; int E } s;
2294            s.E = 3;
2295
2296          is valid.  In addition, the FIELD_DECLs must be maintained in
2297          declaration order so that class layout works as expected.
2298          However, we don't need that order until class layout, so we
2299          save a little time by putting FIELD_DECLs on in reverse order
2300          here, and then reversing them in finish_struct_1.  (We could
2301          also keep a pointer to the correct insertion points in the
2302          list.)  */
2303
2304       if (TREE_CODE (decl) == TYPE_DECL)
2305         TYPE_FIELDS (current_class_type)
2306           = chainon (TYPE_FIELDS (current_class_type), decl);
2307       else
2308         {
2309           TREE_CHAIN (decl) = TYPE_FIELDS (current_class_type);
2310           TYPE_FIELDS (current_class_type) = decl;
2311         }
2312
2313       maybe_add_class_template_decl_list (current_class_type, decl,
2314                                           /*friend_p=*/0);
2315     }
2316
2317   if (pch_file)
2318     note_decl_for_pch (decl);
2319 }
2320
2321 /* DECL has been declared while we are building a PCH file.  Perform
2322    actions that we might normally undertake lazily, but which can be
2323    performed now so that they do not have to be performed in
2324    translation units which include the PCH file.  */
2325
2326 void
2327 note_decl_for_pch (tree decl)
2328 {
2329   gcc_assert (pch_file);
2330
2331   /* There's a good chance that we'll have to mangle names at some
2332      point, even if only for emission in debugging information.  */
2333   if ((TREE_CODE (decl) == VAR_DECL
2334        || TREE_CODE (decl) == FUNCTION_DECL)
2335       && !processing_template_decl)
2336     mangle_decl (decl);
2337 }
2338
2339 /* Finish processing a complete template declaration.  The PARMS are
2340    the template parameters.  */
2341
2342 void
2343 finish_template_decl (tree parms)
2344 {
2345   if (parms)
2346     end_template_decl ();
2347   else
2348     end_specialization ();
2349 }
2350
2351 /* Finish processing a template-id (which names a type) of the form
2352    NAME < ARGS >.  Return the TYPE_DECL for the type named by the
2353    template-id.  If ENTERING_SCOPE is nonzero we are about to enter
2354    the scope of template-id indicated.  */
2355
2356 tree
2357 finish_template_type (tree name, tree args, int entering_scope)
2358 {
2359   tree decl;
2360
2361   decl = lookup_template_class (name, args,
2362                                 NULL_TREE, NULL_TREE, entering_scope,
2363                                 tf_warning_or_error | tf_user);
2364   if (decl != error_mark_node)
2365     decl = TYPE_STUB_DECL (decl);
2366
2367   return decl;
2368 }
2369
2370 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
2371    Return a TREE_LIST containing the ACCESS_SPECIFIER and the
2372    BASE_CLASS, or NULL_TREE if an error occurred.  The
2373    ACCESS_SPECIFIER is one of
2374    access_{default,public,protected_private}_node.  For a virtual base
2375    we set TREE_TYPE.  */
2376
2377 tree
2378 finish_base_specifier (tree base, tree access, bool virtual_p)
2379 {
2380   tree result;
2381
2382   if (base == error_mark_node)
2383     {
2384       error ("invalid base-class specification");
2385       result = NULL_TREE;
2386     }
2387   else if (! is_aggr_type (base, 1))
2388     result = NULL_TREE;
2389   else
2390     {
2391       if (cp_type_quals (base) != 0)
2392         {
2393           error ("base class %qT has cv qualifiers", base);
2394           base = TYPE_MAIN_VARIANT (base);
2395         }
2396       result = build_tree_list (access, base);
2397       if (virtual_p)
2398         TREE_TYPE (result) = integer_type_node;
2399     }
2400
2401   return result;
2402 }
2403
2404 /* Issue a diagnostic that NAME cannot be found in SCOPE.  DECL is
2405    what we found when we tried to do the lookup.  */
2406
2407 void
2408 qualified_name_lookup_error (tree scope, tree name, tree decl)
2409 {
2410   if (scope == error_mark_node)
2411     ; /* We already complained.  */
2412   else if (TYPE_P (scope))
2413     {
2414       if (!COMPLETE_TYPE_P (scope))
2415         error ("incomplete type %qT used in nested name specifier", scope);
2416       else if (TREE_CODE (decl) == TREE_LIST)
2417         {
2418           error ("reference to %<%T::%D%> is ambiguous", scope, name);
2419           print_candidates (decl);
2420         }
2421       else
2422         error ("%qD is not a member of %qT", name, scope);
2423     }
2424   else if (scope != global_namespace)
2425     error ("%qD is not a member of %qD", name, scope);
2426   else
2427     error ("%<::%D%> has not been declared", name);
2428 }
2429
2430 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
2431    id-expression.  (See cp_parser_id_expression for details.)  SCOPE,
2432    if non-NULL, is the type or namespace used to explicitly qualify
2433    ID_EXPRESSION.  DECL is the entity to which that name has been
2434    resolved.
2435
2436    *CONSTANT_EXPRESSION_P is true if we are presently parsing a
2437    constant-expression.  In that case, *NON_CONSTANT_EXPRESSION_P will
2438    be set to true if this expression isn't permitted in a
2439    constant-expression, but it is otherwise not set by this function.
2440    *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
2441    constant-expression, but a non-constant expression is also
2442    permissible.
2443
2444    DONE is true if this expression is a complete postfix-expression;
2445    it is false if this expression is followed by '->', '[', '(', etc.
2446    ADDRESS_P is true iff this expression is the operand of '&'.
2447    TEMPLATE_P is true iff the qualified-id was of the form
2448    "A::template B".  TEMPLATE_ARG_P is true iff this qualified name
2449    appears as a template argument.
2450
2451    If an error occurs, and it is the kind of error that might cause
2452    the parser to abort a tentative parse, *ERROR_MSG is filled in.  It
2453    is the caller's responsibility to issue the message.  *ERROR_MSG
2454    will be a string with static storage duration, so the caller need
2455    not "free" it.
2456
2457    Return an expression for the entity, after issuing appropriate
2458    diagnostics.  This function is also responsible for transforming a
2459    reference to a non-static member into a COMPONENT_REF that makes
2460    the use of "this" explicit.
2461
2462    Upon return, *IDK will be filled in appropriately.  */
2463
2464 tree
2465 finish_id_expression (tree id_expression,
2466                       tree decl,
2467                       tree scope,
2468                       cp_id_kind *idk,
2469                       bool integral_constant_expression_p,
2470                       bool allow_non_integral_constant_expression_p,
2471                       bool *non_integral_constant_expression_p,
2472                       bool template_p,
2473                       bool done,
2474                       bool address_p,
2475                       bool template_arg_p,
2476                       const char **error_msg)
2477 {
2478   /* Initialize the output parameters.  */
2479   *idk = CP_ID_KIND_NONE;
2480   *error_msg = NULL;
2481
2482   if (id_expression == error_mark_node)
2483     return error_mark_node;
2484   /* If we have a template-id, then no further lookup is
2485      required.  If the template-id was for a template-class, we
2486      will sometimes have a TYPE_DECL at this point.  */
2487   else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2488            || TREE_CODE (decl) == TYPE_DECL)
2489     ;
2490   /* Look up the name.  */
2491   else
2492     {
2493       if (decl == error_mark_node)
2494         {
2495           /* Name lookup failed.  */
2496           if (scope
2497               && (!TYPE_P (scope)
2498                   || (!dependent_type_p (scope)
2499                       && !(TREE_CODE (id_expression) == IDENTIFIER_NODE
2500                            && IDENTIFIER_TYPENAME_P (id_expression)
2501                            && dependent_type_p (TREE_TYPE (id_expression))))))
2502             {
2503               /* If the qualifying type is non-dependent (and the name
2504                  does not name a conversion operator to a dependent
2505                  type), issue an error.  */
2506               qualified_name_lookup_error (scope, id_expression, decl);
2507               return error_mark_node;
2508             }
2509           else if (!scope)
2510             {
2511               /* It may be resolved via Koenig lookup.  */
2512               *idk = CP_ID_KIND_UNQUALIFIED;
2513               return id_expression;
2514             }
2515           else
2516             decl = id_expression;
2517         }
2518       /* If DECL is a variable that would be out of scope under
2519          ANSI/ISO rules, but in scope in the ARM, name lookup
2520          will succeed.  Issue a diagnostic here.  */
2521       else
2522         decl = check_for_out_of_scope_variable (decl);
2523
2524       /* Remember that the name was used in the definition of
2525          the current class so that we can check later to see if
2526          the meaning would have been different after the class
2527          was entirely defined.  */
2528       if (!scope && decl != error_mark_node)
2529         maybe_note_name_used_in_class (id_expression, decl);
2530
2531       /* Disallow uses of local variables from containing functions.  */
2532       if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
2533         {
2534           tree context = decl_function_context (decl);
2535           if (context != NULL_TREE && context != current_function_decl
2536               && ! TREE_STATIC (decl))
2537             {
2538               error (TREE_CODE (decl) == VAR_DECL
2539                      ? "use of %<auto%> variable from containing function"
2540                      : "use of parameter from containing function");
2541               error ("  %q+#D declared here", decl);
2542               return error_mark_node;
2543             }
2544         }
2545     }
2546
2547   /* If we didn't find anything, or what we found was a type,
2548      then this wasn't really an id-expression.  */
2549   if (TREE_CODE (decl) == TEMPLATE_DECL
2550       && !DECL_FUNCTION_TEMPLATE_P (decl))
2551     {
2552       *error_msg = "missing template arguments";
2553       return error_mark_node;
2554     }
2555   else if (TREE_CODE (decl) == TYPE_DECL
2556            || TREE_CODE (decl) == NAMESPACE_DECL)
2557     {
2558       *error_msg = "expected primary-expression";
2559       return error_mark_node;
2560     }
2561
2562   /* If the name resolved to a template parameter, there is no
2563      need to look it up again later.  */
2564   if ((TREE_CODE (decl) == CONST_DECL && DECL_TEMPLATE_PARM_P (decl))
2565       || TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
2566     {
2567       tree r;
2568
2569       *idk = CP_ID_KIND_NONE;
2570       if (TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
2571         decl = TEMPLATE_PARM_DECL (decl);
2572       r = convert_from_reference (DECL_INITIAL (decl));
2573
2574       if (integral_constant_expression_p
2575           && !dependent_type_p (TREE_TYPE (decl))
2576           && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r))))
2577         {
2578           if (!allow_non_integral_constant_expression_p)
2579             error ("template parameter %qD of type %qT is not allowed in "
2580                    "an integral constant expression because it is not of "
2581                    "integral or enumeration type", decl, TREE_TYPE (decl));
2582           *non_integral_constant_expression_p = true;
2583         }
2584       return r;
2585     }
2586   /* Similarly, we resolve enumeration constants to their
2587      underlying values.  */
2588   else if (TREE_CODE (decl) == CONST_DECL)
2589     {
2590       *idk = CP_ID_KIND_NONE;
2591       if (!processing_template_decl)
2592         {
2593           used_types_insert (TREE_TYPE (decl));
2594           return DECL_INITIAL (decl);
2595         }
2596       return decl;
2597     }
2598   else
2599     {
2600       bool dependent_p;
2601
2602       /* If the declaration was explicitly qualified indicate
2603          that.  The semantics of `A::f(3)' are different than
2604          `f(3)' if `f' is virtual.  */
2605       *idk = (scope
2606               ? CP_ID_KIND_QUALIFIED
2607               : (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2608                  ? CP_ID_KIND_TEMPLATE_ID
2609                  : CP_ID_KIND_UNQUALIFIED));
2610
2611
2612       /* [temp.dep.expr]
2613
2614          An id-expression is type-dependent if it contains an
2615          identifier that was declared with a dependent type.
2616
2617          The standard is not very specific about an id-expression that
2618          names a set of overloaded functions.  What if some of them
2619          have dependent types and some of them do not?  Presumably,
2620          such a name should be treated as a dependent name.  */
2621       /* Assume the name is not dependent.  */
2622       dependent_p = false;
2623       if (!processing_template_decl)
2624         /* No names are dependent outside a template.  */
2625         ;
2626       /* A template-id where the name of the template was not resolved
2627          is definitely dependent.  */
2628       else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2629                && (TREE_CODE (TREE_OPERAND (decl, 0))
2630                    == IDENTIFIER_NODE))
2631         dependent_p = true;
2632       /* For anything except an overloaded function, just check its
2633          type.  */
2634       else if (!is_overloaded_fn (decl))
2635         dependent_p
2636           = dependent_type_p (TREE_TYPE (decl));
2637       /* For a set of overloaded functions, check each of the
2638          functions.  */
2639       else
2640         {
2641           tree fns = decl;
2642
2643           if (BASELINK_P (fns))
2644             fns = BASELINK_FUNCTIONS (fns);
2645
2646           /* For a template-id, check to see if the template
2647              arguments are dependent.  */
2648           if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
2649             {
2650               tree args = TREE_OPERAND (fns, 1);
2651               dependent_p = any_dependent_template_arguments_p (args);
2652               /* The functions are those referred to by the
2653                  template-id.  */
2654               fns = TREE_OPERAND (fns, 0);
2655             }
2656
2657           /* If there are no dependent template arguments, go through
2658              the overloaded functions.  */
2659           while (fns && !dependent_p)
2660             {
2661               tree fn = OVL_CURRENT (fns);
2662
2663               /* Member functions of dependent classes are
2664                  dependent.  */
2665               if (TREE_CODE (fn) == FUNCTION_DECL
2666                   && type_dependent_expression_p (fn))
2667                 dependent_p = true;
2668               else if (TREE_CODE (fn) == TEMPLATE_DECL
2669                        && dependent_template_p (fn))
2670                 dependent_p = true;
2671
2672               fns = OVL_NEXT (fns);
2673             }
2674         }
2675
2676       /* If the name was dependent on a template parameter, we will
2677          resolve the name at instantiation time.  */
2678       if (dependent_p)
2679         {
2680           /* Create a SCOPE_REF for qualified names, if the scope is
2681              dependent.  */
2682           if (scope)
2683             {
2684               /* Since this name was dependent, the expression isn't
2685                  constant -- yet.  No error is issued because it might
2686                  be constant when things are instantiated.  */
2687               if (integral_constant_expression_p)
2688                 *non_integral_constant_expression_p = true;
2689               if (TYPE_P (scope))
2690                 {
2691                   if (address_p && done)
2692                     decl = finish_qualified_id_expr (scope, decl,
2693                                                      done, address_p,
2694                                                      template_p,
2695                                                      template_arg_p);
2696                   else if (dependent_type_p (scope))
2697                     decl = build_qualified_name (/*type=*/NULL_TREE,
2698                                                  scope,
2699                                                  id_expression,
2700                                                  template_p);
2701                   else if (DECL_P (decl))
2702                     decl = build_qualified_name (TREE_TYPE (decl),
2703                                                  scope,
2704                                                  id_expression,
2705                                                  template_p);
2706                 }
2707               if (TREE_TYPE (decl))
2708                 decl = convert_from_reference (decl);
2709               return decl;
2710             }
2711           /* A TEMPLATE_ID already contains all the information we
2712              need.  */
2713           if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR)
2714             return id_expression;
2715           *idk = CP_ID_KIND_UNQUALIFIED_DEPENDENT;
2716           /* If we found a variable, then name lookup during the
2717              instantiation will always resolve to the same VAR_DECL
2718              (or an instantiation thereof).  */
2719           if (TREE_CODE (decl) == VAR_DECL
2720               || TREE_CODE (decl) == PARM_DECL)
2721             return convert_from_reference (decl);
2722           /* The same is true for FIELD_DECL, but we also need to
2723              make sure that the syntax is correct.  */
2724           else if (TREE_CODE (decl) == FIELD_DECL)
2725             {
2726               /* Since SCOPE is NULL here, this is an unqualified name.
2727                  Access checking has been performed during name lookup
2728                  already.  Turn off checking to avoid duplicate errors.  */
2729               push_deferring_access_checks (dk_no_check);
2730               decl = finish_non_static_data_member
2731                        (decl, current_class_ref,
2732                         /*qualifying_scope=*/NULL_TREE);
2733               pop_deferring_access_checks ();
2734               return decl;
2735             }
2736           return id_expression;
2737         }
2738
2739       /* Only certain kinds of names are allowed in constant
2740          expression.  Enumerators and template parameters have already
2741          been handled above.  */
2742       if (integral_constant_expression_p
2743           && ! DECL_INTEGRAL_CONSTANT_VAR_P (decl)
2744           && ! builtin_valid_in_constant_expr_p (decl))
2745         {
2746           if (!allow_non_integral_constant_expression_p)
2747             {
2748               error ("%qD cannot appear in a constant-expression", decl);
2749               return error_mark_node;
2750             }
2751           *non_integral_constant_expression_p = true;
2752         }
2753
2754       if (TREE_CODE (decl) == NAMESPACE_DECL)
2755         {
2756           error ("use of namespace %qD as expression", decl);
2757           return error_mark_node;
2758         }
2759       else if (DECL_CLASS_TEMPLATE_P (decl))
2760         {
2761           error ("use of class template %qT as expression", decl);
2762           return error_mark_node;
2763         }
2764       else if (TREE_CODE (decl) == TREE_LIST)
2765         {
2766           /* Ambiguous reference to base members.  */
2767           error ("request for member %qD is ambiguous in "
2768                  "multiple inheritance lattice", id_expression);
2769           print_candidates (decl);
2770           return error_mark_node;
2771         }
2772
2773       /* Mark variable-like entities as used.  Functions are similarly
2774          marked either below or after overload resolution.  */
2775       if (TREE_CODE (decl) == VAR_DECL
2776           || TREE_CODE (decl) == PARM_DECL
2777           || TREE_CODE (decl) == RESULT_DECL)
2778         mark_used (decl);
2779
2780       if (scope)
2781         {
2782           decl = (adjust_result_of_qualified_name_lookup
2783                   (decl, scope, current_class_type));
2784
2785           if (TREE_CODE (decl) == FUNCTION_DECL)
2786             mark_used (decl);
2787
2788           if (TREE_CODE (decl) == FIELD_DECL || BASELINK_P (decl))
2789             decl = finish_qualified_id_expr (scope,
2790                                              decl,
2791                                              done,
2792                                              address_p,
2793                                              template_p,
2794                                              template_arg_p);
2795           else
2796             {
2797               tree r = convert_from_reference (decl);
2798
2799               if (processing_template_decl && TYPE_P (scope))
2800                 r = build_qualified_name (TREE_TYPE (r),
2801                                           scope, decl,
2802                                           template_p);
2803               decl = r;
2804             }
2805         }
2806       else if (TREE_CODE (decl) == FIELD_DECL)
2807         {
2808           /* Since SCOPE is NULL here, this is an unqualified name.
2809              Access checking has been performed during name lookup
2810              already.  Turn off checking to avoid duplicate errors.  */
2811           push_deferring_access_checks (dk_no_check);
2812           decl = finish_non_static_data_member (decl, current_class_ref,
2813                                                 /*qualifying_scope=*/NULL_TREE);
2814           pop_deferring_access_checks ();
2815         }
2816       else if (is_overloaded_fn (decl))
2817         {
2818           tree first_fn = OVL_CURRENT (decl);
2819
2820           if (TREE_CODE (first_fn) == TEMPLATE_DECL)
2821             first_fn = DECL_TEMPLATE_RESULT (first_fn);
2822
2823           if (!really_overloaded_fn (decl))
2824             mark_used (first_fn);
2825
2826           if (!template_arg_p
2827               && TREE_CODE (first_fn) == FUNCTION_DECL
2828               && DECL_FUNCTION_MEMBER_P (first_fn)
2829               && !shared_member_p (decl))
2830             {
2831               /* A set of member functions.  */
2832               decl = maybe_dummy_object (DECL_CONTEXT (first_fn), 0);
2833               return finish_class_member_access_expr (decl, id_expression,
2834                                                       /*template_p=*/false);
2835             }
2836         }
2837       else
2838         {
2839           if (DECL_P (decl) && DECL_NONLOCAL (decl)
2840               && DECL_CLASS_SCOPE_P (decl)
2841               && DECL_CONTEXT (decl) != current_class_type)
2842             {
2843               tree path;
2844
2845               path = currently_open_derived_class (DECL_CONTEXT (decl));
2846               perform_or_defer_access_check (TYPE_BINFO (path), decl);
2847             }
2848
2849           decl = convert_from_reference (decl);
2850         }
2851     }
2852
2853   if (TREE_DEPRECATED (decl))
2854     warn_deprecated_use (decl);
2855
2856   return decl;
2857 }
2858
2859 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
2860    use as a type-specifier.  */
2861
2862 tree
2863 finish_typeof (tree expr)
2864 {
2865   tree type;
2866
2867   if (type_dependent_expression_p (expr))
2868     {
2869       type = make_aggr_type (TYPEOF_TYPE);
2870       TYPEOF_TYPE_EXPR (type) = expr;
2871
2872       return type;
2873     }
2874
2875   type = TREE_TYPE (expr);
2876
2877   if (!type || type == unknown_type_node)
2878     {
2879       error ("type of %qE is unknown", expr);
2880       return error_mark_node;
2881     }
2882
2883   return type;
2884 }
2885
2886 /* Perform C++-specific checks for __builtin_offsetof before calling
2887    fold_offsetof.  */
2888
2889 tree
2890 finish_offsetof (tree expr)
2891 {
2892   if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
2893     {
2894       error ("cannot apply %<offsetof%> to destructor %<~%T%>",
2895               TREE_OPERAND (expr, 2));
2896       return error_mark_node;
2897     }
2898   if (TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE
2899       || TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE
2900       || TREE_CODE (TREE_TYPE (expr)) == UNKNOWN_TYPE)
2901     {
2902       if (TREE_CODE (expr) == COMPONENT_REF)
2903         expr = TREE_OPERAND (expr, 1);
2904       error ("cannot apply %<offsetof%> to member function %qD", expr);
2905       return error_mark_node;
2906     }
2907   return fold_offsetof (expr, NULL_TREE);
2908 }
2909
2910 /* Called from expand_body via walk_tree.  Replace all AGGR_INIT_EXPRs
2911    with equivalent CALL_EXPRs.  */
2912
2913 static tree
2914 simplify_aggr_init_exprs_r (tree* tp,
2915                             int* walk_subtrees,
2916                             void* data ATTRIBUTE_UNUSED)
2917 {
2918   /* We don't need to walk into types; there's nothing in a type that
2919      needs simplification.  (And, furthermore, there are places we
2920      actively don't want to go.  For example, we don't want to wander
2921      into the default arguments for a FUNCTION_DECL that appears in a
2922      CALL_EXPR.)  */
2923   if (TYPE_P (*tp))
2924     {
2925       *walk_subtrees = 0;
2926       return NULL_TREE;
2927     }
2928   /* Only AGGR_INIT_EXPRs are interesting.  */
2929   else if (TREE_CODE (*tp) != AGGR_INIT_EXPR)
2930     return NULL_TREE;
2931
2932   simplify_aggr_init_expr (tp);
2933
2934   /* Keep iterating.  */
2935   return NULL_TREE;
2936 }
2937
2938 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR.  This
2939    function is broken out from the above for the benefit of the tree-ssa
2940    project.  */
2941
2942 void
2943 simplify_aggr_init_expr (tree *tp)
2944 {
2945   tree aggr_init_expr = *tp;
2946
2947   /* Form an appropriate CALL_EXPR.  */
2948   tree fn = TREE_OPERAND (aggr_init_expr, 0);
2949   tree args = TREE_OPERAND (aggr_init_expr, 1);
2950   tree slot = TREE_OPERAND (aggr_init_expr, 2);
2951   tree type = TREE_TYPE (slot);
2952
2953   tree call_expr;
2954   enum style_t { ctor, arg, pcc } style;
2955
2956   if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr))
2957     style = ctor;
2958 #ifdef PCC_STATIC_STRUCT_RETURN
2959   else if (1)
2960     style = pcc;
2961 #endif
2962   else
2963     {
2964       gcc_assert (TREE_ADDRESSABLE (type));
2965       style = arg;
2966     }
2967
2968   if (style == ctor)
2969     {
2970       /* Replace the first argument to the ctor with the address of the
2971          slot.  */
2972       tree addr;
2973
2974       args = TREE_CHAIN (args);
2975       cxx_mark_addressable (slot);
2976       addr = build1 (ADDR_EXPR, build_pointer_type (type), slot);
2977       args = tree_cons (NULL_TREE, addr, args);
2978     }
2979
2980   call_expr = build3 (CALL_EXPR,
2981                       TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
2982                       fn, args, NULL_TREE);
2983
2984   if (style == arg)
2985     {
2986       /* Just mark it addressable here, and leave the rest to
2987          expand_call{,_inline}.  */
2988       cxx_mark_addressable (slot);
2989       CALL_EXPR_RETURN_SLOT_OPT (call_expr) = true;
2990       call_expr = build2 (MODIFY_EXPR, TREE_TYPE (call_expr), slot, call_expr);
2991     }
2992   else if (style == pcc)
2993     {
2994       /* If we're using the non-reentrant PCC calling convention, then we
2995          need to copy the returned value out of the static buffer into the
2996          SLOT.  */
2997       push_deferring_access_checks (dk_no_check);
2998       call_expr = build_aggr_init (slot, call_expr,
2999                                    DIRECT_BIND | LOOKUP_ONLYCONVERTING);
3000       pop_deferring_access_checks ();
3001       call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (slot), call_expr, slot);
3002     }
3003
3004   *tp = call_expr;
3005 }
3006
3007 /* Emit all thunks to FN that should be emitted when FN is emitted.  */
3008
3009 static void
3010 emit_associated_thunks (tree fn)
3011 {
3012   /* When we use vcall offsets, we emit thunks with the virtual
3013      functions to which they thunk. The whole point of vcall offsets
3014      is so that you can know statically the entire set of thunks that
3015      will ever be needed for a given virtual function, thereby
3016      enabling you to output all the thunks with the function itself.  */
3017   if (DECL_VIRTUAL_P (fn))
3018     {
3019       tree thunk;
3020
3021       for (thunk = DECL_THUNKS (fn); thunk; thunk = TREE_CHAIN (thunk))
3022         {
3023           if (!THUNK_ALIAS (thunk))
3024             {
3025               use_thunk (thunk, /*emit_p=*/1);
3026               if (DECL_RESULT_THUNK_P (thunk))
3027                 {
3028                   tree probe;
3029
3030                   for (probe = DECL_THUNKS (thunk);
3031                        probe; probe = TREE_CHAIN (probe))
3032                     use_thunk (probe, /*emit_p=*/1);
3033                 }
3034             }
3035           else
3036             gcc_assert (!DECL_THUNKS (thunk));
3037         }
3038     }
3039 }
3040
3041 /* Generate RTL for FN.  */
3042
3043 void
3044 expand_body (tree fn)
3045 {
3046   tree saved_function;
3047
3048   /* Compute the appropriate object-file linkage for inline
3049      functions.  */
3050   if (DECL_DECLARED_INLINE_P (fn))
3051     import_export_decl (fn);
3052
3053   /* If FN is external, then there's no point in generating RTL for
3054      it.  This situation can arise with an inline function under
3055      `-fexternal-templates'; we instantiate the function, even though
3056      we're not planning on emitting it, in case we get a chance to
3057      inline it.  */
3058   if (DECL_EXTERNAL (fn))
3059     return;
3060
3061   /* ??? When is this needed?  */
3062   saved_function = current_function_decl;
3063
3064   /* Emit any thunks that should be emitted at the same time as FN.  */
3065   emit_associated_thunks (fn);
3066
3067   /* This function is only called from cgraph, or recursively from
3068      emit_associated_thunks.  In neither case should we be currently
3069      generating trees for a function.  */
3070   gcc_assert (function_depth == 0);
3071
3072   tree_rest_of_compilation (fn);
3073
3074   current_function_decl = saved_function;
3075
3076   if (DECL_CLONED_FUNCTION_P (fn))
3077     {
3078       /* If this is a clone, go through the other clones now and mark
3079          their parameters used.  We have to do that here, as we don't
3080          know whether any particular clone will be expanded, and
3081          therefore cannot pick one arbitrarily.  */
3082       tree probe;
3083
3084       for (probe = TREE_CHAIN (DECL_CLONED_FUNCTION (fn));
3085            probe && DECL_CLONED_FUNCTION_P (probe);
3086            probe = TREE_CHAIN (probe))
3087         {
3088           tree parms;
3089
3090           for (parms = DECL_ARGUMENTS (probe);
3091                parms; parms = TREE_CHAIN (parms))
3092             TREE_USED (parms) = 1;
3093         }
3094     }
3095 }
3096
3097 /* Generate RTL for FN.  */
3098
3099 void
3100 expand_or_defer_fn (tree fn)
3101 {
3102   /* When the parser calls us after finishing the body of a template
3103      function, we don't really want to expand the body.  */
3104   if (processing_template_decl)
3105     {
3106       /* Normally, collection only occurs in rest_of_compilation.  So,
3107          if we don't collect here, we never collect junk generated
3108          during the processing of templates until we hit a
3109          non-template function.  It's not safe to do this inside a
3110          nested class, though, as the parser may have local state that
3111          is not a GC root.  */
3112       if (!function_depth)
3113         ggc_collect ();
3114       return;
3115     }
3116
3117   /* Replace AGGR_INIT_EXPRs with appropriate CALL_EXPRs.  */
3118   walk_tree_without_duplicates (&DECL_SAVED_TREE (fn),
3119                                 simplify_aggr_init_exprs_r,
3120                                 NULL);
3121
3122   /* If this is a constructor or destructor body, we have to clone
3123      it.  */
3124   if (maybe_clone_body (fn))
3125     {
3126       /* We don't want to process FN again, so pretend we've written
3127          it out, even though we haven't.  */
3128       TREE_ASM_WRITTEN (fn) = 1;
3129       return;
3130     }
3131
3132   /* If this function is marked with the constructor attribute, add it
3133      to the list of functions to be called along with constructors
3134      from static duration objects.  */
3135   if (DECL_STATIC_CONSTRUCTOR (fn))
3136     static_ctors = tree_cons (NULL_TREE, fn, static_ctors);
3137
3138   /* If this function is marked with the destructor attribute, add it
3139      to the list of functions to be called along with destructors from
3140      static duration objects.  */
3141   if (DECL_STATIC_DESTRUCTOR (fn))
3142     static_dtors = tree_cons (NULL_TREE, fn, static_dtors);
3143
3144   /* We make a decision about linkage for these functions at the end
3145      of the compilation.  Until that point, we do not want the back
3146      end to output them -- but we do want it to see the bodies of
3147      these functions so that it can inline them as appropriate.  */
3148   if (DECL_DECLARED_INLINE_P (fn) || DECL_IMPLICIT_INSTANTIATION (fn))
3149     {
3150       if (DECL_INTERFACE_KNOWN (fn))
3151         /* We've already made a decision as to how this function will
3152            be handled.  */;
3153       else if (!at_eof)
3154         {
3155           DECL_EXTERNAL (fn) = 1;
3156           DECL_NOT_REALLY_EXTERN (fn) = 1;
3157           note_vague_linkage_fn (fn);
3158           /* A non-template inline function with external linkage will
3159              always be COMDAT.  As we must eventually determine the
3160              linkage of all functions, and as that causes writes to
3161              the data mapped in from the PCH file, it's advantageous
3162              to mark the functions at this point.  */
3163           if (!DECL_IMPLICIT_INSTANTIATION (fn))
3164             {
3165               /* This function must have external linkage, as
3166                  otherwise DECL_INTERFACE_KNOWN would have been
3167                  set.  */
3168               gcc_assert (TREE_PUBLIC (fn));
3169               comdat_linkage (fn);
3170               DECL_INTERFACE_KNOWN (fn) = 1;
3171             }
3172         }
3173       else
3174         import_export_decl (fn);
3175
3176       /* If the user wants us to keep all inline functions, then mark
3177          this function as needed so that finish_file will make sure to
3178          output it later.  */
3179       if (flag_keep_inline_functions && DECL_DECLARED_INLINE_P (fn))
3180         mark_needed (fn);
3181     }
3182
3183   /* There's no reason to do any of the work here if we're only doing
3184      semantic analysis; this code just generates RTL.  */
3185   if (flag_syntax_only)
3186     return;
3187
3188   function_depth++;
3189
3190   /* Expand or defer, at the whim of the compilation unit manager.  */
3191   cgraph_finalize_function (fn, function_depth > 1);
3192
3193   function_depth--;
3194 }
3195
3196 struct nrv_data
3197 {
3198   tree var;
3199   tree result;
3200   htab_t visited;
3201 };
3202
3203 /* Helper function for walk_tree, used by finalize_nrv below.  */
3204
3205 static tree
3206 finalize_nrv_r (tree* tp, int* walk_subtrees, void* data)
3207 {
3208   struct nrv_data *dp = (struct nrv_data *)data;
3209   void **slot;
3210
3211   /* No need to walk into types.  There wouldn't be any need to walk into
3212      non-statements, except that we have to consider STMT_EXPRs.  */
3213   if (TYPE_P (*tp))
3214     *walk_subtrees = 0;
3215   /* Change all returns to just refer to the RESULT_DECL; this is a nop,
3216      but differs from using NULL_TREE in that it indicates that we care
3217      about the value of the RESULT_DECL.  */
3218   else if (TREE_CODE (*tp) == RETURN_EXPR)
3219     TREE_OPERAND (*tp, 0) = dp->result;
3220   /* Change all cleanups for the NRV to only run when an exception is
3221      thrown.  */
3222   else if (TREE_CODE (*tp) == CLEANUP_STMT
3223            && CLEANUP_DECL (*tp) == dp->var)
3224     CLEANUP_EH_ONLY (*tp) = 1;
3225   /* Replace the DECL_EXPR for the NRV with an initialization of the
3226      RESULT_DECL, if needed.  */
3227   else if (TREE_CODE (*tp) == DECL_EXPR
3228            && DECL_EXPR_DECL (*tp) == dp->var)
3229     {
3230       tree init;
3231       if (DECL_INITIAL (dp->var)
3232           && DECL_INITIAL (dp->var) != error_mark_node)
3233         {
3234           init = build2 (INIT_EXPR, void_type_node, dp->result,
3235                          DECL_INITIAL (dp->var));
3236           DECL_INITIAL (dp->var) = error_mark_node;
3237         }
3238       else
3239         init = build_empty_stmt ();
3240       SET_EXPR_LOCUS (init, EXPR_LOCUS (*tp));
3241       *tp = init;
3242     }
3243   /* And replace all uses of the NRV with the RESULT_DECL.  */
3244   else if (*tp == dp->var)
3245     *tp = dp->result;
3246
3247   /* Avoid walking into the same tree more than once.  Unfortunately, we
3248      can't just use walk_tree_without duplicates because it would only call
3249      us for the first occurrence of dp->var in the function body.  */
3250   slot = htab_find_slot (dp->visited, *tp, INSERT);
3251   if (*slot)
3252     *walk_subtrees = 0;
3253   else
3254     *slot = *tp;
3255
3256   /* Keep iterating.  */
3257   return NULL_TREE;
3258 }
3259
3260 /* Called from finish_function to implement the named return value
3261    optimization by overriding all the RETURN_EXPRs and pertinent
3262    CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
3263    RESULT_DECL for the function.  */
3264
3265 void
3266 finalize_nrv (tree *tp, tree var, tree result)
3267 {
3268   struct nrv_data data;
3269
3270   /* Copy debugging information from VAR to RESULT.  */
3271   DECL_NAME (result) = DECL_NAME (var);
3272   DECL_ARTIFICIAL (result) = DECL_ARTIFICIAL (var);
3273   DECL_IGNORED_P (result) = DECL_IGNORED_P (var);
3274   DECL_SOURCE_LOCATION (result) = DECL_SOURCE_LOCATION (var);
3275   DECL_ABSTRACT_ORIGIN (result) = DECL_ABSTRACT_ORIGIN (var);
3276   /* Don't forget that we take its address.  */
3277   TREE_ADDRESSABLE (result) = TREE_ADDRESSABLE (var);
3278
3279   data.var = var;
3280   data.result = result;
3281   data.visited = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
3282   walk_tree (tp, finalize_nrv_r, &data, 0);
3283   htab_delete (data.visited);
3284 }
3285 \f
3286 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
3287    Remove any elements from the list that are invalid.  */
3288
3289 tree
3290 finish_omp_clauses (tree clauses)
3291 {
3292   bitmap_head generic_head, firstprivate_head, lastprivate_head;
3293   tree c, t, *pc = &clauses;
3294   const char *name;
3295
3296   bitmap_obstack_initialize (NULL);
3297   bitmap_initialize (&generic_head, &bitmap_default_obstack);
3298   bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
3299   bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);
3300
3301   for (pc = &clauses, c = clauses; c ; c = *pc)
3302     {
3303       bool remove = false;
3304
3305       switch (OMP_CLAUSE_CODE (c))
3306         {
3307         case OMP_CLAUSE_SHARED:
3308           name = "shared";
3309           goto check_dup_generic;
3310         case OMP_CLAUSE_PRIVATE:
3311           name = "private";
3312           goto check_dup_generic;
3313         case OMP_CLAUSE_REDUCTION:
3314           name = "reduction";
3315           goto check_dup_generic;
3316         case OMP_CLAUSE_COPYPRIVATE:
3317           name = "copyprivate";
3318           goto check_dup_generic;
3319         case OMP_CLAUSE_COPYIN:
3320           name = "copyin";
3321           goto check_dup_generic;
3322         check_dup_generic:
3323           t = OMP_CLAUSE_DECL (c);
3324           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3325             {
3326               if (processing_template_decl)
3327                 break;
3328               error ("%qE is not a variable in clause %qs", t, name);
3329               remove = true;
3330             }
3331           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
3332                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t))
3333                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
3334             {
3335               error ("%qE appears more than once in data clauses", t);
3336               remove = true;
3337             }
3338           else
3339             bitmap_set_bit (&generic_head, DECL_UID (t));
3340           break;
3341
3342         case OMP_CLAUSE_FIRSTPRIVATE:
3343           t = OMP_CLAUSE_DECL (c);
3344           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3345             {
3346               if (processing_template_decl)
3347                 break;
3348               error ("%qE is not a variable in clause %<firstprivate%>", t);
3349               remove = true;
3350             }
3351           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
3352                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
3353             {
3354               error ("%qE appears more than once in data clauses", t);
3355               remove = true;
3356             }
3357           else
3358             bitmap_set_bit (&firstprivate_head, DECL_UID (t));
3359           break;
3360
3361         case OMP_CLAUSE_LASTPRIVATE:
3362           t = OMP_CLAUSE_DECL (c);
3363           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3364             {
3365               if (processing_template_decl)
3366                 break;
3367               error ("%qE is not a variable in clause %<lastprivate%>", t);
3368               remove = true;
3369             }
3370           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
3371                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
3372             {
3373               error ("%qE appears more than once in data clauses", t);
3374               remove = true;
3375             }
3376           else
3377             bitmap_set_bit (&lastprivate_head, DECL_UID (t));
3378           break;
3379
3380         case OMP_CLAUSE_IF:
3381           t = OMP_CLAUSE_IF_EXPR (c);
3382           t = maybe_convert_cond (t);
3383           if (t == error_mark_node)
3384             remove = true;
3385           OMP_CLAUSE_IF_EXPR (c) = t;
3386           break;
3387
3388         case OMP_CLAUSE_NUM_THREADS:
3389           t = OMP_CLAUSE_NUM_THREADS_EXPR (c);
3390           if (t == error_mark_node)
3391             remove = true;
3392           else if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
3393                    && !type_dependent_expression_p (t))
3394             {
3395               error ("num_threads expression must be integral");
3396               remove = true;
3397             }
3398           break;
3399
3400         case OMP_CLAUSE_SCHEDULE:
3401           t = OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c);
3402           if (t == NULL)
3403             ;
3404           else if (t == error_mark_node)
3405             remove = true;
3406           else if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
3407                    && !type_dependent_expression_p (t))
3408             {
3409               error ("schedule chunk size expression must be integral");
3410               remove = true;
3411             }
3412           break;
3413
3414         case OMP_CLAUSE_NOWAIT:
3415         case OMP_CLAUSE_ORDERED:
3416         case OMP_CLAUSE_DEFAULT:
3417           break;
3418
3419         default:
3420           gcc_unreachable ();
3421         }
3422
3423       if (remove)
3424         *pc = OMP_CLAUSE_CHAIN (c);
3425       else
3426         pc = &OMP_CLAUSE_CHAIN (c);
3427     }
3428
3429   for (pc = &clauses, c = clauses; c ; c = *pc)
3430     {
3431       enum tree_code c_kind = OMP_CLAUSE_CODE (c);
3432       bool remove = false;
3433       bool need_complete_non_reference = false;
3434       bool need_default_ctor = false;
3435       bool need_copy_ctor = false;
3436       bool need_copy_assignment = false;
3437       bool need_implicitly_determined = false;
3438       tree type, inner_type;
3439
3440       switch (c_kind)
3441         {
3442         case OMP_CLAUSE_SHARED:
3443           name = "shared";
3444           need_implicitly_determined = true;
3445           break;
3446         case OMP_CLAUSE_PRIVATE:
3447           name = "private";
3448           need_complete_non_reference = true;
3449           need_default_ctor = true;
3450           need_implicitly_determined = true;
3451           break;
3452         case OMP_CLAUSE_FIRSTPRIVATE:
3453           name = "firstprivate";
3454           need_complete_non_reference = true;
3455           need_copy_ctor = true;
3456           need_implicitly_determined = true;
3457           break;
3458         case OMP_CLAUSE_LASTPRIVATE:
3459           name = "lastprivate";
3460           need_complete_non_reference = true;
3461           need_copy_assignment = true;
3462           need_implicitly_determined = true;
3463           break;
3464         case OMP_CLAUSE_REDUCTION:
3465           name = "reduction";
3466           need_implicitly_determined = true;
3467           break;
3468         case OMP_CLAUSE_COPYPRIVATE:
3469           name = "copyprivate";
3470           need_copy_assignment = true;
3471           break;
3472         case OMP_CLAUSE_COPYIN:
3473           name = "copyin";
3474           need_copy_assignment = true;
3475           break;
3476         default:
3477           pc = &OMP_CLAUSE_CHAIN (c);
3478           continue;
3479         }
3480
3481       t = OMP_CLAUSE_DECL (c);
3482       if (processing_template_decl
3483           && TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3484         {
3485           pc = &OMP_CLAUSE_CHAIN (c);
3486           continue;
3487         }
3488
3489       switch (c_kind)
3490         {
3491         case OMP_CLAUSE_LASTPRIVATE:
3492           if (!bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
3493             need_default_ctor = true;
3494           break;
3495
3496         case OMP_CLAUSE_REDUCTION:
3497           if (AGGREGATE_TYPE_P (TREE_TYPE (t))
3498               || POINTER_TYPE_P (TREE_TYPE (t)))
3499             {
3500               error ("%qE has invalid type for %<reduction%>", t);
3501               remove = true;
3502             }
3503           else if (FLOAT_TYPE_P (TREE_TYPE (t)))
3504             {
3505               enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c);
3506               switch (r_code)
3507                 {
3508                 case PLUS_EXPR:
3509                 case MULT_EXPR:
3510                 case MINUS_EXPR:
3511                   break;
3512                 default:
3513                   error ("%qE has invalid type for %<reduction(%s)%>",
3514                          t, operator_name_info[r_code].name);
3515                   remove = true;
3516                 }
3517             }
3518           break;
3519
3520         case OMP_CLAUSE_COPYIN:
3521           if (TREE_CODE (t) != VAR_DECL || !DECL_THREAD_LOCAL_P (t))
3522             {
3523               error ("%qE must be %<threadprivate%> for %<copyin%>", t);
3524               remove = true;
3525             }
3526           break;
3527
3528         default:
3529           break;
3530         }
3531
3532       if (need_complete_non_reference)
3533         {
3534           t = require_complete_type (t);
3535           if (t == error_mark_node)
3536             remove = true;
3537           else if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
3538             {
3539               error ("%qE has reference type for %qs", t, name);
3540               remove = true;
3541             }
3542         }
3543       if (need_implicitly_determined)
3544         {
3545           const char *share_name = NULL;
3546