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 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 50static struct gimplify_ctx 51{ 52 tree current_bind_expr; 53 tree temps; 54 tree conditional_cleanups; 55 tree exit_label; 56 tree return_temp; 57 VEC(tree,heap) *case_labels; 58 /* The formal temporary table. Should this be persistent? */ 59 htab_t temp_htab; 60 int conditions; 61 bool save_stack; 62 bool into_ssa; 63} *gimplify_ctxp; 64 65 66/* Formal (expression) temporary table handling: Multiple occurrences of 67 the same scalar expression are evaluated into the same temporary. */ 68 69typedef struct gimple_temp_hash_elt 70{ 71 tree val; /* Key */ 72 tree temp; /* Value */ 73} elt_t; 74 75/* Forward declarations. */ 76static enum gimplify_status gimplify_compound_expr (tree *, tree *, bool); 77#ifdef ENABLE_CHECKING 78static bool cpt_same_type (tree a, tree b); 79#endif 80 81 82/* Return a hash value for a formal temporary table entry. */ 83 84static hashval_t 85gimple_tree_hash (const void *p) 86{ 87 tree t = ((const elt_t *) p)->val; 88 return iterative_hash_expr (t, 0); 89} 90 91/* Compare two formal temporary table entries. */ 92 93static int 94gimple_tree_eq (const void *p1, const void *p2) 95{ 96 tree t1 = ((const elt_t *) p1)->val; 97 tree t2 = ((const elt_t *) p2)->val; 98 enum tree_code code = TREE_CODE (t1); 99 100 if (TREE_CODE (t2) != code 101 || TREE_TYPE (t1) != TREE_TYPE (t2)) 102 return 0; 103 104 if (!operand_equal_p (t1, t2, 0)) 105 return 0; 106 107 /* Only allow them to compare equal if they also hash equal; otherwise 108 results are nondeterminate, and we fail bootstrap comparison. */ 109 gcc_assert (gimple_tree_hash (p1) == gimple_tree_hash (p2)); 110 111 return 1; 112} 113 114/* Set up a context for the gimplifier. */ 115 116void 117push_gimplify_context (void) 118{ 119 gcc_assert (!gimplify_ctxp); 120 gimplify_ctxp 121 = (struct gimplify_ctx *) xcalloc (1, sizeof (struct gimplify_ctx)); 122 if (optimize) 123 gimplify_ctxp->temp_htab 124 = htab_create (1000, gimple_tree_hash, gimple_tree_eq, free); 125 else 126 gimplify_ctxp->temp_htab = NULL; 127} 128 129/* Tear down a context for the gimplifier. If BODY is non-null, then 130 put the temporaries into the outer BIND_EXPR. Otherwise, put them 131 in the unexpanded_var_list. */ 132 133void 134pop_gimplify_context (tree body) 135{ 136 tree t; 137 138 gcc_assert (gimplify_ctxp && !gimplify_ctxp->current_bind_expr); 139 140 for (t = gimplify_ctxp->temps; t ; t = TREE_CHAIN (t)) 141 DECL_GIMPLE_FORMAL_TEMP_P (t) = 0; 142 143 if (body) 144 declare_tmp_vars (gimplify_ctxp->temps, body); 145 else 146 record_vars (gimplify_ctxp->temps); 147 148#if 0 149 if (!quiet_flag && optimize) 150 fprintf (stderr, " collisions: %f ", 151 htab_collisions (gimplify_ctxp->temp_htab)); 152#endif 153 154 if (optimize) 155 htab_delete (gimplify_ctxp->temp_htab); 156 free (gimplify_ctxp); 157 gimplify_ctxp = NULL; 158} 159 160static void 161gimple_push_bind_expr (tree bind) 162{ 163 TREE_CHAIN (bind) = gimplify_ctxp->current_bind_expr; 164 gimplify_ctxp->current_bind_expr = bind; 165} 166 167static void 168gimple_pop_bind_expr (void) 169{ 170 gimplify_ctxp->current_bind_expr 171 = TREE_CHAIN (gimplify_ctxp->current_bind_expr); 172} 173 174tree 175gimple_current_bind_expr (void) 176{ 177 return gimplify_ctxp->current_bind_expr; 178} 179 180/* Returns true iff there is a COND_EXPR between us and the innermost 181 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */ 182 183static bool 184gimple_conditional_context (void) 185{ 186 return gimplify_ctxp->conditions > 0; 187} 188 189/* Note that we've entered a COND_EXPR. */ 190 191static void 192gimple_push_condition (void) 193{ 194#ifdef ENABLE_CHECKING 195 if (gimplify_ctxp->conditions == 0) 196 gcc_assert (!gimplify_ctxp->conditional_cleanups); 197#endif 198 ++(gimplify_ctxp->conditions); 199} 200 201/* Note that we've left a COND_EXPR. If we're back at unconditional scope 202 now, add any conditional cleanups we've seen to the prequeue. */ 203 204static void 205gimple_pop_condition (tree *pre_p) 206{ 207 int conds = --(gimplify_ctxp->conditions); 208 209 gcc_assert (conds >= 0); 210 if (conds == 0) 211 { 212 append_to_statement_list (gimplify_ctxp->conditional_cleanups, pre_p); 213 gimplify_ctxp->conditional_cleanups = NULL_TREE; 214 } 215} 216 217/* A subroutine of append_to_statement_list{,_force}. T is not NULL. */ 218 219static void 220append_to_statement_list_1 (tree t, tree *list_p) 221{ 222 tree list = *list_p; 223 tree_stmt_iterator i; 224 225 if (!list) 226 { 227 if (t && TREE_CODE (t) == STATEMENT_LIST) 228 { 229 *list_p = t; 230 return; 231 } 232 *list_p = list = alloc_stmt_list (); 233 } 234 235 i = tsi_last (list); 236 tsi_link_after (&i, t, TSI_CONTINUE_LINKING); 237} 238 239/* Add T to the end of the list container pointed to by LIST_P. 240 If T is an expression with no effects, it is ignored. */ 241 242void 243append_to_statement_list (tree t, tree *list_p) 244{ 245 if (t && TREE_SIDE_EFFECTS (t)) 246 append_to_statement_list_1 (t, list_p); 247} 248 249/* Similar, but the statement is always added, regardless of side effects. */ 250 251void 252append_to_statement_list_force (tree t, tree *list_p) 253{ 254 if (t != NULL_TREE) 255 append_to_statement_list_1 (t, list_p); 256} 257 258/* Both gimplify the statement T and append it to LIST_P. */ 259 260void 261gimplify_and_add (tree t, tree *list_p) 262{ 263 gimplify_stmt (&t); 264 append_to_statement_list (t, list_p); 265} 266 267/* Strip off a legitimate source ending from the input string NAME of 268 length LEN. Rather than having to know the names used by all of 269 our front ends, we strip off an ending of a period followed by 270 up to five characters. (Java uses ".class".) */ 271 272static inline void 273remove_suffix (char *name, int len) 274{ 275 int i; 276 277 for (i = 2; i < 8 && len > i; i++) 278 { 279 if (name[len - i] == '.') 280 { 281 name[len - i] = '\0'; 282 break; 283 } 284 } 285} 286 287/* Create a nameless artificial label and put it in the current function 288 context. Returns the newly created label. */ 289 290tree 291create_artificial_label (void) 292{ 293 tree lab = build_decl (LABEL_DECL, NULL_TREE, void_type_node); 294 295 DECL_ARTIFICIAL (lab) = 1; 296 DECL_IGNORED_P (lab) = 1; 297 DECL_CONTEXT (lab) = current_function_decl; 298 return lab; 299} 300 301/* Subroutine for find_single_pointer_decl. */ 302 303static tree 304find_single_pointer_decl_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, 305 void *data) 306{ 307 tree *pdecl = (tree *) data; 308 309 if (DECL_P (*tp) && POINTER_TYPE_P (TREE_TYPE (*tp))) 310 { 311 if (*pdecl) 312 { 313 /* We already found a pointer decl; return anything other 314 than NULL_TREE to unwind from walk_tree signalling that 315 we have a duplicate. */ 316 return *tp; 317 } 318 *pdecl = *tp; 319 } 320 321 return NULL_TREE; 322} 323 324/* Find the single DECL of pointer type in the tree T and return it. 325 If there are zero or more than one such DECLs, return NULL. */ 326 327static tree 328find_single_pointer_decl (tree t) 329{ 330 tree decl = NULL_TREE; 331 332 if (walk_tree (&t, find_single_pointer_decl_1, &decl, NULL)) 333 { 334 /* find_single_pointer_decl_1 returns a non-zero value, causing 335 walk_tree to return a non-zero value, to indicate that it 336 found more than one pointer DECL. */ 337 return NULL_TREE; 338 } 339 340 return decl; 341} 342 343/* Create a new temporary name with PREFIX. Returns an identifier. */ 344 345static GTY(()) unsigned int tmp_var_id_num; 346 347tree 348create_tmp_var_name (const char *prefix) 349{ 350 char *tmp_name; 351 352 if (prefix) 353 { 354 char *preftmp = ASTRDUP (prefix); 355 356 remove_suffix (preftmp, strlen (preftmp)); 357 prefix = preftmp; 358 } 359 360 ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++); 361 return get_identifier (tmp_name); 362} 363 364 365/* Create a new temporary variable declaration of type TYPE. 366 Does NOT push it into the current binding. */ 367 368tree 369create_tmp_var_raw (tree type, const char *prefix) 370{ 371 tree tmp_var; 372 tree new_type; 373 374 /* Make the type of the variable writable. */ 375 new_type = build_type_variant (type, 0, 0); 376 TYPE_ATTRIBUTES (new_type) = TYPE_ATTRIBUTES (type); 377 378 tmp_var = build_decl (VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL, 379 type); 380 381 /* The variable was declared by the compiler. */ 382 DECL_ARTIFICIAL (tmp_var) = 1; 383 /* And we don't want debug info for it. */ 384 DECL_IGNORED_P (tmp_var) = 1; 385 386 /* Make the variable writable. */ 387 TREE_READONLY (tmp_var) = 0; 388 389 DECL_EXTERNAL (tmp_var) = 0; 390 TREE_STATIC (tmp_var) = 0; 391 TREE_USED (tmp_var) = 1; 392 393 return tmp_var; 394} 395 396/* Create a new temporary variable declaration of type TYPE. DOES push the 397 variable into the current binding. Further, assume that this is called 398 only from gimplification or optimization, at which point the creation of 399 certain types are bugs. */ 400 401tree 402create_tmp_var (tree type, const char *prefix) 403{ 404 tree tmp_var; 405 406 /* We don't allow types that are addressable (meaning we can't make copies), 407 incomplete, or of variable size. */ 408 gcc_assert (!TREE_ADDRESSABLE (type) 409 && COMPLETE_TYPE_P (type) 410 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST); 411 412 tmp_var = create_tmp_var_raw (type, prefix); 413 gimple_add_tmp_var (tmp_var); 414 return tmp_var; 415} 416 417/* Given a tree, try to return a useful variable name that we can use 418 to prefix a temporary that is being assigned the value of the tree. 419 I.E. given <temp> = &A, return A. */ 420 421const char * 422get_name (tree t) 423{ 424 tree stripped_decl; 425 426 stripped_decl = t; 427 STRIP_NOPS (stripped_decl); 428 if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl)) 429 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl)); 430 else 431 { 432 switch (TREE_CODE (stripped_decl)) 433 { 434 case ADDR_EXPR: 435 return get_name (TREE_OPERAND (stripped_decl, 0)); 436 break; 437 default: 438 return NULL; 439 } 440 } 441} 442 443/* Create a temporary with a name derived from VAL. Subroutine of 444 lookup_tmp_var; nobody else should call this function. */ 445 446static inline tree 447create_tmp_from_val (tree val) 448{ 449 return create_tmp_var (TYPE_MAIN_VARIANT (TREE_TYPE (val)), get_name (val)); 450} 451 452/* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse 453 an existing expression temporary. */ 454 455static tree 456lookup_tmp_var (tree val, bool is_formal) 457{ 458 tree ret; 459 460 /* If not optimizing, never really reuse a temporary. local-alloc 461 won't allocate any variable that is used in more than one basic 462 block, which means it will go into memory, causing much extra 463 work in reload and final and poorer code generation, outweighing 464 the extra memory allocation here. */ 465 if (!optimize || !is_formal || TREE_SIDE_EFFECTS (val)) 466 ret = create_tmp_from_val (val); 467 else 468 { 469 elt_t elt, *elt_p; 470 void **slot; 471 472 elt.val = val; 473 slot = htab_find_slot (gimplify_ctxp->temp_htab, (void *)&elt, INSERT); 474 if (*slot == NULL) 475 { 476 elt_p = xmalloc (sizeof (*elt_p)); 477 elt_p->val = val; 478 elt_p->temp = ret = create_tmp_from_val (val); 479 *slot = (void *) elt_p; 480 } 481 else 482 { 483 elt_p = (elt_t *) *slot; 484 ret = elt_p->temp; 485 } 486 } 487 488 if (is_formal) 489 DECL_GIMPLE_FORMAL_TEMP_P (ret) = 1; 490 491 return ret; 492} 493 494/* Returns a formal temporary variable initialized with VAL. PRE_P is as 495 in gimplify_expr. Only use this function if: 496 497 1) The value of the unfactored expression represented by VAL will not 498 change between the initialization and use of the temporary, and 499 2) The temporary will not be otherwise modified. 500 501 For instance, #1 means that this is inappropriate for SAVE_EXPR temps, 502 and #2 means it is inappropriate for && temps. 503 504 For other cases, use get_initialized_tmp_var instead. */ 505 506static tree 507internal_get_tmp_var (tree val, tree *pre_p, tree *post_p, bool is_formal) 508{ 509 tree t, mod; 510 511 gimplify_expr (&val, pre_p, post_p, is_gimple_formal_tmp_rhs, fb_rvalue); 512 513 t = lookup_tmp_var (val, is_formal); 514 515 if (is_formal) 516 { 517 tree u = find_single_pointer_decl (val); 518 519 if (u && TREE_CODE (u) == VAR_DECL && DECL_BASED_ON_RESTRICT_P (u)) 520 u = DECL_GET_RESTRICT_BASE (u); 521 if (u && TYPE_RESTRICT (TREE_TYPE (u))) 522 { 523 if (DECL_BASED_ON_RESTRICT_P (t)) 524 gcc_assert (u == DECL_GET_RESTRICT_BASE (t)); 525 else 526 { 527 DECL_BASED_ON_RESTRICT_P (t) = 1; 528 SET_DECL_RESTRICT_BASE (t, u); 529 } 530 } 531 } 532 533 if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE) 534 DECL_COMPLEX_GIMPLE_REG_P (t) = 1; 535 536 mod = build2 (INIT_EXPR, TREE_TYPE (t), t, val); 537 538 if (EXPR_HAS_LOCATION (val)) 539 SET_EXPR_LOCUS (mod, EXPR_LOCUS (val)); 540 else 541 SET_EXPR_LOCATION (mod, input_location); 542 543 /* gimplify_modify_expr might want to reduce this further. */ 544 gimplify_and_add (mod, pre_p); 545 546 /* If we're gimplifying into ssa, gimplify_modify_expr will have 547 given our temporary an ssa name. Find and return it. */ 548 if (gimplify_ctxp->into_ssa) 549 t = TREE_OPERAND (mod, 0); 550 551 return t; 552} 553 554tree 555get_formal_tmp_var (tree val, tree *pre_p) 556{ 557 return internal_get_tmp_var (val, pre_p, NULL, true); 558} 559 560/* Returns a temporary variable initialized with VAL. PRE_P and POST_P 561 are as in gimplify_expr. */ 562 563tree 564get_initialized_tmp_var (tree val, tree *pre_p, tree *post_p) 565{ 566 return internal_get_tmp_var (val, pre_p, post_p, false); 567} 568 569/* Declares all the variables in VARS in SCOPE. */ 570 571void 572declare_tmp_vars (tree vars, tree scope) 573{ 574 tree last = vars; 575 if (last) 576 { 577 tree temps; 578 579 /* C99 mode puts the default 'return 0;' for main outside the outer 580 braces. So drill down until we find an actual scope. */ 581 while (TREE_CODE (scope) == COMPOUND_EXPR) 582 scope = TREE_OPERAND (scope, 0); 583 584 gcc_assert (TREE_CODE (scope) == BIND_EXPR); 585 586 temps = nreverse (last); 587 TREE_CHAIN (last) = BIND_EXPR_VARS (scope); 588 BIND_EXPR_VARS (scope) = temps; 589 } 590} 591 592void 593gimple_add_tmp_var (tree tmp) 594{ 595 gcc_assert (!TREE_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp)); 596 597 DECL_CONTEXT (tmp) = current_function_decl; 598 DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1; 599 600 if (gimplify_ctxp) 601 { 602 TREE_CHAIN (tmp) = gimplify_ctxp->temps; 603 gimplify_ctxp->temps = tmp; 604 } 605 else if (cfun) 606 record_vars (tmp); 607 else 608 declare_tmp_vars (tmp, DECL_SAVED_TREE (current_function_decl)); 609} 610 611/* Determines whether to assign a locus to the statement STMT. */ 612 613static bool 614should_carry_locus_p (tree stmt) 615{ 616 /* Don't emit a line note for a label. We particularly don't want to 617 emit one for the break label, since it doesn't actually correspond 618 to the beginning of the loop/switch. */ 619 if (TREE_CODE (stmt) == LABEL_EXPR) 620 return false; 621 622 /* Do not annotate empty statements, since it confuses gcov. */ 623 if (!TREE_SIDE_EFFECTS (stmt)) 624 return false; 625 626 return true; 627} 628 629static void 630annotate_one_with_locus (tree t, location_t locus) 631{ 632 if (EXPR_P (t) && ! EXPR_HAS_LOCATION (t) && should_carry_locus_p (t)) 633 SET_EXPR_LOCATION (t, locus); 634} 635 636void 637annotate_all_with_locus (tree *stmt_p, location_t locus) 638{ 639 tree_stmt_iterator i; 640 641 if (!*stmt_p) 642 return; 643 644 for (i = tsi_start (*stmt_p); !tsi_end_p (i); tsi_next (&i)) 645 { 646 tree t = tsi_stmt (i); 647 648 /* Assuming we've already been gimplified, we shouldn't 649 see nested chaining constructs anymore. */ 650 gcc_assert (TREE_CODE (t) != STATEMENT_LIST 651 && TREE_CODE (t) != COMPOUND_EXPR); 652 653 annotate_one_with_locus (t, locus); 654 } 655} 656 657/* Similar to copy_tree_r() but do not copy SAVE_EXPR or TARGET_EXPR nodes. 658 These nodes model computations that should only be done once. If we 659 were to unshare something like SAVE_EXPR(i++), the gimplification 660 process would create wrong code. */ 661 662static tree 663mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data) 664{ 665 enum tree_code code = TREE_CODE (*tp); 666 /* Don't unshare types, decls, constants and SAVE_EXPR nodes. */ 667 if (TREE_CODE_CLASS (code) == tcc_type 668 || TREE_CODE_CLASS (code) == tcc_declaration 669 || TREE_CODE_CLASS (code) == tcc_constant 670 || code == SAVE_EXPR || code == TARGET_EXPR 671 /* We can't do anything sensible with a BLOCK used as an expression, 672 but we also can't just die when we see it because of non-expression 673 uses. So just avert our eyes and cross our fingers. Silly Java. */ 674 || code == BLOCK) 675 *walk_subtrees = 0; 676 else 677 { 678 gcc_assert (code != BIND_EXPR); 679 copy_tree_r (tp, walk_subtrees, data); 680 } 681 682 return NULL_TREE; 683} 684 685/* Callback for walk_tree to unshare most of the shared trees rooted at 686 *TP. If *TP has been visited already (i.e., TREE_VISITED (*TP) == 1), 687 then *TP is deep copied by calling copy_tree_r. 688 689 This unshares the same trees as copy_tree_r with the exception of 690 SAVE_EXPR nodes. These nodes model computations that should only be 691 done once. If we were to unshare something like SAVE_EXPR(i++), the 692 gimplification process would create wrong code. */ 693 694static tree 695copy_if_shared_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, 696 void *data ATTRIBUTE_UNUSED) 697{ 698 tree t = *tp; 699 enum tree_code code = TREE_CODE (t); 700 701 /* Skip types, decls, and constants. But we do want to look at their 702 types and the bounds of types. Mark them as visited so we properly 703 unmark their subtrees on the unmark pass. If we've already seen them, 704 don't look down further. */ 705 if (TREE_CODE_CLASS (code) == tcc_type 706 || TREE_CODE_CLASS (code) == tcc_declaration 707 || TREE_CODE_CLASS (code) == tcc_constant) 708 { 709 if (TREE_VISITED (t)) 710 *walk_subtrees = 0; 711 else 712 TREE_VISITED (t) = 1; 713 } 714 715 /* If this node has been visited already, unshare it and don't look 716 any deeper. */ 717 else if (TREE_VISITED (t)) 718 { 719 walk_tree (tp, mostly_copy_tree_r, NULL, NULL); 720 *walk_subtrees = 0; 721 } 722 723 /* Otherwise, mark the tree as visited and keep looking. */ 724 else 725 TREE_VISITED (t) = 1; 726 727 return NULL_TREE; 728} 729 730static tree 731unmark_visited_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, 732 void *data ATTRIBUTE_UNUSED) 733{ 734 if (TREE_VISITED (*tp)) 735 TREE_VISITED (*tp) = 0; 736 else 737 *walk_subtrees = 0; 738 739 return NULL_TREE; 740} 741 742/* Unshare all the trees in BODY_P, a pointer into the body of FNDECL, and the 743 bodies of any nested functions if we are unsharing the entire body of 744 FNDECL. */ 745 746static void 747unshare_body (tree *body_p, tree fndecl) 748{ 749 struct cgraph_node *cgn = cgraph_node (fndecl); 750 751 walk_tree (body_p, copy_if_shared_r, NULL, NULL); 752 if (body_p == &DECL_SAVED_TREE (fndecl)) 753 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested) 754 unshare_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl); 755} 756 757/* Likewise, but mark all trees as not visited. */ 758 759static void 760unvisit_body (tree *body_p, tree fndecl) 761{ 762 struct cgraph_node *cgn = cgraph_node (fndecl); 763 764 walk_tree (body_p, unmark_visited_r, NULL, NULL); 765 if (body_p == &DECL_SAVED_TREE (fndecl)) 766 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested) 767 unvisit_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl); 768} 769 770/* Unshare T and all the trees reached from T via TREE_CHAIN. */ 771 772static void 773unshare_all_trees (tree t) 774{ 775 walk_tree (&t, copy_if_shared_r, NULL, NULL); 776 walk_tree (&t, unmark_visited_r, NULL, NULL); 777} 778 779/* Unconditionally make an unshared copy of EXPR. This is used when using 780 stored expressions which span multiple functions, such as BINFO_VTABLE, 781 as the normal unsharing process can't tell that they're shared. */ 782 783tree 784unshare_expr (tree expr) 785{ 786 walk_tree (&expr, mostly_copy_tree_r, NULL, NULL); 787 return expr; 788} 789 790/* A terser interface for building a representation of an exception 791 specification. */ 792 793tree 794gimple_build_eh_filter (tree body, tree allowed, tree failure) 795{ 796 tree t; 797 798 /* FIXME should the allowed types go in TREE_TYPE? */ 799 t = build (EH_FILTER_EXPR, void_type_node, allowed, NULL_TREE); 800 append_to_statement_list (failure, &EH_FILTER_FAILURE (t)); 801 802 t = build (TRY_CATCH_EXPR, void_type_node, NULL_TREE, t); 803 append_to_statement_list (body, &TREE_OPERAND (t, 0)); 804 805 return t; 806} 807 808 809/* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both 810 contain statements and have a value. Assign its value to a temporary 811 and give it void_type_node. Returns the temporary, or NULL_TREE if 812 WRAPPER was already void. */ 813 814tree 815voidify_wrapper_expr (tree wrapper, tree temp) 816{ 817 if (!VOID_TYPE_P (TREE_TYPE (wrapper))) 818 { 819 tree *p, sub = wrapper; 820 821 restart: 822 /* Set p to point to the body of the wrapper. */ 823 switch (TREE_CODE (sub)) 824 { 825 case BIND_EXPR: 826 /* For a BIND_EXPR, the body is operand 1. */ 827 p = &BIND_EXPR_BODY (sub); 828 break; 829 830 default: 831 p = &TREE_OPERAND (sub, 0); 832 break; 833 } 834 835 /* Advance to the last statement. Set all container types to void. */ 836 if (TREE_CODE (*p) == STATEMENT_LIST) 837 { 838 tree_stmt_iterator i = tsi_last (*p); 839 p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i); 840 } 841 else 842 { 843 for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1)) 844 { 845 TREE_SIDE_EFFECTS (*p) = 1; 846 TREE_TYPE (*p) = void_type_node; 847 } 848 } 849 850 if (p == NULL || IS_EMPTY_STMT (*p)) 851 ; 852 /* Look through exception handling. */ 853 else if (TREE_CODE (*p) == TRY_FINALLY_EXPR 854 || TREE_CODE (*p) == TRY_CATCH_EXPR) 855 { 856 sub = *p; 857 goto restart; 858 } 859 /* The C++ frontend already did this for us. */ 860 else if (TREE_CODE (*p) == INIT_EXPR 861 || TREE_CODE (*p) == TARGET_EXPR) 862 temp = TREE_OPERAND (*p, 0); 863 /* If we're returning a dereference, move the dereference 864 outside the wrapper. */ 865 else if (TREE_CODE (*p) == INDIRECT_REF) 866 { 867 tree ptr = TREE_OPERAND (*p, 0); 868 temp = create_tmp_var (TREE_TYPE (ptr), "retval"); 869 *p = build (MODIFY_EXPR, TREE_TYPE (ptr), temp, ptr); 870 temp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (temp)), temp); 871 /* If this is a BIND_EXPR for a const inline function, it might not 872 have TREE_SIDE_EFFECTS set. That is no longer accurate. */ 873 TREE_SIDE_EFFECTS (wrapper) = 1; 874 } 875 else 876 { 877 if (!temp) 878 temp = create_tmp_var (TREE_TYPE (wrapper), "retval"); 879 *p = build (MODIFY_EXPR, TREE_TYPE (temp), temp, *p); 880 TREE_SIDE_EFFECTS (wrapper) = 1; 881 } 882 883 TREE_TYPE (wrapper) = void_type_node; 884 return temp; 885 } 886 887 return NULL_TREE; 888} 889 890/* Prepare calls to builtins to SAVE and RESTORE the stack as well as 891 a temporary through which they communicate. */ 892 893static void 894build_stack_save_restore (tree *save, tree *restore) 895{ 896 tree save_call, tmp_var; 897 898 save_call = 899 build_function_call_expr (implicit_built_in_decls[BUILT_IN_STACK_SAVE], 900 NULL_TREE); 901 tmp_var = create_tmp_var (ptr_type_node, "saved_stack"); 902 903 *save = build (MODIFY_EXPR, ptr_type_node, tmp_var, save_call); 904 *restore = 905 build_function_call_expr (implicit_built_in_decls[BUILT_IN_STACK_RESTORE], 906 tree_cons (NULL_TREE, tmp_var, NULL_TREE)); 907} 908 909/* Gimplify a BIND_EXPR. Just voidify and recurse. */ 910 911static enum gimplify_status 912gimplify_bind_expr (tree *expr_p, tree temp, tree *pre_p) 913{ 914 tree bind_expr = *expr_p; 915 bool old_save_stack = gimplify_ctxp->save_stack; 916 tree t; 917 918 temp = voidify_wrapper_expr (bind_expr, temp); 919 920 /* Mark variables seen in this bind expr. */ 921 for (t = BIND_EXPR_VARS (bind_expr); t ; t = TREE_CHAIN (t)) 922 { 923 if (TREE_CODE (t) == VAR_DECL) 924 DECL_SEEN_IN_BIND_EXPR_P (t) = 1; 925 926 /* Preliminarily mark non-addressed complex variables as eligible 927 for promotion to gimple registers. We'll transform their uses 928 as we find them. */ 929 if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE 930 && !TREE_THIS_VOLATILE (t) 931 && (TREE_CODE (t) == VAR_DECL && !DECL_HARD_REGISTER (t)) 932 && !needs_to_live_in_memory (t)) 933 DECL_COMPLEX_GIMPLE_REG_P (t) = 1; 934 } 935 936 gimple_push_bind_expr (bind_expr); 937 gimplify_ctxp->save_stack = false; 938 939 gimplify_to_stmt_list (&BIND_EXPR_BODY (bind_expr)); 940 941 if (gimplify_ctxp->save_stack) 942 { 943 tree stack_save, stack_restore; 944 945 /* Save stack on entry and restore it on exit. Add a try_finally 946 block to achieve this. Note that mudflap depends on the 947 format of the emitted code: see mx_register_decls(). */ 948 build_stack_save_restore (&stack_save, &stack_restore); 949 950 t = build (TRY_FINALLY_EXPR, void_type_node, 951 BIND_EXPR_BODY (bind_expr), NULL_TREE); 952 append_to_statement_list (stack_restore, &TREE_OPERAND (t, 1)); 953 954 BIND_EXPR_BODY (bind_expr) = NULL_TREE; 955 append_to_statement_list (stack_save, &BIND_EXPR_BODY (bind_expr)); 956 append_to_statement_list (t, &BIND_EXPR_BODY (bind_expr)); 957 } 958 959 gimplify_ctxp->save_stack = old_save_stack; 960 gimple_pop_bind_expr (); 961 962 if (temp) 963 { 964 *expr_p = temp; 965 append_to_statement_list (bind_expr, pre_p); 966 return GS_OK; 967 } 968 else 969 return GS_ALL_DONE; 970} 971 972/* Gimplify a RETURN_EXPR. If the expression to be returned is not a 973 GIMPLE value, it is assigned to a new temporary and the statement is 974 re-written to return the temporary. 975 976 PRE_P points to the list where side effects that must happen before 977 STMT should be stored. */ 978 979static enum gimplify_status 980gimplify_return_expr (tree stmt, tree *pre_p) 981{ 982 tree ret_expr = TREE_OPERAND (stmt, 0); 983 tree result_decl, result; 984 985 if (!ret_expr || TREE_CODE (ret_expr) == RESULT_DECL 986 || ret_expr == error_mark_node) 987 return GS_ALL_DONE; 988 989 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))) 990 result_decl = NULL_TREE; 991 else 992 { 993 result_decl = TREE_OPERAND (ret_expr, 0); 994 if (TREE_CODE (result_decl) == INDIRECT_REF) 995 /* See through a return by reference. */ 996 result_decl = TREE_OPERAND (result_decl, 0); 997 998 gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR 999 || TREE_CODE (ret_expr) == INIT_EXPR) 1000 && TREE_CODE (result_decl) == RESULT_DECL); 1001 } 1002 1003 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL. 1004 Recall that aggregate_value_p is FALSE for any aggregate type that is 1005 returned in registers. If we're returning values in registers, then 1006 we don't want to extend the lifetime of the RESULT_DECL, particularly 1007 across another call. In addition, for those aggregates for which 1008 hard_function_value generates a PARALLEL, we'll die during normal 1009 expansion of structure assignments; there's special code in expand_return 1010 to handle this case that does not exist in expand_expr. */ 1011 if (!result_decl 1012 || aggregate_value_p (result_decl, TREE_TYPE (current_function_decl))) 1013 result = result_decl; 1014 else if (gimplify_ctxp->return_temp) 1015 result = gimplify_ctxp->return_temp; 1016 else 1017 { 1018 result = create_tmp_var (TREE_TYPE (result_decl), NULL); 1019 1020 /* ??? With complex control flow (usually involving abnormal edges), 1021 we can wind up warning about an uninitialized value for this. Due 1022 to how this variable is constructed and initialized, this is never 1023 true. Give up and never warn. */ 1024 TREE_NO_WARNING (result) = 1; 1025 1026 gimplify_ctxp->return_temp = result; 1027 } 1028 1029 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use. 1030 Then gimplify the whole thing. */ 1031 if (result != result_decl) 1032 TREE_OPERAND (ret_expr, 0) = result; 1033 1034 gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p); 1035 1036 /* If we didn't use a temporary, then the result is just the result_decl. 1037 Otherwise we need a simple copy. This should already be gimple. */ 1038 if (result == result_decl) 1039 ret_expr = result; 1040 else 1041 ret_expr = build (MODIFY_EXPR, TREE_TYPE (result), result_decl, result); 1042 TREE_OPERAND (stmt, 0) = ret_expr; 1043 1044 return GS_ALL_DONE; 1045} 1046 1047/* Gimplifies a DECL_EXPR node *STMT_P by making any necessary allocation 1048 and initialization explicit. */ 1049 1050static enum gimplify_status 1051gimplify_decl_expr (tree *stmt_p) 1052{ 1053 tree stmt = *stmt_p; 1054 tree decl = DECL_EXPR_DECL (stmt); 1055 1056 *stmt_p = NULL_TREE; 1057 1058 if (TREE_TYPE (decl) == error_mark_node) 1059 return GS_ERROR; 1060 1061 if ((TREE_CODE (decl) == TYPE_DECL 1062 || TREE_CODE (decl) == VAR_DECL) 1063 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl))) 1064 gimplify_type_sizes (TREE_TYPE (decl), stmt_p); 1065 1066 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl)) 1067 { 1068 tree init = DECL_INITIAL (decl); 1069 1070 if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST) 1071 { 1072 /* This is a variable-sized decl. Simplify its size and mark it 1073 for deferred expansion. Note that mudflap depends on the format 1074 of the emitted code: see mx_register_decls(). */ 1075 tree t, args, addr, ptr_type; 1076 1077 gimplify_one_sizepos (&DECL_SIZE (decl), stmt_p); 1078 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), stmt_p); 1079 1080 /* All occurrences of this decl in final gimplified code will be 1081 replaced by indirection. Setting DECL_VALUE_EXPR does two 1082 things: First, it lets the rest of the gimplifier know what 1083 replacement to use. Second, it lets the debug info know 1084 where to find the value. */ 1085 ptr_type = build_pointer_type (TREE_TYPE (decl)); 1086 addr = create_tmp_var (ptr_type, get_name (decl)); 1087 DECL_IGNORED_P (addr) = 0; 1088 t = build_fold_indirect_ref (addr); 1089 SET_DECL_VALUE_EXPR (decl, t); 1090 DECL_HAS_VALUE_EXPR_P (decl) = 1; 1091 1092 args = tree_cons (NULL, DECL_SIZE_UNIT (decl), NULL); 1093 t = built_in_decls[BUILT_IN_ALLOCA]; 1094 t = build_function_call_expr (t, args); 1095 t = fold_convert (ptr_type, t); 1096 t = build2 (MODIFY_EXPR, void_type_node, addr, t); 1097 1098 gimplify_and_add (t, stmt_p); 1099 1100 /* Indicate that we need to restore the stack level when the 1101 enclosing BIND_EXPR is exited. */ 1102 gimplify_ctxp->save_stack = true; 1103 } 1104 1105 if (init && init != error_mark_node) 1106 { 1107 if (!TREE_STATIC (decl)) 1108 { 1109 DECL_INITIAL (decl) = NULL_TREE; 1110 init = build2 (INIT_EXPR, void_type_node, decl, init); 1111 gimplify_and_add (init, stmt_p); 1112 } 1113 else 1114 /* We must still examine initializers for static variables 1115 as they may contain a label address. */ 1116 walk_tree (&init, force_labels_r, NULL, NULL); 1117 } 1118 1119 /* This decl isn't mentioned in the enclosing block, so add it to the 1120 list of temps. FIXME it seems a bit of a kludge to say that 1121 anonymous artificial vars aren't pushed, but everything else is. */ 1122 if (DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE) 1123 gimple_add_tmp_var (decl); 1124 } 1125 1126 return GS_ALL_DONE; 1127} 1128 1129/* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body 1130 and replacing the LOOP_EXPR with goto, but if the loop contains an 1131 EXIT_EXPR, we need to append a label for it to jump to. */ 1132 1133static enum gimplify_status 1134gimplify_loop_expr (tree *expr_p, tree *pre_p) 1135{ 1136 tree saved_label = gimplify_ctxp->exit_label; 1137 tree start_label = build1 (LABEL_EXPR, void_type_node, NULL_TREE); 1138 tree jump_stmt = build_and_jump (&LABEL_EXPR_LABEL (start_label)); 1139 1140 append_to_statement_list (start_label, pre_p); 1141 1142 gimplify_ctxp->exit_label = NULL_TREE; 1143 1144 gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p); 1145 1146 if (gimplify_ctxp->exit_label) 1147 { 1148 append_to_statement_list (jump_stmt, pre_p); 1149 *expr_p = build1 (LABEL_EXPR, void_type_node, gimplify_ctxp->exit_label); 1150 } 1151 else 1152 *expr_p = jump_stmt; 1153 1154 gimplify_ctxp->exit_label = saved_label; 1155 1156 return GS_ALL_DONE; 1157} 1158 1159/* Compare two case labels. Because the front end should already have 1160 made sure that case ranges do not overlap, it is enough to only compare 1161 the CASE_LOW values of each case label. */ 1162 1163static int 1164compare_case_labels (const void *p1, const void *p2) 1165{ 1166 tree case1 = *(tree *)p1; 1167 tree case2 = *(tree *)p2; 1168 1169 return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2)); 1170} 1171 1172/* Sort the case labels in LABEL_VEC in place in ascending order. */ 1173 1174void 1175sort_case_labels (tree label_vec) 1176{ 1177 size_t len = TREE_VEC_LENGTH (label_vec); 1178 tree default_case = TREE_VEC_ELT (label_vec, len - 1); 1179 1180 if (CASE_LOW (default_case)) 1181 { 1182 size_t i; 1183 1184 /* The last label in the vector should be the default case 1185 but it is not. */ 1186 for (i = 0; i < len; ++i) 1187 { 1188 tree t = TREE_VEC_ELT (label_vec, i); 1189 if (!CASE_LOW (t)) 1190 { 1191 default_case = t; 1192 TREE_VEC_ELT (label_vec, i) = TREE_VEC_ELT (label_vec, len - 1); 1193 TREE_VEC_ELT (label_vec, len - 1) = default_case; 1194 break; 1195 } 1196 } 1197 } 1198 1199 qsort (&TREE_VEC_ELT (label_vec, 0), len - 1, sizeof (tree), 1200 compare_case_labels); 1201} 1202 1203/* Gimplify a SWITCH_EXPR, and collect a TREE_VEC of the labels it can 1204 branch to. */ 1205 1206static enum gimplify_status 1207gimplify_switch_expr (tree *expr_p, tree *pre_p) 1208{ 1209 tree switch_expr = *expr_p; 1210 enum gimplify_status ret; 1211 1212 ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL, 1213 is_gimple_val, fb_rvalue); 1214 1215 if (SWITCH_BODY (switch_expr)) 1216 { 1217 VEC(tree,heap) *labels, *saved_labels; 1218 tree label_vec, default_case = NULL_TREE; 1219 size_t i, len; 1220 1221 /* If someone can be bothered to fill in the labels, they can 1222 be bothered to null out the body too. */ 1223 gcc_assert (!SWITCH_LABELS (switch_expr)); 1224 1225 saved_labels = gimplify_ctxp->case_labels; 1226 gimplify_ctxp->case_labels = VEC_alloc (tree, heap, 8); 1227 1228 gimplify_to_stmt_list (&SWITCH_BODY (switch_expr)); 1229 1230 labels = gimplify_ctxp->case_labels; 1231 gimplify_ctxp->case_labels = saved_labels; 1232 1233 len = VEC_length (tree, labels); 1234 1235 for (i = 0; i < len; ++i) 1236 { 1237 tree t = VEC_index (tree, labels, i); 1238 if (!CASE_LOW (t)) 1239 { 1240 /* The default case must be the last label in the list. */ 1241 default_case = t; 1242 VEC_replace (tree, labels, i, VEC_index (tree, labels, len - 1)); 1243 len--; 1244 break; 1245 } 1246 } 1247 1248 label_vec = make_tree_vec (len + 1); 1249 SWITCH_LABELS (*expr_p) = label_vec; 1250 append_to_statement_list (switch_expr, pre_p); 1251 1252 if (! default_case) 1253 { 1254 /* If the switch has no default label, add one, so that we jump 1255 around the switch body. */ 1256 default_case = build (CASE_LABEL_EXPR, void_type_node, NULL_TREE, 1257 NULL_TREE, create_artificial_label ()); 1258 append_to_statement_list (SWITCH_BODY (switch_expr), pre_p); 1259 *expr_p = build (LABEL_EXPR, void_type_node, 1260 CASE_LABEL (default_case)); 1261 } 1262 else 1263 *expr_p = SWITCH_BODY (switch_expr); 1264 1265 for (i = 0; i < len; ++i) 1266 TREE_VEC_ELT (label_vec, i) = VEC_index (tree, labels, i); 1267 TREE_VEC_ELT (label_vec, len) = default_case; 1268 1269 VEC_free (tree, heap, labels); 1270 1271 sort_case_labels (label_vec); 1272 1273 SWITCH_BODY (switch_expr) = NULL; 1274 } 1275 else 1276 gcc_assert (SWITCH_LABELS (switch_expr)); 1277 1278 return ret; 1279} 1280 1281static enum gimplify_status 1282gimplify_case_label_expr (tree *expr_p) 1283{ 1284 tree expr = *expr_p; 1285 1286 gcc_assert (gimplify_ctxp->case_labels); 1287 VEC_safe_push (tree, heap, gimplify_ctxp->case_labels, expr); 1288 *expr_p = build (LABEL_EXPR, void_type_node, CASE_LABEL (expr)); 1289 return GS_ALL_DONE; 1290} 1291 1292/* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first 1293 if necessary. */ 1294 1295tree 1296build_and_jump (tree *label_p) 1297{ 1298 if (label_p == NULL) 1299 /* If there's nowhere to jump, just fall through. */ 1300 return NULL_TREE; 1301 1302 if (*label_p == NULL_TREE) 1303 { 1304 tree label = create_artificial_label (); 1305 *label_p = label; 1306 } 1307 1308 return build1 (GOTO_EXPR, void_type_node, *label_p); 1309} 1310 1311/* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR. 1312 This also involves building a label to jump to and communicating it to 1313 gimplify_loop_expr through gimplify_ctxp->exit_label. */ 1314 1315static enum gimplify_status 1316gimplify_exit_expr (tree *expr_p) 1317{ 1318 tree cond = TREE_OPERAND (*expr_p, 0); 1319 tree expr; 1320 1321 expr = build_and_jump (&gimplify_ctxp->exit_label); 1322 expr = build (COND_EXPR, void_type_node, cond, expr, NULL_TREE); 1323 *expr_p = expr; 1324 1325 return GS_OK; 1326} 1327 1328/* A helper function to be called via walk_tree. Mark all labels under *TP 1329 as being forced. To be called for DECL_INITIAL of static variables. */ 1330 1331tree 1332force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) 1333{ 1334 if (TYPE_P (*tp)) 1335 *walk_subtrees = 0; 1336 if (TREE_CODE (*tp) == LABEL_DECL) 1337 FORCED_LABEL (*tp) = 1; 1338 1339 return NULL_TREE; 1340} 1341 1342/* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is 1343 different from its canonical type, wrap the whole thing inside a 1344 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical 1345 type. 1346 1347 The canonical type of a COMPONENT_REF is the type of the field being 1348 referenced--unless the field is a bit-field which can be read directly 1349 in a smaller mode, in which case the canonical type is the 1350 sign-appropriate type corresponding to that mode. */ 1351 1352static void 1353canonicalize_component_ref (tree *expr_p) 1354{ 1355 tree expr = *expr_p; 1356 tree type; 1357 1358 gcc_assert (TREE_CODE (expr) == COMPONENT_REF); 1359 1360 if (INTEGRAL_TYPE_P (TREE_TYPE (expr))) 1361 type = TREE_TYPE (get_unwidened (expr, NULL_TREE)); 1362 else 1363 type = TREE_TYPE (TREE_OPERAND (expr, 1)); 1364 1365 if (TREE_TYPE (expr) != type) 1366 { 1367 tree old_type = TREE_TYPE (expr); 1368 1369 /* Set the type of the COMPONENT_REF to the underlying type. */ 1370 TREE_TYPE (expr) = type; 1371 1372 /* And wrap the whole thing inside a NOP_EXPR. */ 1373 expr = build1 (NOP_EXPR, old_type, expr); 1374 1375 *expr_p = expr; 1376 } 1377} 1378 1379/* If a NOP conversion is changing a pointer to array of foo to a pointer 1380 to foo, embed that change in the ADDR_EXPR by converting 1381 T array[U]; 1382 (T *)&array 1383 ==> 1384 &array[L] 1385 where L is the lower bound. For simplicity, only do this for constant 1386 lower bound. */ 1387 1388static void 1389canonicalize_addr_expr (tree *expr_p) 1390{ 1391 tree expr = *expr_p; 1392 tree ctype = TREE_TYPE (expr); 1393 tree addr_expr = TREE_OPERAND (expr, 0); 1394 tree atype = TREE_TYPE (addr_expr); 1395 tree dctype, datype, ddatype, otype, obj_expr; 1396 1397 /* Both cast and addr_expr types should be pointers. */ 1398 if (!POINTER_TYPE_P (ctype) || !POINTER_TYPE_P (atype)) 1399 return; 1400 1401 /* The addr_expr type should be a pointer to an array. */ 1402 datype = TREE_TYPE (atype); 1403 if (TREE_CODE (datype) != ARRAY_TYPE) 1404 return; 1405 1406 /* Both cast and addr_expr types should address the same object type. */ 1407 dctype = TREE_TYPE (ctype); 1408 ddatype = TREE_TYPE (datype); 1409 if (!lang_hooks.types_compatible_p (ddatype, dctype)) 1410 return; 1411 1412 /* The addr_expr and the object type should match. */ 1413 obj_expr = TREE_OPERAND (addr_expr, 0); 1414 otype = TREE_TYPE (obj_expr); 1415 if (!lang_hooks.types_compatible_p (otype, datype)) 1416 return; 1417 1418 /* The lower bound and element sizes must be constant. */ 1419 if (!TYPE_SIZE_UNIT (dctype) 1420 || TREE_CODE (TYPE_SIZE_UNIT (dctype)) != INTEGER_CST 1421 || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype)) 1422 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST) 1423 return; 1424 1425 /* All checks succeeded. Build a new node to merge the cast. */ 1426 *expr_p = build4 (ARRAY_REF, dctype, obj_expr, 1427 TYPE_MIN_VALUE (TYPE_DOMAIN (datype)), 1428 TYPE_MIN_VALUE (TYPE_DOMAIN (datype)), 1429 size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (dctype), 1430 size_int (TYPE_ALIGN_UNIT (dctype)))); 1431 *expr_p = build1 (ADDR_EXPR, ctype, *expr_p); 1432} 1433 1434/* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions 1435 underneath as appropriate. */ 1436 1437static enum gimplify_status 1438gimplify_conversion (tree *expr_p) 1439{ 1440 gcc_assert (TREE_CODE (*expr_p) == NOP_EXPR 1441 || TREE_CODE (*expr_p) == CONVERT_EXPR); 1442 1443 /* Then strip away all but the outermost conversion. */ 1444 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0)); 1445 1446 /* And remove the outermost conversion if it's useless. */ 1447 if (tree_ssa_useless_type_conversion (*expr_p)) 1448 *expr_p = TREE_OPERAND (*expr_p, 0); 1449 1450 /* If we still have a conversion at the toplevel, 1451 then canonicalize some constructs. */ 1452 if (TREE_CODE (*expr_p) == NOP_EXPR || TREE_CODE (*expr_p) == CONVERT_EXPR) 1453 { 1454 tree sub = TREE_OPERAND (*expr_p, 0); 1455 1456 /* If a NOP conversion is changing the type of a COMPONENT_REF 1457 expression, then canonicalize its type now in order to expose more 1458 redundant conversions. */ 1459 if (TREE_CODE (sub) == COMPONENT_REF) 1460 canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0)); 1461 1462 /* If a NOP conversion is changing a pointer to array of foo 1463 to a pointer to foo, embed that change in the ADDR_EXPR. */ 1464 else if (TREE_CODE (sub) == ADDR_EXPR) 1465 canonicalize_addr_expr (expr_p); 1466 } 1467 1468 return GS_OK; 1469} 1470 1471/* Gimplify a VAR_DECL or PARM_DECL. Returns GS_OK if we expanded a 1472 DECL_VALUE_EXPR, and it's worth re-examining things. */ 1473 1474static enum gimplify_status 1475gimplify_var_or_parm_decl (tree *expr_p) 1476{ 1477 tree decl = *expr_p; 1478 1479 /* ??? If this is a local variable, and it has not been seen in any 1480 outer BIND_EXPR, then it's probably the result of a duplicate 1481 declaration, for which we've already issued an error. It would 1482 be really nice if the front end wouldn't leak these at all. 1483 Currently the only known culprit is C++ destructors, as seen 1484 in g++.old-deja/g++.jason/binding.C. */ 1485 if (TREE_CODE (decl) == VAR_DECL 1486 && !DECL_SEEN_IN_BIND_EXPR_P (decl) 1487 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl) 1488 && decl_function_context (decl) == current_function_decl) 1489 { 1490 gcc_assert (errorcount || sorrycount); 1491 return GS_ERROR; 1492 } 1493 1494 /* If the decl is an alias for another expression, substitute it now. */ 1495 if (DECL_HAS_VALUE_EXPR_P (decl)) 1496 { 1497 *expr_p = unshare_expr (DECL_VALUE_EXPR (decl)); 1498 return GS_OK; 1499 } 1500 1501 return GS_ALL_DONE; 1502} 1503 1504 1505/* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR 1506 node pointed to by EXPR_P. 1507 1508 compound_lval 1509 : min_lval '[' val ']' 1510 | min_lval '.' ID 1511 | compound_lval '[' val ']' 1512 | compound_lval '.' ID 1513 1514 This is not part of the original SIMPLE definition, which separates 1515 array and member references, but it seems reasonable to handle them 1516 together. Also, this way we don't run into problems with union 1517 aliasing; gcc requires that for accesses through a union to alias, the 1518 union reference must be explicit, which was not always the case when we 1519 were splitting up array and member refs. 1520 1521 PRE_P points to the list where side effects that must happen before 1522 *EXPR_P should be stored. 1523 1524 POST_P points to the list where side effects that must happen after 1525 *EXPR_P should be stored. */ 1526 1527static enum gimplify_status 1528gimplify_compound_lval (tree *expr_p, tree *pre_p, 1529 tree *post_p, fallback_t fallback) 1530{ 1531 tree *p; 1532 VEC(tree,heap) *stack; 1533 enum gimplify_status ret = GS_OK, tret; 1534 int i; 1535 1536 /* Create a stack of the subexpressions so later we can walk them in 1537 order from inner to outer. */ 1538 stack = VEC_alloc (tree, heap, 10); 1539 1540 /* We can handle anything that get_inner_reference can deal with. */ 1541 for (p = expr_p; ; p = &TREE_OPERAND (*p, 0)) 1542 { 1543 restart: 1544 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */ 1545 if (TREE_CODE (*p) == INDIRECT_REF) 1546 *p = fold_indirect_ref (*p); 1547 1548 if (handled_component_p (*p)) 1549 ; 1550 /* Expand DECL_VALUE_EXPR now. In some cases that may expose 1551 additional COMPONENT_REFs. */ 1552 else if ((TREE_CODE (*p) == VAR_DECL || TREE_CODE (*p) == PARM_DECL) 1553 && gimplify_var_or_parm_decl (p) == GS_OK) 1554 goto restart; 1555 else 1556 break; 1557 1558 VEC_safe_push (tree, heap, stack, *p); 1559 } 1560 1561 gcc_assert (VEC_length (tree, stack)); 1562 1563 /* Now STACK is a stack of pointers to all the refs we've walked through 1564 and P points to the innermost expression. 1565 1566 Java requires that we elaborated nodes in source order. That 1567 means we must gimplify the inner expression followed by each of 1568 the indices, in order. But we can't gimplify the inner 1569 expression until we deal with any variable bounds, sizes, or 1570 positions in order to deal with PLACEHOLDER_EXPRs. 1571 1572 So we do this in three steps. First we deal with the annotations 1573 for any variables in the components, then we gimplify the base, 1574 then we gimplify any indices, from left to right. */ 1575 for (i = VEC_length (tree, stack) - 1; i >= 0; i--) 1576 { 1577 tree t = VEC_index (tree, stack, i); 1578 1579 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF) 1580 { 1581 /* Gimplify the low bound and element type size and put them into 1582 the ARRAY_REF. If these values are set, they have already been 1583 gimplified. */ 1584 if (!TREE_OPERAND (t, 2)) 1585 { 1586 tree low = unshare_expr (array_ref_low_bound (t)); 1587 if (!is_gimple_min_invariant (low)) 1588 { 1589 TREE_OPERAND (t, 2) = low; 1590 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p, 1591 is_gimple_formal_tmp_reg, fb_rvalue); 1592 ret = MIN (ret, tret); 1593 } 1594 } 1595 1596 if (!TREE_OPERAND (t, 3)) 1597 { 1598 tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))); 1599 tree elmt_size = unshare_expr (array_ref_element_size (t)); 1600 tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type)); 1601 1602 /* Divide the element size by the alignment of the element 1603 type (above). */ 1604 elmt_size = size_binop (EXACT_DIV_EXPR, elmt_size, factor); 1605 1606 if (!is_gimple_min_invariant (elmt_size)) 1607 { 1608 TREE_OPERAND (t, 3) = elmt_size; 1609 tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p, post_p, 1610 is_gimple_formal_tmp_reg, fb_rvalue); 1611 ret = MIN (ret, tret); 1612 } 1613 } 1614 } 1615 else if (TREE_CODE (t) == COMPONENT_REF) 1616 { 1617 /* Set the field offset into T and gimplify it. */ 1618 if (!TREE_OPERAND (t, 2)) 1619 { 1620 tree offset = unshare_expr (component_ref_field_offset (t)); 1621 tree field = TREE_OPERAND (t, 1); 1622 tree factor 1623 = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT); 1624 1625 /* Divide the offset by its alignment. */ 1626 offset = size_binop (EXACT_DIV_EXPR, offset, factor); 1627 1628 if (!is_gimple_min_invariant (offset)) 1629 { 1630 TREE_OPERAND (t, 2) = offset; 1631 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p, 1632 is_gimple_formal_tmp_reg, fb_rvalue); 1633 ret = MIN (ret, tret); 1634 } 1635 } 1636 } 1637 } 1638 1639 /* Step 2 is to gimplify the base expression. Make sure lvalue is set 1640 so as to match the min_lval predicate. Failure to do so may result 1641 in the creation of large aggregate temporaries. */ 1642 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval, 1643 fallback | fb_lvalue); 1644 ret = MIN (ret, tret); 1645 1646 /* And finally, the indices and operands to BIT_FIELD_REF. During this 1647 loop we also remove any useless conversions. */ 1648 for (; VEC_length (tree, stack) > 0; ) 1649 { 1650 tree t = VEC_pop (tree, stack); 1651 1652 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF) 1653 { 1654 /* Gimplify the dimension. 1655 Temporary fix for gcc.c-torture/execute/20040313-1.c. 1656 Gimplify non-constant array indices into a temporary 1657 variable. 1658 FIXME - The real fix is to gimplify post-modify 1659 expressions into a minimal gimple lvalue. However, that 1660 exposes bugs in alias analysis. The alias analyzer does 1661 not handle &PTR->FIELD very well. Will fix after the 1662 branch is merged into mainline (dnovillo 2004-05-03). */ 1663 if (!is_gimple_min_invariant (TREE_OPERAND (t, 1))) 1664 { 1665 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p, 1666 is_gimple_formal_tmp_reg, fb_rvalue); 1667 ret = MIN (ret, tret); 1668 } 1669 } 1670 else if (TREE_CODE (t) == BIT_FIELD_REF) 1671 { 1672 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p, 1673 is_gimple_val, fb_rvalue); 1674 ret = MIN (ret, tret); 1675 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p, 1676 is_gimple_val, fb_rvalue); 1677 ret = MIN (ret, tret); 1678 } 1679 1680 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0)); 1681 1682 /* The innermost expression P may have originally had TREE_SIDE_EFFECTS 1683 set which would have caused all the outer expressions in EXPR_P 1684 leading to P to also have had TREE_SIDE_EFFECTS set. */ 1685 recalculate_side_effects (t); 1686 } 1687 1688 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval, fallback); 1689 ret = MIN (ret, tret); 1690 1691 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */ 1692 if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF) 1693 { 1694 canonicalize_component_ref (expr_p); 1695 ret = MIN (ret, GS_OK); 1696 } 1697 1698 VEC_free (tree, heap, stack); 1699 1700 return ret; 1701} 1702 1703/* Gimplify the self modifying expression pointed to by EXPR_P 1704 (++, --, +=, -=). 1705 1706 PRE_P points to the list where side effects that must happen before 1707 *EXPR_P should be stored. 1708 1709 POST_P points to the list where side effects that must happen after 1710 *EXPR_P should be stored. 1711 1712 WANT_VALUE is nonzero iff we want to use the value of this expression 1713 in another expression. */ 1714 1715static enum gimplify_status 1716gimplify_self_mod_expr (tree *expr_p, tree *pre_p, tree *post_p, 1717 bool want_value) 1718{ 1719 enum tree_code code; 1720 tree lhs, lvalue, rhs, t1, post = NULL, *orig_post_p = post_p; 1721 bool postfix; 1722 enum tree_code arith_code; 1723 enum gimplify_status ret; 1724 1725 code = TREE_CODE (*expr_p); 1726 1727 gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR 1728 || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR); 1729 1730 /* Prefix or postfix? */ 1731 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR) 1732 /* Faster to treat as prefix if result is not used. */ 1733 postfix = want_value; 1734 else 1735 postfix = false; 1736 1737 /* For postfix, make sure the inner expression's post side effects 1738 are executed after side effects from this expression. */ 1739 if (postfix) 1740 post_p = &post; 1741 1742 /* Add or subtract? */ 1743 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 1744 arith_code = PLUS_EXPR; 1745 else 1746 arith_code = MINUS_EXPR; 1747 1748 /* Gimplify the LHS into a GIMPLE lvalue. */ 1749 lvalue = TREE_OPERAND (*expr_p, 0); 1750 ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue); 1751 if (ret == GS_ERROR) 1752 return ret; 1753 1754 /* Extract the operands to the arithmetic operation. */ 1755 lhs = lvalue; 1756 rhs = TREE_OPERAND (*expr_p, 1); 1757 1758 /* For postfix operator, we evaluate the LHS to an rvalue and then use 1759 that as the result value and in the postqueue operation. */ 1760 if (postfix) 1761 { 1762 ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue); 1763 if (ret == GS_ERROR) 1764 return ret; 1765 } 1766 1767 t1 = build (arith_code, TREE_TYPE (*expr_p), lhs, rhs); 1768 t1 = build (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1); 1769 1770 if (postfix) 1771 { 1772 gimplify_and_add (t1, orig_post_p); 1773 append_to_statement_list (post, orig_post_p); 1774 *expr_p = lhs; 1775 return GS_ALL_DONE; 1776 } 1777 else 1778 { 1779 *expr_p = t1; 1780 return GS_OK; 1781 } 1782} 1783 1784/* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */ 1785 1786static void 1787maybe_with_size_expr (tree *expr_p) 1788{ 1789 tree expr = *expr_p; 1790 tree type = TREE_TYPE (expr); 1791 tree size; 1792 1793 /* If we've already wrapped this or the type is error_mark_node, we can't do 1794 anything. */ 1795 if (TREE_CODE (expr) == WITH_SIZE_EXPR 1796 || type == error_mark_node) 1797 return; 1798 1799 /* If the size isn't known or is a constant, we have nothing to do. */ 1800 size = TYPE_SIZE_UNIT (type); 1801 if (!size || TREE_CODE (size) == INTEGER_CST) 1802 return; 1803 1804 /* Otherwise, make a WITH_SIZE_EXPR. */ 1805 size = unshare_expr (size); 1806 size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr); 1807 *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size); 1808} 1809 1810/* Subroutine of gimplify_call_expr: Gimplify a single argument. */ 1811 1812static enum gimplify_status 1813gimplify_arg (tree *expr_p, tree *pre_p) 1814{ 1815 bool (*test) (tree); 1816 fallback_t fb; 1817 1818 /* In general, we allow lvalues for function arguments to avoid 1819 extra overhead of copying large aggregates out of even larger 1820 aggregates into temporaries only to copy the temporaries to 1821 the argument list. Make optimizers happy by pulling out to 1822 temporaries those types that fit in registers. */ 1823 if (is_gimple_reg_type (TREE_TYPE (*expr_p))) 1824 test = is_gimple_val, fb = fb_rvalue; 1825 else 1826 test = is_gimple_lvalue, fb = fb_either; 1827 1828 /* If this is a variable sized type, we must remember the size. */ 1829 maybe_with_size_expr (expr_p); 1830 1831 /* There is a sequence point before a function call. Side effects in 1832 the argument list must occur before the actual call. So, when 1833 gimplifying arguments, force gimplify_expr to use an internal 1834 post queue which is then appended to the end of PRE_P. */ 1835 return gimplify_expr (expr_p, pre_p, NULL, test, fb); 1836} 1837 1838/* Gimplify the CALL_EXPR node pointed to by EXPR_P. PRE_P points to the 1839 list where side effects that must happen before *EXPR_P should be stored. 1840 WANT_VALUE is true if the result of the call is desired. */ 1841 1842static enum gimplify_status 1843gimplify_call_expr (tree *expr_p, tree *pre_p, bool want_value) 1844{ 1845 tree decl; 1846 tree arglist; 1847 enum gimplify_status ret; 1848 1849 gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR); 1850 1851 /* For reliable diagnostics during inlining, it is necessary that 1852 every call_expr be annotated with file and line. */ 1853 if (! EXPR_HAS_LOCATION (*expr_p)) 1854 SET_EXPR_LOCATION (*expr_p, input_location); 1855 1856 /* This may be a call to a builtin function. 1857 1858 Builtin function calls may be transformed into different 1859 (and more efficient) builtin function calls under certain 1860 circumstances. Unfortunately, gimplification can muck things 1861 up enough that the builtin expanders are not aware that certain 1862 transformations are still valid. 1863 1864 So we attempt transformation/gimplification of the call before 1865 we gimplify the CALL_EXPR. At this time we do not manage to 1866 transform all calls in the same manner as the expanders do, but 1867 we do transform most of them. */ 1868 decl = get_callee_fndecl (*expr_p); 1869 if (decl && DECL_BUILT_IN (decl)) 1870 { 1871 tree arglist = TREE_OPERAND (*expr_p, 1); 1872 tree new = fold_builtin (decl, arglist, !want_value); 1873 1874 if (new && new != *expr_p) 1875 { 1876 /* There was a transformation of this call which computes the 1877 same value, but in a more efficient way. Return and try 1878 again. */ 1879 *expr_p = new; 1880 return GS_OK; 1881 } 1882 1883 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL 1884 && DECL_FUNCTION_CODE (decl) == BUILT_IN_VA_START) 1885 { 1886 if (!arglist || !TREE_CHAIN (arglist)) 1887 { 1888 error ("too few arguments to function %<va_start%>"); 1889 *expr_p = build_empty_stmt (); 1890 return GS_OK; 1891 } 1892 1893 if (fold_builtin_next_arg (TREE_CHAIN (arglist))) 1894 { 1895 *expr_p = build_empty_stmt (); 1896 return GS_OK; 1897 } 1898 /* Avoid gimplifying the second argument to va_start, which needs 1899 to be the plain PARM_DECL. */ 1900 return gimplify_arg (&TREE_VALUE (TREE_OPERAND (*expr_p, 1)), pre_p); 1901 } 1902 } 1903 1904 /* There is a sequence point before the call, so any side effects in 1905 the calling expression must occur before the actual call. Force 1906 gimplify_expr to use an internal post queue. */ 1907 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, NULL, 1908 is_gimple_call_addr, fb_rvalue); 1909 1910 if (PUSH_ARGS_REVERSED) 1911 TREE_OPERAND (*expr_p, 1) = nreverse (TREE_OPERAND (*expr_p, 1)); 1912 for (arglist = TREE_OPERAND (*expr_p, 1); arglist; 1913 arglist = TREE_CHAIN (arglist)) 1914 { 1915 enum gimplify_status t; 1916 1917 t = gimplify_arg (&TREE_VALUE (arglist), pre_p); 1918 1919 if (t == GS_ERROR) 1920 ret = GS_ERROR; 1921 } 1922 if (PUSH_ARGS_REVERSED) 1923 TREE_OPERAND (*expr_p, 1) = nreverse (TREE_OPERAND (*expr_p, 1)); 1924 1925 /* Try this again in case gimplification exposed something. */ 1926 if (ret != GS_ERROR) 1927 { 1928 decl = get_callee_fndecl (*expr_p); 1929 if (decl && DECL_BUILT_IN (decl)) 1930 { 1931 tree arglist = TREE_OPERAND (*expr_p, 1); 1932 tree new = fold_builtin (decl, arglist, !want_value); 1933 1934 if (new && new != *expr_p) 1935 { 1936 /* There was a transformation of this call which computes the 1937 same value, but in a more efficient way. Return and try 1938 again. */ 1939 *expr_p = new; 1940 return GS_OK; 1941 } 1942 } 1943 } 1944 1945 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its 1946 decl. This allows us to eliminate redundant or useless 1947 calls to "const" functions. */ 1948 if (TREE_CODE (*expr_p) == CALL_EXPR 1949 && (call_expr_flags (*expr_p) & (ECF_CONST | ECF_PURE))) 1950 TREE_SIDE_EFFECTS (*expr_p) = 0; 1951 1952 return ret; 1953} 1954 1955/* Handle shortcut semantics in the predicate operand of a COND_EXPR by 1956 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs. 1957 1958 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the 1959 condition is true or false, respectively. If null, we should generate 1960 our own to skip over the evaluation of this specific expression. 1961 1962 This function is the tree equivalent of do_jump. 1963 1964 shortcut_cond_r should only be called by shortcut_cond_expr. */ 1965 1966static tree 1967shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p) 1968{ 1969 tree local_label = NULL_TREE; 1970 tree t, expr = NULL; 1971 1972 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to 1973 retain the shortcut semantics. Just insert the gotos here; 1974 shortcut_cond_expr will append the real blocks later. */ 1975 if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR) 1976 { 1977 /* Turn if (a && b) into 1978 1979 if (a); else goto no; 1980 if (b) goto yes; else goto no; 1981 (no:) */ 1982 1983 if (false_label_p == NULL) 1984 false_label_p = &local_label; 1985 1986 t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p); 1987 append_to_statement_list (t, &expr); 1988 1989 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, 1990 false_label_p); 1991 append_to_statement_list (t, &expr); 1992 } 1993 else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR) 1994 { 1995 /* Turn if (a || b) into 1996 1997 if (a) goto yes; 1998 if (b) goto yes; else goto no; 1999 (yes:) */ 2000 2001 if (true_label_p == NULL) 2002 true_label_p = &local_label; 2003 2004 t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL); 2005 append_to_statement_list (t, &expr); 2006 2007 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, 2008 false_label_p); 2009 append_to_statement_list (t, &expr); 2010 } 2011 else if (TREE_CODE (pred) == COND_EXPR) 2012 { 2013 /* As long as we're messing with gotos, turn if (a ? b : c) into 2014 if (a) 2015 if (b) goto yes; else goto no; 2016 else 2017 if (c) goto yes; else goto no; */ 2018 expr = build (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0), 2019 shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, 2020 false_label_p), 2021 shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p, 2022 false_label_p)); 2023 } 2024 else 2025 { 2026 expr = build (COND_EXPR, void_type_node, pred, 2027 build_and_jump (true_label_p), 2028 build_and_jump (false_label_p)); 2029 } 2030 2031 if (local_label) 2032 { 2033 t = build1 (LABEL_EXPR, void_type_node, local_label); 2034 append_to_statement_list (t, &expr); 2035 } 2036 2037 return expr; 2038} 2039 2040static tree 2041shortcut_cond_expr (tree expr) 2042{ 2043 tree pred = TREE_OPERAND (expr, 0); 2044 tree then_ = TREE_OPERAND (expr, 1); 2045 tree else_ = TREE_OPERAND (expr, 2); 2046 tree true_label, false_label, end_label, t; 2047 tree *true_label_p; 2048 tree *false_label_p; 2049 bool emit_end, emit_false, jump_over_else; 2050 bool then_se = then_ && TREE_SIDE_EFFECTS (then_); 2051 bool else_se = else_ && TREE_SIDE_EFFECTS (else_); 2052 2053 /* First do simple transformations. */ 2054 if (!else_se) 2055 { 2056 /* If there is no 'else', turn (a && b) into if (a) if (b). */ 2057 while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR) 2058 { 2059 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1); 2060 then_ = shortcut_cond_expr (expr); 2061 then_se = then_ && TREE_SIDE_EFFECTS (then_); 2062 pred = TREE_OPERAND (pred, 0); 2063 expr = build (COND_EXPR, void_type_node, pred, then_, NULL_TREE); 2064 } 2065 } 2066 if (!then_se) 2067 { 2068 /* If there is no 'then', turn 2069 if (a || b); else d 2070 into 2071 if (a); else if (b); else d. */ 2072 while (TREE_CODE (pred) == TRUTH_ORIF_EXPR) 2073 { 2074 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1); 2075 else_ = shortcut_cond_expr (expr); 2076 else_se = else_ && TREE_SIDE_EFFECTS (else_); 2077 pred = TREE_OPERAND (pred, 0); 2078 expr = build (COND_EXPR, void_type_node, pred, NULL_TREE, else_); 2079 } 2080 } 2081 2082 /* If we're done, great. */ 2083 if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR 2084 && TREE_CODE (pred) != TRUTH_ORIF_EXPR) 2085 return expr; 2086 2087 /* Otherwise we need to mess with gotos. Change 2088 if (a) c; else d; 2089 to 2090 if (a); else goto no; 2091 c; goto end; 2092 no: d; end: 2093 and recursively gimplify the condition. */ 2094 2095 true_label = false_label = end_label = NULL_TREE; 2096 2097 /* If our arms just jump somewhere, hijack those labels so we don't 2098 generate jumps to jumps. */ 2099 2100 if (then_ 2101 && TREE_CODE (then_) == GOTO_EXPR 2102 && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL) 2103 { 2104 true_label = GOTO_DESTINATION (then_); 2105 then_ = NULL; 2106 then_se = false; 2107 } 2108 2109 if (else_ 2110 && TREE_CODE (else_) == GOTO_EXPR 2111 && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL) 2112 { 2113 false_label = GOTO_DESTINATION (else_); 2114 else_ = NULL; 2115 else_se = false; 2116 } 2117 2118 /* If we aren't hijacking a label for the 'then' branch, it falls through. */ 2119 if (true_label) 2120 true_label_p = &true_label; 2121 else 2122 true_label_p = NULL; 2123 2124 /* The 'else' branch also needs a label if it contains interesting code. */ 2125 if (false_label || else_se) 2126 false_label_p = &false_label; 2127 else 2128 false_label_p = NULL; 2129 2130 /* If there was nothing else in our arms, just forward the label(s). */ 2131 if (!then_se && !else_se) 2132 return shortcut_cond_r (pred, true_label_p, false_label_p); 2133 2134 /* If our last subexpression already has a terminal label, reuse it. */ 2135 if (else_se) 2136 expr = expr_last (else_); 2137 else if (then_se) 2138 expr = expr_last (then_); 2139 else 2140 expr = NULL; 2141 if (expr && TREE_CODE (expr) == LABEL_EXPR) 2142 end_label = LABEL_EXPR_LABEL (expr); 2143 2144 /* If we don't care about jumping to the 'else' branch, jump to the end 2145 if the condition is false. */ 2146 if (!false_label_p) 2147 false_label_p = &end_label; 2148 2149 /* We only want to emit these labels if we aren't hijacking them. */ 2150 emit_end = (end_label == NULL_TREE); 2151 emit_false = (false_label == NULL_TREE); 2152 2153 /* We only emit the jump over the else clause if we have to--if the 2154 then clause may fall through. Otherwise we can wind up with a 2155 useless jump and a useless label at the end of gimplified code, 2156 which will cause us to think that this conditional as a whole 2157 falls through even if it doesn't. If we then inline a function 2158 which ends with such a condition, that can cause us to issue an 2159 inappropriate warning about control reaching the end of a 2160 non-void function. */ 2161 jump_over_else = block_may_fallthru (then_); 2162 2163 pred = shortcut_cond_r (pred, true_label_p, false_label_p); 2164 2165 expr = NULL; 2166 append_to_statement_list (pred, &expr); 2167 2168 append_to_statement_list (then_, &expr); 2169 if (else_se) 2170 { 2171 if (jump_over_else) 2172 { 2173 t = build_and_jump (&end_label); 2174 append_to_statement_list (t, &expr); 2175 } 2176 if (emit_false) 2177 { 2178 t = build1 (LABEL_EXPR, void_type_node, false_label); 2179 append_to_statement_list (t, &expr); 2180 } 2181 append_to_statement_list (else_, &expr); 2182 } 2183 if (emit_end && end_label) 2184 { 2185 t = build1 (LABEL_EXPR, void_type_node, end_label); 2186 append_to_statement_list (t, &expr); 2187 } 2188 2189 return expr; 2190} 2191 2192/* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */ 2193 2194static tree 2195gimple_boolify (tree expr) 2196{ 2197 tree type = TREE_TYPE (expr); 2198 2199 if (TREE_CODE (type) == BOOLEAN_TYPE) 2200 return expr; 2201 2202 switch (TREE_CODE (expr)) 2203 { 2204 case TRUTH_AND_EXPR: 2205 case TRUTH_OR_EXPR: 2206 case TRUTH_XOR_EXPR: 2207 case TRUTH_ANDIF_EXPR: 2208 case TRUTH_ORIF_EXPR: 2209 /* Also boolify the arguments of truth exprs. */ 2210 TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1)); 2211 /* FALLTHRU */ 2212 2213 case TRUTH_NOT_EXPR: 2214 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0)); 2215 /* FALLTHRU */ 2216 2217 case EQ_EXPR: case NE_EXPR: 2218 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR: 2219 /* These expressions always produce boolean results. */ 2220 TREE_TYPE (expr) = boolean_type_node; 2221 return expr; 2222 2223 default: 2224 /* Other expressions that get here must have boolean values, but 2225 might need to be converted to the appropriate mode. */ 2226 return convert (boolean_type_node, expr); 2227 } 2228} 2229 2230/* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;' 2231 into 2232 2233 if (p) if (p) 2234 t1 = a; a; 2235 else or else 2236 t1 = b; b; 2237 t1; 2238 2239 The second form is used when *EXPR_P is of type void. 2240 2241 TARGET is the tree for T1 above. 2242 2243 PRE_P points to the list where side effects that must happen before 2244 *EXPR_P should be stored. */ 2245 2246static enum gimplify_status 2247gimplify_cond_expr (tree *expr_p, tree *pre_p, fallback_t fallback) 2248{ 2249 tree expr = *expr_p; 2250 tree tmp, tmp2, type; 2251 enum gimplify_status ret; 2252 2253 type = TREE_TYPE (expr); 2254 2255 /* If this COND_EXPR has a value, copy the values into a temporary within 2256 the arms. */ 2257 if (! VOID_TYPE_P (type)) 2258 { 2259 tree result; 2260 2261 if ((fallback & fb_lvalue) == 0) 2262 { 2263 result = tmp2 = tmp = create_tmp_var (TREE_TYPE (expr), "iftmp"); 2264 ret = GS_ALL_DONE; 2265 } 2266 else 2267 { 2268 tree type = build_pointer_type (TREE_TYPE (expr)); 2269 2270 if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node) 2271 TREE_OPERAND (expr, 1) = 2272 build_fold_addr_expr (TREE_OPERAND (expr, 1)); 2273 2274 if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node) 2275 TREE_OPERAND (expr, 2) = 2276 build_fold_addr_expr (TREE_OPERAND (expr, 2)); 2277 2278 tmp2 = tmp = create_tmp_var (type, "iftmp"); 2279 2280 expr = build (COND_EXPR, void_type_node, TREE_OPERAND (expr, 0), 2281 TREE_OPERAND (expr, 1), TREE_OPERAND (expr, 2)); 2282 2283 result = build_fold_indirect_ref (tmp); 2284 ret = GS_ALL_DONE; 2285 } 2286 2287 /* Build the then clause, 't1 = a;'. But don't build an assignment 2288 if this branch is void; in C++ it can be, if it's a throw. */ 2289 if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node) 2290 TREE_OPERAND (expr, 1) 2291 = build (MODIFY_EXPR, void_type_node, tmp, TREE_OPERAND (expr, 1)); 2292 2293 /* Build the else clause, 't1 = b;'. */ 2294 if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node) 2295 TREE_OPERAND (expr, 2) 2296 = build (MODIFY_EXPR, void_type_node, tmp2, TREE_OPERAND (expr, 2)); 2297 2298 TREE_TYPE (expr) = void_type_node; 2299 recalculate_side_effects (expr); 2300 2301 /* Move the COND_EXPR to the prequeue. */ 2302 gimplify_and_add (expr, pre_p); 2303 2304 *expr_p = result; 2305 return ret; 2306 } 2307 2308 /* Make sure the condition has BOOLEAN_TYPE. */ 2309 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0)); 2310 2311 /* Break apart && and || conditions. */ 2312 if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR 2313 || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR) 2314 { 2315 expr = shortcut_cond_expr (expr); 2316 2317 if (expr != *expr_p) 2318 { 2319 *expr_p = expr; 2320 2321 /* We can't rely on gimplify_expr to re-gimplify the expanded 2322 form properly, as cleanups might cause the target labels to be 2323 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to 2324 set up a conditional context. */ 2325 gimple_push_condition (); 2326 gimplify_stmt (expr_p); 2327 gimple_pop_condition (pre_p); 2328 2329 return GS_ALL_DONE; 2330 } 2331 } 2332 2333 /* Now do the normal gimplification. */ 2334 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL, 2335 is_gimple_condexpr, fb_rvalue); 2336 2337 gimple_push_condition (); 2338 2339 gimplify_to_stmt_list (&TREE_OPERAND (expr, 1)); 2340 gimplify_to_stmt_list (&TREE_OPERAND (expr, 2)); 2341 recalculate_side_effects (expr); 2342 2343 gimple_pop_condition (pre_p); 2344 2345 if (ret == GS_ERROR) 2346 ; 2347 else if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))) 2348 ret = GS_ALL_DONE; 2349 else if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 2))) 2350 /* Rewrite "if (a); else b" to "if (!a) b" */ 2351 { 2352 TREE_OPERAND (expr, 0) = invert_truthvalue (TREE_OPERAND (expr, 0)); 2353 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL, 2354 is_gimple_condexpr, fb_rvalue); 2355 2356 tmp = TREE_OPERAND (expr, 1); 2357 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 2); 2358 TREE_OPERAND (expr, 2) = tmp; 2359 } 2360 else 2361 /* Both arms are empty; replace the COND_EXPR with its predicate. */ 2362 expr = TREE_OPERAND (expr, 0); 2363 2364 *expr_p = expr; 2365 return ret; 2366} 2367 2368/* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with 2369 a call to __builtin_memcpy. */ 2370 2371static enum gimplify_status 2372gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value) 2373{ 2374 tree args, t, to, to_ptr, from; 2375 2376 to = TREE_OPERAND (*expr_p, 0); 2377 from = TREE_OPERAND (*expr_p, 1); 2378 2379 args = tree_cons (NULL, size, NULL); 2380 2381 t = build_fold_addr_expr (from); 2382 args = tree_cons (NULL, t, args); 2383 2384 to_ptr = build_fold_addr_expr (to); 2385 args = tree_cons (NULL, to_ptr, args); 2386 t = implicit_built_in_decls[BUILT_IN_MEMCPY]; 2387 t = build_function_call_expr (t, args); 2388 2389 if (want_value) 2390 { 2391 t = build1 (NOP_EXPR, TREE_TYPE (to_ptr), t); 2392 t = build1 (INDIRECT_REF, TREE_TYPE (to), t); 2393 } 2394 2395 *expr_p = t; 2396 return GS_OK; 2397} 2398 2399/* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with 2400 a call to __builtin_memset. In this case we know that the RHS is 2401 a CONSTRUCTOR with an empty element list. */ 2402 2403static enum gimplify_status 2404gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value) 2405{ 2406 tree args, t, to, to_ptr; 2407 2408 to = TREE_OPERAND (*expr_p, 0); 2409 2410 args = tree_cons (NULL, size, NULL); 2411 2412 args = tree_cons (NULL, integer_zero_node, args); 2413 2414 to_ptr = build_fold_addr_expr (to); 2415 args = tree_cons (NULL, to_ptr, args); 2416 t = implicit_built_in_decls[BUILT_IN_MEMSET]; 2417 t = build_function_call_expr (t, args); 2418 2419 if (want_value) 2420 { 2421 t = build1 (NOP_EXPR, TREE_TYPE (to_ptr), t); 2422 t = build1 (INDIRECT_REF, TREE_TYPE (to), t); 2423 } 2424 2425 *expr_p = t; 2426 return GS_OK; 2427} 2428 2429/* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree, 2430 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an 2431 assignment. Returns non-null if we detect a potential overlap. */ 2432 2433struct gimplify_init_ctor_preeval_data 2434{ 2435 /* The base decl of the lhs object. May be NULL, in which case we 2436 have to assume the lhs is indirect. */ 2437 tree lhs_base_decl; 2438 2439 /* The alias set of the lhs object. */ 2440 int lhs_alias_set; 2441}; 2442 2443static tree 2444gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata) 2445{ 2446 struct gimplify_init_ctor_preeval_data *data 2447 = (struct gimplify_init_ctor_preeval_data *) xdata; 2448 tree t = *tp; 2449 2450 /* If we find the base object, obviously we have overlap. */ 2451 if (data->lhs_base_decl == t) 2452 return t; 2453 2454 /* If the constructor component is indirect, determine if we have a 2455 potential overlap with the lhs. The only bits of information we 2456 have to go on at this point are addressability and alias sets. */ 2457 if (TREE_CODE (t) == INDIRECT_REF 2458 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl)) 2459 && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t))) 2460 return t; 2461 2462 if (IS_TYPE_OR_DECL_P (t)) 2463 *walk_subtrees = 0; 2464 return NULL; 2465} 2466 2467/* A subroutine of gimplify_init_constructor. Pre-evaluate *EXPR_P, 2468 force values that overlap with the lhs (as described by *DATA) 2469 into temporaries. */ 2470 2471static void 2472gimplify_init_ctor_preeval (tree *expr_p, tree *pre_p, tree *post_p, 2473 struct gimplify_init_ctor_preeval_data *data) 2474{ 2475 enum gimplify_status one; 2476 2477 /* If the value is invariant, then there's nothing to pre-evaluate. 2478 But ensure it doesn't have any side-effects since a SAVE_EXPR is 2479 invariant but has side effects and might contain a reference to 2480 the object we're initializing. */ 2481 if (TREE_INVARIANT (*expr_p) && !TREE_SIDE_EFFECTS (*expr_p)) 2482 return; 2483 2484 /* If the type has non-trivial constructors, we can't pre-evaluate. */ 2485 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p))) 2486 return; 2487 2488 /* Recurse for nested constructors. */ 2489 if (TREE_CODE (*expr_p) == CONSTRUCTOR) 2490 { 2491 unsigned HOST_WIDE_INT ix; 2492 constructor_elt *ce; 2493 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (*expr_p); 2494 2495 for (ix = 0; VEC_iterate (constructor_elt, v, ix, ce); ix++) 2496 gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data); 2497 return; 2498 } 2499 2500 /* We can't preevaluate if the type contains a placeholder. */ 2501 if (type_contains_placeholder_p (TREE_TYPE (*expr_p))) 2502 return; 2503 2504 /* Gimplify the constructor element to something appropriate for the rhs 2505 of a MODIFY_EXPR. Given that we know the lhs is an aggregate, we know 2506 the gimplifier will consider this a store to memory. Doing this 2507 gimplification now means that we won't have to deal with complicated 2508 language-specific trees, nor trees like SAVE_EXPR that can induce 2509 exponential search behavior. */ 2510 one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue); 2511 if (one == GS_ERROR) 2512 { 2513 *expr_p = NULL; 2514 return; 2515 } 2516 2517 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap 2518 with the lhs, since "a = { .x=a }" doesn't make sense. This will 2519 always be true for all scalars, since is_gimple_mem_rhs insists on a 2520 temporary variable for them. */ 2521 if (DECL_P (*expr_p)) 2522 return; 2523 2524 /* If this is of variable size, we have no choice but to assume it doesn't 2525 overlap since we can't make a temporary for it. */ 2526 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p))) != INTEGER_CST) 2527 return; 2528 2529 /* Otherwise, we must search for overlap ... */ 2530 if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL)) 2531 return; 2532 2533 /* ... and if found, force the value into a temporary. */ 2534 *expr_p = get_formal_tmp_var (*expr_p, pre_p); 2535} 2536 2537/* A subroutine of gimplify_init_ctor_eval. Create a loop for 2538 a RANGE_EXPR in a CONSTRUCTOR for an array. 2539 2540 var = lower; 2541 loop_entry: 2542 object[var] = value; 2543 if (var == upper) 2544 goto loop_exit; 2545 var = var + 1; 2546 goto loop_entry; 2547 loop_exit: 2548 2549 We increment var _after_ the loop exit check because we might otherwise 2550 fail if upper == TYPE_MAX_VALUE (type for upper). 2551 2552 Note that we never have to deal with SAVE_EXPRs here, because this has 2553 already been taken care of for us, in gimplify_init_ctor_preeval(). */ 2554 2555static void gimplify_init_ctor_eval (tree, VEC(constructor_elt,gc) *, 2556 tree *, bool); 2557 2558static void 2559gimplify_init_ctor_eval_range (tree object, tree lower, tree upper, 2560 tree value, tree array_elt_type, 2561 tree *pre_p, bool cleared) 2562{ 2563 tree loop_entry_label, loop_exit_label; 2564 tree var, var_type, cref; 2565 2566 loop_entry_label = create_artificial_label (); 2567 loop_exit_label = create_artificial_label (); 2568 2569 /* Create and initialize the index variable. */ 2570 var_type = TREE_TYPE (upper); 2571 var = create_tmp_var (var_type, NULL); 2572 append_to_statement_list (build2 (MODIFY_EXPR, var_type, var, lower), pre_p); 2573 2574 /* Add the loop entry label. */ 2575 append_to_statement_list (build1 (LABEL_EXPR, 2576 void_type_node, 2577 loop_entry_label), 2578 pre_p); 2579 2580 /* Build the reference. */ 2581 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object), 2582 var, NULL_TREE, NULL_TREE); 2583 2584 /* If we are a constructor, just call gimplify_init_ctor_eval to do 2585 the store. Otherwise just assign value to the reference. */ 2586 2587 if (TREE_CODE (value) == CONSTRUCTOR) 2588 /* NB we might have to call ourself recursively through 2589 gimplify_init_ctor_eval if the value is a constructor. */ 2590 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value), 2591 pre_p, cleared); 2592 else 2593 append_to_statement_list (build2 (MODIFY_EXPR, TREE_TYPE (cref), 2594 cref, value), 2595 pre_p); 2596 2597 /* We exit the loop when the index var is equal to the upper bound. */ 2598 gimplify_and_add (build3 (COND_EXPR, void_type_node, 2599 build2 (EQ_EXPR, boolean_type_node, 2600 var, upper), 2601 build1 (GOTO_EXPR, 2602 void_type_node, 2603 loop_exit_label), 2604 NULL_TREE), 2605 pre_p); 2606 2607 /* Otherwise, increment the index var... */ 2608 append_to_statement_list (build2 (MODIFY_EXPR, var_type, var, 2609 build2 (PLUS_EXPR, var_type, var, 2610 fold_convert (var_type, 2611 integer_one_node))), 2612 pre_p); 2613 2614 /* ...and jump back to the loop entry. */ 2615 append_to_statement_list (build1 (GOTO_EXPR, 2616 void_type_node, 2617 loop_entry_label), 2618 pre_p); 2619 2620 /* Add the loop exit label. */ 2621 append_to_statement_list (build1 (LABEL_EXPR, 2622 void_type_node, 2623 loop_exit_label), 2624 pre_p); 2625} 2626 2627/* Return true if FDECL is accessing a field that is zero sized. */ 2628 2629static bool 2630zero_sized_field_decl (tree fdecl) 2631{ 2632 if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl) 2633 && integer_zerop (DECL_SIZE (fdecl))) 2634 return true; 2635 return false; 2636} 2637 2638/* Return true if TYPE is zero sized. */ 2639 2640static bool 2641zero_sized_type (tree type) 2642{ 2643 if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type) 2644 && integer_zerop (TYPE_SIZE (type))) 2645 return true; 2646 return false; 2647} 2648 2649/* A subroutine of gimplify_init_constructor. Generate individual 2650 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the 2651 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the 2652 CONSTRUCTOR. CLEARED is true if the entire LHS object has been 2653 zeroed first. */ 2654 2655static void 2656gimplify_init_ctor_eval (tree object, VEC(constructor_elt,gc) *elts, 2657 tree *pre_p, bool cleared) 2658{ 2659 tree array_elt_type = NULL; 2660 unsigned HOST_WIDE_INT ix; 2661 tree purpose, value; 2662 2663 if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE) 2664 array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object))); 2665 2666 FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value) 2667 { 2668 tree cref, init; 2669 2670 /* NULL values are created above for gimplification errors. */ 2671 if (value == NULL) 2672 continue; 2673 2674 if (cleared && initializer_zerop (value)) 2675 continue; 2676 2677 /* ??? Here's to hoping the front end fills in all of the indices, 2678 so we don't have to figure out what's missing ourselves. */ 2679 gcc_assert (purpose); 2680 2681 /* Skip zero-sized fields, unless value has side-effects. This can 2682 happen with calls to functions returning a zero-sized type, which 2683 we shouldn't discard. As a number of downstream passes don't 2684 expect sets of zero-sized fields, we rely on the gimplification of 2685 the MODIFY_EXPR we make below to drop the assignment statement. */ 2686 if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose)) 2687 continue; 2688 2689 /* If we have a RANGE_EXPR, we have to build a loop to assign the 2690 whole range. */ 2691 if (TREE_CODE (purpose) == RANGE_EXPR) 2692 { 2693 tree lower = TREE_OPERAND (purpose, 0); 2694 tree upper = TREE_OPERAND (purpose, 1); 2695 2696 /* If the lower bound is equal to upper, just treat it as if 2697 upper was the index. */ 2698 if (simple_cst_equal (lower, upper)) 2699 purpose = upper; 2700 else 2701 { 2702 gimplify_init_ctor_eval_range (object, lower, upper, value, 2703 array_elt_type, pre_p, cleared); 2704 continue; 2705 } 2706 } 2707 2708 if (array_elt_type) 2709 { 2710 cref = build (ARRAY_REF, array_elt_type, unshare_expr (object), 2711 purpose, NULL_TREE, NULL_TREE); 2712 } 2713 else 2714 { 2715 gcc_assert (TREE_CODE (purpose) == FIELD_DECL); 2716 cref = build (COMPONENT_REF, TREE_TYPE (purpose), 2717 unshare_expr (object), purpose, NULL_TREE); 2718 } 2719 2720 if (TREE_CODE (value) == CONSTRUCTOR 2721 && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE) 2722 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value), 2723 pre_p, cleared); 2724 else 2725 { 2726 init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value); 2727 gimplify_and_add (init, pre_p); 2728 } 2729 } 2730} 2731 2732/* A subroutine of gimplify_modify_expr. Break out elements of a 2733 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs. 2734 2735 Note that we still need to clear any elements that don't have explicit 2736 initializers, so if not all elements are initialized we keep the 2737 original MODIFY_EXPR, we just remove all of the constructor elements. */ 2738 2739static enum gimplify_status 2740gimplify_init_constructor (tree *expr_p, tree *pre_p, 2741 tree *post_p, bool want_value) 2742{ 2743 tree object; 2744 tree ctor = TREE_OPERAND (*expr_p, 1); 2745 tree type = TREE_TYPE (ctor); 2746 enum gimplify_status ret; 2747 VEC(constructor_elt,gc) *elts; 2748 2749 if (TREE_CODE (ctor) != CONSTRUCTOR) 2750 return GS_UNHANDLED; 2751 2752 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, 2753 is_gimple_lvalue, fb_lvalue); 2754 if (ret == GS_ERROR) 2755 return ret; 2756 object = TREE_OPERAND (*expr_p, 0); 2757 2758 elts = CONSTRUCTOR_ELTS (ctor); 2759 2760 ret = GS_ALL_DONE; 2761 switch (TREE_CODE (type)) 2762 { 2763 case RECORD_TYPE: 2764 case UNION_TYPE: 2765 case QUAL_UNION_TYPE: 2766 case ARRAY_TYPE: 2767 { 2768 struct gimplify_init_ctor_preeval_data preeval_data; 2769 HOST_WIDE_INT num_type_elements, num_ctor_elements; 2770 HOST_WIDE_INT num_nonzero_elements, num_nonconstant_elements; 2771 bool cleared; 2772 2773 /* Aggregate types must lower constructors to initialization of 2774 individual elements. The exception is that a CONSTRUCTOR node 2775 with no elements indicates zero-initialization of the whole. */ 2776 if (VEC_empty (constructor_elt, elts)) 2777 break; 2778 2779 categorize_ctor_elements (ctor, &num_nonzero_elements, 2780 &num_nonconstant_elements, 2781 &num_ctor_elements, &cleared); 2782 2783 /* If a const aggregate variable is being initialized, then it 2784 should never be a lose to promote the variable to be static. */ 2785 if (num_nonconstant_elements == 0 2786 && num_nonzero_elements > 1 2787 && TREE_READONLY (object) 2788 && TREE_CODE (object) == VAR_DECL) 2789 { 2790 DECL_INITIAL (object) = ctor; 2791 TREE_STATIC (object) = 1; 2792 if (!DECL_NAME (object)) 2793 DECL_NAME (object) = create_tmp_var_name ("C"); 2794 walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL); 2795 2796 /* ??? C++ doesn't automatically append a .<number> to the 2797 assembler name, and even when it does, it looks a FE private 2798 data structures to figure out what that number should be, 2799 which are not set for this variable. I suppose this is 2800 important for local statics for inline functions, which aren't 2801 "local" in the object file sense. So in order to get a unique 2802 TU-local symbol, we must invoke the lhd version now. */ 2803 lhd_set_decl_assembler_name (object); 2804 2805 *expr_p = NULL_TREE; 2806 break; 2807 } 2808 2809 /* If there are "lots" of initialized elements, even discounting 2810 those that are not address constants (and thus *must* be 2811 computed at runtime), then partition the constructor into 2812 constant and non-constant parts. Block copy the constant 2813 parts in, then generate code for the non-constant parts. */ 2814 /* TODO. There's code in cp/typeck.c to do this. */ 2815 2816 num_type_elements = count_type_elements (type, true); 2817 2818 /* If count_type_elements could not determine number of type elements 2819 for a constant-sized object, assume clearing is needed. 2820 Don't do this for variable-sized objects, as store_constructor 2821 will ignore the clearing of variable-sized objects. */ 2822 if (num_type_elements < 0 && int_size_in_bytes (type) >= 0) 2823 cleared = true; 2824 /* If there are "lots" of zeros, then block clear the object first. */ 2825 else if (num_type_elements - num_nonzero_elements > CLEAR_RATIO 2826 && num_nonzero_elements < num_type_elements/4) 2827 cleared = true; 2828 /* ??? This bit ought not be needed. For any element not present 2829 in the initializer, we should simply set them to zero. Except 2830 we'd need to *find* the elements that are not present, and that 2831 requires trickery to avoid quadratic compile-time behavior in 2832 large cases or excessive memory use in small cases. */ 2833 else if (num_ctor_elements < num_type_elements) 2834 cleared = true; 2835 2836 /* If there are "lots" of initialized elements, and all of them 2837 are valid address constants, then the entire initializer can 2838 be dropped to memory, and then memcpy'd out. Don't do this 2839 for sparse arrays, though, as it's more efficient to follow 2840 the standard CONSTRUCTOR behavior of memset followed by 2841 individual element initialization. */ 2842 if (num_nonconstant_elements == 0 && !cleared) 2843 { 2844 HOST_WIDE_INT size = int_size_in_bytes (type); 2845 unsigned int align; 2846 2847 /* ??? We can still get unbounded array types, at least 2848 from the C++ front end. This seems wrong, but attempt 2849 to work around it for now. */ 2850 if (size < 0) 2851 { 2852 size = int_size_in_bytes (TREE_TYPE (object)); 2853 if (size >= 0) 2854 TREE_TYPE (ctor) = type = TREE_TYPE (object); 2855 } 2856 2857 /* Find the maximum alignment we can assume for the object. */ 2858 /* ??? Make use of DECL_OFFSET_ALIGN. */ 2859 if (DECL_P (object)) 2860 align = DECL_ALIGN (object); 2861 else 2862 align = TYPE_ALIGN (type); 2863 2864 if (size > 0 && !can_move_by_pieces (size, align)) 2865 { 2866 tree new = create_tmp_var_raw (type, "C"); 2867 2868 gimple_add_tmp_var (new); 2869 TREE_STATIC (new) = 1; 2870 TREE_READONLY (new) = 1; 2871 DECL_INITIAL (new) = ctor; 2872 if (align > DECL_ALIGN (new)) 2873 { 2874 DECL_ALIGN (new) = align; 2875 DECL_USER_ALIGN (new) = 1; 2876 } 2877 walk_tree (&DECL_INITIAL (new), force_labels_r, NULL, NULL); 2878 2879 TREE_OPERAND (*expr_p, 1) = new; 2880 2881 /* This is no longer an assignment of a CONSTRUCTOR, but 2882 we still may have processing to do on the LHS. So 2883 pretend we didn't do anything here to let that happen. */ 2884 return GS_UNHANDLED; 2885 } 2886 } 2887 2888 if (cleared) 2889 { 2890 /* Zap the CONSTRUCTOR element list, which simplifies this case. 2891 Note that we still have to gimplify, in order to handle the 2892 case of variable sized types. Avoid shared tree structures. */ 2893 CONSTRUCTOR_ELTS (ctor) = NULL; 2894 object = unshare_expr (object); 2895 gimplify_stmt (expr_p); 2896 append_to_statement_list (*expr_p, pre_p); 2897 } 2898 2899 /* If we have not block cleared the object, or if there are nonzero 2900 elements in the constructor, add assignments to the individual 2901 scalar fields of the object. */ 2902 if (!cleared || num_nonzero_elements > 0) 2903 { 2904 preeval_data.lhs_base_decl = get_base_address (object); 2905 if (!DECL_P (preeval_data.lhs_base_decl)) 2906 preeval_data.lhs_base_decl = NULL; 2907 preeval_data.lhs_alias_set = get_alias_set (object); 2908 2909 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1), 2910 pre_p, post_p, &preeval_data); 2911 gimplify_init_ctor_eval (object, elts, pre_p, cleared); 2912 } 2913 2914 *expr_p = NULL_TREE; 2915 } 2916 break; 2917 2918 case COMPLEX_TYPE: 2919 { 2920 tree r, i; 2921 2922 /* Extract the real and imaginary parts out of the ctor. */ 2923 gcc_assert (VEC_length (constructor_elt, elts) == 2); 2924 r = VEC_index (constructor_elt, elts, 0)->value; 2925 i = VEC_index (constructor_elt, elts, 1)->value; 2926 if (r == NULL || i == NULL) 2927 { 2928 tree zero = convert (TREE_TYPE (type), integer_zero_node); 2929 if (r == NULL) 2930 r = zero; 2931 if (i == NULL) 2932 i = zero; 2933 } 2934 2935 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to 2936 represent creation of a complex value. */ 2937 if (TREE_CONSTANT (r) && TREE_CONSTANT (i)) 2938 { 2939 ctor = build_complex (type, r, i); 2940 TREE_OPERAND (*expr_p, 1) = ctor; 2941 } 2942 else 2943 { 2944 ctor = build (COMPLEX_EXPR, type, r, i); 2945 TREE_OPERAND (*expr_p, 1) = ctor; 2946 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p, 2947 rhs_predicate_for (TREE_OPERAND (*expr_p, 0)), 2948 fb_rvalue); 2949 } 2950 } 2951 break; 2952 2953 case VECTOR_TYPE: 2954 { 2955 unsigned HOST_WIDE_INT ix; 2956 constructor_elt *ce; 2957 2958 /* Go ahead and simplify constant constructors to VECTOR_CST. */ 2959 if (TREE_CONSTANT (ctor)) 2960 { 2961 bool constant_p = true; 2962 tree value; 2963 2964 /* Even when ctor is constant, it might contain non-*_CST 2965 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't 2966 belong into VECTOR_CST nodes. */ 2967 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value) 2968 if (!CONSTANT_CLASS_P (value)) 2969 { 2970 constant_p = false; 2971 break; 2972 } 2973 2974 if (constant_p) 2975 { 2976 TREE_OPERAND (*expr_p, 1) = build_vector_from_ctor (type, elts); 2977 break; 2978 } 2979 } 2980 2981 /* Vector types use CONSTRUCTOR all the way through gimple 2982 compilation as a general initializer. */ 2983 for (ix = 0; VEC_iterate (constructor_elt, elts, ix, ce); ix++) 2984 { 2985 enum gimplify_status tret; 2986 tret = gimplify_expr (&ce->value, pre_p, post_p, 2987 is_gimple_val, fb_rvalue); 2988 if (tret == GS_ERROR) 2989 ret = GS_ERROR; 2990 } 2991 } 2992 break; 2993 2994 default: 2995 /* So how did we get a CONSTRUCTOR for a scalar type? */ 2996 gcc_unreachable (); 2997 } 2998 2999 if (ret == GS_ERROR) 3000 return GS_ERROR; 3001 else if (want_value) 3002 { 3003 append_to_statement_list (*expr_p, pre_p); 3004 *expr_p = object; 3005 return GS_OK; 3006 } 3007 else 3008 return GS_ALL_DONE; 3009} 3010 3011/* Given a pointer value OP0, return a simplified version of an 3012 indirection through OP0, or NULL_TREE if no simplification is 3013 possible. This may only be applied to a rhs of an expression. 3014 Note that the resulting type may be different from the type pointed 3015 to in the sense that it is still compatible from the langhooks 3016 point of view. */ 3017 3018static tree 3019fold_indirect_ref_rhs (tree t) 3020{ 3021 tree type = TREE_TYPE (TREE_TYPE (t)); 3022 tree sub = t; 3023 tree subtype; 3024 3025 STRIP_USELESS_TYPE_CONVERSION (sub); 3026 subtype = TREE_TYPE (sub); 3027 if (!POINTER_TYPE_P (subtype)) 3028 return NULL_TREE; 3029 3030 if (TREE_CODE (sub) == ADDR_EXPR) 3031 { 3032 tree op = TREE_OPERAND (sub, 0); 3033 tree optype = TREE_TYPE (op); 3034 /* *&p => p */ 3035 if (lang_hooks.types_compatible_p (type, optype)) 3036 return op; 3037 /* *(foo *)&fooarray => fooarray[0] */ 3038 else if (TREE_CODE (optype) == ARRAY_TYPE 3039 && lang_hooks.types_compatible_p (type, TREE_TYPE (optype))) 3040 { 3041 tree type_domain = TYPE_DOMAIN (optype); 3042 tree min_val = size_zero_node; 3043 if (type_domain && TYPE_MIN_VALUE (type_domain)) 3044 min_val = TYPE_MIN_VALUE (type_domain); 3045 return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE); 3046 } 3047 } 3048 3049 /* *(foo *)fooarrptr => (*fooarrptr)[0] */ 3050 if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE 3051 && lang_hooks.types_compatible_p (type, TREE_TYPE (TREE_TYPE (subtype)))) 3052 { 3053 tree type_domain; 3054 tree min_val = size_zero_node; 3055 tree osub = sub; 3056 sub = fold_indirect_ref_rhs (sub); 3057 if (! sub) 3058 sub = build1 (INDIRECT_REF, TREE_TYPE (subtype), osub); 3059 type_domain = TYPE_DOMAIN (TREE_TYPE (sub)); 3060 if (type_domain && TYPE_MIN_VALUE (type_domain)) 3061 min_val = TYPE_MIN_VALUE (type_domain); 3062 return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE); 3063 } 3064 3065 return NULL_TREE; 3066} 3067 3068/* Subroutine of gimplify_modify_expr to do simplifications of MODIFY_EXPRs 3069 based on the code of the RHS. We loop for as long as something changes. */ 3070 3071static enum gimplify_status 3072gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p, tree *pre_p, 3073 tree *post_p, bool want_value) 3074{ 3075 enum gimplify_status ret = GS_OK; 3076 3077 while (ret != GS_UNHANDLED) 3078 switch (TREE_CODE (*from_p)) 3079 { 3080 case INDIRECT_REF: 3081 { 3082 /* If we have code like 3083 3084 *(const A*)(A*)&x 3085 3086 where the type of "x" is a (possibly cv-qualified variant 3087 of "A"), treat the entire expression as identical to "x". 3088 This kind of code arises in C++ when an object is bound 3089 to a const reference, and if "x" is a TARGET_EXPR we want 3090 to take advantage of the optimization below. */ 3091 tree t = fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0)); 3092 if (t) 3093 { 3094 *from_p = t; 3095 ret = GS_OK; 3096 } 3097 else 3098 ret = GS_UNHANDLED; 3099 break; 3100 } 3101 3102 case TARGET_EXPR: 3103 { 3104 /* If we are initializing something from a TARGET_EXPR, strip the 3105 TARGET_EXPR and initialize it directly, if possible. This can't 3106 be done if the initializer is void, since that implies that the 3107 temporary is set in some non-trivial way. 3108 3109 ??? What about code that pulls out the temp and uses it 3110 elsewhere? I think that such code never uses the TARGET_EXPR as 3111 an initializer. If I'm wrong, we'll die because the temp won't 3112 have any RTL. In that case, I guess we'll need to replace 3113 references somehow. */ 3114 tree init = TARGET_EXPR_INITIAL (*from_p); 3115 3116 if (!VOID_TYPE_P (TREE_TYPE (init))) 3117 { 3118 *from_p = init; 3119 ret = GS_OK; 3120 } 3121 else 3122 ret = GS_UNHANDLED; 3123 } 3124 break; 3125 3126 case COMPOUND_EXPR: 3127 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be 3128 caught. */ 3129 gimplify_compound_expr (from_p, pre_p, true); 3130 ret = GS_OK; 3131 break; 3132 3133 case CONSTRUCTOR: 3134 /* If we're initializing from a CONSTRUCTOR, break this into 3135 individual MODIFY_EXPRs. */ 3136 return gimplify_init_constructor (expr_p, pre_p, post_p, want_value); 3137 3138 case COND_EXPR: 3139 /* If we're assigning to a non-register type, push the assignment 3140 down into the branches. This is mandatory for ADDRESSABLE types, 3141 since we cannot generate temporaries for such, but it saves a 3142 copy in other cases as well. */ 3143 if (!is_gimple_reg_type (TREE_TYPE (*from_p))) 3144 { 3145 /* This code should mirror the code in gimplify_cond_expr. */ 3146 enum tree_code code = TREE_CODE (*expr_p); 3147 tree cond = *from_p; 3148 tree result = *to_p; 3149 3150 ret = gimplify_expr (&result, pre_p, post_p, 3151 is_gimple_min_lval, fb_lvalue); 3152 if (ret != GS_ERROR) 3153 ret = GS_OK; 3154 3155 if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node) 3156 TREE_OPERAND (cond, 1) 3157 = build2 (code, void_type_node, result, 3158 TREE_OPERAND (cond, 1)); 3159 if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node) 3160 TREE_OPERAND (cond, 2) 3161 = build2 (code, void_type_node, unshare_expr (result), 3162 TREE_OPERAND (cond, 2)); 3163 3164 TREE_TYPE (cond) = void_type_node; 3165 recalculate_side_effects (cond); 3166 3167 if (want_value) 3168 { 3169 gimplify_and_add (cond, pre_p); 3170 *expr_p = unshare_expr (result); 3171 } 3172 else 3173 *expr_p = cond; 3174 return ret; 3175 } 3176 else 3177 ret = GS_UNHANDLED; 3178 break; 3179 3180 case CALL_EXPR: 3181 /* For calls that return in memory, give *to_p as the CALL_EXPR's 3182 return slot so that we don't generate a temporary. */ 3183 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p) 3184 && aggregate_value_p (*from_p, *from_p)) 3185 { 3186 bool use_target; 3187 3188 if (!(rhs_predicate_for (*to_p))(*from_p)) 3189 /* If we need a temporary, *to_p isn't accurate. */ 3190 use_target = false; 3191 else if (TREE_CODE (*to_p) == RESULT_DECL 3192 && DECL_NAME (*to_p) == NULL_TREE 3193 && needs_to_live_in_memory (*to_p)) 3194 /* It's OK to use the return slot directly unless it's an NRV. */ 3195 use_target = true; 3196 else if (is_gimple_reg_type (TREE_TYPE (*to_p)) 3197 || (DECL_P (*to_p) && DECL_REGISTER (*to_p))) 3198 /* Don't force regs into memory. */ 3199 use_target = false; 3200 else if (TREE_CODE (*to_p) == VAR_DECL 3201 && DECL_GIMPLE_FORMAL_TEMP_P (*to_p)) 3202 /* Don't use the original target if it's a formal temp; we 3203 don't want to take their addresses. */ 3204 use_target = false; 3205 else if (TREE_CODE (*expr_p) == INIT_EXPR) 3206 /* It's OK to use the target directly if it's being 3207 initialized. */ 3208 use_target = true; 3209 else if (!is_gimple_non_addressable (*to_p)) 3210 /* Don't use the original target if it's already addressable; 3211 if its address escapes, and the called function uses the 3212 NRV optimization, a conforming program could see *to_p 3213 change before the called function returns; see c++/19317. 3214 When optimizing, the return_slot pass marks more functions 3215 as safe after we have escape info. */ 3216 use_target = false; 3217 else 3218 use_target = true; 3219 3220 if (use_target) 3221 { 3222 CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1; 3223 lang_hooks.mark_addressable (*to_p); 3224 } 3225 } 3226 3227 ret = GS_UNHANDLED; 3228 break; 3229 3230 default: 3231 ret = GS_UNHANDLED; 3232 break; 3233 } 3234 3235 return ret; 3236} 3237 3238/* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is 3239 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with 3240 DECL_COMPLEX_GIMPLE_REG_P set. */ 3241 3242static enum gimplify_status 3243gimplify_modify_expr_complex_part (tree *expr_p, tree *pre_p, bool want_value) 3244{ 3245 enum tree_code code, ocode; 3246 tree lhs, rhs, new_rhs, other, realpart, imagpart; 3247 3248 lhs = TREE_OPERAND (*expr_p, 0); 3249 rhs = TREE_OPERAND (*expr_p, 1); 3250 code = TREE_CODE (lhs); 3251 lhs = TREE_OPERAND (lhs, 0); 3252 3253 ocode = code == REALPART_EXPR ? IMAGPART_EXPR : REALPART_EXPR; 3254 other = build1 (ocode, TREE_TYPE (rhs), lhs); 3255 other = get_formal_tmp_var (other, pre_p); 3256 3257 realpart = code == REALPART_EXPR ? rhs : other; 3258 imagpart = code == REALPART_EXPR ? other : rhs; 3259 3260 if (TREE_CONSTANT (realpart) && TREE_CONSTANT (imagpart)) 3261 new_rhs = build_complex (TREE_TYPE (lhs), realpart, imagpart); 3262 else 3263 new_rhs = build2 (COMPLEX_EXPR, TREE_TYPE (lhs), realpart, imagpart); 3264 3265 TREE_OPERAND (*expr_p, 0) = lhs; 3266 TREE_OPERAND (*expr_p, 1) = new_rhs; 3267 3268 if (want_value) 3269 { 3270 append_to_statement_list (*expr_p, pre_p); 3271 *expr_p = rhs; 3272 } 3273 3274 return GS_ALL_DONE; 3275} 3276 3277/* Gimplify the MODIFY_EXPR node pointed to by EXPR_P. 3278 3279 modify_expr 3280 : varname '=' rhs 3281 | '*' ID '=' rhs 3282 3283 PRE_P points to the list where side effects that must happen before 3284 *EXPR_P should be stored. 3285 3286 POST_P points to the list where side effects that must happen after 3287 *EXPR_P should be stored. 3288 3289 WANT_VALUE is nonzero iff we want to use the value of this expression 3290 in another expression. */ 3291 3292static enum gimplify_status 3293gimplify_modify_expr (tree *expr_p, tree *pre_p, tree *post_p, bool want_value) 3294{ 3295 tree *from_p = &TREE_OPERAND (*expr_p, 1); 3296 tree *to_p = &TREE_OPERAND (*expr_p, 0); 3297 enum gimplify_status ret = GS_UNHANDLED; 3298 3299 gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR 3300 || TREE_CODE (*expr_p) == INIT_EXPR); 3301 3302 /* For zero sized types only gimplify the left hand side and right hand side 3303 as statements and throw away the assignment. */ 3304 if (zero_sized_type (TREE_TYPE (*from_p))) 3305 { 3306 gimplify_stmt (from_p); 3307 gimplify_stmt (to_p); 3308 append_to_statement_list (*from_p, pre_p); 3309 append_to_statement_list (*to_p, pre_p); 3310 *expr_p = NULL_TREE; 3311 return GS_ALL_DONE; 3312 } 3313 3314 /* See if any simplifications can be done based on what the RHS is. */ 3315 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p, 3316 want_value); 3317 if (ret != GS_UNHANDLED) 3318 return ret; 3319 3320 /* If the value being copied is of variable width, compute the length 3321 of the copy into a WITH_SIZE_EXPR. Note that we need to do this 3322 before gimplifying any of the operands so that we can resolve any 3323 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses 3324 the size of the expression to be copied, not of the destination, so 3325 that is what we must here. */ 3326 maybe_with_size_expr (from_p); 3327 3328 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue); 3329 if (ret == GS_ERROR) 3330 return ret; 3331 3332 ret = gimplify_expr (from_p, pre_p, post_p, 3333 rhs_predicate_for (*to_p), fb_rvalue); 3334 if (ret == GS_ERROR) 3335 return ret; 3336 3337 /* Now see if the above changed *from_p to something we handle specially. */ 3338 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p, 3339 want_value); 3340 if (ret != GS_UNHANDLED) 3341 return ret; 3342 3343 /* If we've got a variable sized assignment between two lvalues (i.e. does 3344 not involve a call), then we can make things a bit more straightforward 3345 by converting the assignment to memcpy or memset. */ 3346 if (TREE_CODE (*from_p) == WITH_SIZE_EXPR) 3347 { 3348 tree from = TREE_OPERAND (*from_p, 0); 3349 tree size = TREE_OPERAND (*from_p, 1); 3350 3351 if (TREE_CODE (from) == CONSTRUCTOR) 3352 return gimplify_modify_expr_to_memset (expr_p, size, want_value); 3353 if (is_gimple_addressable (from)) 3354 { 3355 *from_p = from; 3356 return gimplify_modify_expr_to_memcpy (expr_p, size, want_value); 3357 } 3358 } 3359 3360 /* Transform partial stores to non-addressable complex variables into 3361 total stores. This allows us to use real instead of virtual operands 3362 for these variables, which improves optimization. */ 3363 if ((TREE_CODE (*to_p) == REALPART_EXPR 3364 || TREE_CODE (*to_p) == IMAGPART_EXPR) 3365 && is_gimple_reg (TREE_OPERAND (*to_p, 0))) 3366 return gimplify_modify_expr_complex_part (expr_p, pre_p, want_value); 3367 3368 if (gimplify_ctxp->into_ssa && is_gimple_reg (*to_p)) 3369 { 3370 /* If we've somehow already got an SSA_NAME on the LHS, then 3371 we're probably modified it twice. Not good. */ 3372 gcc_assert (TREE_CODE (*to_p) != SSA_NAME); 3373 *to_p = make_ssa_name (*to_p, *expr_p); 3374 } 3375 3376 if (want_value) 3377 { 3378 append_to_statement_list (*expr_p, pre_p); 3379 *expr_p = *to_p; 3380 return GS_OK; 3381 } 3382 3383 return GS_ALL_DONE; 3384} 3385 3386/* Gimplify a comparison between two variable-sized objects. Do this 3387 with a call to BUILT_IN_MEMCMP. */ 3388 3389static enum gimplify_status 3390gimplify_variable_sized_compare (tree *expr_p) 3391{ 3392 tree op0 = TREE_OPERAND (*expr_p, 0); 3393 tree op1 = TREE_OPERAND (*expr_p, 1); 3394 tree args, t, dest; 3395 3396 t = TYPE_SIZE_UNIT (TREE_TYPE (op0)); 3397 t = unshare_expr (t); 3398 t = SUBSTITUTE_PLACEHOLDER_IN_EXPR (t, op0); 3399 args = tree_cons (NULL, t, NULL); 3400 t = build_fold_addr_expr (op1); 3401 args = tree_cons (NULL, t, args); 3402 dest = build_fold_addr_expr (op0); 3403 args = tree_cons (NULL, dest, args); 3404 t = implicit_built_in_decls[BUILT_IN_MEMCMP]; 3405 t = build_function_call_expr (t, args); 3406 *expr_p 3407 = build (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node); 3408 3409 return GS_OK; 3410} 3411 3412/* Gimplify TRUTH_ANDIF_EXPR and TRUTH_ORIF_EXPR expressions. EXPR_P 3413 points to the expression to gimplify. 3414 3415 Expressions of the form 'a && b' are gimplified to: 3416 3417 a && b ? true : false 3418 3419 gimplify_cond_expr will do the rest. 3420 3421 PRE_P points to the list where side effects that must happen before 3422 *EXPR_P should be stored. */ 3423 3424static enum gimplify_status 3425gimplify_boolean_expr (tree *expr_p) 3426{ 3427 /* Preserve the original type of the expression. */ 3428 tree type = TREE_TYPE (*expr_p); 3429 3430 *expr_p = build (COND_EXPR, type, *expr_p, 3431 convert (type, boolean_true_node), 3432 convert (type, boolean_false_node)); 3433 3434 return GS_OK; 3435} 3436 3437/* Gimplifies an expression sequence. This function gimplifies each 3438 expression and re-writes the original expression with the last 3439 expression of the sequence in GIMPLE form. 3440 3441 PRE_P points to the list where the side effects for all the 3442 expressions in the sequence will be emitted. 3443 3444 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */ 3445/* ??? Should rearrange to share the pre-queue with all the indirect 3446 invocations of gimplify_expr. Would probably save on creations 3447 of statement_list nodes. */ 3448 3449static enum gimplify_status 3450gimplify_compound_expr (tree *expr_p, tree *pre_p, bool want_value) 3451{ 3452 tree t = *expr_p; 3453 3454 do 3455 { 3456 tree *sub_p = &TREE_OPERAND (t, 0); 3457 3458 if (TREE_CODE (*sub_p) == COMPOUND_EXPR) 3459 gimplify_compound_expr (sub_p, pre_p, false); 3460 else 3461 gimplify_stmt (sub_p); 3462 append_to_statement_list (*sub_p, pre_p); 3463 3464 t = TREE_OPERAND (t, 1); 3465 } 3466 while (TREE_CODE (t) == COMPOUND_EXPR); 3467 3468 *expr_p = t; 3469 if (want_value) 3470 return GS_OK; 3471 else 3472 { 3473 gimplify_stmt (expr_p); 3474 return GS_ALL_DONE; 3475 } 3476} 3477 3478/* Gimplifies a statement list. These may be created either by an 3479 enlightened front-end, or by shortcut_cond_expr. */ 3480 3481static enum gimplify_status 3482gimplify_statement_list (tree *expr_p) 3483{ 3484 tree_stmt_iterator i = tsi_start (*expr_p); 3485 3486 while (!tsi_end_p (i)) 3487 { 3488 tree t; 3489 3490 gimplify_stmt (tsi_stmt_ptr (i)); 3491 3492 t = tsi_stmt (i); 3493 if (t == NULL) 3494 tsi_delink (&i); 3495 else if (TREE_CODE (t) == STATEMENT_LIST) 3496 { 3497 tsi_link_before (&i, t, TSI_SAME_STMT); 3498 tsi_delink (&i); 3499 } 3500 else 3501 tsi_next (&i); 3502 } 3503 3504 return GS_ALL_DONE; 3505} 3506 3507/* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to 3508 gimplify. After gimplification, EXPR_P will point to a new temporary 3509 that holds the original value of the SAVE_EXPR node. 3510 3511 PRE_P points to the list where side effects that must happen before 3512 *EXPR_P should be stored. */ 3513 3514static enum gimplify_status 3515gimplify_save_expr (tree *expr_p, tree *pre_p, tree *post_p) 3516{ 3517 enum gimplify_status ret = GS_ALL_DONE; 3518 tree val; 3519 3520 gcc_assert (TREE_CODE (*expr_p) == SAVE_EXPR); 3521 val = TREE_OPERAND (*expr_p, 0); 3522 3523 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */ 3524 if (!SAVE_EXPR_RESOLVED_P (*expr_p)) 3525 { 3526 /* The operand may be a void-valued expression such as SAVE_EXPRs 3527 generated by the Java frontend for class initialization. It is 3528 being executed only for its side-effects. */ 3529 if (TREE_TYPE (val) == void_type_node) 3530 { 3531 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, 3532 is_gimple_stmt, fb_none); 3533 append_to_statement_list (TREE_OPERAND (*expr_p, 0), pre_p); 3534 val = NULL; 3535 } 3536 else 3537 val = get_initialized_tmp_var (val, pre_p, post_p); 3538 3539 TREE_OPERAND (*expr_p, 0) = val; 3540 SAVE_EXPR_RESOLVED_P (*expr_p) = 1; 3541 } 3542 3543 *expr_p = val; 3544 3545 return ret; 3546} 3547 3548/* Re-write the ADDR_EXPR node pointed to by EXPR_P 3549 3550 unary_expr 3551 : ... 3552 | '&' varname 3553 ... 3554 3555 PRE_P points to the list where side effects that must happen before 3556 *EXPR_P should be stored. 3557 3558 POST_P points to the list where side effects that must happen after 3559 *EXPR_P should be stored. */ 3560 3561static enum gimplify_status 3562gimplify_addr_expr (tree *expr_p, tree *pre_p, tree *post_p) 3563{ 3564 tree expr = *expr_p; 3565 tree op0 = TREE_OPERAND (expr, 0); 3566 enum gimplify_status ret; 3567 3568 switch (TREE_CODE (op0)) 3569 { 3570 case INDIRECT_REF: 3571 case MISALIGNED_INDIRECT_REF: 3572 do_indirect_ref: 3573 /* Check if we are dealing with an expression of the form '&*ptr'. 3574 While the front end folds away '&*ptr' into 'ptr', these 3575 expressions may be generated internally by the compiler (e.g., 3576 builtins like __builtin_va_end). */ 3577 /* Caution: the silent array decomposition semantics we allow for 3578 ADDR_EXPR means we can't always discard the pair. */ 3579 /* Gimplification of the ADDR_EXPR operand may drop 3580 cv-qualification conversions, so make sure we add them if 3581 needed. */ 3582 { 3583 tree op00 = TREE_OPERAND (op0, 0); 3584 tree t_expr = TREE_TYPE (expr); 3585 tree t_op00 = TREE_TYPE (op00); 3586 3587 if (!lang_hooks.types_compatible_p (t_expr, t_op00)) 3588 { 3589#ifdef ENABLE_CHECKING 3590 tree t_op0 = TREE_TYPE (op0); 3591 gcc_assert (POINTER_TYPE_P (t_expr) 3592 && cpt_same_type (TREE_CODE (t_op0) == ARRAY_TYPE 3593 ? TREE_TYPE (t_op0) : t_op0, 3594 TREE_TYPE (t_expr)) 3595 && POINTER_TYPE_P (t_op00) 3596 && cpt_same_type (t_op0, TREE_TYPE (t_op00))); 3597#endif 3598 op00 = fold_convert (TREE_TYPE (expr), op00); 3599 } 3600 *expr_p = op00; 3601 ret = GS_OK; 3602 } 3603 break; 3604 3605 case VIEW_CONVERT_EXPR: 3606 /* Take the address of our operand and then convert it to the type of 3607 this ADDR_EXPR. 3608 3609 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at 3610 all clear. The impact of this transformation is even less clear. */ 3611 3612 /* If the operand is a useless conversion, look through it. Doing so 3613 guarantees that the ADDR_EXPR and its operand will remain of the 3614 same type. */ 3615 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0, 0))) 3616 op0 = TREE_OPERAND (op0, 0); 3617 3618 *expr_p = fold_convert (TREE_TYPE (expr), 3619 build_fold_addr_expr (TREE_OPERAND (op0, 0))); 3620 ret = GS_OK; 3621 break; 3622 3623 default: 3624 /* We use fb_either here because the C frontend sometimes takes 3625 the address of a call that returns a struct; see 3626 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make 3627 the implied temporary explicit. */ 3628 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, post_p, 3629 is_gimple_addressable, fb_either); 3630 if (ret != GS_ERROR) 3631 { 3632 op0 = TREE_OPERAND (expr, 0); 3633 3634 /* For various reasons, the gimplification of the expression 3635 may have made a new INDIRECT_REF. */ 3636 if (TREE_CODE (op0) == INDIRECT_REF) 3637 goto do_indirect_ref; 3638 3639 /* Make sure TREE_INVARIANT, TREE_CONSTANT, and TREE_SIDE_EFFECTS 3640 is set properly. */ 3641 recompute_tree_invarant_for_addr_expr (expr); 3642 3643 /* Mark the RHS addressable. */ 3644 lang_hooks.mark_addressable (TREE_OPERAND (expr, 0)); 3645 } 3646 break; 3647 } 3648 3649 return ret; 3650} 3651 3652/* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple 3653 value; output operands should be a gimple lvalue. */ 3654 3655static enum gimplify_status 3656gimplify_asm_expr (tree *expr_p, tree *pre_p, tree *post_p) 3657{ 3658 tree expr = *expr_p; 3659 int noutputs = list_length (ASM_OUTPUTS (expr)); 3660 const char **oconstraints 3661 = (const char **) alloca ((noutputs) * sizeof (const char *)); 3662 int i; 3663 tree link; 3664 const char *constraint; 3665 bool allows_mem, allows_reg, is_inout; 3666 enum gimplify_status ret, tret; 3667 3668 ret = GS_ALL_DONE; 3669 for (i = 0, link = ASM_OUTPUTS (expr); link; ++i, link = TREE_CHAIN (link)) 3670 { 3671 size_t constraint_len; 3672 oconstraints[i] = constraint 3673 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link))); 3674 constraint_len = strlen (constraint); 3675 if (constraint_len == 0) 3676 continue; 3677 3678 parse_output_constraint (&constraint, i, 0, 0, 3679 &allows_mem, &allows_reg, &is_inout); 3680 3681 if (!allows_reg && allows_mem) 3682 lang_hooks.mark_addressable (TREE_VALUE (link)); 3683 3684 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p, 3685 is_inout ? is_gimple_min_lval : is_gimple_lvalue, 3686 fb_lvalue | fb_mayfail); 3687 if (tret == GS_ERROR) 3688 { 3689 error ("invalid lvalue in asm output %d", i); 3690 ret = tret; 3691 } 3692 3693 if (is_inout) 3694 { 3695 /* An input/output operand. To give the optimizers more 3696 flexibility, split it into separate input and output 3697 operands. */ 3698 tree input; 3699 char buf[10]; 3700 3701 /* Turn the in/out constraint into an output constraint. */ 3702 char *p = xstrdup (constraint); 3703 p[0] = '='; 3704 TREE_VALUE (TREE_PURPOSE (link)) = build_string (constraint_len, p); 3705 3706 /* And add a matching input constraint. */ 3707 if (allows_reg) 3708 { 3709 sprintf (buf, "%d", i); 3710 3711 /* If there are multiple alternatives in the constraint, 3712 handle each of them individually. Those that allow register 3713 will be replaced with operand number, the others will stay 3714 unchanged. */ 3715 if (strchr (p, ',') != NULL) 3716 { 3717 size_t len = 0, buflen = strlen (buf); 3718 char *beg, *end, *str, *dst; 3719 3720 for (beg = p + 1;;) 3721 { 3722 end = strchr (beg, ','); 3723 if (end == NULL) 3724 end = strchr (beg, '\0'); 3725 if ((size_t) (end - beg) < buflen) 3726 len += buflen + 1; 3727 else 3728 len += end - beg + 1; 3729 if (*end) 3730 beg = end + 1; 3731 else 3732 break; 3733 } 3734 3735 str = alloca (len); 3736 for (beg = p + 1, dst = str;;) 3737 { 3738 const char *tem; 3739 bool mem_p, reg_p, inout_p; 3740 3741 end = strchr (beg, ','); 3742 if (end) 3743 *end = '\0'; 3744 beg[-1] = '='; 3745 tem = beg - 1; 3746 parse_output_constraint (&tem, i, 0, 0, 3747 &mem_p, ®_p, &inout_p); 3748 if (dst != str) 3749 *dst++ = ','; 3750 if (reg_p) 3751 { 3752 memcpy (dst, buf, buflen); 3753 dst += buflen; 3754 } 3755 else 3756 { 3757 if (end) 3758 len = end - beg; 3759 else 3760 len = strlen (beg); 3761 memcpy (dst, beg, len); 3762 dst += len; 3763 } 3764 if (end) 3765 beg = end + 1; 3766 else 3767 break; 3768 } 3769 *dst = '\0'; 3770 input = build_string (dst - str, str); 3771 } 3772 else 3773 input = build_string (strlen (buf), buf); 3774 } 3775 else 3776 input = build_string (constraint_len - 1, constraint + 1); 3777 3778 free (p); 3779 3780 input = build_tree_list (build_tree_list (NULL_TREE, input), 3781 unshare_expr (TREE_VALUE (link))); 3782 ASM_INPUTS (expr) = chainon (ASM_INPUTS (expr), input); 3783 } 3784 } 3785 3786 for (link = ASM_INPUTS (expr); link; ++i, link = TREE_CHAIN (link)) 3787 { 3788 constraint 3789 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link))); 3790 parse_input_constraint (&constraint, 0, 0, noutputs, 0, 3791 oconstraints, &allows_mem, &allows_reg); 3792 3793 /* If we can't make copies, we can only accept memory. */ 3794 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link)))) 3795 { 3796 if (allows_mem) 3797 allows_reg = 0; 3798 else 3799 { 3800 error ("impossible constraint in %<asm%>"); 3801 error ("non-memory input %d must stay in memory", i); 3802 return GS_ERROR; 3803 } 3804 } 3805 3806 /* If the operand is a memory input, it should be an lvalue. */ 3807 if (!allows_reg && allows_mem) 3808 { 3809 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p, 3810 is_gimple_lvalue, fb_lvalue | fb_mayfail); 3811 lang_hooks.mark_addressable (TREE_VALUE (link)); 3812 if (tret == GS_ERROR) 3813 { 3814 error ("memory input %d is not directly addressable", i); 3815 ret = tret; 3816 } 3817 } 3818 else 3819 { 3820 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p, 3821 is_gimple_asm_val, fb_rvalue); 3822 if (tret == GS_ERROR) 3823 ret = tret; 3824 } 3825 } 3826 3827 return ret; 3828} 3829 3830/* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding 3831 WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while 3832 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we 3833 return to this function. 3834 3835 FIXME should we complexify the prequeue handling instead? Or use flags 3836 for all the cleanups and let the optimizer tighten them up? The current 3837 code seems pretty fragile; it will break on a cleanup within any 3838 non-conditional nesting. But any such nesting would be broken, anyway; 3839 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct 3840 and continues out of it. We can do that at the RTL level, though, so 3841 having an optimizer to tighten up try/finally regions would be a Good 3842 Thing. */ 3843 3844static enum gimplify_status 3845gimplify_cleanup_point_expr (tree *expr_p, tree *pre_p) 3846{ 3847 tree_stmt_iterator iter; 3848 tree body; 3849 3850 tree temp = voidify_wrapper_expr (*expr_p, NULL); 3851 3852 /* We only care about the number of conditions between the innermost 3853 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and 3854 any cleanups collected outside the CLEANUP_POINT_EXPR. */ 3855 int old_conds = gimplify_ctxp->conditions; 3856 tree old_cleanups = gimplify_ctxp->conditional_cleanups; 3857 gimplify_ctxp->conditions = 0; 3858 gimplify_ctxp->conditional_cleanups = NULL_TREE; 3859 3860 body = TREE_OPERAND (*expr_p, 0); 3861 gimplify_to_stmt_list (&body); 3862 3863 gimplify_ctxp->conditions = old_conds; 3864 gimplify_ctxp->conditional_cleanups = old_cleanups; 3865 3866 for (iter = tsi_start (body); !tsi_end_p (iter); ) 3867 { 3868 tree *wce_p = tsi_stmt_ptr (iter); 3869 tree wce = *wce_p; 3870 3871 if (TREE_CODE (wce) == WITH_CLEANUP_EXPR) 3872 { 3873 if (tsi_one_before_end_p (iter)) 3874 { 3875 tsi_link_before (&iter, TREE_OPERAND (wce, 0), TSI_SAME_STMT); 3876 tsi_delink (&iter); 3877 break; 3878 } 3879 else 3880 { 3881 tree sl, tfe; 3882 enum tree_code code; 3883 3884 if (CLEANUP_EH_ONLY (wce)) 3885 code = TRY_CATCH_EXPR; 3886 else 3887 code = TRY_FINALLY_EXPR; 3888 3889 sl = tsi_split_statement_list_after (&iter); 3890 tfe = build (code, void_type_node, sl, NULL_TREE); 3891 append_to_statement_list (TREE_OPERAND (wce, 0), 3892 &TREE_OPERAND (tfe, 1)); 3893 *wce_p = tfe; 3894 iter = tsi_start (sl); 3895 } 3896 } 3897 else 3898 tsi_next (&iter); 3899 } 3900 3901 if (temp) 3902 { 3903 *expr_p = temp; 3904 append_to_statement_list (body, pre_p); 3905 return GS_OK; 3906 } 3907 else 3908 { 3909 *expr_p = body; 3910 return GS_ALL_DONE; 3911 } 3912} 3913 3914/* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP 3915 is the cleanup action required. */ 3916 3917static void 3918gimple_push_cleanup (tree var, tree cleanup, bool eh_only, tree *pre_p) 3919{ 3920 tree wce; 3921 3922 /* Errors can result in improperly nested cleanups. Which results in 3923 confusion when trying to resolve the WITH_CLEANUP_EXPR. */ 3924 if (errorcount || sorrycount) 3925 return; 3926 3927 if (gimple_conditional_context ()) 3928 { 3929 /* If we're in a conditional context, this is more complex. We only 3930 want to run the cleanup if we actually ran the initialization that 3931 necessitates it, but we want to run it after the end of the 3932 conditional context. So we wrap the try/finally around the 3933 condition and use a flag to determine whether or not to actually 3934 run the destructor. Thus 3935 3936 test ? f(A()) : 0 3937 3938 becomes (approximately) 3939 3940 flag = 0; 3941 try { 3942 if (test) { A::A(temp); flag = 1; val = f(temp); } 3943 else { val = 0; } 3944 } finally { 3945 if (flag) A::~A(temp); 3946 } 3947 val 3948 */ 3949 3950 tree flag = create_tmp_var (boolean_type_node, "cleanup"); 3951 tree ffalse = build (MODIFY_EXPR, void_type_node, flag, 3952 boolean_false_node); 3953 tree ftrue = build (MODIFY_EXPR, void_type_node, flag, 3954 boolean_true_node); 3955 cleanup = build (COND_EXPR, void_type_node, flag, cleanup, NULL); 3956 wce = build (WITH_CLEANUP_EXPR, void_type_node, cleanup); 3957 append_to_statement_list (ffalse, &gimplify_ctxp->conditional_cleanups); 3958 append_to_statement_list (wce, &gimplify_ctxp->conditional_cleanups); 3959 append_to_statement_list (ftrue, pre_p); 3960 3961 /* Because of this manipulation, and the EH edges that jump 3962 threading cannot redirect, the temporary (VAR) will appear 3963 to be used uninitialized. Don't warn. */ 3964 TREE_NO_WARNING (var) = 1; 3965 } 3966 else 3967 { 3968 wce = build (WITH_CLEANUP_EXPR, void_type_node, cleanup); 3969 CLEANUP_EH_ONLY (wce) = eh_only; 3970 append_to_statement_list (wce, pre_p); 3971 } 3972 3973 gimplify_stmt (&TREE_OPERAND (wce, 0)); 3974} 3975 3976/* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */ 3977 3978static enum gimplify_status 3979gimplify_target_expr (tree *expr_p, tree *pre_p, tree *post_p) 3980{ 3981 tree targ = *expr_p; 3982 tree temp = TARGET_EXPR_SLOT (targ); 3983 tree init = TARGET_EXPR_INITIAL (targ); 3984 enum gimplify_status ret; 3985 3986 if (init) 3987 { 3988 /* TARGET_EXPR temps aren't part of the enclosing block, so add it 3989 to the temps list. */ 3990 gimple_add_tmp_var (temp); 3991 3992 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the 3993 expression is supposed to initialize the slot. */ 3994 if (VOID_TYPE_P (TREE_TYPE (init))) 3995 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none); 3996 else 3997 { 3998 /* Special handling for BIND_EXPR can result in fewer temps. */ 3999 ret = GS_OK; 4000 if (TREE_CODE (init) == BIND_EXPR) 4001 gimplify_bind_expr (&init, temp, pre_p); 4002 if (init != temp) 4003 { 4004 init = build2 (INIT_EXPR, void_type_node, temp, init); 4005 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, 4006 fb_none); 4007 } 4008 } 4009 if (ret == GS_ERROR) 4010 return GS_ERROR; 4011 append_to_statement_list (init, pre_p); 4012 4013 /* If needed, push the cleanup for the temp. */ 4014 if (TARGET_EXPR_CLEANUP (targ)) 4015 { 4016 gimplify_stmt (&TARGET_EXPR_CLEANUP (targ)); 4017 gimple_push_cleanup (temp, TARGET_EXPR_CLEANUP (targ), 4018 CLEANUP_EH_ONLY (targ), pre_p); 4019 } 4020 4021 /* Only expand this once. */ 4022 TREE_OPERAND (targ, 3) = init; 4023 TARGET_EXPR_INITIAL (targ) = NULL_TREE; 4024 } 4025 else 4026 /* We should have expanded this before. */ 4027 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp)); 4028 4029 *expr_p = temp; 4030 return GS_OK; 4031} 4032 4033/* Gimplification of expression trees. */ 4034 4035/* Gimplify an expression which appears at statement context; usually, this 4036 means replacing it with a suitably gimple STATEMENT_LIST. */ 4037 4038void 4039gimplify_stmt (tree *stmt_p) 4040{ 4041 gimplify_expr (stmt_p, NULL, NULL, is_gimple_stmt, fb_none); 4042} 4043 4044/* Similarly, but force the result to be a STATEMENT_LIST. */ 4045 4046void 4047gimplify_to_stmt_list (tree *stmt_p) 4048{ 4049 gimplify_stmt (stmt_p); 4050 if (!*stmt_p) 4051 *stmt_p = alloc_stmt_list (); 4052 else if (TREE_CODE (*stmt_p) != STATEMENT_LIST) 4053 { 4054 tree t = *stmt_p; 4055 *stmt_p = alloc_stmt_list (); 4056 append_to_statement_list (t, stmt_p); 4057 } 4058} 4059 4060 4061/* Gimplifies the expression tree pointed to by EXPR_P. Return 0 if 4062 gimplification failed. 4063 4064 PRE_P points to the list where side effects that must happen before 4065 EXPR should be stored. 4066 4067 POST_P points to the list where side effects that must happen after 4068 EXPR should be stored, or NULL if there is no suitable list. In 4069 that case, we copy the result to a temporary, emit the 4070 post-effects, and then return the temporary. 4071 4072 GIMPLE_TEST_F points to a function that takes a tree T and 4073 returns nonzero if T is in the GIMPLE form requested by the 4074 caller. The GIMPLE predicates are in tree-gimple.c. 4075 4076 This test is used twice. Before gimplification, the test is 4077 invoked to determine whether *EXPR_P is already gimple enough. If 4078 that fails, *EXPR_P is gimplified according to its code and 4079 GIMPLE_TEST_F is called again. If the test still fails, then a new 4080 temporary variable is created and assigned the value of the 4081 gimplified expression. 4082 4083 FALLBACK tells the function what sort of a temporary we want. If the 1 4084 bit is set, an rvalue is OK. If the 2 bit is set, an lvalue is OK. 4085 If both are set, either is OK, but an lvalue is preferable. 4086 4087 The return value is either GS_ERROR or GS_ALL_DONE, since this function 4088 iterates until solution. */ 4089 4090enum gimplify_status 4091gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p, 4092 bool (* gimple_test_f) (tree), fallback_t fallback) 4093{ 4094 tree tmp; 4095 tree internal_pre = NULL_TREE; 4096 tree internal_post = NULL_TREE; 4097 tree save_expr; 4098 int is_statement = (pre_p == NULL); 4099 location_t saved_location; 4100 enum gimplify_status ret; 4101 4102 save_expr = *expr_p; 4103 if (save_expr == NULL_TREE) 4104 return GS_ALL_DONE; 4105 4106 /* We used to check the predicate here and return immediately if it 4107 succeeds. This is wrong; the design is for gimplification to be 4108 idempotent, and for the predicates to only test for valid forms, not 4109 whether they are fully simplified. */ 4110 4111 /* Set up our internal queues if needed. */ 4112 if (pre_p == NULL) 4113 pre_p = &internal_pre; 4114 if (post_p == NULL) 4115 post_p = &internal_post; 4116 4117 saved_location = input_location; 4118 if (save_expr != error_mark_node 4119 && EXPR_HAS_LOCATION (*expr_p)) 4120 input_location = EXPR_LOCATION (*expr_p); 4121 4122 /* Loop over the specific gimplifiers until the toplevel node 4123 remains the same. */ 4124 do 4125 { 4126 /* Strip away as many useless type conversions as possible 4127 at the toplevel. */ 4128 STRIP_USELESS_TYPE_CONVERSION (*expr_p); 4129 4130 /* Remember the expr. */ 4131 save_expr = *expr_p; 4132 4133 /* Die, die, die, my darling. */ 4134 if (save_expr == error_mark_node 4135 || (TREE_TYPE (save_expr) 4136 && TREE_TYPE (save_expr) == error_mark_node)) 4137 { 4138 ret = GS_ERROR; 4139 break; 4140 } 4141 4142 /* Do any language-specific gimplification. */ 4143 ret = lang_hooks.gimplify_expr (expr_p, pre_p, post_p); 4144 if (ret == GS_OK) 4145 { 4146 if (*expr_p == NULL_TREE) 4147 break; 4148 if (*expr_p != save_expr) 4149 continue; 4150 } 4151 else if (ret != GS_UNHANDLED) 4152 break; 4153 4154 ret = GS_OK; 4155 switch (TREE_CODE (*expr_p)) 4156 { 4157 /* First deal with the special cases. */ 4158 4159 case POSTINCREMENT_EXPR: 4160 case POSTDECREMENT_EXPR: 4161 case PREINCREMENT_EXPR: 4162 case PREDECREMENT_EXPR: 4163 ret = gimplify_self_mod_expr (expr_p, pre_p, post_p, 4164 fallback != fb_none); 4165 break; 4166 4167 case ARRAY_REF: 4168 case ARRAY_RANGE_REF: 4169 case REALPART_EXPR: 4170 case IMAGPART_EXPR: 4171 case COMPONENT_REF: 4172 case VIEW_CONVERT_EXPR: 4173 ret = gimplify_compound_lval (expr_p, pre_p, post_p, 4174 fallback ? fallback : fb_rvalue); 4175 break; 4176 4177 case COND_EXPR: 4178 ret = gimplify_cond_expr (expr_p, pre_p, fallback); 4179 /* C99 code may assign to an array in a structure value of a 4180 conditional expression, and this has undefined behavior 4181 only on execution, so create a temporary if an lvalue is 4182 required. */ 4183 if (fallback == fb_lvalue) 4184 { 4185 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p); 4186 lang_hooks.mark_addressable (*expr_p); 4187 } 4188 break; 4189 4190 case CALL_EXPR: 4191 ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none); 4192 /* C99 code may assign to an array in a structure returned 4193 from a function, and this has undefined behavior only on 4194 execution, so create a temporary if an lvalue is 4195 required. */ 4196 if (fallback == fb_lvalue) 4197 { 4198 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p); 4199 lang_hooks.mark_addressable (*expr_p); 4200 } 4201 break; 4202 4203 case TREE_LIST: 4204 gcc_unreachable (); 4205 4206 case COMPOUND_EXPR: 4207 ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none); 4208 break; 4209 4210 case MODIFY_EXPR: 4211 case INIT_EXPR: 4212 ret = gimplify_modify_expr (expr_p, pre_p, post_p, 4213 fallback != fb_none); 4214 4215 /* The distinction between MODIFY_EXPR and INIT_EXPR is no longer 4216 useful. */ 4217 if (*expr_p && TREE_CODE (*expr_p) == INIT_EXPR) 4218 TREE_SET_CODE (*expr_p, MODIFY_EXPR); 4219 break; 4220 4221 case TRUTH_ANDIF_EXPR: 4222 case TRUTH_ORIF_EXPR: 4223 ret = gimplify_boolean_expr (expr_p); 4224 break; 4225 4226 case TRUTH_NOT_EXPR: 4227 TREE_OPERAND (*expr_p, 0) 4228 = gimple_boolify (TREE_OPERAND (*expr_p, 0)); 4229 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, 4230 is_gimple_val, fb_rvalue); 4231 recalculate_side_effects (*expr_p); 4232 break; 4233 4234 case ADDR_EXPR: 4235 ret = gimplify_addr_expr (expr_p, pre_p, post_p); 4236 break; 4237 4238 case VA_ARG_EXPR: 4239 ret = gimplify_va_arg_expr (expr_p, pre_p, post_p); 4240 break; 4241 4242 case CONVERT_EXPR: 4243 case NOP_EXPR: 4244 if (IS_EMPTY_STMT (*expr_p)) 4245 { 4246 ret = GS_ALL_DONE; 4247 break; 4248 } 4249 4250 if (VOID_TYPE_P (TREE_TYPE (*expr_p)) 4251 || fallback == fb_none) 4252 { 4253 /* Just strip a conversion to void (or in void context) and 4254 try again. */ 4255 *expr_p = TREE_OPERAND (*expr_p, 0); 4256 break; 4257 } 4258 4259 ret = gimplify_conversion (expr_p); 4260 if (ret == GS_ERROR) 4261 break; 4262 if (*expr_p != save_expr) 4263 break; 4264 /* FALLTHRU */ 4265 4266 case FIX_TRUNC_EXPR: 4267 case FIX_CEIL_EXPR: 4268 case FIX_FLOOR_EXPR: 4269 case FIX_ROUND_EXPR: 4270 /* unary_expr: ... | '(' cast ')' val | ... */ 4271 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, 4272 is_gimple_val, fb_rvalue); 4273 recalculate_side_effects (*expr_p); 4274 break; 4275 4276 case INDIRECT_REF: 4277 *expr_p = fold_indirect_ref (*expr_p); 4278 if (*expr_p != save_expr) 4279 break; 4280 /* else fall through. */ 4281 case ALIGN_INDIRECT_REF: 4282 case MISALIGNED_INDIRECT_REF: 4283 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, 4284 is_gimple_reg, fb_rvalue); 4285 recalculate_side_effects (*expr_p); 4286 break; 4287 4288 /* Constants need not be gimplified. */ 4289 case INTEGER_CST: 4290 case REAL_CST: 4291 case STRING_CST: 4292 case COMPLEX_CST: 4293 case VECTOR_CST: 4294 ret = GS_ALL_DONE; 4295 break; 4296 4297 case CONST_DECL: 4298 /* If we require an lvalue, such as for ADDR_EXPR, retain the 4299 CONST_DECL node. Otherwise the decl is replaceable by its 4300 value. */ 4301 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */ 4302 if (fallback & fb_lvalue) 4303 ret = GS_ALL_DONE; 4304 else 4305 *expr_p = DECL_INITIAL (*expr_p); 4306 break; 4307 4308 case DECL_EXPR: 4309 ret = gimplify_decl_expr (expr_p); 4310 break; 4311 4312 case EXC_PTR_EXPR: 4313 /* FIXME make this a decl. */ 4314 ret = GS_ALL_DONE; 4315 break; 4316 4317 case BIND_EXPR: 4318 ret = gimplify_bind_expr (expr_p, NULL, pre_p); 4319 break; 4320 4321 case LOOP_EXPR: 4322 ret = gimplify_loop_expr (expr_p, pre_p); 4323 break; 4324 4325 case SWITCH_EXPR: 4326 ret = gimplify_switch_expr (expr_p, pre_p); 4327 break; 4328 4329 case EXIT_EXPR: 4330 ret = gimplify_exit_expr (expr_p); 4331 break; 4332 4333 case GOTO_EXPR: 4334 /* If the target is not LABEL, then it is a computed jump 4335 and the target needs to be gimplified. */ 4336 if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL) 4337 ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p, 4338 NULL, is_gimple_val, fb_rvalue); 4339 break; 4340 4341 case LABEL_EXPR: 4342 ret = GS_ALL_DONE; 4343 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p)) 4344 == current_function_decl); 4345 break; 4346 4347 case CASE_LABEL_EXPR: 4348 ret = gimplify_case_label_expr (expr_p); 4349 break; 4350 4351 case RETURN_EXPR: 4352 ret = gimplify_return_expr (*expr_p, pre_p); 4353 break; 4354 4355 case CONSTRUCTOR: 4356 /* Don't reduce this in place; let gimplify_init_constructor work its 4357 magic. Buf if we're just elaborating this for side effects, just 4358 gimplify any element that has side-effects. */ 4359 if (fallback == fb_none) 4360 { 4361 unsigned HOST_WIDE_INT ix; 4362 constructor_elt *ce; 4363 tree temp = NULL_TREE; 4364 for (ix = 0; 4365 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (*expr_p), 4366 ix, ce); 4367 ix++) 4368 if (TREE_SIDE_EFFECTS (ce->value)) 4369 append_to_statement_list (ce->value, &temp); 4370 4371 *expr_p = temp; 4372 ret = GS_OK; 4373 } 4374 /* C99 code may assign to an array in a constructed 4375 structure or union, and this has undefined behavior only 4376 on execution, so create a temporary if an lvalue is 4377 required. */ 4378 else if (fallback == fb_lvalue) 4379 { 4380 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p); 4381 lang_hooks.mark_addressable (*expr_p); 4382 } 4383 else 4384 ret = GS_ALL_DONE; 4385 break; 4386 4387 /* The following are special cases that are not handled by the 4388 original GIMPLE grammar. */ 4389 4390 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and 4391 eliminated. */ 4392 case SAVE_EXPR: 4393 ret = gimplify_save_expr (expr_p, pre_p, post_p); 4394 break; 4395 4396 case BIT_FIELD_REF: 4397 { 4398 enum gimplify_status r0, r1, r2; 4399 4400 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, 4401 is_gimple_lvalue, fb_either); 4402 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p, 4403 is_gimple_val, fb_rvalue); 4404 r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p, post_p, 4405 is_gimple_val, fb_rvalue); 4406 recalculate_side_effects (*expr_p); 4407 4408 ret = MIN (r0, MIN (r1, r2)); 4409 } 4410 break; 4411 4412 case NON_LVALUE_EXPR: 4413 /* This should have been stripped above. */ 4414 gcc_unreachable (); 4415 4416 case ASM_EXPR: 4417 ret = gimplify_asm_expr (expr_p, pre_p, post_p); 4418 break; 4419 4420 case TRY_FINALLY_EXPR: 4421 case TRY_CATCH_EXPR: 4422 gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 0)); 4423 gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 1)); 4424 ret = GS_ALL_DONE; 4425 break; 4426 4427 case CLEANUP_POINT_EXPR: 4428 ret = gimplify_cleanup_point_expr (expr_p, pre_p); 4429 break; 4430 4431 case TARGET_EXPR: 4432 ret = gimplify_target_expr (expr_p, pre_p, post_p); 4433 break; 4434 4435 case CATCH_EXPR: 4436 gimplify_to_stmt_list (&CATCH_BODY (*expr_p)); 4437 ret = GS_ALL_DONE; 4438 break; 4439 4440 case EH_FILTER_EXPR: 4441 gimplify_to_stmt_list (&EH_FILTER_FAILURE (*expr_p)); 4442 ret = GS_ALL_DONE; 4443 break; 4444 4445 case OBJ_TYPE_REF: 4446 { 4447 enum gimplify_status r0, r1; 4448 r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p, post_p, 4449 is_gimple_val, fb_rvalue); 4450 r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p, post_p, 4451 is_gimple_val, fb_rvalue); 4452 ret = MIN (r0, r1); 4453 } 4454 break; 4455 4456 case LABEL_DECL: 4457 /* We get here when taking the address of a label. We mark 4458 the label as "forced"; meaning it can never be removed and 4459 it is a potential target for any computed goto. */ 4460 FORCED_LABEL (*expr_p) = 1; 4461 ret = GS_ALL_DONE; 4462 break; 4463 4464 case STATEMENT_LIST: 4465 ret = gimplify_statement_list (expr_p); 4466 break; 4467 4468 case WITH_SIZE_EXPR: 4469 { 4470 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, 4471 post_p == &internal_post ? NULL : post_p, 4472 gimple_test_f, fallback); 4473 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p, 4474 is_gimple_val, fb_rvalue); 4475 } 4476 break; 4477 4478 case VAR_DECL: 4479 case PARM_DECL: 4480 ret = gimplify_var_or_parm_decl (expr_p); 4481 break; 4482 4483 case SSA_NAME: 4484 /* Allow callbacks into the gimplifier during optimization. */ 4485 ret = GS_ALL_DONE; 4486 break; 4487 4488 default: 4489 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p))) 4490 { 4491 case tcc_comparison: 4492 /* If this is a comparison of objects of aggregate type, 4493 handle it specially (by converting to a call to 4494 memcmp). It would be nice to only have to do this 4495 for variable-sized objects, but then we'd have to 4496 allow the same nest of reference nodes we allow for 4497 MODIFY_EXPR and that's too complex. */ 4498 if (!AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (*expr_p, 1)))) 4499 goto expr_2; 4500 ret = gimplify_variable_sized_compare (expr_p); 4501 break; 4502 4503 /* If *EXPR_P does not need to be special-cased, handle it 4504 according to its class. */ 4505 case tcc_unary: 4506 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, 4507 post_p, is_gimple_val, fb_rvalue); 4508 break; 4509 4510 case tcc_binary: 4511 expr_2: 4512 { 4513 enum gimplify_status r0, r1; 4514 4515 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, 4516 post_p, is_gimple_val, fb_rvalue); 4517 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, 4518 post_p, is_gimple_val, fb_rvalue); 4519 4520 ret = MIN (r0, r1); 4521 break; 4522 } 4523 4524 case tcc_declaration: 4525 case tcc_constant: 4526 ret = GS_ALL_DONE; 4527 goto dont_recalculate; 4528 4529 default: 4530 gcc_assert (TREE_CODE (*expr_p) == TRUTH_AND_EXPR 4531 || TREE_CODE (*expr_p) == TRUTH_OR_EXPR 4532 || TREE_CODE (*expr_p) == TRUTH_XOR_EXPR); 4533 goto expr_2; 4534 } 4535 4536 recalculate_side_effects (*expr_p); 4537 dont_recalculate: 4538 break; 4539 } 4540 4541 /* If we replaced *expr_p, gimplify again. */ 4542 if (ret == GS_OK && (*expr_p == NULL || *expr_p == save_expr)) 4543 ret = GS_ALL_DONE; 4544 } 4545 while (ret == GS_OK); 4546 4547 /* If we encountered an error_mark somewhere nested inside, either 4548 stub out the statement or propagate the error back out. */ 4549 if (ret == GS_ERROR) 4550 { 4551 if (is_statement) 4552 *expr_p = NULL; 4553 goto out; 4554 } 4555 4556 /* This was only valid as a return value from the langhook, which 4557 we handled. Make sure it doesn't escape from any other context. */ 4558 gcc_assert (ret != GS_UNHANDLED); 4559 4560 if (fallback == fb_none && *expr_p && !is_gimple_stmt (*expr_p)) 4561 { 4562 /* We aren't looking for a value, and we don't have a valid 4563 statement. If it doesn't have side-effects, throw it away. */ 4564 if (!TREE_SIDE_EFFECTS (*expr_p)) 4565 *expr_p = NULL; 4566 else if (!TREE_THIS_VOLATILE (*expr_p)) 4567 { 4568 /* This is probably a _REF that contains something nested that 4569 has side effects. Recurse through the operands to find it. */ 4570 enum tree_code code = TREE_CODE (*expr_p); 4571 4572 switch (code) 4573 { 4574 case COMPONENT_REF: 4575 case REALPART_EXPR: case IMAGPART_EXPR: 4576 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, 4577 gimple_test_f, fallback); 4578 break; 4579 4580 case ARRAY_REF: 4581 case ARRAY_RANGE_REF: 4582 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, 4583 gimple_test_f, fallback); 4584 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p, 4585 gimple_test_f, fallback); 4586 break; 4587 4588 default: 4589 /* Anything else with side-effects must be converted to 4590 a valid statement before we get here. */ 4591 gcc_unreachable (); 4592 } 4593 4594 *expr_p = NULL; 4595 } 4596 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p)) 4597 && TYPE_MODE (TREE_TYPE (*expr_p)) != BLKmode) 4598 { 4599 /* Historically, the compiler has treated a bare reference 4600 to a non-BLKmode volatile lvalue as forcing a load. */ 4601 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p)); 4602 /* Normally, we do not want to create a temporary for a 4603 TREE_ADDRESSABLE type because such a type should not be 4604 copied by bitwise-assignment. However, we make an 4605 exception here, as all we are doing here is ensuring that 4606 we read the bytes that make up the type. We use 4607 create_tmp_var_raw because create_tmp_var will abort when 4608 given a TREE_ADDRESSABLE type. */ 4609 tree tmp = create_tmp_var_raw (type, "vol"); 4610 gimple_add_tmp_var (tmp); 4611 *expr_p = build (MODIFY_EXPR, type, tmp, *expr_p); 4612 } 4613 else 4614 /* We can't do anything useful with a volatile reference to 4615 an incomplete type, so just throw it away. Likewise for 4616 a BLKmode type, since any implicit inner load should 4617 already have been turned into an explicit one by the 4618 gimplification process. */ 4619 *expr_p = NULL; 4620 } 4621 4622 /* If we are gimplifying at the statement level, we're done. Tack 4623 everything together and replace the original statement with the 4624 gimplified form. */ 4625 if (fallback == fb_none || is_statement) 4626 { 4627 if (internal_pre || internal_post) 4628 { 4629 append_to_statement_list (*expr_p, &internal_pre); 4630 append_to_statement_list (internal_post, &internal_pre); 4631 annotate_all_with_locus (&internal_pre, input_location); 4632 *expr_p = internal_pre; 4633 } 4634 else if (!*expr_p) 4635 ; 4636 else if (TREE_CODE (*expr_p) == STATEMENT_LIST) 4637 annotate_all_with_locus (expr_p, input_location); 4638 else 4639 annotate_one_with_locus (*expr_p, input_location); 4640 goto out; 4641 } 4642 4643 /* Otherwise we're gimplifying a subexpression, so the resulting value is 4644 interesting. */ 4645 4646 /* If it's sufficiently simple already, we're done. Unless we are 4647 handling some post-effects internally; if that's the case, we need to 4648 copy into a temp before adding the post-effects to the tree. */ 4649 if (!internal_post && (*gimple_test_f) (*expr_p)) 4650 goto out; 4651 4652 /* Otherwise, we need to create a new temporary for the gimplified 4653 expression. */ 4654 4655 /* We can't return an lvalue if we have an internal postqueue. The 4656 object the lvalue refers to would (probably) be modified by the 4657 postqueue; we need to copy the value out first, which means an 4658 rvalue. */ 4659 if ((fallback & fb_lvalue) && !internal_post 4660 && is_gimple_addressable (*expr_p)) 4661 { 4662 /* An lvalue will do. Take the address of the expression, store it 4663 in a temporary, and replace the expression with an INDIRECT_REF of 4664 that temporary. */ 4665 tmp = build_fold_addr_expr (*expr_p); 4666 gimplify_expr (&tmp, pre_p, post_p, is_gimple_reg, fb_rvalue); 4667 *expr_p = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (tmp)), tmp); 4668 } 4669 else if ((fallback & fb_rvalue) && is_gimple_formal_tmp_rhs (*expr_p)) 4670 { 4671 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p))); 4672 4673 /* An rvalue will do. Assign the gimplified expression into a new 4674 temporary TMP and replace the original expression with TMP. */ 4675 4676 if (internal_post || (fallback & fb_lvalue)) 4677 /* The postqueue might change the value of the expression between 4678 the initialization and use of the temporary, so we can't use a 4679 formal temp. FIXME do we care? */ 4680 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p); 4681 else 4682 *expr_p = get_formal_tmp_var (*expr_p, pre_p); 4683 4684 if (TREE_CODE (*expr_p) != SSA_NAME) 4685 DECL_GIMPLE_FORMAL_TEMP_P (*expr_p) = 1; 4686 } 4687 else 4688 { 4689#ifdef ENABLE_CHECKING 4690 if (!(fallback & fb_mayfail)) 4691 { 4692 fprintf (stderr, "gimplification failed:\n"); 4693 print_generic_expr (stderr, *expr_p, 0); 4694 debug_tree (*expr_p); 4695 internal_error ("gimplification failed"); 4696 } 4697#endif 4698 gcc_assert (fallback & fb_mayfail); 4699 /* If this is an asm statement, and the user asked for the 4700 impossible, don't die. Fail and let gimplify_asm_expr 4701 issue an error. */ 4702 ret = GS_ERROR; 4703 goto out; 4704 } 4705 4706 /* Make sure the temporary matches our predicate. */ 4707 gcc_assert ((*gimple_test_f) (*expr_p)); 4708 4709 if (internal_post) 4710 { 4711 annotate_all_with_locus (&internal_post, input_location); 4712 append_to_statement_list (internal_post, pre_p); 4713 } 4714 4715 out: 4716 input_location = saved_location; 4717 return ret; 4718} 4719 4720/* Look through TYPE for variable-sized objects and gimplify each such 4721 size that we find. Add to LIST_P any statements generated. */ 4722 4723void 4724gimplify_type_sizes (tree type, tree *list_p) 4725{ 4726 tree field, t; 4727 4728 if (type == NULL || type == error_mark_node) 4729 return; 4730 4731 /* We first do the main variant, then copy into any other variants. */ 4732 type = TYPE_MAIN_VARIANT (type); 4733 4734 /* Avoid infinite recursion. */ 4735 if (TYPE_SIZES_GIMPLIFIED (type)) 4736 return; 4737 4738 TYPE_SIZES_GIMPLIFIED (type) = 1; 4739 4740 switch (TREE_CODE (type)) 4741 { 4742 case INTEGER_TYPE: 4743 case ENUMERAL_TYPE: 4744 case BOOLEAN_TYPE: 4745 case CHAR_TYPE: 4746 case REAL_TYPE: 4747 gimplify_one_sizepos (&TYPE_MIN_VALUE (type), list_p); 4748 gimplify_one_sizepos (&TYPE_MAX_VALUE (type), list_p); 4749 4750 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t)) 4751 { 4752 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (type); 4753 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (type); 4754 } 4755 break; 4756 4757 case ARRAY_TYPE: 4758 /* These types may not have declarations, so handle them here. */ 4759 gimplify_type_sizes (TREE_TYPE (type), list_p); 4760 gimplify_type_sizes (TYPE_DOMAIN (type), list_p); 4761 break; 4762 4763 case RECORD_TYPE: 4764 case UNION_TYPE: 4765 case QUAL_UNION_TYPE: 4766 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 4767 if (TREE_CODE (field) == FIELD_DECL) 4768 { 4769 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p); 4770 gimplify_type_sizes (TREE_TYPE (field), list_p); 4771 } 4772 break; 4773 4774 case POINTER_TYPE: 4775 case REFERENCE_TYPE: 4776 gimplify_type_sizes (TREE_TYPE (type), list_p); 4777 break; 4778 4779 default: 4780 break; 4781 } 4782 4783 gimplify_one_sizepos (&TYPE_SIZE (type), list_p); 4784 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type), list_p); 4785 4786 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t)) 4787 { 4788 TYPE_SIZE (t) = TYPE_SIZE (type); 4789 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (type); 4790 TYPE_SIZES_GIMPLIFIED (t) = 1; 4791 } 4792} 4793 4794/* A subroutine of gimplify_type_sizes to make sure that *EXPR_P, 4795 a size or position, has had all of its SAVE_EXPRs evaluated. 4796 We add any required statements to STMT_P. */ 4797 4798void 4799gimplify_one_sizepos (tree *expr_p, tree *stmt_p) 4800{ 4801 tree type, expr = *expr_p; 4802 4803 /* We don't do anything if the value isn't there, is constant, or contains 4804 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already 4805 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier 4806 will want to replace it with a new variable, but that will cause problems 4807 if this type is from outside the function. It's OK to have that here. */ 4808 if (expr == NULL_TREE || TREE_CONSTANT (expr) 4809 || TREE_CODE (expr) == VAR_DECL 4810 || CONTAINS_PLACEHOLDER_P (expr)) 4811 return; 4812 4813 type = TREE_TYPE (expr); 4814 *expr_p = unshare_expr (expr); 4815 4816 gimplify_expr (expr_p, stmt_p, NULL, is_gimple_val, fb_rvalue); 4817 expr = *expr_p; 4818 4819 /* Verify that we've an exact type match with the original expression. 4820 In particular, we do not wish to drop a "sizetype" in favour of a 4821 type of similar dimensions. We don't want to pollute the generic 4822 type-stripping code with this knowledge because it doesn't matter 4823 for the bulk of GENERIC/GIMPLE. It only matters that TYPE_SIZE_UNIT 4824 and friends retain their "sizetype-ness". */ 4825 if (TREE_TYPE (expr) != type 4826 && TREE_CODE (type) == INTEGER_TYPE 4827 && TYPE_IS_SIZETYPE (type)) 4828 { 4829 tree tmp; 4830 4831 *expr_p = create_tmp_var (type, NULL); 4832 tmp = build1 (NOP_EXPR, type, expr); 4833 tmp = build2 (MODIFY_EXPR, type, *expr_p, tmp); 4834 if (EXPR_HAS_LOCATION (expr)) 4835 SET_EXPR_LOCUS (tmp, EXPR_LOCUS (expr)); 4836 else 4837 SET_EXPR_LOCATION (tmp, input_location); 4838 4839 gimplify_and_add (tmp, stmt_p); 4840 } 4841} 4842 4843#ifdef ENABLE_CHECKING 4844/* Compare types A and B for a "close enough" match. */ 4845 4846static bool 4847cpt_same_type (tree a, tree b) 4848{ 4849 if (lang_hooks.types_compatible_p (a, b)) 4850 return true; 4851 4852 /* ??? The C++ FE decomposes METHOD_TYPES to FUNCTION_TYPES and doesn't 4853 link them together. This routine is intended to catch type errors 4854 that will affect the optimizers, and the optimizers don't add new 4855 dereferences of function pointers, so ignore it. */ 4856 if ((TREE_CODE (a) == FUNCTION_TYPE || TREE_CODE (a) == METHOD_TYPE) 4857 && (TREE_CODE (b) == FUNCTION_TYPE || TREE_CODE (b) == METHOD_TYPE)) 4858 return true; 4859 4860 /* ??? The C FE pushes type qualifiers after the fact into the type of 4861 the element from the type of the array. See build_unary_op's handling 4862 of ADDR_EXPR. This seems wrong -- if we were going to do this, we 4863 should have done it when creating the variable in the first place. 4864 Alternately, why aren't the two array types made variants? */ 4865 if (TREE_CODE (a) == ARRAY_TYPE && TREE_CODE (b) == ARRAY_TYPE) 4866 return cpt_same_type (TREE_TYPE (a), TREE_TYPE (b)); 4867 4868 /* And because of those, we have to recurse down through pointers. */ 4869 if (POINTER_TYPE_P (a) && POINTER_TYPE_P (b)) 4870 return cpt_same_type (TREE_TYPE (a), TREE_TYPE (b)); 4871 4872 return false; 4873} 4874 4875/* Check for some cases of the front end missing cast expressions. 4876 The type of a dereference should correspond to the pointer type; 4877 similarly the type of an address should match its object. */ 4878 4879static tree 4880check_pointer_types_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, 4881 void *data ATTRIBUTE_UNUSED) 4882{ 4883 tree t = *tp; 4884 tree ptype, otype, dtype; 4885 4886 switch (TREE_CODE (t)) 4887 { 4888 case INDIRECT_REF: 4889 case ARRAY_REF: 4890 otype = TREE_TYPE (t); 4891 ptype = TREE_TYPE (TREE_OPERAND (t, 0)); 4892 dtype = TREE_TYPE (ptype); 4893 gcc_assert (cpt_same_type (otype, dtype)); 4894 break; 4895 4896 case ADDR_EXPR: 4897 ptype = TREE_TYPE (t); 4898 otype = TREE_TYPE (TREE_OPERAND (t, 0)); 4899 dtype = TREE_TYPE (ptype); 4900 if (!cpt_same_type (otype, dtype)) 4901 { 4902 /* &array is allowed to produce a pointer to the element, rather than 4903 a pointer to the array type. We must allow this in order to 4904 properly represent assigning the address of an array in C into 4905 pointer to the element type. */ 4906 gcc_assert (TREE_CODE (otype) == ARRAY_TYPE 4907 && POINTER_TYPE_P (ptype) 4908 && cpt_same_type (TREE_TYPE (otype), dtype)); 4909 break; 4910 } 4911 break; 4912 4913 default: 4914 return NULL_TREE; 4915 } 4916 4917 4918 return NULL_TREE; 4919} 4920#endif 4921 4922/* Gimplify the body of statements pointed to by BODY_P. FNDECL is the 4923 function decl containing BODY. */ 4924 4925void 4926gimplify_body (tree *body_p, tree fndecl, bool do_parms) 4927{ 4928 location_t saved_location = input_location; 4929 tree body, parm_stmts; 4930 4931 timevar_push (TV_TREE_GIMPLIFY); 4932 push_gimplify_context (); 4933 4934 /* Unshare most shared trees in the body and in that of any nested functions. 4935 It would seem we don't have to do this for nested functions because 4936 they are supposed to be output and then the outer function gimplified 4937 first, but the g++ front end doesn't always do it that way. */ 4938 unshare_body (body_p, fndecl); 4939 unvisit_body (body_p, fndecl); 4940 4941 /* Make sure input_location isn't set to something wierd. */ 4942 input_location = DECL_SOURCE_LOCATION (fndecl); 4943 4944 /* Resolve callee-copies. This has to be done before processing 4945 the body so that DECL_VALUE_EXPR gets processed correctly. */ 4946 parm_stmts = do_parms ? gimplify_parameters () : NULL; 4947 4948 /* Gimplify the function's body. */ 4949 gimplify_stmt (body_p); 4950 body = *body_p; 4951 4952 if (!body) 4953 body = alloc_stmt_list (); 4954 else if (TREE_CODE (body) == STATEMENT_LIST) 4955 { 4956 tree t = expr_only (*body_p); 4957 if (t) 4958 body = t; 4959 } 4960 4961 /* If there isn't an outer BIND_EXPR, add one. */ 4962 if (TREE_CODE (body) != BIND_EXPR) 4963 { 4964 tree b = build (BIND_EXPR, void_type_node, NULL_TREE, 4965 NULL_TREE, NULL_TREE); 4966 TREE_SIDE_EFFECTS (b) = 1; 4967 append_to_statement_list_force (body, &BIND_EXPR_BODY (b)); 4968 body = b; 4969 } 4970 4971 /* If we had callee-copies statements, insert them at the beginning 4972 of the function. */ 4973 if (parm_stmts) 4974 { 4975 append_to_statement_list_force (BIND_EXPR_BODY (body), &parm_stmts); 4976 BIND_EXPR_BODY (body) = parm_stmts; 4977 } 4978 4979 /* Unshare again, in case gimplification was sloppy. */ 4980 unshare_all_trees (body); 4981 4982 *body_p = body; 4983 4984 pop_gimplify_context (body); 4985 4986#ifdef ENABLE_CHECKING 4987 walk_tree (body_p, check_pointer_types_r, NULL, NULL); 4988#endif 4989 4990 timevar_pop (TV_TREE_GIMPLIFY); 4991 input_location = saved_location; 4992} 4993 4994/* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL 4995 node for the function we want to gimplify. */ 4996 4997void 4998gimplify_function_tree (tree fndecl) 4999{ 5000 tree oldfn, parm, ret; 5001 5002 oldfn = current_function_decl; 5003 current_function_decl = fndecl; 5004 cfun = DECL_STRUCT_FUNCTION (fndecl); 5005 if (cfun == NULL) 5006 allocate_struct_function (fndecl); 5007 5008 for (parm = DECL_ARGUMENTS (fndecl); parm ; parm = TREE_CHAIN (parm)) 5009 { 5010 /* Preliminarily mark non-addressed complex variables as eligible 5011 for promotion to gimple registers. We'll transform their uses 5012 as we find them. */ 5013 if (TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE 5014 && !TREE_THIS_VOLATILE (parm) 5015 && !needs_to_live_in_memory (parm)) 5016 DECL_COMPLEX_GIMPLE_REG_P (parm) = 1; 5017 } 5018 5019 ret = DECL_RESULT (fndecl); 5020 if (TREE_CODE (TREE_TYPE (ret)) == COMPLEX_TYPE 5021 && !needs_to_live_in_memory (ret)) 5022 DECL_COMPLEX_GIMPLE_REG_P (ret) = 1; 5023 5024 gimplify_body (&DECL_SAVED_TREE (fndecl), fndecl, true); 5025 5026 /* If we're instrumenting function entry/exit, then prepend the call to 5027 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to 5028 catch the exit hook. */ 5029 /* ??? Add some way to ignore exceptions for this TFE. */ 5030 if (flag_instrument_function_entry_exit 5031 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl)) 5032 { 5033 tree tf, x, bind; 5034 5035 tf = build (TRY_FINALLY_EXPR, void_type_node, NULL, NULL); 5036 TREE_SIDE_EFFECTS (tf) = 1; 5037 x = DECL_SAVED_TREE (fndecl); 5038 append_to_statement_list (x, &TREE_OPERAND (tf, 0)); 5039 x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_EXIT]; 5040 x = build_function_call_expr (x, NULL); 5041 append_to_statement_list (x, &TREE_OPERAND (tf, 1)); 5042 5043 bind = build (BIND_EXPR, void_type_node, NULL, NULL, NULL); 5044 TREE_SIDE_EFFECTS (bind) = 1; 5045 x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_ENTER]; 5046 x = build_function_call_expr (x, NULL); 5047 append_to_statement_list (x, &BIND_EXPR_BODY (bind)); 5048 append_to_statement_list (tf, &BIND_EXPR_BODY (bind)); 5049 5050 DECL_SAVED_TREE (fndecl) = bind; 5051 } 5052 5053 current_function_decl = oldfn; 5054 cfun = oldfn ? DECL_STRUCT_FUNCTION (oldfn) : NULL; 5055} 5056 5057 5058/* Expands EXPR to list of gimple statements STMTS. If SIMPLE is true, 5059 force the result to be either ssa_name or an invariant, otherwise 5060 just force it to be a rhs expression. If VAR is not NULL, make the 5061 base variable of the final destination be VAR if suitable. */ 5062 5063tree 5064force_gimple_operand (tree expr, tree *stmts, bool simple, tree var) 5065{ 5066 tree t; 5067 enum gimplify_status ret; 5068 gimple_predicate gimple_test_f; 5069 5070 *stmts = NULL_TREE; 5071 5072 if (is_gimple_val (expr)) 5073 return expr; 5074 5075 gimple_test_f = simple ? is_gimple_val : is_gimple_reg_rhs; 5076 5077 push_gimplify_context (); 5078 gimplify_ctxp->into_ssa = in_ssa_p; 5079 5080 if (var) 5081 expr = build (MODIFY_EXPR, TREE_TYPE (var), var, expr); 5082 5083 ret = gimplify_expr (&expr, stmts, NULL, 5084 gimple_test_f, fb_rvalue); 5085 gcc_assert (ret != GS_ERROR); 5086 5087 if (referenced_vars) 5088 { 5089 for (t = gimplify_ctxp->temps; t ; t = TREE_CHAIN (t)) 5090 add_referenced_tmp_var (t); 5091 } 5092 5093 pop_gimplify_context (NULL); 5094 5095 return expr; 5096} 5097 5098/* Invokes force_gimple_operand for EXPR with parameters SIMPLE_P and VAR. If 5099 some statements are produced, emits them before BSI. */ 5100 5101tree 5102force_gimple_operand_bsi (block_stmt_iterator *bsi, tree expr, 5103 bool simple_p, tree var) 5104{ 5105 tree stmts; 5106 5107 expr = force_gimple_operand (expr, &stmts, simple_p, var); 5108 if (stmts) 5109 bsi_insert_before (bsi, stmts, BSI_SAME_STMT); 5110 5111 return expr; 5112} 5113 5114#include "gt-gimplify.h" 5115