gimplify.c revision 220150
1/* Tree lowering pass. This pass converts the GENERIC functions-as-trees 2 tree representation into the GIMPLE form. 3 Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 4 Major work done by Sebastian Pop <s.pop@laposte.net>, 5 Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>. 6 7This file is part of GCC. 8 9GCC is free software; you can redistribute it and/or modify it under 10the terms of the GNU General Public License as published by the Free 11Software Foundation; either version 2, or (at your option) any later 12version. 13 14GCC is distributed in the hope that it will be useful, but WITHOUT ANY 15WARRANTY; without even the implied warranty of MERCHANTABILITY or 16FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 17for more details. 18 19You should have received a copy of the GNU General Public License 20along with GCC; see the file COPYING. If not, write to the Free 21Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2202110-1301, USA. */ 23 24#include "config.h" 25#include "system.h" 26#include "coretypes.h" 27#include "tm.h" 28#include "tree.h" 29#include "rtl.h" 30#include "varray.h" 31#include "tree-gimple.h" 32#include "tree-inline.h" 33#include "diagnostic.h" 34#include "langhooks.h" 35#include "langhooks-def.h" 36#include "tree-flow.h" 37#include "cgraph.h" 38#include "timevar.h" 39#include "except.h" 40#include "hashtab.h" 41#include "flags.h" 42#include "real.h" 43#include "function.h" 44#include "output.h" 45#include "expr.h" 46#include "ggc.h" 47#include "toplev.h" 48#include "target.h" 49#include "optabs.h" 50#include "pointer-set.h" 51 52 53enum gimplify_omp_var_data 54{ 55 GOVD_SEEN = 1, 56 GOVD_EXPLICIT = 2, 57 GOVD_SHARED = 4, 58 GOVD_PRIVATE = 8, 59 GOVD_FIRSTPRIVATE = 16, 60 GOVD_LASTPRIVATE = 32, 61 GOVD_REDUCTION = 64, 62 GOVD_LOCAL = 128, 63 GOVD_DEBUG_PRIVATE = 256, 64 GOVD_DATA_SHARE_CLASS = (GOVD_SHARED | GOVD_PRIVATE | GOVD_FIRSTPRIVATE 65 | GOVD_LASTPRIVATE | GOVD_REDUCTION | GOVD_LOCAL) 66}; 67 68struct gimplify_omp_ctx 69{ 70 struct gimplify_omp_ctx *outer_context; 71 splay_tree variables; 72 struct pointer_set_t *privatized_types; 73 location_t location; 74 enum omp_clause_default_kind default_kind; 75 bool is_parallel; 76 bool is_combined_parallel; 77}; 78 79struct gimplify_ctx 80{ 81 struct gimplify_ctx *prev_context; 82 83 tree current_bind_expr; 84 tree temps; 85 tree conditional_cleanups; 86 tree exit_label; 87 tree return_temp; 88 89 VEC(tree,heap) *case_labels; 90 /* The formal temporary table. Should this be persistent? */ 91 htab_t temp_htab; 92 93 int conditions; 94 bool save_stack; 95 bool into_ssa; 96}; 97 98static struct gimplify_ctx *gimplify_ctxp; 99static struct gimplify_omp_ctx *gimplify_omp_ctxp; 100 101 102 103/* Formal (expression) temporary table handling: Multiple occurrences of 104 the same scalar expression are evaluated into the same temporary. */ 105 106typedef struct gimple_temp_hash_elt 107{ 108 tree val; /* Key */ 109 tree temp; /* Value */ 110} elt_t; 111 112/* Forward declarations. */ 113static enum gimplify_status gimplify_compound_expr (tree *, tree *, bool); 114#ifdef ENABLE_CHECKING 115static bool cpt_same_type (tree a, tree b); 116#endif 117 118 119/* Return a hash value for a formal temporary table entry. */ 120 121static hashval_t 122gimple_tree_hash (const void *p) 123{ 124 tree t = ((const elt_t *) p)->val; 125 return iterative_hash_expr (t, 0); 126} 127 128/* Compare two formal temporary table entries. */ 129 130static int 131gimple_tree_eq (const void *p1, const void *p2) 132{ 133 tree t1 = ((const elt_t *) p1)->val; 134 tree t2 = ((const elt_t *) p2)->val; 135 enum tree_code code = TREE_CODE (t1); 136 137 if (TREE_CODE (t2) != code 138 || TREE_TYPE (t1) != TREE_TYPE (t2)) 139 return 0; 140 141 if (!operand_equal_p (t1, t2, 0)) 142 return 0; 143 144 /* Only allow them to compare equal if they also hash equal; otherwise 145 results are nondeterminate, and we fail bootstrap comparison. */ 146 gcc_assert (gimple_tree_hash (p1) == gimple_tree_hash (p2)); 147 148 return 1; 149} 150 151/* Set up a context for the gimplifier. */ 152 153void 154push_gimplify_context (void) 155{ 156 struct gimplify_ctx *c; 157 158 c = (struct gimplify_ctx *) xcalloc (1, sizeof (struct gimplify_ctx)); 159 c->prev_context = gimplify_ctxp; 160 if (optimize) 161 c->temp_htab = htab_create (1000, gimple_tree_hash, gimple_tree_eq, free); 162 163 gimplify_ctxp = c; 164} 165 166/* Tear down a context for the gimplifier. If BODY is non-null, then 167 put the temporaries into the outer BIND_EXPR. Otherwise, put them 168 in the unexpanded_var_list. */ 169 170void 171pop_gimplify_context (tree body) 172{ 173 struct gimplify_ctx *c = gimplify_ctxp; 174 tree t; 175 176 gcc_assert (c && !c->current_bind_expr); 177 gimplify_ctxp = c->prev_context; 178 179 for (t = c->temps; t ; t = TREE_CHAIN (t)) 180 DECL_GIMPLE_FORMAL_TEMP_P (t) = 0; 181 182 if (body) 183 declare_vars (c->temps, body, false); 184 else 185 record_vars (c->temps); 186 187 if (optimize) 188 htab_delete (c->temp_htab); 189 free (c); 190} 191 192static void 193gimple_push_bind_expr (tree bind) 194{ 195 TREE_CHAIN (bind) = gimplify_ctxp->current_bind_expr; 196 gimplify_ctxp->current_bind_expr = bind; 197} 198 199static void 200gimple_pop_bind_expr (void) 201{ 202 gimplify_ctxp->current_bind_expr 203 = TREE_CHAIN (gimplify_ctxp->current_bind_expr); 204} 205 206tree 207gimple_current_bind_expr (void) 208{ 209 return gimplify_ctxp->current_bind_expr; 210} 211 212/* Returns true iff there is a COND_EXPR between us and the innermost 213 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */ 214 215static bool 216gimple_conditional_context (void) 217{ 218 return gimplify_ctxp->conditions > 0; 219} 220 221/* Note that we've entered a COND_EXPR. */ 222 223static void 224gimple_push_condition (void) 225{ 226#ifdef ENABLE_CHECKING 227 if (gimplify_ctxp->conditions == 0) 228 gcc_assert (!gimplify_ctxp->conditional_cleanups); 229#endif 230 ++(gimplify_ctxp->conditions); 231} 232 233/* Note that we've left a COND_EXPR. If we're back at unconditional scope 234 now, add any conditional cleanups we've seen to the prequeue. */ 235 236static void 237gimple_pop_condition (tree *pre_p) 238{ 239 int conds = --(gimplify_ctxp->conditions); 240 241 gcc_assert (conds >= 0); 242 if (conds == 0) 243 { 244 append_to_statement_list (gimplify_ctxp->conditional_cleanups, pre_p); 245 gimplify_ctxp->conditional_cleanups = NULL_TREE; 246 } 247} 248 249/* A stable comparison routine for use with splay trees and DECLs. */ 250 251static int 252splay_tree_compare_decl_uid (splay_tree_key xa, splay_tree_key xb) 253{ 254 tree a = (tree) xa; 255 tree b = (tree) xb; 256 257 return DECL_UID (a) - DECL_UID (b); 258} 259 260/* Create a new omp construct that deals with variable remapping. */ 261 262static struct gimplify_omp_ctx * 263new_omp_context (bool is_parallel, bool is_combined_parallel) 264{ 265 struct gimplify_omp_ctx *c; 266 267 c = XCNEW (struct gimplify_omp_ctx); 268 c->outer_context = gimplify_omp_ctxp; 269 c->variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0); 270 c->privatized_types = pointer_set_create (); 271 c->location = input_location; 272 c->is_parallel = is_parallel; 273 c->is_combined_parallel = is_combined_parallel; 274 c->default_kind = OMP_CLAUSE_DEFAULT_SHARED; 275 276 return c; 277} 278 279/* Destroy an omp construct that deals with variable remapping. */ 280 281static void 282delete_omp_context (struct gimplify_omp_ctx *c) 283{ 284 splay_tree_delete (c->variables); 285 pointer_set_destroy (c->privatized_types); 286 XDELETE (c); 287} 288 289static void omp_add_variable (struct gimplify_omp_ctx *, tree, unsigned int); 290static bool omp_notice_variable (struct gimplify_omp_ctx *, tree, bool); 291 292/* A subroutine of append_to_statement_list{,_force}. T is not NULL. */ 293 294static void 295append_to_statement_list_1 (tree t, tree *list_p) 296{ 297 tree list = *list_p; 298 tree_stmt_iterator i; 299 300 if (!list) 301 { 302 if (t && TREE_CODE (t) == STATEMENT_LIST) 303 { 304 *list_p = t; 305 return; 306 } 307 *list_p = list = alloc_stmt_list (); 308 } 309 310 i = tsi_last (list); 311 tsi_link_after (&i, t, TSI_CONTINUE_LINKING); 312} 313 314/* Add T to the end of the list container pointed to by LIST_P. 315 If T is an expression with no effects, it is ignored. */ 316 317void 318append_to_statement_list (tree t, tree *list_p) 319{ 320 if (t && TREE_SIDE_EFFECTS (t)) 321 append_to_statement_list_1 (t, list_p); 322} 323 324/* Similar, but the statement is always added, regardless of side effects. */ 325 326void 327append_to_statement_list_force (tree t, tree *list_p) 328{ 329 if (t != NULL_TREE) 330 append_to_statement_list_1 (t, list_p); 331} 332 333/* Both gimplify the statement T and append it to LIST_P. */ 334 335void 336gimplify_and_add (tree t, tree *list_p) 337{ 338 gimplify_stmt (&t); 339 append_to_statement_list (t, list_p); 340} 341 342/* Strip off a legitimate source ending from the input string NAME of 343 length LEN. Rather than having to know the names used by all of 344 our front ends, we strip off an ending of a period followed by 345 up to five characters. (Java uses ".class".) */ 346 347static inline void 348remove_suffix (char *name, int len) 349{ 350 int i; 351 352 for (i = 2; i < 8 && len > i; i++) 353 { 354 if (name[len - i] == '.') 355 { 356 name[len - i] = '\0'; 357 break; 358 } 359 } 360} 361 362/* Create a nameless artificial label and put it in the current function 363 context. Returns the newly created label. */ 364 365tree 366create_artificial_label (void) 367{ 368 tree lab = build_decl (LABEL_DECL, NULL_TREE, void_type_node); 369 370 DECL_ARTIFICIAL (lab) = 1; 371 DECL_IGNORED_P (lab) = 1; 372 DECL_CONTEXT (lab) = current_function_decl; 373 return lab; 374} 375 376/* Subroutine for find_single_pointer_decl. */ 377 378static tree 379find_single_pointer_decl_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, 380 void *data) 381{ 382 tree *pdecl = (tree *) data; 383 384 if (DECL_P (*tp) && POINTER_TYPE_P (TREE_TYPE (*tp))) 385 { 386 if (*pdecl) 387 { 388 /* We already found a pointer decl; return anything other 389 than NULL_TREE to unwind from walk_tree signalling that 390 we have a duplicate. */ 391 return *tp; 392 } 393 *pdecl = *tp; 394 } 395 396 return NULL_TREE; 397} 398 399/* Find the single DECL of pointer type in the tree T and return it. 400 If there are zero or more than one such DECLs, return NULL. */ 401 402static tree 403find_single_pointer_decl (tree t) 404{ 405 tree decl = NULL_TREE; 406 407 if (walk_tree (&t, find_single_pointer_decl_1, &decl, NULL)) 408 { 409 /* find_single_pointer_decl_1 returns a nonzero value, causing 410 walk_tree to return a nonzero value, to indicate that it 411 found more than one pointer DECL. */ 412 return NULL_TREE; 413 } 414 415 return decl; 416} 417 418/* Create a new temporary name with PREFIX. Returns an identifier. */ 419 420static GTY(()) unsigned int tmp_var_id_num; 421 422tree 423create_tmp_var_name (const char *prefix) 424{ 425 char *tmp_name; 426 427 if (prefix) 428 { 429 char *preftmp = ASTRDUP (prefix); 430 431 remove_suffix (preftmp, strlen (preftmp)); 432 prefix = preftmp; 433 } 434 435 ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++); 436 return get_identifier (tmp_name); 437} 438 439 440/* Create a new temporary variable declaration of type TYPE. 441 Does NOT push it into the current binding. */ 442 443tree 444create_tmp_var_raw (tree type, const char *prefix) 445{ 446 tree tmp_var; 447 tree new_type; 448 449 /* Make the type of the variable writable. */ 450 new_type = build_type_variant (type, 0, 0); 451 TYPE_ATTRIBUTES (new_type) = TYPE_ATTRIBUTES (type); 452 453 tmp_var = build_decl (VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL, 454 type); 455 456 /* The variable was declared by the compiler. */ 457 DECL_ARTIFICIAL (tmp_var) = 1; 458 /* And we don't want debug info for it. */ 459 DECL_IGNORED_P (tmp_var) = 1; 460 461 /* Make the variable writable. */ 462 TREE_READONLY (tmp_var) = 0; 463 464 DECL_EXTERNAL (tmp_var) = 0; 465 TREE_STATIC (tmp_var) = 0; 466 TREE_USED (tmp_var) = 1; 467 468 return tmp_var; 469} 470 471/* Create a new temporary variable declaration of type TYPE. DOES push the 472 variable into the current binding. Further, assume that this is called 473 only from gimplification or optimization, at which point the creation of 474 certain types are bugs. */ 475 476tree 477create_tmp_var (tree type, const char *prefix) 478{ 479 tree tmp_var; 480 481 /* We don't allow types that are addressable (meaning we can't make copies), 482 or incomplete. We also used to reject every variable size objects here, 483 but now support those for which a constant upper bound can be obtained. 484 The processing for variable sizes is performed in gimple_add_tmp_var, 485 point at which it really matters and possibly reached via paths not going 486 through this function, e.g. after direct calls to create_tmp_var_raw. */ 487 gcc_assert (!TREE_ADDRESSABLE (type) && COMPLETE_TYPE_P (type)); 488 489 tmp_var = create_tmp_var_raw (type, prefix); 490 gimple_add_tmp_var (tmp_var); 491 return tmp_var; 492} 493 494/* Given a tree, try to return a useful variable name that we can use 495 to prefix a temporary that is being assigned the value of the tree. 496 I.E. given <temp> = &A, return A. */ 497 498const char * 499get_name (tree t) 500{ 501 tree stripped_decl; 502 503 stripped_decl = t; 504 STRIP_NOPS (stripped_decl); 505 if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl)) 506 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl)); 507 else 508 { 509 switch (TREE_CODE (stripped_decl)) 510 { 511 case ADDR_EXPR: 512 return get_name (TREE_OPERAND (stripped_decl, 0)); 513 break; 514 default: 515 return NULL; 516 } 517 } 518} 519 520/* Create a temporary with a name derived from VAL. Subroutine of 521 lookup_tmp_var; nobody else should call this function. */ 522 523static inline tree 524create_tmp_from_val (tree val) 525{ 526 return create_tmp_var (TYPE_MAIN_VARIANT (TREE_TYPE (val)), get_name (val)); 527} 528 529/* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse 530 an existing expression temporary. */ 531 532static tree 533lookup_tmp_var (tree val, bool is_formal) 534{ 535 tree ret; 536 537 /* If not optimizing, never really reuse a temporary. local-alloc 538 won't allocate any variable that is used in more than one basic 539 block, which means it will go into memory, causing much extra 540 work in reload and final and poorer code generation, outweighing 541 the extra memory allocation here. */ 542 if (!optimize || !is_formal || TREE_SIDE_EFFECTS (val)) 543 ret = create_tmp_from_val (val); 544 else 545 { 546 elt_t elt, *elt_p; 547 void **slot; 548 549 elt.val = val; 550 slot = htab_find_slot (gimplify_ctxp->temp_htab, (void *)&elt, INSERT); 551 if (*slot == NULL) 552 { 553 elt_p = XNEW (elt_t); 554 elt_p->val = val; 555 elt_p->temp = ret = create_tmp_from_val (val); 556 *slot = (void *) elt_p; 557 } 558 else 559 { 560 elt_p = (elt_t *) *slot; 561 ret = elt_p->temp; 562 } 563 } 564 565 if (is_formal) 566 DECL_GIMPLE_FORMAL_TEMP_P (ret) = 1; 567 568 return ret; 569} 570 571/* Returns a formal temporary variable initialized with VAL. PRE_P is as 572 in gimplify_expr. Only use this function if: 573 574 1) The value of the unfactored expression represented by VAL will not 575 change between the initialization and use of the temporary, and 576 2) The temporary will not be otherwise modified. 577 578 For instance, #1 means that this is inappropriate for SAVE_EXPR temps, 579 and #2 means it is inappropriate for && temps. 580 581 For other cases, use get_initialized_tmp_var instead. */ 582 583static tree 584internal_get_tmp_var (tree val, tree *pre_p, tree *post_p, bool is_formal) 585{ 586 tree t, mod; 587 588 gimplify_expr (&val, pre_p, post_p, is_gimple_formal_tmp_rhs, fb_rvalue); 589 590 t = lookup_tmp_var (val, is_formal); 591 592 if (is_formal) 593 { 594 tree u = find_single_pointer_decl (val); 595 596 if (u && TREE_CODE (u) == VAR_DECL && DECL_BASED_ON_RESTRICT_P (u)) 597 u = DECL_GET_RESTRICT_BASE (u); 598 if (u && TYPE_RESTRICT (TREE_TYPE (u))) 599 { 600 if (DECL_BASED_ON_RESTRICT_P (t)) 601 gcc_assert (u == DECL_GET_RESTRICT_BASE (t)); 602 else 603 { 604 DECL_BASED_ON_RESTRICT_P (t) = 1; 605 SET_DECL_RESTRICT_BASE (t, u); 606 } 607 } 608 } 609 610 if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE) 611 DECL_COMPLEX_GIMPLE_REG_P (t) = 1; 612 613 mod = build2 (INIT_EXPR, TREE_TYPE (t), t, val); 614 615 if (EXPR_HAS_LOCATION (val)) 616 SET_EXPR_LOCUS (mod, EXPR_LOCUS (val)); 617 else 618 SET_EXPR_LOCATION (mod, input_location); 619 620 /* gimplify_modify_expr might want to reduce this further. */ 621 gimplify_and_add (mod, pre_p); 622 623 /* If we're gimplifying into ssa, gimplify_modify_expr will have 624 given our temporary an ssa name. Find and return it. */ 625 if (gimplify_ctxp->into_ssa) 626 t = TREE_OPERAND (mod, 0); 627 628 return t; 629} 630 631/* Returns a formal temporary variable initialized with VAL. PRE_P 632 points to a statement list where side-effects needed to compute VAL 633 should be stored. */ 634 635tree 636get_formal_tmp_var (tree val, tree *pre_p) 637{ 638 return internal_get_tmp_var (val, pre_p, NULL, true); 639} 640 641/* Returns a temporary variable initialized with VAL. PRE_P and POST_P 642 are as in gimplify_expr. */ 643 644tree 645get_initialized_tmp_var (tree val, tree *pre_p, tree *post_p) 646{ 647 return internal_get_tmp_var (val, pre_p, post_p, false); 648} 649 650/* Declares all the variables in VARS in SCOPE. If DEBUG_INFO is 651 true, generate debug info for them; otherwise don't. */ 652 653void 654declare_vars (tree vars, tree scope, bool debug_info) 655{ 656 tree last = vars; 657 if (last) 658 { 659 tree temps, block; 660 661 /* C99 mode puts the default 'return 0;' for main outside the outer 662 braces. So drill down until we find an actual scope. */ 663 while (TREE_CODE (scope) == COMPOUND_EXPR) 664 scope = TREE_OPERAND (scope, 0); 665 666 gcc_assert (TREE_CODE (scope) == BIND_EXPR); 667 668 temps = nreverse (last); 669 670 block = BIND_EXPR_BLOCK (scope); 671 if (!block || !debug_info) 672 { 673 TREE_CHAIN (last) = BIND_EXPR_VARS (scope); 674 BIND_EXPR_VARS (scope) = temps; 675 } 676 else 677 { 678 /* We need to attach the nodes both to the BIND_EXPR and to its 679 associated BLOCK for debugging purposes. The key point here 680 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR 681 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */ 682 if (BLOCK_VARS (block)) 683 BLOCK_VARS (block) = chainon (BLOCK_VARS (block), temps); 684 else 685 { 686 BIND_EXPR_VARS (scope) = chainon (BIND_EXPR_VARS (scope), temps); 687 BLOCK_VARS (block) = temps; 688 } 689 } 690 } 691} 692 693/* For VAR a VAR_DECL of variable size, try to find a constant upper bound 694 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if 695 no such upper bound can be obtained. */ 696 697static void 698force_constant_size (tree var) 699{ 700 /* The only attempt we make is by querying the maximum size of objects 701 of the variable's type. */ 702 703 HOST_WIDE_INT max_size; 704 705 gcc_assert (TREE_CODE (var) == VAR_DECL); 706 707 max_size = max_int_size_in_bytes (TREE_TYPE (var)); 708 709 gcc_assert (max_size >= 0); 710 711 DECL_SIZE_UNIT (var) 712 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var)), max_size); 713 DECL_SIZE (var) 714 = build_int_cst (TREE_TYPE (DECL_SIZE (var)), max_size * BITS_PER_UNIT); 715} 716 717void 718gimple_add_tmp_var (tree tmp) 719{ 720 gcc_assert (!TREE_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp)); 721 722 /* Later processing assumes that the object size is constant, which might 723 not be true at this point. Force the use of a constant upper bound in 724 this case. */ 725 if (!host_integerp (DECL_SIZE_UNIT (tmp), 1)) 726 force_constant_size (tmp); 727 728 DECL_CONTEXT (tmp) = current_function_decl; 729 DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1; 730 731 if (gimplify_ctxp) 732 { 733 TREE_CHAIN (tmp) = gimplify_ctxp->temps; 734 gimplify_ctxp->temps = tmp; 735 736 /* Mark temporaries local within the nearest enclosing parallel. */ 737 if (gimplify_omp_ctxp) 738 { 739 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp; 740 while (ctx && !ctx->is_parallel) 741 ctx = ctx->outer_context; 742 if (ctx) 743 omp_add_variable (ctx, tmp, GOVD_LOCAL | GOVD_SEEN); 744 } 745 } 746 else if (cfun) 747 record_vars (tmp); 748 else 749 declare_vars (tmp, DECL_SAVED_TREE (current_function_decl), false); 750} 751 752/* Determines whether to assign a locus to the statement STMT. */ 753 754static bool 755should_carry_locus_p (tree stmt) 756{ 757 /* Don't emit a line note for a label. We particularly don't want to 758 emit one for the break label, since it doesn't actually correspond 759 to the beginning of the loop/switch. */ 760 if (TREE_CODE (stmt) == LABEL_EXPR) 761 return false; 762 763 /* Do not annotate empty statements, since it confuses gcov. */ 764 if (!TREE_SIDE_EFFECTS (stmt)) 765 return false; 766 767 return true; 768} 769 770static void 771annotate_one_with_locus (tree t, location_t locus) 772{ 773 if (EXPR_P (t) && ! EXPR_HAS_LOCATION (t) && should_carry_locus_p (t)) 774 SET_EXPR_LOCATION (t, locus); 775} 776 777void 778annotate_all_with_locus (tree *stmt_p, location_t locus) 779{ 780 tree_stmt_iterator i; 781 782 if (!*stmt_p) 783 return; 784 785 for (i = tsi_start (*stmt_p); !tsi_end_p (i); tsi_next (&i)) 786 { 787 tree t = tsi_stmt (i); 788 789 /* Assuming we've already been gimplified, we shouldn't 790 see nested chaining constructs anymore. */ 791 gcc_assert (TREE_CODE (t) != STATEMENT_LIST 792 && TREE_CODE (t) != COMPOUND_EXPR); 793 794 annotate_one_with_locus (t, locus); 795 } 796} 797 798/* Similar to copy_tree_r() but do not copy SAVE_EXPR or TARGET_EXPR nodes. 799 These nodes model computations that should only be done once. If we 800 were to unshare something like SAVE_EXPR(i++), the gimplification 801 process would create wrong code. */ 802 803static tree 804mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data) 805{ 806 enum tree_code code = TREE_CODE (*tp); 807 /* Don't unshare types, decls, constants and SAVE_EXPR nodes. */ 808 if (TREE_CODE_CLASS (code) == tcc_type 809 || TREE_CODE_CLASS (code) == tcc_declaration 810 || TREE_CODE_CLASS (code) == tcc_constant 811 || code == SAVE_EXPR || code == TARGET_EXPR 812 /* We can't do anything sensible with a BLOCK used as an expression, 813 but we also can't just die when we see it because of non-expression 814 uses. So just avert our eyes and cross our fingers. Silly Java. */ 815 || code == BLOCK) 816 *walk_subtrees = 0; 817 else 818 { 819 gcc_assert (code != BIND_EXPR); 820 copy_tree_r (tp, walk_subtrees, data); 821 } 822 823 return NULL_TREE; 824} 825 826/* Callback for walk_tree to unshare most of the shared trees rooted at 827 *TP. If *TP has been visited already (i.e., TREE_VISITED (*TP) == 1), 828 then *TP is deep copied by calling copy_tree_r. 829 830 This unshares the same trees as copy_tree_r with the exception of 831 SAVE_EXPR nodes. These nodes model computations that should only be 832 done once. If we were to unshare something like SAVE_EXPR(i++), the 833 gimplification process would create wrong code. */ 834 835static tree 836copy_if_shared_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, 837 void *data ATTRIBUTE_UNUSED) 838{ 839 tree t = *tp; 840 enum tree_code code = TREE_CODE (t); 841 842 /* Skip types, decls, and constants. But we do want to look at their 843 types and the bounds of types. Mark them as visited so we properly 844 unmark their subtrees on the unmark pass. If we've already seen them, 845 don't look down further. */ 846 if (TREE_CODE_CLASS (code) == tcc_type 847 || TREE_CODE_CLASS (code) == tcc_declaration 848 || TREE_CODE_CLASS (code) == tcc_constant) 849 { 850 if (TREE_VISITED (t)) 851 *walk_subtrees = 0; 852 else 853 TREE_VISITED (t) = 1; 854 } 855 856 /* If this node has been visited already, unshare it and don't look 857 any deeper. */ 858 else if (TREE_VISITED (t)) 859 { 860 walk_tree (tp, mostly_copy_tree_r, NULL, NULL); 861 *walk_subtrees = 0; 862 } 863 864 /* Otherwise, mark the tree as visited and keep looking. */ 865 else 866 TREE_VISITED (t) = 1; 867 868 return NULL_TREE; 869} 870 871static tree 872unmark_visited_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, 873 void *data ATTRIBUTE_UNUSED) 874{ 875 if (TREE_VISITED (*tp)) 876 TREE_VISITED (*tp) = 0; 877 else 878 *walk_subtrees = 0; 879 880 return NULL_TREE; 881} 882 883/* Unshare all the trees in BODY_P, a pointer into the body of FNDECL, and the 884 bodies of any nested functions if we are unsharing the entire body of 885 FNDECL. */ 886 887static void 888unshare_body (tree *body_p, tree fndecl) 889{ 890 struct cgraph_node *cgn = cgraph_node (fndecl); 891 892 walk_tree (body_p, copy_if_shared_r, NULL, NULL); 893 if (body_p == &DECL_SAVED_TREE (fndecl)) 894 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested) 895 unshare_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl); 896} 897 898/* Likewise, but mark all trees as not visited. */ 899 900static void 901unvisit_body (tree *body_p, tree fndecl) 902{ 903 struct cgraph_node *cgn = cgraph_node (fndecl); 904 905 walk_tree (body_p, unmark_visited_r, NULL, NULL); 906 if (body_p == &DECL_SAVED_TREE (fndecl)) 907 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested) 908 unvisit_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl); 909} 910 911/* Unshare T and all the trees reached from T via TREE_CHAIN. */ 912 913static void 914unshare_all_trees (tree t) 915{ 916 walk_tree (&t, copy_if_shared_r, NULL, NULL); 917 walk_tree (&t, unmark_visited_r, NULL, NULL); 918} 919 920/* Unconditionally make an unshared copy of EXPR. This is used when using 921 stored expressions which span multiple functions, such as BINFO_VTABLE, 922 as the normal unsharing process can't tell that they're shared. */ 923 924tree 925unshare_expr (tree expr) 926{ 927 walk_tree (&expr, mostly_copy_tree_r, NULL, NULL); 928 return expr; 929} 930 931/* A terser interface for building a representation of an exception 932 specification. */ 933 934tree 935gimple_build_eh_filter (tree body, tree allowed, tree failure) 936{ 937 tree t; 938 939 /* FIXME should the allowed types go in TREE_TYPE? */ 940 t = build2 (EH_FILTER_EXPR, void_type_node, allowed, NULL_TREE); 941 append_to_statement_list (failure, &EH_FILTER_FAILURE (t)); 942 943 t = build2 (TRY_CATCH_EXPR, void_type_node, NULL_TREE, t); 944 append_to_statement_list (body, &TREE_OPERAND (t, 0)); 945 946 return t; 947} 948 949 950/* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both 951 contain statements and have a value. Assign its value to a temporary 952 and give it void_type_node. Returns the temporary, or NULL_TREE if 953 WRAPPER was already void. */ 954 955tree 956voidify_wrapper_expr (tree wrapper, tree temp) 957{ 958 tree type = TREE_TYPE (wrapper); 959 if (type && !VOID_TYPE_P (type)) 960 { 961 tree *p; 962 963 /* Set p to point to the body of the wrapper. Loop until we find 964 something that isn't a wrapper. */ 965 for (p = &wrapper; p && *p; ) 966 { 967 switch (TREE_CODE (*p)) 968 { 969 case BIND_EXPR: 970 TREE_SIDE_EFFECTS (*p) = 1; 971 TREE_TYPE (*p) = void_type_node; 972 /* For a BIND_EXPR, the body is operand 1. */ 973 p = &BIND_EXPR_BODY (*p); 974 break; 975 976 case CLEANUP_POINT_EXPR: 977 case TRY_FINALLY_EXPR: 978 case TRY_CATCH_EXPR: 979 TREE_SIDE_EFFECTS (*p) = 1; 980 TREE_TYPE (*p) = void_type_node; 981 p = &TREE_OPERAND (*p, 0); 982 break; 983 984 case STATEMENT_LIST: 985 { 986 tree_stmt_iterator i = tsi_last (*p); 987 TREE_SIDE_EFFECTS (*p) = 1; 988 TREE_TYPE (*p) = void_type_node; 989 p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i); 990 } 991 break; 992 993 case COMPOUND_EXPR: 994 /* Advance to the last statement. Set all container types to void. */ 995 for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1)) 996 { 997 TREE_SIDE_EFFECTS (*p) = 1; 998 TREE_TYPE (*p) = void_type_node; 999 } 1000 break; 1001 1002 default: 1003 goto out; 1004 } 1005 } 1006 1007 out: 1008 if (p == NULL || IS_EMPTY_STMT (*p)) 1009 temp = NULL_TREE; 1010 else if (temp) 1011 { 1012 /* The wrapper is on the RHS of an assignment that we're pushing 1013 down. */ 1014 gcc_assert (TREE_CODE (temp) == INIT_EXPR 1015 || TREE_CODE (temp) == MODIFY_EXPR); 1016 TREE_OPERAND (temp, 1) = *p; 1017 *p = temp; 1018 } 1019 else 1020 { 1021 temp = create_tmp_var (type, "retval"); 1022 *p = build2 (INIT_EXPR, type, temp, *p); 1023 } 1024 1025 return temp; 1026 } 1027 1028 return NULL_TREE; 1029} 1030 1031/* Prepare calls to builtins to SAVE and RESTORE the stack as well as 1032 a temporary through which they communicate. */ 1033 1034static void 1035build_stack_save_restore (tree *save, tree *restore) 1036{ 1037 tree save_call, tmp_var; 1038 1039 save_call = 1040 build_function_call_expr (implicit_built_in_decls[BUILT_IN_STACK_SAVE], 1041 NULL_TREE); 1042 tmp_var = create_tmp_var (ptr_type_node, "saved_stack"); 1043 1044 *save = build2 (MODIFY_EXPR, ptr_type_node, tmp_var, save_call); 1045 *restore = 1046 build_function_call_expr (implicit_built_in_decls[BUILT_IN_STACK_RESTORE], 1047 tree_cons (NULL_TREE, tmp_var, NULL_TREE)); 1048} 1049 1050/* Gimplify a BIND_EXPR. Just voidify and recurse. */ 1051 1052static enum gimplify_status 1053gimplify_bind_expr (tree *expr_p, tree *pre_p) 1054{ 1055 tree bind_expr = *expr_p; 1056 bool old_save_stack = gimplify_ctxp->save_stack; 1057 tree t; 1058 1059 tree temp = voidify_wrapper_expr (bind_expr, NULL); 1060 1061 /* Mark variables seen in this bind expr. */ 1062 for (t = BIND_EXPR_VARS (bind_expr); t ; t = TREE_CHAIN (t)) 1063 { 1064 if (TREE_CODE (t) == VAR_DECL) 1065 { 1066 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp; 1067 1068 /* Mark variable as local. */ 1069 if (ctx && !is_global_var (t) 1070 && (! DECL_SEEN_IN_BIND_EXPR_P (t) 1071 || splay_tree_lookup (ctx->variables, 1072 (splay_tree_key) t) == NULL)) 1073 omp_add_variable (gimplify_omp_ctxp, t, GOVD_LOCAL | GOVD_SEEN); 1074 1075 DECL_SEEN_IN_BIND_EXPR_P (t) = 1; 1076 } 1077 1078 /* Preliminarily mark non-addressed complex variables as eligible 1079 for promotion to gimple registers. We'll transform their uses 1080 as we find them. */ 1081 if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE 1082 && !TREE_THIS_VOLATILE (t) 1083 && (TREE_CODE (t) == VAR_DECL && !DECL_HARD_REGISTER (t)) 1084 && !needs_to_live_in_memory (t)) 1085 DECL_COMPLEX_GIMPLE_REG_P (t) = 1; 1086 } 1087 1088 gimple_push_bind_expr (bind_expr); 1089 gimplify_ctxp->save_stack = false; 1090 1091 gimplify_to_stmt_list (&BIND_EXPR_BODY (bind_expr)); 1092 1093 if (gimplify_ctxp->save_stack) 1094 { 1095 tree stack_save, stack_restore; 1096 1097 /* Save stack on entry and restore it on exit. Add a try_finally 1098 block to achieve this. Note that mudflap depends on the 1099 format of the emitted code: see mx_register_decls(). */ 1100 build_stack_save_restore (&stack_save, &stack_restore); 1101 1102 t = build2 (TRY_FINALLY_EXPR, void_type_node, 1103 BIND_EXPR_BODY (bind_expr), NULL_TREE); 1104 append_to_statement_list (stack_restore, &TREE_OPERAND (t, 1)); 1105 1106 BIND_EXPR_BODY (bind_expr) = NULL_TREE; 1107 append_to_statement_list (stack_save, &BIND_EXPR_BODY (bind_expr)); 1108 append_to_statement_list (t, &BIND_EXPR_BODY (bind_expr)); 1109 } 1110 1111 gimplify_ctxp->save_stack = old_save_stack; 1112 gimple_pop_bind_expr (); 1113 1114 if (temp) 1115 { 1116 *expr_p = temp; 1117 append_to_statement_list (bind_expr, pre_p); 1118 return GS_OK; 1119 } 1120 else 1121 return GS_ALL_DONE; 1122} 1123 1124/* Gimplify a RETURN_EXPR. If the expression to be returned is not a 1125 GIMPLE value, it is assigned to a new temporary and the statement is 1126 re-written to return the temporary. 1127 1128 PRE_P points to the list where side effects that must happen before 1129 STMT should be stored. */ 1130 1131static enum gimplify_status 1132gimplify_return_expr (tree stmt, tree *pre_p) 1133{ 1134 tree ret_expr = TREE_OPERAND (stmt, 0); 1135 tree result_decl, result; 1136 1137 if (!ret_expr || TREE_CODE (ret_expr) == RESULT_DECL 1138 || ret_expr == error_mark_node) 1139 return GS_ALL_DONE; 1140 1141 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))) 1142 result_decl = NULL_TREE; 1143 else 1144 { 1145 result_decl = TREE_OPERAND (ret_expr, 0); 1146 if (TREE_CODE (result_decl) == INDIRECT_REF) 1147 /* See through a return by reference. */ 1148 result_decl = TREE_OPERAND (result_decl, 0); 1149 1150 gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR 1151 || TREE_CODE (ret_expr) == INIT_EXPR) 1152 && TREE_CODE (result_decl) == RESULT_DECL); 1153 } 1154 1155 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL. 1156 Recall that aggregate_value_p is FALSE for any aggregate type that is 1157 returned in registers. If we're returning values in registers, then 1158 we don't want to extend the lifetime of the RESULT_DECL, particularly 1159 across another call. In addition, for those aggregates for which 1160 hard_function_value generates a PARALLEL, we'll die during normal 1161 expansion of structure assignments; there's special code in expand_return 1162 to handle this case that does not exist in expand_expr. */ 1163 if (!result_decl 1164 || aggregate_value_p (result_decl, TREE_TYPE (current_function_decl))) 1165 result = result_decl; 1166 else if (gimplify_ctxp->return_temp) 1167 result = gimplify_ctxp->return_temp; 1168 else 1169 { 1170 result = create_tmp_var (TREE_TYPE (result_decl), NULL); 1171 1172 /* ??? With complex control flow (usually involving abnormal edges), 1173 we can wind up warning about an uninitialized value for this. Due 1174 to how this variable is constructed and initialized, this is never 1175 true. Give up and never warn. */ 1176 TREE_NO_WARNING (result) = 1; 1177 1178 gimplify_ctxp->return_temp = result; 1179 } 1180 1181 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use. 1182 Then gimplify the whole thing. */ 1183 if (result != result_decl) 1184 TREE_OPERAND (ret_expr, 0) = result; 1185 1186 gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p); 1187 1188 /* If we didn't use a temporary, then the result is just the result_decl. 1189 Otherwise we need a simple copy. This should already be gimple. */ 1190 if (result == result_decl) 1191 ret_expr = result; 1192 else 1193 ret_expr = build2 (MODIFY_EXPR, TREE_TYPE (result), result_decl, result); 1194 TREE_OPERAND (stmt, 0) = ret_expr; 1195 1196 return GS_ALL_DONE; 1197} 1198 1199/* Gimplifies a DECL_EXPR node *STMT_P by making any necessary allocation 1200 and initialization explicit. */ 1201 1202static enum gimplify_status 1203gimplify_decl_expr (tree *stmt_p) 1204{ 1205 tree stmt = *stmt_p; 1206 tree decl = DECL_EXPR_DECL (stmt); 1207 1208 *stmt_p = NULL_TREE; 1209 1210 if (TREE_TYPE (decl) == error_mark_node) 1211 return GS_ERROR; 1212 1213 if ((TREE_CODE (decl) == TYPE_DECL 1214 || TREE_CODE (decl) == VAR_DECL) 1215 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl))) 1216 gimplify_type_sizes (TREE_TYPE (decl), stmt_p); 1217 1218 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl)) 1219 { 1220 tree init = DECL_INITIAL (decl); 1221 1222 if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST) 1223 { 1224 /* This is a variable-sized decl. Simplify its size and mark it 1225 for deferred expansion. Note that mudflap depends on the format 1226 of the emitted code: see mx_register_decls(). */ 1227 tree t, args, addr, ptr_type; 1228 1229 gimplify_one_sizepos (&DECL_SIZE (decl), stmt_p); 1230 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), stmt_p); 1231 1232 /* All occurrences of this decl in final gimplified code will be 1233 replaced by indirection. Setting DECL_VALUE_EXPR does two 1234 things: First, it lets the rest of the gimplifier know what 1235 replacement to use. Second, it lets the debug info know 1236 where to find the value. */ 1237 ptr_type = build_pointer_type (TREE_TYPE (decl)); 1238 addr = create_tmp_var (ptr_type, get_name (decl)); 1239 DECL_IGNORED_P (addr) = 0; 1240 t = build_fold_indirect_ref (addr); 1241 SET_DECL_VALUE_EXPR (decl, t); 1242 DECL_HAS_VALUE_EXPR_P (decl) = 1; 1243 1244 args = tree_cons (NULL, DECL_SIZE_UNIT (decl), NULL); 1245 t = built_in_decls[BUILT_IN_ALLOCA]; 1246 t = build_function_call_expr (t, args); 1247 t = fold_convert (ptr_type, t); 1248 t = build2 (MODIFY_EXPR, void_type_node, addr, t); 1249 1250 gimplify_and_add (t, stmt_p); 1251 1252 /* Indicate that we need to restore the stack level when the 1253 enclosing BIND_EXPR is exited. */ 1254 gimplify_ctxp->save_stack = true; 1255 } 1256 1257 if (init && init != error_mark_node) 1258 { 1259 if (!TREE_STATIC (decl)) 1260 { 1261 DECL_INITIAL (decl) = NULL_TREE; 1262 init = build2 (INIT_EXPR, void_type_node, decl, init); 1263 gimplify_and_add (init, stmt_p); 1264 } 1265 else 1266 /* We must still examine initializers for static variables 1267 as they may contain a label address. */ 1268 walk_tree (&init, force_labels_r, NULL, NULL); 1269 } 1270 1271 /* Some front ends do not explicitly declare all anonymous 1272 artificial variables. We compensate here by declaring the 1273 variables, though it would be better if the front ends would 1274 explicitly declare them. */ 1275 if (!DECL_SEEN_IN_BIND_EXPR_P (decl) 1276 && DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE) 1277 gimple_add_tmp_var (decl); 1278 } 1279 1280 return GS_ALL_DONE; 1281} 1282 1283/* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body 1284 and replacing the LOOP_EXPR with goto, but if the loop contains an 1285 EXIT_EXPR, we need to append a label for it to jump to. */ 1286 1287static enum gimplify_status 1288gimplify_loop_expr (tree *expr_p, tree *pre_p) 1289{ 1290 tree saved_label = gimplify_ctxp->exit_label; 1291 tree start_label = build1 (LABEL_EXPR, void_type_node, NULL_TREE); 1292 tree jump_stmt = build_and_jump (&LABEL_EXPR_LABEL (start_label)); 1293 1294 append_to_statement_list (start_label, pre_p); 1295 1296 gimplify_ctxp->exit_label = NULL_TREE; 1297 1298 gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p); 1299 1300 if (gimplify_ctxp->exit_label) 1301 { 1302 append_to_statement_list (jump_stmt, pre_p); 1303 *expr_p = build1 (LABEL_EXPR, void_type_node, gimplify_ctxp->exit_label); 1304 } 1305 else 1306 *expr_p = jump_stmt; 1307 1308 gimplify_ctxp->exit_label = saved_label; 1309 1310 return GS_ALL_DONE; 1311} 1312 1313/* Compare two case labels. Because the front end should already have 1314 made sure that case ranges do not overlap, it is enough to only compare 1315 the CASE_LOW values of each case label. */ 1316 1317static int 1318compare_case_labels (const void *p1, const void *p2) 1319{ 1320 tree case1 = *(tree *)p1; 1321 tree case2 = *(tree *)p2; 1322 1323 return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2)); 1324} 1325 1326/* Sort the case labels in LABEL_VEC in place in ascending order. */ 1327 1328void 1329sort_case_labels (tree label_vec) 1330{ 1331 size_t len = TREE_VEC_LENGTH (label_vec); 1332 tree default_case = TREE_VEC_ELT (label_vec, len - 1); 1333 1334 if (CASE_LOW (default_case)) 1335 { 1336 size_t i; 1337 1338 /* The last label in the vector should be the default case 1339 but it is not. */ 1340 for (i = 0; i < len; ++i) 1341 { 1342 tree t = TREE_VEC_ELT (label_vec, i); 1343 if (!CASE_LOW (t)) 1344 { 1345 default_case = t; 1346 TREE_VEC_ELT (label_vec, i) = TREE_VEC_ELT (label_vec, len - 1); 1347 TREE_VEC_ELT (label_vec, len - 1) = default_case; 1348 break; 1349 } 1350 } 1351 } 1352 1353 qsort (&TREE_VEC_ELT (label_vec, 0), len - 1, sizeof (tree), 1354 compare_case_labels); 1355} 1356 1357/* Gimplify a SWITCH_EXPR, and collect a TREE_VEC of the labels it can 1358 branch to. */ 1359 1360static enum gimplify_status 1361gimplify_switch_expr (tree *expr_p, tree *pre_p) 1362{ 1363 tree switch_expr = *expr_p; 1364 enum gimplify_status ret; 1365 1366 ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL, 1367 is_gimple_val, fb_rvalue); 1368 1369 if (SWITCH_BODY (switch_expr)) 1370 { 1371 VEC(tree,heap) *labels, *saved_labels; 1372 tree label_vec, default_case = NULL_TREE; 1373 size_t i, len; 1374 1375 /* If someone can be bothered to fill in the labels, they can 1376 be bothered to null out the body too. */ 1377 gcc_assert (!SWITCH_LABELS (switch_expr)); 1378 1379 saved_labels = gimplify_ctxp->case_labels; 1380 gimplify_ctxp->case_labels = VEC_alloc (tree, heap, 8); 1381 1382 gimplify_to_stmt_list (&SWITCH_BODY (switch_expr)); 1383 1384 labels = gimplify_ctxp->case_labels; 1385 gimplify_ctxp->case_labels = saved_labels; 1386 1387 i = 0; 1388 while (i < VEC_length (tree, labels)) 1389 { 1390 tree elt = VEC_index (tree, labels, i); 1391 tree low = CASE_LOW (elt); 1392 bool remove_element = FALSE; 1393 1394 if (low) 1395 { 1396 /* Discard empty ranges. */ 1397 tree high = CASE_HIGH (elt); 1398 if (high && INT_CST_LT (high, low)) 1399 remove_element = TRUE; 1400 } 1401 else 1402 { 1403 /* The default case must be the last label in the list. */ 1404 gcc_assert (!default_case); 1405 default_case = elt; 1406 remove_element = TRUE; 1407 } 1408 1409 if (remove_element) 1410 VEC_ordered_remove (tree, labels, i); 1411 else 1412 i++; 1413 } 1414 len = i; 1415 1416 label_vec = make_tree_vec (len + 1); 1417 SWITCH_LABELS (*expr_p) = label_vec; 1418 append_to_statement_list (switch_expr, pre_p); 1419 1420 if (! default_case) 1421 { 1422 /* If the switch has no default label, add one, so that we jump 1423 around the switch body. */ 1424 default_case = build3 (CASE_LABEL_EXPR, void_type_node, NULL_TREE, 1425 NULL_TREE, create_artificial_label ()); 1426 append_to_statement_list (SWITCH_BODY (switch_expr), pre_p); 1427 *expr_p = build1 (LABEL_EXPR, void_type_node, 1428 CASE_LABEL (default_case)); 1429 } 1430 else 1431 *expr_p = SWITCH_BODY (switch_expr); 1432 1433 for (i = 0; i < len; ++i) 1434 TREE_VEC_ELT (label_vec, i) = VEC_index (tree, labels, i); 1435 TREE_VEC_ELT (label_vec, len) = default_case; 1436 1437 VEC_free (tree, heap, labels); 1438 1439 sort_case_labels (label_vec); 1440 1441 SWITCH_BODY (switch_expr) = NULL; 1442 } 1443 else 1444 gcc_assert (SWITCH_LABELS (switch_expr)); 1445 1446 return ret; 1447} 1448 1449static enum gimplify_status 1450gimplify_case_label_expr (tree *expr_p) 1451{ 1452 tree expr = *expr_p; 1453 struct gimplify_ctx *ctxp; 1454 1455 /* Invalid OpenMP programs can play Duff's Device type games with 1456 #pragma omp parallel. At least in the C front end, we don't 1457 detect such invalid branches until after gimplification. */ 1458 for (ctxp = gimplify_ctxp; ; ctxp = ctxp->prev_context) 1459 if (ctxp->case_labels) 1460 break; 1461 1462 VEC_safe_push (tree, heap, ctxp->case_labels, expr); 1463 *expr_p = build1 (LABEL_EXPR, void_type_node, CASE_LABEL (expr)); 1464 return GS_ALL_DONE; 1465} 1466 1467/* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first 1468 if necessary. */ 1469 1470tree 1471build_and_jump (tree *label_p) 1472{ 1473 if (label_p == NULL) 1474 /* If there's nowhere to jump, just fall through. */ 1475 return NULL_TREE; 1476 1477 if (*label_p == NULL_TREE) 1478 { 1479 tree label = create_artificial_label (); 1480 *label_p = label; 1481 } 1482 1483 return build1 (GOTO_EXPR, void_type_node, *label_p); 1484} 1485 1486/* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR. 1487 This also involves building a label to jump to and communicating it to 1488 gimplify_loop_expr through gimplify_ctxp->exit_label. */ 1489 1490static enum gimplify_status 1491gimplify_exit_expr (tree *expr_p) 1492{ 1493 tree cond = TREE_OPERAND (*expr_p, 0); 1494 tree expr; 1495 1496 expr = build_and_jump (&gimplify_ctxp->exit_label); 1497 expr = build3 (COND_EXPR, void_type_node, cond, expr, NULL_TREE); 1498 *expr_p = expr; 1499 1500 return GS_OK; 1501} 1502 1503/* A helper function to be called via walk_tree. Mark all labels under *TP 1504 as being forced. To be called for DECL_INITIAL of static variables. */ 1505 1506tree 1507force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) 1508{ 1509 if (TYPE_P (*tp)) 1510 *walk_subtrees = 0; 1511 if (TREE_CODE (*tp) == LABEL_DECL) 1512 FORCED_LABEL (*tp) = 1; 1513 1514 return NULL_TREE; 1515} 1516 1517/* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is 1518 different from its canonical type, wrap the whole thing inside a 1519 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical 1520 type. 1521 1522 The canonical type of a COMPONENT_REF is the type of the field being 1523 referenced--unless the field is a bit-field which can be read directly 1524 in a smaller mode, in which case the canonical type is the 1525 sign-appropriate type corresponding to that mode. */ 1526 1527static void 1528canonicalize_component_ref (tree *expr_p) 1529{ 1530 tree expr = *expr_p; 1531 tree type; 1532 1533 gcc_assert (TREE_CODE (expr) == COMPONENT_REF); 1534 1535 if (INTEGRAL_TYPE_P (TREE_TYPE (expr))) 1536 type = TREE_TYPE (get_unwidened (expr, NULL_TREE)); 1537 else 1538 type = TREE_TYPE (TREE_OPERAND (expr, 1)); 1539 1540 if (TREE_TYPE (expr) != type) 1541 { 1542 tree old_type = TREE_TYPE (expr); 1543 1544 /* Set the type of the COMPONENT_REF to the underlying type. */ 1545 TREE_TYPE (expr) = type; 1546 1547 /* And wrap the whole thing inside a NOP_EXPR. */ 1548 expr = build1 (NOP_EXPR, old_type, expr); 1549 1550 *expr_p = expr; 1551 } 1552} 1553 1554/* If a NOP conversion is changing a pointer to array of foo to a pointer 1555 to foo, embed that change in the ADDR_EXPR by converting 1556 T array[U]; 1557 (T *)&array 1558 ==> 1559 &array[L] 1560 where L is the lower bound. For simplicity, only do this for constant 1561 lower bound. */ 1562 1563static void 1564canonicalize_addr_expr (tree *expr_p) 1565{ 1566 tree expr = *expr_p; 1567 tree ctype = TREE_TYPE (expr); 1568 tree addr_expr = TREE_OPERAND (expr, 0); 1569 tree atype = TREE_TYPE (addr_expr); 1570 tree dctype, datype, ddatype, otype, obj_expr; 1571 1572 /* Both cast and addr_expr types should be pointers. */ 1573 if (!POINTER_TYPE_P (ctype) || !POINTER_TYPE_P (atype)) 1574 return; 1575 1576 /* The addr_expr type should be a pointer to an array. */ 1577 datype = TREE_TYPE (atype); 1578 if (TREE_CODE (datype) != ARRAY_TYPE) 1579 return; 1580 1581 /* Both cast and addr_expr types should address the same object type. */ 1582 dctype = TREE_TYPE (ctype); 1583 ddatype = TREE_TYPE (datype); 1584 if (!lang_hooks.types_compatible_p (ddatype, dctype)) 1585 return; 1586 1587 /* The addr_expr and the object type should match. */ 1588 obj_expr = TREE_OPERAND (addr_expr, 0); 1589 otype = TREE_TYPE (obj_expr); 1590 if (!lang_hooks.types_compatible_p (otype, datype)) 1591 return; 1592 1593 /* The lower bound and element sizes must be constant. */ 1594 if (!TYPE_SIZE_UNIT (dctype) 1595 || TREE_CODE (TYPE_SIZE_UNIT (dctype)) != INTEGER_CST 1596 || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype)) 1597 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST) 1598 return; 1599 1600 /* All checks succeeded. Build a new node to merge the cast. */ 1601 *expr_p = build4 (ARRAY_REF, dctype, obj_expr, 1602 TYPE_MIN_VALUE (TYPE_DOMAIN (datype)), 1603 TYPE_MIN_VALUE (TYPE_DOMAIN (datype)), 1604 size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (dctype), 1605 size_int (TYPE_ALIGN_UNIT (dctype)))); 1606 *expr_p = build1 (ADDR_EXPR, ctype, *expr_p); 1607} 1608 1609/* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions 1610 underneath as appropriate. */ 1611 1612static enum gimplify_status 1613gimplify_conversion (tree *expr_p) 1614{ 1615 gcc_assert (TREE_CODE (*expr_p) == NOP_EXPR 1616 || TREE_CODE (*expr_p) == CONVERT_EXPR); 1617 1618 /* Then strip away all but the outermost conversion. */ 1619 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0)); 1620 1621 /* And remove the outermost conversion if it's useless. */ 1622 if (tree_ssa_useless_type_conversion (*expr_p)) 1623 *expr_p = TREE_OPERAND (*expr_p, 0); 1624 1625 /* If we still have a conversion at the toplevel, 1626 then canonicalize some constructs. */ 1627 if (TREE_CODE (*expr_p) == NOP_EXPR || TREE_CODE (*expr_p) == CONVERT_EXPR) 1628 { 1629 tree sub = TREE_OPERAND (*expr_p, 0); 1630 1631 /* If a NOP conversion is changing the type of a COMPONENT_REF 1632 expression, then canonicalize its type now in order to expose more 1633 redundant conversions. */ 1634 if (TREE_CODE (sub) == COMPONENT_REF) 1635 canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0)); 1636 1637 /* If a NOP conversion is changing a pointer to array of foo 1638 to a pointer to foo, embed that change in the ADDR_EXPR. */ 1639 else if (TREE_CODE (sub) == ADDR_EXPR) 1640 canonicalize_addr_expr (expr_p); 1641 } 1642 1643 return GS_OK; 1644} 1645 1646/* Gimplify a VAR_DECL or PARM_DECL. Returns GS_OK if we expanded a 1647 DECL_VALUE_EXPR, and it's worth re-examining things. */ 1648 1649static enum gimplify_status 1650gimplify_var_or_parm_decl (tree *expr_p) 1651{ 1652 tree decl = *expr_p; 1653 1654 /* ??? If this is a local variable, and it has not been seen in any 1655 outer BIND_EXPR, then it's probably the result of a duplicate 1656 declaration, for which we've already issued an error. It would 1657 be really nice if the front end wouldn't leak these at all. 1658 Currently the only known culprit is C++ destructors, as seen 1659 in g++.old-deja/g++.jason/binding.C. */ 1660 if (TREE_CODE (decl) == VAR_DECL 1661 && !DECL_SEEN_IN_BIND_EXPR_P (decl) 1662 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl) 1663 && decl_function_context (decl) == current_function_decl) 1664 { 1665 gcc_assert (errorcount || sorrycount); 1666 return GS_ERROR; 1667 } 1668 1669 /* When within an OpenMP context, notice uses of variables. */ 1670 if (gimplify_omp_ctxp && omp_notice_variable (gimplify_omp_ctxp, decl, true)) 1671 return GS_ALL_DONE; 1672 1673 /* If the decl is an alias for another expression, substitute it now. */ 1674 if (DECL_HAS_VALUE_EXPR_P (decl)) 1675 { 1676 *expr_p = unshare_expr (DECL_VALUE_EXPR (decl)); 1677 return GS_OK; 1678 } 1679 1680 return GS_ALL_DONE; 1681} 1682 1683 1684/* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR 1685 node pointed to by EXPR_P. 1686 1687 compound_lval 1688 : min_lval '[' val ']' 1689 | min_lval '.' ID 1690 | compound_lval '[' val ']' 1691 | compound_lval '.' ID 1692 1693 This is not part of the original SIMPLE definition, which separates 1694 array and member references, but it seems reasonable to handle them 1695 together. Also, this way we don't run into problems with union 1696 aliasing; gcc requires that for accesses through a union to alias, the 1697 union reference must be explicit, which was not always the case when we 1698 were splitting up array and member refs. 1699 1700 PRE_P points to the list where side effects that must happen before 1701 *EXPR_P should be stored. 1702 1703 POST_P points to the list where side effects that must happen after 1704 *EXPR_P should be stored. */ 1705 1706static enum gimplify_status 1707gimplify_compound_lval (tree *expr_p, tree *pre_p, 1708 tree *post_p, fallback_t fallback) 1709{ 1710 tree *p; 1711 VEC(tree,heap) *stack; 1712 enum gimplify_status ret = GS_OK, tret; 1713 int i; 1714 1715 /* Create a stack of the subexpressions so later we can walk them in 1716 order from inner to outer. */ 1717 stack = VEC_alloc (tree, heap, 10); 1718 1719 /* We can handle anything that get_inner_reference can deal with. */ 1720 for (p = expr_p; ; p = &TREE_OPERAND (*p, 0)) 1721 { 1722 restart: 1723 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */ 1724 if (TREE_CODE (*p) == INDIRECT_REF) 1725 *p = fold_indirect_ref (*p); 1726 1727 if (handled_component_p (*p)) 1728 ; 1729 /* Expand DECL_VALUE_EXPR now. In some cases that may expose 1730 additional COMPONENT_REFs. */ 1731 else if ((TREE_CODE (*p) == VAR_DECL || TREE_CODE (*p) == PARM_DECL) 1732 && gimplify_var_or_parm_decl (p) == GS_OK) 1733 goto restart; 1734 else 1735 break; 1736 1737 VEC_safe_push (tree, heap, stack, *p); 1738 } 1739 1740 gcc_assert (VEC_length (tree, stack)); 1741 1742 /* Now STACK is a stack of pointers to all the refs we've walked through 1743 and P points to the innermost expression. 1744 1745 Java requires that we elaborated nodes in source order. That 1746 means we must gimplify the inner expression followed by each of 1747 the indices, in order. But we can't gimplify the inner 1748 expression until we deal with any variable bounds, sizes, or 1749 positions in order to deal with PLACEHOLDER_EXPRs. 1750 1751 So we do this in three steps. First we deal with the annotations 1752 for any variables in the components, then we gimplify the base, 1753 then we gimplify any indices, from left to right. */ 1754 for (i = VEC_length (tree, stack) - 1; i >= 0; i--) 1755 { 1756 tree t = VEC_index (tree, stack, i); 1757 1758 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF) 1759 { 1760 /* Gimplify the low bound and element type size and put them into 1761 the ARRAY_REF. If these values are set, they have already been 1762 gimplified. */ 1763 if (!TREE_OPERAND (t, 2)) 1764 { 1765 tree low = unshare_expr (array_ref_low_bound (t)); 1766 if (!is_gimple_min_invariant (low)) 1767 { 1768 TREE_OPERAND (t, 2) = low; 1769 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p, 1770 is_gimple_formal_tmp_reg, fb_rvalue); 1771 ret = MIN (ret, tret); 1772 } 1773 } 1774 1775 if (!TREE_OPERAND (t, 3)) 1776 { 1777 tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))); 1778 tree elmt_size = unshare_expr (array_ref_element_size (t)); 1779 tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type)); 1780 1781 /* Divide the element size by the alignment of the element 1782 type (above). */ 1783 elmt_size = size_binop (EXACT_DIV_EXPR, elmt_size, factor); 1784 1785 if (!is_gimple_min_invariant (elmt_size)) 1786 { 1787 TREE_OPERAND (t, 3) = elmt_size; 1788 tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p, post_p, 1789 is_gimple_formal_tmp_reg, fb_rvalue); 1790 ret = MIN (ret, tret); 1791 } 1792 } 1793 } 1794 else if (TREE_CODE (t) == COMPONENT_REF) 1795 { 1796 /* Set the field offset into T and gimplify it. */ 1797 if (!TREE_OPERAND (t, 2)) 1798 { 1799 tree offset = unshare_expr (component_ref_field_offset (t)); 1800 tree field = TREE_OPERAND (t, 1); 1801 tree factor 1802 = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT); 1803 1804 /* Divide the offset by its alignment. */ 1805 offset = size_binop (EXACT_DIV_EXPR, offset, factor); 1806 1807 if (!is_gimple_min_invariant (offset)) 1808 { 1809 TREE_OPERAND (t, 2) = offset; 1810 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p, 1811 is_gimple_formal_tmp_reg, fb_rvalue); 1812 ret = MIN (ret, tret); 1813 } 1814 } 1815 } 1816 } 1817 1818 /* Step 2 is to gimplify the base expression. Make sure lvalue is set 1819 so as to match the min_lval predicate. Failure to do so may result 1820 in the creation of large aggregate temporaries. */ 1821 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval, 1822 fallback | fb_lvalue); 1823 ret = MIN (ret, tret); 1824 1825 /* And finally, the indices and operands to BIT_FIELD_REF. During this 1826 loop we also remove any useless conversions. */ 1827 for (; VEC_length (tree, stack) > 0; ) 1828 { 1829 tree t = VEC_pop (tree, stack); 1830 1831 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF) 1832 { 1833 /* Gimplify the dimension. 1834 Temporary fix for gcc.c-torture/execute/20040313-1.c. 1835 Gimplify non-constant array indices into a temporary 1836 variable. 1837 FIXME - The real fix is to gimplify post-modify 1838 expressions into a minimal gimple lvalue. However, that 1839 exposes bugs in alias analysis. The alias analyzer does 1840 not handle &PTR->FIELD very well. Will fix after the 1841 branch is merged into mainline (dnovillo 2004-05-03). */ 1842 if (!is_gimple_min_invariant (TREE_OPERAND (t, 1))) 1843 { 1844 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p, 1845 is_gimple_formal_tmp_reg, fb_rvalue); 1846 ret = MIN (ret, tret); 1847 } 1848 } 1849 else if (TREE_CODE (t) == BIT_FIELD_REF) 1850 { 1851 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p, 1852 is_gimple_val, fb_rvalue); 1853 ret = MIN (ret, tret); 1854 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p, 1855 is_gimple_val, fb_rvalue); 1856 ret = MIN (ret, tret); 1857 } 1858 1859 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0)); 1860 1861 /* The innermost expression P may have originally had TREE_SIDE_EFFECTS 1862 set which would have caused all the outer expressions in EXPR_P 1863 leading to P to also have had TREE_SIDE_EFFECTS set. */ 1864 recalculate_side_effects (t); 1865 } 1866 1867 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval, fallback); 1868 ret = MIN (ret, tret); 1869 1870 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */ 1871 if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF) 1872 { 1873 canonicalize_component_ref (expr_p); 1874 ret = MIN (ret, GS_OK); 1875 } 1876 1877 VEC_free (tree, heap, stack); 1878 1879 return ret; 1880} 1881 1882/* Gimplify the self modifying expression pointed to by EXPR_P 1883 (++, --, +=, -=). 1884 1885 PRE_P points to the list where side effects that must happen before 1886 *EXPR_P should be stored. 1887 1888 POST_P points to the list where side effects that must happen after 1889 *EXPR_P should be stored. 1890 1891 WANT_VALUE is nonzero iff we want to use the value of this expression 1892 in another expression. */ 1893 1894static enum gimplify_status 1895gimplify_self_mod_expr (tree *expr_p, tree *pre_p, tree *post_p, 1896 bool want_value) 1897{ 1898 enum tree_code code; 1899 tree lhs, lvalue, rhs, t1, post = NULL, *orig_post_p = post_p; 1900 bool postfix; 1901 enum tree_code arith_code; 1902 enum gimplify_status ret; 1903 1904 code = TREE_CODE (*expr_p); 1905 1906 gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR 1907 || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR); 1908 1909 /* Prefix or postfix? */ 1910 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR) 1911 /* Faster to treat as prefix if result is not used. */ 1912 postfix = want_value; 1913 else 1914 postfix = false; 1915 1916 /* For postfix, make sure the inner expression's post side effects 1917 are executed after side effects from this expression. */ 1918 if (postfix) 1919 post_p = &post; 1920 1921 /* Add or subtract? */ 1922 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 1923 arith_code = PLUS_EXPR; 1924 else 1925 arith_code = MINUS_EXPR; 1926 1927 /* Gimplify the LHS into a GIMPLE lvalue. */ 1928 lvalue = TREE_OPERAND (*expr_p, 0); 1929 ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue); 1930 if (ret == GS_ERROR) 1931 return ret; 1932 1933 /* Extract the operands to the arithmetic operation. */ 1934 lhs = lvalue; 1935 rhs = TREE_OPERAND (*expr_p, 1); 1936 1937 /* For postfix operator, we evaluate the LHS to an rvalue and then use 1938 that as the result value and in the postqueue operation. */ 1939 if (postfix) 1940 { 1941 ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue); 1942 if (ret == GS_ERROR) 1943 return ret; 1944 } 1945 1946 t1 = build2 (arith_code, TREE_TYPE (*expr_p), lhs, rhs); 1947 t1 = build2 (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1); 1948 1949 if (postfix) 1950 { 1951 gimplify_and_add (t1, orig_post_p); 1952 append_to_statement_list (post, orig_post_p); 1953 *expr_p = lhs; 1954 return GS_ALL_DONE; 1955 } 1956 else 1957 { 1958 *expr_p = t1; 1959 return GS_OK; 1960 } 1961} 1962 1963/* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */ 1964 1965static void 1966maybe_with_size_expr (tree *expr_p) 1967{ 1968 tree expr = *expr_p; 1969 tree type = TREE_TYPE (expr); 1970 tree size; 1971 1972 /* If we've already wrapped this or the type is error_mark_node, we can't do 1973 anything. */ 1974 if (TREE_CODE (expr) == WITH_SIZE_EXPR 1975 || type == error_mark_node) 1976 return; 1977 1978 /* If the size isn't known or is a constant, we have nothing to do. */ 1979 size = TYPE_SIZE_UNIT (type); 1980 if (!size || TREE_CODE (size) == INTEGER_CST) 1981 return; 1982 1983 /* Otherwise, make a WITH_SIZE_EXPR. */ 1984 size = unshare_expr (size); 1985 size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr); 1986 *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size); 1987} 1988 1989/* Subroutine of gimplify_call_expr: Gimplify a single argument. */ 1990 1991static enum gimplify_status 1992gimplify_arg (tree *expr_p, tree *pre_p) 1993{ 1994 bool (*test) (tree); 1995 fallback_t fb; 1996 1997 /* In general, we allow lvalues for function arguments to avoid 1998 extra overhead of copying large aggregates out of even larger 1999 aggregates into temporaries only to copy the temporaries to 2000 the argument list. Make optimizers happy by pulling out to 2001 temporaries those types that fit in registers. */ 2002 if (is_gimple_reg_type (TREE_TYPE (*expr_p))) 2003 test = is_gimple_val, fb = fb_rvalue; 2004 else 2005 test = is_gimple_lvalue, fb = fb_either; 2006 2007 /* If this is a variable sized type, we must remember the size. */ 2008 maybe_with_size_expr (expr_p); 2009 2010 /* There is a sequence point before a function call. Side effects in 2011 the argument list must occur before the actual call. So, when 2012 gimplifying arguments, force gimplify_expr to use an internal 2013 post queue which is then appended to the end of PRE_P. */ 2014 return gimplify_expr (expr_p, pre_p, NULL, test, fb); 2015} 2016 2017/* Gimplify the CALL_EXPR node pointed to by EXPR_P. PRE_P points to the 2018 list where side effects that must happen before *EXPR_P should be stored. 2019 WANT_VALUE is true if the result of the call is desired. */ 2020 2021static enum gimplify_status 2022gimplify_call_expr (tree *expr_p, tree *pre_p, bool want_value) 2023{ 2024 tree decl; 2025 tree arglist; 2026 enum gimplify_status ret; 2027 2028 gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR); 2029 2030 /* For reliable diagnostics during inlining, it is necessary that 2031 every call_expr be annotated with file and line. */ 2032 if (! EXPR_HAS_LOCATION (*expr_p)) 2033 SET_EXPR_LOCATION (*expr_p, input_location); 2034 2035 /* This may be a call to a builtin function. 2036 2037 Builtin function calls may be transformed into different 2038 (and more efficient) builtin function calls under certain 2039 circumstances. Unfortunately, gimplification can muck things 2040 up enough that the builtin expanders are not aware that certain 2041 transformations are still valid. 2042 2043 So we attempt transformation/gimplification of the call before 2044 we gimplify the CALL_EXPR. At this time we do not manage to 2045 transform all calls in the same manner as the expanders do, but 2046 we do transform most of them. */ 2047 decl = get_callee_fndecl (*expr_p); 2048 if (decl && DECL_BUILT_IN (decl)) 2049 { 2050 tree arglist = TREE_OPERAND (*expr_p, 1); 2051 tree new = fold_builtin (decl, arglist, !want_value); 2052 2053 if (new && new != *expr_p) 2054 { 2055 /* There was a transformation of this call which computes the 2056 same value, but in a more efficient way. Return and try 2057 again. */ 2058 *expr_p = new; 2059 return GS_OK; 2060 } 2061 2062 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL 2063 && DECL_FUNCTION_CODE (decl) == BUILT_IN_VA_START) 2064 { 2065 if (!arglist || !TREE_CHAIN (arglist)) 2066 { 2067 error ("too few arguments to function %<va_start%>"); 2068 *expr_p = build_empty_stmt (); 2069 return GS_OK; 2070 } 2071 2072 if (fold_builtin_next_arg (TREE_CHAIN (arglist))) 2073 { 2074 *expr_p = build_empty_stmt (); 2075 return GS_OK; 2076 } 2077 /* Avoid gimplifying the second argument to va_start, which needs 2078 to be the plain PARM_DECL. */ 2079 return gimplify_arg (&TREE_VALUE (TREE_OPERAND (*expr_p, 1)), pre_p); 2080 } 2081 } 2082 2083 /* There is a sequence point before the call, so any side effects in 2084 the calling expression must occur before the actual call. Force 2085 gimplify_expr to use an internal post queue. */ 2086 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, NULL, 2087 is_gimple_call_addr, fb_rvalue); 2088 2089 if (PUSH_ARGS_REVERSED) 2090 TREE_OPERAND (*expr_p, 1) = nreverse (TREE_OPERAND (*expr_p, 1)); 2091 for (arglist = TREE_OPERAND (*expr_p, 1); arglist; 2092 arglist = TREE_CHAIN (arglist)) 2093 { 2094 enum gimplify_status t; 2095 2096 t = gimplify_arg (&TREE_VALUE (arglist), pre_p); 2097 2098 if (t == GS_ERROR) 2099 ret = GS_ERROR; 2100 } 2101 if (PUSH_ARGS_REVERSED) 2102 TREE_OPERAND (*expr_p, 1) = nreverse (TREE_OPERAND (*expr_p, 1)); 2103 2104 /* Try this again in case gimplification exposed something. */ 2105 if (ret != GS_ERROR) 2106 { 2107 decl = get_callee_fndecl (*expr_p); 2108 if (decl && DECL_BUILT_IN (decl)) 2109 { 2110 tree arglist = TREE_OPERAND (*expr_p, 1); 2111 tree new = fold_builtin (decl, arglist, !want_value); 2112 2113 if (new && new != *expr_p) 2114 { 2115 /* There was a transformation of this call which computes the 2116 same value, but in a more efficient way. Return and try 2117 again. */ 2118 *expr_p = new; 2119 return GS_OK; 2120 } 2121 } 2122 } 2123 2124 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its 2125 decl. This allows us to eliminate redundant or useless 2126 calls to "const" functions. */ 2127 if (TREE_CODE (*expr_p) == CALL_EXPR 2128 && (call_expr_flags (*expr_p) & (ECF_CONST | ECF_PURE))) 2129 TREE_SIDE_EFFECTS (*expr_p) = 0; 2130 2131 return ret; 2132} 2133 2134/* Handle shortcut semantics in the predicate operand of a COND_EXPR by 2135 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs. 2136 2137 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the 2138 condition is true or false, respectively. If null, we should generate 2139 our own to skip over the evaluation of this specific expression. 2140 2141 This function is the tree equivalent of do_jump. 2142 2143 shortcut_cond_r should only be called by shortcut_cond_expr. */ 2144 2145static tree 2146shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p) 2147{ 2148 tree local_label = NULL_TREE; 2149 tree t, expr = NULL; 2150 2151 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to 2152 retain the shortcut semantics. Just insert the gotos here; 2153 shortcut_cond_expr will append the real blocks later. */ 2154 if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR) 2155 { 2156 /* Turn if (a && b) into 2157 2158 if (a); else goto no; 2159 if (b) goto yes; else goto no; 2160 (no:) */ 2161 2162 if (false_label_p == NULL) 2163 false_label_p = &local_label; 2164 2165 t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p); 2166 append_to_statement_list (t, &expr); 2167 2168 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, 2169 false_label_p); 2170 append_to_statement_list (t, &expr); 2171 } 2172 else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR) 2173 { 2174 /* Turn if (a || b) into 2175 2176 if (a) goto yes; 2177 if (b) goto yes; else goto no; 2178 (yes:) */ 2179 2180 if (true_label_p == NULL) 2181 true_label_p = &local_label; 2182 2183 t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL); 2184 append_to_statement_list (t, &expr); 2185 2186 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, 2187 false_label_p); 2188 append_to_statement_list (t, &expr); 2189 } 2190 else if (TREE_CODE (pred) == COND_EXPR) 2191 { 2192 /* As long as we're messing with gotos, turn if (a ? b : c) into 2193 if (a) 2194 if (b) goto yes; else goto no; 2195 else 2196 if (c) goto yes; else goto no; */ 2197 expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0), 2198 shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, 2199 false_label_p), 2200 shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p, 2201 false_label_p)); 2202 } 2203 else 2204 { 2205 expr = build3 (COND_EXPR, void_type_node, pred, 2206 build_and_jump (true_label_p), 2207 build_and_jump (false_label_p)); 2208 } 2209 2210 if (local_label) 2211 { 2212 t = build1 (LABEL_EXPR, void_type_node, local_label); 2213 append_to_statement_list (t, &expr); 2214 } 2215 2216 return expr; 2217} 2218 2219static tree 2220shortcut_cond_expr (tree expr) 2221{ 2222 tree pred = TREE_OPERAND (expr, 0); 2223 tree then_ = TREE_OPERAND (expr, 1); 2224 tree else_ = TREE_OPERAND (expr, 2); 2225 tree true_label, false_label, end_label, t; 2226 tree *true_label_p; 2227 tree *false_label_p; 2228 bool emit_end, emit_false, jump_over_else; 2229 bool then_se = then_ && TREE_SIDE_EFFECTS (then_); 2230 bool else_se = else_ && TREE_SIDE_EFFECTS (else_); 2231 2232 /* First do simple transformations. */ 2233 if (!else_se) 2234 { 2235 /* If there is no 'else', turn (a && b) into if (a) if (b). */ 2236 while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR) 2237 { 2238 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1); 2239 then_ = shortcut_cond_expr (expr); 2240 then_se = then_ && TREE_SIDE_EFFECTS (then_); 2241 pred = TREE_OPERAND (pred, 0); 2242 expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE); 2243 } 2244 } 2245 if (!then_se) 2246 { 2247 /* If there is no 'then', turn 2248 if (a || b); else d 2249 into 2250 if (a); else if (b); else d. */ 2251 while (TREE_CODE (pred) == TRUTH_ORIF_EXPR) 2252 { 2253 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1); 2254 else_ = shortcut_cond_expr (expr); 2255 else_se = else_ && TREE_SIDE_EFFECTS (else_); 2256 pred = TREE_OPERAND (pred, 0); 2257 expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_); 2258 } 2259 } 2260 2261 /* If we're done, great. */ 2262 if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR 2263 && TREE_CODE (pred) != TRUTH_ORIF_EXPR) 2264 return expr; 2265 2266 /* Otherwise we need to mess with gotos. Change 2267 if (a) c; else d; 2268 to 2269 if (a); else goto no; 2270 c; goto end; 2271 no: d; end: 2272 and recursively gimplify the condition. */ 2273 2274 true_label = false_label = end_label = NULL_TREE; 2275 2276 /* If our arms just jump somewhere, hijack those labels so we don't 2277 generate jumps to jumps. */ 2278 2279 if (then_ 2280 && TREE_CODE (then_) == GOTO_EXPR 2281 && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL) 2282 { 2283 true_label = GOTO_DESTINATION (then_); 2284 then_ = NULL; 2285 then_se = false; 2286 } 2287 2288 if (else_ 2289 && TREE_CODE (else_) == GOTO_EXPR 2290 && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL) 2291 { 2292 false_label = GOTO_DESTINATION (else_); 2293 else_ = NULL; 2294 else_se = false; 2295 } 2296 2297 /* If we aren't hijacking a label for the 'then' branch, it falls through. */ 2298 if (true_label) 2299 true_label_p = &true_label; 2300 else 2301 true_label_p = NULL; 2302 2303 /* The 'else' branch also needs a label if it contains interesting code. */ 2304 if (false_label || else_se) 2305 false_label_p = &false_label; 2306 else 2307 false_label_p = NULL; 2308 2309 /* If there was nothing else in our arms, just forward the label(s). */ 2310 if (!then_se && !else_se) 2311 return shortcut_cond_r (pred, true_label_p, false_label_p); 2312 2313 /* If our last subexpression already has a terminal label, reuse it. */ 2314 if (else_se) 2315 expr = expr_last (else_); 2316 else if (then_se) 2317 expr = expr_last (then_); 2318 else 2319 expr = NULL; 2320 if (expr && TREE_CODE (expr) == LABEL_EXPR) 2321 end_label = LABEL_EXPR_LABEL (expr); 2322 2323 /* If we don't care about jumping to the 'else' branch, jump to the end 2324 if the condition is false. */ 2325 if (!false_label_p) 2326 false_label_p = &end_label; 2327 2328 /* We only want to emit these labels if we aren't hijacking them. */ 2329 emit_end = (end_label == NULL_TREE); 2330 emit_false = (false_label == NULL_TREE); 2331 2332 /* We only emit the jump over the else clause if we have to--if the 2333 then clause may fall through. Otherwise we can wind up with a 2334 useless jump and a useless label at the end of gimplified code, 2335 which will cause us to think that this conditional as a whole 2336 falls through even if it doesn't. If we then inline a function 2337 which ends with such a condition, that can cause us to issue an 2338 inappropriate warning about control reaching the end of a 2339 non-void function. */ 2340 jump_over_else = block_may_fallthru (then_); 2341 2342 pred = shortcut_cond_r (pred, true_label_p, false_label_p); 2343 2344 expr = NULL; 2345 append_to_statement_list (pred, &expr); 2346 2347 append_to_statement_list (then_, &expr); 2348 if (else_se) 2349 { 2350 if (jump_over_else) 2351 { 2352 t = build_and_jump (&end_label); 2353 append_to_statement_list (t, &expr); 2354 } 2355 if (emit_false) 2356 { 2357 t = build1 (LABEL_EXPR, void_type_node, false_label); 2358 append_to_statement_list (t, &expr); 2359 } 2360 append_to_statement_list (else_, &expr); 2361 } 2362 if (emit_end && end_label) 2363 { 2364 t = build1 (LABEL_EXPR, void_type_node, end_label); 2365 append_to_statement_list (t, &expr); 2366 } 2367 2368 return expr; 2369} 2370 2371/* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */ 2372 2373tree 2374gimple_boolify (tree expr) 2375{ 2376 tree type = TREE_TYPE (expr); 2377 2378 if (TREE_CODE (type) == BOOLEAN_TYPE) 2379 return expr; 2380 2381 switch (TREE_CODE (expr)) 2382 { 2383 case TRUTH_AND_EXPR: 2384 case TRUTH_OR_EXPR: 2385 case TRUTH_XOR_EXPR: 2386 case TRUTH_ANDIF_EXPR: 2387 case TRUTH_ORIF_EXPR: 2388 /* Also boolify the arguments of truth exprs. */ 2389 TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1)); 2390 /* FALLTHRU */ 2391 2392 case TRUTH_NOT_EXPR: 2393 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0)); 2394 /* FALLTHRU */ 2395 2396 case EQ_EXPR: case NE_EXPR: 2397 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR: 2398 /* These expressions always produce boolean results. */ 2399 TREE_TYPE (expr) = boolean_type_node; 2400 return expr; 2401 2402 default: 2403 /* Other expressions that get here must have boolean values, but 2404 might need to be converted to the appropriate mode. */ 2405 return fold_convert (boolean_type_node, expr); 2406 } 2407} 2408 2409/* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;' 2410 into 2411 2412 if (p) if (p) 2413 t1 = a; a; 2414 else or else 2415 t1 = b; b; 2416 t1; 2417 2418 The second form is used when *EXPR_P is of type void. 2419 2420 TARGET is the tree for T1 above. 2421 2422 PRE_P points to the list where side effects that must happen before 2423 *EXPR_P should be stored. */ 2424 2425static enum gimplify_status 2426gimplify_cond_expr (tree *expr_p, tree *pre_p, fallback_t fallback) 2427{ 2428 tree expr = *expr_p; 2429 tree tmp, tmp2, type; 2430 enum gimplify_status ret; 2431 2432 type = TREE_TYPE (expr); 2433 2434 /* If this COND_EXPR has a value, copy the values into a temporary within 2435 the arms. */ 2436 if (! VOID_TYPE_P (type)) 2437 { 2438 tree result; 2439 2440 if ((fallback & fb_lvalue) == 0) 2441 { 2442 result = tmp2 = tmp = create_tmp_var (TREE_TYPE (expr), "iftmp"); 2443 ret = GS_ALL_DONE; 2444 } 2445 else 2446 { 2447 tree type = build_pointer_type (TREE_TYPE (expr)); 2448 2449 if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node) 2450 TREE_OPERAND (expr, 1) = 2451 build_fold_addr_expr (TREE_OPERAND (expr, 1)); 2452 2453 if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node) 2454 TREE_OPERAND (expr, 2) = 2455 build_fold_addr_expr (TREE_OPERAND (expr, 2)); 2456 2457 tmp2 = tmp = create_tmp_var (type, "iftmp"); 2458 2459 expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (expr, 0), 2460 TREE_OPERAND (expr, 1), TREE_OPERAND (expr, 2)); 2461 2462 result = build_fold_indirect_ref (tmp); 2463 ret = GS_ALL_DONE; 2464 } 2465 2466 /* Build the then clause, 't1 = a;'. But don't build an assignment 2467 if this branch is void; in C++ it can be, if it's a throw. */ 2468 if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node) 2469 TREE_OPERAND (expr, 1) 2470 = build2 (MODIFY_EXPR, void_type_node, tmp, TREE_OPERAND (expr, 1)); 2471 2472 /* Build the else clause, 't1 = b;'. */ 2473 if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node) 2474 TREE_OPERAND (expr, 2) 2475 = build2 (MODIFY_EXPR, void_type_node, tmp2, TREE_OPERAND (expr, 2)); 2476 2477 TREE_TYPE (expr) = void_type_node; 2478 recalculate_side_effects (expr); 2479 2480 /* Move the COND_EXPR to the prequeue. */ 2481 gimplify_and_add (expr, pre_p); 2482 2483 *expr_p = result; 2484 return ret; 2485 } 2486 2487 /* Make sure the condition has BOOLEAN_TYPE. */ 2488 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0)); 2489 2490 /* Break apart && and || conditions. */ 2491 if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR 2492 || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR) 2493 { 2494 expr = shortcut_cond_expr (expr); 2495 2496 if (expr != *expr_p) 2497 { 2498 *expr_p = expr; 2499 2500 /* We can't rely on gimplify_expr to re-gimplify the expanded 2501 form properly, as cleanups might cause the target labels to be 2502 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to 2503 set up a conditional context. */ 2504 gimple_push_condition (); 2505 gimplify_stmt (expr_p); 2506 gimple_pop_condition (pre_p); 2507 2508 return GS_ALL_DONE; 2509 } 2510 } 2511 2512 /* Now do the normal gimplification. */ 2513 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL, 2514 is_gimple_condexpr, fb_rvalue); 2515 2516 gimple_push_condition (); 2517 2518 gimplify_to_stmt_list (&TREE_OPERAND (expr, 1)); 2519 gimplify_to_stmt_list (&TREE_OPERAND (expr, 2)); 2520 recalculate_side_effects (expr); 2521 2522 gimple_pop_condition (pre_p); 2523 2524 if (ret == GS_ERROR) 2525 ; 2526 else if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))) 2527 ret = GS_ALL_DONE; 2528 else if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 2))) 2529 /* Rewrite "if (a); else b" to "if (!a) b" */ 2530 { 2531 TREE_OPERAND (expr, 0) = invert_truthvalue (TREE_OPERAND (expr, 0)); 2532 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL, 2533 is_gimple_condexpr, fb_rvalue); 2534 2535 tmp = TREE_OPERAND (expr, 1); 2536 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 2); 2537 TREE_OPERAND (expr, 2) = tmp; 2538 } 2539 else 2540 /* Both arms are empty; replace the COND_EXPR with its predicate. */ 2541 expr = TREE_OPERAND (expr, 0); 2542 2543 *expr_p = expr; 2544 return ret; 2545} 2546 2547/* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with 2548 a call to __builtin_memcpy. */ 2549 2550static enum gimplify_status 2551gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value) 2552{ 2553 tree args, t, to, to_ptr, from; 2554 2555 to = TREE_OPERAND (*expr_p, 0); 2556 from = TREE_OPERAND (*expr_p, 1); 2557 2558 args = tree_cons (NULL, size, NULL); 2559 2560 t = build_fold_addr_expr (from); 2561 args = tree_cons (NULL, t, args); 2562 2563 to_ptr = build_fold_addr_expr (to); 2564 args = tree_cons (NULL, to_ptr, args); 2565 t = implicit_built_in_decls[BUILT_IN_MEMCPY]; 2566 t = build_function_call_expr (t, args); 2567 2568 if (want_value) 2569 { 2570 t = build1 (NOP_EXPR, TREE_TYPE (to_ptr), t); 2571 t = build1 (INDIRECT_REF, TREE_TYPE (to), t); 2572 } 2573 2574 *expr_p = t; 2575 return GS_OK; 2576} 2577 2578/* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with 2579 a call to __builtin_memset. In this case we know that the RHS is 2580 a CONSTRUCTOR with an empty element list. */ 2581 2582static enum gimplify_status 2583gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value) 2584{ 2585 tree args, t, to, to_ptr; 2586 2587 to = TREE_OPERAND (*expr_p, 0); 2588 2589 args = tree_cons (NULL, size, NULL); 2590 2591 args = tree_cons (NULL, integer_zero_node, args); 2592 2593 to_ptr = build_fold_addr_expr (to); 2594 args = tree_cons (NULL, to_ptr, args); 2595 t = implicit_built_in_decls[BUILT_IN_MEMSET]; 2596 t = build_function_call_expr (t, args); 2597 2598 if (want_value) 2599 { 2600 t = build1 (NOP_EXPR, TREE_TYPE (to_ptr), t); 2601 t = build1 (INDIRECT_REF, TREE_TYPE (to), t); 2602 } 2603 2604 *expr_p = t; 2605 return GS_OK; 2606} 2607 2608/* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree, 2609 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an 2610 assignment. Returns non-null if we detect a potential overlap. */ 2611 2612struct gimplify_init_ctor_preeval_data 2613{ 2614 /* The base decl of the lhs object. May be NULL, in which case we 2615 have to assume the lhs is indirect. */ 2616 tree lhs_base_decl; 2617 2618 /* The alias set of the lhs object. */ 2619 int lhs_alias_set; 2620}; 2621 2622static tree 2623gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata) 2624{ 2625 struct gimplify_init_ctor_preeval_data *data 2626 = (struct gimplify_init_ctor_preeval_data *) xdata; 2627 tree t = *tp; 2628 2629 /* If we find the base object, obviously we have overlap. */ 2630 if (data->lhs_base_decl == t) 2631 return t; 2632 2633 /* If the constructor component is indirect, determine if we have a 2634 potential overlap with the lhs. The only bits of information we 2635 have to go on at this point are addressability and alias sets. */ 2636 if (TREE_CODE (t) == INDIRECT_REF 2637 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl)) 2638 && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t))) 2639 return t; 2640 2641 /* If the constructor component is a call, determine if it can hide a 2642 potential overlap with the lhs through an INDIRECT_REF like above. */ 2643 if (TREE_CODE (t) == CALL_EXPR) 2644 { 2645 tree type, fntype = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))); 2646 2647 for (type = TYPE_ARG_TYPES (fntype); type; type = TREE_CHAIN (type)) 2648 if (POINTER_TYPE_P (TREE_VALUE (type)) 2649 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl)) 2650 && alias_sets_conflict_p (data->lhs_alias_set, 2651 get_alias_set 2652 (TREE_TYPE (TREE_VALUE (type))))) 2653 return t; 2654 } 2655 2656 if (IS_TYPE_OR_DECL_P (t)) 2657 *walk_subtrees = 0; 2658 return NULL; 2659} 2660 2661/* A subroutine of gimplify_init_constructor. Pre-evaluate *EXPR_P, 2662 force values that overlap with the lhs (as described by *DATA) 2663 into temporaries. */ 2664 2665static void 2666gimplify_init_ctor_preeval (tree *expr_p, tree *pre_p, tree *post_p, 2667 struct gimplify_init_ctor_preeval_data *data) 2668{ 2669 enum gimplify_status one; 2670 2671 /* If the value is invariant, then there's nothing to pre-evaluate. 2672 But ensure it doesn't have any side-effects since a SAVE_EXPR is 2673 invariant but has side effects and might contain a reference to 2674 the object we're initializing. */ 2675 if (TREE_INVARIANT (*expr_p) && !TREE_SIDE_EFFECTS (*expr_p)) 2676 return; 2677 2678 /* If the type has non-trivial constructors, we can't pre-evaluate. */ 2679 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p))) 2680 return; 2681 2682 /* Recurse for nested constructors. */ 2683 if (TREE_CODE (*expr_p) == CONSTRUCTOR) 2684 { 2685 unsigned HOST_WIDE_INT ix; 2686 constructor_elt *ce; 2687 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (*expr_p); 2688 2689 for (ix = 0; VEC_iterate (constructor_elt, v, ix, ce); ix++) 2690 gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data); 2691 return; 2692 } 2693 2694 /* If this is a variable sized type, we must remember the size. */ 2695 maybe_with_size_expr (expr_p); 2696 2697 /* Gimplify the constructor element to something appropriate for the rhs 2698 of a MODIFY_EXPR. Given that we know the lhs is an aggregate, we know 2699 the gimplifier will consider this a store to memory. Doing this 2700 gimplification now means that we won't have to deal with complicated 2701 language-specific trees, nor trees like SAVE_EXPR that can induce 2702 exponential search behavior. */ 2703 one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue); 2704 if (one == GS_ERROR) 2705 { 2706 *expr_p = NULL; 2707 return; 2708 } 2709 2710 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap 2711 with the lhs, since "a = { .x=a }" doesn't make sense. This will 2712 always be true for all scalars, since is_gimple_mem_rhs insists on a 2713 temporary variable for them. */ 2714 if (DECL_P (*expr_p)) 2715 return; 2716 2717 /* If this is of variable size, we have no choice but to assume it doesn't 2718 overlap since we can't make a temporary for it. */ 2719 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p))) != INTEGER_CST) 2720 return; 2721 2722 /* Otherwise, we must search for overlap ... */ 2723 if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL)) 2724 return; 2725 2726 /* ... and if found, force the value into a temporary. */ 2727 *expr_p = get_formal_tmp_var (*expr_p, pre_p); 2728} 2729 2730/* A subroutine of gimplify_init_ctor_eval. Create a loop for 2731 a RANGE_EXPR in a CONSTRUCTOR for an array. 2732 2733 var = lower; 2734 loop_entry: 2735 object[var] = value; 2736 if (var == upper) 2737 goto loop_exit; 2738 var = var + 1; 2739 goto loop_entry; 2740 loop_exit: 2741 2742 We increment var _after_ the loop exit check because we might otherwise 2743 fail if upper == TYPE_MAX_VALUE (type for upper). 2744 2745 Note that we never have to deal with SAVE_EXPRs here, because this has 2746 already been taken care of for us, in gimplify_init_ctor_preeval(). */ 2747 2748static void gimplify_init_ctor_eval (tree, VEC(constructor_elt,gc) *, 2749 tree *, bool); 2750 2751static void 2752gimplify_init_ctor_eval_range (tree object, tree lower, tree upper, 2753 tree value, tree array_elt_type, 2754 tree *pre_p, bool cleared) 2755{ 2756 tree loop_entry_label, loop_exit_label; 2757 tree var, var_type, cref; 2758 2759 loop_entry_label = create_artificial_label (); 2760 loop_exit_label = create_artificial_label (); 2761 2762 /* Create and initialize the index variable. */ 2763 var_type = TREE_TYPE (upper); 2764 var = create_tmp_var (var_type, NULL); 2765 append_to_statement_list (build2 (MODIFY_EXPR, var_type, var, lower), pre_p); 2766 2767 /* Add the loop entry label. */ 2768 append_to_statement_list (build1 (LABEL_EXPR, 2769 void_type_node, 2770 loop_entry_label), 2771 pre_p); 2772 2773 /* Build the reference. */ 2774 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object), 2775 var, NULL_TREE, NULL_TREE); 2776 2777 /* If we are a constructor, just call gimplify_init_ctor_eval to do 2778 the store. Otherwise just assign value to the reference. */ 2779 2780 if (TREE_CODE (value) == CONSTRUCTOR) 2781 /* NB we might have to call ourself recursively through 2782 gimplify_init_ctor_eval if the value is a constructor. */ 2783 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value), 2784 pre_p, cleared); 2785 else 2786 append_to_statement_list (build2 (MODIFY_EXPR, TREE_TYPE (cref), 2787 cref, value), 2788 pre_p); 2789 2790 /* We exit the loop when the index var is equal to the upper bound. */ 2791 gimplify_and_add (build3 (COND_EXPR, void_type_node, 2792 build2 (EQ_EXPR, boolean_type_node, 2793 var, upper), 2794 build1 (GOTO_EXPR, 2795 void_type_node, 2796 loop_exit_label), 2797 NULL_TREE), 2798 pre_p); 2799 2800 /* Otherwise, increment the index var... */ 2801 append_to_statement_list (build2 (MODIFY_EXPR, var_type, var, 2802 build2 (PLUS_EXPR, var_type, var, 2803 fold_convert (var_type, 2804 integer_one_node))), 2805 pre_p); 2806 2807 /* ...and jump back to the loop entry. */ 2808 append_to_statement_list (build1 (GOTO_EXPR, 2809 void_type_node, 2810 loop_entry_label), 2811 pre_p); 2812 2813 /* Add the loop exit label. */ 2814 append_to_statement_list (build1 (LABEL_EXPR, 2815 void_type_node, 2816 loop_exit_label), 2817 pre_p); 2818} 2819 2820/* Return true if FDECL is accessing a field that is zero sized. */ 2821 2822static bool 2823zero_sized_field_decl (tree fdecl) 2824{ 2825 if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl) 2826 && integer_zerop (DECL_SIZE (fdecl))) 2827 return true; 2828 return false; 2829} 2830 2831/* Return true if TYPE is zero sized. */ 2832 2833static bool 2834zero_sized_type (tree type) 2835{ 2836 if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type) 2837 && integer_zerop (TYPE_SIZE (type))) 2838 return true; 2839 return false; 2840} 2841 2842/* A subroutine of gimplify_init_constructor. Generate individual 2843 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the 2844 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the 2845 CONSTRUCTOR. CLEARED is true if the entire LHS object has been 2846 zeroed first. */ 2847 2848static void 2849gimplify_init_ctor_eval (tree object, VEC(constructor_elt,gc) *elts, 2850 tree *pre_p, bool cleared) 2851{ 2852 tree array_elt_type = NULL; 2853 unsigned HOST_WIDE_INT ix; 2854 tree purpose, value; 2855 2856 if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE) 2857 array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object))); 2858 2859 FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value) 2860 { 2861 tree cref, init; 2862 2863 /* NULL values are created above for gimplification errors. */ 2864 if (value == NULL) 2865 continue; 2866 2867 if (cleared && initializer_zerop (value)) 2868 continue; 2869 2870 /* ??? Here's to hoping the front end fills in all of the indices, 2871 so we don't have to figure out what's missing ourselves. */ 2872 gcc_assert (purpose); 2873 2874 /* Skip zero-sized fields, unless value has side-effects. This can 2875 happen with calls to functions returning a zero-sized type, which 2876 we shouldn't discard. As a number of downstream passes don't 2877 expect sets of zero-sized fields, we rely on the gimplification of 2878 the MODIFY_EXPR we make below to drop the assignment statement. */ 2879 if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose)) 2880 continue; 2881 2882 /* If we have a RANGE_EXPR, we have to build a loop to assign the 2883 whole range. */ 2884 if (TREE_CODE (purpose) == RANGE_EXPR) 2885 { 2886 tree lower = TREE_OPERAND (purpose, 0); 2887 tree upper = TREE_OPERAND (purpose, 1); 2888 2889 /* If the lower bound is equal to upper, just treat it as if 2890 upper was the index. */ 2891 if (simple_cst_equal (lower, upper)) 2892 purpose = upper; 2893 else 2894 { 2895 gimplify_init_ctor_eval_range (object, lower, upper, value, 2896 array_elt_type, pre_p, cleared); 2897 continue; 2898 } 2899 } 2900 2901 if (array_elt_type) 2902 { 2903 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object), 2904 purpose, NULL_TREE, NULL_TREE); 2905 } 2906 else 2907 { 2908 gcc_assert (TREE_CODE (purpose) == FIELD_DECL); 2909 cref = build3 (COMPONENT_REF, TREE_TYPE (purpose), 2910 unshare_expr (object), purpose, NULL_TREE); 2911 } 2912 2913 if (TREE_CODE (value) == CONSTRUCTOR 2914 && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE) 2915 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value), 2916 pre_p, cleared); 2917 else 2918 { 2919 init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value); 2920 gimplify_and_add (init, pre_p); 2921 } 2922 } 2923} 2924 2925/* A subroutine of gimplify_modify_expr. Break out elements of a 2926 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs. 2927 2928 Note that we still need to clear any elements that don't have explicit 2929 initializers, so if not all elements are initialized we keep the 2930 original MODIFY_EXPR, we just remove all of the constructor elements. */ 2931 2932static enum gimplify_status 2933gimplify_init_constructor (tree *expr_p, tree *pre_p, 2934 tree *post_p, bool want_value) 2935{ 2936 tree object; 2937 tree ctor = TREE_OPERAND (*expr_p, 1); 2938 tree type = TREE_TYPE (ctor); 2939 enum gimplify_status ret; 2940 VEC(constructor_elt,gc) *elts; 2941 2942 if (TREE_CODE (ctor) != CONSTRUCTOR) 2943 return GS_UNHANDLED; 2944 2945 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, 2946 is_gimple_lvalue, fb_lvalue); 2947 if (ret == GS_ERROR) 2948 return ret; 2949 object = TREE_OPERAND (*expr_p, 0); 2950 2951 elts = CONSTRUCTOR_ELTS (ctor); 2952 2953 ret = GS_ALL_DONE; 2954 switch (TREE_CODE (type)) 2955 { 2956 case RECORD_TYPE: 2957 case UNION_TYPE: 2958 case QUAL_UNION_TYPE: 2959 case ARRAY_TYPE: 2960 { 2961 struct gimplify_init_ctor_preeval_data preeval_data; 2962 HOST_WIDE_INT num_type_elements, num_ctor_elements; 2963 HOST_WIDE_INT num_nonzero_elements; 2964 bool cleared, valid_const_initializer; 2965 2966 /* Aggregate types must lower constructors to initialization of 2967 individual elements. The exception is that a CONSTRUCTOR node 2968 with no elements indicates zero-initialization of the whole. */ 2969 if (VEC_empty (constructor_elt, elts)) 2970 break; 2971 2972 /* Fetch information about the constructor to direct later processing. 2973 We might want to make static versions of it in various cases, and 2974 can only do so if it known to be a valid constant initializer. */ 2975 valid_const_initializer 2976 = categorize_ctor_elements (ctor, &num_nonzero_elements, 2977 &num_ctor_elements, &cleared); 2978 2979 /* If a const aggregate variable is being initialized, then it 2980 should never be a lose to promote the variable to be static. */ 2981 if (valid_const_initializer 2982 && num_nonzero_elements > 1 2983 && TREE_READONLY (object) 2984 && TREE_CODE (object) == VAR_DECL) 2985 { 2986 DECL_INITIAL (object) = ctor; 2987 TREE_STATIC (object) = 1; 2988 if (!DECL_NAME (object)) 2989 DECL_NAME (object) = create_tmp_var_name ("C"); 2990 walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL); 2991 2992 /* ??? C++ doesn't automatically append a .<number> to the 2993 assembler name, and even when it does, it looks a FE private 2994 data structures to figure out what that number should be, 2995 which are not set for this variable. I suppose this is 2996 important for local statics for inline functions, which aren't 2997 "local" in the object file sense. So in order to get a unique 2998 TU-local symbol, we must invoke the lhd version now. */ 2999 lhd_set_decl_assembler_name (object); 3000 3001 *expr_p = NULL_TREE; 3002 break; 3003 } 3004 3005 /* If there are "lots" of initialized elements, even discounting 3006 those that are not address constants (and thus *must* be 3007 computed at runtime), then partition the constructor into 3008 constant and non-constant parts. Block copy the constant 3009 parts in, then generate code for the non-constant parts. */ 3010 /* TODO. There's code in cp/typeck.c to do this. */ 3011 3012 num_type_elements = count_type_elements (type, true); 3013 3014 /* If count_type_elements could not determine number of type elements 3015 for a constant-sized object, assume clearing is needed. 3016 Don't do this for variable-sized objects, as store_constructor 3017 will ignore the clearing of variable-sized objects. */ 3018 if (num_type_elements < 0 && int_size_in_bytes (type) >= 0) 3019 cleared = true; 3020 /* If there are "lots" of zeros, then block clear the object first. */ 3021 else if (num_type_elements - num_nonzero_elements > CLEAR_RATIO 3022 && num_nonzero_elements < num_type_elements/4) 3023 cleared = true; 3024 /* ??? This bit ought not be needed. For any element not present 3025 in the initializer, we should simply set them to zero. Except 3026 we'd need to *find* the elements that are not present, and that 3027 requires trickery to avoid quadratic compile-time behavior in 3028 large cases or excessive memory use in small cases. */ 3029 else if (num_ctor_elements < num_type_elements) 3030 cleared = true; 3031 3032 /* If there are "lots" of initialized elements, and all of them 3033 are valid address constants, then the entire initializer can 3034 be dropped to memory, and then memcpy'd out. Don't do this 3035 for sparse arrays, though, as it's more efficient to follow 3036 the standard CONSTRUCTOR behavior of memset followed by 3037 individual element initialization. */ 3038 if (valid_const_initializer && !cleared) 3039 { 3040 HOST_WIDE_INT size = int_size_in_bytes (type); 3041 unsigned int align; 3042 3043 /* ??? We can still get unbounded array types, at least 3044 from the C++ front end. This seems wrong, but attempt 3045 to work around it for now. */ 3046 if (size < 0) 3047 { 3048 size = int_size_in_bytes (TREE_TYPE (object)); 3049 if (size >= 0) 3050 TREE_TYPE (ctor) = type = TREE_TYPE (object); 3051 } 3052 3053 /* Find the maximum alignment we can assume for the object. */ 3054 /* ??? Make use of DECL_OFFSET_ALIGN. */ 3055 if (DECL_P (object)) 3056 align = DECL_ALIGN (object); 3057 else 3058 align = TYPE_ALIGN (type); 3059 3060 if (size > 0 && !can_move_by_pieces (size, align)) 3061 { 3062 tree new = create_tmp_var_raw (type, "C"); 3063 3064 gimple_add_tmp_var (new); 3065 TREE_STATIC (new) = 1; 3066 TREE_READONLY (new) = 1; 3067 DECL_INITIAL (new) = ctor; 3068 if (align > DECL_ALIGN (new)) 3069 { 3070 DECL_ALIGN (new) = align; 3071 DECL_USER_ALIGN (new) = 1; 3072 } 3073 walk_tree (&DECL_INITIAL (new), force_labels_r, NULL, NULL); 3074 3075 TREE_OPERAND (*expr_p, 1) = new; 3076 3077 /* This is no longer an assignment of a CONSTRUCTOR, but 3078 we still may have processing to do on the LHS. So 3079 pretend we didn't do anything here to let that happen. */ 3080 return GS_UNHANDLED; 3081 } 3082 } 3083 3084 /* If there are nonzero elements, pre-evaluate to capture elements 3085 overlapping with the lhs into temporaries. We must do this before 3086 clearing to fetch the values before they are zeroed-out. */ 3087 if (num_nonzero_elements > 0) 3088 { 3089 preeval_data.lhs_base_decl = get_base_address (object); 3090 if (!DECL_P (preeval_data.lhs_base_decl)) 3091 preeval_data.lhs_base_decl = NULL; 3092 preeval_data.lhs_alias_set = get_alias_set (object); 3093 3094 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1), 3095 pre_p, post_p, &preeval_data); 3096 } 3097 3098 if (cleared) 3099 { 3100 /* Zap the CONSTRUCTOR element list, which simplifies this case. 3101 Note that we still have to gimplify, in order to handle the 3102 case of variable sized types. Avoid shared tree structures. */ 3103 CONSTRUCTOR_ELTS (ctor) = NULL; 3104 object = unshare_expr (object); 3105 gimplify_stmt (expr_p); 3106 append_to_statement_list (*expr_p, pre_p); 3107 } 3108 3109 /* If we have not block cleared the object, or if there are nonzero 3110 elements in the constructor, add assignments to the individual 3111 scalar fields of the object. */ 3112 if (!cleared || num_nonzero_elements > 0) 3113 gimplify_init_ctor_eval (object, elts, pre_p, cleared); 3114 3115 *expr_p = NULL_TREE; 3116 } 3117 break; 3118 3119 case COMPLEX_TYPE: 3120 { 3121 tree r, i; 3122 3123 /* Extract the real and imaginary parts out of the ctor. */ 3124 gcc_assert (VEC_length (constructor_elt, elts) == 2); 3125 r = VEC_index (constructor_elt, elts, 0)->value; 3126 i = VEC_index (constructor_elt, elts, 1)->value; 3127 if (r == NULL || i == NULL) 3128 { 3129 tree zero = fold_convert (TREE_TYPE (type), integer_zero_node); 3130 if (r == NULL) 3131 r = zero; 3132 if (i == NULL) 3133 i = zero; 3134 } 3135 3136 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to 3137 represent creation of a complex value. */ 3138 if (TREE_CONSTANT (r) && TREE_CONSTANT (i)) 3139 { 3140 ctor = build_complex (type, r, i); 3141 TREE_OPERAND (*expr_p, 1) = ctor; 3142 } 3143 else 3144 { 3145 ctor = build2 (COMPLEX_EXPR, type, r, i); 3146 TREE_OPERAND (*expr_p, 1) = ctor; 3147 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p, 3148 rhs_predicate_for (TREE_OPERAND (*expr_p, 0)), 3149 fb_rvalue); 3150 } 3151 } 3152 break; 3153 3154 case VECTOR_TYPE: 3155 { 3156 unsigned HOST_WIDE_INT ix; 3157 constructor_elt *ce; 3158 3159 /* Go ahead and simplify constant constructors to VECTOR_CST. */ 3160 if (TREE_CONSTANT (ctor)) 3161 { 3162 bool constant_p = true; 3163 tree value; 3164 3165 /* Even when ctor is constant, it might contain non-*_CST 3166 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't 3167 belong into VECTOR_CST nodes. */ 3168 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value) 3169 if (!CONSTANT_CLASS_P (value)) 3170 { 3171 constant_p = false; 3172 break; 3173 } 3174 3175 if (constant_p) 3176 { 3177 TREE_OPERAND (*expr_p, 1) = build_vector_from_ctor (type, elts); 3178 break; 3179 } 3180 3181 /* Don't reduce a TREE_CONSTANT vector ctor even if we can't 3182 make a VECTOR_CST. It won't do anything for us, and it'll 3183 prevent us from representing it as a single constant. */ 3184 break; 3185 } 3186 3187 /* Vector types use CONSTRUCTOR all the way through gimple 3188 compilation as a general initializer. */ 3189 for (ix = 0; VEC_iterate (constructor_elt, elts, ix, ce); ix++) 3190 { 3191 enum gimplify_status tret; 3192 tret = gimplify_expr (&ce->value, pre_p, post_p, 3193 is_gimple_val, fb_rvalue); 3194 if (tret == GS_ERROR) 3195 ret = GS_ERROR; 3196 } 3197 } 3198 break; 3199 3200 default: 3201 /* So how did we get a CONSTRUCTOR for a scalar type? */ 3202 gcc_unreachable (); 3203 } 3204 3205 if (ret == GS_ERROR) 3206 return GS_ERROR; 3207 else if (want_value) 3208 { 3209 append_to_statement_list (*expr_p, pre_p); 3210 *expr_p = object; 3211 return GS_OK; 3212 } 3213 else 3214 return GS_ALL_DONE; 3215} 3216 3217/* Given a pointer value OP0, return a simplified version of an 3218 indirection through OP0, or NULL_TREE if no simplification is 3219 possible. This may only be applied to a rhs of an expression. 3220 Note that the resulting type may be different from the type pointed 3221 to in the sense that it is still compatible from the langhooks 3222 point of view. */ 3223 3224static tree 3225fold_indirect_ref_rhs (tree t) 3226{ 3227 tree type = TREE_TYPE (TREE_TYPE (t)); 3228 tree sub = t; 3229 tree subtype; 3230 3231 STRIP_USELESS_TYPE_CONVERSION (sub); 3232 subtype = TREE_TYPE (sub); 3233 if (!POINTER_TYPE_P (subtype)) 3234 return NULL_TREE; 3235 3236 if (TREE_CODE (sub) == ADDR_EXPR) 3237 { 3238 tree op = TREE_OPERAND (sub, 0); 3239 tree optype = TREE_TYPE (op); 3240 /* *&p => p */ 3241 if (lang_hooks.types_compatible_p (type, optype)) 3242 return op; 3243 /* *(foo *)&fooarray => fooarray[0] */ 3244 else if (TREE_CODE (optype) == ARRAY_TYPE 3245 && lang_hooks.types_compatible_p (type, TREE_TYPE (optype))) 3246 { 3247 tree type_domain = TYPE_DOMAIN (optype); 3248 tree min_val = size_zero_node; 3249 if (type_domain && TYPE_MIN_VALUE (type_domain)) 3250 min_val = TYPE_MIN_VALUE (type_domain); 3251 return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE); 3252 } 3253 } 3254 3255 /* *(foo *)fooarrptr => (*fooarrptr)[0] */ 3256 if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE 3257 && lang_hooks.types_compatible_p (type, TREE_TYPE (TREE_TYPE (subtype)))) 3258 { 3259 tree type_domain; 3260 tree min_val = size_zero_node; 3261 tree osub = sub; 3262 sub = fold_indirect_ref_rhs (sub); 3263 if (! sub) 3264 sub = build1 (INDIRECT_REF, TREE_TYPE (subtype), osub); 3265 type_domain = TYPE_DOMAIN (TREE_TYPE (sub)); 3266 if (type_domain && TYPE_MIN_VALUE (type_domain)) 3267 min_val = TYPE_MIN_VALUE (type_domain); 3268 return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE); 3269 } 3270 3271 return NULL_TREE; 3272} 3273 3274/* Subroutine of gimplify_modify_expr to do simplifications of MODIFY_EXPRs 3275 based on the code of the RHS. We loop for as long as something changes. */ 3276 3277static enum gimplify_status 3278gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p, tree *pre_p, 3279 tree *post_p, bool want_value) 3280{ 3281 enum gimplify_status ret = GS_OK; 3282 3283 while (ret != GS_UNHANDLED) 3284 switch (TREE_CODE (*from_p)) 3285 { 3286 case INDIRECT_REF: 3287 { 3288 /* If we have code like 3289 3290 *(const A*)(A*)&x 3291 3292 where the type of "x" is a (possibly cv-qualified variant 3293 of "A"), treat the entire expression as identical to "x". 3294 This kind of code arises in C++ when an object is bound 3295 to a const reference, and if "x" is a TARGET_EXPR we want 3296 to take advantage of the optimization below. */ 3297 tree t = fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0)); 3298 if (t) 3299 { 3300 *from_p = t; 3301 ret = GS_OK; 3302 } 3303 else 3304 ret = GS_UNHANDLED; 3305 break; 3306 } 3307 3308 case TARGET_EXPR: 3309 { 3310 /* If we are initializing something from a TARGET_EXPR, strip the 3311 TARGET_EXPR and initialize it directly, if possible. This can't 3312 be done if the initializer is void, since that implies that the 3313 temporary is set in some non-trivial way. 3314 3315 ??? What about code that pulls out the temp and uses it 3316 elsewhere? I think that such code never uses the TARGET_EXPR as 3317 an initializer. If I'm wrong, we'll die because the temp won't 3318 have any RTL. In that case, I guess we'll need to replace 3319 references somehow. */ 3320 tree init = TARGET_EXPR_INITIAL (*from_p); 3321 3322 if (!VOID_TYPE_P (TREE_TYPE (init))) 3323 { 3324 *from_p = init; 3325 ret = GS_OK; 3326 } 3327 else 3328 ret = GS_UNHANDLED; 3329 } 3330 break; 3331 3332 case COMPOUND_EXPR: 3333 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be 3334 caught. */ 3335 gimplify_compound_expr (from_p, pre_p, true); 3336 ret = GS_OK; 3337 break; 3338 3339 case CONSTRUCTOR: 3340 /* If we're initializing from a CONSTRUCTOR, break this into 3341 individual MODIFY_EXPRs. */ 3342 return gimplify_init_constructor (expr_p, pre_p, post_p, want_value); 3343 3344 case COND_EXPR: 3345 /* If we're assigning to a non-register type, push the assignment 3346 down into the branches. This is mandatory for ADDRESSABLE types, 3347 since we cannot generate temporaries for such, but it saves a 3348 copy in other cases as well. */ 3349 if (!is_gimple_reg_type (TREE_TYPE (*from_p))) 3350 { 3351 /* This code should mirror the code in gimplify_cond_expr. */ 3352 enum tree_code code = TREE_CODE (*expr_p); 3353 tree cond = *from_p; 3354 tree result = *to_p; 3355 3356 ret = gimplify_expr (&result, pre_p, post_p, 3357 is_gimple_min_lval, fb_lvalue); 3358 if (ret != GS_ERROR) 3359 ret = GS_OK; 3360 3361 if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node) 3362 TREE_OPERAND (cond, 1) 3363 = build2 (code, void_type_node, result, 3364 TREE_OPERAND (cond, 1)); 3365 if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node) 3366 TREE_OPERAND (cond, 2) 3367 = build2 (code, void_type_node, unshare_expr (result), 3368 TREE_OPERAND (cond, 2)); 3369 3370 TREE_TYPE (cond) = void_type_node; 3371 recalculate_side_effects (cond); 3372 3373 if (want_value) 3374 { 3375 gimplify_and_add (cond, pre_p); 3376 *expr_p = unshare_expr (result); 3377 } 3378 else 3379 *expr_p = cond; 3380 return ret; 3381 } 3382 else 3383 ret = GS_UNHANDLED; 3384 break; 3385 3386 case CALL_EXPR: 3387 /* For calls that return in memory, give *to_p as the CALL_EXPR's 3388 return slot so that we don't generate a temporary. */ 3389 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p) 3390 && aggregate_value_p (*from_p, *from_p)) 3391 { 3392 bool use_target; 3393 3394 if (!(rhs_predicate_for (*to_p))(*from_p)) 3395 /* If we need a temporary, *to_p isn't accurate. */ 3396 use_target = false; 3397 else if (TREE_CODE (*to_p) == RESULT_DECL 3398 && DECL_NAME (*to_p) == NULL_TREE 3399 && needs_to_live_in_memory (*to_p)) 3400 /* It's OK to use the return slot directly unless it's an NRV. */ 3401 use_target = true; 3402 else if (is_gimple_reg_type (TREE_TYPE (*to_p)) 3403 || (DECL_P (*to_p) && DECL_REGISTER (*to_p))) 3404 /* Don't force regs into memory. */ 3405 use_target = false; 3406 else if (TREE_CODE (*to_p) == VAR_DECL 3407 && DECL_GIMPLE_FORMAL_TEMP_P (*to_p)) 3408 /* Don't use the original target if it's a formal temp; we 3409 don't want to take their addresses. */ 3410 use_target = false; 3411 else if (TREE_CODE (*expr_p) == INIT_EXPR) 3412 /* It's OK to use the target directly if it's being 3413 initialized. */ 3414 use_target = true; 3415 else if (!is_gimple_non_addressable (*to_p)) 3416 /* Don't use the original target if it's already addressable; 3417 if its address escapes, and the called function uses the 3418 NRV optimization, a conforming program could see *to_p 3419 change before the called function returns; see c++/19317. 3420 When optimizing, the return_slot pass marks more functions 3421 as safe after we have escape info. */ 3422 use_target = false; 3423 else 3424 use_target = true; 3425 3426 if (use_target) 3427 { 3428 CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1; 3429 lang_hooks.mark_addressable (*to_p); 3430 } 3431 } 3432 3433 ret = GS_UNHANDLED; 3434 break; 3435 3436 /* If we're initializing from a container, push the initialization 3437 inside it. */ 3438 case CLEANUP_POINT_EXPR: 3439 case BIND_EXPR: 3440 case STATEMENT_LIST: 3441 { 3442 tree wrap = *from_p; 3443 tree t; 3444 3445 ret = gimplify_expr (to_p, pre_p, post_p, 3446 is_gimple_min_lval, fb_lvalue); 3447 if (ret != GS_ERROR) 3448 ret = GS_OK; 3449 3450 t = voidify_wrapper_expr (wrap, *expr_p); 3451 gcc_assert (t == *expr_p); 3452 3453 if (want_value) 3454 { 3455 gimplify_and_add (wrap, pre_p); 3456 *expr_p = unshare_expr (*to_p); 3457 } 3458 else 3459 *expr_p = wrap; 3460 return GS_OK; 3461 } 3462 3463 default: 3464 ret = GS_UNHANDLED; 3465 break; 3466 } 3467 3468 return ret; 3469} 3470 3471/* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is 3472 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with 3473 DECL_COMPLEX_GIMPLE_REG_P set. */ 3474 3475static enum gimplify_status 3476gimplify_modify_expr_complex_part (tree *expr_p, tree *pre_p, bool want_value) 3477{ 3478 enum tree_code code, ocode; 3479 tree lhs, rhs, new_rhs, other, realpart, imagpart; 3480 3481 lhs = TREE_OPERAND (*expr_p, 0); 3482 rhs = TREE_OPERAND (*expr_p, 1); 3483 code = TREE_CODE (lhs); 3484 lhs = TREE_OPERAND (lhs, 0); 3485 3486 ocode = code == REALPART_EXPR ? IMAGPART_EXPR : REALPART_EXPR; 3487 other = build1 (ocode, TREE_TYPE (rhs), lhs); 3488 other = get_formal_tmp_var (other, pre_p); 3489 3490 realpart = code == REALPART_EXPR ? rhs : other; 3491 imagpart = code == REALPART_EXPR ? other : rhs; 3492 3493 if (TREE_CONSTANT (realpart) && TREE_CONSTANT (imagpart)) 3494 new_rhs = build_complex (TREE_TYPE (lhs), realpart, imagpart); 3495 else 3496 new_rhs = build2 (COMPLEX_EXPR, TREE_TYPE (lhs), realpart, imagpart); 3497 3498 TREE_OPERAND (*expr_p, 0) = lhs; 3499 TREE_OPERAND (*expr_p, 1) = new_rhs; 3500 3501 if (want_value) 3502 { 3503 append_to_statement_list (*expr_p, pre_p); 3504 *expr_p = rhs; 3505 } 3506 3507 return GS_ALL_DONE; 3508} 3509 3510/* Gimplify the MODIFY_EXPR node pointed to by EXPR_P. 3511 3512 modify_expr 3513 : varname '=' rhs 3514 | '*' ID '=' rhs 3515 3516 PRE_P points to the list where side effects that must happen before 3517 *EXPR_P should be stored. 3518 3519 POST_P points to the list where side effects that must happen after 3520 *EXPR_P should be stored. 3521 3522 WANT_VALUE is nonzero iff we want to use the value of this expression 3523 in another expression. */ 3524 3525static enum gimplify_status 3526gimplify_modify_expr (tree *expr_p, tree *pre_p, tree *post_p, bool want_value) 3527{ 3528 tree *from_p = &TREE_OPERAND (*expr_p, 1); 3529 tree *to_p = &TREE_OPERAND (*expr_p, 0); 3530 enum gimplify_status ret = GS_UNHANDLED; 3531 3532 gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR 3533 || TREE_CODE (*expr_p) == INIT_EXPR); 3534 3535 /* See if any simplifications can be done based on what the RHS is. */ 3536 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p, 3537 want_value); 3538 if (ret != GS_UNHANDLED) 3539 return ret; 3540 3541 /* For zero sized types only gimplify the left hand side and right hand 3542 side as statements and throw away the assignment. Do this after 3543 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable 3544 types properly. */ 3545 if (zero_sized_type (TREE_TYPE (*from_p))) 3546 { 3547 gimplify_stmt (from_p); 3548 gimplify_stmt (to_p); 3549 append_to_statement_list (*from_p, pre_p); 3550 append_to_statement_list (*to_p, pre_p); 3551 *expr_p = NULL_TREE; 3552 return GS_ALL_DONE; 3553 } 3554 3555 /* If the value being copied is of variable width, compute the length 3556 of the copy into a WITH_SIZE_EXPR. Note that we need to do this 3557 before gimplifying any of the operands so that we can resolve any 3558 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses 3559 the size of the expression to be copied, not of the destination, so 3560 that is what we must here. */ 3561 maybe_with_size_expr (from_p); 3562 3563 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue); 3564 if (ret == GS_ERROR) 3565 return ret; 3566 3567 ret = gimplify_expr (from_p, pre_p, post_p, 3568 rhs_predicate_for (*to_p), fb_rvalue); 3569 if (ret == GS_ERROR) 3570 return ret; 3571 3572 /* Now see if the above changed *from_p to something we handle specially. */ 3573 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p, 3574 want_value); 3575 if (ret != GS_UNHANDLED) 3576 return ret; 3577 3578 /* If we've got a variable sized assignment between two lvalues (i.e. does 3579 not involve a call), then we can make things a bit more straightforward 3580 by converting the assignment to memcpy or memset. */ 3581 if (TREE_CODE (*from_p) == WITH_SIZE_EXPR) 3582 { 3583 tree from = TREE_OPERAND (*from_p, 0); 3584 tree size = TREE_OPERAND (*from_p, 1); 3585 3586 if (TREE_CODE (from) == CONSTRUCTOR) 3587 return gimplify_modify_expr_to_memset (expr_p, size, want_value); 3588 if (is_gimple_addressable (from)) 3589 { 3590 *from_p = from; 3591 return gimplify_modify_expr_to_memcpy (expr_p, size, want_value); 3592 } 3593 } 3594 3595 /* Transform partial stores to non-addressable complex variables into 3596 total stores. This allows us to use real instead of virtual operands 3597 for these variables, which improves optimization. */ 3598 if ((TREE_CODE (*to_p) == REALPART_EXPR 3599 || TREE_CODE (*to_p) == IMAGPART_EXPR) 3600 && is_gimple_reg (TREE_OPERAND (*to_p, 0))) 3601 return gimplify_modify_expr_complex_part (expr_p, pre_p, want_value); 3602 3603 if (gimplify_ctxp->into_ssa && is_gimple_reg (*to_p)) 3604 { 3605 /* If we've somehow already got an SSA_NAME on the LHS, then 3606 we're probably modified it twice. Not good. */ 3607 gcc_assert (TREE_CODE (*to_p) != SSA_NAME); 3608 *to_p = make_ssa_name (*to_p, *expr_p); 3609 } 3610 3611 if (want_value) 3612 { 3613 append_to_statement_list (*expr_p, pre_p); 3614 *expr_p = *to_p; 3615 return GS_OK; 3616 } 3617 3618 return GS_ALL_DONE; 3619} 3620 3621/* Gimplify a comparison between two variable-sized objects. Do this 3622 with a call to BUILT_IN_MEMCMP. */ 3623 3624static enum gimplify_status 3625gimplify_variable_sized_compare (tree *expr_p) 3626{ 3627 tree op0 = TREE_OPERAND (*expr_p, 0); 3628 tree op1 = TREE_OPERAND (*expr_p, 1); 3629 tree args, t, dest; 3630 3631 t = TYPE_SIZE_UNIT (TREE_TYPE (op0)); 3632 t = unshare_expr (t); 3633 t = SUBSTITUTE_PLACEHOLDER_IN_EXPR (t, op0); 3634 args = tree_cons (NULL, t, NULL); 3635 t = build_fold_addr_expr (op1); 3636 args = tree_cons (NULL, t, args); 3637 dest = build_fold_addr_expr (op0); 3638 args = tree_cons (NULL, dest, args); 3639 t = implicit_built_in_decls[BUILT_IN_MEMCMP]; 3640 t = build_function_call_expr (t, args); 3641 *expr_p 3642 = build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node); 3643 3644 return GS_OK; 3645} 3646 3647/* Gimplify a comparison between two aggregate objects of integral scalar 3648 mode as a comparison between the bitwise equivalent scalar values. */ 3649 3650static enum gimplify_status 3651gimplify_scalar_mode_aggregate_compare (tree *expr_p) 3652{ 3653 tree op0 = TREE_OPERAND (*expr_p, 0); 3654 tree op1 = TREE_OPERAND (*expr_p, 1); 3655 3656 tree type = TREE_TYPE (op0); 3657 tree scalar_type = lang_hooks.types.type_for_mode (TYPE_MODE (type), 1); 3658 3659 op0 = fold_build1 (VIEW_CONVERT_EXPR, scalar_type, op0); 3660 op1 = fold_build1 (VIEW_CONVERT_EXPR, scalar_type, op1); 3661 3662 *expr_p 3663 = fold_build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), op0, op1); 3664 3665 return GS_OK; 3666} 3667 3668/* Gimplify TRUTH_ANDIF_EXPR and TRUTH_ORIF_EXPR expressions. EXPR_P 3669 points to the expression to gimplify. 3670 3671 Expressions of the form 'a && b' are gimplified to: 3672 3673 a && b ? true : false 3674 3675 gimplify_cond_expr will do the rest. 3676 3677 PRE_P points to the list where side effects that must happen before 3678 *EXPR_P should be stored. */ 3679 3680static enum gimplify_status 3681gimplify_boolean_expr (tree *expr_p) 3682{ 3683 /* Preserve the original type of the expression. */ 3684 tree type = TREE_TYPE (*expr_p); 3685 3686 *expr_p = build3 (COND_EXPR, type, *expr_p, 3687 fold_convert (type, boolean_true_node), 3688 fold_convert (type, boolean_false_node)); 3689 3690 return GS_OK; 3691} 3692 3693/* Gimplifies an expression sequence. This function gimplifies each 3694 expression and re-writes the original expression with the last 3695 expression of the sequence in GIMPLE form. 3696 3697 PRE_P points to the list where the side effects for all the 3698 expressions in the sequence will be emitted. 3699 3700 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */ 3701/* ??? Should rearrange to share the pre-queue with all the indirect 3702 invocations of gimplify_expr. Would probably save on creations 3703 of statement_list nodes. */ 3704 3705static enum gimplify_status 3706gimplify_compound_expr (tree *expr_p, tree *pre_p, bool want_value) 3707{ 3708 tree t = *expr_p; 3709 3710 do 3711 { 3712 tree *sub_p = &TREE_OPERAND (t, 0); 3713 3714 if (TREE_CODE (*sub_p) == COMPOUND_EXPR) 3715 gimplify_compound_expr (sub_p, pre_p, false); 3716 else 3717 gimplify_stmt (sub_p); 3718 append_to_statement_list (*sub_p, pre_p); 3719 3720 t = TREE_OPERAND (t, 1); 3721 } 3722 while (TREE_CODE (t) == COMPOUND_EXPR); 3723 3724 *expr_p = t; 3725 if (want_value) 3726 return GS_OK; 3727 else 3728 { 3729 gimplify_stmt (expr_p); 3730 return GS_ALL_DONE; 3731 } 3732} 3733 3734/* Gimplifies a statement list. These may be created either by an 3735 enlightened front-end, or by shortcut_cond_expr. */ 3736 3737static enum gimplify_status 3738gimplify_statement_list (tree *expr_p, tree *pre_p) 3739{ 3740 tree temp = voidify_wrapper_expr (*expr_p, NULL); 3741 3742 tree_stmt_iterator i = tsi_start (*expr_p); 3743 3744 while (!tsi_end_p (i)) 3745 { 3746 tree t; 3747 3748 gimplify_stmt (tsi_stmt_ptr (i)); 3749 3750 t = tsi_stmt (i); 3751 if (t == NULL) 3752 tsi_delink (&i); 3753 else if (TREE_CODE (t) == STATEMENT_LIST) 3754 { 3755 tsi_link_before (&i, t, TSI_SAME_STMT); 3756 tsi_delink (&i); 3757 } 3758 else 3759 tsi_next (&i); 3760 } 3761 3762 if (temp) 3763 { 3764 append_to_statement_list (*expr_p, pre_p); 3765 *expr_p = temp; 3766 return GS_OK; 3767 } 3768 3769 return GS_ALL_DONE; 3770} 3771 3772/* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to 3773 gimplify. After gimplification, EXPR_P will point to a new temporary 3774 that holds the original value of the SAVE_EXPR node. 3775 3776 PRE_P points to the list where side effects that must happen before 3777 *EXPR_P should be stored. */ 3778 3779static enum gimplify_status 3780gimplify_save_expr (tree *expr_p, tree *pre_p, tree *post_p) 3781{ 3782 enum gimplify_status ret = GS_ALL_DONE; 3783 tree val; 3784 3785 gcc_assert (TREE_CODE (*expr_p) == SAVE_EXPR); 3786 val = TREE_OPERAND (*expr_p, 0); 3787 3788 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */ 3789 if (!SAVE_EXPR_RESOLVED_P (*expr_p)) 3790 { 3791 /* The operand may be a void-valued expression such as SAVE_EXPRs 3792 generated by the Java frontend for class initialization. It is 3793 being executed only for its side-effects. */ 3794 if (TREE_TYPE (val) == void_type_node) 3795 { 3796 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, 3797 is_gimple_stmt, fb_none); 3798 append_to_statement_list (TREE_OPERAND (*expr_p, 0), pre_p); 3799 val = NULL; 3800 } 3801 else 3802 val = get_initialized_tmp_var (val, pre_p, post_p); 3803 3804 TREE_OPERAND (*expr_p, 0) = val; 3805 SAVE_EXPR_RESOLVED_P (*expr_p) = 1; 3806 } 3807 3808 *expr_p = val; 3809 3810 return ret; 3811} 3812 3813/* Re-write the ADDR_EXPR node pointed to by EXPR_P 3814 3815 unary_expr 3816 : ... 3817 | '&' varname 3818 ... 3819 3820 PRE_P points to the list where side effects that must happen before 3821 *EXPR_P should be stored. 3822 3823 POST_P points to the list where side effects that must happen after 3824 *EXPR_P should be stored. */ 3825 3826static enum gimplify_status 3827gimplify_addr_expr (tree *expr_p, tree *pre_p, tree *post_p) 3828{ 3829 tree expr = *expr_p; 3830 tree op0 = TREE_OPERAND (expr, 0); 3831 enum gimplify_status ret; 3832 3833 switch (TREE_CODE (op0)) 3834 { 3835 case INDIRECT_REF: 3836 case MISALIGNED_INDIRECT_REF: 3837 do_indirect_ref: 3838 /* Check if we are dealing with an expression of the form '&*ptr'. 3839 While the front end folds away '&*ptr' into 'ptr', these 3840 expressions may be generated internally by the compiler (e.g., 3841 builtins like __builtin_va_end). */ 3842 /* Caution: the silent array decomposition semantics we allow for 3843 ADDR_EXPR means we can't always discard the pair. */ 3844 /* Gimplification of the ADDR_EXPR operand may drop 3845 cv-qualification conversions, so make sure we add them if 3846 needed. */ 3847 { 3848 tree op00 = TREE_OPERAND (op0, 0); 3849 tree t_expr = TREE_TYPE (expr); 3850 tree t_op00 = TREE_TYPE (op00); 3851 3852 if (!lang_hooks.types_compatible_p (t_expr, t_op00)) 3853 { 3854#ifdef ENABLE_CHECKING 3855 tree t_op0 = TREE_TYPE (op0); 3856 gcc_assert (POINTER_TYPE_P (t_expr) 3857 && cpt_same_type (TREE_CODE (t_op0) == ARRAY_TYPE 3858 ? TREE_TYPE (t_op0) : t_op0, 3859 TREE_TYPE (t_expr)) 3860 && POINTER_TYPE_P (t_op00) 3861 && cpt_same_type (t_op0, TREE_TYPE (t_op00))); 3862#endif 3863 op00 = fold_convert (TREE_TYPE (expr), op00); 3864 } 3865 *expr_p = op00; 3866 ret = GS_OK; 3867 } 3868 break; 3869 3870 case VIEW_CONVERT_EXPR: 3871 /* Take the address of our operand and then convert it to the type of 3872 this ADDR_EXPR. 3873 3874 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at 3875 all clear. The impact of this transformation is even less clear. */ 3876 3877 /* If the operand is a useless conversion, look through it. Doing so 3878 guarantees that the ADDR_EXPR and its operand will remain of the 3879 same type. */ 3880 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0, 0))) 3881 op0 = TREE_OPERAND (op0, 0); 3882 3883 *expr_p = fold_convert (TREE_TYPE (expr), 3884 build_fold_addr_expr (TREE_OPERAND (op0, 0))); 3885 ret = GS_OK; 3886 break; 3887 3888 default: 3889 /* We use fb_either here because the C frontend sometimes takes 3890 the address of a call that returns a struct; see 3891 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make 3892 the implied temporary explicit. */ 3893 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, post_p, 3894 is_gimple_addressable, fb_either); 3895 if (ret != GS_ERROR) 3896 { 3897 op0 = TREE_OPERAND (expr, 0); 3898 3899 /* For various reasons, the gimplification of the expression 3900 may have made a new INDIRECT_REF. */ 3901 if (TREE_CODE (op0) == INDIRECT_REF) 3902 goto do_indirect_ref; 3903 3904 /* Make sure TREE_INVARIANT, TREE_CONSTANT, and TREE_SIDE_EFFECTS 3905 is set properly. */ 3906 recompute_tree_invariant_for_addr_expr (expr); 3907 3908 /* Mark the RHS addressable. */ 3909 lang_hooks.mark_addressable (TREE_OPERAND (expr, 0)); 3910 } 3911 break; 3912 } 3913 3914 return ret; 3915} 3916 3917/* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple 3918 value; output operands should be a gimple lvalue. */ 3919 3920static enum gimplify_status 3921gimplify_asm_expr (tree *expr_p, tree *pre_p, tree *post_p) 3922{ 3923 tree expr = *expr_p; 3924 int noutputs = list_length (ASM_OUTPUTS (expr)); 3925 const char **oconstraints 3926 = (const char **) alloca ((noutputs) * sizeof (const char *)); 3927 int i; 3928 tree link; 3929 const char *constraint; 3930 bool allows_mem, allows_reg, is_inout; 3931 enum gimplify_status ret, tret; 3932 3933 ret = GS_ALL_DONE; 3934 for (i = 0, link = ASM_OUTPUTS (expr); link; ++i, link = TREE_CHAIN (link)) 3935 { 3936 size_t constraint_len; 3937 oconstraints[i] = constraint 3938 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link))); 3939 constraint_len = strlen (constraint); 3940 if (constraint_len == 0) 3941 continue; 3942 3943 parse_output_constraint (&constraint, i, 0, 0, 3944 &allows_mem, &allows_reg, &is_inout); 3945 3946 if (!allows_reg && allows_mem) 3947 lang_hooks.mark_addressable (TREE_VALUE (link)); 3948 3949 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p, 3950 is_inout ? is_gimple_min_lval : is_gimple_lvalue, 3951 fb_lvalue | fb_mayfail); 3952 if (tret == GS_ERROR) 3953 { 3954 error ("invalid lvalue in asm output %d", i); 3955 ret = tret; 3956 } 3957 3958 if (is_inout) 3959 { 3960 /* An input/output operand. To give the optimizers more 3961 flexibility, split it into separate input and output 3962 operands. */ 3963 tree input; 3964 char buf[10]; 3965 3966 /* Turn the in/out constraint into an output constraint. */ 3967 char *p = xstrdup (constraint); 3968 p[0] = '='; 3969 TREE_VALUE (TREE_PURPOSE (link)) = build_string (constraint_len, p); 3970 3971 /* And add a matching input constraint. */ 3972 if (allows_reg) 3973 { 3974 sprintf (buf, "%d", i); 3975 3976 /* If there are multiple alternatives in the constraint, 3977 handle each of them individually. Those that allow register 3978 will be replaced with operand number, the others will stay 3979 unchanged. */ 3980 if (strchr (p, ',') != NULL) 3981 { 3982 size_t len = 0, buflen = strlen (buf); 3983 char *beg, *end, *str, *dst; 3984 3985 for (beg = p + 1;;) 3986 { 3987 end = strchr (beg, ','); 3988 if (end == NULL) 3989 end = strchr (beg, '\0'); 3990 if ((size_t) (end - beg) < buflen) 3991 len += buflen + 1; 3992 else 3993 len += end - beg + 1; 3994 if (*end) 3995 beg = end + 1; 3996 else 3997 break; 3998 } 3999 4000 str = (char *) alloca (len); 4001 for (beg = p + 1, dst = str;;) 4002 { 4003 const char *tem; 4004 bool mem_p, reg_p, inout_p; 4005 4006 end = strchr (beg, ','); 4007 if (end) 4008 *end = '\0'; 4009 beg[-1] = '='; 4010 tem = beg - 1; 4011 parse_output_constraint (&tem, i, 0, 0, 4012 &mem_p, ®_p, &inout_p); 4013 if (dst != str) 4014 *dst++ = ','; 4015 if (reg_p) 4016 { 4017 memcpy (dst, buf, buflen); 4018 dst += buflen; 4019 } 4020 else 4021 { 4022 if (end) 4023 len = end - beg; 4024 else 4025 len = strlen (beg); 4026 memcpy (dst, beg, len); 4027 dst += len; 4028 } 4029 if (end) 4030 beg = end + 1; 4031 else 4032 break; 4033 } 4034 *dst = '\0'; 4035 input = build_string (dst - str, str); 4036 } 4037 else 4038 input = build_string (strlen (buf), buf); 4039 } 4040 else 4041 input = build_string (constraint_len - 1, constraint + 1); 4042 4043 free (p); 4044 4045 input = build_tree_list (build_tree_list (NULL_TREE, input), 4046 unshare_expr (TREE_VALUE (link))); 4047 ASM_INPUTS (expr) = chainon (ASM_INPUTS (expr), input); 4048 } 4049 } 4050 4051 for (link = ASM_INPUTS (expr); link; ++i, link = TREE_CHAIN (link)) 4052 { 4053 constraint 4054 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link))); 4055 parse_input_constraint (&constraint, 0, 0, noutputs, 0, 4056 oconstraints, &allows_mem, &allows_reg); 4057 4058 /* If we can't make copies, we can only accept memory. */ 4059 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link)))) 4060 { 4061 if (allows_mem) 4062 allows_reg = 0; 4063 else 4064 { 4065 error ("impossible constraint in %<asm%>"); 4066 error ("non-memory input %d must stay in memory", i); 4067 return GS_ERROR; 4068 } 4069 } 4070 4071 /* If the operand is a memory input, it should be an lvalue. */ 4072 if (!allows_reg && allows_mem) 4073 { 4074 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p, 4075 is_gimple_lvalue, fb_lvalue | fb_mayfail); 4076 lang_hooks.mark_addressable (TREE_VALUE (link)); 4077 if (tret == GS_ERROR) 4078 { 4079 error ("memory input %d is not directly addressable", i); 4080 ret = tret; 4081 } 4082 } 4083 else 4084 { 4085 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p, 4086 is_gimple_asm_val, fb_rvalue); 4087 if (tret == GS_ERROR) 4088 ret = tret; 4089 } 4090 } 4091 4092 return ret; 4093} 4094 4095/* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding 4096 WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while 4097 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we 4098 return to this function. 4099 4100 FIXME should we complexify the prequeue handling instead? Or use flags 4101 for all the cleanups and let the optimizer tighten them up? The current 4102 code seems pretty fragile; it will break on a cleanup within any 4103 non-conditional nesting. But any such nesting would be broken, anyway; 4104 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct 4105 and continues out of it. We can do that at the RTL level, though, so 4106 having an optimizer to tighten up try/finally regions would be a Good 4107 Thing. */ 4108 4109static enum gimplify_status 4110gimplify_cleanup_point_expr (tree *expr_p, tree *pre_p) 4111{ 4112 tree_stmt_iterator iter; 4113 tree body; 4114 4115 tree temp = voidify_wrapper_expr (*expr_p, NULL); 4116 4117 /* We only care about the number of conditions between the innermost 4118 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and 4119 any cleanups collected outside the CLEANUP_POINT_EXPR. */ 4120 int old_conds = gimplify_ctxp->conditions; 4121 tree old_cleanups = gimplify_ctxp->conditional_cleanups; 4122 gimplify_ctxp->conditions = 0; 4123 gimplify_ctxp->conditional_cleanups = NULL_TREE; 4124 4125 body = TREE_OPERAND (*expr_p, 0); 4126 gimplify_to_stmt_list (&body); 4127 4128 gimplify_ctxp->conditions = old_conds; 4129 gimplify_ctxp->conditional_cleanups = old_cleanups; 4130 4131 for (iter = tsi_start (body); !tsi_end_p (iter); ) 4132 { 4133 tree *wce_p = tsi_stmt_ptr (iter); 4134 tree wce = *wce_p; 4135 4136 if (TREE_CODE (wce) == WITH_CLEANUP_EXPR) 4137 { 4138 if (tsi_one_before_end_p (iter)) 4139 { 4140 tsi_link_before (&iter, TREE_OPERAND (wce, 0), TSI_SAME_STMT); 4141 tsi_delink (&iter); 4142 break; 4143 } 4144 else 4145 { 4146 tree sl, tfe; 4147 enum tree_code code; 4148 4149 if (CLEANUP_EH_ONLY (wce)) 4150 code = TRY_CATCH_EXPR; 4151 else 4152 code = TRY_FINALLY_EXPR; 4153 4154 sl = tsi_split_statement_list_after (&iter); 4155 tfe = build2 (code, void_type_node, sl, NULL_TREE); 4156 append_to_statement_list (TREE_OPERAND (wce, 0), 4157 &TREE_OPERAND (tfe, 1)); 4158 *wce_p = tfe; 4159 iter = tsi_start (sl); 4160 } 4161 } 4162 else 4163 tsi_next (&iter); 4164 } 4165 4166 if (temp) 4167 { 4168 *expr_p = temp; 4169 append_to_statement_list (body, pre_p); 4170 return GS_OK; 4171 } 4172 else 4173 { 4174 *expr_p = body; 4175 return GS_ALL_DONE; 4176 } 4177} 4178 4179/* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP 4180 is the cleanup action required. */ 4181 4182static void 4183gimple_push_cleanup (tree var, tree cleanup, bool eh_only, tree *pre_p) 4184{ 4185 tree wce; 4186 4187 /* Errors can result in improperly nested cleanups. Which results in 4188 confusion when trying to resolve the WITH_CLEANUP_EXPR. */ 4189 if (errorcount || sorrycount) 4190 return; 4191 4192 if (gimple_conditional_context ()) 4193 { 4194 /* If we're in a conditional context, this is more complex. We only 4195 want to run the cleanup if we actually ran the initialization that 4196 necessitates it, but we want to run it after the end of the 4197 conditional context. So we wrap the try/finally around the 4198 condition and use a flag to determine whether or not to actually 4199 run the destructor. Thus 4200 4201 test ? f(A()) : 0 4202 4203 becomes (approximately) 4204 4205 flag = 0; 4206 try { 4207 if (test) { A::A(temp); flag = 1; val = f(temp); } 4208 else { val = 0; } 4209 } finally { 4210 if (flag) A::~A(temp); 4211 } 4212 val 4213 */ 4214 4215 tree flag = create_tmp_var (boolean_type_node, "cleanup"); 4216 tree ffalse = build2 (MODIFY_EXPR, void_type_node, flag, 4217 boolean_false_node); 4218 tree ftrue = build2 (MODIFY_EXPR, void_type_node, flag, 4219 boolean_true_node); 4220 cleanup = build3 (COND_EXPR, void_type_node, flag, cleanup, NULL); 4221 wce = build1 (WITH_CLEANUP_EXPR, void_type_node, cleanup); 4222 append_to_statement_list (ffalse, &gimplify_ctxp->conditional_cleanups); 4223 append_to_statement_list (wce, &gimplify_ctxp->conditional_cleanups); 4224 append_to_statement_list (ftrue, pre_p); 4225 4226 /* Because of this manipulation, and the EH edges that jump 4227 threading cannot redirect, the temporary (VAR) will appear 4228 to be used uninitialized. Don't warn. */ 4229 TREE_NO_WARNING (var) = 1; 4230 } 4231 else 4232 { 4233 wce = build1 (WITH_CLEANUP_EXPR, void_type_node, cleanup); 4234 CLEANUP_EH_ONLY (wce) = eh_only; 4235 append_to_statement_list (wce, pre_p); 4236 } 4237 4238 gimplify_stmt (&TREE_OPERAND (wce, 0)); 4239} 4240 4241/* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */ 4242 4243static enum gimplify_status 4244gimplify_target_expr (tree *expr_p, tree *pre_p, tree *post_p) 4245{ 4246 tree targ = *expr_p; 4247 tree temp = TARGET_EXPR_SLOT (targ); 4248 tree init = TARGET_EXPR_INITIAL (targ); 4249 enum gimplify_status ret; 4250 4251 if (init) 4252 { 4253 /* TARGET_EXPR temps aren't part of the enclosing block, so add it 4254 to the temps list. */ 4255 gimple_add_tmp_var (temp); 4256 4257 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the 4258 expression is supposed to initialize the slot. */ 4259 if (VOID_TYPE_P (TREE_TYPE (init))) 4260 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none); 4261 else 4262 { 4263 init = build2 (INIT_EXPR, void_type_node, temp, init); 4264 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, 4265 fb_none); 4266 } 4267 if (ret == GS_ERROR) 4268 { 4269 /* PR c++/28266 Make sure this is expanded only once. */ 4270 TARGET_EXPR_INITIAL (targ) = NULL_TREE; 4271 return GS_ERROR; 4272 } 4273 append_to_statement_list (init, pre_p); 4274 4275 /* If needed, push the cleanup for the temp. */ 4276 if (TARGET_EXPR_CLEANUP (targ)) 4277 { 4278 gimplify_stmt (&TARGET_EXPR_CLEANUP (targ)); 4279 gimple_push_cleanup (temp, TARGET_EXPR_CLEANUP (targ), 4280 CLEANUP_EH_ONLY (targ), pre_p); 4281 } 4282 4283 /* Only expand this once. */ 4284 TREE_OPERAND (targ, 3) = init; 4285 TARGET_EXPR_INITIAL (targ) = NULL_TREE; 4286 } 4287 else 4288 /* We should have expanded this before. */ 4289 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp)); 4290 4291 *expr_p = temp; 4292 return GS_OK; 4293} 4294 4295/* Gimplification of expression trees. */ 4296 4297/* Gimplify an expression which appears at statement context; usually, this 4298 means replacing it with a suitably gimple STATEMENT_LIST. */ 4299 4300void 4301gimplify_stmt (tree *stmt_p) 4302{ 4303 gimplify_expr (stmt_p, NULL, NULL, is_gimple_stmt, fb_none); 4304} 4305 4306/* Similarly, but force the result to be a STATEMENT_LIST. */ 4307 4308void 4309gimplify_to_stmt_list (tree *stmt_p) 4310{ 4311 gimplify_stmt (stmt_p); 4312 if (!*stmt_p) 4313 *stmt_p = alloc_stmt_list (); 4314 else if (TREE_CODE (*stmt_p) != STATEMENT_LIST) 4315 { 4316 tree t = *stmt_p; 4317 *stmt_p = alloc_stmt_list (); 4318 append_to_statement_list (t, stmt_p); 4319 } 4320} 4321 4322 4323/* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels 4324 to CTX. If entries already exist, force them to be some flavor of private. 4325 If there is no enclosing parallel, do nothing. */ 4326 4327void 4328omp_firstprivatize_variable (struct gimplify_omp_ctx *ctx, tree decl) 4329{ 4330 splay_tree_node n; 4331 4332 if (decl == NULL || !DECL_P (decl)) 4333 return; 4334 4335 do 4336 { 4337 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl); 4338 if (n != NULL) 4339 { 4340 if (n->value & GOVD_SHARED) 4341 n->value = GOVD_FIRSTPRIVATE | (n->value & GOVD_SEEN); 4342 else 4343 return; 4344 } 4345 else if (ctx->is_parallel) 4346 omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE); 4347 4348 ctx = ctx->outer_context; 4349 } 4350 while (ctx); 4351} 4352 4353/* Similarly for each of the type sizes of TYPE. */ 4354 4355static void 4356omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *ctx, tree type) 4357{ 4358 if (type == NULL || type == error_mark_node) 4359 return; 4360 type = TYPE_MAIN_VARIANT (type); 4361 4362 if (pointer_set_insert (ctx->privatized_types, type)) 4363 return; 4364 4365 switch (TREE_CODE (type)) 4366 { 4367 case INTEGER_TYPE: 4368 case ENUMERAL_TYPE: 4369 case BOOLEAN_TYPE: 4370 case REAL_TYPE: 4371 omp_firstprivatize_variable (ctx, TYPE_MIN_VALUE (type)); 4372 omp_firstprivatize_variable (ctx, TYPE_MAX_VALUE (type)); 4373 break; 4374 4375 case ARRAY_TYPE: 4376 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type)); 4377 omp_firstprivatize_type_sizes (ctx, TYPE_DOMAIN (type)); 4378 break; 4379 4380 case RECORD_TYPE: 4381 case UNION_TYPE: 4382 case QUAL_UNION_TYPE: 4383 { 4384 tree field; 4385 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 4386 if (TREE_CODE (field) == FIELD_DECL) 4387 { 4388 omp_firstprivatize_variable (ctx, DECL_FIELD_OFFSET (field)); 4389 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (field)); 4390 } 4391 } 4392 break; 4393 4394 case POINTER_TYPE: 4395 case REFERENCE_TYPE: 4396 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type)); 4397 break; 4398 4399 default: 4400 break; 4401 } 4402 4403 omp_firstprivatize_variable (ctx, TYPE_SIZE (type)); 4404 omp_firstprivatize_variable (ctx, TYPE_SIZE_UNIT (type)); 4405 lang_hooks.types.omp_firstprivatize_type_sizes (ctx, type); 4406} 4407 4408/* Add an entry for DECL in the OpenMP context CTX with FLAGS. */ 4409 4410static void 4411omp_add_variable (struct gimplify_omp_ctx *ctx, tree decl, unsigned int flags) 4412{ 4413 splay_tree_node n; 4414 unsigned int nflags; 4415 tree t; 4416 4417 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node) 4418 return; 4419 4420 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means 4421 there are constructors involved somewhere. */ 4422 if (TREE_ADDRESSABLE (TREE_TYPE (decl)) 4423 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))) 4424 flags |= GOVD_SEEN; 4425 4426 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl); 4427 if (n != NULL) 4428 { 4429 /* We shouldn't be re-adding the decl with the same data 4430 sharing class. */ 4431 gcc_assert ((n->value & GOVD_DATA_SHARE_CLASS & flags) == 0); 4432 /* The only combination of data sharing classes we should see is 4433 FIRSTPRIVATE and LASTPRIVATE. */ 4434 nflags = n->value | flags; 4435 gcc_assert ((nflags & GOVD_DATA_SHARE_CLASS) 4436 == (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE)); 4437 n->value = nflags; 4438 return; 4439 } 4440 4441 /* When adding a variable-sized variable, we have to handle all sorts 4442 of additional bits of data: the pointer replacement variable, and 4443 the parameters of the type. */ 4444 if (DECL_SIZE (decl) && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST) 4445 { 4446 /* Add the pointer replacement variable as PRIVATE if the variable 4447 replacement is private, else FIRSTPRIVATE since we'll need the 4448 address of the original variable either for SHARED, or for the 4449 copy into or out of the context. */ 4450 if (!(flags & GOVD_LOCAL)) 4451 { 4452 nflags = flags & GOVD_PRIVATE ? GOVD_PRIVATE : GOVD_FIRSTPRIVATE; 4453 nflags |= flags & GOVD_SEEN; 4454 t = DECL_VALUE_EXPR (decl); 4455 gcc_assert (TREE_CODE (t) == INDIRECT_REF); 4456 t = TREE_OPERAND (t, 0); 4457 gcc_assert (DECL_P (t)); 4458 omp_add_variable (ctx, t, nflags); 4459 } 4460 4461 /* Add all of the variable and type parameters (which should have 4462 been gimplified to a formal temporary) as FIRSTPRIVATE. */ 4463 omp_firstprivatize_variable (ctx, DECL_SIZE_UNIT (decl)); 4464 omp_firstprivatize_variable (ctx, DECL_SIZE (decl)); 4465 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl)); 4466 4467 /* The variable-sized variable itself is never SHARED, only some form 4468 of PRIVATE. The sharing would take place via the pointer variable 4469 which we remapped above. */ 4470 if (flags & GOVD_SHARED) 4471 flags = GOVD_PRIVATE | GOVD_DEBUG_PRIVATE 4472 | (flags & (GOVD_SEEN | GOVD_EXPLICIT)); 4473 4474 /* We're going to make use of the TYPE_SIZE_UNIT at least in the 4475 alloca statement we generate for the variable, so make sure it 4476 is available. This isn't automatically needed for the SHARED 4477 case, since we won't be allocating local storage then. 4478 For local variables TYPE_SIZE_UNIT might not be gimplified yet, 4479 in this case omp_notice_variable will be called later 4480 on when it is gimplified. */ 4481 else if (! (flags & GOVD_LOCAL)) 4482 omp_notice_variable (ctx, TYPE_SIZE_UNIT (TREE_TYPE (decl)), true); 4483 } 4484 else if (lang_hooks.decls.omp_privatize_by_reference (decl)) 4485 { 4486 gcc_assert ((flags & GOVD_LOCAL) == 0); 4487 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl)); 4488 4489 /* Similar to the direct variable sized case above, we'll need the 4490 size of references being privatized. */ 4491 if ((flags & GOVD_SHARED) == 0) 4492 { 4493 t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl))); 4494 if (TREE_CODE (t) != INTEGER_CST) 4495 omp_notice_variable (ctx, t, true); 4496 } 4497 } 4498 4499 splay_tree_insert (ctx->variables, (splay_tree_key)decl, flags); 4500} 4501 4502/* Record the fact that DECL was used within the OpenMP context CTX. 4503 IN_CODE is true when real code uses DECL, and false when we should 4504 merely emit default(none) errors. Return true if DECL is going to 4505 be remapped and thus DECL shouldn't be gimplified into its 4506 DECL_VALUE_EXPR (if any). */ 4507 4508static bool 4509omp_notice_variable (struct gimplify_omp_ctx *ctx, tree decl, bool in_code) 4510{ 4511 splay_tree_node n; 4512 unsigned flags = in_code ? GOVD_SEEN : 0; 4513 bool ret = false, shared; 4514 4515 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node) 4516 return false; 4517 4518 /* Threadprivate variables are predetermined. */ 4519 if (is_global_var (decl)) 4520 { 4521 if (DECL_THREAD_LOCAL_P (decl)) 4522 return false; 4523 4524 if (DECL_HAS_VALUE_EXPR_P (decl)) 4525 { 4526 tree value = get_base_address (DECL_VALUE_EXPR (decl)); 4527 4528 if (value && DECL_P (value) && DECL_THREAD_LOCAL_P (value)) 4529 return false; 4530 } 4531 } 4532 4533 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl); 4534 if (n == NULL) 4535 { 4536 enum omp_clause_default_kind default_kind, kind; 4537 4538 if (!ctx->is_parallel) 4539 goto do_outer; 4540 4541 /* ??? Some compiler-generated variables (like SAVE_EXPRs) could be 4542 remapped firstprivate instead of shared. To some extent this is 4543 addressed in omp_firstprivatize_type_sizes, but not effectively. */ 4544 default_kind = ctx->default_kind; 4545 kind = lang_hooks.decls.omp_predetermined_sharing (decl); 4546 if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED) 4547 default_kind = kind; 4548 4549 switch (default_kind) 4550 { 4551 case OMP_CLAUSE_DEFAULT_NONE: 4552 error ("%qs not specified in enclosing parallel", 4553 IDENTIFIER_POINTER (DECL_NAME (decl))); 4554 error ("%Henclosing parallel", &ctx->location); 4555 /* FALLTHRU */ 4556 case OMP_CLAUSE_DEFAULT_SHARED: 4557 flags |= GOVD_SHARED; 4558 break; 4559 case OMP_CLAUSE_DEFAULT_PRIVATE: 4560 flags |= GOVD_PRIVATE; 4561 break; 4562 default: 4563 gcc_unreachable (); 4564 } 4565 4566 omp_add_variable (ctx, decl, flags); 4567 4568 shared = (flags & GOVD_SHARED) != 0; 4569 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared); 4570 goto do_outer; 4571 } 4572 4573 shared = ((flags | n->value) & GOVD_SHARED) != 0; 4574 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared); 4575 4576 /* If nothing changed, there's nothing left to do. */ 4577 if ((n->value & flags) == flags) 4578 return ret; 4579 flags |= n->value; 4580 n->value = flags; 4581 4582 do_outer: 4583 /* If the variable is private in the current context, then we don't 4584 need to propagate anything to an outer context. */ 4585 if (flags & GOVD_PRIVATE) 4586 return ret; 4587 if (ctx->outer_context 4588 && omp_notice_variable (ctx->outer_context, decl, in_code)) 4589 return true; 4590 return ret; 4591} 4592 4593/* Verify that DECL is private within CTX. If there's specific information 4594 to the contrary in the innermost scope, generate an error. */ 4595 4596static bool 4597omp_is_private (struct gimplify_omp_ctx *ctx, tree decl) 4598{ 4599 splay_tree_node n; 4600 4601 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl); 4602 if (n != NULL) 4603 { 4604 if (n->value & GOVD_SHARED) 4605 { 4606 if (ctx == gimplify_omp_ctxp) 4607 { 4608 error ("iteration variable %qs should be private", 4609 IDENTIFIER_POINTER (DECL_NAME (decl))); 4610 n->value = GOVD_PRIVATE; 4611 return true; 4612 } 4613 else 4614 return false; 4615 } 4616 else if ((n->value & GOVD_EXPLICIT) != 0 4617 && (ctx == gimplify_omp_ctxp 4618 || (ctx->is_combined_parallel 4619 && gimplify_omp_ctxp->outer_context == ctx))) 4620 { 4621 if ((n->value & GOVD_FIRSTPRIVATE) != 0) 4622 error ("iteration variable %qs should not be firstprivate", 4623 IDENTIFIER_POINTER (DECL_NAME (decl))); 4624 else if ((n->value & GOVD_REDUCTION) != 0) 4625 error ("iteration variable %qs should not be reduction", 4626 IDENTIFIER_POINTER (DECL_NAME (decl))); 4627 } 4628 return true; 4629 } 4630 4631 if (ctx->is_parallel) 4632 return false; 4633 else if (ctx->outer_context) 4634 return omp_is_private (ctx->outer_context, decl); 4635 else 4636 return !is_global_var (decl); 4637} 4638 4639/* Return true if DECL is private within a parallel region 4640 that binds to the current construct's context or in parallel 4641 region's REDUCTION clause. */ 4642 4643static bool 4644omp_check_private (struct gimplify_omp_ctx *ctx, tree decl) 4645{ 4646 splay_tree_node n; 4647 4648 do 4649 { 4650 ctx = ctx->outer_context; 4651 if (ctx == NULL) 4652 return !(is_global_var (decl) 4653 /* References might be private, but might be shared too. */ 4654 || lang_hooks.decls.omp_privatize_by_reference (decl)); 4655 4656 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl); 4657 if (n != NULL) 4658 return (n->value & GOVD_SHARED) == 0; 4659 } 4660 while (!ctx->is_parallel); 4661 return false; 4662} 4663 4664/* Scan the OpenMP clauses in *LIST_P, installing mappings into a new 4665 and previous omp contexts. */ 4666 4667static void 4668gimplify_scan_omp_clauses (tree *list_p, tree *pre_p, bool in_parallel, 4669 bool in_combined_parallel) 4670{ 4671 struct gimplify_omp_ctx *ctx, *outer_ctx; 4672 tree c; 4673 4674 ctx = new_omp_context (in_parallel, in_combined_parallel); 4675 outer_ctx = ctx->outer_context; 4676 4677 while ((c = *list_p) != NULL) 4678 { 4679 enum gimplify_status gs; 4680 bool remove = false; 4681 bool notice_outer = true; 4682 const char *check_non_private = NULL; 4683 unsigned int flags; 4684 tree decl; 4685 4686 switch (OMP_CLAUSE_CODE (c)) 4687 { 4688 case OMP_CLAUSE_PRIVATE: 4689 flags = GOVD_PRIVATE | GOVD_EXPLICIT; 4690 notice_outer = false; 4691 goto do_add; 4692 case OMP_CLAUSE_SHARED: 4693 flags = GOVD_SHARED | GOVD_EXPLICIT; 4694 goto do_add; 4695 case OMP_CLAUSE_FIRSTPRIVATE: 4696 flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT; 4697 check_non_private = "firstprivate"; 4698 goto do_add; 4699 case OMP_CLAUSE_LASTPRIVATE: 4700 flags = GOVD_LASTPRIVATE | GOVD_SEEN | GOVD_EXPLICIT; 4701 check_non_private = "lastprivate"; 4702 goto do_add; 4703 case OMP_CLAUSE_REDUCTION: 4704 flags = GOVD_REDUCTION | GOVD_SEEN | GOVD_EXPLICIT; 4705 check_non_private = "reduction"; 4706 goto do_add; 4707 4708 do_add: 4709 decl = OMP_CLAUSE_DECL (c); 4710 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node) 4711 { 4712 remove = true; 4713 break; 4714 } 4715 omp_add_variable (ctx, decl, flags); 4716 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION 4717 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c)) 4718 { 4719 omp_add_variable (ctx, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c), 4720 GOVD_LOCAL | GOVD_SEEN); 4721 gimplify_omp_ctxp = ctx; 4722 push_gimplify_context (); 4723 gimplify_stmt (&OMP_CLAUSE_REDUCTION_INIT (c)); 4724 pop_gimplify_context (OMP_CLAUSE_REDUCTION_INIT (c)); 4725 push_gimplify_context (); 4726 gimplify_stmt (&OMP_CLAUSE_REDUCTION_MERGE (c)); 4727 pop_gimplify_context (OMP_CLAUSE_REDUCTION_MERGE (c)); 4728 gimplify_omp_ctxp = outer_ctx; 4729 } 4730 if (notice_outer) 4731 goto do_notice; 4732 break; 4733 4734 case OMP_CLAUSE_COPYIN: 4735 case OMP_CLAUSE_COPYPRIVATE: 4736 decl = OMP_CLAUSE_DECL (c); 4737 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node) 4738 { 4739 remove = true; 4740 break; 4741 } 4742 do_notice: 4743 if (outer_ctx) 4744 omp_notice_variable (outer_ctx, decl, true); 4745 if (check_non_private 4746 && !in_parallel 4747 && omp_check_private (ctx, decl)) 4748 { 4749 error ("%s variable %qs is private in outer context", 4750 check_non_private, IDENTIFIER_POINTER (DECL_NAME (decl))); 4751 remove = true; 4752 } 4753 break; 4754 4755 case OMP_CLAUSE_IF: 4756 OMP_CLAUSE_OPERAND (c, 0) 4757 = gimple_boolify (OMP_CLAUSE_OPERAND (c, 0)); 4758 /* Fall through. */ 4759 4760 case OMP_CLAUSE_SCHEDULE: 4761 case OMP_CLAUSE_NUM_THREADS: 4762 gs = gimplify_expr (&OMP_CLAUSE_OPERAND (c, 0), pre_p, NULL, 4763 is_gimple_val, fb_rvalue); 4764 if (gs == GS_ERROR) 4765 remove = true; 4766 break; 4767 4768 case OMP_CLAUSE_NOWAIT: 4769 case OMP_CLAUSE_ORDERED: 4770 break; 4771 4772 case OMP_CLAUSE_DEFAULT: 4773 ctx->default_kind = OMP_CLAUSE_DEFAULT_KIND (c); 4774 break; 4775 4776 default: 4777 gcc_unreachable (); 4778 } 4779 4780 if (remove) 4781 *list_p = OMP_CLAUSE_CHAIN (c); 4782 else 4783 list_p = &OMP_CLAUSE_CHAIN (c); 4784 } 4785 4786 gimplify_omp_ctxp = ctx; 4787} 4788 4789/* For all variables that were not actually used within the context, 4790 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */ 4791 4792static int 4793gimplify_adjust_omp_clauses_1 (splay_tree_node n, void *data) 4794{ 4795 tree *list_p = (tree *) data; 4796 tree decl = (tree) n->key; 4797 unsigned flags = n->value; 4798 enum omp_clause_code code; 4799 tree clause; 4800 bool private_debug; 4801 4802 if (flags & (GOVD_EXPLICIT | GOVD_LOCAL)) 4803 return 0; 4804 if ((flags & GOVD_SEEN) == 0) 4805 return 0; 4806 if (flags & GOVD_DEBUG_PRIVATE) 4807 { 4808 gcc_assert ((flags & GOVD_DATA_SHARE_CLASS) == GOVD_PRIVATE); 4809 private_debug = true; 4810 } 4811 else 4812 private_debug 4813 = lang_hooks.decls.omp_private_debug_clause (decl, 4814 !!(flags & GOVD_SHARED)); 4815 if (private_debug) 4816 code = OMP_CLAUSE_PRIVATE; 4817 else if (flags & GOVD_SHARED) 4818 { 4819 if (is_global_var (decl)) 4820 { 4821 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp->outer_context; 4822 while (ctx != NULL) 4823 { 4824 splay_tree_node on 4825 = splay_tree_lookup (ctx->variables, (splay_tree_key) decl); 4826 if (on && (on->value & (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE 4827 | GOVD_PRIVATE | GOVD_REDUCTION)) != 0) 4828 break; 4829 ctx = ctx->outer_context; 4830 } 4831 if (ctx == NULL) 4832 return 0; 4833 } 4834 code = OMP_CLAUSE_SHARED; 4835 } 4836 else if (flags & GOVD_PRIVATE) 4837 code = OMP_CLAUSE_PRIVATE; 4838 else if (flags & GOVD_FIRSTPRIVATE) 4839 code = OMP_CLAUSE_FIRSTPRIVATE; 4840 else 4841 gcc_unreachable (); 4842 4843 clause = build_omp_clause (code); 4844 OMP_CLAUSE_DECL (clause) = decl; 4845 OMP_CLAUSE_CHAIN (clause) = *list_p; 4846 if (private_debug) 4847 OMP_CLAUSE_PRIVATE_DEBUG (clause) = 1; 4848 *list_p = clause; 4849 4850 return 0; 4851} 4852 4853static void 4854gimplify_adjust_omp_clauses (tree *list_p) 4855{ 4856 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp; 4857 tree c, decl; 4858 4859 while ((c = *list_p) != NULL) 4860 { 4861 splay_tree_node n; 4862 bool remove = false; 4863 4864 switch (OMP_CLAUSE_CODE (c)) 4865 { 4866 case OMP_CLAUSE_PRIVATE: 4867 case OMP_CLAUSE_SHARED: 4868 case OMP_CLAUSE_FIRSTPRIVATE: 4869 decl = OMP_CLAUSE_DECL (c); 4870 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl); 4871 remove = !(n->value & GOVD_SEEN); 4872 if (! remove) 4873 { 4874 bool shared = OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED; 4875 if ((n->value & GOVD_DEBUG_PRIVATE) 4876 || lang_hooks.decls.omp_private_debug_clause (decl, shared)) 4877 { 4878 gcc_assert ((n->value & GOVD_DEBUG_PRIVATE) == 0 4879 || ((n->value & GOVD_DATA_SHARE_CLASS) 4880 == GOVD_PRIVATE)); 4881 OMP_CLAUSE_SET_CODE (c, OMP_CLAUSE_PRIVATE); 4882 OMP_CLAUSE_PRIVATE_DEBUG (c) = 1; 4883 } 4884 } 4885 break; 4886 4887 case OMP_CLAUSE_LASTPRIVATE: 4888 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to 4889 accurately reflect the presence of a FIRSTPRIVATE clause. */ 4890 decl = OMP_CLAUSE_DECL (c); 4891 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl); 4892 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c) 4893 = (n->value & GOVD_FIRSTPRIVATE) != 0; 4894 break; 4895 4896 case OMP_CLAUSE_REDUCTION: 4897 case OMP_CLAUSE_COPYIN: 4898 case OMP_CLAUSE_COPYPRIVATE: 4899 case OMP_CLAUSE_IF: 4900 case OMP_CLAUSE_NUM_THREADS: 4901 case OMP_CLAUSE_SCHEDULE: 4902 case OMP_CLAUSE_NOWAIT: 4903 case OMP_CLAUSE_ORDERED: 4904 case OMP_CLAUSE_DEFAULT: 4905 break; 4906 4907 default: 4908 gcc_unreachable (); 4909 } 4910 4911 if (remove) 4912 *list_p = OMP_CLAUSE_CHAIN (c); 4913 else 4914 list_p = &OMP_CLAUSE_CHAIN (c); 4915 } 4916 4917 /* Add in any implicit data sharing. */ 4918 splay_tree_foreach (ctx->variables, gimplify_adjust_omp_clauses_1, list_p); 4919 4920 gimplify_omp_ctxp = ctx->outer_context; 4921 delete_omp_context (ctx); 4922} 4923 4924/* Gimplify the contents of an OMP_PARALLEL statement. This involves 4925 gimplification of the body, as well as scanning the body for used 4926 variables. We need to do this scan now, because variable-sized 4927 decls will be decomposed during gimplification. */ 4928 4929static enum gimplify_status 4930gimplify_omp_parallel (tree *expr_p, tree *pre_p) 4931{ 4932 tree expr = *expr_p; 4933 4934 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr), pre_p, true, 4935 OMP_PARALLEL_COMBINED (expr)); 4936 4937 push_gimplify_context (); 4938 4939 gimplify_stmt (&OMP_PARALLEL_BODY (expr)); 4940 4941 if (TREE_CODE (OMP_PARALLEL_BODY (expr)) == BIND_EXPR) 4942 pop_gimplify_context (OMP_PARALLEL_BODY (expr)); 4943 else 4944 pop_gimplify_context (NULL_TREE); 4945 4946 gimplify_adjust_omp_clauses (&OMP_PARALLEL_CLAUSES (expr)); 4947 4948 return GS_ALL_DONE; 4949} 4950 4951/* Gimplify the gross structure of an OMP_FOR statement. */ 4952 4953static enum gimplify_status 4954gimplify_omp_for (tree *expr_p, tree *pre_p) 4955{ 4956 tree for_stmt, decl, t; 4957 enum gimplify_status ret = 0; 4958 4959 for_stmt = *expr_p; 4960 4961 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt), pre_p, false, false); 4962 4963 t = OMP_FOR_INIT (for_stmt); 4964 gcc_assert (TREE_CODE (t) == MODIFY_EXPR); 4965 decl = TREE_OPERAND (t, 0); 4966 gcc_assert (DECL_P (decl)); 4967 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl))); 4968 4969 /* Make sure the iteration variable is private. */ 4970 if (omp_is_private (gimplify_omp_ctxp, decl)) 4971 omp_notice_variable (gimplify_omp_ctxp, decl, true); 4972 else 4973 omp_add_variable (gimplify_omp_ctxp, decl, GOVD_PRIVATE | GOVD_SEEN); 4974 4975 ret |= gimplify_expr (&TREE_OPERAND (t, 1), &OMP_FOR_PRE_BODY (for_stmt), 4976 NULL, is_gimple_val, fb_rvalue); 4977 4978 t = OMP_FOR_COND (for_stmt); 4979 gcc_assert (COMPARISON_CLASS_P (t)); 4980 gcc_assert (TREE_OPERAND (t, 0) == decl); 4981 4982 ret |= gimplify_expr (&TREE_OPERAND (t, 1), &OMP_FOR_PRE_BODY (for_stmt), 4983 NULL, is_gimple_val, fb_rvalue); 4984 4985 t = OMP_FOR_INCR (for_stmt); 4986 switch (TREE_CODE (t)) 4987 { 4988 case PREINCREMENT_EXPR: 4989 case POSTINCREMENT_EXPR: 4990 t = build_int_cst (TREE_TYPE (decl), 1); 4991 goto build_modify; 4992 case PREDECREMENT_EXPR: 4993 case POSTDECREMENT_EXPR: 4994 t = build_int_cst (TREE_TYPE (decl), -1); 4995 goto build_modify; 4996 build_modify: 4997 t = build2 (PLUS_EXPR, TREE_TYPE (decl), decl, t); 4998 t = build2 (MODIFY_EXPR, void_type_node, decl, t); 4999 OMP_FOR_INCR (for_stmt) = t; 5000 break; 5001 5002 case MODIFY_EXPR: 5003 gcc_assert (TREE_OPERAND (t, 0) == decl); 5004 t = TREE_OPERAND (t, 1); 5005 switch (TREE_CODE (t)) 5006 { 5007 case PLUS_EXPR: 5008 if (TREE_OPERAND (t, 1) == decl) 5009 { 5010 TREE_OPERAND (t, 1) = TREE_OPERAND (t, 0); 5011 TREE_OPERAND (t, 0) = decl; 5012 break; 5013 } 5014 case MINUS_EXPR: 5015 gcc_assert (TREE_OPERAND (t, 0) == decl); 5016 break; 5017 default: 5018 gcc_unreachable (); 5019 } 5020 5021 ret |= gimplify_expr (&TREE_OPERAND (t, 1), &OMP_FOR_PRE_BODY (for_stmt), 5022 NULL, is_gimple_val, fb_rvalue); 5023 break; 5024 5025 default: 5026 gcc_unreachable (); 5027 } 5028 5029 gimplify_to_stmt_list (&OMP_FOR_BODY (for_stmt)); 5030 gimplify_adjust_omp_clauses (&OMP_FOR_CLAUSES (for_stmt)); 5031 5032 return ret == GS_ALL_DONE ? GS_ALL_DONE : GS_ERROR; 5033} 5034 5035/* Gimplify the gross structure of other OpenMP worksharing constructs. 5036 In particular, OMP_SECTIONS and OMP_SINGLE. */ 5037 5038static enum gimplify_status 5039gimplify_omp_workshare (tree *expr_p, tree *pre_p) 5040{ 5041 tree stmt = *expr_p; 5042 5043 gimplify_scan_omp_clauses (&OMP_CLAUSES (stmt), pre_p, false, false); 5044 gimplify_to_stmt_list (&OMP_BODY (stmt)); 5045 gimplify_adjust_omp_clauses (&OMP_CLAUSES (stmt)); 5046 5047 return GS_ALL_DONE; 5048} 5049 5050/* A subroutine of gimplify_omp_atomic. The front end is supposed to have 5051 stabilized the lhs of the atomic operation as *ADDR. Return true if 5052 EXPR is this stabilized form. */ 5053 5054static bool 5055goa_lhs_expr_p (tree expr, tree addr) 5056{ 5057 /* Also include casts to other type variants. The C front end is fond 5058 of adding these for e.g. volatile variables. This is like 5059 STRIP_TYPE_NOPS but includes the main variant lookup. */ 5060 while ((TREE_CODE (expr) == NOP_EXPR 5061 || TREE_CODE (expr) == CONVERT_EXPR 5062 || TREE_CODE (expr) == NON_LVALUE_EXPR) 5063 && TREE_OPERAND (expr, 0) != error_mark_node 5064 && (TYPE_MAIN_VARIANT (TREE_TYPE (expr)) 5065 == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (expr, 0))))) 5066 expr = TREE_OPERAND (expr, 0); 5067 5068 if (TREE_CODE (expr) == INDIRECT_REF && TREE_OPERAND (expr, 0) == addr) 5069 return true; 5070 if (TREE_CODE (addr) == ADDR_EXPR && expr == TREE_OPERAND (addr, 0)) 5071 return true; 5072 return false; 5073} 5074 5075/* A subroutine of gimplify_omp_atomic. Attempt to implement the atomic 5076 operation as a __sync_fetch_and_op builtin. INDEX is log2 of the 5077 size of the data type, and thus usable to find the index of the builtin 5078 decl. Returns GS_UNHANDLED if the expression is not of the proper form. */ 5079 5080static enum gimplify_status 5081gimplify_omp_atomic_fetch_op (tree *expr_p, tree addr, tree rhs, int index) 5082{ 5083 enum built_in_function base; 5084 tree decl, args, itype; 5085 enum insn_code *optab; 5086 5087 /* Check for one of the supported fetch-op operations. */ 5088 switch (TREE_CODE (rhs)) 5089 { 5090 case PLUS_EXPR: 5091 base = BUILT_IN_FETCH_AND_ADD_N; 5092 optab = sync_add_optab; 5093 break; 5094 case MINUS_EXPR: 5095 base = BUILT_IN_FETCH_AND_SUB_N; 5096 optab = sync_add_optab; 5097 break; 5098 case BIT_AND_EXPR: 5099 base = BUILT_IN_FETCH_AND_AND_N; 5100 optab = sync_and_optab; 5101 break; 5102 case BIT_IOR_EXPR: 5103 base = BUILT_IN_FETCH_AND_OR_N; 5104 optab = sync_ior_optab; 5105 break; 5106 case BIT_XOR_EXPR: 5107 base = BUILT_IN_FETCH_AND_XOR_N; 5108 optab = sync_xor_optab; 5109 break; 5110 default: 5111 return GS_UNHANDLED; 5112 } 5113 5114 /* Make sure the expression is of the proper form. */ 5115 if (goa_lhs_expr_p (TREE_OPERAND (rhs, 0), addr)) 5116 rhs = TREE_OPERAND (rhs, 1); 5117 else if (commutative_tree_code (TREE_CODE (rhs)) 5118 && goa_lhs_expr_p (TREE_OPERAND (rhs, 1), addr)) 5119 rhs = TREE_OPERAND (rhs, 0); 5120 else 5121 return GS_UNHANDLED; 5122 5123 decl = built_in_decls[base + index + 1]; 5124 itype = TREE_TYPE (TREE_TYPE (decl)); 5125 5126 if (optab[TYPE_MODE (itype)] == CODE_FOR_nothing) 5127 return GS_UNHANDLED; 5128 5129 args = tree_cons (NULL, fold_convert (itype, rhs), NULL); 5130 args = tree_cons (NULL, addr, args); 5131 *expr_p = build_function_call_expr (decl, args); 5132 return GS_OK; 5133} 5134 5135/* A subroutine of gimplify_omp_atomic_pipeline. Walk *EXPR_P and replace 5136 appearances of *LHS_ADDR with LHS_VAR. If an expression does not involve 5137 the lhs, evaluate it into a temporary. Return 1 if the lhs appeared as 5138 a subexpression, 0 if it did not, or -1 if an error was encountered. */ 5139 5140static int 5141goa_stabilize_expr (tree *expr_p, tree *pre_p, tree lhs_addr, tree lhs_var) 5142{ 5143 tree expr = *expr_p; 5144 int saw_lhs; 5145 5146 if (goa_lhs_expr_p (expr, lhs_addr)) 5147 { 5148 *expr_p = lhs_var; 5149 return 1; 5150 } 5151 if (is_gimple_val (expr)) 5152 return 0; 5153 5154 saw_lhs = 0; 5155 switch (TREE_CODE_CLASS (TREE_CODE (expr))) 5156 { 5157 case tcc_binary: 5158 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p, 5159 lhs_addr, lhs_var); 5160 case tcc_unary: 5161 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p, 5162 lhs_addr, lhs_var); 5163 break; 5164 default: 5165 break; 5166 } 5167 5168 if (saw_lhs == 0) 5169 { 5170 enum gimplify_status gs; 5171 gs = gimplify_expr (expr_p, pre_p, NULL, is_gimple_val, fb_rvalue); 5172 if (gs != GS_ALL_DONE) 5173 saw_lhs = -1; 5174 } 5175 5176 return saw_lhs; 5177} 5178 5179/* A subroutine of gimplify_omp_atomic. Implement the atomic operation as: 5180 5181 oldval = *addr; 5182 repeat: 5183 newval = rhs; // with oldval replacing *addr in rhs 5184 oldval = __sync_val_compare_and_swap (addr, oldval, newval); 5185 if (oldval != newval) 5186 goto repeat; 5187 5188 INDEX is log2 of the size of the data type, and thus usable to find the 5189 index of the builtin decl. */ 5190 5191static enum gimplify_status 5192gimplify_omp_atomic_pipeline (tree *expr_p, tree *pre_p, tree addr, 5193 tree rhs, int index) 5194{ 5195 tree oldval, oldival, oldival2, newval, newival, label; 5196 tree type, itype, cmpxchg, args, x, iaddr; 5197 5198 cmpxchg = built_in_decls[BUILT_IN_VAL_COMPARE_AND_SWAP_N + index + 1]; 5199 type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr))); 5200 itype = TREE_TYPE (TREE_TYPE (cmpxchg)); 5201 5202 if (sync_compare_and_swap[TYPE_MODE (itype)] == CODE_FOR_nothing) 5203 return GS_UNHANDLED; 5204 5205 oldval = create_tmp_var (type, NULL); 5206 newval = create_tmp_var (type, NULL); 5207 5208 /* Precompute as much of RHS as possible. In the same walk, replace 5209 occurrences of the lhs value with our temporary. */ 5210 if (goa_stabilize_expr (&rhs, pre_p, addr, oldval) < 0) 5211 return GS_ERROR; 5212 5213 x = build_fold_indirect_ref (addr); 5214 x = build2 (MODIFY_EXPR, void_type_node, oldval, x); 5215 gimplify_and_add (x, pre_p); 5216 5217 /* For floating-point values, we'll need to view-convert them to integers 5218 so that we can perform the atomic compare and swap. Simplify the 5219 following code by always setting up the "i"ntegral variables. */ 5220 if (INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type)) 5221 { 5222 oldival = oldval; 5223 newival = newval; 5224 iaddr = addr; 5225 } 5226 else 5227 { 5228 oldival = create_tmp_var (itype, NULL); 5229 newival = create_tmp_var (itype, NULL); 5230 5231 x = build1 (VIEW_CONVERT_EXPR, itype, oldval); 5232 x = build2 (MODIFY_EXPR, void_type_node, oldival, x); 5233 gimplify_and_add (x, pre_p); 5234 iaddr = fold_convert (build_pointer_type (itype), addr); 5235 } 5236 5237 oldival2 = create_tmp_var (itype, NULL); 5238 5239 label = create_artificial_label (); 5240 x = build1 (LABEL_EXPR, void_type_node, label); 5241 gimplify_and_add (x, pre_p); 5242 5243 x = build2 (MODIFY_EXPR, void_type_node, newval, rhs); 5244 gimplify_and_add (x, pre_p); 5245 5246 if (newval != newival) 5247 { 5248 x = build1 (VIEW_CONVERT_EXPR, itype, newval); 5249 x = build2 (MODIFY_EXPR, void_type_node, newival, x); 5250 gimplify_and_add (x, pre_p); 5251 } 5252 5253 x = build2 (MODIFY_EXPR, void_type_node, oldival2, 5254 fold_convert (itype, oldival)); 5255 gimplify_and_add (x, pre_p); 5256 5257 args = tree_cons (NULL, fold_convert (itype, newival), NULL); 5258 args = tree_cons (NULL, fold_convert (itype, oldival), args); 5259 args = tree_cons (NULL, iaddr, args); 5260 x = build_function_call_expr (cmpxchg, args); 5261 if (oldval == oldival) 5262 x = fold_convert (type, x); 5263 x = build2 (MODIFY_EXPR, void_type_node, oldival, x); 5264 gimplify_and_add (x, pre_p); 5265 5266 /* For floating point, be prepared for the loop backedge. */ 5267 if (oldval != oldival) 5268 { 5269 x = build1 (VIEW_CONVERT_EXPR, type, oldival); 5270 x = build2 (MODIFY_EXPR, void_type_node, oldval, x); 5271 gimplify_and_add (x, pre_p); 5272 } 5273 5274 /* Note that we always perform the comparison as an integer, even for 5275 floating point. This allows the atomic operation to properly 5276 succeed even with NaNs and -0.0. */ 5277 x = build3 (COND_EXPR, void_type_node, 5278 build2 (NE_EXPR, boolean_type_node, oldival, oldival2), 5279 build1 (GOTO_EXPR, void_type_node, label), NULL); 5280 gimplify_and_add (x, pre_p); 5281 5282 *expr_p = NULL; 5283 return GS_ALL_DONE; 5284} 5285 5286/* A subroutine of gimplify_omp_atomic. Implement the atomic operation as: 5287 5288 GOMP_atomic_start (); 5289 *addr = rhs; 5290 GOMP_atomic_end (); 5291 5292 The result is not globally atomic, but works so long as all parallel 5293 references are within #pragma omp atomic directives. According to 5294 responses received from omp@openmp.org, appears to be within spec. 5295 Which makes sense, since that's how several other compilers handle 5296 this situation as well. */ 5297 5298static enum gimplify_status 5299gimplify_omp_atomic_mutex (tree *expr_p, tree *pre_p, tree addr, tree rhs) 5300{ 5301 tree t; 5302 5303 t = built_in_decls[BUILT_IN_GOMP_ATOMIC_START]; 5304 t = build_function_call_expr (t, NULL); 5305 gimplify_and_add (t, pre_p); 5306 5307 t = build_fold_indirect_ref (addr); 5308 t = build2 (MODIFY_EXPR, void_type_node, t, rhs); 5309 gimplify_and_add (t, pre_p); 5310 5311 t = built_in_decls[BUILT_IN_GOMP_ATOMIC_END]; 5312 t = build_function_call_expr (t, NULL); 5313 gimplify_and_add (t, pre_p); 5314 5315 *expr_p = NULL; 5316 return GS_ALL_DONE; 5317} 5318 5319/* Gimplify an OMP_ATOMIC statement. */ 5320 5321static enum gimplify_status 5322gimplify_omp_atomic (tree *expr_p, tree *pre_p) 5323{ 5324 tree addr = TREE_OPERAND (*expr_p, 0); 5325 tree rhs = TREE_OPERAND (*expr_p, 1); 5326 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr))); 5327 HOST_WIDE_INT index; 5328 5329 /* Make sure the type is one of the supported sizes. */ 5330 index = tree_low_cst (TYPE_SIZE_UNIT (type), 1); 5331 index = exact_log2 (index); 5332 if (index >= 0 && index <= 4) 5333 { 5334 enum gimplify_status gs; 5335 unsigned int align; 5336 5337 if (DECL_P (TREE_OPERAND (addr, 0))) 5338 align = DECL_ALIGN_UNIT (TREE_OPERAND (addr, 0)); 5339 else if (TREE_CODE (TREE_OPERAND (addr, 0)) == COMPONENT_REF 5340 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (addr, 0), 1)) 5341 == FIELD_DECL) 5342 align = DECL_ALIGN_UNIT (TREE_OPERAND (TREE_OPERAND (addr, 0), 1)); 5343 else 5344 align = TYPE_ALIGN_UNIT (type); 5345 5346 /* __sync builtins require strict data alignment. */ 5347 if (exact_log2 (align) >= index) 5348 { 5349 /* When possible, use specialized atomic update functions. */ 5350 if (INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type)) 5351 { 5352 gs = gimplify_omp_atomic_fetch_op (expr_p, addr, rhs, index); 5353 if (gs != GS_UNHANDLED) 5354 return gs; 5355 } 5356 5357 /* If we don't have specialized __sync builtins, try and implement 5358 as a compare and swap loop. */ 5359 gs = gimplify_omp_atomic_pipeline (expr_p, pre_p, addr, rhs, index); 5360 if (gs != GS_UNHANDLED) 5361 return gs; 5362 } 5363 } 5364 5365 /* The ultimate fallback is wrapping the operation in a mutex. */ 5366 return gimplify_omp_atomic_mutex (expr_p, pre_p, addr, rhs); 5367} 5368 5369/* Gimplifies the expression tree pointed to by EXPR_P. Return 0 if 5370 gimplification failed. 5371 5372 PRE_P points to the list where side effects that must happen before 5373 EXPR should be stored. 5374 5375 POST_P points to the list where side effects that must happen after 5376 EXPR should be stored, or NULL if there is no suitable list. In 5377 that case, we copy the result to a temporary, emit the 5378 post-effects, and then return the temporary. 5379 5380 GIMPLE_TEST_F points to a function that takes a tree T and 5381 returns nonzero if T is in the GIMPLE form requested by the 5382 caller. The GIMPLE predicates are in tree-gimple.c. 5383 5384 This test is used twice. Before gimplification, the test is 5385 invoked to determine whether *EXPR_P is already gimple enough. If 5386 that fails, *EXPR_P is gimplified according to its code and 5387 GIMPLE_TEST_F is called again. If the test still fails, then a new 5388 temporary variable is created and assigned the value of the 5389 gimplified expression. 5390 5391 FALLBACK tells the function what sort of a temporary we want. If the 1 5392 bit is set, an rvalue is OK. If the 2 bit is set, an lvalue is OK. 5393 If both are set, either is OK, but an lvalue is preferable. 5394 5395 The return value is either GS_ERROR or GS_ALL_DONE, since this function 5396 iterates until solution. */ 5397 5398enum gimplify_status 5399gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p, 5400 bool (* gimple_test_f) (tree), fallback_t fallback) 5401{ 5402 tree tmp; 5403 tree internal_pre = NULL_TREE; 5404 tree internal_post = NULL_TREE; 5405 tree save_expr; 5406 int is_statement = (pre_p == NULL); 5407 location_t saved_location; 5408 enum gimplify_status ret; 5409 5410 save_expr = *expr_p; 5411 if (save_expr == NULL_TREE) 5412 return GS_ALL_DONE; 5413 5414 /* We used to check the predicate here and return immediately if it 5415 succeeds. This is wrong; the design is for gimplification to be 5416 idempotent, and for the predicates to only test for valid forms, not 5417 whether they are fully simplified. */ 5418 5419 /* Set up our internal queues if needed. */ 5420 if (pre_p == NULL) 5421 pre_p = &internal_pre; 5422 if (post_p == NULL) 5423 post_p = &internal_post; 5424 5425 saved_location = input_location; 5426 if (save_expr != error_mark_node 5427 && EXPR_HAS_LOCATION (*expr_p)) 5428 input_location = EXPR_LOCATION (*expr_p); 5429 5430 /* Loop over the specific gimplifiers until the toplevel node 5431 remains the same. */ 5432 do 5433 { 5434 /* Strip away as many useless type conversions as possible 5435 at the toplevel. */ 5436 STRIP_USELESS_TYPE_CONVERSION (*expr_p); 5437 5438 /* Remember the expr. */ 5439 save_expr = *expr_p; 5440 5441 /* Die, die, die, my darling. */ 5442 if (save_expr == error_mark_node 5443 || (TREE_TYPE (save_expr) 5444 && TREE_TYPE (save_expr) == error_mark_node)) 5445 { 5446 ret = GS_ERROR; 5447 break; 5448 } 5449 5450 /* Do any language-specific gimplification. */ 5451 ret = lang_hooks.gimplify_expr (expr_p, pre_p, post_p); 5452 if (ret == GS_OK) 5453 { 5454 if (*expr_p == NULL_TREE) 5455 break; 5456 if (*expr_p != save_expr) 5457 continue; 5458 } 5459 else if (ret != GS_UNHANDLED) 5460 break; 5461 5462 ret = GS_OK; 5463 switch (TREE_CODE (*expr_p)) 5464 { 5465 /* First deal with the special cases. */ 5466 5467 case POSTINCREMENT_EXPR: 5468 case POSTDECREMENT_EXPR: 5469 case PREINCREMENT_EXPR: 5470 case PREDECREMENT_EXPR: 5471 ret = gimplify_self_mod_expr (expr_p, pre_p, post_p, 5472 fallback != fb_none); 5473 break; 5474 5475 case ARRAY_REF: 5476 case ARRAY_RANGE_REF: 5477 case REALPART_EXPR: 5478 case IMAGPART_EXPR: 5479 case COMPONENT_REF: 5480 case VIEW_CONVERT_EXPR: 5481 ret = gimplify_compound_lval (expr_p, pre_p, post_p, 5482 fallback ? fallback : fb_rvalue); 5483 break; 5484 5485 case COND_EXPR: 5486 ret = gimplify_cond_expr (expr_p, pre_p, fallback); 5487 /* C99 code may assign to an array in a structure value of a 5488 conditional expression, and this has undefined behavior 5489 only on execution, so create a temporary if an lvalue is 5490 required. */ 5491 if (fallback == fb_lvalue) 5492 { 5493 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p); 5494 lang_hooks.mark_addressable (*expr_p); 5495 } 5496 break; 5497 5498 case CALL_EXPR: 5499 ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none); 5500 /* C99 code may assign to an array in a structure returned 5501 from a function, and this has undefined behavior only on 5502 execution, so create a temporary if an lvalue is 5503 required. */ 5504 if (fallback == fb_lvalue) 5505 { 5506 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p); 5507 lang_hooks.mark_addressable (*expr_p); 5508 } 5509 break; 5510 5511 case TREE_LIST: 5512 gcc_unreachable (); 5513 5514 case COMPOUND_EXPR: 5515 ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none); 5516 break; 5517 5518 case MODIFY_EXPR: 5519 case INIT_EXPR: 5520 ret = gimplify_modify_expr (expr_p, pre_p, post_p, 5521 fallback != fb_none); 5522 5523 /* The distinction between MODIFY_EXPR and INIT_EXPR is no longer 5524 useful. */ 5525 if (*expr_p && TREE_CODE (*expr_p) == INIT_EXPR) 5526 TREE_SET_CODE (*expr_p, MODIFY_EXPR); 5527 break; 5528 5529 case TRUTH_ANDIF_EXPR: 5530 case TRUTH_ORIF_EXPR: 5531 ret = gimplify_boolean_expr (expr_p); 5532 break; 5533 5534 case TRUTH_NOT_EXPR: 5535 TREE_OPERAND (*expr_p, 0) 5536 = gimple_boolify (TREE_OPERAND (*expr_p, 0)); 5537 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, 5538 is_gimple_val, fb_rvalue); 5539 recalculate_side_effects (*expr_p); 5540 break; 5541 5542 case ADDR_EXPR: 5543 ret = gimplify_addr_expr (expr_p, pre_p, post_p); 5544 break; 5545 5546 case VA_ARG_EXPR: 5547 ret = gimplify_va_arg_expr (expr_p, pre_p, post_p); 5548 break; 5549 5550 case CONVERT_EXPR: 5551 case NOP_EXPR: 5552 if (IS_EMPTY_STMT (*expr_p)) 5553 { 5554 ret = GS_ALL_DONE; 5555 break; 5556 } 5557 5558 if (VOID_TYPE_P (TREE_TYPE (*expr_p)) 5559 || fallback == fb_none) 5560 { 5561 /* Just strip a conversion to void (or in void context) and 5562 try again. */ 5563 *expr_p = TREE_OPERAND (*expr_p, 0); 5564 break; 5565 } 5566 5567 ret = gimplify_conversion (expr_p); 5568 if (ret == GS_ERROR) 5569 break; 5570 if (*expr_p != save_expr) 5571 break; 5572 /* FALLTHRU */ 5573 5574 case FIX_TRUNC_EXPR: 5575 case FIX_CEIL_EXPR: 5576 case FIX_FLOOR_EXPR: 5577 case FIX_ROUND_EXPR: 5578 /* unary_expr: ... | '(' cast ')' val | ... */ 5579 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, 5580 is_gimple_val, fb_rvalue); 5581 recalculate_side_effects (*expr_p); 5582 break; 5583 5584 case INDIRECT_REF: 5585 *expr_p = fold_indirect_ref (*expr_p); 5586 if (*expr_p != save_expr) 5587 break; 5588 /* else fall through. */ 5589 case ALIGN_INDIRECT_REF: 5590 case MISALIGNED_INDIRECT_REF: 5591 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, 5592 is_gimple_reg, fb_rvalue); 5593 recalculate_side_effects (*expr_p); 5594 break; 5595 5596 /* Constants need not be gimplified. */ 5597 case INTEGER_CST: 5598 case REAL_CST: 5599 case STRING_CST: 5600 case COMPLEX_CST: 5601 case VECTOR_CST: 5602 ret = GS_ALL_DONE; 5603 break; 5604 5605 case CONST_DECL: 5606 /* If we require an lvalue, such as for ADDR_EXPR, retain the 5607 CONST_DECL node. Otherwise the decl is replaceable by its 5608 value. */ 5609 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */ 5610 if (fallback & fb_lvalue) 5611 ret = GS_ALL_DONE; 5612 else 5613 *expr_p = DECL_INITIAL (*expr_p); 5614 break; 5615 5616 case DECL_EXPR: 5617 ret = gimplify_decl_expr (expr_p); 5618 break; 5619 5620 case EXC_PTR_EXPR: 5621 /* FIXME make this a decl. */ 5622 ret = GS_ALL_DONE; 5623 break; 5624 5625 case BIND_EXPR: 5626 ret = gimplify_bind_expr (expr_p, pre_p); 5627 break; 5628 5629 case LOOP_EXPR: 5630 ret = gimplify_loop_expr (expr_p, pre_p); 5631 break; 5632 5633 case SWITCH_EXPR: 5634 ret = gimplify_switch_expr (expr_p, pre_p); 5635 break; 5636 5637 case EXIT_EXPR: 5638 ret = gimplify_exit_expr (expr_p); 5639 break; 5640 5641 case GOTO_EXPR: 5642 /* If the target is not LABEL, then it is a computed jump 5643 and the target needs to be gimplified. */ 5644 if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL) 5645 ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p, 5646 NULL, is_gimple_val, fb_rvalue); 5647 break; 5648 5649 case LABEL_EXPR: 5650 ret = GS_ALL_DONE; 5651 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p)) 5652 == current_function_decl); 5653 break; 5654 5655 case CASE_LABEL_EXPR: 5656 ret = gimplify_case_label_expr (expr_p); 5657 break; 5658 5659 case RETURN_EXPR: 5660 ret = gimplify_return_expr (*expr_p, pre_p); 5661 break; 5662 5663 case CONSTRUCTOR: 5664 /* Don't reduce this in place; let gimplify_init_constructor work its 5665 magic. Buf if we're just elaborating this for side effects, just 5666 gimplify any element that has side-effects. */ 5667 if (fallback == fb_none) 5668 { 5669 unsigned HOST_WIDE_INT ix; 5670 constructor_elt *ce; 5671 tree temp = NULL_TREE; 5672 for (ix = 0; 5673 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (*expr_p), 5674 ix, ce); 5675 ix++) 5676 if (TREE_SIDE_EFFECTS (ce->value)) 5677 append_to_statement_list (ce->value, &temp); 5678 5679 *expr_p = temp; 5680 ret = GS_OK; 5681 } 5682 /* C99 code may assign to an array in a constructed 5683 structure or union, and this has undefined behavior only 5684 on execution, so create a temporary if an lvalue is 5685 required. */ 5686 else if (fallback == fb_lvalue) 5687 { 5688 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p); 5689 lang_hooks.mark_addressable (*expr_p); 5690 } 5691 else 5692 ret = GS_ALL_DONE; 5693 break; 5694 5695 /* The following are special cases that are not handled by the 5696 original GIMPLE grammar. */ 5697 5698 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and 5699 eliminated. */ 5700 case SAVE_EXPR: 5701 ret = gimplify_save_expr (expr_p, pre_p, post_p); 5702 break; 5703 5704 case BIT_FIELD_REF: 5705 { 5706 enum gimplify_status r0, r1, r2; 5707 5708 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, 5709 is_gimple_lvalue, fb_either); 5710 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p, 5711 is_gimple_val, fb_rvalue); 5712 r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p, post_p, 5713 is_gimple_val, fb_rvalue); 5714 recalculate_side_effects (*expr_p); 5715 5716 ret = MIN (r0, MIN (r1, r2)); 5717 } 5718 break; 5719 5720 case NON_LVALUE_EXPR: 5721 /* This should have been stripped above. */ 5722 gcc_unreachable (); 5723 5724 case ASM_EXPR: 5725 ret = gimplify_asm_expr (expr_p, pre_p, post_p); 5726 break; 5727 5728 case TRY_FINALLY_EXPR: 5729 case TRY_CATCH_EXPR: 5730 gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 0)); 5731 gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 1)); 5732 ret = GS_ALL_DONE; 5733 break; 5734 5735 case CLEANUP_POINT_EXPR: 5736 ret = gimplify_cleanup_point_expr (expr_p, pre_p); 5737 break; 5738 5739 case TARGET_EXPR: 5740 ret = gimplify_target_expr (expr_p, pre_p, post_p); 5741 break; 5742 5743 case CATCH_EXPR: 5744 gimplify_to_stmt_list (&CATCH_BODY (*expr_p)); 5745 ret = GS_ALL_DONE; 5746 break; 5747 5748 case EH_FILTER_EXPR: 5749 gimplify_to_stmt_list (&EH_FILTER_FAILURE (*expr_p)); 5750 ret = GS_ALL_DONE; 5751 break; 5752 5753 case OBJ_TYPE_REF: 5754 { 5755 enum gimplify_status r0, r1; 5756 r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p, post_p, 5757 is_gimple_val, fb_rvalue); 5758 r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p, post_p, 5759 is_gimple_val, fb_rvalue); 5760 ret = MIN (r0, r1); 5761 } 5762 break; 5763 5764 case LABEL_DECL: 5765 /* We get here when taking the address of a label. We mark 5766 the label as "forced"; meaning it can never be removed and 5767 it is a potential target for any computed goto. */ 5768 FORCED_LABEL (*expr_p) = 1; 5769 ret = GS_ALL_DONE; 5770 break; 5771 5772 case STATEMENT_LIST: 5773 ret = gimplify_statement_list (expr_p, pre_p); 5774 break; 5775 5776 case WITH_SIZE_EXPR: 5777 { 5778 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, 5779 post_p == &internal_post ? NULL : post_p, 5780 gimple_test_f, fallback); 5781 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p, 5782 is_gimple_val, fb_rvalue); 5783 } 5784 break; 5785 5786 case VAR_DECL: 5787 case PARM_DECL: 5788 ret = gimplify_var_or_parm_decl (expr_p); 5789 break; 5790 5791 case RESULT_DECL: 5792 /* When within an OpenMP context, notice uses of variables. */ 5793 if (gimplify_omp_ctxp) 5794 omp_notice_variable (gimplify_omp_ctxp, *expr_p, true); 5795 ret = GS_ALL_DONE; 5796 break; 5797 5798 case SSA_NAME: 5799 /* Allow callbacks into the gimplifier during optimization. */ 5800 ret = GS_ALL_DONE; 5801 break; 5802 5803 case OMP_PARALLEL: 5804 ret = gimplify_omp_parallel (expr_p, pre_p); 5805 break; 5806 5807 case OMP_FOR: 5808 ret = gimplify_omp_for (expr_p, pre_p); 5809 break; 5810 5811 case OMP_SECTIONS: 5812 case OMP_SINGLE: 5813 ret = gimplify_omp_workshare (expr_p, pre_p); 5814 break; 5815 5816 case OMP_SECTION: 5817 case OMP_MASTER: 5818 case OMP_ORDERED: 5819 case OMP_CRITICAL: 5820 gimplify_to_stmt_list (&OMP_BODY (*expr_p)); 5821 break; 5822 5823 case OMP_ATOMIC: 5824 ret = gimplify_omp_atomic (expr_p, pre_p); 5825 break; 5826 5827 case OMP_RETURN: 5828 case OMP_CONTINUE: 5829 ret = GS_ALL_DONE; 5830 break; 5831 5832 default: 5833 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p))) 5834 { 5835 case tcc_comparison: 5836 /* Handle comparison of objects of non scalar mode aggregates 5837 with a call to memcmp. It would be nice to only have to do 5838 this for variable-sized objects, but then we'd have to allow 5839 the same nest of reference nodes we allow for MODIFY_EXPR and 5840 that's too complex. 5841 5842 Compare scalar mode aggregates as scalar mode values. Using 5843 memcmp for them would be very inefficient at best, and is 5844 plain wrong if bitfields are involved. */ 5845 5846 { 5847 tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 1)); 5848 5849 if (!AGGREGATE_TYPE_P (type)) 5850 goto expr_2; 5851 else if (TYPE_MODE (type) != BLKmode) 5852 ret = gimplify_scalar_mode_aggregate_compare (expr_p); 5853 else 5854 ret = gimplify_variable_sized_compare (expr_p); 5855 5856 break; 5857 } 5858 5859 /* If *EXPR_P does not need to be special-cased, handle it 5860 according to its class. */ 5861 case tcc_unary: 5862 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, 5863 post_p, is_gimple_val, fb_rvalue); 5864 break; 5865 5866 case tcc_binary: 5867 expr_2: 5868 { 5869 enum gimplify_status r0, r1; 5870 5871 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, 5872 post_p, is_gimple_val, fb_rvalue); 5873 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, 5874 post_p, is_gimple_val, fb_rvalue); 5875 5876 ret = MIN (r0, r1); 5877 break; 5878 } 5879 5880 case tcc_declaration: 5881 case tcc_constant: 5882 ret = GS_ALL_DONE; 5883 goto dont_recalculate; 5884 5885 default: 5886 gcc_assert (TREE_CODE (*expr_p) == TRUTH_AND_EXPR 5887 || TREE_CODE (*expr_p) == TRUTH_OR_EXPR 5888 || TREE_CODE (*expr_p) == TRUTH_XOR_EXPR); 5889 goto expr_2; 5890 } 5891 5892 recalculate_side_effects (*expr_p); 5893 dont_recalculate: 5894 break; 5895 } 5896 5897 /* If we replaced *expr_p, gimplify again. */ 5898 if (ret == GS_OK && (*expr_p == NULL || *expr_p == save_expr)) 5899 ret = GS_ALL_DONE; 5900 } 5901 while (ret == GS_OK); 5902 5903 /* If we encountered an error_mark somewhere nested inside, either 5904 stub out the statement or propagate the error back out. */ 5905 if (ret == GS_ERROR) 5906 { 5907 if (is_statement) 5908 *expr_p = NULL; 5909 goto out; 5910 } 5911 5912 /* This was only valid as a return value from the langhook, which 5913 we handled. Make sure it doesn't escape from any other context. */ 5914 gcc_assert (ret != GS_UNHANDLED); 5915 5916 if (fallback == fb_none && *expr_p && !is_gimple_stmt (*expr_p)) 5917 { 5918 /* We aren't looking for a value, and we don't have a valid 5919 statement. If it doesn't have side-effects, throw it away. */ 5920 if (!TREE_SIDE_EFFECTS (*expr_p)) 5921 *expr_p = NULL; 5922 else if (!TREE_THIS_VOLATILE (*expr_p)) 5923 { 5924 /* This is probably a _REF that contains something nested that 5925 has side effects. Recurse through the operands to find it. */ 5926 enum tree_code code = TREE_CODE (*expr_p); 5927 5928 switch (code) 5929 { 5930 case COMPONENT_REF: 5931 case REALPART_EXPR: 5932 case IMAGPART_EXPR: 5933 case VIEW_CONVERT_EXPR: 5934 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, 5935 gimple_test_f, fallback); 5936 break; 5937 5938 case ARRAY_REF: 5939 case ARRAY_RANGE_REF: 5940 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, 5941 gimple_test_f, fallback); 5942 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p, 5943 gimple_test_f, fallback); 5944 break; 5945 5946 default: 5947 /* Anything else with side-effects must be converted to 5948 a valid statement before we get here. */ 5949 gcc_unreachable (); 5950 } 5951 5952 *expr_p = NULL; 5953 } 5954 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p)) 5955 && TYPE_MODE (TREE_TYPE (*expr_p)) != BLKmode) 5956 { 5957 /* Historically, the compiler has treated a bare reference 5958 to a non-BLKmode volatile lvalue as forcing a load. */ 5959 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p)); 5960 /* Normally, we do not want to create a temporary for a 5961 TREE_ADDRESSABLE type because such a type should not be 5962 copied by bitwise-assignment. However, we make an 5963 exception here, as all we are doing here is ensuring that 5964 we read the bytes that make up the type. We use 5965 create_tmp_var_raw because create_tmp_var will abort when 5966 given a TREE_ADDRESSABLE type. */ 5967 tree tmp = create_tmp_var_raw (type, "vol"); 5968 gimple_add_tmp_var (tmp); 5969 *expr_p = build2 (MODIFY_EXPR, type, tmp, *expr_p); 5970 } 5971 else 5972 /* We can't do anything useful with a volatile reference to 5973 an incomplete type, so just throw it away. Likewise for 5974 a BLKmode type, since any implicit inner load should 5975 already have been turned into an explicit one by the 5976 gimplification process. */ 5977 *expr_p = NULL; 5978 } 5979 5980 /* If we are gimplifying at the statement level, we're done. Tack 5981 everything together and replace the original statement with the 5982 gimplified form. */ 5983 if (fallback == fb_none || is_statement) 5984 { 5985 if (internal_pre || internal_post) 5986 { 5987 append_to_statement_list (*expr_p, &internal_pre); 5988 append_to_statement_list (internal_post, &internal_pre); 5989 annotate_all_with_locus (&internal_pre, input_location); 5990 *expr_p = internal_pre; 5991 } 5992 else if (!*expr_p) 5993 ; 5994 else if (TREE_CODE (*expr_p) == STATEMENT_LIST) 5995 annotate_all_with_locus (expr_p, input_location); 5996 else 5997 annotate_one_with_locus (*expr_p, input_location); 5998 goto out; 5999 } 6000 6001 /* Otherwise we're gimplifying a subexpression, so the resulting value is 6002 interesting. */ 6003 6004 /* If it's sufficiently simple already, we're done. Unless we are 6005 handling some post-effects internally; if that's the case, we need to 6006 copy into a temp before adding the post-effects to the tree. */ 6007 if (!internal_post && (*gimple_test_f) (*expr_p)) 6008 goto out; 6009 6010 /* Otherwise, we need to create a new temporary for the gimplified 6011 expression. */ 6012 6013 /* We can't return an lvalue if we have an internal postqueue. The 6014 object the lvalue refers to would (probably) be modified by the 6015 postqueue; we need to copy the value out first, which means an 6016 rvalue. */ 6017 if ((fallback & fb_lvalue) && !internal_post 6018 && is_gimple_addressable (*expr_p)) 6019 { 6020 /* An lvalue will do. Take the address of the expression, store it 6021 in a temporary, and replace the expression with an INDIRECT_REF of 6022 that temporary. */ 6023 tmp = build_fold_addr_expr (*expr_p); 6024 gimplify_expr (&tmp, pre_p, post_p, is_gimple_reg, fb_rvalue); 6025 *expr_p = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (tmp)), tmp); 6026 } 6027 else if ((fallback & fb_rvalue) && is_gimple_formal_tmp_rhs (*expr_p)) 6028 { 6029 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p))); 6030 6031 /* An rvalue will do. Assign the gimplified expression into a new 6032 temporary TMP and replace the original expression with TMP. */ 6033 6034 if (internal_post || (fallback & fb_lvalue)) 6035 /* The postqueue might change the value of the expression between 6036 the initialization and use of the temporary, so we can't use a 6037 formal temp. FIXME do we care? */ 6038 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p); 6039 else 6040 *expr_p = get_formal_tmp_var (*expr_p, pre_p); 6041 6042 if (TREE_CODE (*expr_p) != SSA_NAME) 6043 DECL_GIMPLE_FORMAL_TEMP_P (*expr_p) = 1; 6044 } 6045 else 6046 { 6047#ifdef ENABLE_CHECKING 6048 if (!(fallback & fb_mayfail)) 6049 { 6050 fprintf (stderr, "gimplification failed:\n"); 6051 print_generic_expr (stderr, *expr_p, 0); 6052 debug_tree (*expr_p); 6053 internal_error ("gimplification failed"); 6054 } 6055#endif 6056 gcc_assert (fallback & fb_mayfail); 6057 /* If this is an asm statement, and the user asked for the 6058 impossible, don't die. Fail and let gimplify_asm_expr 6059 issue an error. */ 6060 ret = GS_ERROR; 6061 goto out; 6062 } 6063 6064 /* Make sure the temporary matches our predicate. */ 6065 gcc_assert ((*gimple_test_f) (*expr_p)); 6066 6067 if (internal_post) 6068 { 6069 annotate_all_with_locus (&internal_post, input_location); 6070 append_to_statement_list (internal_post, pre_p); 6071 } 6072 6073 out: 6074 input_location = saved_location; 6075 return ret; 6076} 6077 6078/* Look through TYPE for variable-sized objects and gimplify each such 6079 size that we find. Add to LIST_P any statements generated. */ 6080 6081void 6082gimplify_type_sizes (tree type, tree *list_p) 6083{ 6084 tree field, t; 6085 6086 if (type == NULL || type == error_mark_node) 6087 return; 6088 6089 /* We first do the main variant, then copy into any other variants. */ 6090 type = TYPE_MAIN_VARIANT (type); 6091 6092 /* Avoid infinite recursion. */ 6093 if (TYPE_SIZES_GIMPLIFIED (type)) 6094 return; 6095 6096 TYPE_SIZES_GIMPLIFIED (type) = 1; 6097 6098 switch (TREE_CODE (type)) 6099 { 6100 case INTEGER_TYPE: 6101 case ENUMERAL_TYPE: 6102 case BOOLEAN_TYPE: 6103 case REAL_TYPE: 6104 gimplify_one_sizepos (&TYPE_MIN_VALUE (type), list_p); 6105 gimplify_one_sizepos (&TYPE_MAX_VALUE (type), list_p); 6106 6107 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t)) 6108 { 6109 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (type); 6110 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (type); 6111 } 6112 break; 6113 6114 case ARRAY_TYPE: 6115 /* These types may not have declarations, so handle them here. */ 6116 gimplify_type_sizes (TREE_TYPE (type), list_p); 6117 gimplify_type_sizes (TYPE_DOMAIN (type), list_p); 6118 break; 6119 6120 case RECORD_TYPE: 6121 case UNION_TYPE: 6122 case QUAL_UNION_TYPE: 6123 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 6124 if (TREE_CODE (field) == FIELD_DECL) 6125 { 6126 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p); 6127 gimplify_type_sizes (TREE_TYPE (field), list_p); 6128 } 6129 break; 6130 6131 case POINTER_TYPE: 6132 case REFERENCE_TYPE: 6133 /* We used to recurse on the pointed-to type here, which turned out to 6134 be incorrect because its definition might refer to variables not 6135 yet initialized at this point if a forward declaration is involved. 6136 6137 It was actually useful for anonymous pointed-to types to ensure 6138 that the sizes evaluation dominates every possible later use of the 6139 values. Restricting to such types here would be safe since there 6140 is no possible forward declaration around, but would introduce an 6141 undesirable middle-end semantic to anonymity. We then defer to 6142 front-ends the responsibility of ensuring that the sizes are 6143 evaluated both early and late enough, e.g. by attaching artificial 6144 type declarations to the tree. */ 6145 break; 6146 6147 default: 6148 break; 6149 } 6150 6151 gimplify_one_sizepos (&TYPE_SIZE (type), list_p); 6152 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type), list_p); 6153 6154 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t)) 6155 { 6156 TYPE_SIZE (t) = TYPE_SIZE (type); 6157 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (type); 6158 TYPE_SIZES_GIMPLIFIED (t) = 1; 6159 } 6160} 6161 6162/* A subroutine of gimplify_type_sizes to make sure that *EXPR_P, 6163 a size or position, has had all of its SAVE_EXPRs evaluated. 6164 We add any required statements to STMT_P. */ 6165 6166void 6167gimplify_one_sizepos (tree *expr_p, tree *stmt_p) 6168{ 6169 tree type, expr = *expr_p; 6170 6171 /* We don't do anything if the value isn't there, is constant, or contains 6172 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already 6173 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier 6174 will want to replace it with a new variable, but that will cause problems 6175 if this type is from outside the function. It's OK to have that here. */ 6176 if (expr == NULL_TREE || TREE_CONSTANT (expr) 6177 || TREE_CODE (expr) == VAR_DECL 6178 || CONTAINS_PLACEHOLDER_P (expr)) 6179 return; 6180 6181 type = TREE_TYPE (expr); 6182 *expr_p = unshare_expr (expr); 6183 6184 gimplify_expr (expr_p, stmt_p, NULL, is_gimple_val, fb_rvalue); 6185 expr = *expr_p; 6186 6187 /* Verify that we've an exact type match with the original expression. 6188 In particular, we do not wish to drop a "sizetype" in favour of a 6189 type of similar dimensions. We don't want to pollute the generic 6190 type-stripping code with this knowledge because it doesn't matter 6191 for the bulk of GENERIC/GIMPLE. It only matters that TYPE_SIZE_UNIT 6192 and friends retain their "sizetype-ness". */ 6193 if (TREE_TYPE (expr) != type 6194 && TREE_CODE (type) == INTEGER_TYPE 6195 && TYPE_IS_SIZETYPE (type)) 6196 { 6197 tree tmp; 6198 6199 *expr_p = create_tmp_var (type, NULL); 6200 tmp = build1 (NOP_EXPR, type, expr); 6201 tmp = build2 (MODIFY_EXPR, type, *expr_p, tmp); 6202 if (EXPR_HAS_LOCATION (expr)) 6203 SET_EXPR_LOCUS (tmp, EXPR_LOCUS (expr)); 6204 else 6205 SET_EXPR_LOCATION (tmp, input_location); 6206 6207 gimplify_and_add (tmp, stmt_p); 6208 } 6209} 6210 6211#ifdef ENABLE_CHECKING 6212/* Compare types A and B for a "close enough" match. */ 6213 6214static bool 6215cpt_same_type (tree a, tree b) 6216{ 6217 if (lang_hooks.types_compatible_p (a, b)) 6218 return true; 6219 6220 /* ??? The C++ FE decomposes METHOD_TYPES to FUNCTION_TYPES and doesn't 6221 link them together. This routine is intended to catch type errors 6222 that will affect the optimizers, and the optimizers don't add new 6223 dereferences of function pointers, so ignore it. */ 6224 if ((TREE_CODE (a) == FUNCTION_TYPE || TREE_CODE (a) == METHOD_TYPE) 6225 && (TREE_CODE (b) == FUNCTION_TYPE || TREE_CODE (b) == METHOD_TYPE)) 6226 return true; 6227 6228 /* ??? The C FE pushes type qualifiers after the fact into the type of 6229 the element from the type of the array. See build_unary_op's handling 6230 of ADDR_EXPR. This seems wrong -- if we were going to do this, we 6231 should have done it when creating the variable in the first place. 6232 Alternately, why aren't the two array types made variants? */ 6233 if (TREE_CODE (a) == ARRAY_TYPE && TREE_CODE (b) == ARRAY_TYPE) 6234 return cpt_same_type (TREE_TYPE (a), TREE_TYPE (b)); 6235 6236 /* And because of those, we have to recurse down through pointers. */ 6237 if (POINTER_TYPE_P (a) && POINTER_TYPE_P (b)) 6238 return cpt_same_type (TREE_TYPE (a), TREE_TYPE (b)); 6239 6240 return false; 6241} 6242 6243/* Check for some cases of the front end missing cast expressions. 6244 The type of a dereference should correspond to the pointer type; 6245 similarly the type of an address should match its object. */ 6246 6247static tree 6248check_pointer_types_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, 6249 void *data ATTRIBUTE_UNUSED) 6250{ 6251 tree t = *tp; 6252 tree ptype, otype, dtype; 6253 6254 switch (TREE_CODE (t)) 6255 { 6256 case INDIRECT_REF: 6257 case ARRAY_REF: 6258 otype = TREE_TYPE (t); 6259 ptype = TREE_TYPE (TREE_OPERAND (t, 0)); 6260 dtype = TREE_TYPE (ptype); 6261 gcc_assert (cpt_same_type (otype, dtype)); 6262 break; 6263 6264 case ADDR_EXPR: 6265 ptype = TREE_TYPE (t); 6266 otype = TREE_TYPE (TREE_OPERAND (t, 0)); 6267 dtype = TREE_TYPE (ptype); 6268 if (!cpt_same_type (otype, dtype)) 6269 { 6270 /* &array is allowed to produce a pointer to the element, rather than 6271 a pointer to the array type. We must allow this in order to 6272 properly represent assigning the address of an array in C into 6273 pointer to the element type. */ 6274 gcc_assert (TREE_CODE (otype) == ARRAY_TYPE 6275 && POINTER_TYPE_P (ptype) 6276 && cpt_same_type (TREE_TYPE (otype), dtype)); 6277 break; 6278 } 6279 break; 6280 6281 default: 6282 return NULL_TREE; 6283 } 6284 6285 6286 return NULL_TREE; 6287} 6288#endif 6289 6290/* Gimplify the body of statements pointed to by BODY_P. FNDECL is the 6291 function decl containing BODY. */ 6292 6293void 6294gimplify_body (tree *body_p, tree fndecl, bool do_parms) 6295{ 6296 location_t saved_location = input_location; 6297 tree body, parm_stmts; 6298 6299 timevar_push (TV_TREE_GIMPLIFY); 6300 6301 gcc_assert (gimplify_ctxp == NULL); 6302 push_gimplify_context (); 6303 6304 /* Unshare most shared trees in the body and in that of any nested functions. 6305 It would seem we don't have to do this for nested functions because 6306 they are supposed to be output and then the outer function gimplified 6307 first, but the g++ front end doesn't always do it that way. */ 6308 unshare_body (body_p, fndecl); 6309 unvisit_body (body_p, fndecl); 6310 6311 /* Make sure input_location isn't set to something wierd. */ 6312 input_location = DECL_SOURCE_LOCATION (fndecl); 6313 6314 /* Resolve callee-copies. This has to be done before processing 6315 the body so that DECL_VALUE_EXPR gets processed correctly. */ 6316 parm_stmts = do_parms ? gimplify_parameters () : NULL; 6317 6318 /* Gimplify the function's body. */ 6319 gimplify_stmt (body_p); 6320 body = *body_p; 6321 6322 if (!body) 6323 body = alloc_stmt_list (); 6324 else if (TREE_CODE (body) == STATEMENT_LIST) 6325 { 6326 tree t = expr_only (*body_p); 6327 if (t) 6328 body = t; 6329 } 6330 6331 /* If there isn't an outer BIND_EXPR, add one. */ 6332 if (TREE_CODE (body) != BIND_EXPR) 6333 { 6334 tree b = build3 (BIND_EXPR, void_type_node, NULL_TREE, 6335 NULL_TREE, NULL_TREE); 6336 TREE_SIDE_EFFECTS (b) = 1; 6337 append_to_statement_list_force (body, &BIND_EXPR_BODY (b)); 6338 body = b; 6339 } 6340 6341 /* If we had callee-copies statements, insert them at the beginning 6342 of the function. */ 6343 if (parm_stmts) 6344 { 6345 append_to_statement_list_force (BIND_EXPR_BODY (body), &parm_stmts); 6346 BIND_EXPR_BODY (body) = parm_stmts; 6347 } 6348 6349 /* Unshare again, in case gimplification was sloppy. */ 6350 unshare_all_trees (body); 6351 6352 *body_p = body; 6353 6354 pop_gimplify_context (body); 6355 gcc_assert (gimplify_ctxp == NULL); 6356 6357#ifdef ENABLE_CHECKING 6358 walk_tree (body_p, check_pointer_types_r, NULL, NULL); 6359#endif 6360 6361 timevar_pop (TV_TREE_GIMPLIFY); 6362 input_location = saved_location; 6363} 6364 6365/* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL 6366 node for the function we want to gimplify. */ 6367 6368void 6369gimplify_function_tree (tree fndecl) 6370{ 6371 tree oldfn, parm, ret; 6372 6373 oldfn = current_function_decl; 6374 current_function_decl = fndecl; 6375 cfun = DECL_STRUCT_FUNCTION (fndecl); 6376 if (cfun == NULL) 6377 allocate_struct_function (fndecl); 6378 6379 for (parm = DECL_ARGUMENTS (fndecl); parm ; parm = TREE_CHAIN (parm)) 6380 { 6381 /* Preliminarily mark non-addressed complex variables as eligible 6382 for promotion to gimple registers. We'll transform their uses 6383 as we find them. */ 6384 if (TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE 6385 && !TREE_THIS_VOLATILE (parm) 6386 && !needs_to_live_in_memory (parm)) 6387 DECL_COMPLEX_GIMPLE_REG_P (parm) = 1; 6388 } 6389 6390 ret = DECL_RESULT (fndecl); 6391 if (TREE_CODE (TREE_TYPE (ret)) == COMPLEX_TYPE 6392 && !needs_to_live_in_memory (ret)) 6393 DECL_COMPLEX_GIMPLE_REG_P (ret) = 1; 6394 6395 gimplify_body (&DECL_SAVED_TREE (fndecl), fndecl, true); 6396 6397 /* If we're instrumenting function entry/exit, then prepend the call to 6398 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to 6399 catch the exit hook. */ 6400 /* ??? Add some way to ignore exceptions for this TFE. */ 6401 if (flag_instrument_function_entry_exit 6402 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl)) 6403 { 6404 tree tf, x, bind; 6405 6406 tf = build2 (TRY_FINALLY_EXPR, void_type_node, NULL, NULL); 6407 TREE_SIDE_EFFECTS (tf) = 1; 6408 x = DECL_SAVED_TREE (fndecl); 6409 append_to_statement_list (x, &TREE_OPERAND (tf, 0)); 6410 x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_EXIT]; 6411 x = build_function_call_expr (x, NULL); 6412 append_to_statement_list (x, &TREE_OPERAND (tf, 1)); 6413 6414 bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL); 6415 TREE_SIDE_EFFECTS (bind) = 1; 6416 x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_ENTER]; 6417 x = build_function_call_expr (x, NULL); 6418 append_to_statement_list (x, &BIND_EXPR_BODY (bind)); 6419 append_to_statement_list (tf, &BIND_EXPR_BODY (bind)); 6420 6421 DECL_SAVED_TREE (fndecl) = bind; 6422 } 6423 6424 current_function_decl = oldfn; 6425 cfun = oldfn ? DECL_STRUCT_FUNCTION (oldfn) : NULL; 6426} 6427 6428 6429/* Expands EXPR to list of gimple statements STMTS. If SIMPLE is true, 6430 force the result to be either ssa_name or an invariant, otherwise 6431 just force it to be a rhs expression. If VAR is not NULL, make the 6432 base variable of the final destination be VAR if suitable. */ 6433 6434tree 6435force_gimple_operand (tree expr, tree *stmts, bool simple, tree var) 6436{ 6437 tree t; 6438 enum gimplify_status ret; 6439 gimple_predicate gimple_test_f; 6440 6441 *stmts = NULL_TREE; 6442 6443 if (is_gimple_val (expr)) 6444 return expr; 6445 6446 gimple_test_f = simple ? is_gimple_val : is_gimple_reg_rhs; 6447 6448 push_gimplify_context (); 6449 gimplify_ctxp->into_ssa = in_ssa_p; 6450 6451 if (var) 6452 expr = build2 (MODIFY_EXPR, TREE_TYPE (var), var, expr); 6453 6454 ret = gimplify_expr (&expr, stmts, NULL, 6455 gimple_test_f, fb_rvalue); 6456 gcc_assert (ret != GS_ERROR); 6457 6458 if (referenced_vars) 6459 { 6460 for (t = gimplify_ctxp->temps; t ; t = TREE_CHAIN (t)) 6461 add_referenced_var (t); 6462 } 6463 6464 pop_gimplify_context (NULL); 6465 6466 return expr; 6467} 6468 6469/* Invokes force_gimple_operand for EXPR with parameters SIMPLE_P and VAR. If 6470 some statements are produced, emits them before BSI. */ 6471 6472tree 6473force_gimple_operand_bsi (block_stmt_iterator *bsi, tree expr, 6474 bool simple_p, tree var) 6475{ 6476 tree stmts; 6477 6478 expr = force_gimple_operand (expr, &stmts, simple_p, var); 6479 if (stmts) 6480 bsi_insert_before (bsi, stmts, BSI_SAME_STMT); 6481 6482 return expr; 6483} 6484 6485#include "gt-gimplify.h" 6486