OSDN Git Service

56dbe6fddad601d11fc9b60cd49e2d89567cb08e
[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 = TREE_TYPE (expr);
1616
1617       if (processing_template_decl)
1618         {
1619           expr = build_stmt (EXPR_STMT, expr);
1620           expr = add_stmt (expr);
1621           /* Mark the last statement so that we can recognize it as such at
1622              template-instantiation time.  */
1623           EXPR_STMT_STMT_EXPR_RESULT (expr) = 1;
1624         }
1625       else if (VOID_TYPE_P (type))
1626         {
1627           /* Just treat this like an ordinary statement.  */
1628           expr = finish_expr_stmt (expr);
1629         }
1630       else
1631         {
1632           /* It actually has a value we need to deal with.  First, force it
1633              to be an rvalue so that we won't need to build up a copy
1634              constructor call later when we try to assign it to something.  */
1635           expr = force_rvalue (expr);
1636           if (error_operand_p (expr))
1637             return error_mark_node;
1638
1639           /* Update for array-to-pointer decay.  */
1640           type = TREE_TYPE (expr);
1641
1642           /* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
1643              normal statement, but don't convert to void or actually add
1644              the EXPR_STMT.  */
1645           if (TREE_CODE (expr) != CLEANUP_POINT_EXPR)
1646             expr = maybe_cleanup_point_expr (expr);
1647           add_stmt (expr);
1648         }
1649
1650       /* The type of the statement-expression is the type of the last
1651          expression.  */
1652       TREE_TYPE (stmt_expr) = type;
1653     }
1654
1655   return stmt_expr;
1656 }
1657
1658 /* Finish a statement-expression.  EXPR should be the value returned
1659    by the previous begin_stmt_expr.  Returns an expression
1660    representing the statement-expression.  */
1661
1662 tree
1663 finish_stmt_expr (tree stmt_expr, bool has_no_scope)
1664 {
1665   tree type;
1666   tree result;
1667
1668   if (error_operand_p (stmt_expr))
1669     return error_mark_node;
1670
1671   gcc_assert (TREE_CODE (stmt_expr) == STATEMENT_LIST);
1672
1673   type = TREE_TYPE (stmt_expr);
1674   result = pop_stmt_list (stmt_expr);
1675   TREE_TYPE (result) = type;
1676
1677   if (processing_template_decl)
1678     {
1679       result = build_min (STMT_EXPR, type, result);
1680       TREE_SIDE_EFFECTS (result) = 1;
1681       STMT_EXPR_NO_SCOPE (result) = has_no_scope;
1682     }
1683   else if (CLASS_TYPE_P (type))
1684     {
1685       /* Wrap the statement-expression in a TARGET_EXPR so that the
1686          temporary object created by the final expression is destroyed at
1687          the end of the full-expression containing the
1688          statement-expression.  */
1689       result = force_target_expr (type, result);
1690     }
1691
1692   return result;
1693 }
1694
1695 /* Perform Koenig lookup.  FN is the postfix-expression representing
1696    the function (or functions) to call; ARGS are the arguments to the
1697    call.  Returns the functions to be considered by overload
1698    resolution.  */
1699
1700 tree
1701 perform_koenig_lookup (tree fn, tree args)
1702 {
1703   tree identifier = NULL_TREE;
1704   tree functions = NULL_TREE;
1705
1706   /* Find the name of the overloaded function.  */
1707   if (TREE_CODE (fn) == IDENTIFIER_NODE)
1708     identifier = fn;
1709   else if (is_overloaded_fn (fn))
1710     {
1711       functions = fn;
1712       identifier = DECL_NAME (get_first_fn (functions));
1713     }
1714   else if (DECL_P (fn))
1715     {
1716       functions = fn;
1717       identifier = DECL_NAME (fn);
1718     }
1719
1720   /* A call to a namespace-scope function using an unqualified name.
1721
1722      Do Koenig lookup -- unless any of the arguments are
1723      type-dependent.  */
1724   if (!any_type_dependent_arguments_p (args))
1725     {
1726       fn = lookup_arg_dependent (identifier, functions, args);
1727       if (!fn)
1728         /* The unqualified name could not be resolved.  */
1729         fn = unqualified_fn_lookup_error (identifier);
1730     }
1731
1732   return fn;
1733 }
1734
1735 /* Generate an expression for `FN (ARGS)'.
1736
1737    If DISALLOW_VIRTUAL is true, the call to FN will be not generated
1738    as a virtual call, even if FN is virtual.  (This flag is set when
1739    encountering an expression where the function name is explicitly
1740    qualified.  For example a call to `X::f' never generates a virtual
1741    call.)
1742
1743    Returns code for the call.  */
1744
1745 tree
1746 finish_call_expr (tree fn, tree args, bool disallow_virtual, bool koenig_p)
1747 {
1748   tree result;
1749   tree orig_fn;
1750   tree orig_args;
1751
1752   if (fn == error_mark_node || args == error_mark_node)
1753     return error_mark_node;
1754
1755   /* ARGS should be a list of arguments.  */
1756   gcc_assert (!args || TREE_CODE (args) == TREE_LIST);
1757
1758   orig_fn = fn;
1759   orig_args = args;
1760
1761   if (processing_template_decl)
1762     {
1763       if (type_dependent_expression_p (fn)
1764           || any_type_dependent_arguments_p (args))
1765         {
1766           result = build_nt (CALL_EXPR, fn, args, NULL_TREE);
1767           KOENIG_LOOKUP_P (result) = koenig_p;
1768           return result;
1769         }
1770       if (!BASELINK_P (fn)
1771           && TREE_CODE (fn) != PSEUDO_DTOR_EXPR
1772           && TREE_TYPE (fn) != unknown_type_node)
1773         fn = build_non_dependent_expr (fn);
1774       args = build_non_dependent_args (orig_args);
1775     }
1776
1777   /* A reference to a member function will appear as an overloaded
1778      function (rather than a BASELINK) if an unqualified name was used
1779      to refer to it.  */
1780   if (!BASELINK_P (fn) && is_overloaded_fn (fn))
1781     {
1782       tree f = fn;
1783
1784       if (TREE_CODE (f) == TEMPLATE_ID_EXPR)
1785         f = TREE_OPERAND (f, 0);
1786       f = get_first_fn (f);
1787       if (DECL_FUNCTION_MEMBER_P (f))
1788         {
1789           tree type = currently_open_derived_class (DECL_CONTEXT (f));
1790           if (!type)
1791             type = DECL_CONTEXT (f);
1792           fn = build_baselink (TYPE_BINFO (type),
1793                                TYPE_BINFO (type),
1794                                fn, /*optype=*/NULL_TREE);
1795         }
1796     }
1797
1798   result = NULL_TREE;
1799   if (BASELINK_P (fn))
1800     {
1801       tree object;
1802
1803       /* A call to a member function.  From [over.call.func]:
1804
1805            If the keyword this is in scope and refers to the class of
1806            that member function, or a derived class thereof, then the
1807            function call is transformed into a qualified function call
1808            using (*this) as the postfix-expression to the left of the
1809            . operator.... [Otherwise] a contrived object of type T
1810            becomes the implied object argument.
1811
1812         This paragraph is unclear about this situation:
1813
1814           struct A { void f(); };
1815           struct B : public A {};
1816           struct C : public A { void g() { B::f(); }};
1817
1818         In particular, for `B::f', this paragraph does not make clear
1819         whether "the class of that member function" refers to `A' or
1820         to `B'.  We believe it refers to `B'.  */
1821       if (current_class_type
1822           && DERIVED_FROM_P (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
1823                              current_class_type)
1824           && current_class_ref)
1825         object = maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
1826                                      NULL);
1827       else
1828         {
1829           tree representative_fn;
1830
1831           representative_fn = BASELINK_FUNCTIONS (fn);
1832           if (TREE_CODE (representative_fn) == TEMPLATE_ID_EXPR)
1833             representative_fn = TREE_OPERAND (representative_fn, 0);
1834           representative_fn = get_first_fn (representative_fn);
1835           object = build_dummy_object (DECL_CONTEXT (representative_fn));
1836         }
1837
1838       if (processing_template_decl)
1839         {
1840           if (type_dependent_expression_p (object))
1841             return build_nt (CALL_EXPR, orig_fn, orig_args, NULL_TREE);
1842           object = build_non_dependent_expr (object);
1843         }
1844
1845       result = build_new_method_call (object, fn, args, NULL_TREE,
1846                                       (disallow_virtual
1847                                        ? LOOKUP_NONVIRTUAL : 0),
1848                                       /*fn_p=*/NULL);
1849     }
1850   else if (is_overloaded_fn (fn))
1851     {
1852       /* If the function is an overloaded builtin, resolve it.  */
1853       if (TREE_CODE (fn) == FUNCTION_DECL
1854           && (DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
1855               || DECL_BUILT_IN_CLASS (fn) == BUILT_IN_MD))
1856         result = resolve_overloaded_builtin (fn, args);
1857
1858       if (!result)
1859         /* A call to a namespace-scope function.  */
1860         result = build_new_function_call (fn, args, koenig_p);
1861     }
1862   else if (TREE_CODE (fn) == PSEUDO_DTOR_EXPR)
1863     {
1864       if (args)
1865         error ("arguments to destructor are not allowed");
1866       /* Mark the pseudo-destructor call as having side-effects so
1867          that we do not issue warnings about its use.  */
1868       result = build1 (NOP_EXPR,
1869                        void_type_node,
1870                        TREE_OPERAND (fn, 0));
1871       TREE_SIDE_EFFECTS (result) = 1;
1872     }
1873   else if (CLASS_TYPE_P (TREE_TYPE (fn)))
1874     /* If the "function" is really an object of class type, it might
1875        have an overloaded `operator ()'.  */
1876     result = build_new_op (CALL_EXPR, LOOKUP_NORMAL, fn, args, NULL_TREE,
1877                            /*overloaded_p=*/NULL);
1878
1879   if (!result)
1880     /* A call where the function is unknown.  */
1881     result = build_function_call (fn, args);
1882
1883   if (processing_template_decl)
1884     {
1885       result = build3 (CALL_EXPR, TREE_TYPE (result), orig_fn,
1886                        orig_args, NULL_TREE);
1887       KOENIG_LOOKUP_P (result) = koenig_p;
1888     }
1889   return result;
1890 }
1891
1892 /* Finish a call to a postfix increment or decrement or EXPR.  (Which
1893    is indicated by CODE, which should be POSTINCREMENT_EXPR or
1894    POSTDECREMENT_EXPR.)  */
1895
1896 tree
1897 finish_increment_expr (tree expr, enum tree_code code)
1898 {
1899   return build_x_unary_op (code, expr);
1900 }
1901
1902 /* Finish a use of `this'.  Returns an expression for `this'.  */
1903
1904 tree
1905 finish_this_expr (void)
1906 {
1907   tree result;
1908
1909   if (current_class_ptr)
1910     {
1911       result = current_class_ptr;
1912     }
1913   else if (current_function_decl
1914            && DECL_STATIC_FUNCTION_P (current_function_decl))
1915     {
1916       error ("%<this%> is unavailable for static member functions");
1917       result = error_mark_node;
1918     }
1919   else
1920     {
1921       if (current_function_decl)
1922         error ("invalid use of %<this%> in non-member function");
1923       else
1924         error ("invalid use of %<this%> at top level");
1925       result = error_mark_node;
1926     }
1927
1928   return result;
1929 }
1930
1931 /* Finish a pseudo-destructor expression.  If SCOPE is NULL, the
1932    expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
1933    the TYPE for the type given.  If SCOPE is non-NULL, the expression
1934    was of the form `OBJECT.SCOPE::~DESTRUCTOR'.  */
1935
1936 tree
1937 finish_pseudo_destructor_expr (tree object, tree scope, tree destructor)
1938 {
1939   if (destructor == error_mark_node)
1940     return error_mark_node;
1941
1942   gcc_assert (TYPE_P (destructor));
1943
1944   if (!processing_template_decl)
1945     {
1946       if (scope == error_mark_node)
1947         {
1948           error ("invalid qualifying scope in pseudo-destructor name");
1949           return error_mark_node;
1950         }
1951
1952       /* [expr.pseudo] says both:
1953
1954            The type designated by the pseudo-destructor-name shall be
1955            the same as the object type.
1956
1957          and:
1958
1959            The cv-unqualified versions of the object type and of the
1960            type designated by the pseudo-destructor-name shall be the
1961            same type.
1962
1963          We implement the more generous second sentence, since that is
1964          what most other compilers do.  */
1965       if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object),
1966                                                       destructor))
1967         {
1968           error ("%qE is not of type %qT", object, destructor);
1969           return error_mark_node;
1970         }
1971     }
1972
1973   return build3 (PSEUDO_DTOR_EXPR, void_type_node, object, scope, destructor);
1974 }
1975
1976 /* Finish an expression of the form CODE EXPR.  */
1977
1978 tree
1979 finish_unary_op_expr (enum tree_code code, tree expr)
1980 {
1981   tree result = build_x_unary_op (code, expr);
1982   /* Inside a template, build_x_unary_op does not fold the
1983      expression. So check whether the result is folded before
1984      setting TREE_NEGATED_INT.  */
1985   if (code == NEGATE_EXPR && TREE_CODE (expr) == INTEGER_CST
1986       && TREE_CODE (result) == INTEGER_CST
1987       && !TYPE_UNSIGNED (TREE_TYPE (result))
1988       && INT_CST_LT (result, integer_zero_node))
1989     {
1990       /* RESULT may be a cached INTEGER_CST, so we must copy it before
1991          setting TREE_NEGATED_INT.  */
1992       result = copy_node (result);
1993       TREE_NEGATED_INT (result) = 1;
1994     }
1995   overflow_warning (result);
1996   return result;
1997 }
1998
1999 /* Finish a compound-literal expression.  TYPE is the type to which
2000    the INITIALIZER_LIST is being cast.  */
2001
2002 tree
2003 finish_compound_literal (tree type, VEC(constructor_elt,gc) *initializer_list)
2004 {
2005   tree var;
2006   tree compound_literal;
2007
2008   if (!TYPE_OBJ_P (type))
2009     {
2010       error ("compound literal of non-object type %qT", type);
2011       return error_mark_node;
2012     }
2013
2014   /* Build a CONSTRUCTOR for the INITIALIZER_LIST.  */
2015   compound_literal = build_constructor (NULL_TREE, initializer_list);
2016   if (processing_template_decl)
2017     {
2018       TREE_TYPE (compound_literal) = type;
2019       /* Mark the expression as a compound literal.  */
2020       TREE_HAS_CONSTRUCTOR (compound_literal) = 1;
2021       return compound_literal;
2022     }
2023
2024   /* Create a temporary variable to represent the compound literal.  */
2025   var = create_temporary_var (type);
2026   if (!current_function_decl)
2027     {
2028       /* If this compound-literal appears outside of a function, then
2029          the corresponding variable has static storage duration, just
2030          like the variable in whose initializer it appears.  */
2031       TREE_STATIC (var) = 1;
2032       /* The variable has internal linkage, since there is no need to
2033          reference it from another translation unit.  */
2034       TREE_PUBLIC (var) = 0;
2035       /* It must have a name, so that the name mangler can mangle it.  */
2036       DECL_NAME (var) = make_anon_name ();
2037     }
2038   /* We must call pushdecl, since the gimplifier complains if the
2039      variable has not been declared via a BIND_EXPR.  */
2040   pushdecl (var);
2041   /* Initialize the variable as we would any other variable with a
2042      brace-enclosed initializer.  */
2043   cp_finish_decl (var, compound_literal,
2044                   /*init_const_expr_p=*/false,
2045                   /*asmspec_tree=*/NULL_TREE,
2046                   LOOKUP_ONLYCONVERTING);
2047   return var;
2048 }
2049
2050 /* Return the declaration for the function-name variable indicated by
2051    ID.  */
2052
2053 tree
2054 finish_fname (tree id)
2055 {
2056   tree decl;
2057
2058   decl = fname_decl (C_RID_CODE (id), id);
2059   if (processing_template_decl)
2060     decl = DECL_NAME (decl);
2061   return decl;
2062 }
2063
2064 /* Finish a translation unit.  */
2065
2066 void
2067 finish_translation_unit (void)
2068 {
2069   /* In case there were missing closebraces,
2070      get us back to the global binding level.  */
2071   pop_everything ();
2072   while (current_namespace != global_namespace)
2073     pop_namespace ();
2074
2075   /* Do file scope __FUNCTION__ et al.  */
2076   finish_fname_decls ();
2077 }
2078
2079 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
2080    Returns the parameter.  */
2081
2082 tree
2083 finish_template_type_parm (tree aggr, tree identifier)
2084 {
2085   if (aggr != class_type_node)
2086     {
2087       pedwarn ("template type parameters must use the keyword %<class%> or %<typename%>");
2088       aggr = class_type_node;
2089     }
2090
2091   return build_tree_list (aggr, identifier);
2092 }
2093
2094 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
2095    Returns the parameter.  */
2096
2097 tree
2098 finish_template_template_parm (tree aggr, tree identifier)
2099 {
2100   tree decl = build_decl (TYPE_DECL, identifier, NULL_TREE);
2101   tree tmpl = build_lang_decl (TEMPLATE_DECL, identifier, NULL_TREE);
2102   DECL_TEMPLATE_PARMS (tmpl) = current_template_parms;
2103   DECL_TEMPLATE_RESULT (tmpl) = decl;
2104   DECL_ARTIFICIAL (decl) = 1;
2105   end_template_decl ();
2106
2107   gcc_assert (DECL_TEMPLATE_PARMS (tmpl));
2108
2109   return finish_template_type_parm (aggr, tmpl);
2110 }
2111
2112 /* ARGUMENT is the default-argument value for a template template
2113    parameter.  If ARGUMENT is invalid, issue error messages and return
2114    the ERROR_MARK_NODE.  Otherwise, ARGUMENT itself is returned.  */
2115
2116 tree
2117 check_template_template_default_arg (tree argument)
2118 {
2119   if (TREE_CODE (argument) != TEMPLATE_DECL
2120       && TREE_CODE (argument) != TEMPLATE_TEMPLATE_PARM
2121       && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
2122     {
2123       if (TREE_CODE (argument) == TYPE_DECL)
2124         error ("invalid use of type %qT as a default value for a template "
2125                "template-parameter", TREE_TYPE (argument));
2126       else
2127         error ("invalid default argument for a template template parameter");
2128       return error_mark_node;
2129     }
2130
2131   return argument;
2132 }
2133
2134 /* Begin a class definition, as indicated by T.  */
2135
2136 tree
2137 begin_class_definition (tree t, tree attributes)
2138 {
2139   if (t == error_mark_node)
2140     return error_mark_node;
2141
2142   if (processing_template_parmlist)
2143     {
2144       error ("definition of %q#T inside template parameter list", t);
2145       return error_mark_node;
2146     }
2147   /* A non-implicit typename comes from code like:
2148
2149        template <typename T> struct A {
2150          template <typename U> struct A<T>::B ...
2151
2152      This is erroneous.  */
2153   else if (TREE_CODE (t) == TYPENAME_TYPE)
2154     {
2155       error ("invalid definition of qualified type %qT", t);
2156       t = error_mark_node;
2157     }
2158
2159   if (t == error_mark_node || ! IS_AGGR_TYPE (t))
2160     {
2161       t = make_aggr_type (RECORD_TYPE);
2162       pushtag (make_anon_name (), t, /*tag_scope=*/ts_current);
2163     }
2164
2165   /* Update the location of the decl.  */
2166   DECL_SOURCE_LOCATION (TYPE_NAME (t)) = input_location;
2167
2168   if (TYPE_BEING_DEFINED (t))
2169     {
2170       t = make_aggr_type (TREE_CODE (t));
2171       pushtag (TYPE_IDENTIFIER (t), t, /*tag_scope=*/ts_current);
2172     }
2173   maybe_process_partial_specialization (t);
2174   pushclass (t);
2175   TYPE_BEING_DEFINED (t) = 1;
2176
2177   cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
2178
2179   if (flag_pack_struct)
2180     {
2181       tree v;
2182       TYPE_PACKED (t) = 1;
2183       /* Even though the type is being defined for the first time
2184          here, there might have been a forward declaration, so there
2185          might be cv-qualified variants of T.  */
2186       for (v = TYPE_NEXT_VARIANT (t); v; v = TYPE_NEXT_VARIANT (v))
2187         TYPE_PACKED (v) = 1;
2188     }
2189   /* Reset the interface data, at the earliest possible
2190      moment, as it might have been set via a class foo;
2191      before.  */
2192   if (! TYPE_ANONYMOUS_P (t))
2193     {
2194       struct c_fileinfo *finfo = get_fileinfo (lbasename (input_filename));
2195       CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
2196       SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2197         (t, finfo->interface_unknown);
2198     }
2199   reset_specialization();
2200
2201   /* Make a declaration for this class in its own scope.  */
2202   build_self_reference ();
2203
2204   return t;
2205 }
2206
2207 /* Finish the member declaration given by DECL.  */
2208
2209 void
2210 finish_member_declaration (tree decl)
2211 {
2212   if (decl == error_mark_node || decl == NULL_TREE)
2213     return;
2214
2215   if (decl == void_type_node)
2216     /* The COMPONENT was a friend, not a member, and so there's
2217        nothing for us to do.  */
2218     return;
2219
2220   /* We should see only one DECL at a time.  */
2221   gcc_assert (TREE_CHAIN (decl) == NULL_TREE);
2222
2223   /* Set up access control for DECL.  */
2224   TREE_PRIVATE (decl)
2225     = (current_access_specifier == access_private_node);
2226   TREE_PROTECTED (decl)
2227     = (current_access_specifier == access_protected_node);
2228   if (TREE_CODE (decl) == TEMPLATE_DECL)
2229     {
2230       TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl)) = TREE_PRIVATE (decl);
2231       TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl)) = TREE_PROTECTED (decl);
2232     }
2233
2234   /* Mark the DECL as a member of the current class.  */
2235   DECL_CONTEXT (decl) = current_class_type;
2236
2237   /* [dcl.link]
2238
2239      A C language linkage is ignored for the names of class members
2240      and the member function type of class member functions.  */
2241   if (DECL_LANG_SPECIFIC (decl) && DECL_LANGUAGE (decl) == lang_c)
2242     SET_DECL_LANGUAGE (decl, lang_cplusplus);
2243
2244   /* Put functions on the TYPE_METHODS list and everything else on the
2245      TYPE_FIELDS list.  Note that these are built up in reverse order.
2246      We reverse them (to obtain declaration order) in finish_struct.  */
2247   if (TREE_CODE (decl) == FUNCTION_DECL
2248       || DECL_FUNCTION_TEMPLATE_P (decl))
2249     {
2250       /* We also need to add this function to the
2251          CLASSTYPE_METHOD_VEC.  */
2252       if (add_method (current_class_type, decl, NULL_TREE))
2253         {
2254           TREE_CHAIN (decl) = TYPE_METHODS (current_class_type);
2255           TYPE_METHODS (current_class_type) = decl;
2256
2257           maybe_add_class_template_decl_list (current_class_type, decl,
2258                                               /*friend_p=*/0);
2259         }
2260     }
2261   /* Enter the DECL into the scope of the class.  */
2262   else if ((TREE_CODE (decl) == USING_DECL && !DECL_DEPENDENT_P (decl))
2263            || pushdecl_class_level (decl))
2264     {
2265       /* All TYPE_DECLs go at the end of TYPE_FIELDS.  Ordinary fields
2266          go at the beginning.  The reason is that lookup_field_1
2267          searches the list in order, and we want a field name to
2268          override a type name so that the "struct stat hack" will
2269          work.  In particular:
2270
2271            struct S { enum E { }; int E } s;
2272            s.E = 3;
2273
2274          is valid.  In addition, the FIELD_DECLs must be maintained in
2275          declaration order so that class layout works as expected.
2276          However, we don't need that order until class layout, so we
2277          save a little time by putting FIELD_DECLs on in reverse order
2278          here, and then reversing them in finish_struct_1.  (We could
2279          also keep a pointer to the correct insertion points in the
2280          list.)  */
2281
2282       if (TREE_CODE (decl) == TYPE_DECL)
2283         TYPE_FIELDS (current_class_type)
2284           = chainon (TYPE_FIELDS (current_class_type), decl);
2285       else
2286         {
2287           TREE_CHAIN (decl) = TYPE_FIELDS (current_class_type);
2288           TYPE_FIELDS (current_class_type) = decl;
2289         }
2290
2291       maybe_add_class_template_decl_list (current_class_type, decl,
2292                                           /*friend_p=*/0);
2293     }
2294
2295   if (pch_file)
2296     note_decl_for_pch (decl);
2297 }
2298
2299 /* DECL has been declared while we are building a PCH file.  Perform
2300    actions that we might normally undertake lazily, but which can be
2301    performed now so that they do not have to be performed in
2302    translation units which include the PCH file.  */
2303
2304 void
2305 note_decl_for_pch (tree decl)
2306 {
2307   gcc_assert (pch_file);
2308
2309   /* There's a good chance that we'll have to mangle names at some
2310      point, even if only for emission in debugging information.  */
2311   if ((TREE_CODE (decl) == VAR_DECL
2312        || TREE_CODE (decl) == FUNCTION_DECL)
2313       && !processing_template_decl)
2314     mangle_decl (decl);
2315 }
2316
2317 /* Finish processing a complete template declaration.  The PARMS are
2318    the template parameters.  */
2319
2320 void
2321 finish_template_decl (tree parms)
2322 {
2323   if (parms)
2324     end_template_decl ();
2325   else
2326     end_specialization ();
2327 }
2328
2329 /* Finish processing a template-id (which names a type) of the form
2330    NAME < ARGS >.  Return the TYPE_DECL for the type named by the
2331    template-id.  If ENTERING_SCOPE is nonzero we are about to enter
2332    the scope of template-id indicated.  */
2333
2334 tree
2335 finish_template_type (tree name, tree args, int entering_scope)
2336 {
2337   tree decl;
2338
2339   decl = lookup_template_class (name, args,
2340                                 NULL_TREE, NULL_TREE, entering_scope,
2341                                 tf_warning_or_error | tf_user);
2342   if (decl != error_mark_node)
2343     decl = TYPE_STUB_DECL (decl);
2344
2345   return decl;
2346 }
2347
2348 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
2349    Return a TREE_LIST containing the ACCESS_SPECIFIER and the
2350    BASE_CLASS, or NULL_TREE if an error occurred.  The
2351    ACCESS_SPECIFIER is one of
2352    access_{default,public,protected_private}_node.  For a virtual base
2353    we set TREE_TYPE.  */
2354
2355 tree
2356 finish_base_specifier (tree base, tree access, bool virtual_p)
2357 {
2358   tree result;
2359
2360   if (base == error_mark_node)
2361     {
2362       error ("invalid base-class specification");
2363       result = NULL_TREE;
2364     }
2365   else if (! is_aggr_type (base, 1))
2366     result = NULL_TREE;
2367   else
2368     {
2369       if (cp_type_quals (base) != 0)
2370         {
2371           error ("base class %qT has cv qualifiers", base);
2372           base = TYPE_MAIN_VARIANT (base);
2373         }
2374       result = build_tree_list (access, base);
2375       if (virtual_p)
2376         TREE_TYPE (result) = integer_type_node;
2377     }
2378
2379   return result;
2380 }
2381
2382 /* Issue a diagnostic that NAME cannot be found in SCOPE.  DECL is
2383    what we found when we tried to do the lookup.  */
2384
2385 void
2386 qualified_name_lookup_error (tree scope, tree name, tree decl)
2387 {
2388   if (scope == error_mark_node)
2389     ; /* We already complained.  */
2390   else if (TYPE_P (scope))
2391     {
2392       if (!COMPLETE_TYPE_P (scope))
2393         error ("incomplete type %qT used in nested name specifier", scope);
2394       else if (TREE_CODE (decl) == TREE_LIST)
2395         {
2396           error ("reference to %<%T::%D%> is ambiguous", scope, name);
2397           print_candidates (decl);
2398         }
2399       else
2400         error ("%qD is not a member of %qT", name, scope);
2401     }
2402   else if (scope != global_namespace)
2403     error ("%qD is not a member of %qD", name, scope);
2404   else
2405     error ("%<::%D%> has not been declared", name);
2406 }
2407
2408 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
2409    id-expression.  (See cp_parser_id_expression for details.)  SCOPE,
2410    if non-NULL, is the type or namespace used to explicitly qualify
2411    ID_EXPRESSION.  DECL is the entity to which that name has been
2412    resolved.
2413
2414    *CONSTANT_EXPRESSION_P is true if we are presently parsing a
2415    constant-expression.  In that case, *NON_CONSTANT_EXPRESSION_P will
2416    be set to true if this expression isn't permitted in a
2417    constant-expression, but it is otherwise not set by this function.
2418    *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
2419    constant-expression, but a non-constant expression is also
2420    permissible.
2421
2422    DONE is true if this expression is a complete postfix-expression;
2423    it is false if this expression is followed by '->', '[', '(', etc.
2424    ADDRESS_P is true iff this expression is the operand of '&'.
2425    TEMPLATE_P is true iff the qualified-id was of the form
2426    "A::template B".  TEMPLATE_ARG_P is true iff this qualified name
2427    appears as a template argument.
2428
2429    If an error occurs, and it is the kind of error that might cause
2430    the parser to abort a tentative parse, *ERROR_MSG is filled in.  It
2431    is the caller's responsibility to issue the message.  *ERROR_MSG
2432    will be a string with static storage duration, so the caller need
2433    not "free" it.
2434
2435    Return an expression for the entity, after issuing appropriate
2436    diagnostics.  This function is also responsible for transforming a
2437    reference to a non-static member into a COMPONENT_REF that makes
2438    the use of "this" explicit.
2439
2440    Upon return, *IDK will be filled in appropriately.  */
2441
2442 tree
2443 finish_id_expression (tree id_expression,
2444                       tree decl,
2445                       tree scope,
2446                       cp_id_kind *idk,
2447                       bool integral_constant_expression_p,
2448                       bool allow_non_integral_constant_expression_p,
2449                       bool *non_integral_constant_expression_p,
2450                       bool template_p,
2451                       bool done,
2452                       bool address_p,
2453                       bool template_arg_p,
2454                       const char **error_msg)
2455 {
2456   /* Initialize the output parameters.  */
2457   *idk = CP_ID_KIND_NONE;
2458   *error_msg = NULL;
2459
2460   if (id_expression == error_mark_node)
2461     return error_mark_node;
2462   /* If we have a template-id, then no further lookup is
2463      required.  If the template-id was for a template-class, we
2464      will sometimes have a TYPE_DECL at this point.  */
2465   else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2466            || TREE_CODE (decl) == TYPE_DECL)
2467     ;
2468   /* Look up the name.  */
2469   else
2470     {
2471       if (decl == error_mark_node)
2472         {
2473           /* Name lookup failed.  */
2474           if (scope
2475               && (!TYPE_P (scope)
2476                   || (!dependent_type_p (scope)
2477                       && !(TREE_CODE (id_expression) == IDENTIFIER_NODE
2478                            && IDENTIFIER_TYPENAME_P (id_expression)
2479                            && dependent_type_p (TREE_TYPE (id_expression))))))
2480             {
2481               /* If the qualifying type is non-dependent (and the name
2482                  does not name a conversion operator to a dependent
2483                  type), issue an error.  */
2484               qualified_name_lookup_error (scope, id_expression, decl);
2485               return error_mark_node;
2486             }
2487           else if (!scope)
2488             {
2489               /* It may be resolved via Koenig lookup.  */
2490               *idk = CP_ID_KIND_UNQUALIFIED;
2491               return id_expression;
2492             }
2493           else
2494             decl = id_expression;
2495         }
2496       /* If DECL is a variable that would be out of scope under
2497          ANSI/ISO rules, but in scope in the ARM, name lookup
2498          will succeed.  Issue a diagnostic here.  */
2499       else
2500         decl = check_for_out_of_scope_variable (decl);
2501
2502       /* Remember that the name was used in the definition of
2503          the current class so that we can check later to see if
2504          the meaning would have been different after the class
2505          was entirely defined.  */
2506       if (!scope && decl != error_mark_node)
2507         maybe_note_name_used_in_class (id_expression, decl);
2508
2509       /* Disallow uses of local variables from containing functions.  */
2510       if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
2511         {
2512           tree context = decl_function_context (decl);
2513           if (context != NULL_TREE && context != current_function_decl
2514               && ! TREE_STATIC (decl))
2515             {
2516               error (TREE_CODE (decl) == VAR_DECL
2517                      ? "use of %<auto%> variable from containing function"
2518                      : "use of parameter from containing function");
2519               error ("  %q+#D declared here", decl);
2520               return error_mark_node;
2521             }
2522         }
2523     }
2524
2525   /* If we didn't find anything, or what we found was a type,
2526      then this wasn't really an id-expression.  */
2527   if (TREE_CODE (decl) == TEMPLATE_DECL
2528       && !DECL_FUNCTION_TEMPLATE_P (decl))
2529     {
2530       *error_msg = "missing template arguments";
2531       return error_mark_node;
2532     }
2533   else if (TREE_CODE (decl) == TYPE_DECL
2534            || TREE_CODE (decl) == NAMESPACE_DECL)
2535     {
2536       *error_msg = "expected primary-expression";
2537       return error_mark_node;
2538     }
2539
2540   /* If the name resolved to a template parameter, there is no
2541      need to look it up again later.  */
2542   if ((TREE_CODE (decl) == CONST_DECL && DECL_TEMPLATE_PARM_P (decl))
2543       || TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
2544     {
2545       tree r;
2546
2547       *idk = CP_ID_KIND_NONE;
2548       if (TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
2549         decl = TEMPLATE_PARM_DECL (decl);
2550       r = convert_from_reference (DECL_INITIAL (decl));
2551
2552       if (integral_constant_expression_p
2553           && !dependent_type_p (TREE_TYPE (decl))
2554           && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r))))
2555         {
2556           if (!allow_non_integral_constant_expression_p)
2557             error ("template parameter %qD of type %qT is not allowed in "
2558                    "an integral constant expression because it is not of "
2559                    "integral or enumeration type", decl, TREE_TYPE (decl));
2560           *non_integral_constant_expression_p = true;
2561         }
2562       return r;
2563     }
2564   /* Similarly, we resolve enumeration constants to their
2565      underlying values.  */
2566   else if (TREE_CODE (decl) == CONST_DECL)
2567     {
2568       *idk = CP_ID_KIND_NONE;
2569       if (!processing_template_decl)
2570         {
2571           used_types_insert (TREE_TYPE (decl));
2572           return DECL_INITIAL (decl);
2573         }
2574       return decl;
2575     }
2576   else
2577     {
2578       bool dependent_p;
2579
2580       /* If the declaration was explicitly qualified indicate
2581          that.  The semantics of `A::f(3)' are different than
2582          `f(3)' if `f' is virtual.  */
2583       *idk = (scope
2584               ? CP_ID_KIND_QUALIFIED
2585               : (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2586                  ? CP_ID_KIND_TEMPLATE_ID
2587                  : CP_ID_KIND_UNQUALIFIED));
2588
2589
2590       /* [temp.dep.expr]
2591
2592          An id-expression is type-dependent if it contains an
2593          identifier that was declared with a dependent type.
2594
2595          The standard is not very specific about an id-expression that
2596          names a set of overloaded functions.  What if some of them
2597          have dependent types and some of them do not?  Presumably,
2598          such a name should be treated as a dependent name.  */
2599       /* Assume the name is not dependent.  */
2600       dependent_p = false;
2601       if (!processing_template_decl)
2602         /* No names are dependent outside a template.  */
2603         ;
2604       /* A template-id where the name of the template was not resolved
2605          is definitely dependent.  */
2606       else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
2607                && (TREE_CODE (TREE_OPERAND (decl, 0))
2608                    == IDENTIFIER_NODE))
2609         dependent_p = true;
2610       /* For anything except an overloaded function, just check its
2611          type.  */
2612       else if (!is_overloaded_fn (decl))
2613         dependent_p
2614           = dependent_type_p (TREE_TYPE (decl));
2615       /* For a set of overloaded functions, check each of the
2616          functions.  */
2617       else
2618         {
2619           tree fns = decl;
2620
2621           if (BASELINK_P (fns))
2622             fns = BASELINK_FUNCTIONS (fns);
2623
2624           /* For a template-id, check to see if the template
2625              arguments are dependent.  */
2626           if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
2627             {
2628               tree args = TREE_OPERAND (fns, 1);
2629               dependent_p = any_dependent_template_arguments_p (args);
2630               /* The functions are those referred to by the
2631                  template-id.  */
2632               fns = TREE_OPERAND (fns, 0);
2633             }
2634
2635           /* If there are no dependent template arguments, go through
2636              the overloaded functions.  */
2637           while (fns && !dependent_p)
2638             {
2639               tree fn = OVL_CURRENT (fns);
2640
2641               /* Member functions of dependent classes are
2642                  dependent.  */
2643               if (TREE_CODE (fn) == FUNCTION_DECL
2644                   && type_dependent_expression_p (fn))
2645                 dependent_p = true;
2646               else if (TREE_CODE (fn) == TEMPLATE_DECL
2647                        && dependent_template_p (fn))
2648                 dependent_p = true;
2649
2650               fns = OVL_NEXT (fns);
2651             }
2652         }
2653
2654       /* If the name was dependent on a template parameter, we will
2655          resolve the name at instantiation time.  */
2656       if (dependent_p)
2657         {
2658           /* Create a SCOPE_REF for qualified names, if the scope is
2659              dependent.  */
2660           if (scope)
2661             {
2662               /* Since this name was dependent, the expression isn't
2663                  constant -- yet.  No error is issued because it might
2664                  be constant when things are instantiated.  */
2665               if (integral_constant_expression_p)
2666                 *non_integral_constant_expression_p = true;
2667               if (TYPE_P (scope))
2668                 {
2669                   if (address_p && done)
2670                     decl = finish_qualified_id_expr (scope, decl,
2671                                                      done, address_p,
2672                                                      template_p,
2673                                                      template_arg_p);
2674                   else if (dependent_type_p (scope))
2675                     decl = build_qualified_name (/*type=*/NULL_TREE,
2676                                                  scope,
2677                                                  id_expression,
2678                                                  template_p);
2679                   else if (DECL_P (decl))
2680                     decl = build_qualified_name (TREE_TYPE (decl),
2681                                                  scope,
2682                                                  id_expression,
2683                                                  template_p);
2684                 }
2685               if (TREE_TYPE (decl))
2686                 decl = convert_from_reference (decl);
2687               return decl;
2688             }
2689           /* A TEMPLATE_ID already contains all the information we
2690              need.  */
2691           if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR)
2692             return id_expression;
2693           *idk = CP_ID_KIND_UNQUALIFIED_DEPENDENT;
2694           /* If we found a variable, then name lookup during the
2695              instantiation will always resolve to the same VAR_DECL
2696              (or an instantiation thereof).  */
2697           if (TREE_CODE (decl) == VAR_DECL
2698               || TREE_CODE (decl) == PARM_DECL)
2699             return convert_from_reference (decl);
2700           /* The same is true for FIELD_DECL, but we also need to
2701              make sure that the syntax is correct.  */
2702           else if (TREE_CODE (decl) == FIELD_DECL)
2703             {
2704               /* Since SCOPE is NULL here, this is an unqualified name.
2705                  Access checking has been performed during name lookup
2706                  already.  Turn off checking to avoid duplicate errors.  */
2707               push_deferring_access_checks (dk_no_check);
2708               decl = finish_non_static_data_member
2709                        (decl, current_class_ref,
2710                         /*qualifying_scope=*/NULL_TREE);
2711               pop_deferring_access_checks ();
2712               return decl;
2713             }
2714           return id_expression;
2715         }
2716
2717       /* Only certain kinds of names are allowed in constant
2718          expression.  Enumerators and template parameters have already
2719          been handled above.  */
2720       if (integral_constant_expression_p
2721           && ! DECL_INTEGRAL_CONSTANT_VAR_P (decl)
2722           && ! builtin_valid_in_constant_expr_p (decl))
2723         {
2724           if (!allow_non_integral_constant_expression_p)
2725             {
2726               error ("%qD cannot appear in a constant-expression", decl);
2727               return error_mark_node;
2728             }
2729           *non_integral_constant_expression_p = true;
2730         }
2731
2732       if (TREE_CODE (decl) == NAMESPACE_DECL)
2733         {
2734           error ("use of namespace %qD as expression", decl);
2735           return error_mark_node;
2736         }
2737       else if (DECL_CLASS_TEMPLATE_P (decl))
2738         {
2739           error ("use of class template %qT as expression", decl);
2740           return error_mark_node;
2741         }
2742       else if (TREE_CODE (decl) == TREE_LIST)
2743         {
2744           /* Ambiguous reference to base members.  */
2745           error ("request for member %qD is ambiguous in "
2746                  "multiple inheritance lattice", id_expression);
2747           print_candidates (decl);
2748           return error_mark_node;
2749         }
2750
2751       /* Mark variable-like entities as used.  Functions are similarly
2752          marked either below or after overload resolution.  */
2753       if (TREE_CODE (decl) == VAR_DECL
2754           || TREE_CODE (decl) == PARM_DECL
2755           || TREE_CODE (decl) == RESULT_DECL)
2756         mark_used (decl);
2757
2758       if (scope)
2759         {
2760           decl = (adjust_result_of_qualified_name_lookup
2761                   (decl, scope, current_class_type));
2762
2763           if (TREE_CODE (decl) == FUNCTION_DECL)
2764             mark_used (decl);
2765
2766           if (TREE_CODE (decl) == FIELD_DECL || BASELINK_P (decl))
2767             decl = finish_qualified_id_expr (scope,
2768                                              decl,
2769                                              done,
2770                                              address_p,
2771                                              template_p,
2772                                              template_arg_p);
2773           else
2774             {
2775               tree r = convert_from_reference (decl);
2776
2777               if (processing_template_decl && TYPE_P (scope))
2778                 r = build_qualified_name (TREE_TYPE (r),
2779                                           scope, decl,
2780                                           template_p);
2781               decl = r;
2782             }
2783         }
2784       else if (TREE_CODE (decl) == FIELD_DECL)
2785         {
2786           /* Since SCOPE is NULL here, this is an unqualified name.
2787              Access checking has been performed during name lookup
2788              already.  Turn off checking to avoid duplicate errors.  */
2789           push_deferring_access_checks (dk_no_check);
2790           decl = finish_non_static_data_member (decl, current_class_ref,
2791                                                 /*qualifying_scope=*/NULL_TREE);
2792           pop_deferring_access_checks ();
2793         }
2794       else if (is_overloaded_fn (decl))
2795         {
2796           tree first_fn = OVL_CURRENT (decl);
2797
2798           if (TREE_CODE (first_fn) == TEMPLATE_DECL)
2799             first_fn = DECL_TEMPLATE_RESULT (first_fn);
2800
2801           if (!really_overloaded_fn (decl))
2802             mark_used (first_fn);
2803
2804           if (!template_arg_p
2805               && TREE_CODE (first_fn) == FUNCTION_DECL
2806               && DECL_FUNCTION_MEMBER_P (first_fn)
2807               && !shared_member_p (decl))
2808             {
2809               /* A set of member functions.  */
2810               decl = maybe_dummy_object (DECL_CONTEXT (first_fn), 0);
2811               return finish_class_member_access_expr (decl, id_expression,
2812                                                       /*template_p=*/false);
2813             }
2814         }
2815       else
2816         {
2817           if (DECL_P (decl) && DECL_NONLOCAL (decl)
2818               && DECL_CLASS_SCOPE_P (decl)
2819               && DECL_CONTEXT (decl) != current_class_type)
2820             {
2821               tree path;
2822
2823               path = currently_open_derived_class (DECL_CONTEXT (decl));
2824               perform_or_defer_access_check (TYPE_BINFO (path), decl);
2825             }
2826
2827           decl = convert_from_reference (decl);
2828         }
2829     }
2830
2831   if (TREE_DEPRECATED (decl))
2832     warn_deprecated_use (decl);
2833
2834   return decl;
2835 }
2836
2837 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
2838    use as a type-specifier.  */
2839
2840 tree
2841 finish_typeof (tree expr)
2842 {
2843   tree type;
2844
2845   if (type_dependent_expression_p (expr))
2846     {
2847       type = make_aggr_type (TYPEOF_TYPE);
2848       TYPEOF_TYPE_EXPR (type) = expr;
2849
2850       return type;
2851     }
2852
2853   type = TREE_TYPE (expr);
2854
2855   if (!type || type == unknown_type_node)
2856     {
2857       error ("type of %qE is unknown", expr);
2858       return error_mark_node;
2859     }
2860
2861   return type;
2862 }
2863
2864 /* Perform C++-specific checks for __builtin_offsetof before calling
2865    fold_offsetof.  */
2866
2867 tree
2868 finish_offsetof (tree expr)
2869 {
2870   if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
2871     {
2872       error ("cannot apply %<offsetof%> to destructor %<~%T%>",
2873               TREE_OPERAND (expr, 2));
2874       return error_mark_node;
2875     }
2876   if (TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE
2877       || TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE
2878       || TREE_CODE (TREE_TYPE (expr)) == UNKNOWN_TYPE)
2879     {
2880       if (TREE_CODE (expr) == COMPONENT_REF)
2881         expr = TREE_OPERAND (expr, 1);
2882       error ("cannot apply %<offsetof%> to member function %qD", expr);
2883       return error_mark_node;
2884     }
2885   return fold_offsetof (expr, NULL_TREE);
2886 }
2887
2888 /* Called from expand_body via walk_tree.  Replace all AGGR_INIT_EXPRs
2889    with equivalent CALL_EXPRs.  */
2890
2891 static tree
2892 simplify_aggr_init_exprs_r (tree* tp,
2893                             int* walk_subtrees,
2894                             void* data ATTRIBUTE_UNUSED)
2895 {
2896   /* We don't need to walk into types; there's nothing in a type that
2897      needs simplification.  (And, furthermore, there are places we
2898      actively don't want to go.  For example, we don't want to wander
2899      into the default arguments for a FUNCTION_DECL that appears in a
2900      CALL_EXPR.)  */
2901   if (TYPE_P (*tp))
2902     {
2903       *walk_subtrees = 0;
2904       return NULL_TREE;
2905     }
2906   /* Only AGGR_INIT_EXPRs are interesting.  */
2907   else if (TREE_CODE (*tp) != AGGR_INIT_EXPR)
2908     return NULL_TREE;
2909
2910   simplify_aggr_init_expr (tp);
2911
2912   /* Keep iterating.  */
2913   return NULL_TREE;
2914 }
2915
2916 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR.  This
2917    function is broken out from the above for the benefit of the tree-ssa
2918    project.  */
2919
2920 void
2921 simplify_aggr_init_expr (tree *tp)
2922 {
2923   tree aggr_init_expr = *tp;
2924
2925   /* Form an appropriate CALL_EXPR.  */
2926   tree fn = TREE_OPERAND (aggr_init_expr, 0);
2927   tree args = TREE_OPERAND (aggr_init_expr, 1);
2928   tree slot = TREE_OPERAND (aggr_init_expr, 2);
2929   tree type = TREE_TYPE (slot);
2930
2931   tree call_expr;
2932   enum style_t { ctor, arg, pcc } style;
2933
2934   if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr))
2935     style = ctor;
2936 #ifdef PCC_STATIC_STRUCT_RETURN
2937   else if (1)
2938     style = pcc;
2939 #endif
2940   else
2941     {
2942       gcc_assert (TREE_ADDRESSABLE (type));
2943       style = arg;
2944     }
2945
2946   if (style == ctor)
2947     {
2948       /* Replace the first argument to the ctor with the address of the
2949          slot.  */
2950       tree addr;
2951
2952       args = TREE_CHAIN (args);
2953       cxx_mark_addressable (slot);
2954       addr = build1 (ADDR_EXPR, build_pointer_type (type), slot);
2955       args = tree_cons (NULL_TREE, addr, args);
2956     }
2957
2958   call_expr = build3 (CALL_EXPR,
2959                       TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
2960                       fn, args, NULL_TREE);
2961
2962   if (style == arg)
2963     {
2964       /* Just mark it addressable here, and leave the rest to
2965          expand_call{,_inline}.  */
2966       cxx_mark_addressable (slot);
2967       CALL_EXPR_RETURN_SLOT_OPT (call_expr) = true;
2968       call_expr = build2 (MODIFY_EXPR, TREE_TYPE (call_expr), slot, call_expr);
2969     }
2970   else if (style == pcc)
2971     {
2972       /* If we're using the non-reentrant PCC calling convention, then we
2973          need to copy the returned value out of the static buffer into the
2974          SLOT.  */
2975       push_deferring_access_checks (dk_no_check);
2976       call_expr = build_aggr_init (slot, call_expr,
2977                                    DIRECT_BIND | LOOKUP_ONLYCONVERTING);
2978       pop_deferring_access_checks ();
2979       call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (slot), call_expr, slot);
2980     }
2981
2982   *tp = call_expr;
2983 }
2984
2985 /* Emit all thunks to FN that should be emitted when FN is emitted.  */
2986
2987 static void
2988 emit_associated_thunks (tree fn)
2989 {
2990   /* When we use vcall offsets, we emit thunks with the virtual
2991      functions to which they thunk. The whole point of vcall offsets
2992      is so that you can know statically the entire set of thunks that
2993      will ever be needed for a given virtual function, thereby
2994      enabling you to output all the thunks with the function itself.  */
2995   if (DECL_VIRTUAL_P (fn))
2996     {
2997       tree thunk;
2998
2999       for (thunk = DECL_THUNKS (fn); thunk; thunk = TREE_CHAIN (thunk))
3000         {
3001           if (!THUNK_ALIAS (thunk))
3002             {
3003               use_thunk (thunk, /*emit_p=*/1);
3004               if (DECL_RESULT_THUNK_P (thunk))
3005                 {
3006                   tree probe;
3007
3008                   for (probe = DECL_THUNKS (thunk);
3009                        probe; probe = TREE_CHAIN (probe))
3010                     use_thunk (probe, /*emit_p=*/1);
3011                 }
3012             }
3013           else
3014             gcc_assert (!DECL_THUNKS (thunk));
3015         }
3016     }
3017 }
3018
3019 /* Generate RTL for FN.  */
3020
3021 void
3022 expand_body (tree fn)
3023 {
3024   tree saved_function;
3025
3026   /* Compute the appropriate object-file linkage for inline
3027      functions.  */
3028   if (DECL_DECLARED_INLINE_P (fn))
3029     import_export_decl (fn);
3030
3031   /* If FN is external, then there's no point in generating RTL for
3032      it.  This situation can arise with an inline function under
3033      `-fexternal-templates'; we instantiate the function, even though
3034      we're not planning on emitting it, in case we get a chance to
3035      inline it.  */
3036   if (DECL_EXTERNAL (fn))
3037     return;
3038
3039   /* ??? When is this needed?  */
3040   saved_function = current_function_decl;
3041
3042   /* Emit any thunks that should be emitted at the same time as FN.  */
3043   emit_associated_thunks (fn);
3044
3045   /* This function is only called from cgraph, or recursively from
3046      emit_associated_thunks.  In neither case should we be currently
3047      generating trees for a function.  */
3048   gcc_assert (function_depth == 0);
3049
3050   tree_rest_of_compilation (fn);
3051
3052   current_function_decl = saved_function;
3053
3054   if (DECL_CLONED_FUNCTION_P (fn))
3055     {
3056       /* If this is a clone, go through the other clones now and mark
3057          their parameters used.  We have to do that here, as we don't
3058          know whether any particular clone will be expanded, and
3059          therefore cannot pick one arbitrarily.  */
3060       tree probe;
3061
3062       for (probe = TREE_CHAIN (DECL_CLONED_FUNCTION (fn));
3063            probe && DECL_CLONED_FUNCTION_P (probe);
3064            probe = TREE_CHAIN (probe))
3065         {
3066           tree parms;
3067
3068           for (parms = DECL_ARGUMENTS (probe);
3069                parms; parms = TREE_CHAIN (parms))
3070             TREE_USED (parms) = 1;
3071         }
3072     }
3073 }
3074
3075 /* Generate RTL for FN.  */
3076
3077 void
3078 expand_or_defer_fn (tree fn)
3079 {
3080   /* When the parser calls us after finishing the body of a template
3081      function, we don't really want to expand the body.  */
3082   if (processing_template_decl)
3083     {
3084       /* Normally, collection only occurs in rest_of_compilation.  So,
3085          if we don't collect here, we never collect junk generated
3086          during the processing of templates until we hit a
3087          non-template function.  It's not safe to do this inside a
3088          nested class, though, as the parser may have local state that
3089          is not a GC root.  */
3090       if (!function_depth)
3091         ggc_collect ();
3092       return;
3093     }
3094
3095   /* Replace AGGR_INIT_EXPRs with appropriate CALL_EXPRs.  */
3096   walk_tree_without_duplicates (&DECL_SAVED_TREE (fn),
3097                                 simplify_aggr_init_exprs_r,
3098                                 NULL);
3099
3100   /* If this is a constructor or destructor body, we have to clone
3101      it.  */
3102   if (maybe_clone_body (fn))
3103     {
3104       /* We don't want to process FN again, so pretend we've written
3105          it out, even though we haven't.  */
3106       TREE_ASM_WRITTEN (fn) = 1;
3107       return;
3108     }
3109
3110   /* If this function is marked with the constructor attribute, add it
3111      to the list of functions to be called along with constructors
3112      from static duration objects.  */
3113   if (DECL_STATIC_CONSTRUCTOR (fn))
3114     static_ctors = tree_cons (NULL_TREE, fn, static_ctors);
3115
3116   /* If this function is marked with the destructor attribute, add it
3117      to the list of functions to be called along with destructors from
3118      static duration objects.  */
3119   if (DECL_STATIC_DESTRUCTOR (fn))
3120     static_dtors = tree_cons (NULL_TREE, fn, static_dtors);
3121
3122   /* We make a decision about linkage for these functions at the end
3123      of the compilation.  Until that point, we do not want the back
3124      end to output them -- but we do want it to see the bodies of
3125      these functions so that it can inline them as appropriate.  */
3126   if (DECL_DECLARED_INLINE_P (fn) || DECL_IMPLICIT_INSTANTIATION (fn))
3127     {
3128       if (DECL_INTERFACE_KNOWN (fn))
3129         /* We've already made a decision as to how this function will
3130            be handled.  */;
3131       else if (!at_eof)
3132         {
3133           DECL_EXTERNAL (fn) = 1;
3134           DECL_NOT_REALLY_EXTERN (fn) = 1;
3135           note_vague_linkage_fn (fn);
3136           /* A non-template inline function with external linkage will
3137              always be COMDAT.  As we must eventually determine the
3138              linkage of all functions, and as that causes writes to
3139              the data mapped in from the PCH file, it's advantageous
3140              to mark the functions at this point.  */
3141           if (!DECL_IMPLICIT_INSTANTIATION (fn))
3142             {
3143               /* This function must have external linkage, as
3144                  otherwise DECL_INTERFACE_KNOWN would have been
3145                  set.  */
3146               gcc_assert (TREE_PUBLIC (fn));
3147               comdat_linkage (fn);
3148               DECL_INTERFACE_KNOWN (fn) = 1;
3149             }
3150         }
3151       else
3152         import_export_decl (fn);
3153
3154       /* If the user wants us to keep all inline functions, then mark
3155          this function as needed so that finish_file will make sure to
3156          output it later.  */
3157       if (flag_keep_inline_functions && DECL_DECLARED_INLINE_P (fn))
3158         mark_needed (fn);
3159     }
3160
3161   /* There's no reason to do any of the work here if we're only doing
3162      semantic analysis; this code just generates RTL.  */
3163   if (flag_syntax_only)
3164     return;
3165
3166   function_depth++;
3167
3168   /* Expand or defer, at the whim of the compilation unit manager.  */
3169   cgraph_finalize_function (fn, function_depth > 1);
3170
3171   function_depth--;
3172 }
3173
3174 struct nrv_data
3175 {
3176   tree var;
3177   tree result;
3178   htab_t visited;
3179 };
3180
3181 /* Helper function for walk_tree, used by finalize_nrv below.  */
3182
3183 static tree
3184 finalize_nrv_r (tree* tp, int* walk_subtrees, void* data)
3185 {
3186   struct nrv_data *dp = (struct nrv_data *)data;
3187   void **slot;
3188
3189   /* No need to walk into types.  There wouldn't be any need to walk into
3190      non-statements, except that we have to consider STMT_EXPRs.  */
3191   if (TYPE_P (*tp))
3192     *walk_subtrees = 0;
3193   /* Change all returns to just refer to the RESULT_DECL; this is a nop,
3194      but differs from using NULL_TREE in that it indicates that we care
3195      about the value of the RESULT_DECL.  */
3196   else if (TREE_CODE (*tp) == RETURN_EXPR)
3197     TREE_OPERAND (*tp, 0) = dp->result;
3198   /* Change all cleanups for the NRV to only run when an exception is
3199      thrown.  */
3200   else if (TREE_CODE (*tp) == CLEANUP_STMT
3201            && CLEANUP_DECL (*tp) == dp->var)
3202     CLEANUP_EH_ONLY (*tp) = 1;
3203   /* Replace the DECL_EXPR for the NRV with an initialization of the
3204      RESULT_DECL, if needed.  */
3205   else if (TREE_CODE (*tp) == DECL_EXPR
3206            && DECL_EXPR_DECL (*tp) == dp->var)
3207     {
3208       tree init;
3209       if (DECL_INITIAL (dp->var)
3210           && DECL_INITIAL (dp->var) != error_mark_node)
3211         {
3212           init = build2 (INIT_EXPR, void_type_node, dp->result,
3213                          DECL_INITIAL (dp->var));
3214           DECL_INITIAL (dp->var) = error_mark_node;
3215         }
3216       else
3217         init = build_empty_stmt ();
3218       SET_EXPR_LOCUS (init, EXPR_LOCUS (*tp));
3219       *tp = init;
3220     }
3221   /* And replace all uses of the NRV with the RESULT_DECL.  */
3222   else if (*tp == dp->var)
3223     *tp = dp->result;
3224
3225   /* Avoid walking into the same tree more than once.  Unfortunately, we
3226      can't just use walk_tree_without duplicates because it would only call
3227      us for the first occurrence of dp->var in the function body.  */
3228   slot = htab_find_slot (dp->visited, *tp, INSERT);
3229   if (*slot)
3230     *walk_subtrees = 0;
3231   else
3232     *slot = *tp;
3233
3234   /* Keep iterating.  */
3235   return NULL_TREE;
3236 }
3237
3238 /* Called from finish_function to implement the named return value
3239    optimization by overriding all the RETURN_EXPRs and pertinent
3240    CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
3241    RESULT_DECL for the function.  */
3242
3243 void
3244 finalize_nrv (tree *tp, tree var, tree result)
3245 {
3246   struct nrv_data data;
3247
3248   /* Copy debugging information from VAR to RESULT.  */
3249   DECL_NAME (result) = DECL_NAME (var);
3250   DECL_ARTIFICIAL (result) = DECL_ARTIFICIAL (var);
3251   DECL_IGNORED_P (result) = DECL_IGNORED_P (var);
3252   DECL_SOURCE_LOCATION (result) = DECL_SOURCE_LOCATION (var);
3253   DECL_ABSTRACT_ORIGIN (result) = DECL_ABSTRACT_ORIGIN (var);
3254   /* Don't forget that we take its address.  */
3255   TREE_ADDRESSABLE (result) = TREE_ADDRESSABLE (var);
3256
3257   data.var = var;
3258   data.result = result;
3259   data.visited = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
3260   walk_tree (tp, finalize_nrv_r, &data, 0);
3261   htab_delete (data.visited);
3262 }
3263 \f
3264 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
3265    Remove any elements from the list that are invalid.  */
3266
3267 tree
3268 finish_omp_clauses (tree clauses)
3269 {
3270   bitmap_head generic_head, firstprivate_head, lastprivate_head;
3271   tree c, t, *pc = &clauses;
3272   const char *name;
3273
3274   bitmap_obstack_initialize (NULL);
3275   bitmap_initialize (&generic_head, &bitmap_default_obstack);
3276   bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
3277   bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);
3278
3279   for (pc = &clauses, c = clauses; c ; c = *pc)
3280     {
3281       bool remove = false;
3282
3283       switch (OMP_CLAUSE_CODE (c))
3284         {
3285         case OMP_CLAUSE_SHARED:
3286           name = "shared";
3287           goto check_dup_generic;
3288         case OMP_CLAUSE_PRIVATE:
3289           name = "private";
3290           goto check_dup_generic;
3291         case OMP_CLAUSE_REDUCTION:
3292           name = "reduction";
3293           goto check_dup_generic;
3294         case OMP_CLAUSE_COPYPRIVATE:
3295           name = "copyprivate";
3296           goto check_dup_generic;
3297         case OMP_CLAUSE_COPYIN:
3298           name = "copyin";
3299           goto check_dup_generic;
3300         check_dup_generic:
3301           t = OMP_CLAUSE_DECL (c);
3302           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3303             {
3304               if (processing_template_decl)
3305                 break;
3306               error ("%qE is not a variable in clause %qs", t, name);
3307               remove = true;
3308             }
3309           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
3310                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t))
3311                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
3312             {
3313               error ("%qE appears more than once in data clauses", t);
3314               remove = true;
3315             }
3316           else
3317             bitmap_set_bit (&generic_head, DECL_UID (t));
3318           break;
3319
3320         case OMP_CLAUSE_FIRSTPRIVATE:
3321           t = OMP_CLAUSE_DECL (c);
3322           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3323             {
3324               if (processing_template_decl)
3325                 break;
3326               error ("%qE is not a variable in clause %<firstprivate%>", t);
3327               remove = true;
3328             }
3329           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
3330                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
3331             {
3332               error ("%qE appears more than once in data clauses", t);
3333               remove = true;
3334             }
3335           else
3336             bitmap_set_bit (&firstprivate_head, DECL_UID (t));
3337           break;
3338
3339         case OMP_CLAUSE_LASTPRIVATE:
3340           t = OMP_CLAUSE_DECL (c);
3341           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3342             {
3343               if (processing_template_decl)
3344                 break;
3345               error ("%qE is not a variable in clause %<lastprivate%>", t);
3346               remove = true;
3347             }
3348           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
3349                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
3350             {
3351               error ("%qE appears more than once in data clauses", t);
3352               remove = true;
3353             }
3354           else
3355             bitmap_set_bit (&lastprivate_head, DECL_UID (t));
3356           break;
3357
3358         case OMP_CLAUSE_IF:
3359           t = OMP_CLAUSE_IF_EXPR (c);
3360           t = maybe_convert_cond (t);
3361           if (t == error_mark_node)
3362             remove = true;
3363           OMP_CLAUSE_IF_EXPR (c) = t;
3364           break;
3365
3366         case OMP_CLAUSE_NUM_THREADS:
3367           t = OMP_CLAUSE_NUM_THREADS_EXPR (c);
3368           if (t == error_mark_node)
3369             remove = true;
3370           else if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
3371                    && !type_dependent_expression_p (t))
3372             {
3373               error ("num_threads expression must be integral");
3374               remove = true;
3375             }
3376           break;
3377
3378         case OMP_CLAUSE_SCHEDULE:
3379           t = OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c);
3380           if (t == NULL)
3381             ;
3382           else if (t == error_mark_node)
3383             remove = true;
3384           else if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
3385                    && !type_dependent_expression_p (t))
3386             {
3387               error ("schedule chunk size expression must be integral");
3388               remove = true;
3389             }
3390           break;
3391
3392         case OMP_CLAUSE_NOWAIT:
3393         case OMP_CLAUSE_ORDERED:
3394         case OMP_CLAUSE_DEFAULT:
3395           break;
3396
3397         default:
3398           gcc_unreachable ();
3399         }
3400
3401       if (remove)
3402         *pc = OMP_CLAUSE_CHAIN (c);
3403       else
3404         pc = &OMP_CLAUSE_CHAIN (c);
3405     }
3406
3407   for (pc = &clauses, c = clauses; c ; c = *pc)
3408     {
3409       enum tree_code c_kind = OMP_CLAUSE_CODE (c);
3410       bool remove = false;
3411       bool need_complete_non_reference = false;
3412       bool need_default_ctor = false;
3413       bool need_copy_ctor = false;
3414       bool need_copy_assignment = false;
3415       bool need_implicitly_determined = false;
3416       tree type, inner_type;
3417
3418       switch (c_kind)
3419         {
3420         case OMP_CLAUSE_SHARED:
3421           name = "shared";
3422           need_implicitly_determined = true;
3423           break;
3424         case OMP_CLAUSE_PRIVATE:
3425           name = "private";
3426           need_complete_non_reference = true;
3427           need_default_ctor = true;
3428           need_implicitly_determined = true;
3429           break;
3430         case OMP_CLAUSE_FIRSTPRIVATE:
3431           name = "firstprivate";
3432           need_complete_non_reference = true;
3433           need_copy_ctor = true;
3434           need_implicitly_determined = true;
3435           break;
3436         case OMP_CLAUSE_LASTPRIVATE:
3437           name = "lastprivate";
3438           need_complete_non_reference = true;
3439           need_copy_assignment = true;
3440           need_implicitly_determined = true;
3441           break;
3442         case OMP_CLAUSE_REDUCTION:
3443           name = "reduction";
3444           need_implicitly_determined = true;
3445           break;
3446         case OMP_CLAUSE_COPYPRIVATE:
3447           name = "copyprivate";
3448           need_copy_assignment = true;
3449           break;
3450         case OMP_CLAUSE_COPYIN:
3451           name = "copyin";
3452           need_copy_assignment = true;
3453           break;
3454         default:
3455           pc = &OMP_CLAUSE_CHAIN (c);
3456           continue;
3457         }
3458
3459       t = OMP_CLAUSE_DECL (c);
3460       if (processing_template_decl
3461           && TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
3462         {
3463           pc = &OMP_CLAUSE_CHAIN (c);
3464           continue;
3465         }
3466
3467       switch (c_kind)
3468         {
3469         case OMP_CLAUSE_LASTPRIVATE:
3470           if (!bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
3471             need_default_ctor = true;
3472           break;
3473
3474         case OMP_CLAUSE_REDUCTION:
3475           if (AGGREGATE_TYPE_P (TREE_TYPE (t))
3476               || POINTER_TYPE_P (TREE_TYPE (t)))
3477             {
3478               error ("%qE has invalid type for %<reduction%>", t);
3479               remove = true;
3480             }
3481           else if (FLOAT_TYPE_P (TREE_TYPE (t)))
3482             {
3483               enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c);
3484               switch (r_code)
3485                 {
3486                 case PLUS_EXPR:
3487                 case MULT_EXPR:
3488                 case MINUS_EXPR:
3489                   break;
3490                 default:
3491                   error ("%qE has invalid type for %<reduction(%s)%>",
3492                          t, operator_name_info[r_code].name);
3493                   remove = true;
3494                 }
3495             }
3496           break;
3497
3498         case OMP_CLAUSE_COPYIN:
3499           if (TREE_CODE (t) != VAR_DECL || !DECL_THREAD_LOCAL_P (t))
3500             {
3501               error ("%qE must be %<threadprivate%> for %<copyin%>", t);
3502               remove = true;
3503             }
3504           break;
3505
3506         default:
3507           break;
3508         }
3509
3510       if (need_complete_non_reference)
3511         {
3512           t = require_complete_type (t);
3513           if (t == error_mark_node)
3514             remove = true;
3515           else if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
3516             {
3517               error ("%qE has reference type for %qs", t, name);
3518               remove = true;
3519             }
3520         }
3521       if (need_implicitly_determined)
3522         {
3523           const char *share_name = NULL;
3524
3525           if (TREE_CODE (t) == VAR_DECL && DECL_THREAD_LOCAL_P (t))
3526             share_name = "threadprivate";
3527           else switch (cxx_omp_predetermined_sharing (t))
3528             {
3529             case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
3530               break;
3531             case OMP_CLAUSE_DEFAULT_SHARED:
3532               share_name = "shared";
3533               break;
3534             case OMP_CLAUSE_DEFAULT_PRIVATE:
3535               share_name = "private";
3536               break;
3537             default:
3538               gcc_unreachable ();
3539             }
3540           if (share_name)
3541             {
3542               error ("%qE is predetermined %qs for %qs",
3543                      t, share_name, name);
3544               remove = true;
3545             }
3546         }
3547
3548       /* We're interested in the base element, not arrays.  */
3549       inner_type = type = TREE_TYPE (t);
3550       while (TREE_CODE (inner_type) == ARRAY_TYPE)
3551         inner_type = TREE_TYPE (inner_type);
3552
3553       /* Check for special function availability by building a call to one.
3554          Save the results, because later we won't be in the right context
3555          for making these queries.  */
3556       if (CLASS_TYPE_P (inner_type)
3557           && (need_default_ctor || need_copy_ctor || need_copy_assignment))
3558         {
3559           int save_errorcount = errorcount;
3560           tree info;
3561
3562           /* Always allocate 3 elements for simplicity.  These are the
3563              function decls for the ctor, dtor, and assignment op.
3564              This layout is known to the three lang hooks,
3565              cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
3566              and cxx_omp_clause_assign_op.  */
3567           info = make_tree_vec (3);
3568           CP_OMP_CLAUSE_INFO (c) = info;
3569
3570           if (need_default_ctor
3571               || (need_copy_ctor
3572                   && !TYPE_HAS_TRIVIAL_INIT_REF (inner_type)))
3573             {
3574               if (need_default_ctor)
3575                 t = NULL;
3576               else
3577                 {
3578                   t = build_int_cst (build_pointer_type (inner_type), 0);
3579                   t = build1 (INDIRECT_REF, inner_type, t);
3580                   t = build_tree_list (NULL, t);
3581                 }
3582               t = build_special_member_call (NULL_TREE,
3583                                              complete_ctor_identifier,
3584                                              t, inner_type, LOOKUP_NORMAL);
3585               t = get_callee_fndecl (t);
3586               TREE_VEC_ELT (info, 0) = t;
3587             }
3588
3589           if ((need_default_ctor || need_copy_ctor)
3590               && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_type))
3591             {
3592               t = build_int_cst (build_pointer_type (inner_type), 0);
3593               t = build1 (INDIRECT_REF, inner_type, t);
3594               t = build_special_member_call (t, complete_dtor_identifier,
3595                                              NULL, inner_type, LOOKUP_NORMAL);
3596               t = get_callee_fndecl (t);
3597               TREE_VEC_ELT (info, 1) = t;
3598             }
3599
3600           if (need_copy_assignment
3601               && !TYPE_HAS_TRIVIAL_ASSIGN_REF (inner_type))
3602             {
3603               t = build_int_cst (build_pointer_type (inner_type), 0);
3604               t = build1 (INDIRECT_REF, inner_type, t);
3605               t = build_special_member_call (t, ansi_assopname (NOP_EXPR),
3606                                              build_tree_list (NULL, t),
3607                                              inner_type, LOOKUP_NORMAL);
3608
3609               /* We'll have called convert_from_reference on the call, which
3610                  may well have added an indirect_ref.  It's unneeded here,
3611                  and in the way, so kill it.  */
3612               if (TREE_CODE (t) == INDIRECT_REF)
3613                 t = TREE_OPERAND (t, 0);
3614
3615               t = get_callee_fndecl (t);
3616               TREE_VEC_ELT (info, 2) = t;
3617             }
3618
3619           if (errorcount != save_errorcount)
3620             remove = true;
3621         }
3622
3623       if (remove)
3624         *pc = OMP_CLAUSE_CHAIN (c);
3625       else
3626         pc = &OMP_CLAUSE_CHAIN (c);
3627     }
3628
3629   bitmap_obstack_release (NULL);
3630   return clauses;
3631 }
3632
3633 /* For all variables in the tree_list VARS, mark them as thread local.  */
3634
3635 void
3636 finish_omp_threadprivate (tree vars)
3637 {
3638   tree t;
3639
3640   /* Mark every variable in VARS to be assigned thread local storage.  */
3641   for (t = vars; t; t = TREE_CHAIN (t))
3642     {
3643       tree v = TREE_PURPOSE (t);
3644
3645       /* If V had already been marked threadprivate, it doesn't matter
3646          whether it had been used prior to this point.  */
3647       if (TREE_USED (v)
3648           && (DECL_LANG_SPECIFIC (v) == NULL
3649               || !CP_DECL_THREADPRIVATE_P (v)))
3650         error ("%qE declared %<threadprivate%> after first use", v);
3651       else if (! TREE_STATIC (v) && ! DECL_EXTERNAL (v))
3652         error ("automatic variable %qE cannot be %<threadprivate%>", v);
3653       else if (! COMPLETE_TYPE_P (TREE_TYPE (v)))
3654         error ("%<threadprivate%> %qE has incomplete type", v);
3655       else if (TREE_STATIC (v) && TYPE_P (CP_DECL_CONTEXT (v)))
3656         error ("%<threadprivate%> %qE is not file, namespace "
3657                "or block scope variable", v);
3658       else
3659         {
3660           /* Allocate a LANG_SPECIFIC structure for V, if needed.  */
3661           if (DECL_LANG_SPECIFIC (v) == NULL)
3662             {
3663               retrofit_lang_decl (v);
3664
3665               /* Make sure that DECL_DISCRIMINATOR_P continues to be true
3666                  after the allocation of the lang_decl structure.  */
3667               if (DECL_DISCRIMINATOR_P (v))
3668                 DECL_LANG_SPECIFIC (v)->decl_flags.u2sel = 1;
3669             }
3670
3671           if (! DECL_THREAD_LOCAL_P (v))
3672             {
3673               DECL_TLS_MODEL (v) = decl_default_tls_model (v);
3674               /* If rtl has been already set for this var, call
3675                  make_decl_rtl once again, so that encode_section_info
3676                  has a chance to look at the new decl flags.  */
3677               if (DECL_RTL_SET_P (v))
3678                 make_decl_rtl (v);
3679             }
3680           CP_DECL_THREADPRIVATE_P (v) = 1;
3681         }
3682     }
3683 }
3684
3685 /* Build an OpenMP structured block.  */
3686
3687 tree
3688 begin_omp_structured_block (void)
3689 {
3690   return do_pushlevel (sk_omp);
3691 }
3692
3693 tree
3694 finish_omp_structured_block (tree block)
3695 {
3696   return do_poplevel (block);
3697 }
3698
3699 /* Similarly, except force the retention of the BLOCK.  */
3700
3701 tree
3702 begin_omp_parallel (void)
3703 {
3704   keep_next_level (true);
3705   return begin_omp_structured_block ();
3706 }
3707
3708 tree
3709 finish_omp_parallel (tree clauses, tree body)
3710 {
3711   tree stmt;
3712
3713   body = finish_omp_structured_block (body);
3714
3715   stmt = make_node (OMP_PARALLEL);
3716   TREE_TYPE (stmt) = void_type_node;
3717   OMP_PARALLEL_CLAUSES (stmt) = clauses;
3718   OMP_PARALLEL_BODY (stmt) = body;
3719
3720   return add_stmt (stmt);
3721 }
3722
3723 /* Build and validate an OMP_FOR statement.  CLAUSES, BODY, COND, INCR
3724    are directly for their associated operands in the statement.  DECL
3725    and INIT are a combo; if DECL is NULL then INIT ought to be a
3726    MODIFY_EXPR, and the DECL should be extracted.  PRE_BODY are
3727    optional statements that need to go before the loop into its
3728    sk_omp scope.  */
3729
3730 tree
3731 finish_omp_for (location_t locus, tree decl, tree init, tree cond,
3732                 tree incr, tree body, tree pre_body)
3733 {
3734   if (decl == NULL)
3735     {
3736       if (init != NULL)
3737         switch (TREE_CODE (init))
3738           {
3739           case MODIFY_EXPR:
3740             decl = TREE_OPERAND (init, 0);
3741             init = TREE_OPERAND (init, 1);
3742             break;
3743           case MODOP_EXPR:
3744             if (TREE_CODE (TREE_OPERAND (init, 1)) == NOP_EXPR)
3745               {
3746                 decl = TREE_OPERAND (init, 0);
3747                 init = TREE_OPERAND (init, 2);
3748               }
3749             break;
3750           default:
3751             break;
3752           }
3753
3754       if (decl == NULL)
3755         {
3756           error ("expected iteration declaration or initialization");
3757           return NULL;
3758         }
3759     }
3760
3761   if (type_dependent_expression_p (decl)
3762       || type_dependent_expression_p (init)
3763       || (cond && type_dependent_expression_p (cond))
3764       || (incr && type_dependent_expression_p (incr)))
3765     {
3766       tree stmt;
3767
3768       if (cond == NULL)
3769         {
3770           error ("%Hmissing controlling predicate", &locus);
3771           return NULL;
3772         }
3773
3774       if (incr == NULL)
3775         {
3776           error ("%Hmissing increment expression", &locus);
3777           return NULL;
3778         }
3779
3780       stmt = make_node (OMP_FOR);
3781
3782       /* This is really just a place-holder.  We'll be decomposing this
3783          again and going through the build_modify_expr path below when
3784          we instantiate the thing.  */
3785       init = build2 (MODIFY_EXPR, void_type_node, decl, init);
3786
3787       TREE_TYPE (stmt) = void_type_node;
3788       OMP_FOR_INIT (stmt) = init;
3789       OMP_FOR_COND (stmt) = cond;
3790       OMP_FOR_INCR (stmt) = incr;
3791       OMP_FOR_BODY (stmt) = body;
3792       OMP_FOR_PRE_BODY (stmt) = pre_body;
3793
3794       SET_EXPR_LOCATION (stmt, locus);
3795       return add_stmt (stmt);
3796     }
3797
3798   if (!DECL_P (decl))
3799     {
3800       error ("expected iteration declaration or initialization");
3801       return NULL;
3802     }
3803
3804   if (pre_body == NULL || IS_EMPTY_STMT (pre_body))
3805     pre_body = NULL;
3806   else if (! processing_template_decl)
3807     {
3808       add_stmt (pre_body);
3809       pre_body = NULL;
3810     }
3811   init = build_modify_expr (decl, NOP_EXPR, init);
3812   return c_finish_omp_for (locus, decl, init, cond, incr, body, pre_body);
3813 }
3814
3815 void
3816 finish_omp_atomic (enum tree_code code, tree lhs, tree rhs)
3817 {
3818   tree orig_lhs;
3819   tree orig_rhs;
3820   bool dependent_p;
3821   tree stmt;
3822
3823   orig_lhs = lhs;
3824   orig_rhs = rhs;
3825   dependent_p = false;
3826   stmt = NULL_TREE;
3827
3828   /* Even in a template, we can detect invalid uses of the atomic
3829      pragma if neither LHS nor RHS is type-dependent.  */
3830   if (processing_template_decl)
3831     {
3832       dependent_p = (type_dependent_expression_p (lhs) 
3833                      || type_dependent_expression_p (rhs));
3834       if (!dependent_p)
3835         {
3836           lhs = build_non_dependent_expr (lhs);
3837           rhs = build_non_dependent_expr (rhs);
3838         }
3839     }
3840   if (!dependent_p)
3841     {
3842       stmt = c_finish_omp_atomic (code, lhs, rhs);
3843       if (stmt == error_mark_node)
3844         return;
3845     }
3846   if (processing_template_decl)
3847     {
3848       stmt = build2 (OMP_ATOMIC, void_type_node, orig_lhs, orig_rhs);
3849       OMP_ATOMIC_DEPENDENT_P (stmt) = 1;
3850       OMP_ATOMIC_CODE (stmt) = code;
3851     }
3852   add_stmt (stmt);
3853 }
3854
3855 void
3856 finish_omp_barrier (void)
3857 {
3858   tree fn = built_in_decls[BUILT_IN_GOMP_BARRIER];
3859   tree stmt = finish_call_expr (fn, NULL, false, false);
3860   finish_expr_stmt (stmt);
3861 }
3862
3863 void
3864 finish_omp_flush (void)
3865 {
3866   tree fn = built_in_decls[BUILT_IN_SYNCHRONIZE];
3867   tree stmt = finish_call_expr (fn, NULL, false, false);
3868   finish_expr_stmt (stmt);
3869 }
3870
3871 /* True if OpenMP sharing attribute of DECL is predetermined.  */
3872
3873 enum omp_clause_default_kind
3874 cxx_omp_predetermined_sharing (tree decl)
3875 {
3876   enum omp_clause_default_kind kind;
3877
3878   kind = c_omp_predetermined_sharing (decl);
3879   if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
3880     return kind;
3881
3882   /* Static data members are predetermined as shared.  */
3883   if (TREE_STATIC (decl))
3884     {
3885       tree ctx = CP_DECL_CONTEXT (decl);
3886       if (TYPE_P (ctx) && IS_AGGR_TYPE (ctx))
3887         return OMP_CLAUSE_DEFAULT_SHARED;
3888     }
3889
3890   return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
3891 }
3892 \f
3893 void
3894 init_cp_semantics (void)
3895 {
3896 }
3897
3898 #include "gt-cp-semantics.h"