gcc/gimplify.c

   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 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
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 2, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to the Free
  21 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  22 02111-1307, 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 "errors.h"
  31 #include "varray.h"
  32 #include "tree-gimple.h"
  33 #include "tree-inline.h"
  34 #include "diagnostic.h"
  35 #include "langhooks.h"
  36 #include "langhooks-def.h"
  37 #include "tree-flow.h"
  38 #include "cgraph.h"
  39 #include "timevar.h"
  40 #include "except.h"
  41 #include "hashtab.h"
  42 #include "flags.h"
  43 #include "real.h"
  44 #include "function.h"
  45 #include "output.h"
  46 #include "expr.h"
  47 #include "ggc.h"
  48 #include "target.h"
  49
  50 static struct gimplify_ctx
  51 {
  52   tree current_bind_expr;
  53   bool save_stack;
  54   tree temps;
  55   tree conditional_cleanups;
  56   int conditions;
  57   tree exit_label;
  58   tree return_temp;
  59   varray_type case_labels;
  60   /* The formal temporary table.  Should this be persistent?  */
  61   htab_t temp_htab;
  62 } *gimplify_ctxp;
  63
  64
  65 /* Formal (expression) temporary table handling: Multiple occurrences of
  66    the same scalar expression are evaluated into the same temporary.  */
  67
  68 typedef struct gimple_temp_hash_elt
  69 {
  70   tree val;   /* Key */
  71   tree temp;  /* Value */
  72 } elt_t;
  73
  74 /* Forward declarations.  */
  75 static hashval_t gimple_tree_hash (const void *);
  76 static int gimple_tree_eq (const void *, const void *);
  77 static bool gimple_conditional_context (void);
  78 static void gimple_push_condition (void);
  79 static void gimple_pop_condition (tree *);
  80 static void append_to_statement_list_1 (tree, tree *, bool);
  81 static inline void remove_suffix (char *, int);
  82 static inline tree create_tmp_from_val (tree);
  83 static tree lookup_tmp_var (tree, bool);
  84 static tree internal_get_tmp_var (tree, tree *, tree *, bool);
  85 static bool should_carry_locus_p (tree);
  86 static tree mostly_copy_tree_r (tree *, int *, void *);
  87 static tree mark_decls_volatile_r (tree *, int *, void *);
  88 static tree copy_if_shared_r (tree *, int *, void *);
  89 static tree unmark_visited_r (tree *, int *, void *);
  90 static void unshare_body (tree *, tree);
  91 static void unvisit_body (tree *, tree);
  92 static void build_stack_save_restore (tree *, tree *);
  93 static enum gimplify_status gimplify_bind_expr (tree *, tree, tree *);
  94 static enum gimplify_status gimplify_return_expr (tree, tree *);
  95 static enum gimplify_status gimplify_loop_expr (tree *, tree *);
  96 static int compare_case_labels (const void *, const void *);
  97 static enum gimplify_status gimplify_switch_expr (tree *, tree *);
  98 static enum gimplify_status gimplify_case_label_expr (tree *);
  99 static enum gimplify_status gimplify_labeled_block_expr (tree *);
 100 static enum gimplify_status gimplify_exit_block_expr (tree *);
 101 static enum gimplify_status gimplify_exit_expr (tree *);
 102 static enum gimplify_status gimplify_init_constructor (tree *, tree *, tree *,
 103                                                        bool);
 104 static void canonicalize_component_ref (tree *);
 105 static void canonicalize_addr_expr (tree *);
 106 static enum gimplify_status gimplify_conversion (tree *);
 107 static enum gimplify_status gimplify_minimax_expr (tree *, tree *, tree *);
 108 static enum gimplify_status gimplify_array_ref_to_plus (tree *, tree *,
 109                                                         tree *);
 110 static tree build_addr_expr_with_type (tree, tree);
 111 static tree build_addr_expr (tree);
 112 static enum gimplify_status gimplify_compound_lval (tree *, tree *, tree *,
 113                                                     bool);
 114 static enum gimplify_status gimplify_self_mod_expr (tree *, tree *, tree *,
 115                                                     bool);
 116 static enum gimplify_status gimplify_call_expr (tree *, tree *,
 117                                                 bool (*) (tree));
 118 static tree shortcut_cond_r (tree, tree *, tree *);
 119 static tree shortcut_cond_expr (tree);
 120 static tree gimple_boolify (tree);
 121 static enum gimplify_status gimplify_cond_expr (tree *, tree *, tree);
 122 static enum gimplify_status gimplify_modify_expr (tree *, tree *, tree *,
 123                                                   bool);
 124 static enum gimplify_status gimplify_modify_expr_rhs (tree *, tree *, tree *,
 125                                                       tree *, tree *, bool);
 126 static enum gimplify_status gimplify_variable_sized_compare (tree *);
 127 static enum gimplify_status gimplify_boolean_expr (tree *);
 128 static enum gimplify_status gimplify_compound_expr (tree *, tree *, bool);
 129 static enum gimplify_status gimplify_statement_list (tree *);
 130 static enum gimplify_status gimplify_save_expr (tree *, tree *, tree *);
 131 static enum gimplify_status gimplify_addr_expr (tree *, tree *, tree *);
 132 static enum gimplify_status gimplify_asm_expr (tree *, tree *, tree *);
 133 static enum gimplify_status gimplify_cleanup_point_expr (tree *, tree *);
 134 static void gimple_push_cleanup (tree, tree, tree *);
 135 static enum gimplify_status gimplify_target_expr (tree *, tree *, tree *);
 136 #ifdef ENABLE_CHECKING
 137 static bool cpt_same_type (tree, tree);
 138 static tree check_pointer_types_r (tree *, int *, void *);
 139 #endif
 140
 141 /* Return a hash value for a formal temporary table entry.  */
 142
 143 static hashval_t
 144 gimple_tree_hash (const void *p)
 145 {
 146   tree t = ((const elt_t *)p)->val;
 147   return iterative_hash_expr (t, 0);
 148 }
 149
 150 /* Compare two formal temporary table entries.  */
 151
 152 static int
 153 gimple_tree_eq (const void *p1, const void *p2)
 154 {
 155   tree t1 = ((const elt_t *)p1)->val;
 156   tree t2 = ((const elt_t *)p2)->val;
 157   enum tree_code code = TREE_CODE (t1);
 158
 159   if (TREE_CODE (t2) != code
 160       || TREE_TYPE (t1) != TREE_TYPE (t2))
 161     return 0;
 162
 163   if (!operand_equal_p (t1, t2, 0))
 164     return 0;
 165
 166   /* Only allow them to compare equal if they also hash equal; otherwise
 167      results are nondeterminate, and we fail bootstrap comparison.  */
 168   if (gimple_tree_hash (p1) != gimple_tree_hash (p2))
 169     abort ();
 170
 171   return 1;
 172 }
 173
 174 /* Set up a context for the gimplifier.  */
 175
 176 void
 177 push_gimplify_context (void)
 178 {
 179   if (gimplify_ctxp)
 180     abort ();
 181   gimplify_ctxp
 182     = (struct gimplify_ctx *) xcalloc (1, sizeof (struct gimplify_ctx));
 183   gimplify_ctxp->temp_htab
 184     = htab_create (1000, gimple_tree_hash, gimple_tree_eq, free);
 185 }
 186
 187 /* Tear down a context for the gimplifier.  If BODY is non-null, then
 188    put the temporaries into the outer BIND_EXPR.  Otherwise, put them
 189    in the unexpanded_var_list.  */
 190
 191 void
 192 pop_gimplify_context (tree body)
 193 {
 194   if (!gimplify_ctxp || gimplify_ctxp->current_bind_expr)
 195     abort ();
 196
 197   if (body)
 198     declare_tmp_vars (gimplify_ctxp->temps, body);
 199   else
 200     record_vars (gimplify_ctxp->temps);
 201
 202 #if 0
 203   if (!quiet_flag)
 204     fprintf (stderr, " collisions: %f ",
 205              htab_collisions (gimplify_ctxp->temp_htab));
 206 #endif
 207
 208   htab_delete (gimplify_ctxp->temp_htab);
 209   free (gimplify_ctxp);
 210   gimplify_ctxp = NULL;
 211 }
 212
 213 void
 214 gimple_push_bind_expr (tree bind)
 215 {
 216   TREE_CHAIN (bind) = gimplify_ctxp->current_bind_expr;
 217   gimplify_ctxp->current_bind_expr = bind;
 218 }
 219
 220 void
 221 gimple_pop_bind_expr (void)
 222 {
 223   gimplify_ctxp->current_bind_expr
 224     = TREE_CHAIN (gimplify_ctxp->current_bind_expr);
 225 }
 226
 227 tree
 228 gimple_current_bind_expr (void)
 229 {
 230   return gimplify_ctxp->current_bind_expr;
 231 }
 232
 233 /* Returns true iff there is a COND_EXPR between us and the innermost
 234    CLEANUP_POINT_EXPR.  This info is used by gimple_push_cleanup.  */
 235
 236 static bool
 237 gimple_conditional_context (void)
 238 {
 239   return gimplify_ctxp->conditions > 0;
 240 }
 241
 242 /* Note that we've entered a COND_EXPR.  */
 243
 244 static void
 245 gimple_push_condition (void)
 246 {
 247   ++(gimplify_ctxp->conditions);
 248 }
 249
 250 /* Note that we've left a COND_EXPR.  If we're back at unconditional scope
 251    now, add any conditional cleanups we've seen to the prequeue.  */
 252
 253 static void
 254 gimple_pop_condition (tree *pre_p)
 255 {
 256   int conds = --(gimplify_ctxp->conditions);
 257   if (conds == 0)
 258     {
 259       append_to_statement_list (gimplify_ctxp->conditional_cleanups, pre_p);
 260       gimplify_ctxp->conditional_cleanups = NULL_TREE;
 261     }
 262   else if (conds < 0)
 263     abort ();
 264 }
 265
 266 /* A subroutine of append_to_statement_list{,_force}.  */
 267
 268 static void
 269 append_to_statement_list_1 (tree t, tree *list_p, bool side_effects)
 270 {
 271   tree list = *list_p;
 272   tree_stmt_iterator i;
 273
 274   if (!side_effects)
 275     return;
 276
 277   if (!list)
 278     {
 279       if (t && TREE_CODE (t) == STATEMENT_LIST)
 280         {
 281           *list_p = t;
 282           return;
 283         }
 284       *list_p = list = alloc_stmt_list ();
 285     }
 286
 287   i = tsi_last (list);
 288   tsi_link_after (&i, t, TSI_CONTINUE_LINKING);
 289 }
 290
 291 /* Add T to the end of the list container pointed by LIST_P.
 292    If T is an expression with no effects, it is ignored.  */
 293
 294 void
 295 append_to_statement_list (tree t, tree *list_p)
 296 {
 297   append_to_statement_list_1 (t, list_p, t ? TREE_SIDE_EFFECTS (t) : false);
 298 }
 299
 300 /* Similar, but the statement is always added, regardless of side effects.  */
 301
 302 void
 303 append_to_statement_list_force (tree t, tree *list_p)
 304 {
 305   append_to_statement_list_1 (t, list_p, t != NULL);
 306 }
 307
 308 /* Both gimplify the statement T and append it to LIST_P.  */
 309
 310 void
 311 gimplify_and_add (tree t, tree *list_p)
 312 {
 313   gimplify_stmt (&t);
 314   append_to_statement_list (t, list_p);
 315 }
 316
 317 /* Add T to the end of a COMPOUND_EXPR pointed by LIST_P.  The type
 318    of the result is the type of T.  */
 319
 320 void
 321 append_to_compound_expr (tree t, tree *list_p)
 322 {
 323   if (!t)
 324     return;
 325   if (!*list_p)
 326     *list_p = t;
 327   else
 328     *list_p = build (COMPOUND_EXPR, TREE_TYPE (t), *list_p, t);
 329 }
 330
 331 /* Strip off a legitimate source ending from the input string NAME of
 332    length LEN.  Rather than having to know the names used by all of
 333    our front ends, we strip off an ending of a period followed by
 334    up to five characters.  (Java uses ".class".)  */
 335
 336 static inline void
 337 remove_suffix (char *name, int len)
 338 {
 339   int i;
 340
 341   for (i = 2;  i < 8 && len > i;  i++)
 342     {
 343       if (name[len - i] == '.')
 344         {
 345           name[len - i] = '\0';
 346           break;
 347         }
 348     }
 349 }
 350
 351 /* Create a nameless artificial label and put it in the current function
 352    context.  Returns the newly created label.  */
 353
 354 tree
 355 create_artificial_label (void)
 356 {
 357   tree lab = build_decl (LABEL_DECL, NULL_TREE, void_type_node);
 358   DECL_ARTIFICIAL (lab) = 1;
 359   DECL_CONTEXT (lab) = current_function_decl;
 360   return lab;
 361 }
 362
 363 /* Create a new temporary name with PREFIX.  Returns an identifier.  */
 364
 365 static GTY(()) unsigned int tmp_var_id_num;
 366
 367 tree
 368 create_tmp_var_name (const char *prefix)
 369 {
 370   char *tmp_name;
 371
 372   if (prefix)
 373     {
 374       char *preftmp = ASTRDUP (prefix);
 375       remove_suffix (preftmp, strlen (preftmp));
 376       prefix = preftmp;
 377     }
 378
 379   ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++);
 380   return get_identifier (tmp_name);
 381 }
 382
 383
 384 /* Create a new temporary variable declaration of type TYPE.
 385    Does NOT push it into the current binding.  */
 386
 387 tree
 388 create_tmp_var_raw (tree type, const char *prefix)
 389 {
 390   tree tmp_var;
 391   tree new_type;
 392
 393   /* Make the type of the variable writable.  */
 394   new_type = build_type_variant (type, 0, 0);
 395   TYPE_ATTRIBUTES (new_type) = TYPE_ATTRIBUTES (type);
 396
 397   tmp_var = build_decl (VAR_DECL, create_tmp_var_name (prefix), type);
 398
 399   /* The variable was declared by the compiler.  */
 400   DECL_ARTIFICIAL (tmp_var) = 1;
 401   /* And we don't want debug info for it.  */
 402   DECL_IGNORED_P (tmp_var) = 1;
 403
 404   /* Make the variable writable.  */
 405   TREE_READONLY (tmp_var) = 0;
 406
 407   DECL_EXTERNAL (tmp_var) = 0;
 408   TREE_STATIC (tmp_var) = 0;
 409   TREE_USED (tmp_var) = 1;
 410
 411   return tmp_var;
 412 }
 413
 414 /* Create a new temporary variable declaration of type TYPE.  DOES push the
 415    variable into the current binding.  Further, assume that this is called
 416    only from gimplification or optimization, at which point the creation of
 417    certain types are bugs.  */
 418
 419 tree
 420 create_tmp_var (tree type, const char *prefix)
 421 {
 422   tree tmp_var;
 423
 424 #if defined ENABLE_CHECKING
 425   /* We don't allow types that are addressable (meaning we can't make copies),
 426      incomplete, or of variable size.  */
 427   if (TREE_ADDRESSABLE (type)
 428       || !COMPLETE_TYPE_P (type)
 429       || TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST)
 430     abort ();
 431 #endif
 432
 433   tmp_var = create_tmp_var_raw (type, prefix);
 434   gimple_add_tmp_var (tmp_var);
 435   return tmp_var;
 436 }
 437
 438 /*  Given a tree, try to return a useful variable name that we can use
 439     to prefix a temporary that is being assigned the value of the tree.
 440     I.E. given  <temp> = &A, return A.  */
 441
 442 const char *
 443 get_name (tree t)
 444 {
 445   tree stripped_decl;
 446
 447   stripped_decl = t;
 448   STRIP_NOPS (stripped_decl);
 449   if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
 450     return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
 451   else
 452     {
 453       switch (TREE_CODE (stripped_decl))
 454         {
 455         case ADDR_EXPR:
 456           return get_name (TREE_OPERAND (stripped_decl, 0));
 457           break;
 458         default:
 459           return NULL;
 460         }
 461     }
 462 }
 463
 464 /* Create a temporary with a name derived from VAL.  Subroutine of
 465    lookup_tmp_var; nobody else should call this function.  */
 466
 467 static inline tree
 468 create_tmp_from_val (tree val)
 469 {
 470   return create_tmp_var (TREE_TYPE (val), get_name (val));
 471 }
 472
 473 /* Create a temporary to hold the value of VAL.  If IS_FORMAL, try to reuse
 474    an existing expression temporary.  */
 475
 476 static tree
 477 lookup_tmp_var (tree val, bool is_formal)
 478 {
 479   if (!is_formal || TREE_SIDE_EFFECTS (val))
 480     return create_tmp_from_val (val);
 481   else
 482     {
 483       elt_t elt, *elt_p;
 484       void **slot;
 485
 486       elt.val = val;
 487       slot = htab_find_slot (gimplify_ctxp->temp_htab, (void *)&elt, INSERT);
 488       if (*slot == NULL)
 489         {
 490           elt_p = xmalloc (sizeof (*elt_p));
 491           elt_p->val = val;
 492           elt_p->temp = create_tmp_from_val (val);
 493           *slot = (void *)elt_p;
 494         }
 495       else
 496         elt_p = (elt_t *) *slot;
 497
 498       return elt_p->temp;
 499     }
 500 }
 501
 502 /* Returns a formal temporary variable initialized with VAL.  PRE_P is as
 503    in gimplify_expr.  Only use this function if:
 504
 505    1) The value of the unfactored expression represented by VAL will not
 506       change between the initialization and use of the temporary, and
 507    2) The temporary will not be otherwise modified.
 508
 509    For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
 510    and #2 means it is inappropriate for && temps.
 511
 512    For other cases, use get_initialized_tmp_var instead.  */
 513
 514 static tree
 515 internal_get_tmp_var (tree val, tree *pre_p, tree *post_p, bool is_formal)
 516 {
 517   tree t, mod;
 518   char class;
 519
 520   gimplify_expr (&val, pre_p, post_p, is_gimple_rhs, fb_rvalue);
 521
 522   t = lookup_tmp_var (val, is_formal);
 523
 524   mod = build (MODIFY_EXPR, TREE_TYPE (t), t, val);
 525
 526   class = TREE_CODE_CLASS (TREE_CODE (val));
 527   if (EXPR_LOCUS (val))
 528     SET_EXPR_LOCUS (mod, EXPR_LOCUS (val));
 529   else
 530     annotate_with_locus (mod, input_location);
 531   /* gimplify_modify_expr might want to reduce this further.  */
 532   gimplify_stmt (&mod);
 533   append_to_statement_list (mod, pre_p);
 534
 535   return t;
 536 }
 537
 538 tree
 539 get_formal_tmp_var (tree val, tree *pre_p)
 540 {
 541   return internal_get_tmp_var (val, pre_p, NULL, true);
 542 }
 543
 544 /* Returns a temporary variable initialized with VAL.  PRE_P and POST_P
 545    are as in gimplify_expr.  */
 546
 547 tree
 548 get_initialized_tmp_var (tree val, tree *pre_p, tree *post_p)
 549 {
 550   return internal_get_tmp_var (val, pre_p, post_p, false);
 551 }
 552
 553 /*  Returns true if T is a GIMPLE temporary variable, false otherwise.  */
 554
 555 bool
 556 is_gimple_tmp_var (tree t)
 557 {
 558   /* FIXME this could trigger for other local artificials, too.  */
 559   return (TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t)
 560           && !TREE_STATIC (t) && !DECL_EXTERNAL (t));
 561 }
 562
 563 /* Declares all the variables in VARS in SCOPE.  Returns the last
 564    DECL_STMT emitted.  */
 565
 566 void
 567 declare_tmp_vars (tree vars, tree scope)
 568 {
 569   tree last = vars;
 570   if (last)
 571     {
 572       tree temps;
 573
 574       /* C99 mode puts the default 'return 0;' for main() outside the outer
 575          braces.  So drill down until we find an actual scope.  */
 576       while (TREE_CODE (scope) == COMPOUND_EXPR)
 577         scope = TREE_OPERAND (scope, 0);
 578
 579       if (TREE_CODE (scope) != BIND_EXPR)
 580         abort ();
 581
 582       temps = nreverse (last);
 583       TREE_CHAIN (last) = BIND_EXPR_VARS (scope);
 584       BIND_EXPR_VARS (scope) = temps;
 585
 586       /* We don't add the temps to the block for this BIND_EXPR, as we're
 587          not interested in debugging info for them.  */
 588     }
 589 }
 590
 591 void
 592 gimple_add_tmp_var (tree tmp)
 593 {
 594   if (TREE_CHAIN (tmp) || tmp->decl.seen_in_bind_expr)
 595     abort ();
 596
 597   DECL_CONTEXT (tmp) = current_function_decl;
 598   tmp->decl.seen_in_bind_expr = 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
 613 static bool
 614 should_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
 629 static void
 630 annotate_one_with_locus (tree t, location_t locus)
 631 {
 632   if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (t)))
 633       && ! EXPR_HAS_LOCATION (t)
 634       && should_carry_locus_p (t))
 635     annotate_with_locus (t, locus);
 636 }
 637
 638 void
 639 annotate_all_with_locus (tree *stmt_p, location_t locus)
 640 {
 641   tree_stmt_iterator i;
 642
 643   if (!*stmt_p)
 644     return;
 645
 646   for (i = tsi_start (*stmt_p); !tsi_end_p (i); tsi_next (&i))
 647     {
 648       tree t = tsi_stmt (i);
 649
 650 #ifdef ENABLE_CHECKING
 651           /* Assuming we've already been gimplified, we shouldn't
 652              see nested chaining constructs anymore.  */
 653           if (TREE_CODE (t) == STATEMENT_LIST
 654               || TREE_CODE (t) == COMPOUND_EXPR)
 655             abort ();
 656 #endif
 657
 658       annotate_one_with_locus (t, locus);
 659     }
 660 }
 661
 662 /* Similar to copy_tree_r() but do not copy SAVE_EXPR or TARGET_EXPR nodes.
 663    These nodes model computations that should only be done once.  If we
 664    were to unshare something like SAVE_EXPR(i++), the gimplification
 665    process would create wrong code.  */
 666
 667 static tree
 668 mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data)
 669 {
 670   enum tree_code code = TREE_CODE (*tp);
 671   /* Don't unshare types, decls, constants and SAVE_EXPR nodes.  */
 672   if (TREE_CODE_CLASS (code) == 't'
 673       || TREE_CODE_CLASS (code) == 'd'
 674       || TREE_CODE_CLASS (code) == 'c'
 675       || code == SAVE_EXPR || code == TARGET_EXPR
 676       /* We can't do anything sensible with a BLOCK used as an expression,
 677          but we also can't abort when we see it because of non-expression
 678          uses.  So just avert our eyes and cross our fingers.  Silly Java.  */
 679       || code == BLOCK)
 680     *walk_subtrees = 0;
 681   else if (code == BIND_EXPR)
 682     abort ();
 683   else
 684     copy_tree_r (tp, walk_subtrees, data);
 685
 686   return NULL_TREE;
 687 }
 688
 689 /* Mark all the _DECL nodes under *TP as volatile.  FIXME: This must die
 690    after VA_ARG_EXPRs are properly lowered.  */
 691
 692 static tree
 693 mark_decls_volatile_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
 694                        void *data ATTRIBUTE_UNUSED)
 695 {
 696   if (SSA_VAR_P (*tp))
 697     TREE_THIS_VOLATILE (*tp) = 1;
 698
 699   return NULL_TREE;
 700 }
 701
 702
 703 /* Callback for walk_tree to unshare most of the shared trees rooted at
 704    *TP.  If *TP has been visited already (i.e., TREE_VISITED (*TP) == 1),
 705    then *TP is deep copied by calling copy_tree_r.
 706
 707    This unshares the same trees as copy_tree_r with the exception of
 708    SAVE_EXPR nodes.  These nodes model computations that should only be
 709    done once.  If we were to unshare something like SAVE_EXPR(i++), the
 710    gimplification process would create wrong code.  */
 711
 712 static tree
 713 copy_if_shared_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
 714                   void *data ATTRIBUTE_UNUSED)
 715 {
 716   tree t = *tp;
 717   enum tree_code code = TREE_CODE (t);
 718
 719   /* Skip types, decls, and constants.  But we do want to look at their
 720      types and the bounds of types.  Mark them as visited so we properly
 721      unmark their subtrees on the unmark pass.  If we've already seen them,
 722      don't look down further.  */
 723   if (TREE_CODE_CLASS (code) == 't'
 724       || TREE_CODE_CLASS (code) == 'd'
 725       || TREE_CODE_CLASS (code) == 'c')
 726     {
 727       if (TREE_VISITED (t))
 728         *walk_subtrees = 0;
 729       else
 730         TREE_VISITED (t) = 1;
 731     }
 732
 733   /* Special-case BIND_EXPR.  We should never be copying these, therefore
 734      we can omit examining BIND_EXPR_VARS.  Which also avoids problems with
 735      double processing of the DECL_INITIAL, which could be seen via both
 736      the BIND_EXPR_VARS and a DECL_STMT.  */
 737   else if (code == BIND_EXPR)
 738     {
 739       if (TREE_VISITED (t))
 740         abort ();
 741       TREE_VISITED (t) = 1;
 742       *walk_subtrees = 0;
 743       walk_tree (&BIND_EXPR_BODY (t), copy_if_shared_r, NULL, NULL);
 744     }
 745
 746   /* If this node has been visited already, unshare it and don't look
 747      any deeper.  */
 748   else if (TREE_VISITED (t))
 749     {
 750       walk_tree (tp, mostly_copy_tree_r, NULL, NULL);
 751       *walk_subtrees = 0;
 752     }
 753
 754   /* Otherwise, mark the tree as visited and keep looking.  */
 755   else
 756     {
 757       TREE_VISITED (t) = 1;
 758       if (TREE_CODE (*tp) == VA_ARG_EXPR
 759           && targetm.calls.gimplify_va_arg_expr == NULL)
 760         {
 761           /* Mark any _DECL inside the operand as volatile to avoid
 762              the optimizers messing around with it. We have to do this
 763              early, otherwise we might mark a variable as volatile
 764              after we gimplify other statements that use the variable
 765              assuming it's not volatile.  */
 766
 767           /* FIXME once most targets define the above hook, this should
 768              go away (perhaps along with the #include "target.h").  */
 769           walk_tree (&TREE_OPERAND (*tp, 0), mark_decls_volatile_r,
 770                      NULL, NULL);
 771         }
 772     }
 773
 774   return NULL_TREE;
 775 }
 776
 777 static tree
 778 unmark_visited_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
 779                   void *data ATTRIBUTE_UNUSED)
 780 {
 781   if (TREE_VISITED (*tp))
 782     TREE_VISITED (*tp) = 0;
 783   else
 784     *walk_subtrees = 0;
 785
 786   return NULL_TREE;
 787 }
 788
 789 /* Unshare all the trees in BODY_P, a pointer to the body of FNDECL, and the
 790    bodies of any nested functions.  */
 791
 792 static void
 793 unshare_body (tree *body_p, tree fndecl)
 794 {
 795   struct cgraph_node *cgn = cgraph_node (fndecl);
 796
 797   walk_tree (body_p, copy_if_shared_r, NULL, NULL);
 798   for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
 799     unshare_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
 800 }
 801
 802 /* Likewise, but mark all trees as not visited.  */
 803
 804 static void
 805 unvisit_body (tree *body_p, tree fndecl)
 806 {
 807   struct cgraph_node *cgn = cgraph_node (fndecl);
 808
 809   walk_tree (body_p, unmark_visited_r, NULL, NULL);
 810   for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
 811     unvisit_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
 812 }
 813
 814 /* Unshare T and all the trees reached from T via TREE_CHAIN.  */
 815
 816 void
 817 unshare_all_trees (tree t)
 818 {
 819   walk_tree (&t, copy_if_shared_r, NULL, NULL);
 820   walk_tree (&t, unmark_visited_r, NULL, NULL);
 821 }
 822
 823 /* Unconditionally make an unshared copy of EXPR.  This is used when using
 824    stored expressions which span multiple functions, such as BINFO_VTABLE,
 825    as the normal unsharing process can't tell that they're shared.  */
 826
 827 tree
 828 unshare_expr (tree expr)
 829 {
 830   walk_tree (&expr, mostly_copy_tree_r, NULL, NULL);
 831   return expr;
 832 }
 833
 834 /* A terser interface for building a representation of a exception
 835    specification.  */
 836
 837 tree
 838 gimple_build_eh_filter (tree body, tree allowed, tree failure)
 839 {
 840   tree t;
 841
 842   /* FIXME should the allowed types go in TREE_TYPE?  */
 843   t = build (EH_FILTER_EXPR, void_type_node, allowed, NULL_TREE);
 844   append_to_statement_list (failure, &EH_FILTER_FAILURE (t));
 845
 846   t = build (TRY_CATCH_EXPR, void_type_node, NULL_TREE, t);
 847   append_to_statement_list (body, &TREE_OPERAND (t, 0));
 848
 849   return t;
 850 }
 851
 852 \f
 853 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
 854    contain statements and have a value.  Assign its value to a temporary
 855    and give it void_type_node.  Returns the temporary, or NULL_TREE if
 856    WRAPPER was already void.  */
 857
 858 tree
 859 voidify_wrapper_expr (tree wrapper, tree temp)
 860 {
 861   if (!VOID_TYPE_P (TREE_TYPE (wrapper)))
 862     {
 863       tree *p, sub = wrapper;
 864
 865     restart:
 866       /* Set p to point to the body of the wrapper.  */
 867       switch (TREE_CODE (sub))
 868         {
 869         case BIND_EXPR:
 870           /* For a BIND_EXPR, the body is operand 1.  */
 871           p = &BIND_EXPR_BODY (sub);
 872           break;
 873
 874         default:
 875           p = &TREE_OPERAND (sub, 0);
 876           break;
 877         }
 878
 879       /* Advance to the last statement.  Set all container types to void.  */
 880       if (TREE_CODE (*p) == STATEMENT_LIST)
 881         {
 882           tree_stmt_iterator i = tsi_last (*p);
 883           p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i);
 884         }
 885       else
 886         {
 887           for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1))
 888             {
 889               TREE_SIDE_EFFECTS (*p) = 1;
 890               TREE_TYPE (*p) = void_type_node;
 891             }
 892         }
 893
 894       if (p == NULL || IS_EMPTY_STMT (*p))
 895         ;
 896       /* Look through exception handling.  */
 897       else if (TREE_CODE (*p) == TRY_FINALLY_EXPR
 898                || TREE_CODE (*p) == TRY_CATCH_EXPR)
 899         {
 900           sub = *p;
 901           goto restart;
 902         }
 903       /* The C++ frontend already did this for us.  */
 904       else if (TREE_CODE (*p) == INIT_EXPR)
 905         temp = TREE_OPERAND (*p, 0);
 906       /* If we're returning a dereference, move the dereference
 907          outside the wrapper.  */
 908       else if (TREE_CODE (*p) == INDIRECT_REF)
 909         {
 910           tree ptr = TREE_OPERAND (*p, 0);
 911           temp = create_tmp_var (TREE_TYPE (ptr), "retval");
 912           *p = build (MODIFY_EXPR, TREE_TYPE (ptr), temp, ptr);
 913           temp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (temp)), temp);
 914           /* If this is a BIND_EXPR for a const inline function, it might not
 915              have TREE_SIDE_EFFECTS set.  That is no longer accurate.  */
 916           TREE_SIDE_EFFECTS (wrapper) = 1;
 917         }
 918       else
 919         {
 920           if (!temp)
 921             temp = create_tmp_var (TREE_TYPE (wrapper), "retval");
 922           *p = build (MODIFY_EXPR, TREE_TYPE (temp), temp, *p);
 923           TREE_SIDE_EFFECTS (wrapper) = 1;
 924         }
 925
 926       TREE_TYPE (wrapper) = void_type_node;
 927       return temp;
 928     }
 929
 930   return NULL_TREE;
 931 }
 932
 933 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
 934    a temporary through which they communicate.  */
 935
 936 static void
 937 build_stack_save_restore (tree *save, tree *restore)
 938 {
 939   tree save_call, tmp_var;
 940
 941   save_call =
 942       build_function_call_expr (implicit_built_in_decls[BUILT_IN_STACK_SAVE],
 943                                 NULL_TREE);
 944   tmp_var = create_tmp_var (ptr_type_node, "saved_stack");
 945
 946   *save = build (MODIFY_EXPR, ptr_type_node, tmp_var, save_call);
 947   *restore =
 948     build_function_call_expr (implicit_built_in_decls[BUILT_IN_STACK_RESTORE],
 949                               tree_cons (NULL_TREE, tmp_var, NULL_TREE));
 950 }
 951
 952 /* Gimplify a BIND_EXPR.  Just voidify and recurse.  */
 953
 954 static enum gimplify_status
 955 gimplify_bind_expr (tree *expr_p, tree temp, tree *pre_p)
 956 {
 957   tree bind_expr = *expr_p;
 958   bool old_save_stack = gimplify_ctxp->save_stack;
 959   tree t;
 960
 961   temp = voidify_wrapper_expr (bind_expr, temp);
 962
 963   /* Mark variables seen in this bind expr.  */
 964   for (t = BIND_EXPR_VARS (bind_expr); t ; t = TREE_CHAIN (t))
 965     t->decl.seen_in_bind_expr = 1;
 966
 967   gimple_push_bind_expr (bind_expr);
 968   gimplify_ctxp->save_stack = false;
 969
 970   gimplify_to_stmt_list (&BIND_EXPR_BODY (bind_expr));
 971
 972   if (gimplify_ctxp->save_stack)
 973     {
 974       tree stack_save, stack_restore;
 975
 976       /* Save stack on entry and restore it on exit.  Add a try_finally
 977          block to achieve this.  Note that mudflap depends on the
 978          format of the emitted code: see mx_register_decls().  */
 979       build_stack_save_restore (&stack_save, &stack_restore);
 980
 981       t = build (TRY_FINALLY_EXPR, void_type_node,
 982                  BIND_EXPR_BODY (bind_expr), NULL_TREE);
 983       append_to_statement_list (stack_restore, &TREE_OPERAND (t, 1));
 984
 985       BIND_EXPR_BODY (bind_expr) = NULL_TREE;
 986       append_to_statement_list (stack_save, &BIND_EXPR_BODY (bind_expr));
 987       append_to_statement_list (t, &BIND_EXPR_BODY (bind_expr));
 988     }
 989
 990   gimplify_ctxp->save_stack = old_save_stack;
 991   gimple_pop_bind_expr ();
 992
 993   if (temp)
 994     {
 995       *expr_p = temp;
 996       append_to_statement_list (bind_expr, pre_p);
 997       return GS_OK;
 998     }
 999   else
1000     return GS_ALL_DONE;
1001 }
1002
1003 /* Gimplify a RETURN_EXPR.  If the expression to be returned is not a
1004    GIMPLE value, it is assigned to a new temporary and the statement is
1005    re-written to return the temporary.
1006
1007    PRE_P points to the list where side effects that must happen before
1008    STMT should be stored.  */
1009
1010 static enum gimplify_status
1011 gimplify_return_expr (tree stmt, tree *pre_p)
1012 {
1013   tree ret_expr = TREE_OPERAND (stmt, 0);
1014   tree result_decl, result;
1015
1016   if (!ret_expr || TREE_CODE (ret_expr) == RESULT_DECL)
1017     return GS_ALL_DONE;
1018
1019   if (ret_expr == error_mark_node)
1020     return GS_ERROR;
1021
1022   if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
1023     result_decl = NULL_TREE;
1024   else
1025     {
1026       result_decl = TREE_OPERAND (ret_expr, 0);
1027 #ifdef ENABLE_CHECKING
1028       if ((TREE_CODE (ret_expr) != MODIFY_EXPR
1029            && TREE_CODE (ret_expr) != INIT_EXPR)
1030           || TREE_CODE (result_decl) != RESULT_DECL)
1031         abort ();
1032 #endif
1033     }
1034
1035   /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1036      Recall that aggregate_value_p is FALSE for any aggregate type that is
1037      returned in registers.  If we're returning values in registers, then
1038      we don't want to extend the lifetime of the RESULT_DECL, particularly
1039      across another call.  In addition, for those aggregates for which
1040      hard_function_value generates a PARALLEL, we'll abort during normal
1041      expansion of structure assignments; there's special code in expand_return
1042      to handle this case that does not exist in expand_expr.  */
1043   if (!result_decl
1044       || aggregate_value_p (result_decl, TREE_TYPE (current_function_decl)))
1045     result = result_decl;
1046   else if (gimplify_ctxp->return_temp)
1047     result = gimplify_ctxp->return_temp;
1048   else
1049     {
1050       result = create_tmp_var (TREE_TYPE (result_decl), NULL);
1051
1052       /* ??? With complex control flow (usually involving abnormal edges),
1053          we can wind up warning about an uninitialized value for this.  Due
1054          to how this variable is constructed and initialized, this is never
1055          true.  Give up and never warn.  */
1056       TREE_NO_WARNING (result) = 1;
1057
1058       gimplify_ctxp->return_temp = result;
1059     }
1060
1061   /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1062      Then gimplify the whole thing.  */
1063   if (result != result_decl)
1064     TREE_OPERAND (ret_expr, 0) = result;
1065   gimplify_stmt (&TREE_OPERAND (stmt, 0));
1066   append_to_statement_list (TREE_OPERAND (stmt, 0), pre_p);
1067
1068   /* If we didn't use a temporary, then the result is just the result_decl.
1069      Otherwise we need a simple copy.  This should already be gimple.  */
1070   if (result == result_decl)
1071     ret_expr = result;
1072   else
1073     ret_expr = build (MODIFY_EXPR, TREE_TYPE (result), result_decl, result);
1074   TREE_OPERAND (stmt, 0) = ret_expr;
1075
1076   return GS_ALL_DONE;
1077 }
1078
1079 /* Gimplify a LOOP_EXPR.  Normally this just involves gimplifying the body
1080    and replacing the LOOP_EXPR with goto, but if the loop contains an
1081    EXIT_EXPR, we need to append a label for it to jump to.  */
1082
1083 static enum gimplify_status
1084 gimplify_loop_expr (tree *expr_p, tree *pre_p)
1085 {
1086   tree saved_label = gimplify_ctxp->exit_label;
1087   tree start_label = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
1088   tree jump_stmt = build_and_jump (&LABEL_EXPR_LABEL (start_label));
1089
1090   append_to_statement_list (start_label, pre_p);
1091
1092   gimplify_ctxp->exit_label = NULL_TREE;
1093
1094   gimplify_stmt (&LOOP_EXPR_BODY (*expr_p));
1095   append_to_statement_list (LOOP_EXPR_BODY (*expr_p), pre_p);
1096
1097   if (gimplify_ctxp->exit_label)
1098     {
1099       append_to_statement_list (jump_stmt, pre_p);
1100       *expr_p = build1 (LABEL_EXPR, void_type_node, gimplify_ctxp->exit_label);
1101     }
1102   else
1103     *expr_p = jump_stmt;
1104
1105   gimplify_ctxp->exit_label = saved_label;
1106
1107   return GS_ALL_DONE;
1108 }
1109
1110 /* Compare two case labels.  Because the front end should already have
1111    made sure that case ranges do not overlap, it is enough to only compare
1112    the CASE_LOW values of each case label.  */
1113
1114 static int
1115 compare_case_labels (const void *p1, const void *p2)
1116 {
1117   tree case1 = *(tree *)p1;
1118   tree case2 = *(tree *)p2;
1119
1120   return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
1121 }
1122
1123 /* Sort the case labels in LABEL_VEC in ascending order.  */
1124
1125 void
1126 sort_case_labels (tree label_vec)
1127 {
1128   size_t len = TREE_VEC_LENGTH (label_vec);
1129   tree default_case = TREE_VEC_ELT (label_vec, len - 1);
1130
1131   if (CASE_LOW (default_case))
1132     {
1133       size_t i;
1134
1135       /* The last label in the vector should be the default case
1136          but it is not.  */
1137       for (i = 0; i < len; ++i)
1138         {
1139           tree t = TREE_VEC_ELT (label_vec, i);
1140           if (!CASE_LOW (t))
1141             {
1142               default_case = t;
1143               TREE_VEC_ELT (label_vec, i) = TREE_VEC_ELT (label_vec, len - 1);
1144               TREE_VEC_ELT (label_vec, len - 1) = default_case;
1145               break;
1146             }
1147         }
1148     }
1149
1150   qsort (&TREE_VEC_ELT (label_vec, 0), len - 1, sizeof (tree),
1151          compare_case_labels);
1152 }
1153
1154 /* Gimplify a SWITCH_EXPR, and collect a TREE_VEC of the labels it can
1155    branch to.  */
1156
1157 static enum gimplify_status
1158 gimplify_switch_expr (tree *expr_p, tree *pre_p)
1159 {
1160   tree switch_expr = *expr_p;
1161   enum gimplify_status ret;
1162
1163   ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL,
1164                        is_gimple_val, fb_rvalue);
1165
1166   if (SWITCH_BODY (switch_expr))
1167     {
1168       varray_type labels, saved_labels;
1169       tree label_vec, default_case = NULL_TREE;
1170       size_t i, len;
1171
1172       /* If someone can be bothered to fill in the labels, they can
1173          be bothered to null out the body too.  */
1174       if (SWITCH_LABELS (switch_expr))
1175         abort ();
1176
1177       saved_labels = gimplify_ctxp->case_labels;
1178       VARRAY_TREE_INIT (gimplify_ctxp->case_labels, 8, "case_labels");
1179
1180       gimplify_to_stmt_list (&SWITCH_BODY (switch_expr));
1181
1182       labels = gimplify_ctxp->case_labels;
1183       gimplify_ctxp->case_labels = saved_labels;
1184
1185       len = VARRAY_ACTIVE_SIZE (labels);
1186
1187       for (i = 0; i < len; ++i)
1188         {
1189           tree t = VARRAY_TREE (labels, i);
1190           if (!CASE_LOW (t))
1191             {
1192               /* The default case must be the last label in the list.  */
1193               default_case = t;
1194               VARRAY_TREE (labels, i) = VARRAY_TREE (labels, len - 1);
1195               len--;
1196               break;
1197             }
1198         }
1199
1200       label_vec = make_tree_vec (len + 1);
1201       SWITCH_LABELS (*expr_p) = label_vec;
1202       append_to_statement_list (switch_expr, pre_p);
1203
1204       if (! default_case)
1205         {
1206           /* If the switch has no default label, add one, so that we jump
1207              around the switch body.  */
1208           default_case = build (CASE_LABEL_EXPR, void_type_node, NULL_TREE,
1209                                 NULL_TREE, create_artificial_label ());
1210           append_to_statement_list (SWITCH_BODY (switch_expr), pre_p);
1211           *expr_p = build (LABEL_EXPR, void_type_node,
1212                            CASE_LABEL (default_case));
1213         }
1214       else
1215         *expr_p = SWITCH_BODY (switch_expr);
1216
1217       for (i = 0; i < len; ++i)
1218         TREE_VEC_ELT (label_vec, i) = VARRAY_TREE (labels, i);
1219       TREE_VEC_ELT (label_vec, len) = default_case;
1220
1221       sort_case_labels (label_vec);
1222
1223       SWITCH_BODY (switch_expr) = NULL;
1224     }
1225   else if (!SWITCH_LABELS (switch_expr))
1226     abort ();
1227
1228   return ret;
1229 }
1230
1231 static enum gimplify_status
1232 gimplify_case_label_expr (tree *expr_p)
1233 {
1234   tree expr = *expr_p;
1235   if (gimplify_ctxp->case_labels)
1236     VARRAY_PUSH_TREE (gimplify_ctxp->case_labels, expr);
1237   else
1238     abort ();
1239   *expr_p = build (LABEL_EXPR, void_type_node, CASE_LABEL (expr));
1240   return GS_ALL_DONE;
1241 }
1242
1243 /* Gimplify a LABELED_BLOCK_EXPR into a LABEL_EXPR following
1244    a (possibly empty) body.  */
1245
1246 static enum gimplify_status
1247 gimplify_labeled_block_expr (tree *expr_p)
1248 {
1249   tree body = LABELED_BLOCK_BODY (*expr_p);
1250   tree label = LABELED_BLOCK_LABEL (*expr_p);
1251   tree t;
1252
1253   DECL_CONTEXT (label) = current_function_decl;
1254   t = build (LABEL_EXPR, void_type_node, label);
1255   if (body != NULL_TREE)
1256     t = build (COMPOUND_EXPR, void_type_node, body, t);
1257   *expr_p = t;
1258
1259   return GS_OK;
1260 }
1261
1262 /* Gimplify a EXIT_BLOCK_EXPR into a GOTO_EXPR.  */
1263
1264 static enum gimplify_status
1265 gimplify_exit_block_expr (tree *expr_p)
1266 {
1267   tree labeled_block = TREE_OPERAND (*expr_p, 0);
1268   tree label;
1269
1270   /* First operand must be a LABELED_BLOCK_EXPR, which should
1271      already be lowered (or partially lowered) when we get here.  */
1272 #if defined ENABLE_CHECKING
1273   if (TREE_CODE (labeled_block) != LABELED_BLOCK_EXPR)
1274     abort ();
1275 #endif
1276
1277   label = LABELED_BLOCK_LABEL (labeled_block);
1278   *expr_p = build1 (GOTO_EXPR, void_type_node, label);
1279
1280   return GS_OK;
1281 }
1282
1283 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1284    if necessary.  */
1285
1286 tree
1287 build_and_jump (tree *label_p)
1288 {
1289   if (label_p == NULL)
1290     /* If there's nowhere to jump, just fall through.  */
1291     return NULL_TREE;
1292
1293   if (*label_p == NULL_TREE)
1294     {
1295       tree label = create_artificial_label ();
1296       *label_p = label;
1297     }
1298
1299   return build1 (GOTO_EXPR, void_type_node, *label_p);
1300 }
1301
1302 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1303    This also involves building a label to jump to and communicating it to
1304    gimplify_loop_expr through gimplify_ctxp->exit_label.  */
1305
1306 static enum gimplify_status
1307 gimplify_exit_expr (tree *expr_p)
1308 {
1309   tree cond = TREE_OPERAND (*expr_p, 0);
1310   tree expr;
1311
1312   expr = build_and_jump (&gimplify_ctxp->exit_label);
1313   expr = build (COND_EXPR, void_type_node, cond, expr, NULL_TREE);
1314   *expr_p = expr;
1315
1316   return GS_OK;
1317 }
1318
1319 /* A helper function to be called via walk_tree.  Mark all labels under *TP
1320    as being forced.  To be called for DECL_INITIAL of static variables.  */
1321
1322 tree
1323 force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1324 {
1325   if (TYPE_P (*tp))
1326     *walk_subtrees = 0;
1327   if (TREE_CODE (*tp) == LABEL_DECL)
1328     FORCED_LABEL (*tp) = 1;
1329
1330   return NULL_TREE;
1331 }
1332
1333 /* Break out elements of a constructor used as an initializer into separate
1334    MODIFY_EXPRs.
1335
1336    Note that we still need to clear any elements that don't have explicit
1337    initializers, so if not all elements are initialized we keep the
1338    original MODIFY_EXPR, we just remove all of the constructor elements.  */
1339
1340 static enum gimplify_status
1341 gimplify_init_constructor (tree *expr_p, tree *pre_p,
1342                            tree *post_p, bool want_value)
1343 {
1344   tree object = TREE_OPERAND (*expr_p, 0);
1345   tree ctor = TREE_OPERAND (*expr_p, 1);
1346   tree type = TREE_TYPE (ctor);
1347   enum gimplify_status ret;
1348   tree elt_list;
1349
1350   if (TREE_CODE (ctor) != CONSTRUCTOR)
1351     return GS_UNHANDLED;
1352
1353   elt_list = CONSTRUCTOR_ELTS (ctor);
1354
1355   ret = GS_ALL_DONE;
1356   switch (TREE_CODE (type))
1357     {
1358     case RECORD_TYPE:
1359     case UNION_TYPE:
1360     case QUAL_UNION_TYPE:
1361     case ARRAY_TYPE:
1362       {
1363         HOST_WIDE_INT i, num_elements, num_nonzero_elements;
1364         HOST_WIDE_INT num_nonconstant_elements;
1365         bool cleared;
1366
1367         /* Aggregate types must lower constructors to initialization of
1368            individual elements.  The exception is that a CONSTRUCTOR node
1369            with no elements indicates zero-initialization of the whole.  */
1370         if (elt_list == NULL)
1371           {
1372             if (want_value)
1373               {
1374                 *expr_p = object;
1375                 return GS_OK;
1376               }
1377             else
1378               return GS_UNHANDLED;
1379           }
1380
1381         categorize_ctor_elements (ctor, &num_nonzero_elements,
1382                                   &num_nonconstant_elements);
1383         num_elements = count_type_elements (TREE_TYPE (ctor));
1384
1385         /* If a const aggregate variable is being initialized, then it
1386            should never be a lose to promote the variable to be static.  */
1387         if (num_nonconstant_elements == 0
1388             && TREE_READONLY (object)
1389             && TREE_CODE (object) == VAR_DECL)
1390           {
1391             DECL_INITIAL (object) = ctor;
1392             TREE_STATIC (object) = 1;
1393             if (!DECL_NAME (object))
1394               DECL_NAME (object) = create_tmp_var_name ("C");
1395             walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL);
1396
1397             /* ??? C++ doesn't automatically append a .<number> to the
1398                assembler name, and even when it does, it looks a FE private
1399                data structures to figure out what that number should be,
1400                which are not set for this variable.  I suppose this is
1401                important for local statics for inline functions, which aren't
1402                "local" in the object file sense.  So in order to get a unique
1403                TU-local symbol, we must invoke the lhd version now.  */
1404             lhd_set_decl_assembler_name (object);
1405
1406             *expr_p = NULL_TREE;
1407             break;
1408           }
1409
1410         /* If there are "lots" of initialized elements, and all of them
1411            are valid address constants, then the entire initializer can
1412            be dropped to memory, and then memcpy'd out.  */
1413         if (num_nonconstant_elements == 0)
1414           {
1415             HOST_WIDE_INT size = int_size_in_bytes (type);
1416             unsigned int align;
1417
1418             /* ??? We can still get unbounded array types, at least
1419                from the C++ front end.  This seems wrong, but attempt
1420                to work around it for now.  */
1421             if (size < 0)
1422               {
1423                 size = int_size_in_bytes (TREE_TYPE (object));
1424                 if (size >= 0)
1425                   TREE_TYPE (ctor) = type = TREE_TYPE (object);
1426               }
1427
1428             /* Find the maximum alignment we can assume for the object.  */
1429             /* ??? Make use of DECL_OFFSET_ALIGN.  */
1430             if (DECL_P (object))
1431               align = DECL_ALIGN (object);
1432             else
1433               align = TYPE_ALIGN (type);
1434
1435             if (size > 0 && !can_move_by_pieces (size, align))
1436               {
1437                 tree new = create_tmp_var_raw (type, "C");
1438                 gimple_add_tmp_var (new);
1439                 TREE_STATIC (new) = 1;
1440                 TREE_READONLY (new) = 1;
1441                 DECL_INITIAL (new) = ctor;
1442                 if (align > DECL_ALIGN (new))
1443                   {
1444                     DECL_ALIGN (new) = align;
1445                     DECL_USER_ALIGN (new) = 1;
1446                   }
1447                 walk_tree (&DECL_INITIAL (new), force_labels_r, NULL, NULL);
1448
1449                 TREE_OPERAND (*expr_p, 1) = new;
1450                 break;
1451               }
1452           }
1453
1454         /* If there are "lots" of initialized elements, even discounting
1455            those that are not address constants (and thus *must* be
1456            computed at runtime), then partition the constructor into
1457            constant and non-constant parts.  Block copy the constant
1458            parts in, then generate code for the non-constant parts.  */
1459         /* TODO.  There's code in cp/typeck.c to do this.  */
1460
1461         /* If there are "lots" of zeros, then block clear the object first.  */
1462         cleared = false;
1463         if (num_elements - num_nonzero_elements > CLEAR_RATIO
1464             && num_nonzero_elements < num_elements/4)
1465           cleared = true;
1466
1467         /* ??? This bit ought not be needed.  For any element not present
1468            in the initializer, we should simply set them to zero.  Except
1469            we'd need to *find* the elements that are not present, and that
1470            requires trickery to avoid quadratic compile-time behavior in
1471            large cases or excessive memory use in small cases.  */
1472         else
1473           {
1474             HOST_WIDE_INT len = list_length (elt_list);
1475             if (TREE_CODE (type) == ARRAY_TYPE)
1476               {
1477                 tree nelts = array_type_nelts (type);
1478                 if (!host_integerp (nelts, 1)
1479                     || tree_low_cst (nelts, 1) != len)
1480                   cleared = 1;;
1481               }
1482             else if (len != fields_length (type))
1483               cleared = 1;
1484           }
1485
1486         if (cleared)
1487           {
1488             CONSTRUCTOR_ELTS (ctor) = NULL_TREE;
1489             append_to_statement_list (*expr_p, pre_p);
1490           }
1491
1492         for (i = 0; elt_list; i++, elt_list = TREE_CHAIN (elt_list))
1493           {
1494             tree purpose, value, cref, init;
1495
1496             purpose = TREE_PURPOSE (elt_list);
1497             value = TREE_VALUE (elt_list);
1498
1499             if (cleared && initializer_zerop (value))
1500               continue;
1501
1502             if (TREE_CODE (type) == ARRAY_TYPE)
1503               {
1504                 tree t = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
1505
1506                 /* ??? Here's to hoping the front end fills in all of the
1507                    indicies, so we don't have to figure out what's missing
1508                    ourselves.  */
1509                 if (!purpose)
1510                   abort ();
1511                 /* ??? Need to handle this.  */
1512                 if (TREE_CODE (purpose) == RANGE_EXPR)
1513                   abort ();
1514
1515                 cref = build (ARRAY_REF, t, object, purpose, NULL_TREE, NULL_TREE);
1516               }
1517             else
1518               cref = build (COMPONENT_REF, TREE_TYPE (purpose), object,
1519                             purpose, NULL_TREE);
1520
1521             init = build (MODIFY_EXPR, TREE_TYPE (purpose), cref, value);
1522             /* Each member initialization is a full-expression.  */
1523             gimplify_stmt (&init);
1524             append_to_statement_list (init, pre_p);
1525           }
1526
1527         *expr_p = NULL_TREE;
1528       }
1529       break;
1530
1531     case COMPLEX_TYPE:
1532       {
1533         tree r, i;
1534
1535         /* Extract the real and imaginary parts out of the ctor.  */
1536         r = i = NULL_TREE;
1537         if (elt_list)
1538           {
1539             r = TREE_VALUE (elt_list);
1540             elt_list = TREE_CHAIN (elt_list);
1541             if (elt_list)
1542               {
1543                 i = TREE_VALUE (elt_list);
1544                 if (TREE_CHAIN (elt_list))
1545                   abort ();
1546               }
1547           }
1548         if (r == NULL || i == NULL)
1549           {
1550             tree zero = convert (TREE_TYPE (type), integer_zero_node);
1551             if (r == NULL)
1552               r = zero;
1553             if (i == NULL)
1554               i = zero;
1555           }
1556
1557         /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
1558            represent creation of a complex value.  */
1559         if (TREE_CONSTANT (r) && TREE_CONSTANT (i))
1560           {
1561             ctor = build_complex (type, r, i);
1562             TREE_OPERAND (*expr_p, 1) = ctor;
1563           }
1564         else
1565           {
1566             ctor = build (COMPLEX_EXPR, type, r, i);
1567             TREE_OPERAND (*expr_p, 1) = ctor;
1568             ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
1569                                  is_gimple_rhs, fb_rvalue);
1570           }
1571       }
1572       break;
1573
1574     case VECTOR_TYPE:
1575       /* Go ahead and simplify constant constructors to VECTOR_CST.  */
1576       if (TREE_CONSTANT (ctor))
1577         TREE_OPERAND (*expr_p, 1) = build_vector (type, elt_list);
1578       else
1579         {
1580           /* Vector types use CONSTRUCTOR all the way through gimple
1581              compilation as a general initializer.  */
1582           for (; elt_list; elt_list = TREE_CHAIN (elt_list))
1583             {
1584               enum gimplify_status tret;
1585               tret = gimplify_expr (&TREE_VALUE (elt_list), pre_p, post_p,
1586                                     is_gimple_constructor_elt, fb_rvalue);
1587               if (tret == GS_ERROR)
1588                 ret = GS_ERROR;
1589             }
1590         }
1591       break;
1592
1593     default:
1594       /* So how did we get a CONSTRUCTOR for a scalar type?  */
1595       abort ();
1596     }
1597
1598   if (ret == GS_ERROR)
1599     return GS_ERROR;
1600   else if (want_value)
1601     {
1602       append_to_statement_list (*expr_p, pre_p);
1603       *expr_p = object;
1604       return GS_OK;
1605     }
1606   else
1607     return GS_ALL_DONE;
1608 }
1609
1610 /* *EXPR_P is a COMPONENT_REF being used as an rvalue.  If its type is
1611    different from its canonical type, wrap the whole thing inside a
1612    NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1613    type.
1614
1615    The canonical type of a COMPONENT_REF is the type of the field being
1616    referenced--unless the field is a bit-field which can be read directly
1617    in a smaller mode, in which case the canonical type is the
1618    sign-appropriate type corresponding to that mode.  */
1619
1620 static void
1621 canonicalize_component_ref (tree *expr_p)
1622 {
1623   tree expr = *expr_p;
1624   tree type;
1625
1626   if (TREE_CODE (expr) != COMPONENT_REF)
1627     abort ();
1628
1629   if (INTEGRAL_TYPE_P (TREE_TYPE (expr)))
1630     type = TREE_TYPE (get_unwidened (expr, NULL_TREE));
1631   else
1632     type = TREE_TYPE (TREE_OPERAND (expr, 1));
1633
1634   if (TREE_TYPE (expr) != type)
1635     {
1636       tree old_type = TREE_TYPE (expr);
1637
1638       /* Set the type of the COMPONENT_REF to the underlying type.  */
1639       TREE_TYPE (expr) = type;
1640
1641       /* And wrap the whole thing inside a NOP_EXPR.  */
1642       expr = build1 (NOP_EXPR, old_type, expr);
1643
1644       *expr_p = expr;
1645     }
1646 }
1647
1648 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1649    to foo, embed that change in the ADDR_EXPR by converting
1650       T array[U];
1651       (T *)&array
1652    ==>
1653       &array[L]
1654    where L is the lower bound.  Only do this for constant lower bound since
1655    we have no place to put any statements made during gimplification of
1656    the lower bound.  */
1657
1658 static void
1659 canonicalize_addr_expr (tree *expr_p)
1660 {
1661   tree expr = *expr_p;
1662   tree ctype = TREE_TYPE (expr);
1663   tree addr_expr = TREE_OPERAND (expr, 0);
1664   tree atype = TREE_TYPE (addr_expr);
1665   tree dctype, datype, ddatype, otype, obj_expr;
1666
1667   /* Both cast and addr_expr types should be pointers.  */
1668   if (!POINTER_TYPE_P (ctype) || !POINTER_TYPE_P (atype))
1669     return;
1670
1671   /* The addr_expr type should be a pointer to an array.  */
1672   datype = TREE_TYPE (atype);
1673   if (TREE_CODE (datype) != ARRAY_TYPE)
1674     return;
1675
1676   /* Both cast and addr_expr types should address the same object type.  */
1677   dctype = TREE_TYPE (ctype);
1678   ddatype = TREE_TYPE (datype);
1679   if (!lang_hooks.types_compatible_p (ddatype, dctype))
1680     return;
1681
1682   /* The addr_expr and the object type should match.  */
1683   obj_expr = TREE_OPERAND (addr_expr, 0);
1684   otype = TREE_TYPE (obj_expr);
1685   if (!lang_hooks.types_compatible_p (otype, datype))
1686     return;
1687
1688   /* The lower bound and element sizes must be constant.  */
1689   if (TREE_CODE (TYPE_SIZE_UNIT (dctype)) != INTEGER_CST
1690       || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype))
1691       || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST)
1692     return;
1693
1694   /* All checks succeeded.  Build a new node to merge the cast.  */
1695   *expr_p = build4 (ARRAY_REF, dctype, obj_expr,
1696                     TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
1697                     TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
1698                     size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (dctype),
1699                                 size_int (TYPE_ALIGN (dctype)
1700                                           / BITS_PER_UNIT)));
1701   *expr_p = build1 (ADDR_EXPR, ctype, *expr_p);
1702 }
1703
1704 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR.  Remove it and/or other conversions
1705    underneath as appropriate.  */
1706
1707 static enum gimplify_status
1708 gimplify_conversion (tree *expr_p)
1709 {
1710   /* Strip away as many useless type conversions as possible
1711      at the toplevel.  */
1712   STRIP_USELESS_TYPE_CONVERSION (*expr_p);
1713
1714   /* If we still have a conversion at the toplevel, then strip
1715      away all but the outermost conversion.  */
1716   if (TREE_CODE (*expr_p) == NOP_EXPR || TREE_CODE (*expr_p) == CONVERT_EXPR)
1717     {
1718       STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0));
1719
1720       /* And remove the outermost conversion if it's useless.  */
1721       if (tree_ssa_useless_type_conversion (*expr_p))
1722         *expr_p = TREE_OPERAND (*expr_p, 0);
1723     }
1724
1725   /* If we still have a conversion at the toplevel,
1726      then canonicalize some constructs.  */
1727   if (TREE_CODE (*expr_p) == NOP_EXPR || TREE_CODE (*expr_p) == CONVERT_EXPR)
1728     {
1729       tree sub = TREE_OPERAND (*expr_p, 0);
1730
1731       /* If a NOP conversion is changing the type of a COMPONENT_REF
1732          expression, then canonicalize its type now in order to expose more
1733          redundant conversions.  */
1734       if (TREE_CODE (sub) == COMPONENT_REF)
1735         canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
1736
1737       /* If a NOP conversion is changing a pointer to array of foo
1738          to a pointer to foo, embed that change in the ADDR_EXPR.  */
1739       else if (TREE_CODE (sub) == ADDR_EXPR)
1740         canonicalize_addr_expr (expr_p);
1741     }
1742
1743   return GS_OK;
1744 }
1745
1746 /* Reduce MIN/MAX_EXPR to a COND_EXPR for further gimplification.  */
1747
1748 static enum gimplify_status
1749 gimplify_minimax_expr (tree *expr_p, tree *pre_p, tree *post_p)
1750 {
1751   tree op1 = TREE_OPERAND (*expr_p, 0);
1752   tree op2 = TREE_OPERAND (*expr_p, 1);
1753   enum tree_code code;
1754   enum gimplify_status r0, r1;
1755
1756   if (TREE_CODE (*expr_p) == MIN_EXPR)
1757     code = LE_EXPR;
1758   else
1759     code = GE_EXPR;
1760
1761   r0 = gimplify_expr (&op1, pre_p, post_p, is_gimple_val, fb_rvalue);
1762   r1 = gimplify_expr (&op2, pre_p, post_p, is_gimple_val, fb_rvalue);
1763
1764   *expr_p = build (COND_EXPR, TREE_TYPE (*expr_p),
1765                    build (code, boolean_type_node, op1, op2),
1766                    op1, op2);
1767
1768   if (r0 == GS_ERROR || r1 == GS_ERROR)
1769     return GS_ERROR;
1770   else
1771     return GS_OK;
1772 }
1773
1774 /* Subroutine of gimplify_compound_lval.
1775    Converts an ARRAY_REF to the equivalent *(&array + offset) form.  */
1776
1777 static enum gimplify_status
1778 gimplify_array_ref_to_plus (tree *expr_p, tree *pre_p, tree *post_p)
1779 {
1780   tree array = TREE_OPERAND (*expr_p, 0);
1781   tree arrtype = TREE_TYPE (array);
1782   tree elttype = TREE_TYPE (arrtype);
1783   tree size = array_ref_element_size (*expr_p);
1784   tree ptrtype = build_pointer_type (elttype);
1785   enum tree_code add_code = PLUS_EXPR;
1786   tree idx = TREE_OPERAND (*expr_p, 1);
1787   tree minidx = unshare_expr (array_ref_low_bound (*expr_p));
1788   tree offset, addr, result;
1789   enum gimplify_status ret;
1790
1791   /* If the array domain does not start at zero, apply the offset.  */
1792   if (!integer_zerop (minidx))
1793     {
1794       idx = convert (TREE_TYPE (minidx), idx);
1795       idx = fold (build (MINUS_EXPR, TREE_TYPE (minidx), idx, minidx));
1796     }
1797
1798   /* If the index is negative -- a technically invalid situation now
1799      that we've biased the index back to zero -- then casting it to
1800      unsigned has ill effects.  In particular, -1*4U/4U != -1.
1801      Represent this as a subtraction of a positive rather than addition
1802      of a negative.  This will prevent any conversion back to ARRAY_REF
1803      from getting the wrong results from the division.  */
1804   if (TREE_CODE (idx) == INTEGER_CST && tree_int_cst_sgn (idx) < 0)
1805     {
1806       idx = fold (build1 (NEGATE_EXPR, TREE_TYPE (idx), idx));
1807       add_code = MINUS_EXPR;
1808     }
1809
1810   /* Pointer arithmetic must be done in sizetype.  */
1811   idx = fold_convert (sizetype, idx);
1812
1813   /* Convert the index to a byte offset.  */
1814   offset = size_binop (MULT_EXPR, size, idx);
1815
1816   ret = gimplify_expr (&array, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
1817   if (ret == GS_ERROR)
1818     return ret;
1819
1820   addr = build_fold_addr_expr_with_type (array, ptrtype);
1821   result = fold (build (add_code, ptrtype, addr, offset));
1822   *expr_p = build1 (INDIRECT_REF, elttype, result);
1823
1824   return GS_OK;
1825 }
1826
1827 /*  Build an expression for the address of T.  Folds away INDIRECT_REF to
1828     avoid confusing the gimplify process.  */
1829
1830 static tree
1831 build_addr_expr_with_type (tree t, tree ptrtype)
1832 {
1833   if (TREE_CODE (t) == INDIRECT_REF)
1834     {
1835       t = TREE_OPERAND (t, 0);
1836       if (TREE_TYPE (t) != ptrtype)
1837         t = build1 (NOP_EXPR, ptrtype, t);
1838     }
1839   else
1840     {
1841       tree base = t;
1842
1843       if (TREE_CODE (base) == REALPART_EXPR
1844           || TREE_CODE (base) == IMAGPART_EXPR)
1845         base = TREE_OPERAND (base, 0);
1846       else
1847         while (handled_component_p (base))
1848           base = TREE_OPERAND (base, 0);
1849
1850       if (DECL_P (base))
1851         TREE_ADDRESSABLE (base) = 1;
1852
1853       t = build1 (ADDR_EXPR, ptrtype, t);
1854     }
1855
1856   return t;
1857 }
1858
1859 static tree
1860 build_addr_expr (tree t)
1861 {
1862   return build_addr_expr_with_type (t, build_pointer_type (TREE_TYPE (t)));
1863 }
1864
1865 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
1866    node pointed by EXPR_P.
1867
1868       compound_lval
1869               : min_lval '[' val ']'
1870               | min_lval '.' ID
1871               | compound_lval '[' val ']'
1872               | compound_lval '.' ID
1873
1874    This is not part of the original SIMPLE definition, which separates
1875    array and member references, but it seems reasonable to handle them
1876    together.  Also, this way we don't run into problems with union
1877    aliasing; gcc requires that for accesses through a union to alias, the
1878    union reference must be explicit, which was not always the case when we
1879    were splitting up array and member refs.
1880
1881    PRE_P points to the list where side effects that must happen before
1882      *EXPR_P should be stored.
1883
1884    POST_P points to the list where side effects that must happen after
1885      *EXPR_P should be stored.  */
1886
1887 static enum gimplify_status
1888 gimplify_compound_lval (tree *expr_p, tree *pre_p,
1889                         tree *post_p, bool want_lvalue)
1890 {
1891   tree *p;
1892   varray_type stack;
1893   enum gimplify_status ret = GS_OK, tret;
1894
1895 #if defined ENABLE_CHECKING
1896   if (TREE_CODE (*expr_p) != ARRAY_REF
1897       && TREE_CODE (*expr_p) != ARRAY_RANGE_REF
1898       && TREE_CODE (*expr_p) != COMPONENT_REF
1899       && TREE_CODE (*expr_p) != BIT_FIELD_REF
1900       && TREE_CODE (*expr_p) != REALPART_EXPR
1901       && TREE_CODE (*expr_p) != IMAGPART_EXPR)
1902     abort ();
1903 #endif
1904
1905   /* Create a stack of the subexpressions so later we can walk them in
1906      order from inner to outer.  */
1907   VARRAY_TREE_INIT (stack, 10, "stack");
1908
1909   /* We can either handle one REALPART_EXPR or IMAGEPART_EXPR or
1910      nest of handled components.  */
1911   if (TREE_CODE (*expr_p) == REALPART_EXPR
1912       || TREE_CODE (*expr_p) == IMAGPART_EXPR)
1913     p = &TREE_OPERAND (*expr_p, 0);
1914   else
1915     for (p = expr_p; handled_component_p (*p); p = &TREE_OPERAND (*p, 0))
1916       VARRAY_PUSH_TREE (stack, *p);
1917
1918   /* Now STACK is a stack of pointers to all the refs we've walked through
1919      and P points to the innermost expression.
1920
1921      Process each of the outer nodes from left to right, then gimplify the
1922      base.  We need to do it in this order so that PLACEHOLDER_EXPRs
1923      can be resolved.  */
1924   for (; VARRAY_ACTIVE_SIZE (stack) > 0; )
1925     {
1926       tree t = VARRAY_TOP_TREE (stack);
1927
1928       if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1929         {
1930           /* Gimplify the dimension.
1931              Temporary fix for gcc.c-torture/execute/20040313-1.c.
1932              Gimplify non-constant array indices into a temporary
1933              variable.
1934              FIXME - The real fix is to gimplify post-modify
1935              expressions into a minimal gimple lvalue.  However, that
1936              exposes bugs in alias analysis.  The alias analyzer does
1937              not handle &PTR->FIELD very well.  Will fix after the
1938              branch is merged into mainline (dnovillo 2004-05-03).  */
1939           if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
1940             {
1941               tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
1942                                     is_gimple_tmp_var, fb_rvalue);
1943               ret = MIN (ret, tret);
1944             }
1945
1946           /* Gimplify the low bound and element type size and put them into
1947              the ARRAY_REF.  If these values are set, they have already been
1948              gimplified.  */
1949           if (!TREE_OPERAND (t, 2))
1950             {
1951               tree low = unshare_expr (array_ref_low_bound (t));
1952               if (!is_gimple_min_invariant (low))
1953                 {
1954                   TREE_OPERAND (t, 2) = low;
1955                   tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
1956                                         is_gimple_tmp_var, fb_rvalue);
1957                   ret = MIN (ret, tret);
1958                 }
1959             }
1960
1961           if (!TREE_OPERAND (t, 3))
1962             {
1963               tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
1964               tree elmt_size = unshare_expr (array_ref_element_size (t));
1965               tree factor = size_int (TYPE_ALIGN (elmt_type) / BITS_PER_UNIT);
1966
1967               /* Divide the element size by the alignment of the element
1968                  type (above).  */
1969               elmt_size = size_binop (EXACT_DIV_EXPR, elmt_size, factor);
1970
1971               if (!is_gimple_min_invariant (elmt_size))
1972                 {
1973                   TREE_OPERAND (t, 3) = elmt_size;
1974                   tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p, post_p,
1975                                         is_gimple_tmp_var, fb_rvalue);
1976                   ret = MIN (ret, tret);
1977                 }
1978             }
1979         }
1980       else if (TREE_CODE (t) == COMPONENT_REF)
1981         {
1982           /* Set the field offset into T and gimplify it.  */
1983           if (!TREE_OPERAND (t, 2))
1984             {
1985               tree offset = unshare_expr (component_ref_field_offset (t));
1986               tree field = TREE_OPERAND (t, 1);
1987               tree factor
1988                 = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
1989
1990               /* Divide the offset by its alignment.  */
1991               offset = size_binop (EXACT_DIV_EXPR, offset, factor);
1992
1993               if (!is_gimple_min_invariant (offset))
1994                 {
1995                   TREE_OPERAND (t, 2) = offset;
1996                   tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
1997                                         is_gimple_tmp_var, fb_rvalue);
1998                   ret = MIN (ret, tret);
1999                 }
2000             }
2001         }
2002       else if (TREE_CODE (t) == BIT_FIELD_REF)
2003         {
2004           tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
2005                                 is_gimple_val, fb_rvalue);
2006           ret = MIN (ret, tret);
2007           tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2008                                 is_gimple_val, fb_rvalue);
2009           ret = MIN (ret, tret);
2010         }
2011
2012       recalculate_side_effects (t);
2013       VARRAY_POP (stack);
2014     }
2015
2016   tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
2017                         want_lvalue ? fb_lvalue : fb_rvalue);
2018   ret = MIN (ret, tret);
2019
2020   /* If the outermost expression is a COMPONENT_REF, canonicalize its type.  */
2021   if (!want_lvalue && TREE_CODE (*expr_p) == COMPONENT_REF)
2022     {
2023       canonicalize_component_ref (expr_p);
2024       ret = MIN (ret, GS_OK);
2025     }
2026
2027   return ret;
2028 }
2029
2030 /*  Gimplify the self modifying expression pointed by EXPR_P (++, --, +=, -=).
2031
2032     PRE_P points to the list where side effects that must happen before
2033         *EXPR_P should be stored.
2034
2035     POST_P points to the list where side effects that must happen after
2036         *EXPR_P should be stored.
2037
2038     WANT_VALUE is nonzero iff we want to use the value of this expression
2039         in another expression.  */
2040
2041 static enum gimplify_status
2042 gimplify_self_mod_expr (tree *expr_p, tree *pre_p, tree *post_p,
2043                         bool want_value)
2044 {
2045   enum tree_code code;
2046   tree lhs, lvalue, rhs, t1;
2047   bool postfix;
2048   enum tree_code arith_code;
2049   enum gimplify_status ret;
2050
2051   code = TREE_CODE (*expr_p);
2052
2053 #if defined ENABLE_CHECKING
2054   if (code != POSTINCREMENT_EXPR
2055       && code != POSTDECREMENT_EXPR
2056       && code != PREINCREMENT_EXPR
2057       && code != PREDECREMENT_EXPR)
2058     abort ();
2059 #endif
2060
2061   /* Prefix or postfix?  */
2062   if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
2063     /* Faster to treat as prefix if result is not used.  */
2064     postfix = want_value;
2065   else
2066     postfix = false;
2067
2068   /* Add or subtract?  */
2069   if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2070     arith_code = PLUS_EXPR;
2071   else
2072     arith_code = MINUS_EXPR;
2073
2074   /* Gimplify the LHS into a GIMPLE lvalue.  */
2075   lvalue = TREE_OPERAND (*expr_p, 0);
2076   ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
2077   if (ret == GS_ERROR)
2078     return ret;
2079
2080   /* Extract the operands to the arithmetic operation.  */
2081   lhs = lvalue;
2082   rhs = TREE_OPERAND (*expr_p, 1);
2083
2084   /* For postfix operator, we evaluate the LHS to an rvalue and then use
2085      that as the result value and in the postqueue operation.  */
2086   if (postfix)
2087     {
2088       ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue);
2089       if (ret == GS_ERROR)
2090         return ret;
2091     }
2092
2093   t1 = build (arith_code, TREE_TYPE (*expr_p), lhs, rhs);
2094   t1 = build (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1);
2095
2096   if (postfix)
2097     {
2098       gimplify_stmt (&t1);
2099       append_to_statement_list (t1, post_p);
2100       *expr_p = lhs;
2101       return GS_ALL_DONE;
2102     }
2103   else
2104     {
2105       *expr_p = t1;
2106       return GS_OK;
2107     }
2108 }
2109
2110 /*  Gimplify the CALL_EXPR node pointed by EXPR_P.
2111
2112       call_expr
2113               : ID '(' arglist ')'
2114
2115       arglist
2116               : arglist ',' val
2117               | val
2118
2119     PRE_P points to the list where side effects that must happen before
2120         *EXPR_P should be stored.  */
2121
2122 static enum gimplify_status
2123 gimplify_call_expr (tree *expr_p, tree *pre_p, bool (*gimple_test_f) (tree))
2124 {
2125   tree decl;
2126   tree arglist;
2127   enum gimplify_status ret;
2128
2129 #if defined ENABLE_CHECKING
2130   if (TREE_CODE (*expr_p) != CALL_EXPR)
2131     abort ();
2132 #endif
2133
2134   /* For reliable diagnostics during inlining, it is necessary that
2135      every call_expr be annotated with file and line.  */
2136   if (!EXPR_LOCUS (*expr_p))
2137     annotate_with_locus (*expr_p, input_location);
2138
2139   /* This may be a call to a builtin function.
2140
2141      Builtin function calls may be transformed into different
2142      (and more efficient) builtin function calls under certain
2143      circumstances.  Unfortunately, gimplification can muck things
2144      up enough that the builtin expanders are not aware that certain
2145      transformations are still valid.
2146
2147      So we attempt transformation/gimplification of the call before
2148      we gimplify the CALL_EXPR.  At this time we do not manage to
2149      transform all calls in the same manner as the expanders do, but
2150      we do transform most of them.  */
2151   decl = get_callee_fndecl (*expr_p);
2152   if (decl && DECL_BUILT_IN (decl))
2153     {
2154       tree new;
2155
2156       /* If it is allocation of stack, record the need to restore the memory
2157          when the enclosing bind_expr is exited.  */
2158       if (DECL_FUNCTION_CODE (decl) == BUILT_IN_STACK_ALLOC)
2159         gimplify_ctxp->save_stack = true;
2160
2161       /* If it is restore of the stack, reset it, since it means we are
2162          regimplifying the bind_expr.  Note that we use the fact that
2163          for try_finally_expr, try part is processed first.  */
2164       if (DECL_FUNCTION_CODE (decl) == BUILT_IN_STACK_RESTORE)
2165         gimplify_ctxp->save_stack = false;
2166
2167       new = simplify_builtin (*expr_p, gimple_test_f == is_gimple_stmt);
2168
2169       if (new && new != *expr_p)
2170         {
2171           /* There was a transformation of this call which computes the
2172              same value, but in a more efficient way.  Return and try
2173              again.  */
2174           *expr_p = new;
2175           return GS_OK;
2176         }
2177     }
2178
2179   /* There is a sequence point before the call, so any side effects in
2180      the calling expression must occur before the actual call.  Force
2181      gimplify_expr to use an internal post queue.  */
2182   ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, NULL,
2183                        is_gimple_call_addr, fb_rvalue);
2184
2185   if (PUSH_ARGS_REVERSED)
2186     TREE_OPERAND (*expr_p, 1) = nreverse (TREE_OPERAND (*expr_p, 1));
2187   for (arglist = TREE_OPERAND (*expr_p, 1); arglist;
2188        arglist = TREE_CHAIN (arglist))
2189     {
2190       enum gimplify_status t;
2191
2192       /* There is a sequence point before a function call.  Side effects in
2193          the argument list must occur before the actual call. So, when
2194          gimplifying arguments, force gimplify_expr to use an internal
2195          post queue which is then appended to the end of PRE_P.  */
2196       t = gimplify_expr (&TREE_VALUE (arglist), pre_p, NULL, is_gimple_val,
2197                          fb_rvalue);
2198
2199       if (t == GS_ERROR)
2200         ret = GS_ERROR;
2201     }
2202   if (PUSH_ARGS_REVERSED)
2203     TREE_OPERAND (*expr_p, 1) = nreverse (TREE_OPERAND (*expr_p, 1));
2204
2205   /* Try this again in case gimplification exposed something.  */
2206   if (ret != GS_ERROR && decl && DECL_BUILT_IN (decl))
2207     {
2208       tree new = simplify_builtin (*expr_p, gimple_test_f == is_gimple_stmt);
2209
2210       if (new && new != *expr_p)
2211         {
2212           /* There was a transformation of this call which computes the
2213              same value, but in a more efficient way.  Return and try
2214              again.  */
2215           *expr_p = new;
2216           return GS_OK;
2217         }
2218     }
2219
2220   /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2221      decl.  This allows us to eliminate redundant or useless
2222      calls to "const" functions.  */
2223   if (TREE_CODE (*expr_p) == CALL_EXPR
2224       && (call_expr_flags (*expr_p) & (ECF_CONST | ECF_PURE)))
2225     TREE_SIDE_EFFECTS (*expr_p) = 0;
2226
2227   return ret;
2228 }
2229
2230 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2231    rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2232
2233    TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2234    condition is true or false, respectively.  If null, we should generate
2235    our own to skip over the evaluation of this specific expression.
2236
2237    This function is the tree equivalent of do_jump.
2238
2239    shortcut_cond_r should only be called by shortcut_cond_expr.  */
2240
2241 static tree
2242 shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p)
2243 {
2244   tree local_label = NULL_TREE;
2245   tree t, expr = NULL;
2246
2247   /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2248      retain the shortcut semantics.  Just insert the gotos here;
2249      shortcut_cond_expr will append the real blocks later.  */
2250   if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2251     {
2252       /* Turn if (a && b) into
2253
2254          if (a); else goto no;
2255          if (b) goto yes; else goto no;
2256          (no:) */
2257
2258       if (false_label_p == NULL)
2259         false_label_p = &local_label;
2260
2261       t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p);
2262       append_to_statement_list (t, &expr);
2263
2264       t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2265                            false_label_p);
2266       append_to_statement_list (t, &expr);
2267     }
2268   else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2269     {
2270       /* Turn if (a || b) into
2271
2272          if (a) goto yes;
2273          if (b) goto yes; else goto no;
2274          (yes:) */
2275
2276       if (true_label_p == NULL)
2277         true_label_p = &local_label;
2278
2279       t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL);
2280       append_to_statement_list (t, &expr);
2281
2282       t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2283                            false_label_p);
2284       append_to_statement_list (t, &expr);
2285     }
2286   else if (TREE_CODE (pred) == COND_EXPR)
2287     {
2288       /* As long as we're messing with gotos, turn if (a ? b : c) into
2289          if (a)
2290            if (b) goto yes; else goto no;
2291          else
2292            if (c) goto yes; else goto no;  */
2293       expr = build (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
2294                     shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2295                                      false_label_p),
2296                     shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
2297                                      false_label_p));
2298     }
2299   else
2300     {
2301       expr = build (COND_EXPR, void_type_node, pred,
2302                     build_and_jump (true_label_p),
2303                     build_and_jump (false_label_p));
2304     }
2305
2306   if (local_label)
2307     {
2308       t = build1 (LABEL_EXPR, void_type_node, local_label);
2309       append_to_statement_list (t, &expr);
2310     }
2311
2312   return expr;
2313 }
2314
2315 static tree
2316 shortcut_cond_expr (tree expr)
2317 {
2318   tree pred = TREE_OPERAND (expr, 0);
2319   tree then_ = TREE_OPERAND (expr, 1);
2320   tree else_ = TREE_OPERAND (expr, 2);
2321   tree true_label, false_label, end_label, t;
2322   tree *true_label_p;
2323   tree *false_label_p;
2324   bool emit_end, emit_false;
2325   bool then_se = then_ && TREE_SIDE_EFFECTS (then_);
2326   bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
2327
2328   /* First do simple transformations.  */
2329   if (!else_se)
2330     {
2331       /* If there is no 'else', turn (a && b) into if (a) if (b).  */
2332       while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2333         {
2334           TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2335           then_ = shortcut_cond_expr (expr);
2336           pred = TREE_OPERAND (pred, 0);
2337           expr = build (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
2338         }
2339     }
2340   if (!then_se)
2341     {
2342       /* If there is no 'then', turn
2343            if (a || b); else d
2344          into
2345            if (a); else if (b); else d.  */
2346       while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2347         {
2348           TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2349           else_ = shortcut_cond_expr (expr);
2350           pred = TREE_OPERAND (pred, 0);
2351           expr = build (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
2352         }
2353     }
2354
2355   /* If we're done, great.  */
2356   if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
2357       && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
2358     return expr;
2359
2360   /* Otherwise we need to mess with gotos.  Change
2361        if (a) c; else d;
2362      to
2363        if (a); else goto no;
2364        c; goto end;
2365        no: d; end:
2366      and recursively gimplify the condition.  */
2367
2368   true_label = false_label = end_label = NULL_TREE;
2369
2370   /* If our arms just jump somewhere, hijack those labels so we don't
2371      generate jumps to jumps.  */
2372
2373   if (then_
2374       && TREE_CODE (then_) == GOTO_EXPR
2375       && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL)
2376     {
2377       true_label = GOTO_DESTINATION (then_);
2378       then_ = NULL;
2379       then_se = false;
2380     }
2381
2382   if (else_
2383       && TREE_CODE (else_) == GOTO_EXPR
2384       && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL)
2385     {
2386       false_label = GOTO_DESTINATION (else_);
2387       else_ = NULL;
2388       else_se = false;
2389     }
2390
2391   /* If we aren't hijacking a label for the 'then' branch, it falls through.  */
2392   if (true_label)
2393     true_label_p = &true_label;
2394   else
2395     true_label_p = NULL;
2396
2397   /* The 'else' branch also needs a label if it contains interesting code.  */
2398   if (false_label || else_se)
2399     false_label_p = &false_label;
2400   else
2401     false_label_p = NULL;
2402
2403   /* If there was nothing else in our arms, just forward the label(s).  */
2404   if (!then_se && !else_se)
2405     return shortcut_cond_r (pred, true_label_p, false_label_p);
2406
2407   /* If our last subexpression already has a terminal label, reuse it.  */
2408   if (else_se)
2409     expr = expr_last (else_);
2410   else if (then_se)
2411     expr = expr_last (then_);
2412   else
2413     expr = NULL;
2414   if (expr && TREE_CODE (expr) == LABEL_EXPR)
2415     end_label = LABEL_EXPR_LABEL (expr);
2416
2417   /* If we don't care about jumping to the 'else' branch, jump to the end
2418      if the condition is false.  */
2419   if (!false_label_p)
2420     false_label_p = &end_label;
2421
2422   /* We only want to emit these labels if we aren't hijacking them.  */
2423   emit_end = (end_label == NULL_TREE);
2424   emit_false = (false_label == NULL_TREE);
2425
2426   pred = shortcut_cond_r (pred, true_label_p, false_label_p);
2427
2428   expr = NULL;
2429   append_to_statement_list (pred, &expr);
2430
2431   append_to_statement_list (then_, &expr);
2432   if (else_se)
2433     {
2434       t = build_and_jump (&end_label);
2435       append_to_statement_list (t, &expr);
2436       if (emit_false)
2437         {
2438           t = build1 (LABEL_EXPR, void_type_node, false_label);
2439           append_to_statement_list (t, &expr);
2440         }
2441       append_to_statement_list (else_, &expr);
2442     }
2443   if (emit_end && end_label)
2444     {
2445       t = build1 (LABEL_EXPR, void_type_node, end_label);
2446       append_to_statement_list (t, &expr);
2447     }
2448
2449   return expr;
2450 }
2451
2452 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE.  */
2453
2454 static tree
2455 gimple_boolify (tree expr)
2456 {
2457   tree type = TREE_TYPE (expr);
2458
2459   if (TREE_CODE (type) == BOOLEAN_TYPE)
2460     return expr;
2461
2462   /* If this is the predicate of a COND_EXPR, it might not even be a
2463      truthvalue yet.  */
2464   expr = lang_hooks.truthvalue_conversion (expr);
2465
2466   switch (TREE_CODE (expr))
2467     {
2468     case TRUTH_AND_EXPR:
2469     case TRUTH_OR_EXPR:
2470     case TRUTH_XOR_EXPR:
2471     case TRUTH_ANDIF_EXPR:
2472     case TRUTH_ORIF_EXPR:
2473       /* Also boolify the arguments of truth exprs.  */
2474       TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1));
2475       /* FALLTHRU */
2476
2477     case TRUTH_NOT_EXPR:
2478       TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2479       /* FALLTHRU */
2480
2481     case EQ_EXPR: case NE_EXPR:
2482     case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2483       /* These expressions always produce boolean results.  */
2484       TREE_TYPE (expr) = boolean_type_node;
2485       return expr;
2486
2487     default:
2488       /* Other expressions that get here must have boolean values, but
2489          might need to be converted to the appropriate mode.  */
2490       return convert (boolean_type_node, expr);
2491     }
2492 }
2493
2494 /*  Convert the conditional expression pointed by EXPR_P '(p) ? a : b;'
2495     into
2496
2497     if (p)                      if (p)
2498       t1 = a;                     a;
2499     else                or      else
2500       t1 = b;                     b;
2501     t1;
2502
2503     The second form is used when *EXPR_P is of type void.
2504
2505     TARGET is the tree for T1 above.
2506
2507     PRE_P points to the list where side effects that must happen before
2508         *EXPR_P should be stored.  */
2509
2510 static enum gimplify_status
2511 gimplify_cond_expr (tree *expr_p, tree *pre_p, tree target)
2512 {
2513   tree expr = *expr_p;
2514   tree tmp;
2515   enum gimplify_status ret;
2516
2517   /* If this COND_EXPR has a value, copy the values into a temporary within
2518      the arms.  */
2519   if (! VOID_TYPE_P (TREE_TYPE (expr)))
2520     {
2521       if (target)
2522         {
2523           tmp = target;
2524           ret = GS_OK;
2525         }
2526       else
2527         {
2528           tmp = create_tmp_var (TREE_TYPE (expr), "iftmp");
2529           ret = GS_ALL_DONE;
2530         }
2531
2532       /* Build the then clause, 't1 = a;'.  But don't build an assignment
2533          if this branch is void; in C++ it can be, if it's a throw.  */
2534       if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
2535         TREE_OPERAND (expr, 1)
2536           = build (MODIFY_EXPR, void_type_node, tmp, TREE_OPERAND (expr, 1));
2537
2538       /* Build the else clause, 't1 = b;'.  */
2539       if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
2540         TREE_OPERAND (expr, 2)
2541           = build (MODIFY_EXPR, void_type_node, tmp, TREE_OPERAND (expr, 2));
2542
2543       TREE_TYPE (expr) = void_type_node;
2544       recalculate_side_effects (expr);
2545
2546       /* Move the COND_EXPR to the prequeue and use the temp in its place.  */
2547       gimplify_stmt (&expr);
2548       append_to_statement_list (expr, pre_p);
2549       *expr_p = tmp;
2550
2551       return ret;
2552     }
2553
2554   /* Make sure the condition has BOOLEAN_TYPE.  */
2555   TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2556
2557   /* Break apart && and || conditions.  */
2558   if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR
2559       || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
2560     {
2561       expr = shortcut_cond_expr (expr);
2562
2563       if (expr != *expr_p)
2564         {
2565           *expr_p = expr;
2566
2567           /* We can't rely on gimplify_expr to re-gimplify the expanded
2568              form properly, as cleanups might cause the target labels to be
2569              wrapped in a TRY_FINALLY_EXPR.  To prevent that, we need to
2570              set up a conditional context.  */
2571           gimple_push_condition ();
2572           gimplify_stmt (expr_p);
2573           gimple_pop_condition (pre_p);
2574
2575           return GS_ALL_DONE;
2576         }
2577     }
2578
2579   /* Now do the normal gimplification.  */
2580   ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL,
2581                        is_gimple_condexpr, fb_rvalue);
2582
2583   gimple_push_condition ();
2584
2585   gimplify_to_stmt_list (&TREE_OPERAND (expr, 1));
2586   gimplify_to_stmt_list (&TREE_OPERAND (expr, 2));
2587   recalculate_side_effects (expr);
2588
2589   gimple_pop_condition (pre_p);
2590
2591   if (ret == GS_ERROR)
2592     ;
2593   else if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2594     ret = GS_ALL_DONE;
2595   else if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 2)))
2596     /* Rewrite "if (a); else b" to "if (!a) b"  */
2597     {
2598       TREE_OPERAND (expr, 0) = invert_truthvalue (TREE_OPERAND (expr, 0));
2599       ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL,
2600                            is_gimple_condexpr, fb_rvalue);
2601
2602       tmp = TREE_OPERAND (expr, 1);
2603       TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 2);
2604       TREE_OPERAND (expr, 2) = tmp;
2605     }
2606   else
2607     /* Both arms are empty; replace the COND_EXPR with its predicate.  */
2608     expr = TREE_OPERAND (expr, 0);
2609
2610   *expr_p = expr;
2611   return ret;
2612 }
2613
2614 /*  Gimplify the MODIFY_EXPR node pointed by EXPR_P.
2615
2616       modify_expr
2617               : varname '=' rhs
2618               | '*' ID '=' rhs
2619
2620     PRE_P points to the list where side effects that must happen before
2621         *EXPR_P should be stored.
2622
2623     POST_P points to the list where side effects that must happen after
2624         *EXPR_P should be stored.
2625
2626     WANT_VALUE is nonzero iff we want to use the value of this expression
2627         in another expression.  */
2628
2629 static enum gimplify_status
2630 gimplify_modify_expr (tree *expr_p, tree *pre_p, tree *post_p, bool want_value)
2631 {
2632   tree *from_p = &TREE_OPERAND (*expr_p, 1);
2633   tree *to_p = &TREE_OPERAND (*expr_p, 0);
2634   enum gimplify_status ret = GS_UNHANDLED;
2635
2636 #if defined ENABLE_CHECKING
2637   if (TREE_CODE (*expr_p) != MODIFY_EXPR && TREE_CODE (*expr_p) != INIT_EXPR)
2638     abort ();
2639 #endif
2640
2641   /* The distinction between MODIFY_EXPR and INIT_EXPR is no longer useful.  */
2642   if (TREE_CODE (*expr_p) == INIT_EXPR)
2643     TREE_SET_CODE (*expr_p, MODIFY_EXPR);
2644
2645   /* See if any simplifications can be done based on what the RHS is.  */
2646   ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
2647                                   want_value);
2648   if (ret != GS_UNHANDLED)
2649     return ret;
2650
2651   /* If the value being copied is of variable width, expose the length
2652      if the copy by converting the whole thing to a memcpy.  Note that
2653      we need to do this before gimplifying any of the operands
2654      so that we can resolve any PLACEHOLDER_EXPRs in the size.  */
2655   if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (*to_p))) != INTEGER_CST)
2656     {
2657       tree args, t, dest;
2658
2659       t = TYPE_SIZE_UNIT (TREE_TYPE (*to_p));
2660       t = SUBSTITUTE_PLACEHOLDER_IN_EXPR (t, *to_p);
2661       t = SUBSTITUTE_PLACEHOLDER_IN_EXPR (t, *from_p);
2662       t = unshare_expr (t);
2663       args = tree_cons (NULL, t, NULL);
2664       t = build_fold_addr_expr (*from_p);
2665       args = tree_cons (NULL, t, args);
2666       dest = build_fold_addr_expr (*to_p);
2667       args = tree_cons (NULL, dest, args);
2668       t = implicit_built_in_decls[BUILT_IN_MEMCPY];
2669       t = build_function_call_expr (t, args);
2670       if (want_value)
2671         {
2672           t = build1 (NOP_EXPR, TREE_TYPE (dest), t);
2673           t = build1 (INDIRECT_REF, TREE_TYPE (*to_p), t);
2674         }
2675       *expr_p = t;
2676       return GS_OK;
2677     }
2678
2679   ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
2680   if (ret == GS_ERROR)
2681     return ret;
2682
2683   ret = gimplify_expr (from_p, pre_p, post_p, is_gimple_rhs, fb_rvalue);
2684   if (ret == GS_ERROR)
2685     return ret;
2686
2687   /* Now see if the above changed *from_p to something we handle specially.  */
2688   ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
2689                                   want_value);
2690   if (ret != GS_UNHANDLED)
2691     return ret;
2692
2693   /* If the destination is already simple, nothing else needed.  */
2694   if (is_gimple_tmp_var (*to_p))
2695     ret = GS_ALL_DONE;
2696   else
2697     {
2698       /* If the RHS of the MODIFY_EXPR may throw or make a nonlocal goto and
2699          the LHS is a user variable, then we need to introduce a temporary.
2700          ie temp = RHS; LHS = temp.
2701
2702          This way the optimizers can determine that the user variable is
2703          only modified if evaluation of the RHS does not throw.
2704
2705          FIXME this should be handled by the is_gimple_rhs predicate.  */
2706
2707       if (aggregate_value_p (TREE_TYPE (*from_p), NULL_TREE))
2708         /* Don't force a temp of a large aggregate type; the copy could be
2709            arbitrarily expensive.  Instead we will generate a V_MAY_DEF for
2710            the assignment.  */;
2711       else if (TREE_CODE (*from_p) == CALL_EXPR
2712                || (flag_non_call_exceptions && tree_could_trap_p (*from_p))
2713                /* If we're dealing with a renamable type, either source or dest
2714                   must be a renamed variable.  */
2715                || (is_gimple_reg_type (TREE_TYPE (*from_p))
2716                    && !is_gimple_reg (*to_p)))
2717         gimplify_expr (from_p, pre_p, post_p, is_gimple_val, fb_rvalue);
2718
2719       ret = want_value ? GS_OK : GS_ALL_DONE;
2720     }
2721
2722   if (want_value)
2723     {
2724       append_to_statement_list (*expr_p, pre_p);
2725       *expr_p = *to_p;
2726     }
2727
2728   return ret;
2729 }
2730
2731 /*  Subroutine of above to do simplications of MODIFY_EXPRs based on
2732     the code of the RHS.  We loop for as long as we can do something.  */
2733
2734 static enum gimplify_status
2735 gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p, tree *pre_p,
2736                           tree *post_p, bool want_value)
2737 {
2738   enum gimplify_status ret = GS_OK;
2739
2740   while (ret != GS_UNHANDLED)
2741     switch (TREE_CODE (*from_p))
2742       {
2743       case TARGET_EXPR:
2744         {
2745           /* If we are initializing something from a TARGET_EXPR, strip the
2746              TARGET_EXPR and initialize it directly, if possible.  This can't
2747              be done if the initializer is void, since that implies that the
2748              temporary is set in some non-trivial way.
2749
2750              ??? What about code that pulls out the temp and uses it
2751              elsewhere? I think that such code never uses the TARGET_EXPR as
2752              an initializer.  If I'm wrong, we'll abort because the temp won't
2753              have any RTL.  In that case, I guess we'll need to replace
2754              references somehow.  */
2755           tree init = TARGET_EXPR_INITIAL (*from_p);
2756
2757           if (!VOID_TYPE_P (TREE_TYPE (init)))
2758             {
2759               *from_p = init;
2760               ret = GS_OK;
2761             }
2762           else
2763             ret = GS_UNHANDLED;
2764         }
2765         break;
2766
2767       case COMPOUND_EXPR:
2768         /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
2769            caught.  */
2770         gimplify_compound_expr (from_p, pre_p, true);
2771         ret = GS_OK;
2772         break;
2773
2774       case CONSTRUCTOR:
2775         /* If we're initializing from a CONSTRUCTOR, break this into
2776            individual MODIFY_EXPRs.  */
2777         return gimplify_init_constructor (expr_p, pre_p, post_p, want_value);
2778
2779       case COND_EXPR:
2780         /* If we're assigning from a ?: expression with ADDRESSABLE type, push
2781            the assignment down into the branches, since we can't generate a
2782            temporary of such a type.  */
2783         if (TREE_ADDRESSABLE (TREE_TYPE (*from_p)))
2784           {
2785             *expr_p = *from_p;
2786             return gimplify_cond_expr (expr_p, pre_p, *to_p);
2787           }
2788         else
2789           ret = GS_UNHANDLED;
2790         break;
2791
2792       default:
2793         ret = GS_UNHANDLED;
2794         break;
2795       }
2796
2797   return ret;
2798 }
2799
2800 /*  Gimplify a comparison between two variable-sized objects.  Do this
2801     with a call to BUILT_IN_MEMCMP.  */
2802
2803 static enum gimplify_status
2804 gimplify_variable_sized_compare (tree *expr_p)
2805 {
2806   tree op0 = TREE_OPERAND (*expr_p, 0);
2807   tree op1 = TREE_OPERAND (*expr_p, 1);
2808   tree args, t, dest;
2809
2810   t = TYPE_SIZE_UNIT (TREE_TYPE (op0));
2811   t = SUBSTITUTE_PLACEHOLDER_IN_EXPR (t, op0);
2812   t = unshare_expr (t);
2813   args = tree_cons (NULL, t, NULL);
2814   t = build_addr_expr (op1);
2815   args = tree_cons (NULL, t, args);
2816   dest = build_addr_expr (op0);
2817   args = tree_cons (NULL, dest, args);
2818   t = implicit_built_in_decls[BUILT_IN_MEMCMP];
2819   t = build_function_call_expr (t, args);
2820   *expr_p
2821     = build (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node);
2822
2823   return GS_OK;
2824 }
2825
2826 /*  Gimplify TRUTH_ANDIF_EXPR and TRUTH_ORIF_EXPR expressions.  EXPR_P
2827     points to the expression to gimplify.
2828
2829     Expressions of the form 'a && b' are gimplified to:
2830
2831         a && b ? true : false
2832
2833     gimplify_cond_expr will do the rest.
2834
2835     PRE_P points to the list where side effects that must happen before
2836         *EXPR_P should be stored.  */
2837
2838 static enum gimplify_status
2839 gimplify_boolean_expr (tree *expr_p)
2840 {
2841   /* Preserve the original type of the expression.  */
2842   tree type = TREE_TYPE (*expr_p);
2843
2844   *expr_p = build (COND_EXPR, type, *expr_p,
2845                    convert (type, boolean_true_node),
2846                    convert (type, boolean_false_node));
2847
2848   return GS_OK;
2849 }
2850
2851 /* Gimplifies an expression sequence.  This function gimplifies each
2852    expression and re-writes the original expression with the last
2853    expression of the sequence in GIMPLE form.
2854
2855    PRE_P points to the list where the side effects for all the
2856        expressions in the sequence will be emitted.
2857
2858    WANT_VALUE is true when the result of the last COMPOUND_EXPR is used.  */
2859 /* ??? Should rearrange to share the pre-queue with all the indirect
2860    invocations of gimplify_expr.  Would probably save on creations
2861    of statement_list nodes.  */
2862
2863 static enum gimplify_status
2864 gimplify_compound_expr (tree *expr_p, tree *pre_p, bool want_value)
2865 {
2866   tree t = *expr_p;
2867
2868   do
2869     {
2870       tree *sub_p = &TREE_OPERAND (t, 0);
2871
2872       if (TREE_CODE (*sub_p) == COMPOUND_EXPR)
2873         gimplify_compound_expr (sub_p, pre_p, false);
2874       else
2875         gimplify_stmt (sub_p);
2876       append_to_statement_list (*sub_p, pre_p);
2877
2878       t = TREE_OPERAND (t, 1);
2879     }
2880   while (TREE_CODE (t) == COMPOUND_EXPR);
2881
2882   *expr_p = t;
2883   if (want_value)
2884     return GS_OK;
2885   else
2886     {
2887       gimplify_stmt (expr_p);
2888       return GS_ALL_DONE;
2889     }
2890 }
2891
2892 /* Gimplifies a statement list.  These may be created either by an
2893    enlightened front-end, or by shortcut_cond_expr.  */
2894
2895 static enum gimplify_status
2896 gimplify_statement_list (tree *expr_p)
2897 {
2898   tree_stmt_iterator i = tsi_start (*expr_p);
2899
2900   while (!tsi_end_p (i))
2901     {
2902       tree t;
2903
2904       gimplify_stmt (tsi_stmt_ptr (i));
2905
2906       t = tsi_stmt (i);
2907       if (t == NULL)
2908         tsi_delink (&i);
2909       else if (TREE_CODE (t) == STATEMENT_LIST)
2910         {
2911           tsi_link_before (&i, t, TSI_SAME_STMT);
2912           tsi_delink (&i);
2913         }
2914       else
2915         tsi_next (&i);
2916     }
2917
2918   return GS_ALL_DONE;
2919 }
2920
2921 /*  Gimplify a SAVE_EXPR node.  EXPR_P points to the expression to
2922     gimplify.  After gimplification, EXPR_P will point to a new temporary
2923     that holds the original value of the SAVE_EXPR node.
2924
2925     PRE_P points to the list where side effects that must happen before
2926         *EXPR_P should be stored.  */
2927
2928 static enum gimplify_status
2929 gimplify_save_expr (tree *expr_p, tree *pre_p, tree *post_p)
2930 {
2931   enum gimplify_status ret = GS_ALL_DONE;
2932   tree val;
2933
2934 #if defined ENABLE_CHECKING
2935   if (TREE_CODE (*expr_p) != SAVE_EXPR)
2936     abort ();
2937 #endif
2938
2939   val = TREE_OPERAND (*expr_p, 0);
2940
2941   /* If the operand is already a GIMPLE temporary, just re-write the
2942      SAVE_EXPR node.  */
2943   if (is_gimple_tmp_var (val))
2944     *expr_p = val;
2945   /* The operand may be a void-valued expression such as SAVE_EXPRs
2946      generated by the Java frontend for class initialization.  It is
2947      being executed only for its side-effects.  */
2948   else if (TREE_TYPE (val) == void_type_node)
2949     {
2950       tree body = TREE_OPERAND (*expr_p, 0);
2951       ret = gimplify_expr (& body, pre_p, post_p, is_gimple_stmt, fb_none);
2952       append_to_statement_list (body, pre_p);
2953       *expr_p = NULL;
2954     }
2955   else
2956     *expr_p = TREE_OPERAND (*expr_p, 0)
2957       = get_initialized_tmp_var (val, pre_p, post_p);
2958
2959   return ret;
2960 }
2961
2962 /*  Re-write the ADDR_EXPR node pointed by EXPR_P
2963
2964       unary_expr
2965               : ...
2966               | '&' varname
2967               ...
2968
2969     PRE_P points to the list where side effects that must happen before
2970         *EXPR_P should be stored.
2971
2972     POST_P points to the list where side effects that must happen after
2973         *EXPR_P should be stored.  */
2974
2975 static enum gimplify_status
2976 gimplify_addr_expr (tree *expr_p, tree *pre_p, tree *post_p)
2977 {
2978   tree expr = *expr_p;
2979   tree op0 = TREE_OPERAND (expr, 0);
2980   enum gimplify_status ret;
2981
2982   switch (TREE_CODE (op0))
2983     {
2984     case INDIRECT_REF:
2985       /* Check if we are dealing with an expression of the form '&*ptr'.
2986          While the front end folds away '&*ptr' into 'ptr', these
2987          expressions may be generated internally by the compiler (e.g.,
2988          builtins like __builtin_va_end).  */
2989       *expr_p = TREE_OPERAND (op0, 0);
2990       ret = GS_OK;
2991       break;
2992
2993     case ARRAY_REF:
2994       /* Fold &a[6] to (&a + 6).  */
2995       ret = gimplify_array_ref_to_plus (&TREE_OPERAND (expr, 0),
2996                                         pre_p, post_p);
2997
2998       /* This added an INDIRECT_REF.  Fold it away.  */
2999       *expr_p = TREE_OPERAND (TREE_OPERAND (expr, 0), 0);
3000       break;
3001
3002     case VIEW_CONVERT_EXPR:
3003       /* Take the address of our operand and then convert it to the type of
3004          this ADDR_EXPR.  */
3005       *expr_p = fold_convert (TREE_TYPE (expr),
3006                               build_addr_expr (TREE_OPERAND (op0, 0)));
3007       ret = GS_OK;
3008       break;
3009
3010     default:
3011       /* We use fb_either here because the C frontend sometimes takes
3012          the address of a call that returns a struct.  */
3013       ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, post_p,
3014                            is_gimple_addr_expr_arg, fb_either);
3015       if (ret != GS_ERROR)
3016         {
3017           /* At this point, the argument of the ADDR_EXPR should be
3018              sufficiently simple that there are never side effects.  */
3019           /* ??? Could split out the decision code from build1 to verify.  */
3020           TREE_SIDE_EFFECTS (expr) = 0;
3021
3022           /* Make sure TREE_INVARIANT/TREE_CONSTANT is set properly.  */
3023           recompute_tree_invarant_for_addr_expr (expr);
3024
3025           /* Mark the RHS addressable.  */
3026           lang_hooks.mark_addressable (TREE_OPERAND (expr, 0));
3027         }
3028       break;
3029     }
3030
3031   /* If the operand is gimplified into a _DECL, mark the address expression
3032      as TREE_INVARIANT.  */
3033   if (DECL_P (TREE_OPERAND (expr, 0)))
3034     TREE_INVARIANT (expr) = 1;
3035
3036   return ret;
3037 }
3038
3039 /* Gimplify the operands of an ASM_EXPR.  Input operands should be a gimple
3040    value; output operands should be a gimple lvalue.  */
3041
3042 static enum gimplify_status
3043 gimplify_asm_expr (tree *expr_p, tree *pre_p, tree *post_p)
3044 {
3045   tree expr = *expr_p;
3046   int noutputs = list_length (ASM_OUTPUTS (expr));
3047   const char **oconstraints
3048     = (const char **) alloca ((noutputs) * sizeof (const char *));
3049   int i;
3050   tree link;
3051   const char *constraint;
3052   bool allows_mem, allows_reg, is_inout;
3053   enum gimplify_status ret, tret;
3054
3055   ASM_STRING (expr)
3056     = resolve_asm_operand_names (ASM_STRING (expr), ASM_OUTPUTS (expr),
3057                                  ASM_INPUTS (expr));
3058
3059   ret = GS_ALL_DONE;
3060   for (i = 0, link = ASM_OUTPUTS (expr); link; ++i, link = TREE_CHAIN (link))
3061     {
3062       oconstraints[i] = constraint
3063         = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
3064
3065       parse_output_constraint (&constraint, i, 0, 0,
3066                                &allows_mem, &allows_reg, &is_inout);
3067
3068       if (!allows_reg && allows_mem)
3069         lang_hooks.mark_addressable (TREE_VALUE (link));
3070
3071       tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
3072                             is_inout ? is_gimple_min_lval : is_gimple_lvalue,
3073                             fb_lvalue | fb_mayfail);
3074       if (tret == GS_ERROR)
3075         {
3076           error ("invalid lvalue in asm output %d", i);
3077           ret = tret;
3078         }
3079
3080       if (is_inout)
3081         {
3082           /* An input/output operand.  To give the optimizers more
3083              flexibility, split it into separate input and output
3084              operands.  */
3085           tree input;
3086           char buf[10];
3087           size_t constraint_len = strlen (constraint);
3088
3089           /* Turn the in/out constraint into an output constraint.  */
3090           char *p = xstrdup (constraint);
3091           p[0] = '=';
3092           TREE_VALUE (TREE_PURPOSE (link)) = build_string (constraint_len, p);
3093           free (p);
3094
3095           /* And add a matching input constraint.  */
3096           if (allows_reg)
3097             {
3098               sprintf (buf, "%d", i);
3099               input = build_string (strlen (buf), buf);
3100             }
3101           else
3102             input = build_string (constraint_len - 1, constraint + 1);
3103           input = build_tree_list (build_tree_list (NULL_TREE, input),
3104                                    unshare_expr (TREE_VALUE (link)));
3105           ASM_INPUTS (expr) = chainon (ASM_INPUTS (expr), input);
3106         }
3107     }
3108
3109   for (link = ASM_INPUTS (expr); link; ++i, link = TREE_CHAIN (link))
3110     {
3111       constraint
3112         = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
3113       parse_input_constraint (&constraint, 0, 0, noutputs, 0,
3114                               oconstraints, &allows_mem, &allows_reg);
3115
3116       /* If the operand is a memory input, it should be an lvalue.  */
3117       if (!allows_reg && allows_mem)
3118         {
3119           lang_hooks.mark_addressable (TREE_VALUE (link));
3120           tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
3121                                 is_gimple_lvalue, fb_lvalue | fb_mayfail);
3122           if (tret == GS_ERROR)
3123             {
3124               error ("memory input %d is not directly addressable", i);
3125               ret = tret;
3126             }
3127         }
3128       else
3129         {
3130           tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
3131                                 is_gimple_val, fb_rvalue);
3132           if (tret == GS_ERROR)
3133             ret = tret;
3134         }
3135     }
3136
3137   return ret;
3138 }
3139
3140 /* Gimplify a CLEANUP_POINT_EXPR.  Currently this works by adding
3141    WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
3142    gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
3143    return to this function.
3144
3145    FIXME should we complexify the prequeue handling instead?  Or use flags
3146    for all the cleanups and let the optimizer tighten them up?  The current
3147    code seems pretty fragile; it will break on a cleanup within any
3148    non-conditional nesting.  But any such nesting would be broken, anyway;
3149    we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
3150    and continues out of it.  We can do that at the RTL level, though, so
3151    having an optimizer to tighten up try/finally regions would be a Good
3152    Thing.  */
3153
3154 static enum gimplify_status
3155 gimplify_cleanup_point_expr (tree *expr_p, tree *pre_p)
3156 {
3157   tree_stmt_iterator iter;
3158   tree body;
3159
3160   tree temp = voidify_wrapper_expr (*expr_p, NULL);
3161
3162   /* We only care about the number of conditions between the innermost
3163      CLEANUP_POINT_EXPR and the cleanup.  So save and reset the count.  */
3164   int old_conds = gimplify_ctxp->conditions;
3165   gimplify_ctxp->conditions = 0;
3166
3167   body = TREE_OPERAND (*expr_p, 0);
3168   gimplify_to_stmt_list (&body);
3169
3170   gimplify_ctxp->conditions = old_conds;
3171
3172   for (iter = tsi_start (body); !tsi_end_p (iter); )
3173     {
3174       tree *wce_p = tsi_stmt_ptr (iter);
3175       tree wce = *wce_p;
3176
3177       if (TREE_CODE (wce) == WITH_CLEANUP_EXPR)
3178         {
3179           if (tsi_one_before_end_p (iter))
3180             {
3181               tsi_link_before (&iter, TREE_OPERAND (wce, 1), TSI_SAME_STMT);
3182               tsi_delink (&iter);
3183               break;
3184             }
3185           else
3186             {
3187               tree sl, tfe;
3188
3189               sl = tsi_split_statement_list_after (&iter);
3190               tfe = build (TRY_FINALLY_EXPR, void_type_node, sl, NULL_TREE);
3191               append_to_statement_list (TREE_OPERAND (wce, 1),
3192                                      &TREE_OPERAND (tfe, 1));
3193               *wce_p = tfe;
3194               iter = tsi_start (sl);
3195             }
3196         }
3197       else
3198         tsi_next (&iter);
3199     }
3200
3201   if (temp)
3202     {
3203       *expr_p = temp;
3204       append_to_statement_list (body, pre_p);
3205       return GS_OK;
3206     }
3207   else
3208     {
3209       *expr_p = body;
3210       return GS_ALL_DONE;
3211     }
3212 }
3213
3214 /* Insert a cleanup marker for gimplify_cleanup_point_expr.  CLEANUP
3215    is the cleanup action required.  */
3216
3217 static void
3218 gimple_push_cleanup (tree var, tree cleanup, tree *pre_p)
3219 {
3220   tree wce;
3221
3222   /* Errors can result in improperly nested cleanups.  Which results in
3223      confusion when trying to resolve the WITH_CLEANUP_EXPR.  */
3224   if (errorcount || sorrycount)
3225     return;
3226
3227   if (gimple_conditional_context ())
3228     {
3229       /* If we're in a conditional context, this is more complex.  We only
3230          want to run the cleanup if we actually ran the initialization that
3231          necessitates it, but we want to run it after the end of the
3232          conditional context.  So we wrap the try/finally around the
3233          condition and use a flag to determine whether or not to actually
3234          run the destructor.  Thus
3235
3236            test ? f(A()) : 0
3237
3238          becomes (approximately)
3239
3240            flag = 0;
3241            try {
3242              if (test) { A::A(temp); flag = 1; val = f(temp); }
3243              else { val = 0; }
3244            } finally {
3245              if (flag) A::~A(temp);
3246            }
3247            val
3248       */
3249
3250       tree flag = create_tmp_var (boolean_type_node, "cleanup");
3251       tree ffalse = build (MODIFY_EXPR, void_type_node, flag,
3252                            boolean_false_node);
3253       tree ftrue = build (MODIFY_EXPR, void_type_node, flag,
3254                           boolean_true_node);
3255       cleanup = build (COND_EXPR, void_type_node, flag, cleanup, NULL);
3256       wce = build (WITH_CLEANUP_EXPR, void_type_node, NULL_TREE,
3257                    cleanup, NULL_TREE);
3258       append_to_statement_list (ffalse, &gimplify_ctxp->conditional_cleanups);
3259       append_to_statement_list (wce, &gimplify_ctxp->conditional_cleanups);
3260       append_to_statement_list (ftrue, pre_p);
3261
3262       /* Because of this manipulation, and the EH edges that jump
3263          threading cannot redirect, the temporary (VAR) will appear
3264          to be used uninitialized.  Don't warn.  */
3265       TREE_NO_WARNING (var) = 1;
3266     }
3267   else
3268     {
3269       wce = build (WITH_CLEANUP_EXPR, void_type_node, NULL_TREE,
3270                    cleanup, NULL_TREE);
3271       append_to_statement_list (wce, pre_p);
3272     }
3273
3274   gimplify_stmt (&TREE_OPERAND (wce, 1));
3275 }
3276
3277 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR.  */
3278
3279 static enum gimplify_status
3280 gimplify_target_expr (tree *expr_p, tree *pre_p, tree *post_p)
3281 {
3282   tree targ = *expr_p;
3283   tree temp = TARGET_EXPR_SLOT (targ);
3284   tree init = TARGET_EXPR_INITIAL (targ);
3285   enum gimplify_status ret;
3286
3287   if (init)
3288     {
3289       /* TARGET_EXPR temps aren't part of the enclosing block, so add it
3290          to the temps list.  */
3291       gimple_add_tmp_var (temp);
3292
3293       /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
3294          expression is supposed to initialize the slot.  */
3295       if (VOID_TYPE_P (TREE_TYPE (init)))
3296         ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
3297       else
3298         {
3299           /* Special handling for BIND_EXPR can result in fewer temps.  */
3300           ret = GS_OK;
3301           if (TREE_CODE (init) == BIND_EXPR)
3302             gimplify_bind_expr (&init, temp, pre_p);
3303           if (init != temp)
3304             {
3305               init = build (MODIFY_EXPR, void_type_node, temp, init);
3306               ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt,
3307                                    fb_none);
3308             }
3309         }
3310       if (ret == GS_ERROR)
3311         return GS_ERROR;
3312       append_to_statement_list (init, pre_p);
3313
3314       /* If needed, push the cleanup for the temp.  */
3315       if (TARGET_EXPR_CLEANUP (targ))
3316         {
3317           gimplify_stmt (&TARGET_EXPR_CLEANUP (targ));
3318           gimple_push_cleanup (temp, TARGET_EXPR_CLEANUP (targ), pre_p);
3319         }
3320
3321       /* Only expand this once.  */
3322       TREE_OPERAND (targ, 3) = init;
3323       TARGET_EXPR_INITIAL (targ) = NULL_TREE;
3324     }
3325   else if (!temp->decl.seen_in_bind_expr)
3326     /* We should have expanded this before.  */
3327     abort ();
3328
3329   *expr_p = temp;
3330   return GS_OK;
3331 }
3332
3333 /* Gimplification of expression trees.  */
3334
3335 /* Gimplify an expression which appears at statement context; usually, this
3336    means replacing it with a suitably gimple STATEMENT_LIST.  */
3337
3338 void
3339 gimplify_stmt (tree *stmt_p)
3340 {
3341   gimplify_expr (stmt_p, NULL, NULL, is_gimple_stmt, fb_none);
3342 }
3343
3344 /* Similarly, but force the result to be a STATEMENT_LIST.  */
3345
3346 void
3347 gimplify_to_stmt_list (tree *stmt_p)
3348 {
3349   gimplify_stmt (stmt_p);
3350   if (!*stmt_p)
3351     *stmt_p = alloc_stmt_list ();
3352   else if (TREE_CODE (*stmt_p) != STATEMENT_LIST)
3353     {
3354       tree t = *stmt_p;
3355       *stmt_p = alloc_stmt_list ();
3356       append_to_statement_list (t, stmt_p);
3357     }
3358 }
3359
3360
3361 /*  Gimplifies the expression tree pointed by EXPR_P.  Return 0 if
3362     gimplification failed.
3363
3364     PRE_P points to the list where side effects that must happen before
3365         EXPR should be stored.
3366
3367     POST_P points to the list where side effects that must happen after
3368         EXPR should be stored, or NULL if there is no suitable list.  In
3369         that case, we copy the result to a temporary, emit the
3370         post-effects, and then return the temporary.
3371
3372     GIMPLE_TEST_F points to a function that takes a tree T and
3373         returns nonzero if T is in the GIMPLE form requested by the
3374         caller.  The GIMPLE predicates are in tree-gimple.c.
3375
3376         This test is used twice.  Before gimplification, the test is
3377         invoked to determine whether *EXPR_P is already gimple enough.  If
3378         that fails, *EXPR_P is gimplified according to its code and
3379         GIMPLE_TEST_F is called again.  If the test still fails, then a new
3380         temporary variable is created and assigned the value of the
3381         gimplified expression.
3382
3383     FALLBACK tells the function what sort of a temporary we want.  If the 1
3384         bit is set, an rvalue is OK.  If the 2 bit is set, an lvalue is OK.
3385         If both are set, either is OK, but an lvalue is preferable.
3386
3387     The return value is either GS_ERROR or GS_ALL_DONE, since this function
3388     iterates until solution.  */
3389
3390 enum gimplify_status
3391 gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
3392                bool (* gimple_test_f) (tree), fallback_t fallback)
3393 {
3394   tree tmp;
3395   tree internal_pre = NULL_TREE;
3396   tree internal_post = NULL_TREE;
3397   tree save_expr;
3398   int is_statement = (pre_p == NULL);
3399   location_t *locus;
3400   location_t saved_location;
3401   enum gimplify_status ret;
3402
3403   save_expr = *expr_p;
3404   if (save_expr == NULL_TREE)
3405     return GS_ALL_DONE;
3406
3407   /* We used to check the predicate here and return immediately if it
3408      succeeds.  This is wrong; the design is for gimplification to be
3409      idempotent, and for the predicates to only test for valid forms, not
3410      whether they are fully simplified.  */
3411
3412   /* Set up our internal queues if needed.  */
3413   if (pre_p == NULL)
3414     pre_p = &internal_pre;
3415   if (post_p == NULL)
3416     post_p = &internal_post;
3417
3418   saved_location = input_location;
3419   if (save_expr == error_mark_node)
3420     locus = NULL;
3421   else
3422     locus = EXPR_LOCUS (save_expr);
3423   if (locus)
3424     input_location = *locus;
3425
3426   /* Loop over the specific gimplifiers until the toplevel node
3427      remains the same.  */
3428   do
3429     {
3430       /* Strip any uselessness.  */
3431       STRIP_MAIN_TYPE_NOPS (*expr_p);
3432
3433       /* Remember the expr.  */
3434       save_expr = *expr_p;
3435
3436       /* Die, die, die, my darling.  */
3437       if (save_expr == error_mark_node
3438           || (TREE_TYPE (save_expr)
3439               && TREE_TYPE (save_expr) == error_mark_node))
3440         {
3441           ret = GS_ERROR;
3442           break;
3443         }
3444
3445       /* Do any language-specific gimplification.  */
3446       ret = lang_hooks.gimplify_expr (expr_p, pre_p, post_p);
3447       if (ret == GS_OK)
3448         {
3449           if (*expr_p == NULL_TREE)
3450             break;
3451           if (*expr_p != save_expr)
3452             continue;
3453         }
3454       else if (ret != GS_UNHANDLED)
3455         break;
3456
3457       ret = GS_OK;
3458       switch (TREE_CODE (*expr_p))
3459         {
3460           /* First deal with the special cases.  */
3461
3462         case POSTINCREMENT_EXPR:
3463         case POSTDECREMENT_EXPR:
3464         case PREINCREMENT_EXPR:
3465         case PREDECREMENT_EXPR:
3466           ret = gimplify_self_mod_expr (expr_p, pre_p, post_p,
3467                                         fallback != fb_none);
3468           break;
3469
3470         case ARRAY_REF:
3471         case ARRAY_RANGE_REF:
3472         case REALPART_EXPR:
3473         case IMAGPART_EXPR:
3474         case COMPONENT_REF:
3475           ret = gimplify_compound_lval (expr_p, pre_p, post_p,
3476                                         fallback & fb_lvalue);
3477           break;
3478
3479         case COND_EXPR:
3480           ret = gimplify_cond_expr (expr_p, pre_p, NULL_TREE);
3481           break;
3482
3483         case CALL_EXPR:
3484           ret = gimplify_call_expr (expr_p, pre_p, gimple_test_f);
3485           break;
3486
3487         case TREE_LIST:
3488           abort ();
3489
3490         case COMPOUND_EXPR:
3491           ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none);
3492           break;
3493
3494         case MODIFY_EXPR:
3495         case INIT_EXPR:
3496           ret = gimplify_modify_expr (expr_p, pre_p, post_p,
3497                                       fallback != fb_none);
3498           break;
3499
3500         case TRUTH_ANDIF_EXPR:
3501         case TRUTH_ORIF_EXPR:
3502           ret = gimplify_boolean_expr (expr_p);
3503           break;
3504
3505         case TRUTH_NOT_EXPR:
3506           TREE_OPERAND (*expr_p, 0)
3507             = gimple_boolify (TREE_OPERAND (*expr_p, 0));
3508           ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3509                                is_gimple_val, fb_rvalue);
3510           recalculate_side_effects (*expr_p);
3511           break;
3512
3513         case ADDR_EXPR:
3514           ret = gimplify_addr_expr (expr_p, pre_p, post_p);
3515           break;
3516
3517         case VA_ARG_EXPR:
3518           ret = gimplify_va_arg_expr (expr_p, pre_p, post_p);
3519           break;
3520
3521         case VIEW_CONVERT_EXPR:
3522           if (VOID_TYPE_P (TREE_TYPE (*expr_p))
3523               || fallback == fb_none)
3524             {
3525               /* Just strip a conversion to void (or in void context) and
3526                  try again.  */
3527               *expr_p = TREE_OPERAND (*expr_p, 0);
3528               break;
3529             }
3530
3531           /* If both types are BLKmode or if one type is of variable size,
3532              convert this into a pointer punning operation.  This avoids
3533              copies of large data or making a variable-size temporary.  */
3534           if ((TYPE_MODE (TREE_TYPE (*expr_p)) == BLKmode
3535                && TYPE_MODE (TREE_TYPE (TREE_OPERAND (*expr_p, 0))) == BLKmode)
3536               || !TREE_CONSTANT (TYPE_SIZE (TREE_TYPE (*expr_p)))
3537               || !TREE_CONSTANT (TYPE_SIZE (TREE_TYPE
3538                                             (TREE_OPERAND (*expr_p,0)))))
3539             {
3540               tree restype = TREE_TYPE (*expr_p);
3541               *expr_p = build1 (INDIRECT_REF, TREE_TYPE (*expr_p),
3542                                 fold_convert (build_pointer_type (restype),
3543                                               build_addr_expr
3544                                               (TREE_OPERAND (*expr_p, 0))));
3545               break;
3546             }
3547           goto unary;
3548
3549         case CONVERT_EXPR:
3550         case NOP_EXPR:
3551           if (IS_EMPTY_STMT (*expr_p))
3552             {
3553               ret = GS_ALL_DONE;
3554               break;
3555             }
3556
3557           if (VOID_TYPE_P (TREE_TYPE (*expr_p))
3558               || fallback == fb_none)
3559             {
3560               /* Just strip a conversion to void (or in void context) and
3561                  try again.  */
3562               *expr_p = TREE_OPERAND (*expr_p, 0);
3563               break;
3564             }
3565
3566           ret = gimplify_conversion (expr_p);
3567           if (ret == GS_ERROR)
3568             break;
3569           if (*expr_p != save_expr)
3570             break;
3571           /* FALLTHRU */
3572
3573         case FIX_TRUNC_EXPR:
3574         case FIX_CEIL_EXPR:
3575         case FIX_FLOOR_EXPR:
3576         case FIX_ROUND_EXPR:
3577         unary:
3578           /* unary_expr: ... | '(' cast ')' val | ...  */
3579           ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3580                                is_gimple_val, fb_rvalue);
3581           recalculate_side_effects (*expr_p);
3582           break;
3583
3584         case INDIRECT_REF:
3585           ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3586                                is_gimple_reg, fb_rvalue);
3587           recalculate_side_effects (*expr_p);
3588           break;
3589
3590           /* Constants need not be gimplified.  */
3591         case INTEGER_CST:
3592         case REAL_CST:
3593         case STRING_CST:
3594         case COMPLEX_CST:
3595         case VECTOR_CST:
3596           ret = GS_ALL_DONE;
3597           break;
3598
3599         case CONST_DECL:
3600           *expr_p = DECL_INITIAL (*expr_p);
3601           break;
3602
3603         case EXC_PTR_EXPR:
3604           /* FIXME make this a decl.  */
3605           ret = GS_ALL_DONE;
3606           break;
3607
3608         case BIND_EXPR:
3609           ret = gimplify_bind_expr (expr_p, NULL, pre_p);
3610           break;
3611
3612         case LOOP_EXPR:
3613           ret = gimplify_loop_expr (expr_p, pre_p);
3614           break;
3615
3616         case SWITCH_EXPR:
3617           ret = gimplify_switch_expr (expr_p, pre_p);
3618           break;
3619
3620         case LABELED_BLOCK_EXPR:
3621           ret = gimplify_labeled_block_expr (expr_p);
3622           break;
3623
3624         case EXIT_BLOCK_EXPR:
3625           ret = gimplify_exit_block_expr (expr_p);
3626           break;
3627
3628         case EXIT_EXPR:
3629           ret = gimplify_exit_expr (expr_p);
3630           break;
3631
3632         case GOTO_EXPR:
3633           /* If the target is not LABEL, then it is a computed jump
3634              and the target needs to be gimplified.  */
3635           if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL)
3636             ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p,
3637                                  NULL, is_gimple_val, fb_rvalue);
3638           break;
3639
3640         case LABEL_EXPR:
3641           ret = GS_ALL_DONE;
3642 #ifdef ENABLE_CHECKING
3643           if (decl_function_context (LABEL_EXPR_LABEL (*expr_p)) != current_function_decl)
3644             abort ();
3645 #endif
3646           break;
3647
3648         case CASE_LABEL_EXPR:
3649           ret = gimplify_case_label_expr (expr_p);
3650           break;
3651
3652         case RETURN_EXPR:
3653           ret = gimplify_return_expr (*expr_p, pre_p);
3654           break;
3655
3656         case CONSTRUCTOR:
3657           /* Don't reduce this in place; let gimplify_init_constructor work
3658              its magic.  */
3659           ret = GS_ALL_DONE;
3660           break;
3661
3662           /* The following are special cases that are not handled by the
3663              original GIMPLE grammar.  */
3664
3665           /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
3666              eliminated.  */
3667         case SAVE_EXPR:
3668           ret = gimplify_save_expr (expr_p, pre_p, post_p);
3669           break;
3670
3671         case BIT_FIELD_REF:
3672           {
3673             enum gimplify_status r0, r1, r2;
3674
3675             r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3676                                 is_gimple_min_lval, fb_either);
3677             r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
3678                                 is_gimple_val, fb_rvalue);
3679             r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p, post_p,
3680                                 is_gimple_val, fb_rvalue);
3681             recalculate_side_effects (*expr_p);
3682
3683             ret = MIN (r0, MIN (r1, r2));
3684           }
3685           break;
3686
3687         case NON_LVALUE_EXPR:
3688           /* This should have been stripped above.  */
3689           abort ();
3690           break;
3691
3692         case ASM_EXPR:
3693           ret = gimplify_asm_expr (expr_p, pre_p, post_p);
3694           break;
3695
3696         case TRY_FINALLY_EXPR:
3697         case TRY_CATCH_EXPR:
3698           gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 0));
3699           gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 1));
3700           ret = GS_ALL_DONE;
3701           break;
3702
3703         case CLEANUP_POINT_EXPR:
3704           ret = gimplify_cleanup_point_expr (expr_p, pre_p);
3705           break;
3706
3707         case TARGET_EXPR:
3708           ret = gimplify_target_expr (expr_p, pre_p, post_p);
3709           break;
3710
3711         case CATCH_EXPR:
3712           gimplify_to_stmt_list (&CATCH_BODY (*expr_p));
3713           ret = GS_ALL_DONE;
3714           break;
3715
3716         case EH_FILTER_EXPR:
3717           gimplify_to_stmt_list (&EH_FILTER_FAILURE (*expr_p));
3718           ret = GS_ALL_DONE;
3719           break;
3720
3721         case OBJ_TYPE_REF:
3722           {
3723             enum gimplify_status r0, r1;
3724             r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p, post_p,
3725                                 is_gimple_val, fb_rvalue);
3726             r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p, post_p,
3727                                 is_gimple_val, fb_rvalue);
3728             ret = MIN (r0, r1);
3729           }
3730           break;
3731
3732         case MIN_EXPR:
3733         case MAX_EXPR:
3734           ret = gimplify_minimax_expr (expr_p, pre_p, post_p);
3735           break;
3736
3737         case LABEL_DECL:
3738           /* We get here when taking the address of a label.  We mark
3739              the label as "forced"; meaning it can never be removed and
3740              it is a potential target for any computed goto.  */
3741           FORCED_LABEL (*expr_p) = 1;
3742           ret = GS_ALL_DONE;
3743           break;
3744
3745         case STATEMENT_LIST:
3746           ret = gimplify_statement_list (expr_p);
3747           break;
3748
3749         case VAR_DECL:
3750           /* ??? If this is a local variable, and it has not been seen in any
3751              outer BIND_EXPR, then it's probably the result of a duplicate
3752              declaration, for which we've already issued an error.  It would
3753              be really nice if the front end wouldn't leak these at all.
3754              Currently the only known culprit is C++ destructors, as seen
3755              in g++.old-deja/g++.jason/binding.C.  */
3756           tmp = *expr_p;
3757           if (!TREE_STATIC (tmp) && !DECL_EXTERNAL (tmp)
3758               && decl_function_context (tmp) == current_function_decl
3759               && !tmp->decl.seen_in_bind_expr)
3760             {
3761 #ifdef ENABLE_CHECKING
3762               if (!errorcount && !sorrycount)
3763                 abort ();
3764 #endif
3765               ret = GS_ERROR;
3766             }
3767           else
3768             ret = GS_ALL_DONE;
3769           break;
3770
3771         default:
3772           /* If this is a comparison of objects of aggregate type, handle
3773              it specially (by converting to a call to memcmp).  It would be
3774              nice to only have to do this for variable-sized objects, but
3775              then we'd have to allow the same nest of reference nodes we
3776              allow for MODIFY_EXPR and that's too complex.  */
3777           if (TREE_CODE_CLASS (TREE_CODE (*expr_p)) == '<'
3778               && (AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (*expr_p, 1)))))
3779             ret = gimplify_variable_sized_compare (expr_p);
3780
3781           /* If *EXPR_P does not need to be special-cased, handle it
3782              according to its class.  */
3783           else if (TREE_CODE_CLASS (TREE_CODE (*expr_p)) == '1')
3784             ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
3785                                  post_p, is_gimple_val, fb_rvalue);
3786           else if (TREE_CODE_CLASS (TREE_CODE (*expr_p)) == '2'
3787                    || TREE_CODE_CLASS (TREE_CODE (*expr_p)) == '<'
3788                    || TREE_CODE (*expr_p) == TRUTH_AND_EXPR
3789                    || TREE_CODE (*expr_p) == TRUTH_OR_EXPR
3790                    || TREE_CODE (*expr_p) == TRUTH_XOR_EXPR)
3791             {
3792               enum gimplify_status r0, r1;
3793
3794               r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
3795                                   post_p, is_gimple_val, fb_rvalue);
3796               r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
3797                                   post_p, is_gimple_val, fb_rvalue);
3798
3799               ret = MIN (r0, r1);
3800             }
3801           else if (TREE_CODE_CLASS (TREE_CODE (*expr_p)) == 'd'
3802                    || TREE_CODE_CLASS (TREE_CODE (*expr_p)) == 'c')
3803             {
3804               ret = GS_ALL_DONE;
3805               break;
3806             }
3807           else
3808             /* Fail if we don't know how to handle this tree code.  */
3809             abort ();
3810
3811           recalculate_side_effects (*expr_p);
3812           break;
3813         }
3814
3815       /* If we replaced *expr_p, gimplify again.  */
3816       if (ret == GS_OK && (*expr_p == NULL || *expr_p == save_expr))
3817         ret = GS_ALL_DONE;
3818     }
3819   while (ret == GS_OK);
3820
3821   /* If we encountered an error_mark somewhere nested inside, either
3822      stub out the statement or propagate the error back out.  */
3823   if (ret == GS_ERROR)
3824     {
3825       if (is_statement)
3826         *expr_p = NULL;
3827       goto out;
3828     }
3829
3830 #ifdef ENABLE_CHECKING
3831   /* This was only valid as a return value from the langhook, which
3832      we handled.  Make sure it doesn't escape from any other context.  */
3833   if (ret == GS_UNHANDLED)
3834     abort ();
3835 #endif
3836
3837   if (fallback == fb_none && *expr_p && !is_gimple_stmt (*expr_p))
3838     {
3839       /* We aren't looking for a value, and we don't have a valid
3840          statement.  If it doesn't have side-effects, throw it away.  */
3841       if (!TREE_SIDE_EFFECTS (*expr_p))
3842         *expr_p = NULL;
3843       else if (!TREE_THIS_VOLATILE (*expr_p))
3844         {
3845           /* This is probably a _REF that contains something nested that
3846              has side effects.  Recurse through the operands to find it.  */
3847           enum tree_code code = TREE_CODE (*expr_p);
3848
3849           if (code == COMPONENT_REF
3850               || code == REALPART_EXPR || code == IMAGPART_EXPR)
3851             gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3852                            gimple_test_f, fallback);
3853           else if (code == ARRAY_REF || code == ARRAY_RANGE_REF)
3854             {
3855               gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3856                              gimple_test_f, fallback);
3857               gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
3858                            gimple_test_f, fallback);
3859             }
3860           else
3861             /* Anything else with side-effects
3862                must be converted to a valid statement before we get here.  */
3863             abort ();
3864
3865           *expr_p = NULL;
3866         }
3867       else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p)))
3868         {
3869           /* Historically, the compiler has treated a bare
3870              reference to a volatile lvalue as forcing a load.  */
3871           tree tmp = create_tmp_var (TREE_TYPE (*expr_p), "vol");
3872           *expr_p = build (MODIFY_EXPR, TREE_TYPE (tmp), tmp, *expr_p);
3873         }
3874       else
3875         /* We can't do anything useful with a volatile reference to
3876            incomplete type, so just throw it away.  */
3877         *expr_p = NULL;
3878     }
3879
3880   /* If we are gimplifying at the statement level, we're done.  Tack
3881      everything together and replace the original statement with the
3882      gimplified form.  */
3883   if (fallback == fb_none || is_statement)
3884     {
3885       if (internal_pre || internal_post)
3886         {
3887           append_to_statement_list (*expr_p, &internal_pre);
3888           append_to_statement_list (internal_post, &internal_pre);
3889           annotate_all_with_locus (&internal_pre, input_location);
3890           *expr_p = internal_pre;
3891         }
3892       else if (!*expr_p)
3893         ;
3894       else if (TREE_CODE (*expr_p) == STATEMENT_LIST)
3895         annotate_all_with_locus (expr_p, input_location);
3896       else
3897         annotate_one_with_locus (*expr_p, input_location);
3898       goto out;
3899     }
3900
3901   /* Otherwise we're gimplifying a subexpression, so the resulting value is
3902      interesting.  */
3903
3904   /* If it's sufficiently simple already, we're done.  Unless we are
3905      handling some post-effects internally; if that's the case, we need to
3906      copy into a temp before adding the post-effects to the tree.  */
3907   if (!internal_post && (*gimple_test_f) (*expr_p))
3908     goto out;
3909
3910   /* Otherwise, we need to create a new temporary for the gimplified
3911      expression.  */
3912
3913   /* We can't return an lvalue if we have an internal postqueue.  The
3914      object the lvalue refers to would (probably) be modified by the
3915      postqueue; we need to copy the value out first, which means an
3916      rvalue.  */
3917   if ((fallback & fb_lvalue) && !internal_post
3918       && is_gimple_addr_expr_arg (*expr_p))
3919     {
3920       /* An lvalue will do.  Take the address of the expression, store it
3921          in a temporary, and replace the expression with an INDIRECT_REF of
3922          that temporary.  */
3923       tmp = build_fold_addr_expr (*expr_p);
3924       gimplify_expr (&tmp, pre_p, post_p, is_gimple_reg, fb_rvalue);
3925       *expr_p = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (tmp)), tmp);
3926     }
3927   else if ((fallback & fb_rvalue) && is_gimple_rhs (*expr_p))
3928     {
3929 #if defined ENABLE_CHECKING
3930       if (VOID_TYPE_P (TREE_TYPE (*expr_p)))
3931         abort ();
3932 #endif
3933
3934       /* An rvalue will do.  Assign the gimplified expression into a new
3935          temporary TMP and replace the original expression with TMP.  */
3936
3937       if (internal_post || (fallback & fb_lvalue))
3938         /* The postqueue might change the value of the expression between
3939            the initialization and use of the temporary, so we can't use a
3940            formal temp.  FIXME do we care?  */
3941         *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
3942       else
3943         *expr_p = get_formal_tmp_var (*expr_p, pre_p);
3944     }
3945   else if (fallback & fb_mayfail)
3946     {
3947       /* If this is an asm statement, and the user asked for the impossible,
3948          don't abort.  Fail and let gimplify_asm_expr issue an error.  */
3949       ret = GS_ERROR;
3950       goto out;
3951     }
3952   else
3953     {
3954       fprintf (stderr, "gimplification failed:\n");
3955       print_generic_expr (stderr, *expr_p, 0);
3956       debug_tree (*expr_p);
3957       abort ();
3958     }
3959
3960 #if defined ENABLE_CHECKING
3961   /* Make sure the temporary matches our predicate.  */
3962   if (!(*gimple_test_f) (*expr_p))
3963     abort ();
3964 #endif
3965
3966   if (internal_post)
3967     {
3968       annotate_all_with_locus (&internal_post, input_location);
3969       append_to_statement_list (internal_post, pre_p);
3970     }
3971
3972  out:
3973   input_location = saved_location;
3974   return ret;
3975 }
3976
3977 /* Look through TYPE for variable-sized objects and gimplify each such
3978    size that we find.  Add to LIST_P any statements generated.  */
3979
3980 void
3981 gimplify_type_sizes (tree type, tree *list_p)
3982 {
3983   tree field;
3984
3985   switch (TREE_CODE (type))
3986     {
3987     case ERROR_MARK:
3988       return;
3989
3990     case INTEGER_TYPE:
3991     case ENUMERAL_TYPE:
3992     case BOOLEAN_TYPE:
3993     case CHAR_TYPE:
3994     case REAL_TYPE:
3995       gimplify_one_sizepos (&TYPE_MIN_VALUE (type), list_p);
3996       gimplify_one_sizepos (&TYPE_MAX_VALUE (type), list_p);
3997       break;
3998
3999     case ARRAY_TYPE:
4000       /* These anonymous types don't have declarations, so handle them here. */
4001       gimplify_type_sizes (TYPE_DOMAIN (type), list_p);
4002       break;
4003
4004     case RECORD_TYPE:
4005     case UNION_TYPE:
4006     case QUAL_UNION_TYPE:
4007       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
4008         if (TREE_CODE (field) == FIELD_DECL)
4009           gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p);
4010       break;
4011
4012     default:
4013       break;
4014     }
4015
4016   gimplify_one_sizepos (&TYPE_SIZE (type), list_p);
4017   gimplify_one_sizepos (&TYPE_SIZE_UNIT (type), list_p);
4018 }
4019
4020 /* Subroutine of the above to gimplify one size or position, *EXPR_P.
4021    We add any required statements to STMT_P.  */
4022
4023 void
4024 gimplify_one_sizepos (tree *expr_p, tree *stmt_p)
4025 {
4026   /* We don't do anything if the value isn't there, is constant, or contains
4027      A PLACEHOLDER_EXPR.  */
4028   if (*expr_p == NULL_TREE || TREE_CONSTANT (*expr_p)
4029       || CONTAINS_PLACEHOLDER_P (*expr_p))
4030     return;
4031
4032   gimplify_expr (expr_p, stmt_p, NULL, is_gimple_val, fb_rvalue);
4033 }
4034 \f
4035 #ifdef ENABLE_CHECKING
4036 /* Compare types A and B for a "close enough" match.  */
4037
4038 static bool
4039 cpt_same_type (tree a, tree b)
4040 {
4041   if (lang_hooks.types_compatible_p (a, b))
4042     return true;
4043
4044   /* ??? The C++ FE decomposes METHOD_TYPES to FUNCTION_TYPES and doesn't
4045      link them together.  This routine is intended to catch type errors
4046      that will affect the optimizers, and the optimizers don't add new
4047      dereferences of function pointers, so ignore it.  */
4048   if ((TREE_CODE (a) == FUNCTION_TYPE || TREE_CODE (a) == METHOD_TYPE)
4049       && (TREE_CODE (b) == FUNCTION_TYPE || TREE_CODE (b) == METHOD_TYPE))
4050     return true;
4051
4052   /* ??? The C FE pushes type qualifiers after the fact into the type of
4053      the element from the type of the array.  See build_unary_op's handling
4054      of ADDR_EXPR.  This seems wrong -- if we were going to do this, we
4055      should have done it when creating the variable in the first place.
4056      Alternately, why aren't the two array types made variants?  */
4057   if (TREE_CODE (a) == ARRAY_TYPE && TREE_CODE (b) == ARRAY_TYPE)
4058     return cpt_same_type (TREE_TYPE (a), TREE_TYPE (b));
4059
4060   /* And because of those, we have to recurse down through pointers.  */
4061   if (POINTER_TYPE_P (a) && POINTER_TYPE_P (b))
4062     return cpt_same_type (TREE_TYPE (a), TREE_TYPE (b));
4063
4064   return false;
4065 }
4066
4067 /* Check for some cases of the front end missing cast expressions.
4068    The type of a dereference should correspond to the pointer type;
4069    similarly the type of an address should match its object.  */
4070
4071 static tree
4072 check_pointer_types_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
4073                        void *data ATTRIBUTE_UNUSED)
4074 {
4075   tree t = *tp;
4076   tree ptype, otype, dtype;
4077
4078   switch (TREE_CODE (t))
4079     {
4080     case INDIRECT_REF:
4081     case ARRAY_REF:
4082       otype = TREE_TYPE (t);
4083       ptype = TREE_TYPE (TREE_OPERAND (t, 0));
4084       dtype = TREE_TYPE (ptype);
4085       if (!cpt_same_type (otype, dtype))
4086         abort ();
4087       break;
4088
4089     case ADDR_EXPR:
4090       ptype = TREE_TYPE (t);
4091       otype = TREE_TYPE (TREE_OPERAND (t, 0));
4092       dtype = TREE_TYPE (ptype);
4093       if (!cpt_same_type (otype, dtype))
4094         {
4095           /* &array is allowed to produce a pointer to the element, rather than
4096              a pointer to the array type.  We must allow this in order to
4097              properly represent assigning the address of an array in C into
4098              pointer to the element type.  */
4099           if (TREE_CODE (otype) == ARRAY_TYPE
4100               && POINTER_TYPE_P (ptype)
4101               && cpt_same_type (TREE_TYPE (otype), dtype))
4102             break;
4103           abort ();
4104         }
4105       break;
4106
4107     default:
4108       return NULL_TREE;
4109     }
4110
4111
4112   return NULL_TREE;
4113 }
4114 #endif
4115
4116 /* Gimplify the body of statements pointed by BODY_P.  FNDECL is the
4117    function decl containing BODY.  */
4118
4119 void
4120 gimplify_body (tree *body_p, tree fndecl)
4121 {
4122   location_t saved_location = input_location;
4123   tree body;
4124
4125   timevar_push (TV_TREE_GIMPLIFY);
4126   push_gimplify_context ();
4127
4128   /* Unshare most shared trees in the body and in that of any nested functions.
4129      It would seem we don't have to do this for nested functions because
4130      they are supposed to be output and then the outer function gimplified
4131      first, but the g++ front end doesn't always do it that way.  */
4132   unshare_body (body_p, fndecl);
4133   unvisit_body (body_p, fndecl);
4134
4135   /* Make sure input_location isn't set to something wierd.  */
4136   input_location = DECL_SOURCE_LOCATION (fndecl);
4137
4138   /* Gimplify the function's body.  */
4139   gimplify_stmt (body_p);
4140   body = *body_p;
4141
4142   /* Unshare again, in case gimplification was sloppy.  */
4143   unshare_all_trees (body);
4144
4145   if (!body)
4146     body = alloc_stmt_list ();
4147   else if (TREE_CODE (body) == STATEMENT_LIST)
4148     {
4149       tree t = expr_only (*body_p);
4150       if (t)
4151         body = t;
4152     }
4153
4154   /* If there isn't an outer BIND_EXPR, add one.  */
4155   if (TREE_CODE (body) != BIND_EXPR)
4156     {
4157       tree b = build (BIND_EXPR, void_type_node, NULL_TREE,
4158                       NULL_TREE, NULL_TREE);
4159       TREE_SIDE_EFFECTS (b) = 1;
4160       append_to_statement_list_force (body, &BIND_EXPR_BODY (b));
4161       body = b;
4162     }
4163   *body_p = body;
4164
4165   pop_gimplify_context (body);
4166
4167 #ifdef ENABLE_CHECKING
4168   walk_tree (body_p, check_pointer_types_r, NULL, NULL);
4169 #endif
4170
4171   timevar_pop (TV_TREE_GIMPLIFY);
4172   input_location = saved_location;
4173 }
4174
4175 /* Entry point to the gimplification pass.  FNDECL is the FUNCTION_DECL
4176    node for the function we want to gimplify.  */
4177
4178 void
4179 gimplify_function_tree (tree fndecl)
4180 {
4181   tree oldfn;
4182
4183   oldfn = current_function_decl;
4184   current_function_decl = fndecl;
4185
4186   gimplify_body (&DECL_SAVED_TREE (fndecl), fndecl);
4187
4188   /* If we're instrumenting function entry/exit, then prepend the call to
4189      the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
4190      catch the exit hook.  */
4191   /* ??? Add some way to ignore exceptions for this TFE.  */
4192   if (flag_instrument_function_entry_exit
4193       && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl))
4194     {
4195       tree tf, x, bind;
4196
4197       tf = build (TRY_FINALLY_EXPR, void_type_node, NULL, NULL);
4198       TREE_SIDE_EFFECTS (tf) = 1;
4199       x = DECL_SAVED_TREE (fndecl);
4200       append_to_statement_list (x, &TREE_OPERAND (tf, 0));
4201       x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_EXIT];
4202       x = build_function_call_expr (x, NULL);
4203       append_to_statement_list (x, &TREE_OPERAND (tf, 1));
4204
4205       bind = build (BIND_EXPR, void_type_node, NULL, NULL, NULL);
4206       TREE_SIDE_EFFECTS (bind) = 1;
4207       x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_ENTER];
4208       x = build_function_call_expr (x, NULL);
4209       append_to_statement_list (x, &BIND_EXPR_BODY (bind));
4210       append_to_statement_list (tf, &BIND_EXPR_BODY (bind));
4211
4212       DECL_SAVED_TREE (fndecl) = bind;
4213     }
4214
4215   current_function_decl = oldfn;
4216 }
4217
4218 #include "gt-gimplify.h"