OSDN Git Service

* dwarf2out.c (dwarf2out_imported_module_or_decl_1): Allow
[pf3gnuchains/gcc-fork.git] / gcc / cp / cp-gimplify.c
1 /* C++-specific tree lowering bits; see also c-gimplify.c and tree-gimple.c.
2
3    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4    Free Software Foundation, Inc.
5    Contributed by Jason Merrill <jason@redhat.com>
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
12 version.
13
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
17 for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3.  If not see
21 <http://www.gnu.org/licenses/>.  */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "tree.h"
28 #include "cp-tree.h"
29 #include "c-common.h"
30 #include "toplev.h"
31 #include "tree-iterator.h"
32 #include "gimple.h"
33 #include "hashtab.h"
34 #include "pointer-set.h"
35 #include "flags.h"
36
37 /* Local declarations.  */
38
39 enum bc_t { bc_break = 0, bc_continue = 1 };
40
41 /* Stack of labels which are targets for "break" or "continue",
42    linked through TREE_CHAIN.  */
43 static tree bc_label[2];
44
45 /* Begin a scope which can be exited by a break or continue statement.  BC
46    indicates which.
47
48    Just creates a label and pushes it into the current context.  */
49
50 static tree
51 begin_bc_block (enum bc_t bc)
52 {
53   tree label = create_artificial_label ();
54   TREE_CHAIN (label) = bc_label[bc];
55   bc_label[bc] = label;
56   return label;
57 }
58
59 /* Finish a scope which can be exited by a break or continue statement.
60    LABEL was returned from the most recent call to begin_bc_block.  BODY is
61    an expression for the contents of the scope.
62
63    If we saw a break (or continue) in the scope, append a LABEL_EXPR to
64    body.  Otherwise, just forget the label.  */
65
66 static gimple_seq
67 finish_bc_block (enum bc_t bc, tree label, gimple_seq body)
68 {
69   gcc_assert (label == bc_label[bc]);
70
71   if (TREE_USED (label))
72     {
73       gimple_seq_add_stmt (&body, gimple_build_label (label));
74     }
75
76   bc_label[bc] = TREE_CHAIN (label);
77   TREE_CHAIN (label) = NULL_TREE;
78   return body;
79 }
80
81 /* Get the LABEL_EXPR to represent a break or continue statement
82    in the current block scope.  BC indicates which.  */
83
84 static tree
85 get_bc_label (enum bc_t bc)
86 {
87   tree label = bc_label[bc];
88
89   if (label == NULL_TREE)
90     {
91       if (bc == bc_break)
92         error ("break statement not within loop or switch");
93       else
94         error ("continue statement not within loop or switch");
95
96       return NULL_TREE;
97     }
98
99   /* Mark the label used for finish_bc_block.  */
100   TREE_USED (label) = 1;
101   return label;
102 }
103
104 /* Genericize a TRY_BLOCK.  */
105
106 static void
107 genericize_try_block (tree *stmt_p)
108 {
109   tree body = TRY_STMTS (*stmt_p);
110   tree cleanup = TRY_HANDLERS (*stmt_p);
111
112   *stmt_p = build2 (TRY_CATCH_EXPR, void_type_node, body, cleanup);
113 }
114
115 /* Genericize a HANDLER by converting to a CATCH_EXPR.  */
116
117 static void
118 genericize_catch_block (tree *stmt_p)
119 {
120   tree type = HANDLER_TYPE (*stmt_p);
121   tree body = HANDLER_BODY (*stmt_p);
122
123   /* FIXME should the caught type go in TREE_TYPE?  */
124   *stmt_p = build2 (CATCH_EXPR, void_type_node, type, body);
125 }
126
127 /* A terser interface for building a representation of an exception
128    specification.  */
129
130 static tree
131 build_gimple_eh_filter_tree (tree body, tree allowed, tree failure)
132 {
133   tree t;
134
135   /* FIXME should the allowed types go in TREE_TYPE?  */
136   t = build2 (EH_FILTER_EXPR, void_type_node, allowed, NULL_TREE);
137   append_to_statement_list (failure, &EH_FILTER_FAILURE (t));
138
139   t = build2 (TRY_CATCH_EXPR, void_type_node, NULL_TREE, t);
140   append_to_statement_list (body, &TREE_OPERAND (t, 0));
141
142   return t;
143 }
144
145 /* Genericize an EH_SPEC_BLOCK by converting it to a
146    TRY_CATCH_EXPR/EH_FILTER_EXPR pair.  */
147
148 static void
149 genericize_eh_spec_block (tree *stmt_p)
150 {
151   tree body = EH_SPEC_STMTS (*stmt_p);
152   tree allowed = EH_SPEC_RAISES (*stmt_p);
153   tree failure = build_call_n (call_unexpected_node, 1, build_exc_ptr ());
154
155   *stmt_p = build_gimple_eh_filter_tree (body, allowed, failure);
156 }
157
158 /* Genericize an IF_STMT by turning it into a COND_EXPR.  */
159
160 static void
161 genericize_if_stmt (tree *stmt_p)
162 {
163   tree stmt, cond, then_, else_;
164   location_t locus = EXPR_LOCATION (*stmt_p);
165
166   stmt = *stmt_p;
167   cond = IF_COND (stmt);
168   then_ = THEN_CLAUSE (stmt);
169   else_ = ELSE_CLAUSE (stmt);
170
171   if (!then_)
172     then_ = build_empty_stmt ();
173   if (!else_)
174     else_ = build_empty_stmt ();
175
176   if (integer_nonzerop (cond) && !TREE_SIDE_EFFECTS (else_))
177     stmt = then_;
178   else if (integer_zerop (cond) && !TREE_SIDE_EFFECTS (then_))
179     stmt = else_;
180   else
181     stmt = build3 (COND_EXPR, void_type_node, cond, then_, else_);
182   if (CAN_HAVE_LOCATION_P (stmt) && !EXPR_HAS_LOCATION (stmt))
183     SET_EXPR_LOCATION (stmt, locus);
184   *stmt_p = stmt;
185 }
186
187 /* Build a generic representation of one of the C loop forms.  COND is the
188    loop condition or NULL_TREE.  BODY is the (possibly compound) statement
189    controlled by the loop.  INCR is the increment expression of a for-loop,
190    or NULL_TREE.  COND_IS_FIRST indicates whether the condition is
191    evaluated before the loop body as in while and for loops, or after the
192    loop body as in do-while loops.  */
193
194 static gimple_seq
195 gimplify_cp_loop (tree cond, tree body, tree incr, bool cond_is_first)
196 {
197   gimple top, entry, stmt;
198   gimple_seq stmt_list, body_seq, incr_seq, exit_seq;
199   tree cont_block, break_block;
200   location_t stmt_locus;
201
202   stmt_locus = input_location;
203   stmt_list = NULL;
204   body_seq = NULL;
205   incr_seq = NULL;
206   exit_seq = NULL;
207   entry = NULL;
208
209   break_block = begin_bc_block (bc_break);
210   cont_block = begin_bc_block (bc_continue);
211
212   /* If condition is zero don't generate a loop construct.  */
213   if (cond && integer_zerop (cond))
214     {
215       top = NULL;
216       if (cond_is_first)
217         {
218           stmt = gimple_build_goto (get_bc_label (bc_break));
219           gimple_set_location (stmt, stmt_locus);
220           gimple_seq_add_stmt (&stmt_list, stmt);
221         }
222     }
223   else
224     {
225       /* If we use a LOOP_EXPR here, we have to feed the whole thing
226          back through the main gimplifier to lower it.  Given that we
227          have to gimplify the loop body NOW so that we can resolve
228          break/continue stmts, seems easier to just expand to gotos.  */
229       top = gimple_build_label (create_artificial_label ());
230
231       /* If we have an exit condition, then we build an IF with gotos either
232          out of the loop, or to the top of it.  If there's no exit condition,
233          then we just build a jump back to the top.  */
234       if (cond && !integer_nonzerop (cond))
235         {
236           if (cond != error_mark_node)
237             { 
238               gimplify_expr (&cond, &exit_seq, NULL, is_gimple_val, fb_rvalue);
239               stmt = gimple_build_cond (NE_EXPR, cond,
240                                         build_int_cst (TREE_TYPE (cond), 0),
241                                         gimple_label_label (top),
242                                         get_bc_label (bc_break));
243               gimple_seq_add_stmt (&exit_seq, stmt);
244             }
245
246           if (cond_is_first)
247             {
248               if (incr)
249                 {
250                   entry = gimple_build_label (create_artificial_label ());
251                   stmt = gimple_build_goto (gimple_label_label (entry));
252                 }
253               else
254                 stmt = gimple_build_goto (get_bc_label (bc_continue));
255               gimple_set_location (stmt, stmt_locus);
256               gimple_seq_add_stmt (&stmt_list, stmt);
257             }
258         }
259       else
260         {
261           stmt = gimple_build_goto (gimple_label_label (top));
262           gimple_seq_add_stmt (&exit_seq, stmt);
263         }
264     }
265
266   gimplify_stmt (&body, &body_seq);
267   gimplify_stmt (&incr, &incr_seq);
268
269   body_seq = finish_bc_block (bc_continue, cont_block, body_seq);
270
271   gimple_seq_add_stmt (&stmt_list, top);
272   gimple_seq_add_seq (&stmt_list, body_seq);
273   gimple_seq_add_seq (&stmt_list, incr_seq);
274   gimple_seq_add_stmt (&stmt_list, entry);
275   gimple_seq_add_seq (&stmt_list, exit_seq);
276
277   annotate_all_with_location (stmt_list, stmt_locus);
278
279   return finish_bc_block (bc_break, break_block, stmt_list);
280 }
281
282 /* Gimplify a FOR_STMT node.  Move the stuff in the for-init-stmt into the
283    prequeue and hand off to gimplify_cp_loop.  */
284
285 static void
286 gimplify_for_stmt (tree *stmt_p, gimple_seq *pre_p)
287 {
288   tree stmt = *stmt_p;
289
290   if (FOR_INIT_STMT (stmt))
291     gimplify_and_add (FOR_INIT_STMT (stmt), pre_p);
292
293   gimple_seq_add_seq (pre_p,
294                       gimplify_cp_loop (FOR_COND (stmt), FOR_BODY (stmt),
295                                         FOR_EXPR (stmt), 1));
296   *stmt_p = NULL_TREE;
297 }
298
299 /* Gimplify a WHILE_STMT node.  */
300
301 static void
302 gimplify_while_stmt (tree *stmt_p, gimple_seq *pre_p)
303 {
304   tree stmt = *stmt_p;
305   gimple_seq_add_seq (pre_p,
306                       gimplify_cp_loop (WHILE_COND (stmt), WHILE_BODY (stmt),
307                                         NULL_TREE, 1));
308   *stmt_p = NULL_TREE;
309 }
310
311 /* Gimplify a DO_STMT node.  */
312
313 static void
314 gimplify_do_stmt (tree *stmt_p, gimple_seq *pre_p)
315 {
316   tree stmt = *stmt_p;
317   gimple_seq_add_seq (pre_p,
318                       gimplify_cp_loop (DO_COND (stmt), DO_BODY (stmt),
319                                         NULL_TREE, 0));
320   *stmt_p = NULL_TREE;
321 }
322
323 /* Genericize a SWITCH_STMT by turning it into a SWITCH_EXPR.  */
324
325 static void
326 gimplify_switch_stmt (tree *stmt_p, gimple_seq *pre_p)
327 {
328   tree stmt = *stmt_p;
329   tree break_block, body, t;
330   location_t stmt_locus = input_location;
331   gimple_seq seq = NULL;
332
333   break_block = begin_bc_block (bc_break);
334
335   body = SWITCH_STMT_BODY (stmt);
336   if (!body)
337     body = build_empty_stmt ();
338
339   t = build3 (SWITCH_EXPR, SWITCH_STMT_TYPE (stmt),
340               SWITCH_STMT_COND (stmt), body, NULL_TREE);
341   SET_EXPR_LOCATION (t, stmt_locus);
342   gimplify_and_add (t, &seq);
343
344   seq = finish_bc_block (bc_break, break_block, seq);
345   gimple_seq_add_seq (pre_p, seq);
346   *stmt_p = NULL_TREE;
347 }
348
349 /* Hook into the middle of gimplifying an OMP_FOR node.  This is required
350    in order to properly gimplify CONTINUE statements.  Here we merely
351    manage the continue stack; the rest of the job is performed by the
352    regular gimplifier.  */
353
354 static enum gimplify_status
355 cp_gimplify_omp_for (tree *expr_p, gimple_seq *pre_p)
356 {
357   tree for_stmt = *expr_p;
358   tree cont_block;
359   gimple stmt;
360   gimple_seq seq = NULL;
361
362   /* Protect ourselves from recursion.  */
363   if (OMP_FOR_GIMPLIFYING_P (for_stmt))
364     return GS_UNHANDLED;
365   OMP_FOR_GIMPLIFYING_P (for_stmt) = 1;
366
367   /* Note that while technically the continue label is enabled too soon
368      here, we should have already diagnosed invalid continues nested within
369      statement expressions within the INIT, COND, or INCR expressions.  */
370   cont_block = begin_bc_block (bc_continue);
371
372   gimplify_and_add (for_stmt, &seq);
373   stmt = gimple_seq_last_stmt (seq);
374   if (gimple_code (stmt) == GIMPLE_OMP_FOR)
375     gimple_omp_set_body (stmt, finish_bc_block (bc_continue, cont_block,
376                                                 gimple_omp_body (stmt)));
377   else
378     seq = finish_bc_block (bc_continue, cont_block, seq);
379   gimple_seq_add_seq (pre_p, seq);
380
381   OMP_FOR_GIMPLIFYING_P (for_stmt) = 0;
382
383   return GS_ALL_DONE;
384 }
385
386 /*  Gimplify an EXPR_STMT node.  */
387
388 static void
389 gimplify_expr_stmt (tree *stmt_p)
390 {
391   tree stmt = EXPR_STMT_EXPR (*stmt_p);
392
393   if (stmt == error_mark_node)
394     stmt = NULL;
395
396   /* Gimplification of a statement expression will nullify the
397      statement if all its side effects are moved to *PRE_P and *POST_P.
398
399      In this case we will not want to emit the gimplified statement.
400      However, we may still want to emit a warning, so we do that before
401      gimplification.  */
402   if (stmt && warn_unused_value)
403     {
404       if (!TREE_SIDE_EFFECTS (stmt))
405         {
406           if (!IS_EMPTY_STMT (stmt)
407               && !VOID_TYPE_P (TREE_TYPE (stmt))
408               && !TREE_NO_WARNING (stmt))
409             warning (OPT_Wunused_value, "statement with no effect");
410         }
411       else
412         warn_if_unused_value (stmt, input_location);
413     }
414
415   if (stmt == NULL_TREE)
416     stmt = alloc_stmt_list ();
417
418   *stmt_p = stmt;
419 }
420
421 /* Gimplify initialization from an AGGR_INIT_EXPR.  */
422
423 static void
424 cp_gimplify_init_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
425 {
426   tree from = TREE_OPERAND (*expr_p, 1);
427   tree to = TREE_OPERAND (*expr_p, 0);
428   tree t;
429   tree slot = NULL_TREE;
430
431   /* What about code that pulls out the temp and uses it elsewhere?  I
432      think that such code never uses the TARGET_EXPR as an initializer.  If
433      I'm wrong, we'll abort because the temp won't have any RTL.  In that
434      case, I guess we'll need to replace references somehow.  */
435   if (TREE_CODE (from) == TARGET_EXPR)
436     {
437       slot = TARGET_EXPR_SLOT (from);
438       from = TARGET_EXPR_INITIAL (from);
439     }
440
441   /* Look through any COMPOUND_EXPRs, since build_compound_expr pushes them
442      inside the TARGET_EXPR.  */
443   for (t = from; t; )
444     {
445       tree sub = TREE_CODE (t) == COMPOUND_EXPR ? TREE_OPERAND (t, 0) : t;
446
447       /* If we are initializing from an AGGR_INIT_EXPR, drop the INIT_EXPR and
448          replace the slot operand with our target.
449
450          Should we add a target parm to gimplify_expr instead?  No, as in this
451          case we want to replace the INIT_EXPR.  */
452       if (TREE_CODE (sub) == AGGR_INIT_EXPR)
453         {
454           gimplify_expr (&to, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
455           AGGR_INIT_EXPR_SLOT (sub) = to;
456           *expr_p = from;
457
458           /* The initialization is now a side-effect, so the container can
459              become void.  */
460           if (from != sub)
461             TREE_TYPE (from) = void_type_node;
462         }
463
464       if (t == sub)
465         break;
466       else
467         t = TREE_OPERAND (t, 1);
468     }
469
470 }
471
472 /* Gimplify a MUST_NOT_THROW_EXPR.  */
473
474 static enum gimplify_status
475 gimplify_must_not_throw_expr (tree *expr_p, gimple_seq *pre_p)
476 {
477   tree stmt = *expr_p;
478   tree temp = voidify_wrapper_expr (stmt, NULL);
479   tree body = TREE_OPERAND (stmt, 0);
480
481   stmt = build_gimple_eh_filter_tree (body, NULL_TREE,
482                                       build_call_n (terminate_node, 0));
483
484   gimplify_and_add (stmt, pre_p);
485   if (temp)
486     {
487       *expr_p = temp;
488       return GS_OK;
489     }
490
491   *expr_p = NULL;
492   return GS_ALL_DONE;
493 }
494
495 /* Do C++-specific gimplification.  Args are as for gimplify_expr.  */
496
497 int
498 cp_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
499 {
500   int saved_stmts_are_full_exprs_p = 0;
501   enum tree_code code = TREE_CODE (*expr_p);
502   enum gimplify_status ret;
503   tree block = NULL;
504   VEC(gimple, heap) *bind_expr_stack = NULL;
505
506   if (STATEMENT_CODE_P (code))
507     {
508       saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
509       current_stmt_tree ()->stmts_are_full_exprs_p
510         = STMT_IS_FULL_EXPR_P (*expr_p);
511     }
512
513   switch (code)
514     {
515     case PTRMEM_CST:
516       *expr_p = cplus_expand_constant (*expr_p);
517       ret = GS_OK;
518       break;
519
520     case AGGR_INIT_EXPR:
521       simplify_aggr_init_expr (expr_p);
522       ret = GS_OK;
523       break;
524
525     case THROW_EXPR:
526       /* FIXME communicate throw type to back end, probably by moving
527          THROW_EXPR into ../tree.def.  */
528       *expr_p = TREE_OPERAND (*expr_p, 0);
529       ret = GS_OK;
530       break;
531
532     case MUST_NOT_THROW_EXPR:
533       ret = gimplify_must_not_throw_expr (expr_p, pre_p);
534       break;
535
536       /* We used to do this for MODIFY_EXPR as well, but that's unsafe; the
537          LHS of an assignment might also be involved in the RHS, as in bug
538          25979.  */
539     case INIT_EXPR:
540       cp_gimplify_init_expr (expr_p, pre_p, post_p);
541       ret = GS_OK;
542       break;
543
544     case EMPTY_CLASS_EXPR:
545       /* We create an empty CONSTRUCTOR with RECORD_TYPE.  */
546       *expr_p = build_constructor (TREE_TYPE (*expr_p), NULL);
547       ret = GS_OK;
548       break;
549
550     case BASELINK:
551       *expr_p = BASELINK_FUNCTIONS (*expr_p);
552       ret = GS_OK;
553       break;
554
555     case TRY_BLOCK:
556       genericize_try_block (expr_p);
557       ret = GS_OK;
558       break;
559
560     case HANDLER:
561       genericize_catch_block (expr_p);
562       ret = GS_OK;
563       break;
564
565     case EH_SPEC_BLOCK:
566       genericize_eh_spec_block (expr_p);
567       ret = GS_OK;
568       break;
569
570     case USING_STMT:
571       /* Get the innermost inclosing GIMPLE_BIND that has a non NULL
572          BLOCK, and append an IMPORTED_DECL to its
573          BLOCK_VARS chained list.  */
574
575       bind_expr_stack = gimple_bind_expr_stack ();
576       if (bind_expr_stack)
577         {
578           int i;
579           for (i = VEC_length (gimple, bind_expr_stack) - 1; i >= 0; i--)
580             if ((block = gimple_bind_block (VEC_index (gimple,
581                                                        bind_expr_stack,
582                                                        i))))
583               break;
584         }
585       if (block)
586         {
587           tree using_directive;
588           gcc_assert (TREE_OPERAND (*expr_p, 0));
589
590           using_directive = make_node (IMPORTED_DECL);
591           TREE_TYPE (using_directive) = void_type_node;
592
593           IMPORTED_DECL_ASSOCIATED_DECL (using_directive)
594             = TREE_OPERAND (*expr_p, 0);
595           TREE_CHAIN (using_directive) = BLOCK_VARS (block);
596           BLOCK_VARS (block) = using_directive;
597         }
598       /* The USING_STMT won't appear in GIMPLE.  */
599       *expr_p = NULL;
600       ret = GS_ALL_DONE;
601       break;
602
603     case FOR_STMT:
604       gimplify_for_stmt (expr_p, pre_p);
605       ret = GS_OK;
606       break;
607
608     case WHILE_STMT:
609       gimplify_while_stmt (expr_p, pre_p);
610       ret = GS_OK;
611       break;
612
613     case DO_STMT:
614       gimplify_do_stmt (expr_p, pre_p);
615       ret = GS_OK;
616       break;
617
618     case SWITCH_STMT:
619       gimplify_switch_stmt (expr_p, pre_p);
620       ret = GS_OK;
621       break;
622
623     case OMP_FOR:
624       ret = cp_gimplify_omp_for (expr_p, pre_p);
625       break;
626
627     case CONTINUE_STMT:
628       gimple_seq_add_stmt (pre_p, gimple_build_predict (PRED_CONTINUE, NOT_TAKEN));
629       gimple_seq_add_stmt (pre_p, gimple_build_goto (get_bc_label (bc_continue)));
630       *expr_p = NULL_TREE;
631       ret = GS_ALL_DONE;
632       break;
633
634     case BREAK_STMT:
635       gimple_seq_add_stmt (pre_p, gimple_build_goto (get_bc_label (bc_break)));
636       *expr_p = NULL_TREE;
637       ret = GS_ALL_DONE;
638       break;
639
640     case EXPR_STMT:
641       gimplify_expr_stmt (expr_p);
642       ret = GS_OK;
643       break;
644
645     case UNARY_PLUS_EXPR:
646       {
647         tree arg = TREE_OPERAND (*expr_p, 0);
648         tree type = TREE_TYPE (*expr_p);
649         *expr_p = (TREE_TYPE (arg) != type) ? fold_convert (type, arg)
650                                             : arg;
651         ret = GS_OK;
652       }
653       break;
654
655     default:
656       ret = c_gimplify_expr (expr_p, pre_p, post_p);
657       break;
658     }
659
660   /* Restore saved state.  */
661   if (STATEMENT_CODE_P (code))
662     current_stmt_tree ()->stmts_are_full_exprs_p
663       = saved_stmts_are_full_exprs_p;
664
665   return ret;
666 }
667
668 static inline bool
669 is_invisiref_parm (const_tree t)
670 {
671   return ((TREE_CODE (t) == PARM_DECL || TREE_CODE (t) == RESULT_DECL)
672           && DECL_BY_REFERENCE (t));
673 }
674
675 /* Return true if the uid in both int tree maps are equal.  */
676
677 int
678 cxx_int_tree_map_eq (const void *va, const void *vb)
679 {
680   const struct cxx_int_tree_map *a = (const struct cxx_int_tree_map *) va;
681   const struct cxx_int_tree_map *b = (const struct cxx_int_tree_map *) vb;
682   return (a->uid == b->uid);
683 }
684
685 /* Hash a UID in a cxx_int_tree_map.  */
686
687 unsigned int
688 cxx_int_tree_map_hash (const void *item)
689 {
690   return ((const struct cxx_int_tree_map *)item)->uid;
691 }
692
693 /* Perform any pre-gimplification lowering of C++ front end trees to
694    GENERIC.  */
695
696 static tree
697 cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)
698 {
699   tree stmt = *stmt_p;
700   struct pointer_set_t *p_set = (struct pointer_set_t*) data;
701
702   if (is_invisiref_parm (stmt)
703       /* Don't dereference parms in a thunk, pass the references through. */
704       && !(DECL_THUNK_P (current_function_decl)
705            && TREE_CODE (stmt) == PARM_DECL))
706     {
707       *stmt_p = convert_from_reference (stmt);
708       *walk_subtrees = 0;
709       return NULL;
710     }
711
712   /* Map block scope extern declarations to visible declarations with the
713      same name and type in outer scopes if any.  */
714   if (cp_function_chain->extern_decl_map
715       && (TREE_CODE (stmt) == FUNCTION_DECL || TREE_CODE (stmt) == VAR_DECL)
716       && DECL_EXTERNAL (stmt))
717     {
718       struct cxx_int_tree_map *h, in;
719       in.uid = DECL_UID (stmt);
720       h = (struct cxx_int_tree_map *)
721           htab_find_with_hash (cp_function_chain->extern_decl_map,
722                                &in, in.uid);
723       if (h)
724         {
725           *stmt_p = h->to;
726           *walk_subtrees = 0;
727           return NULL;
728         }
729     }
730
731   /* Other than invisiref parms, don't walk the same tree twice.  */
732   if (pointer_set_contains (p_set, stmt))
733     {
734       *walk_subtrees = 0;
735       return NULL_TREE;
736     }
737
738   if (TREE_CODE (stmt) == ADDR_EXPR
739       && is_invisiref_parm (TREE_OPERAND (stmt, 0)))
740     {
741       *stmt_p = convert (TREE_TYPE (stmt), TREE_OPERAND (stmt, 0));
742       *walk_subtrees = 0;
743     }
744   else if (TREE_CODE (stmt) == RETURN_EXPR
745            && TREE_OPERAND (stmt, 0)
746            && is_invisiref_parm (TREE_OPERAND (stmt, 0)))
747     /* Don't dereference an invisiref RESULT_DECL inside a RETURN_EXPR.  */
748     *walk_subtrees = 0;
749   else if (TREE_CODE (stmt) == OMP_CLAUSE)
750     switch (OMP_CLAUSE_CODE (stmt))
751       {
752       case OMP_CLAUSE_LASTPRIVATE:
753         /* Don't dereference an invisiref in OpenMP clauses.  */
754         if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
755           {
756             *walk_subtrees = 0;
757             if (OMP_CLAUSE_LASTPRIVATE_STMT (stmt))
758               cp_walk_tree (&OMP_CLAUSE_LASTPRIVATE_STMT (stmt),
759                             cp_genericize_r, p_set, NULL);
760           }
761         break;
762       case OMP_CLAUSE_PRIVATE:
763       case OMP_CLAUSE_SHARED:
764       case OMP_CLAUSE_FIRSTPRIVATE:
765       case OMP_CLAUSE_COPYIN:
766       case OMP_CLAUSE_COPYPRIVATE:
767         /* Don't dereference an invisiref in OpenMP clauses.  */
768         if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
769           *walk_subtrees = 0;
770         break;
771       case OMP_CLAUSE_REDUCTION:
772         gcc_assert (!is_invisiref_parm (OMP_CLAUSE_DECL (stmt)));
773         break;
774       default:
775         break;
776       }
777   else if (IS_TYPE_OR_DECL_P (stmt))
778     *walk_subtrees = 0;
779
780   /* Due to the way voidify_wrapper_expr is written, we don't get a chance
781      to lower this construct before scanning it, so we need to lower these
782      before doing anything else.  */
783   else if (TREE_CODE (stmt) == CLEANUP_STMT)
784     *stmt_p = build2 (CLEANUP_EH_ONLY (stmt) ? TRY_CATCH_EXPR
785                                              : TRY_FINALLY_EXPR,
786                       void_type_node,
787                       CLEANUP_BODY (stmt),
788                       CLEANUP_EXPR (stmt));
789
790   else if (TREE_CODE (stmt) == IF_STMT)
791     {
792       genericize_if_stmt (stmt_p);
793       /* *stmt_p has changed, tail recurse to handle it again.  */
794       return cp_genericize_r (stmt_p, walk_subtrees, data);
795     }
796
797   /* COND_EXPR might have incompatible types in branches if one or both
798      arms are bitfields.  Fix it up now.  */
799   else if (TREE_CODE (stmt) == COND_EXPR)
800     {
801       tree type_left
802         = (TREE_OPERAND (stmt, 1)
803            ? is_bitfield_expr_with_lowered_type (TREE_OPERAND (stmt, 1))
804            : NULL_TREE);
805       tree type_right
806         = (TREE_OPERAND (stmt, 2)
807            ? is_bitfield_expr_with_lowered_type (TREE_OPERAND (stmt, 2))
808            : NULL_TREE);
809       if (type_left
810           && !useless_type_conversion_p (TREE_TYPE (stmt),
811                                          TREE_TYPE (TREE_OPERAND (stmt, 1))))
812         {
813           TREE_OPERAND (stmt, 1)
814             = fold_convert (type_left, TREE_OPERAND (stmt, 1));
815           gcc_assert (useless_type_conversion_p (TREE_TYPE (stmt),
816                                                  type_left));
817         }
818       if (type_right
819           && !useless_type_conversion_p (TREE_TYPE (stmt),
820                                          TREE_TYPE (TREE_OPERAND (stmt, 2))))
821         {
822           TREE_OPERAND (stmt, 2)
823             = fold_convert (type_right, TREE_OPERAND (stmt, 2));
824           gcc_assert (useless_type_conversion_p (TREE_TYPE (stmt),
825                                                  type_right));
826         }
827     }
828
829   pointer_set_insert (p_set, *stmt_p);
830
831   return NULL;
832 }
833
834 void
835 cp_genericize (tree fndecl)
836 {
837   tree t;
838   struct pointer_set_t *p_set;
839
840   /* Fix up the types of parms passed by invisible reference.  */
841   for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
842     if (TREE_ADDRESSABLE (TREE_TYPE (t)))
843       {
844         /* If a function's arguments are copied to create a thunk,
845            then DECL_BY_REFERENCE will be set -- but the type of the
846            argument will be a pointer type, so we will never get
847            here.  */
848         gcc_assert (!DECL_BY_REFERENCE (t));
849         gcc_assert (DECL_ARG_TYPE (t) != TREE_TYPE (t));
850         TREE_TYPE (t) = DECL_ARG_TYPE (t);
851         DECL_BY_REFERENCE (t) = 1;
852         TREE_ADDRESSABLE (t) = 0;
853         relayout_decl (t);
854       }
855
856   /* Do the same for the return value.  */
857   if (TREE_ADDRESSABLE (TREE_TYPE (DECL_RESULT (fndecl))))
858     {
859       t = DECL_RESULT (fndecl);
860       TREE_TYPE (t) = build_reference_type (TREE_TYPE (t));
861       DECL_BY_REFERENCE (t) = 1;
862       TREE_ADDRESSABLE (t) = 0;
863       relayout_decl (t);
864     }
865
866   /* If we're a clone, the body is already GIMPLE.  */
867   if (DECL_CLONED_FUNCTION_P (fndecl))
868     return;
869
870   /* We do want to see every occurrence of the parms, so we can't just use
871      walk_tree's hash functionality.  */
872   p_set = pointer_set_create ();
873   cp_walk_tree (&DECL_SAVED_TREE (fndecl), cp_genericize_r, p_set, NULL);
874   pointer_set_destroy (p_set);
875
876   /* Do everything else.  */
877   c_genericize (fndecl);
878
879   gcc_assert (bc_label[bc_break] == NULL);
880   gcc_assert (bc_label[bc_continue] == NULL);
881 }
882 \f
883 /* Build code to apply FN to each member of ARG1 and ARG2.  FN may be
884    NULL if there is in fact nothing to do.  ARG2 may be null if FN
885    actually only takes one argument.  */
886
887 static tree
888 cxx_omp_clause_apply_fn (tree fn, tree arg1, tree arg2)
889 {
890   tree defparm, parm, t;
891   int i = 0;
892   int nargs;
893   tree *argarray;
894
895   if (fn == NULL)
896     return NULL;
897
898   nargs = list_length (DECL_ARGUMENTS (fn));
899   argarray = (tree *) alloca (nargs * sizeof (tree));
900
901   defparm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn)));
902   if (arg2)
903     defparm = TREE_CHAIN (defparm);
904
905   if (TREE_CODE (TREE_TYPE (arg1)) == ARRAY_TYPE)
906     {
907       tree inner_type = TREE_TYPE (arg1);
908       tree start1, end1, p1;
909       tree start2 = NULL, p2 = NULL;
910       tree ret = NULL, lab;
911
912       start1 = arg1;
913       start2 = arg2;
914       do
915         {
916           inner_type = TREE_TYPE (inner_type);
917           start1 = build4 (ARRAY_REF, inner_type, start1,
918                            size_zero_node, NULL, NULL);
919           if (arg2)
920             start2 = build4 (ARRAY_REF, inner_type, start2,
921                              size_zero_node, NULL, NULL);
922         }
923       while (TREE_CODE (inner_type) == ARRAY_TYPE);
924       start1 = build_fold_addr_expr (start1);
925       if (arg2)
926         start2 = build_fold_addr_expr (start2);
927
928       end1 = TYPE_SIZE_UNIT (TREE_TYPE (arg1));
929       end1 = build2 (POINTER_PLUS_EXPR, TREE_TYPE (start1), start1, end1);
930
931       p1 = create_tmp_var (TREE_TYPE (start1), NULL);
932       t = build2 (MODIFY_EXPR, TREE_TYPE (p1), p1, start1);
933       append_to_statement_list (t, &ret);
934
935       if (arg2)
936         {
937           p2 = create_tmp_var (TREE_TYPE (start2), NULL);
938           t = build2 (MODIFY_EXPR, TREE_TYPE (p2), p2, start2);
939           append_to_statement_list (t, &ret);
940         }
941
942       lab = create_artificial_label ();
943       t = build1 (LABEL_EXPR, void_type_node, lab);
944       append_to_statement_list (t, &ret);
945
946       argarray[i++] = p1;
947       if (arg2)
948         argarray[i++] = p2;
949       /* Handle default arguments.  */
950       for (parm = defparm; parm && parm != void_list_node;
951            parm = TREE_CHAIN (parm), i++)
952         argarray[i] = convert_default_arg (TREE_VALUE (parm),
953                                            TREE_PURPOSE (parm), fn, i);
954       t = build_call_a (fn, i, argarray);
955       t = fold_convert (void_type_node, t);
956       t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
957       append_to_statement_list (t, &ret);
958
959       t = TYPE_SIZE_UNIT (inner_type);
960       t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (p1), p1, t);
961       t = build2 (MODIFY_EXPR, TREE_TYPE (p1), p1, t);
962       append_to_statement_list (t, &ret);
963
964       if (arg2)
965         {
966           t = TYPE_SIZE_UNIT (inner_type);
967           t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (p2), p2, t);
968           t = build2 (MODIFY_EXPR, TREE_TYPE (p2), p2, t);
969           append_to_statement_list (t, &ret);
970         }
971
972       t = build2 (NE_EXPR, boolean_type_node, p1, end1);
973       t = build3 (COND_EXPR, void_type_node, t, build_and_jump (&lab), NULL);
974       append_to_statement_list (t, &ret);
975
976       return ret;
977     }
978   else
979     {
980       argarray[i++] = build_fold_addr_expr (arg1);
981       if (arg2)
982         argarray[i++] = build_fold_addr_expr (arg2);
983       /* Handle default arguments.  */
984       for (parm = defparm; parm && parm != void_list_node;
985            parm = TREE_CHAIN (parm), i++)
986         argarray[i] = convert_default_arg (TREE_VALUE (parm),
987                                            TREE_PURPOSE (parm),
988                                            fn, i);
989       t = build_call_a (fn, i, argarray);
990       t = fold_convert (void_type_node, t);
991       return fold_build_cleanup_point_expr (TREE_TYPE (t), t);
992     }
993 }
994
995 /* Return code to initialize DECL with its default constructor, or
996    NULL if there's nothing to do.  */
997
998 tree
999 cxx_omp_clause_default_ctor (tree clause, tree decl,
1000                              tree outer ATTRIBUTE_UNUSED)
1001 {
1002   tree info = CP_OMP_CLAUSE_INFO (clause);
1003   tree ret = NULL;
1004
1005   if (info)
1006     ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 0), decl, NULL);
1007
1008   return ret;
1009 }
1010
1011 /* Return code to initialize DST with a copy constructor from SRC.  */
1012
1013 tree
1014 cxx_omp_clause_copy_ctor (tree clause, tree dst, tree src)
1015 {
1016   tree info = CP_OMP_CLAUSE_INFO (clause);
1017   tree ret = NULL;
1018
1019   if (info)
1020     ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 0), dst, src);
1021   if (ret == NULL)
1022     ret = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
1023
1024   return ret;
1025 }
1026
1027 /* Similarly, except use an assignment operator instead.  */
1028
1029 tree
1030 cxx_omp_clause_assign_op (tree clause, tree dst, tree src)
1031 {
1032   tree info = CP_OMP_CLAUSE_INFO (clause);
1033   tree ret = NULL;
1034
1035   if (info)
1036     ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 2), dst, src);
1037   if (ret == NULL)
1038     ret = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
1039
1040   return ret;
1041 }
1042
1043 /* Return code to destroy DECL.  */
1044
1045 tree
1046 cxx_omp_clause_dtor (tree clause, tree decl)
1047 {
1048   tree info = CP_OMP_CLAUSE_INFO (clause);
1049   tree ret = NULL;
1050
1051   if (info)
1052     ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 1), decl, NULL);
1053
1054   return ret;
1055 }
1056
1057 /* True if OpenMP should privatize what this DECL points to rather
1058    than the DECL itself.  */
1059
1060 bool
1061 cxx_omp_privatize_by_reference (const_tree decl)
1062 {
1063   return is_invisiref_parm (decl);
1064 }
1065
1066 /* True if OpenMP sharing attribute of DECL is predetermined.  */
1067
1068 enum omp_clause_default_kind
1069 cxx_omp_predetermined_sharing (tree decl)
1070 {
1071   tree type;
1072
1073   /* Static data members are predetermined as shared.  */
1074   if (TREE_STATIC (decl))
1075     {
1076       tree ctx = CP_DECL_CONTEXT (decl);
1077       if (TYPE_P (ctx) && MAYBE_CLASS_TYPE_P (ctx))
1078         return OMP_CLAUSE_DEFAULT_SHARED;
1079     }
1080
1081   type = TREE_TYPE (decl);
1082   if (TREE_CODE (type) == REFERENCE_TYPE)
1083     {
1084       if (!is_invisiref_parm (decl))
1085         return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
1086       type = TREE_TYPE (type);
1087
1088       if (TREE_CODE (decl) == RESULT_DECL && DECL_NAME (decl))
1089         {
1090           /* NVR doesn't preserve const qualification of the
1091              variable's type.  */
1092           tree outer = outer_curly_brace_block (current_function_decl);
1093           tree var;
1094
1095           if (outer)
1096             for (var = BLOCK_VARS (outer); var; var = TREE_CHAIN (var))
1097               if (DECL_NAME (decl) == DECL_NAME (var)
1098                   && (TYPE_MAIN_VARIANT (type)
1099                       == TYPE_MAIN_VARIANT (TREE_TYPE (var))))
1100                 {
1101                   if (TYPE_READONLY (TREE_TYPE (var)))
1102                     type = TREE_TYPE (var);
1103                   break;
1104                 }
1105         }
1106     }
1107
1108   if (type == error_mark_node)
1109     return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
1110
1111   /* Variables with const-qualified type having no mutable member
1112      are predetermined shared.  */
1113   if (TYPE_READONLY (type) && !cp_has_mutable_p (type))
1114     return OMP_CLAUSE_DEFAULT_SHARED;
1115
1116   return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
1117 }
1118
1119 /* Finalize an implicitly determined clause.  */
1120
1121 void
1122 cxx_omp_finish_clause (tree c)
1123 {
1124   tree decl, inner_type;
1125   bool make_shared = false;
1126
1127   if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_FIRSTPRIVATE)
1128     return;
1129
1130   decl = OMP_CLAUSE_DECL (c);
1131   decl = require_complete_type (decl);
1132   inner_type = TREE_TYPE (decl);
1133   if (decl == error_mark_node)
1134     make_shared = true;
1135   else if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE)
1136     {
1137       if (is_invisiref_parm (decl))
1138         inner_type = TREE_TYPE (inner_type);
1139       else
1140         {
1141           error ("%qE implicitly determined as %<firstprivate%> has reference type",
1142                  decl);
1143           make_shared = true;
1144         }
1145     }
1146
1147   /* We're interested in the base element, not arrays.  */
1148   while (TREE_CODE (inner_type) == ARRAY_TYPE)
1149     inner_type = TREE_TYPE (inner_type);
1150
1151   /* Check for special function availability by building a call to one.
1152      Save the results, because later we won't be in the right context
1153      for making these queries.  */
1154   if (!make_shared
1155       && CLASS_TYPE_P (inner_type)
1156       && cxx_omp_create_clause_info (c, inner_type, false, true, false))
1157     make_shared = true;
1158
1159   if (make_shared)
1160     OMP_CLAUSE_CODE (c) = OMP_CLAUSE_SHARED;
1161 }