gcc/gimple.c

   1 /* Gimple IR support functions.
   2
   3    Copyright 2007, 2008 Free Software Foundation, Inc.
   4    Contributed by Aldy Hernandez <aldyh@redhat.com>
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "tree.h"
  27 #include "ggc.h"
  28 #include "errors.h"
  29 #include "hard-reg-set.h"
  30 #include "basic-block.h"
  31 #include "gimple.h"
  32 #include "diagnostic.h"
  33 #include "tree-flow.h"
  34 #include "value-prof.h"
  35 #include "flags.h"
  36
  37 #define DEFGSCODE(SYM, NAME, STRUCT)    NAME,
  38 const char *const gimple_code_name[] = {
  39 #include "gimple.def"
  40 };
  41 #undef DEFGSCODE
  42
  43 /* All the tuples have their operand vector at the very bottom
  44    of the structure.  Therefore, the offset required to find the
  45    operands vector the size of the structure minus the size of the 1
  46    element tree array at the end (see gimple_ops).  */
  47 #define DEFGSCODE(SYM, NAME, STRUCT)    (sizeof (STRUCT) - sizeof (tree)),
  48 const size_t gimple_ops_offset_[] = {
  49 #include "gimple.def"
  50 };
  51 #undef DEFGSCODE
  52
  53 #ifdef GATHER_STATISTICS
  54 /* Gimple stats.  */
  55
  56 int gimple_alloc_counts[(int) gimple_alloc_kind_all];
  57 int gimple_alloc_sizes[(int) gimple_alloc_kind_all];
  58
  59 /* Keep in sync with gimple.h:enum gimple_alloc_kind.  */
  60 static const char * const gimple_alloc_kind_names[] = {
  61     "assignments",
  62     "phi nodes",
  63     "conditionals",
  64     "sequences",
  65     "everything else"
  66 };
  67
  68 #endif /* GATHER_STATISTICS */
  69
  70 /* A cache of gimple_seq objects.  Sequences are created and destroyed
  71    fairly often during gimplification.  */
  72 static GTY ((deletable)) struct gimple_seq_d *gimple_seq_cache;
  73
  74 /* Private API manipulation functions shared only with some
  75    other files.  */
  76 extern void gimple_set_stored_syms (gimple, bitmap, bitmap_obstack *);
  77 extern void gimple_set_loaded_syms (gimple, bitmap, bitmap_obstack *);
  78
  79 /* Gimple tuple constructors.
  80    Note: Any constructor taking a ``gimple_seq'' as a parameter, can
  81    be passed a NULL to start with an empty sequence.  */
  82
  83 /* Set the code for statement G to CODE.  */
  84
  85 static inline void
  86 gimple_set_code (gimple g, enum gimple_code code)
  87 {
  88   g->gsbase.code = code;
  89 }
  90
  91
  92 /* Return the GSS_* identifier for the given GIMPLE statement CODE.  */
  93
  94 static enum gimple_statement_structure_enum
  95 gss_for_code (enum gimple_code code)
  96 {
  97   switch (code)
  98     {
  99     case GIMPLE_ASSIGN:
 100     case GIMPLE_CALL:
 101     case GIMPLE_RETURN:                 return GSS_WITH_MEM_OPS;
 102     case GIMPLE_COND:
 103     case GIMPLE_GOTO:
 104     case GIMPLE_LABEL:
 105     case GIMPLE_CHANGE_DYNAMIC_TYPE:
 106     case GIMPLE_SWITCH:                 return GSS_WITH_OPS;
 107     case GIMPLE_ASM:                    return GSS_ASM;
 108     case GIMPLE_BIND:                   return GSS_BIND;
 109     case GIMPLE_CATCH:                  return GSS_CATCH;
 110     case GIMPLE_EH_FILTER:              return GSS_EH_FILTER;
 111     case GIMPLE_NOP:                    return GSS_BASE;
 112     case GIMPLE_PHI:                    return GSS_PHI;
 113     case GIMPLE_RESX:                   return GSS_RESX;
 114     case GIMPLE_TRY:                    return GSS_TRY;
 115     case GIMPLE_WITH_CLEANUP_EXPR:      return GSS_WCE;
 116     case GIMPLE_OMP_CRITICAL:           return GSS_OMP_CRITICAL;
 117     case GIMPLE_OMP_FOR:                return GSS_OMP_FOR;
 118     case GIMPLE_OMP_MASTER:
 119     case GIMPLE_OMP_ORDERED:
 120     case GIMPLE_OMP_SECTION:            return GSS_OMP;
 121     case GIMPLE_OMP_RETURN:
 122     case GIMPLE_OMP_SECTIONS_SWITCH:    return GSS_BASE;
 123     case GIMPLE_OMP_CONTINUE:           return GSS_OMP_CONTINUE;
 124     case GIMPLE_OMP_PARALLEL:           return GSS_OMP_PARALLEL;
 125     case GIMPLE_OMP_TASK:               return GSS_OMP_TASK;
 126     case GIMPLE_OMP_SECTIONS:           return GSS_OMP_SECTIONS;
 127     case GIMPLE_OMP_SINGLE:             return GSS_OMP_SINGLE;
 128     case GIMPLE_OMP_ATOMIC_LOAD:        return GSS_OMP_ATOMIC_LOAD;
 129     case GIMPLE_OMP_ATOMIC_STORE:       return GSS_OMP_ATOMIC_STORE;
 130     case GIMPLE_PREDICT:                return GSS_BASE;
 131     default:                            gcc_unreachable ();
 132     }
 133 }
 134
 135
 136 /* Return the number of bytes needed to hold a GIMPLE statement with
 137    code CODE.  */
 138
 139 static size_t
 140 gimple_size (enum gimple_code code)
 141 {
 142   enum gimple_statement_structure_enum gss = gss_for_code (code);
 143
 144   if (gss == GSS_WITH_OPS)
 145     return sizeof (struct gimple_statement_with_ops);
 146   else if (gss == GSS_WITH_MEM_OPS)
 147     return sizeof (struct gimple_statement_with_memory_ops);
 148
 149   switch (code)
 150     {
 151     case GIMPLE_ASM:
 152       return sizeof (struct gimple_statement_asm);
 153     case GIMPLE_NOP:
 154       return sizeof (struct gimple_statement_base);
 155     case GIMPLE_BIND:
 156       return sizeof (struct gimple_statement_bind);
 157     case GIMPLE_CATCH:
 158       return sizeof (struct gimple_statement_catch);
 159     case GIMPLE_EH_FILTER:
 160       return sizeof (struct gimple_statement_eh_filter);
 161     case GIMPLE_TRY:
 162       return sizeof (struct gimple_statement_try);
 163     case GIMPLE_RESX:
 164       return sizeof (struct gimple_statement_resx);
 165     case GIMPLE_OMP_CRITICAL:
 166       return sizeof (struct gimple_statement_omp_critical);
 167     case GIMPLE_OMP_FOR:
 168       return sizeof (struct gimple_statement_omp_for);
 169     case GIMPLE_OMP_PARALLEL:
 170       return sizeof (struct gimple_statement_omp_parallel);
 171     case GIMPLE_OMP_TASK:
 172       return sizeof (struct gimple_statement_omp_task);
 173     case GIMPLE_OMP_SECTION:
 174     case GIMPLE_OMP_MASTER:
 175     case GIMPLE_OMP_ORDERED:
 176       return sizeof (struct gimple_statement_omp);
 177     case GIMPLE_OMP_RETURN:
 178       return sizeof (struct gimple_statement_base);
 179     case GIMPLE_OMP_CONTINUE:
 180       return sizeof (struct gimple_statement_omp_continue);
 181     case GIMPLE_OMP_SECTIONS:
 182       return sizeof (struct gimple_statement_omp_sections);
 183     case GIMPLE_OMP_SECTIONS_SWITCH:
 184       return sizeof (struct gimple_statement_base);
 185     case GIMPLE_OMP_SINGLE:
 186       return sizeof (struct gimple_statement_omp_single);
 187     case GIMPLE_OMP_ATOMIC_LOAD:
 188       return sizeof (struct gimple_statement_omp_atomic_load);
 189     case GIMPLE_OMP_ATOMIC_STORE:
 190       return sizeof (struct gimple_statement_omp_atomic_store);
 191     case GIMPLE_WITH_CLEANUP_EXPR:
 192       return sizeof (struct gimple_statement_wce);
 193     case GIMPLE_CHANGE_DYNAMIC_TYPE:
 194       return sizeof (struct gimple_statement_with_ops);
 195     case GIMPLE_PREDICT:
 196       return sizeof (struct gimple_statement_base);
 197     default:
 198       break;
 199     }
 200
 201   gcc_unreachable ();
 202 }
 203
 204
 205 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
 206    operands.  */
 207
 208 #define gimple_alloc(c, n) gimple_alloc_stat (c, n MEM_STAT_INFO)
 209 static gimple
 210 gimple_alloc_stat (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
 211 {
 212   size_t size;
 213   gimple stmt;
 214
 215   size = gimple_size (code);
 216   if (num_ops > 0)
 217     size += sizeof (tree) * (num_ops - 1);
 218
 219 #ifdef GATHER_STATISTICS
 220   {
 221     enum gimple_alloc_kind kind = gimple_alloc_kind (code);
 222     gimple_alloc_counts[(int) kind]++;
 223     gimple_alloc_sizes[(int) kind] += size;
 224   }
 225 #endif
 226
 227   stmt = (gimple) ggc_alloc_cleared_stat (size PASS_MEM_STAT);
 228   gimple_set_code (stmt, code);
 229   gimple_set_num_ops (stmt, num_ops);
 230
 231   /* Do not call gimple_set_modified here as it has other side
 232      effects and this tuple is still not completely built.  */
 233   stmt->gsbase.modified = 1;
 234
 235   return stmt;
 236 }
 237
 238 /* Set SUBCODE to be the code of the expression computed by statement G.  */
 239
 240 static inline void
 241 gimple_set_subcode (gimple g, unsigned subcode)
 242 {
 243   /* We only have 16 bits for the RHS code.  Assert that we are not
 244      overflowing it.  */
 245   gcc_assert (subcode < (1 << 16));
 246   g->gsbase.subcode = subcode;
 247 }
 248
 249
 250
 251 /* Build a tuple with operands.  CODE is the statement to build (which
 252    must be one of the GIMPLE_WITH_OPS tuples).  SUBCODE is the sub-code
 253    for the new tuple.  NUM_OPS is the number of operands to allocate.  */
 254
 255 #define gimple_build_with_ops(c, s, n) \
 256   gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
 257
 258 static gimple
 259 gimple_build_with_ops_stat (enum gimple_code code, enum tree_code subcode,
 260                             unsigned num_ops MEM_STAT_DECL)
 261 {
 262   gimple s = gimple_alloc_stat (code, num_ops PASS_MEM_STAT);
 263   gimple_set_subcode (s, subcode);
 264
 265   return s;
 266 }
 267
 268
 269 /* Build a GIMPLE_RETURN statement returning RETVAL.  */
 270
 271 gimple
 272 gimple_build_return (tree retval)
 273 {
 274   gimple s = gimple_build_with_ops (GIMPLE_RETURN, 0, 1);
 275   if (retval)
 276     gimple_return_set_retval (s, retval);
 277   return s;
 278 }
 279
 280 /* Helper for gimple_build_call, gimple_build_call_vec and
 281    gimple_build_call_from_tree.  Build the basic components of a
 282    GIMPLE_CALL statement to function FN with NARGS arguments.  */
 283
 284 static inline gimple
 285 gimple_build_call_1 (tree fn, unsigned nargs)
 286 {
 287   gimple s = gimple_build_with_ops (GIMPLE_CALL, 0, nargs + 3);
 288   if (TREE_CODE (fn) == FUNCTION_DECL)
 289     fn = build_fold_addr_expr (fn);
 290   gimple_set_op (s, 1, fn);
 291   return s;
 292 }
 293
 294
 295 /* Build a GIMPLE_CALL statement to function FN with the arguments
 296    specified in vector ARGS.  */
 297
 298 gimple
 299 gimple_build_call_vec (tree fn, VEC(tree, heap) *args)
 300 {
 301   unsigned i;
 302   unsigned nargs = VEC_length (tree, args);
 303   gimple call = gimple_build_call_1 (fn, nargs);
 304
 305   for (i = 0; i < nargs; i++)
 306     gimple_call_set_arg (call, i, VEC_index (tree, args, i));
 307
 308   return call;
 309 }
 310
 311
 312 /* Build a GIMPLE_CALL statement to function FN.  NARGS is the number of
 313    arguments.  The ... are the arguments.  */
 314
 315 gimple
 316 gimple_build_call (tree fn, unsigned nargs, ...)
 317 {
 318   va_list ap;
 319   gimple call;
 320   unsigned i;
 321
 322   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
 323
 324   call = gimple_build_call_1 (fn, nargs);
 325
 326   va_start (ap, nargs);
 327   for (i = 0; i < nargs; i++)
 328     gimple_call_set_arg (call, i, va_arg (ap, tree));
 329   va_end (ap);
 330
 331   return call;
 332 }
 333
 334
 335 /* Build a GIMPLE_CALL statement from CALL_EXPR T.  Note that T is
 336    assumed to be in GIMPLE form already.  Minimal checking is done of
 337    this fact.  */
 338
 339 gimple
 340 gimple_build_call_from_tree (tree t)
 341 {
 342   unsigned i, nargs;
 343   gimple call;
 344   tree fndecl = get_callee_fndecl (t);
 345
 346   gcc_assert (TREE_CODE (t) == CALL_EXPR);
 347
 348   nargs = call_expr_nargs (t);
 349   call = gimple_build_call_1 (fndecl ? fndecl : CALL_EXPR_FN (t), nargs);
 350
 351   for (i = 0; i < nargs; i++)
 352     gimple_call_set_arg (call, i, CALL_EXPR_ARG (t, i));
 353
 354   gimple_set_block (call, TREE_BLOCK (t));
 355
 356   /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL.  */
 357   gimple_call_set_chain (call, CALL_EXPR_STATIC_CHAIN (t));
 358   gimple_call_set_tail (call, CALL_EXPR_TAILCALL (t));
 359   gimple_call_set_cannot_inline (call, CALL_CANNOT_INLINE_P (t));
 360   gimple_call_set_return_slot_opt (call, CALL_EXPR_RETURN_SLOT_OPT (t));
 361   gimple_call_set_from_thunk (call, CALL_FROM_THUNK_P (t));
 362   gimple_call_set_va_arg_pack (call, CALL_EXPR_VA_ARG_PACK (t));
 363
 364   return call;
 365 }
 366
 367
 368 /* Extract the operands and code for expression EXPR into *SUBCODE_P,
 369    *OP1_P and *OP2_P respectively.  */
 370
 371 void
 372 extract_ops_from_tree (tree expr, enum tree_code *subcode_p, tree *op1_p,
 373                        tree *op2_p)
 374 {
 375   enum gimple_rhs_class grhs_class;
 376
 377   *subcode_p = TREE_CODE (expr);
 378   grhs_class = get_gimple_rhs_class (*subcode_p);
 379
 380   if (grhs_class == GIMPLE_BINARY_RHS)
 381     {
 382       *op1_p = TREE_OPERAND (expr, 0);
 383       *op2_p = TREE_OPERAND (expr, 1);
 384     }
 385   else if (grhs_class == GIMPLE_UNARY_RHS)
 386     {
 387       *op1_p = TREE_OPERAND (expr, 0);
 388       *op2_p = NULL_TREE;
 389     }
 390   else if (grhs_class == GIMPLE_SINGLE_RHS)
 391     {
 392       *op1_p = expr;
 393       *op2_p = NULL_TREE;
 394     }
 395   else
 396     gcc_unreachable ();
 397 }
 398
 399
 400 /* Build a GIMPLE_ASSIGN statement.
 401
 402    LHS of the assignment.
 403    RHS of the assignment which can be unary or binary.  */
 404
 405 gimple
 406 gimple_build_assign_stat (tree lhs, tree rhs MEM_STAT_DECL)
 407 {
 408   enum tree_code subcode;
 409   tree op1, op2;
 410
 411   extract_ops_from_tree (rhs, &subcode, &op1, &op2);
 412   return gimple_build_assign_with_ops_stat (subcode, lhs, op1, op2
 413                                             PASS_MEM_STAT);
 414 }
 415
 416
 417 /* Build a GIMPLE_ASSIGN statement with sub-code SUBCODE and operands
 418    OP1 and OP2.  If OP2 is NULL then SUBCODE must be of class
 419    GIMPLE_UNARY_RHS or GIMPLE_SINGLE_RHS.  */
 420
 421 gimple
 422 gimple_build_assign_with_ops_stat (enum tree_code subcode, tree lhs, tree op1,
 423                                    tree op2 MEM_STAT_DECL)
 424 {
 425   unsigned num_ops;
 426   gimple p;
 427
 428   /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
 429      code).  */
 430   num_ops = get_gimple_rhs_num_ops (subcode) + 1;
 431
 432   p = gimple_build_with_ops_stat (GIMPLE_ASSIGN, subcode, num_ops
 433                                   PASS_MEM_STAT);
 434   gimple_assign_set_lhs (p, lhs);
 435   gimple_assign_set_rhs1 (p, op1);
 436   if (op2)
 437     {
 438       gcc_assert (num_ops > 2);
 439       gimple_assign_set_rhs2 (p, op2);
 440     }
 441
 442   return p;
 443 }
 444
 445
 446 /* Build a new GIMPLE_ASSIGN tuple and append it to the end of *SEQ_P.
 447
 448    DST/SRC are the destination and source respectively.  You can pass
 449    ungimplified trees in DST or SRC, in which case they will be
 450    converted to a gimple operand if necessary.
 451
 452    This function returns the newly created GIMPLE_ASSIGN tuple.  */
 453
 454 inline gimple
 455 gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
 456 {
 457   tree t = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
 458   gimplify_and_add (t, seq_p);
 459   ggc_free (t);
 460   return gimple_seq_last_stmt (*seq_p);
 461 }
 462
 463
 464 /* Build a GIMPLE_COND statement.
 465
 466    PRED is the condition used to compare LHS and the RHS.
 467    T_LABEL is the label to jump to if the condition is true.
 468    F_LABEL is the label to jump to otherwise.  */
 469
 470 gimple
 471 gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
 472                    tree t_label, tree f_label)
 473 {
 474   gimple p;
 475
 476   gcc_assert (TREE_CODE_CLASS (pred_code) == tcc_comparison);
 477   p = gimple_build_with_ops (GIMPLE_COND, pred_code, 4);
 478   gimple_cond_set_lhs (p, lhs);
 479   gimple_cond_set_rhs (p, rhs);
 480   gimple_cond_set_true_label (p, t_label);
 481   gimple_cond_set_false_label (p, f_label);
 482   return p;
 483 }
 484
 485
 486 /* Extract operands for a GIMPLE_COND statement out of COND_EXPR tree COND.  */
 487
 488 void
 489 gimple_cond_get_ops_from_tree (tree cond, enum tree_code *code_p,
 490                                tree *lhs_p, tree *rhs_p)
 491 {
 492   gcc_assert (TREE_CODE_CLASS (TREE_CODE (cond)) == tcc_comparison
 493               || TREE_CODE (cond) == TRUTH_NOT_EXPR
 494               || is_gimple_min_invariant (cond)
 495               || SSA_VAR_P (cond));
 496
 497   extract_ops_from_tree (cond, code_p, lhs_p, rhs_p);
 498
 499   /* Canonicalize conditionals of the form 'if (!VAL)'.  */
 500   if (*code_p == TRUTH_NOT_EXPR)
 501     {
 502       *code_p = EQ_EXPR;
 503       gcc_assert (*lhs_p && *rhs_p == NULL_TREE);
 504       *rhs_p = fold_convert (TREE_TYPE (*lhs_p), integer_zero_node);
 505     }
 506   /* Canonicalize conditionals of the form 'if (VAL)'  */
 507   else if (TREE_CODE_CLASS (*code_p) != tcc_comparison)
 508     {
 509       *code_p = NE_EXPR;
 510       gcc_assert (*lhs_p && *rhs_p == NULL_TREE);
 511       *rhs_p = fold_convert (TREE_TYPE (*lhs_p), integer_zero_node);
 512     }
 513 }
 514
 515
 516 /* Build a GIMPLE_COND statement from the conditional expression tree
 517    COND.  T_LABEL and F_LABEL are as in gimple_build_cond.  */
 518
 519 gimple
 520 gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
 521 {
 522   enum tree_code code;
 523   tree lhs, rhs;
 524
 525   gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
 526   return gimple_build_cond (code, lhs, rhs, t_label, f_label);
 527 }
 528
 529 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
 530    boolean expression tree COND.  */
 531
 532 void
 533 gimple_cond_set_condition_from_tree (gimple stmt, tree cond)
 534 {
 535   enum tree_code code;
 536   tree lhs, rhs;
 537
 538   gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
 539   gimple_cond_set_condition (stmt, code, lhs, rhs);
 540 }
 541
 542 /* Build a GIMPLE_LABEL statement for LABEL.  */
 543
 544 gimple
 545 gimple_build_label (tree label)
 546 {
 547   gimple p = gimple_build_with_ops (GIMPLE_LABEL, 0, 1);
 548   gimple_label_set_label (p, label);
 549   return p;
 550 }
 551
 552 /* Build a GIMPLE_GOTO statement to label DEST.  */
 553
 554 gimple
 555 gimple_build_goto (tree dest)
 556 {
 557   gimple p = gimple_build_with_ops (GIMPLE_GOTO, 0, 1);
 558   gimple_goto_set_dest (p, dest);
 559   return p;
 560 }
 561
 562
 563 /* Build a GIMPLE_NOP statement.  */
 564
 565 gimple
 566 gimple_build_nop (void)
 567 {
 568   return gimple_alloc (GIMPLE_NOP, 0);
 569 }
 570
 571
 572 /* Build a GIMPLE_BIND statement.
 573    VARS are the variables in BODY.
 574    BLOCK is the containing block.  */
 575
 576 gimple
 577 gimple_build_bind (tree vars, gimple_seq body, tree block)
 578 {
 579   gimple p = gimple_alloc (GIMPLE_BIND, 0);
 580   gimple_bind_set_vars (p, vars);
 581   if (body)
 582     gimple_bind_set_body (p, body);
 583   if (block)
 584     gimple_bind_set_block (p, block);
 585   return p;
 586 }
 587
 588 /* Helper function to set the simple fields of a asm stmt.
 589
 590    STRING is a pointer to a string that is the asm blocks assembly code.
 591    NINPUT is the number of register inputs.
 592    NOUTPUT is the number of register outputs.
 593    NCLOBBERS is the number of clobbered registers.
 594    */
 595
 596 static inline gimple
 597 gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
 598                     unsigned nclobbers)
 599 {
 600   gimple p;
 601   int size = strlen (string);
 602
 603   p = gimple_build_with_ops (GIMPLE_ASM, 0, ninputs + noutputs + nclobbers);
 604
 605   p->gimple_asm.ni = ninputs;
 606   p->gimple_asm.no = noutputs;
 607   p->gimple_asm.nc = nclobbers;
 608   p->gimple_asm.string = ggc_alloc_string (string, size);
 609
 610 #ifdef GATHER_STATISTICS
 611   gimple_alloc_sizes[(int) gimple_alloc_kind (GIMPLE_ASM)] += size;
 612 #endif
 613
 614   return p;
 615 }
 616
 617 /* Build a GIMPLE_ASM statement.
 618
 619    STRING is the assembly code.
 620    NINPUT is the number of register inputs.
 621    NOUTPUT is the number of register outputs.
 622    NCLOBBERS is the number of clobbered registers.
 623    INPUTS is a vector of the input register parameters.
 624    OUTPUTS is a vector of the output register parameters.
 625    CLOBBERS is a vector of the clobbered register parameters.  */
 626
 627 gimple
 628 gimple_build_asm_vec (const char *string, VEC(tree,gc)* inputs,
 629                       VEC(tree,gc)* outputs, VEC(tree,gc)* clobbers)
 630 {
 631   gimple p;
 632   unsigned i;
 633
 634   p = gimple_build_asm_1 (string,
 635                           VEC_length (tree, inputs),
 636                           VEC_length (tree, outputs),
 637                           VEC_length (tree, clobbers));
 638
 639   for (i = 0; i < VEC_length (tree, inputs); i++)
 640     gimple_asm_set_input_op (p, i, VEC_index (tree, inputs, i));
 641
 642   for (i = 0; i < VEC_length (tree, outputs); i++)
 643     gimple_asm_set_output_op (p, i, VEC_index (tree, outputs, i));
 644
 645   for (i = 0; i < VEC_length (tree, clobbers); i++)
 646     gimple_asm_set_clobber_op (p, i, VEC_index (tree, clobbers, i));
 647
 648   return p;
 649 }
 650
 651 /* Build a GIMPLE_ASM statement.
 652
 653    STRING is the assembly code.
 654    NINPUT is the number of register inputs.
 655    NOUTPUT is the number of register outputs.
 656    NCLOBBERS is the number of clobbered registers.
 657    ... are trees for each input, output and clobbered register.  */
 658
 659 gimple
 660 gimple_build_asm (const char *string, unsigned ninputs, unsigned noutputs,
 661                   unsigned nclobbers, ...)
 662 {
 663   gimple p;
 664   unsigned i;
 665   va_list ap;
 666
 667   p = gimple_build_asm_1 (string, ninputs, noutputs, nclobbers);
 668
 669   va_start (ap, nclobbers);
 670
 671   for (i = 0; i < ninputs; i++)
 672     gimple_asm_set_input_op (p, i, va_arg (ap, tree));
 673
 674   for (i = 0; i < noutputs; i++)
 675     gimple_asm_set_output_op (p, i, va_arg (ap, tree));
 676
 677   for (i = 0; i < nclobbers; i++)
 678     gimple_asm_set_clobber_op (p, i, va_arg (ap, tree));
 679
 680   va_end (ap);
 681
 682   return p;
 683 }
 684
 685 /* Build a GIMPLE_CATCH statement.
 686
 687   TYPES are the catch types.
 688   HANDLER is the exception handler.  */
 689
 690 gimple
 691 gimple_build_catch (tree types, gimple_seq handler)
 692 {
 693   gimple p = gimple_alloc (GIMPLE_CATCH, 0);
 694   gimple_catch_set_types (p, types);
 695   if (handler)
 696     gimple_catch_set_handler (p, handler);
 697
 698   return p;
 699 }
 700
 701 /* Build a GIMPLE_EH_FILTER statement.
 702
 703    TYPES are the filter's types.
 704    FAILURE is the filter's failure action.  */
 705
 706 gimple
 707 gimple_build_eh_filter (tree types, gimple_seq failure)
 708 {
 709   gimple p = gimple_alloc (GIMPLE_EH_FILTER, 0);
 710   gimple_eh_filter_set_types (p, types);
 711   if (failure)
 712     gimple_eh_filter_set_failure (p, failure);
 713
 714   return p;
 715 }
 716
 717 /* Build a GIMPLE_TRY statement.
 718
 719    EVAL is the expression to evaluate.
 720    CLEANUP is the cleanup expression.
 721    KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
 722    whether this is a try/catch or a try/finally respectively.  */
 723
 724 gimple
 725 gimple_build_try (gimple_seq eval, gimple_seq cleanup,
 726                   enum gimple_try_flags kind)
 727 {
 728   gimple p;
 729
 730   gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
 731   p = gimple_alloc (GIMPLE_TRY, 0);
 732   gimple_set_subcode (p, kind);
 733   if (eval)
 734     gimple_try_set_eval (p, eval);
 735   if (cleanup)
 736     gimple_try_set_cleanup (p, cleanup);
 737
 738   return p;
 739 }
 740
 741 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
 742
 743    CLEANUP is the cleanup expression.  */
 744
 745 gimple
 746 gimple_build_wce (gimple_seq cleanup)
 747 {
 748   gimple p = gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR, 0);
 749   if (cleanup)
 750     gimple_wce_set_cleanup (p, cleanup);
 751
 752   return p;
 753 }
 754
 755
 756 /* Build a GIMPLE_RESX statement.
 757
 758    REGION is the region number from which this resx causes control flow to
 759    leave.  */
 760
 761 gimple
 762 gimple_build_resx (int region)
 763 {
 764   gimple p = gimple_alloc (GIMPLE_RESX, 0);
 765   gimple_resx_set_region (p, region);
 766   return p;
 767 }
 768
 769
 770 /* The helper for constructing a gimple switch statement.
 771    INDEX is the switch's index.
 772    NLABELS is the number of labels in the switch excluding the default.
 773    DEFAULT_LABEL is the default label for the switch statement.  */
 774
 775 static inline gimple
 776 gimple_build_switch_1 (unsigned nlabels, tree index, tree default_label)
 777 {
 778   /* nlabels + 1 default label + 1 index.  */
 779   gimple p = gimple_build_with_ops (GIMPLE_SWITCH, 0, nlabels + 1 + 1);
 780   gimple_switch_set_index (p, index);
 781   gimple_switch_set_default_label (p, default_label);
 782   return p;
 783 }
 784
 785
 786 /* Build a GIMPLE_SWITCH statement.
 787
 788    INDEX is the switch's index.
 789    NLABELS is the number of labels in the switch excluding the DEFAULT_LABEL.
 790    ... are the labels excluding the default.  */
 791
 792 gimple
 793 gimple_build_switch (unsigned nlabels, tree index, tree default_label, ...)
 794 {
 795   va_list al;
 796   unsigned i;
 797   gimple p;
 798
 799   p = gimple_build_switch_1 (nlabels, index, default_label);
 800
 801   /* Store the rest of the labels.  */
 802   va_start (al, default_label);
 803   for (i = 1; i <= nlabels; i++)
 804     gimple_switch_set_label (p, i, va_arg (al, tree));
 805   va_end (al);
 806
 807   return p;
 808 }
 809
 810
 811 /* Build a GIMPLE_SWITCH statement.
 812
 813    INDEX is the switch's index.
 814    DEFAULT_LABEL is the default label
 815    ARGS is a vector of labels excluding the default.  */
 816
 817 gimple
 818 gimple_build_switch_vec (tree index, tree default_label, VEC(tree, heap) *args)
 819 {
 820   unsigned i;
 821   unsigned nlabels = VEC_length (tree, args);
 822   gimple p = gimple_build_switch_1 (nlabels, index, default_label);
 823
 824   /*  Put labels in labels[1 - (nlabels + 1)].
 825      Default label is in labels[0].  */
 826   for (i = 1; i <= nlabels; i++)
 827     gimple_switch_set_label (p, i, VEC_index (tree, args, i - 1));
 828
 829   return p;
 830 }
 831
 832
 833 /* Build a GIMPLE_OMP_CRITICAL statement.
 834
 835    BODY is the sequence of statements for which only one thread can execute.
 836    NAME is optional identifier for this critical block.  */
 837
 838 gimple
 839 gimple_build_omp_critical (gimple_seq body, tree name)
 840 {
 841   gimple p = gimple_alloc (GIMPLE_OMP_CRITICAL, 0);
 842   gimple_omp_critical_set_name (p, name);
 843   if (body)
 844     gimple_omp_set_body (p, body);
 845
 846   return p;
 847 }
 848
 849 /* Build a GIMPLE_OMP_FOR statement.
 850
 851    BODY is sequence of statements inside the for loop.
 852    CLAUSES, are any of the OMP loop construct's clauses: private, firstprivate,
 853    lastprivate, reductions, ordered, schedule, and nowait.
 854    COLLAPSE is the collapse count.
 855    PRE_BODY is the sequence of statements that are loop invariant.  */
 856
 857 gimple
 858 gimple_build_omp_for (gimple_seq body, tree clauses, size_t collapse,
 859                       gimple_seq pre_body)
 860 {
 861   gimple p = gimple_alloc (GIMPLE_OMP_FOR, 0);
 862   if (body)
 863     gimple_omp_set_body (p, body);
 864   gimple_omp_for_set_clauses (p, clauses);
 865   p->gimple_omp_for.collapse = collapse;
 866   p->gimple_omp_for.iter = GGC_CNEWVEC (struct gimple_omp_for_iter, collapse);
 867   if (pre_body)
 868     gimple_omp_for_set_pre_body (p, pre_body);
 869
 870   return p;
 871 }
 872
 873
 874 /* Build a GIMPLE_OMP_PARALLEL statement.
 875
 876    BODY is sequence of statements which are executed in parallel.
 877    CLAUSES, are the OMP parallel construct's clauses.
 878    CHILD_FN is the function created for the parallel threads to execute.
 879    DATA_ARG are the shared data argument(s).  */
 880
 881 gimple
 882 gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
 883                            tree data_arg)
 884 {
 885   gimple p = gimple_alloc (GIMPLE_OMP_PARALLEL, 0);
 886   if (body)
 887     gimple_omp_set_body (p, body);
 888   gimple_omp_parallel_set_clauses (p, clauses);
 889   gimple_omp_parallel_set_child_fn (p, child_fn);
 890   gimple_omp_parallel_set_data_arg (p, data_arg);
 891
 892   return p;
 893 }
 894
 895
 896 /* Build a GIMPLE_OMP_TASK statement.
 897
 898    BODY is sequence of statements which are executed by the explicit task.
 899    CLAUSES, are the OMP parallel construct's clauses.
 900    CHILD_FN is the function created for the parallel threads to execute.
 901    DATA_ARG are the shared data argument(s).
 902    COPY_FN is the optional function for firstprivate initialization.
 903    ARG_SIZE and ARG_ALIGN are size and alignment of the data block.  */
 904
 905 gimple
 906 gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
 907                        tree data_arg, tree copy_fn, tree arg_size,
 908                        tree arg_align)
 909 {
 910   gimple p = gimple_alloc (GIMPLE_OMP_TASK, 0);
 911   if (body)
 912     gimple_omp_set_body (p, body);
 913   gimple_omp_task_set_clauses (p, clauses);
 914   gimple_omp_task_set_child_fn (p, child_fn);
 915   gimple_omp_task_set_data_arg (p, data_arg);
 916   gimple_omp_task_set_copy_fn (p, copy_fn);
 917   gimple_omp_task_set_arg_size (p, arg_size);
 918   gimple_omp_task_set_arg_align (p, arg_align);
 919
 920   return p;
 921 }
 922
 923
 924 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
 925
 926    BODY is the sequence of statements in the section.  */
 927
 928 gimple
 929 gimple_build_omp_section (gimple_seq body)
 930 {
 931   gimple p = gimple_alloc (GIMPLE_OMP_SECTION, 0);
 932   if (body)
 933     gimple_omp_set_body (p, body);
 934
 935   return p;
 936 }
 937
 938
 939 /* Build a GIMPLE_OMP_MASTER statement.
 940
 941    BODY is the sequence of statements to be executed by just the master.  */
 942
 943 gimple
 944 gimple_build_omp_master (gimple_seq body)
 945 {
 946   gimple p = gimple_alloc (GIMPLE_OMP_MASTER, 0);
 947   if (body)
 948     gimple_omp_set_body (p, body);
 949
 950   return p;
 951 }
 952
 953
 954 /* Build a GIMPLE_OMP_CONTINUE statement.
 955
 956    CONTROL_DEF is the definition of the control variable.
 957    CONTROL_USE is the use of the control variable.  */
 958
 959 gimple
 960 gimple_build_omp_continue (tree control_def, tree control_use)
 961 {
 962   gimple p = gimple_alloc (GIMPLE_OMP_CONTINUE, 0);
 963   gimple_omp_continue_set_control_def (p, control_def);
 964   gimple_omp_continue_set_control_use (p, control_use);
 965   return p;
 966 }
 967
 968 /* Build a GIMPLE_OMP_ORDERED statement.
 969
 970    BODY is the sequence of statements inside a loop that will executed in
 971    sequence.  */
 972
 973 gimple
 974 gimple_build_omp_ordered (gimple_seq body)
 975 {
 976   gimple p = gimple_alloc (GIMPLE_OMP_ORDERED, 0);
 977   if (body)
 978     gimple_omp_set_body (p, body);
 979
 980   return p;
 981 }
 982
 983
 984 /* Build a GIMPLE_OMP_RETURN statement.
 985    WAIT_P is true if this is a non-waiting return.  */
 986
 987 gimple
 988 gimple_build_omp_return (bool wait_p)
 989 {
 990   gimple p = gimple_alloc (GIMPLE_OMP_RETURN, 0);
 991   if (wait_p)
 992     gimple_omp_return_set_nowait (p);
 993
 994   return p;
 995 }
 996
 997
 998 /* Build a GIMPLE_OMP_SECTIONS statement.
 999
1000    BODY is a sequence of section statements.
1001    CLAUSES are any of the OMP sections contsruct's clauses: private,
1002    firstprivate, lastprivate, reduction, and nowait.  */
1003
1004 gimple
1005 gimple_build_omp_sections (gimple_seq body, tree clauses)
1006 {
1007   gimple p = gimple_alloc (GIMPLE_OMP_SECTIONS, 0);
1008   if (body)
1009     gimple_omp_set_body (p, body);
1010   gimple_omp_sections_set_clauses (p, clauses);
1011
1012   return p;
1013 }
1014
1015
1016 /* Build a GIMPLE_OMP_SECTIONS_SWITCH.  */
1017
1018 gimple
1019 gimple_build_omp_sections_switch (void)
1020 {
1021   return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH, 0);
1022 }
1023
1024
1025 /* Build a GIMPLE_OMP_SINGLE statement.
1026
1027    BODY is the sequence of statements that will be executed once.
1028    CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1029    copyprivate, nowait.  */
1030
1031 gimple
1032 gimple_build_omp_single (gimple_seq body, tree clauses)
1033 {
1034   gimple p = gimple_alloc (GIMPLE_OMP_SINGLE, 0);
1035   if (body)
1036     gimple_omp_set_body (p, body);
1037   gimple_omp_single_set_clauses (p, clauses);
1038
1039   return p;
1040 }
1041
1042
1043 /* Build a GIMPLE_CHANGE_DYNAMIC_TYPE statement.  TYPE is the new type
1044    for the location PTR.  */
1045
1046 gimple
1047 gimple_build_cdt (tree type, tree ptr)
1048 {
1049   gimple p = gimple_build_with_ops (GIMPLE_CHANGE_DYNAMIC_TYPE, 0, 2);
1050   gimple_cdt_set_new_type (p, type);
1051   gimple_cdt_set_location (p, ptr);
1052
1053   return p;
1054 }
1055
1056
1057 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement.  */
1058
1059 gimple
1060 gimple_build_omp_atomic_load (tree lhs, tree rhs)
1061 {
1062   gimple p = gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0);
1063   gimple_omp_atomic_load_set_lhs (p, lhs);
1064   gimple_omp_atomic_load_set_rhs (p, rhs);
1065   return p;
1066 }
1067
1068 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1069
1070    VAL is the value we are storing.  */
1071
1072 gimple
1073 gimple_build_omp_atomic_store (tree val)
1074 {
1075   gimple p = gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0);
1076   gimple_omp_atomic_store_set_val (p, val);
1077   return p;
1078 }
1079
1080 /* Build a GIMPLE_PREDICT statement.  PREDICT is one of the predictors from
1081    predict.def, OUTCOME is NOT_TAKEN or TAKEN.  */
1082
1083 gimple
1084 gimple_build_predict (enum br_predictor predictor, enum prediction outcome)
1085 {
1086   gimple p = gimple_alloc (GIMPLE_PREDICT, 0);
1087   /* Ensure all the predictors fit into the lower bits of the subcode.  */
1088   gcc_assert ((int) END_PREDICTORS <= GF_PREDICT_TAKEN);
1089   gimple_predict_set_predictor (p, predictor);
1090   gimple_predict_set_outcome (p, outcome);
1091   return p;
1092 }
1093
1094 /* Return which gimple structure is used by T.  The enums here are defined
1095    in gsstruct.def.  */
1096
1097 enum gimple_statement_structure_enum
1098 gimple_statement_structure (gimple gs)
1099 {
1100   return gss_for_code (gimple_code (gs));
1101 }
1102
1103 #if defined ENABLE_GIMPLE_CHECKING && (GCC_VERSION >= 2007)
1104 /* Complain of a gimple type mismatch and die.  */
1105
1106 void
1107 gimple_check_failed (const_gimple gs, const char *file, int line,
1108                      const char *function, enum gimple_code code,
1109                      enum tree_code subcode)
1110 {
1111   internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1112                   gimple_code_name[code],
1113                   tree_code_name[subcode],
1114                   gimple_code_name[gimple_code (gs)],
1115                   gs->gsbase.subcode > 0
1116                     ? tree_code_name[gs->gsbase.subcode]
1117                     : "",
1118                   function, trim_filename (file), line);
1119 }
1120
1121
1122 /* Similar to gimple_check_failed, except that instead of specifying a
1123    dozen codes, use the knowledge that they're all sequential.  */
1124
1125 void
1126 gimple_range_check_failed (const_gimple gs, const char *file, int line,
1127                            const char *function, enum gimple_code c1,
1128                            enum gimple_code c2)
1129 {
1130   char *buffer;
1131   unsigned length = 0;
1132   enum gimple_code c;
1133
1134   for (c = c1; c <= c2; ++c)
1135     length += 4 + strlen (gimple_code_name[c]);
1136
1137   length += strlen ("expected ");
1138   buffer = XALLOCAVAR (char, length);
1139   length = 0;
1140
1141   for (c = c1; c <= c2; ++c)
1142     {
1143       const char *prefix = length ? " or " : "expected ";
1144
1145       strcpy (buffer + length, prefix);
1146       length += strlen (prefix);
1147       strcpy (buffer + length, gimple_code_name[c]);
1148       length += strlen (gimple_code_name[c]);
1149     }
1150
1151   internal_error ("gimple check: %s, have %s in %s, at %s:%d",
1152                   buffer, gimple_code_name[gimple_code (gs)],
1153                   function, trim_filename (file), line);
1154 }
1155 #endif /* ENABLE_GIMPLE_CHECKING */
1156
1157
1158 /* Allocate a new GIMPLE sequence in GC memory and return it.  If
1159    there are free sequences in GIMPLE_SEQ_CACHE return one of those
1160    instead.  */
1161
1162 gimple_seq
1163 gimple_seq_alloc (void)
1164 {
1165   gimple_seq seq = gimple_seq_cache;
1166   if (seq)
1167     {
1168       gimple_seq_cache = gimple_seq_cache->next_free;
1169       gcc_assert (gimple_seq_cache != seq);
1170       memset (seq, 0, sizeof (*seq));
1171     }
1172   else
1173     {
1174       seq = (gimple_seq) ggc_alloc_cleared (sizeof (*seq));
1175 #ifdef GATHER_STATISTICS
1176       gimple_alloc_counts[(int) gimple_alloc_kind_seq]++;
1177       gimple_alloc_sizes[(int) gimple_alloc_kind_seq] += sizeof (*seq);
1178 #endif
1179     }
1180
1181   return seq;
1182 }
1183
1184 /* Return SEQ to the free pool of GIMPLE sequences.  */
1185
1186 void
1187 gimple_seq_free (gimple_seq seq)
1188 {
1189   if (seq == NULL)
1190     return;
1191
1192   gcc_assert (gimple_seq_first (seq) == NULL);
1193   gcc_assert (gimple_seq_last (seq) == NULL);
1194
1195   /* If this triggers, it's a sign that the same list is being freed
1196      twice.  */
1197   gcc_assert (seq != gimple_seq_cache || gimple_seq_cache == NULL);
1198
1199   /* Add SEQ to the pool of free sequences.  */
1200   seq->next_free = gimple_seq_cache;
1201   gimple_seq_cache = seq;
1202 }
1203
1204
1205 /* Link gimple statement GS to the end of the sequence *SEQ_P.  If
1206    *SEQ_P is NULL, a new sequence is allocated.  */
1207
1208 void
1209 gimple_seq_add_stmt (gimple_seq *seq_p, gimple gs)
1210 {
1211   gimple_stmt_iterator si;
1212
1213   if (gs == NULL)
1214     return;
1215
1216   if (*seq_p == NULL)
1217     *seq_p = gimple_seq_alloc ();
1218
1219   si = gsi_last (*seq_p);
1220   gsi_insert_after (&si, gs, GSI_NEW_STMT);
1221 }
1222
1223
1224 /* Append sequence SRC to the end of sequence *DST_P.  If *DST_P is
1225    NULL, a new sequence is allocated.  */
1226
1227 void
1228 gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
1229 {
1230   gimple_stmt_iterator si;
1231
1232   if (src == NULL)
1233     return;
1234
1235   if (*dst_p == NULL)
1236     *dst_p = gimple_seq_alloc ();
1237
1238   si = gsi_last (*dst_p);
1239   gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
1240 }
1241
1242
1243 /* Helper function of empty_body_p.  Return true if STMT is an empty
1244    statement.  */
1245
1246 static bool
1247 empty_stmt_p (gimple stmt)
1248 {
1249   if (gimple_code (stmt) == GIMPLE_NOP)
1250     return true;
1251   if (gimple_code (stmt) == GIMPLE_BIND)
1252     return empty_body_p (gimple_bind_body (stmt));
1253   return false;
1254 }
1255
1256
1257 /* Return true if BODY contains nothing but empty statements.  */
1258
1259 bool
1260 empty_body_p (gimple_seq body)
1261 {
1262   gimple_stmt_iterator i;
1263
1264
1265   if (gimple_seq_empty_p (body))
1266     return true;
1267   for (i = gsi_start (body); !gsi_end_p (i); gsi_next (&i))
1268     if (!empty_stmt_p (gsi_stmt (i)))
1269       return false;
1270
1271   return true;
1272 }
1273
1274
1275 /* Perform a deep copy of sequence SRC and return the result.  */
1276
1277 gimple_seq
1278 gimple_seq_copy (gimple_seq src)
1279 {
1280   gimple_stmt_iterator gsi;
1281   gimple_seq new_seq = gimple_seq_alloc ();
1282   gimple stmt;
1283
1284   for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
1285     {
1286       stmt = gimple_copy (gsi_stmt (gsi));
1287       gimple_seq_add_stmt (&new_seq, stmt);
1288     }
1289
1290   return new_seq;
1291 }
1292
1293
1294 /* Walk all the statements in the sequence SEQ calling walk_gimple_stmt
1295    on each one.  WI is as in walk_gimple_stmt.
1296
1297    If walk_gimple_stmt returns non-NULL, the walk is stopped, the
1298    value is stored in WI->CALLBACK_RESULT and the statement that
1299    produced the value is returned.
1300
1301    Otherwise, all the statements are walked and NULL returned.  */
1302
1303 gimple
1304 walk_gimple_seq (gimple_seq seq, walk_stmt_fn callback_stmt,
1305                  walk_tree_fn callback_op, struct walk_stmt_info *wi)
1306 {
1307   gimple_stmt_iterator gsi;
1308
1309   for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
1310     {
1311       tree ret = walk_gimple_stmt (&gsi, callback_stmt, callback_op, wi);
1312       if (ret)
1313         {
1314           /* If CALLBACK_STMT or CALLBACK_OP return a value, WI must exist
1315              to hold it.  */
1316           gcc_assert (wi);
1317           wi->callback_result = ret;
1318           return gsi_stmt (gsi);
1319         }
1320     }
1321
1322   if (wi)
1323     wi->callback_result = NULL_TREE;
1324
1325   return NULL;
1326 }
1327
1328
1329 /* Helper function for walk_gimple_stmt.  Walk operands of a GIMPLE_ASM.  */
1330
1331 static tree
1332 walk_gimple_asm (gimple stmt, walk_tree_fn callback_op,
1333                  struct walk_stmt_info *wi)
1334 {
1335   tree ret;
1336   unsigned noutputs;
1337   const char **oconstraints;
1338   unsigned i;
1339   const char *constraint;
1340   bool allows_mem, allows_reg, is_inout;
1341
1342   noutputs = gimple_asm_noutputs (stmt);
1343   oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
1344
1345   if (wi)
1346     wi->is_lhs = true;
1347
1348   for (i = 0; i < noutputs; i++)
1349     {
1350       tree op = gimple_asm_output_op (stmt, i);
1351       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
1352       oconstraints[i] = constraint;
1353       parse_output_constraint (&constraint, i, 0, 0, &allows_mem, &allows_reg,
1354                                &is_inout);
1355       if (wi)
1356         wi->val_only = (allows_reg || !allows_mem);
1357       ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
1358       if (ret)
1359         return ret;
1360     }
1361
1362   for (i = 0; i < gimple_asm_ninputs (stmt); i++)
1363     {
1364       tree op = gimple_asm_input_op (stmt, i);
1365       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
1366       parse_input_constraint (&constraint, 0, 0, noutputs, 0,
1367                               oconstraints, &allows_mem, &allows_reg);
1368       if (wi)
1369         wi->val_only = (allows_reg || !allows_mem);
1370
1371       /* Although input "m" is not really a LHS, we need a lvalue.  */
1372       if (wi)
1373         wi->is_lhs = !wi->val_only;
1374       ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
1375       if (ret)
1376         return ret;
1377     }
1378
1379   if (wi)
1380     {
1381       wi->is_lhs = false;
1382       wi->val_only = true;
1383     }
1384
1385   return NULL_TREE;
1386 }
1387
1388
1389 /* Helper function of WALK_GIMPLE_STMT.  Walk every tree operand in
1390    STMT.  CALLBACK_OP and WI are as in WALK_GIMPLE_STMT.
1391
1392    CALLBACK_OP is called on each operand of STMT via walk_tree.
1393    Additional parameters to walk_tree must be stored in WI.  For each operand
1394    OP, walk_tree is called as:
1395
1396         walk_tree (&OP, CALLBACK_OP, WI, WI->PSET)
1397
1398    If CALLBACK_OP returns non-NULL for an operand, the remaining
1399    operands are not scanned.
1400
1401    The return value is that returned by the last call to walk_tree, or
1402    NULL_TREE if no CALLBACK_OP is specified.  */
1403
1404 inline tree
1405 walk_gimple_op (gimple stmt, walk_tree_fn callback_op,
1406                 struct walk_stmt_info *wi)
1407 {
1408   struct pointer_set_t *pset = (wi) ? wi->pset : NULL;
1409   unsigned i;
1410   tree ret = NULL_TREE;
1411
1412   switch (gimple_code (stmt))
1413     {
1414     case GIMPLE_ASSIGN:
1415       /* Walk the RHS operands.  A formal temporary LHS may use a
1416          COMPONENT_REF RHS.  */
1417       if (wi)
1418         wi->val_only = !is_gimple_formal_tmp_var (gimple_assign_lhs (stmt));
1419
1420       for (i = 1; i < gimple_num_ops (stmt); i++)
1421         {
1422           ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi,
1423                            pset);
1424           if (ret)
1425             return ret;
1426         }
1427
1428       /* Walk the LHS.  If the RHS is appropriate for a memory, we
1429          may use a COMPONENT_REF on the LHS.  */
1430       if (wi)
1431         {
1432           /* If the RHS has more than 1 operand, it is not appropriate
1433              for the memory.  */
1434           wi->val_only = !is_gimple_mem_rhs (gimple_assign_rhs1 (stmt))
1435                          || !gimple_assign_single_p (stmt);
1436           wi->is_lhs = true;
1437         }
1438
1439       ret = walk_tree (gimple_op_ptr (stmt, 0), callback_op, wi, pset);
1440       if (ret)
1441         return ret;
1442
1443       if (wi)
1444         {
1445           wi->val_only = true;
1446           wi->is_lhs = false;
1447         }
1448       break;
1449
1450     case GIMPLE_CALL:
1451       if (wi)
1452         wi->is_lhs = false;
1453
1454       ret = walk_tree (gimple_call_chain_ptr (stmt), callback_op, wi, pset);
1455       if (ret)
1456         return ret;
1457
1458       ret = walk_tree (gimple_call_fn_ptr (stmt), callback_op, wi, pset);
1459       if (ret)
1460         return ret;
1461
1462       for (i = 0; i < gimple_call_num_args (stmt); i++)
1463         {
1464           ret = walk_tree (gimple_call_arg_ptr (stmt, i), callback_op, wi,
1465                            pset);
1466           if (ret)
1467             return ret;
1468         }
1469
1470       if (wi)
1471         wi->is_lhs = true;
1472
1473       ret = walk_tree (gimple_call_lhs_ptr (stmt), callback_op, wi, pset);
1474       if (ret)
1475         return ret;
1476
1477       if (wi)
1478         wi->is_lhs = false;
1479       break;
1480
1481     case GIMPLE_CATCH:
1482       ret = walk_tree (gimple_catch_types_ptr (stmt), callback_op, wi,
1483                        pset);
1484       if (ret)
1485         return ret;
1486       break;
1487
1488     case GIMPLE_EH_FILTER:
1489       ret = walk_tree (gimple_eh_filter_types_ptr (stmt), callback_op, wi,
1490                        pset);
1491       if (ret)
1492         return ret;
1493       break;
1494
1495     case GIMPLE_CHANGE_DYNAMIC_TYPE:
1496       ret = walk_tree (gimple_cdt_location_ptr (stmt), callback_op, wi, pset);
1497       if (ret)
1498         return ret;
1499
1500       ret = walk_tree (gimple_cdt_new_type_ptr (stmt), callback_op, wi, pset);
1501       if (ret)
1502         return ret;
1503       break;
1504
1505     case GIMPLE_ASM:
1506       ret = walk_gimple_asm (stmt, callback_op, wi);
1507       if (ret)
1508         return ret;
1509       break;
1510
1511     case GIMPLE_OMP_CONTINUE:
1512       ret = walk_tree (gimple_omp_continue_control_def_ptr (stmt),
1513                        callback_op, wi, pset);
1514       if (ret)
1515         return ret;
1516
1517       ret = walk_tree (gimple_omp_continue_control_use_ptr (stmt),
1518                        callback_op, wi, pset);
1519       if (ret)
1520         return ret;
1521       break;
1522
1523     case GIMPLE_OMP_CRITICAL:
1524       ret = walk_tree (gimple_omp_critical_name_ptr (stmt), callback_op, wi,
1525                        pset);
1526       if (ret)
1527         return ret;
1528       break;
1529
1530     case GIMPLE_OMP_FOR:
1531       ret = walk_tree (gimple_omp_for_clauses_ptr (stmt), callback_op, wi,
1532                        pset);
1533       if (ret)
1534         return ret;
1535       for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
1536         {
1537           ret = walk_tree (gimple_omp_for_index_ptr (stmt, i), callback_op,
1538                            wi, pset);
1539           if (ret)
1540             return ret;
1541           ret = walk_tree (gimple_omp_for_initial_ptr (stmt, i), callback_op,
1542                            wi, pset);
1543           if (ret)
1544             return ret;
1545           ret = walk_tree (gimple_omp_for_final_ptr (stmt, i), callback_op,
1546                            wi, pset);
1547           if (ret)
1548             return ret;
1549           ret = walk_tree (gimple_omp_for_incr_ptr (stmt, i), callback_op,
1550                            wi, pset);
1551         }
1552       if (ret)
1553         return ret;
1554       break;
1555
1556     case GIMPLE_OMP_PARALLEL:
1557       ret = walk_tree (gimple_omp_parallel_clauses_ptr (stmt), callback_op,
1558                        wi, pset);
1559       if (ret)
1560         return ret;
1561       ret = walk_tree (gimple_omp_parallel_child_fn_ptr (stmt), callback_op,
1562                        wi, pset);
1563       if (ret)
1564         return ret;
1565       ret = walk_tree (gimple_omp_parallel_data_arg_ptr (stmt), callback_op,
1566                        wi, pset);
1567       if (ret)
1568         return ret;
1569       break;
1570
1571     case GIMPLE_OMP_TASK:
1572       ret = walk_tree (gimple_omp_task_clauses_ptr (stmt), callback_op,
1573                        wi, pset);
1574       if (ret)
1575         return ret;
1576       ret = walk_tree (gimple_omp_task_child_fn_ptr (stmt), callback_op,
1577                        wi, pset);
1578       if (ret)
1579         return ret;
1580       ret = walk_tree (gimple_omp_task_data_arg_ptr (stmt), callback_op,
1581                        wi, pset);
1582       if (ret)
1583         return ret;
1584       ret = walk_tree (gimple_omp_task_copy_fn_ptr (stmt), callback_op,
1585                        wi, pset);
1586       if (ret)
1587         return ret;
1588       ret = walk_tree (gimple_omp_task_arg_size_ptr (stmt), callback_op,
1589                        wi, pset);
1590       if (ret)
1591         return ret;
1592       ret = walk_tree (gimple_omp_task_arg_align_ptr (stmt), callback_op,
1593                        wi, pset);
1594       if (ret)
1595         return ret;
1596       break;
1597
1598     case GIMPLE_OMP_SECTIONS:
1599       ret = walk_tree (gimple_omp_sections_clauses_ptr (stmt), callback_op,
1600                        wi, pset);
1601       if (ret)
1602         return ret;
1603
1604       ret = walk_tree (gimple_omp_sections_control_ptr (stmt), callback_op,
1605                        wi, pset);
1606       if (ret)
1607         return ret;
1608
1609       break;
1610
1611     case GIMPLE_OMP_SINGLE:
1612       ret = walk_tree (gimple_omp_single_clauses_ptr (stmt), callback_op, wi,
1613                        pset);
1614       if (ret)
1615         return ret;
1616       break;
1617
1618     case GIMPLE_OMP_ATOMIC_LOAD:
1619       ret = walk_tree (gimple_omp_atomic_load_lhs_ptr (stmt), callback_op, wi,
1620                        pset);
1621       if (ret)
1622         return ret;
1623
1624       ret = walk_tree (gimple_omp_atomic_load_rhs_ptr (stmt), callback_op, wi,
1625                        pset);
1626       if (ret)
1627         return ret;
1628       break;
1629
1630     case GIMPLE_OMP_ATOMIC_STORE:
1631       ret = walk_tree (gimple_omp_atomic_store_val_ptr (stmt), callback_op,
1632                        wi, pset);
1633       if (ret)
1634         return ret;
1635       break;
1636
1637       /* Tuples that do not have operands.  */
1638     case GIMPLE_NOP:
1639     case GIMPLE_RESX:
1640     case GIMPLE_OMP_RETURN:
1641     case GIMPLE_PREDICT:
1642       break;
1643
1644     default:
1645       {
1646         enum gimple_statement_structure_enum gss;
1647         gss = gimple_statement_structure (stmt);
1648         if (gss == GSS_WITH_OPS || gss == GSS_WITH_MEM_OPS)
1649           for (i = 0; i < gimple_num_ops (stmt); i++)
1650             {
1651               ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi, pset);
1652               if (ret)
1653                 return ret;
1654             }
1655       }
1656       break;
1657     }
1658
1659   return NULL_TREE;
1660 }
1661
1662
1663 /* Walk the current statement in GSI (optionally using traversal state
1664    stored in WI).  If WI is NULL, no state is kept during traversal.
1665    The callback CALLBACK_STMT is called.  If CALLBACK_STMT indicates
1666    that it has handled all the operands of the statement, its return
1667    value is returned.  Otherwise, the return value from CALLBACK_STMT
1668    is discarded and its operands are scanned.
1669
1670    If CALLBACK_STMT is NULL or it didn't handle the operands,
1671    CALLBACK_OP is called on each operand of the statement via
1672    walk_gimple_op.  If walk_gimple_op returns non-NULL for any
1673    operand, the remaining operands are not scanned.  In this case, the
1674    return value from CALLBACK_OP is returned.
1675
1676    In any other case, NULL_TREE is returned.  */
1677
1678 tree
1679 walk_gimple_stmt (gimple_stmt_iterator *gsi, walk_stmt_fn callback_stmt,
1680                   walk_tree_fn callback_op, struct walk_stmt_info *wi)
1681 {
1682   gimple ret;
1683   tree tree_ret;
1684   gimple stmt = gsi_stmt (*gsi);
1685
1686   if (wi)
1687     wi->gsi = *gsi;
1688
1689   if (wi && wi->want_locations && gimple_has_location (stmt))
1690     input_location = gimple_location (stmt);
1691
1692   ret = NULL;
1693
1694   /* Invoke the statement callback.  Return if the callback handled
1695      all of STMT operands by itself.  */
1696   if (callback_stmt)
1697     {
1698       bool handled_ops = false;
1699       tree_ret = callback_stmt (gsi, &handled_ops, wi);
1700       if (handled_ops)
1701         return tree_ret;
1702
1703       /* If CALLBACK_STMT did not handle operands, it should not have
1704          a value to return.  */
1705       gcc_assert (tree_ret == NULL);
1706
1707       /* Re-read stmt in case the callback changed it.  */
1708       stmt = gsi_stmt (*gsi);
1709     }
1710
1711   /* If CALLBACK_OP is defined, invoke it on every operand of STMT.  */
1712   if (callback_op)
1713     {
1714       tree_ret = walk_gimple_op (stmt, callback_op, wi);
1715       if (tree_ret)
1716         return tree_ret;
1717     }
1718
1719   /* If STMT can have statements inside (e.g. GIMPLE_BIND), walk them.  */
1720   switch (gimple_code (stmt))
1721     {
1722     case GIMPLE_BIND:
1723       ret = walk_gimple_seq (gimple_bind_body (stmt), callback_stmt,
1724                              callback_op, wi);
1725       if (ret)
1726         return wi->callback_result;
1727       break;
1728
1729     case GIMPLE_CATCH:
1730       ret = walk_gimple_seq (gimple_catch_handler (stmt), callback_stmt,
1731                              callback_op, wi);
1732       if (ret)
1733         return wi->callback_result;
1734       break;
1735
1736     case GIMPLE_EH_FILTER:
1737       ret = walk_gimple_seq (gimple_eh_filter_failure (stmt), callback_stmt,
1738                              callback_op, wi);
1739       if (ret)
1740         return wi->callback_result;
1741       break;
1742
1743     case GIMPLE_TRY:
1744       ret = walk_gimple_seq (gimple_try_eval (stmt), callback_stmt, callback_op,
1745                              wi);
1746       if (ret)
1747         return wi->callback_result;
1748
1749       ret = walk_gimple_seq (gimple_try_cleanup (stmt), callback_stmt,
1750                              callback_op, wi);
1751       if (ret)
1752         return wi->callback_result;
1753       break;
1754
1755     case GIMPLE_OMP_FOR:
1756       ret = walk_gimple_seq (gimple_omp_for_pre_body (stmt), callback_stmt,
1757                              callback_op, wi);
1758       if (ret)
1759         return wi->callback_result;
1760
1761       /* FALL THROUGH.  */
1762     case GIMPLE_OMP_CRITICAL:
1763     case GIMPLE_OMP_MASTER:
1764     case GIMPLE_OMP_ORDERED:
1765     case GIMPLE_OMP_SECTION:
1766     case GIMPLE_OMP_PARALLEL:
1767     case GIMPLE_OMP_TASK:
1768     case GIMPLE_OMP_SECTIONS:
1769     case GIMPLE_OMP_SINGLE:
1770       ret = walk_gimple_seq (gimple_omp_body (stmt), callback_stmt, callback_op,
1771                              wi);
1772       if (ret)
1773         return wi->callback_result;
1774       break;
1775
1776     case GIMPLE_WITH_CLEANUP_EXPR:
1777       ret = walk_gimple_seq (gimple_wce_cleanup (stmt), callback_stmt,
1778                              callback_op, wi);
1779       if (ret)
1780         return wi->callback_result;
1781       break;
1782
1783     default:
1784       gcc_assert (!gimple_has_substatements (stmt));
1785       break;
1786     }
1787
1788   return NULL;
1789 }
1790
1791
1792 /* Set sequence SEQ to be the GIMPLE body for function FN.  */
1793
1794 void
1795 gimple_set_body (tree fndecl, gimple_seq seq)
1796 {
1797   struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
1798   if (fn == NULL)
1799     {
1800       /* If FNDECL still does not have a function structure associated
1801          with it, then it does not make sense for it to receive a
1802          GIMPLE body.  */
1803       gcc_assert (seq == NULL);
1804     }
1805   else
1806     fn->gimple_body = seq;
1807 }
1808
1809
1810 /* Return the body of GIMPLE statements for function FN.  */
1811
1812 gimple_seq
1813 gimple_body (tree fndecl)
1814 {
1815   struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
1816   return fn ? fn->gimple_body : NULL;
1817 }
1818
1819 /* Return true when FNDECL has Gimple body either in unlowered
1820    or CFG form.  */
1821 bool
1822 gimple_has_body_p (tree fndecl)
1823 {
1824   struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
1825   return (gimple_body (fndecl) || (fn && fn->cfg));
1826 }
1827
1828 /* Detect flags from a GIMPLE_CALL.  This is just like
1829    call_expr_flags, but for gimple tuples.  */
1830
1831 int
1832 gimple_call_flags (const_gimple stmt)
1833 {
1834   int flags;
1835   tree decl = gimple_call_fndecl (stmt);
1836   tree t;
1837
1838   if (decl)
1839     flags = flags_from_decl_or_type (decl);
1840   else
1841     {
1842       t = TREE_TYPE (gimple_call_fn (stmt));
1843       if (t && TREE_CODE (t) == POINTER_TYPE)
1844         flags = flags_from_decl_or_type (TREE_TYPE (t));
1845       else
1846         flags = 0;
1847     }
1848
1849   return flags;
1850 }
1851
1852
1853 /* Return true if GS is a copy assignment.  */
1854
1855 bool
1856 gimple_assign_copy_p (gimple gs)
1857 {
1858   return gimple_code (gs) == GIMPLE_ASSIGN
1859          && get_gimple_rhs_class (gimple_assign_rhs_code (gs))
1860             == GIMPLE_SINGLE_RHS
1861          && is_gimple_val (gimple_op (gs, 1));
1862 }
1863
1864
1865 /* Return true if GS is a SSA_NAME copy assignment.  */
1866
1867 bool
1868 gimple_assign_ssa_name_copy_p (gimple gs)
1869 {
1870   return (gimple_code (gs) == GIMPLE_ASSIGN
1871           && (get_gimple_rhs_class (gimple_assign_rhs_code (gs))
1872               == GIMPLE_SINGLE_RHS)
1873           && TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
1874           && TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
1875 }
1876
1877
1878 /* Return true if GS is an assignment with a singleton RHS, i.e.,
1879    there is no operator associated with the assignment itself.
1880    Unlike gimple_assign_copy_p, this predicate returns true for
1881    any RHS operand, including those that perform an operation
1882    and do not have the semantics of a copy, such as COND_EXPR.  */
1883
1884 bool
1885 gimple_assign_single_p (gimple gs)
1886 {
1887   return (gimple_code (gs) == GIMPLE_ASSIGN
1888           && get_gimple_rhs_class (gimple_assign_rhs_code (gs))
1889              == GIMPLE_SINGLE_RHS);
1890 }
1891
1892 /* Return true if GS is an assignment with a unary RHS, but the
1893    operator has no effect on the assigned value.  The logic is adapted
1894    from STRIP_NOPS.  This predicate is intended to be used in tuplifying
1895    instances in which STRIP_NOPS was previously applied to the RHS of
1896    an assignment.
1897
1898    NOTE: In the use cases that led to the creation of this function
1899    and of gimple_assign_single_p, it is typical to test for either
1900    condition and to proceed in the same manner.  In each case, the
1901    assigned value is represented by the single RHS operand of the
1902    assignment.  I suspect there may be cases where gimple_assign_copy_p,
1903    gimple_assign_single_p, or equivalent logic is used where a similar
1904    treatment of unary NOPs is appropriate.  */
1905
1906 bool
1907 gimple_assign_unary_nop_p (gimple gs)
1908 {
1909   return (gimple_code (gs) == GIMPLE_ASSIGN
1910           && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
1911               || gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
1912           && gimple_assign_rhs1 (gs) != error_mark_node
1913           && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))
1914               == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs)))));
1915 }
1916
1917 /* Set BB to be the basic block holding G.  */
1918
1919 void
1920 gimple_set_bb (gimple stmt, basic_block bb)
1921 {
1922   stmt->gsbase.bb = bb;
1923
1924   /* If the statement is a label, add the label to block-to-labels map
1925      so that we can speed up edge creation for GIMPLE_GOTOs.  */
1926   if (cfun->cfg && gimple_code (stmt) == GIMPLE_LABEL)
1927     {
1928       tree t;
1929       int uid;
1930
1931       t = gimple_label_label (stmt);
1932       uid = LABEL_DECL_UID (t);
1933       if (uid == -1)
1934         {
1935           unsigned old_len = VEC_length (basic_block, label_to_block_map);
1936           LABEL_DECL_UID (t) = uid = cfun->cfg->last_label_uid++;
1937           if (old_len <= (unsigned) uid)
1938             {
1939               unsigned new_len = 3 * uid / 2;
1940
1941               VEC_safe_grow_cleared (basic_block, gc, label_to_block_map,
1942                                      new_len);
1943             }
1944         }
1945
1946       VEC_replace (basic_block, label_to_block_map, uid, bb);
1947     }
1948 }
1949
1950
1951 /* Fold the expression computed by STMT.  If the expression can be
1952    folded, return the folded result, otherwise return NULL.  STMT is
1953    not modified.  */
1954
1955 tree
1956 gimple_fold (const_gimple stmt)
1957 {
1958   switch (gimple_code (stmt))
1959     {
1960     case GIMPLE_COND:
1961       return fold_binary (gimple_cond_code (stmt),
1962                           boolean_type_node,
1963                           gimple_cond_lhs (stmt),
1964                           gimple_cond_rhs (stmt));
1965
1966     case GIMPLE_ASSIGN:
1967       switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
1968         {
1969         case GIMPLE_UNARY_RHS:
1970           return fold_unary (gimple_assign_rhs_code (stmt),
1971                              TREE_TYPE (gimple_assign_lhs (stmt)),
1972                              gimple_assign_rhs1 (stmt));
1973         case GIMPLE_BINARY_RHS:
1974           return fold_binary (gimple_assign_rhs_code (stmt),
1975                               TREE_TYPE (gimple_assign_lhs (stmt)),
1976                               gimple_assign_rhs1 (stmt),
1977                               gimple_assign_rhs2 (stmt));
1978         case GIMPLE_SINGLE_RHS:
1979           return fold (gimple_assign_rhs1 (stmt));
1980         default:;
1981         }
1982       break;
1983
1984     case GIMPLE_SWITCH:
1985       return gimple_switch_index (stmt);
1986
1987     case GIMPLE_CALL:
1988       return NULL_TREE;
1989
1990     default:
1991       break;
1992     }
1993
1994   gcc_unreachable ();
1995 }
1996
1997
1998 /* Modify the RHS of the assignment pointed-to by GSI using the
1999    operands in the expression tree EXPR.
2000
2001    NOTE: The statement pointed-to by GSI may be reallocated if it
2002    did not have enough operand slots.
2003
2004    This function is useful to convert an existing tree expression into
2005    the flat representation used for the RHS of a GIMPLE assignment.
2006    It will reallocate memory as needed to expand or shrink the number
2007    of operand slots needed to represent EXPR.
2008
2009    NOTE: If you find yourself building a tree and then calling this
2010    function, you are most certainly doing it the slow way.  It is much
2011    better to build a new assignment or to use the function
2012    gimple_assign_set_rhs_with_ops, which does not require an
2013    expression tree to be built.  */
2014
2015 void
2016 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
2017 {
2018   enum tree_code subcode;
2019   tree op1, op2;
2020
2021   extract_ops_from_tree (expr, &subcode, &op1, &op2);
2022   gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2);
2023 }
2024
2025
2026 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
2027    operands OP1 and OP2.
2028
2029    NOTE: The statement pointed-to by GSI may be reallocated if it
2030    did not have enough operand slots.  */
2031
2032 void
2033 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
2034                                 tree op1, tree op2)
2035 {
2036   unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
2037   gimple stmt = gsi_stmt (*gsi);
2038
2039   /* If the new CODE needs more operands, allocate a new statement.  */
2040   if (gimple_num_ops (stmt) < new_rhs_ops + 1)
2041     {
2042       tree lhs = gimple_assign_lhs (stmt);
2043       gimple new_stmt = gimple_alloc (gimple_code (stmt), new_rhs_ops + 1);
2044       memcpy (new_stmt, stmt, gimple_size (gimple_code (stmt)));
2045       gsi_replace (gsi, new_stmt, true);
2046       stmt = new_stmt;
2047
2048       /* The LHS needs to be reset as this also changes the SSA name
2049          on the LHS.  */
2050       gimple_assign_set_lhs (stmt, lhs);
2051     }
2052
2053   gimple_set_num_ops (stmt, new_rhs_ops + 1);
2054   gimple_set_subcode (stmt, code);
2055   gimple_assign_set_rhs1 (stmt, op1);
2056   if (new_rhs_ops > 1)
2057     gimple_assign_set_rhs2 (stmt, op2);
2058 }
2059
2060
2061 /* Return the LHS of a statement that performs an assignment,
2062    either a GIMPLE_ASSIGN or a GIMPLE_CALL.  Returns NULL_TREE
2063    for a call to a function that returns no value, or for a
2064    statement other than an assignment or a call.  */
2065
2066 tree
2067 gimple_get_lhs (const_gimple stmt)
2068 {
2069   enum gimple_code code = gimple_code (stmt);
2070
2071   if (code == GIMPLE_ASSIGN)
2072     return gimple_assign_lhs (stmt);
2073   else if (code == GIMPLE_CALL)
2074     return gimple_call_lhs (stmt);
2075   else
2076     return NULL_TREE;
2077 }
2078
2079
2080 /* Set the LHS of a statement that performs an assignment,
2081    either a GIMPLE_ASSIGN or a GIMPLE_CALL.  */
2082
2083 void
2084 gimple_set_lhs (gimple stmt, tree lhs)
2085 {
2086   enum gimple_code code = gimple_code (stmt);
2087
2088   if (code == GIMPLE_ASSIGN)
2089     gimple_assign_set_lhs (stmt, lhs);
2090   else if (code == GIMPLE_CALL)
2091     gimple_call_set_lhs (stmt, lhs);
2092   else
2093     gcc_unreachable();
2094 }
2095
2096
2097 /* Return a deep copy of statement STMT.  All the operands from STMT
2098    are reallocated and copied using unshare_expr.  The DEF, USE, VDEF
2099    and VUSE operand arrays are set to empty in the new copy.  */
2100
2101 gimple
2102 gimple_copy (gimple stmt)
2103 {
2104   enum gimple_code code = gimple_code (stmt);
2105   unsigned num_ops = gimple_num_ops (stmt);
2106   gimple copy = gimple_alloc (code, num_ops);
2107   unsigned i;
2108
2109   /* Shallow copy all the fields from STMT.  */
2110   memcpy (copy, stmt, gimple_size (code));
2111
2112   /* If STMT has sub-statements, deep-copy them as well.  */
2113   if (gimple_has_substatements (stmt))
2114     {
2115       gimple_seq new_seq;
2116       tree t;
2117
2118       switch (gimple_code (stmt))
2119         {
2120         case GIMPLE_BIND:
2121           new_seq = gimple_seq_copy (gimple_bind_body (stmt));
2122           gimple_bind_set_body (copy, new_seq);
2123           gimple_bind_set_vars (copy, unshare_expr (gimple_bind_vars (stmt)));
2124           gimple_bind_set_block (copy, gimple_bind_block (stmt));
2125           break;
2126
2127         case GIMPLE_CATCH:
2128           new_seq = gimple_seq_copy (gimple_catch_handler (stmt));
2129           gimple_catch_set_handler (copy, new_seq);
2130           t = unshare_expr (gimple_catch_types (stmt));
2131           gimple_catch_set_types (copy, t);
2132           break;
2133
2134         case GIMPLE_EH_FILTER:
2135           new_seq = gimple_seq_copy (gimple_eh_filter_failure (stmt));
2136           gimple_eh_filter_set_failure (copy, new_seq);
2137           t = unshare_expr (gimple_eh_filter_types (stmt));
2138           gimple_eh_filter_set_types (copy, t);
2139           break;
2140
2141         case GIMPLE_TRY:
2142           new_seq = gimple_seq_copy (gimple_try_eval (stmt));
2143           gimple_try_set_eval (copy, new_seq);
2144           new_seq = gimple_seq_copy (gimple_try_cleanup (stmt));
2145           gimple_try_set_cleanup (copy, new_seq);
2146           break;
2147
2148         case GIMPLE_OMP_FOR:
2149           new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt));
2150           gimple_omp_for_set_pre_body (copy, new_seq);
2151           t = unshare_expr (gimple_omp_for_clauses (stmt));
2152           gimple_omp_for_set_clauses (copy, t);
2153           copy->gimple_omp_for.iter
2154             = GGC_NEWVEC (struct gimple_omp_for_iter,
2155                           gimple_omp_for_collapse (stmt));
2156           for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
2157             {
2158               gimple_omp_for_set_cond (copy, i,
2159                                        gimple_omp_for_cond (stmt, i));
2160               gimple_omp_for_set_index (copy, i,
2161                                         gimple_omp_for_index (stmt, i));
2162               t = unshare_expr (gimple_omp_for_initial (stmt, i));
2163               gimple_omp_for_set_initial (copy, i, t);
2164               t = unshare_expr (gimple_omp_for_final (stmt, i));
2165               gimple_omp_for_set_final (copy, i, t);
2166               t = unshare_expr (gimple_omp_for_incr (stmt, i));
2167               gimple_omp_for_set_incr (copy, i, t);
2168             }
2169           goto copy_omp_body;
2170
2171         case GIMPLE_OMP_PARALLEL:
2172           t = unshare_expr (gimple_omp_parallel_clauses (stmt));
2173           gimple_omp_parallel_set_clauses (copy, t);
2174           t = unshare_expr (gimple_omp_parallel_child_fn (stmt));
2175           gimple_omp_parallel_set_child_fn (copy, t);
2176           t = unshare_expr (gimple_omp_parallel_data_arg (stmt));
2177           gimple_omp_parallel_set_data_arg (copy, t);
2178           goto copy_omp_body;
2179
2180         case GIMPLE_OMP_TASK:
2181           t = unshare_expr (gimple_omp_task_clauses (stmt));
2182           gimple_omp_task_set_clauses (copy, t);
2183           t = unshare_expr (gimple_omp_task_child_fn (stmt));
2184           gimple_omp_task_set_child_fn (copy, t);
2185           t = unshare_expr (gimple_omp_task_data_arg (stmt));
2186           gimple_omp_task_set_data_arg (copy, t);
2187           t = unshare_expr (gimple_omp_task_copy_fn (stmt));
2188           gimple_omp_task_set_copy_fn (copy, t);
2189           t = unshare_expr (gimple_omp_task_arg_size (stmt));
2190           gimple_omp_task_set_arg_size (copy, t);
2191           t = unshare_expr (gimple_omp_task_arg_align (stmt));
2192           gimple_omp_task_set_arg_align (copy, t);
2193           goto copy_omp_body;
2194
2195         case GIMPLE_OMP_CRITICAL:
2196           t = unshare_expr (gimple_omp_critical_name (stmt));
2197           gimple_omp_critical_set_name (copy, t);
2198           goto copy_omp_body;
2199
2200         case GIMPLE_OMP_SECTIONS:
2201           t = unshare_expr (gimple_omp_sections_clauses (stmt));
2202           gimple_omp_sections_set_clauses (copy, t);
2203           t = unshare_expr (gimple_omp_sections_control (stmt));
2204           gimple_omp_sections_set_control (copy, t);
2205           /* FALLTHRU  */
2206
2207         case GIMPLE_OMP_SINGLE:
2208         case GIMPLE_OMP_SECTION:
2209         case GIMPLE_OMP_MASTER:
2210         case GIMPLE_OMP_ORDERED:
2211         copy_omp_body:
2212           new_seq = gimple_seq_copy (gimple_omp_body (stmt));
2213           gimple_omp_set_body (copy, new_seq);
2214           break;
2215
2216         case GIMPLE_WITH_CLEANUP_EXPR:
2217           new_seq = gimple_seq_copy (gimple_wce_cleanup (stmt));
2218           gimple_wce_set_cleanup (copy, new_seq);
2219           break;
2220
2221         default:
2222           gcc_unreachable ();
2223         }
2224     }
2225
2226   /* Make copy of operands.  */
2227   if (num_ops > 0)
2228     {
2229       for (i = 0; i < num_ops; i++)
2230         gimple_set_op (copy, i, unshare_expr (gimple_op (stmt, i)));
2231
2232       /* Clear out SSA operand vectors on COPY.  Note that we cannot
2233          call the API functions for setting addresses_taken, stores
2234          and loads.  These functions free the previous values, and we
2235          cannot do that on COPY as it will affect the original
2236          statement.  */
2237       if (gimple_has_ops (stmt))
2238         {
2239           gimple_set_def_ops (copy, NULL);
2240           gimple_set_use_ops (copy, NULL);
2241           copy->gsops.opbase.addresses_taken = NULL;
2242         }
2243
2244       if (gimple_has_mem_ops (stmt))
2245         {
2246           gimple_set_vdef_ops (copy, NULL);
2247           gimple_set_vuse_ops (copy, NULL);
2248           copy->gsmem.membase.stores = NULL;
2249           copy->gsmem.membase.loads = NULL;
2250         }
2251
2252       update_stmt (copy);
2253     }
2254
2255   return copy;
2256 }
2257
2258
2259 /* Set the MODIFIED flag to MODIFIEDP, iff the gimple statement G has
2260    a MODIFIED field.  */
2261
2262 void
2263 gimple_set_modified (gimple s, bool modifiedp)
2264 {
2265   if (gimple_has_ops (s))
2266     {
2267       s->gsbase.modified = (unsigned) modifiedp;
2268
2269       if (modifiedp
2270           && cfun->gimple_df
2271           && is_gimple_call (s)
2272           && gimple_call_noreturn_p (s))
2273         VEC_safe_push (gimple, gc, MODIFIED_NORETURN_CALLS (cfun), s);
2274     }
2275 }
2276
2277
2278 /* Return true if statement S has side-effects.  We consider a
2279    statement to have side effects if:
2280
2281    - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
2282    - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS.  */
2283
2284 bool
2285 gimple_has_side_effects (const_gimple s)
2286 {
2287   unsigned i;
2288
2289   /* We don't have to scan the arguments to check for
2290      volatile arguments, though, at present, we still
2291      do a scan to check for TREE_SIDE_EFFECTS.  */
2292   if (gimple_has_volatile_ops (s))
2293     return true;
2294
2295   if (is_gimple_call (s))
2296     {
2297       unsigned nargs = gimple_call_num_args (s);
2298
2299       if (!(gimple_call_flags (s) & (ECF_CONST | ECF_PURE)))
2300         return true;
2301       else if (gimple_call_flags (s) & ECF_LOOPING_CONST_OR_PURE)
2302         /* An infinite loop is considered a side effect.  */
2303         return true;
2304
2305       if (gimple_call_lhs (s)
2306           && TREE_SIDE_EFFECTS (gimple_call_lhs (s)))
2307         {
2308           gcc_assert (gimple_has_volatile_ops (s));
2309           return true;
2310         }
2311
2312       if (TREE_SIDE_EFFECTS (gimple_call_fn (s)))
2313         return true;
2314
2315       for (i = 0; i < nargs; i++)
2316         if (TREE_SIDE_EFFECTS (gimple_call_arg (s, i)))
2317           {
2318             gcc_assert (gimple_has_volatile_ops (s));
2319             return true;
2320           }
2321
2322       return false;
2323     }
2324   else
2325     {
2326       for (i = 0; i < gimple_num_ops (s); i++)
2327         if (TREE_SIDE_EFFECTS (gimple_op (s, i)))
2328           {
2329             gcc_assert (gimple_has_volatile_ops (s));
2330             return true;
2331           }
2332     }
2333
2334   return false;
2335 }
2336
2337 /* Return true if the RHS of statement S has side effects.
2338    We may use it to determine if it is admissable to replace
2339    an assignment or call with a copy of a previously-computed
2340    value.  In such cases, side-effects due the the LHS are
2341    preserved.  */
2342
2343 bool
2344 gimple_rhs_has_side_effects (const_gimple s)
2345 {
2346   unsigned i;
2347
2348   if (is_gimple_call (s))
2349     {
2350       unsigned nargs = gimple_call_num_args (s);
2351
2352       if (!(gimple_call_flags (s) & (ECF_CONST | ECF_PURE)))
2353         return true;
2354
2355       /* We cannot use gimple_has_volatile_ops here,
2356          because we must ignore a volatile LHS.  */
2357       if (TREE_SIDE_EFFECTS (gimple_call_fn (s))
2358           || TREE_THIS_VOLATILE (gimple_call_fn (s)))
2359         {
2360           gcc_assert (gimple_has_volatile_ops (s));
2361           return true;
2362         }
2363
2364       for (i = 0; i < nargs; i++)
2365         if (TREE_SIDE_EFFECTS (gimple_call_arg (s, i))
2366             || TREE_THIS_VOLATILE (gimple_call_arg (s, i)))
2367           return true;
2368
2369       return false;
2370     }
2371   else if (is_gimple_assign (s))
2372     {
2373       /* Skip the first operand, the LHS. */
2374       for (i = 1; i < gimple_num_ops (s); i++)
2375         if (TREE_SIDE_EFFECTS (gimple_op (s, i))
2376             || TREE_THIS_VOLATILE (gimple_op (s, i)))
2377           {
2378             gcc_assert (gimple_has_volatile_ops (s));
2379             return true;
2380           }
2381     }
2382   else
2383     {
2384       /* For statements without an LHS, examine all arguments.  */
2385       for (i = 0; i < gimple_num_ops (s); i++)
2386         if (TREE_SIDE_EFFECTS (gimple_op (s, i))
2387             || TREE_THIS_VOLATILE (gimple_op (s, i)))
2388           {
2389             gcc_assert (gimple_has_volatile_ops (s));
2390             return true;
2391           }
2392     }
2393
2394   return false;
2395 }
2396
2397
2398 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
2399    Return true if S can trap.  If INCLUDE_LHS is true and S is a
2400    GIMPLE_ASSIGN, the LHS of the assignment is also checked.
2401    Otherwise, only the RHS of the assignment is checked.  */
2402
2403 static bool
2404 gimple_could_trap_p_1 (gimple s, bool include_lhs)
2405 {
2406   unsigned i, start;
2407   tree t, div = NULL_TREE;
2408   enum tree_code op;
2409
2410   start = (is_gimple_assign (s) && !include_lhs) ? 1 : 0;
2411
2412   for (i = start; i < gimple_num_ops (s); i++)
2413     if (tree_could_trap_p (gimple_op (s, i)))
2414       return true;
2415
2416   switch (gimple_code (s))
2417     {
2418     case GIMPLE_ASM:
2419       return gimple_asm_volatile_p (s);
2420
2421     case GIMPLE_CALL:
2422       t = gimple_call_fndecl (s);
2423       /* Assume that calls to weak functions may trap.  */
2424       if (!t || !DECL_P (t) || DECL_WEAK (t))
2425         return true;
2426       return false;
2427
2428     case GIMPLE_ASSIGN:
2429       t = gimple_expr_type (s);
2430       op = gimple_assign_rhs_code (s);
2431       if (get_gimple_rhs_class (op) == GIMPLE_BINARY_RHS)
2432         div = gimple_assign_rhs2 (s);
2433       return (operation_could_trap_p (op, FLOAT_TYPE_P (t),
2434                                       (INTEGRAL_TYPE_P (t)
2435                                        && TYPE_OVERFLOW_TRAPS (t)),
2436                                       div));
2437
2438     default:
2439       break;
2440     }
2441
2442   return false;
2443
2444 }
2445
2446
2447 /* Return true if statement S can trap.  */
2448
2449 bool
2450 gimple_could_trap_p (gimple s)
2451 {
2452   return gimple_could_trap_p_1 (s, true);
2453 }
2454
2455
2456 /* Return true if RHS of a GIMPLE_ASSIGN S can trap.  */
2457
2458 bool
2459 gimple_assign_rhs_could_trap_p (gimple s)
2460 {
2461   gcc_assert (is_gimple_assign (s));
2462   return gimple_could_trap_p_1 (s, false);
2463 }
2464
2465
2466 /* Print debugging information for gimple stmts generated.  */
2467
2468 void
2469 dump_gimple_statistics (void)
2470 {
2471 #ifdef GATHER_STATISTICS
2472   int i, total_tuples = 0, total_bytes = 0;
2473
2474   fprintf (stderr, "\nGIMPLE statements\n");
2475   fprintf (stderr, "Kind                   Stmts      Bytes\n");
2476   fprintf (stderr, "---------------------------------------\n");
2477   for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
2478     {
2479       fprintf (stderr, "%-20s %7d %10d\n", gimple_alloc_kind_names[i],
2480           gimple_alloc_counts[i], gimple_alloc_sizes[i]);
2481       total_tuples += gimple_alloc_counts[i];
2482       total_bytes += gimple_alloc_sizes[i];
2483     }
2484   fprintf (stderr, "---------------------------------------\n");
2485   fprintf (stderr, "%-20s %7d %10d\n", "Total", total_tuples, total_bytes);
2486   fprintf (stderr, "---------------------------------------\n");
2487 #else
2488   fprintf (stderr, "No gimple statistics\n");
2489 #endif
2490 }
2491
2492
2493 /* Deep copy SYMS into the set of symbols stored by STMT.  If SYMS is
2494    NULL or empty, the storage used is freed up.  */
2495
2496 void
2497 gimple_set_stored_syms (gimple stmt, bitmap syms, bitmap_obstack *obs)
2498 {
2499   gcc_assert (gimple_has_mem_ops (stmt));
2500
2501   if (syms == NULL || bitmap_empty_p (syms))
2502     BITMAP_FREE (stmt->gsmem.membase.stores);
2503   else
2504     {
2505       if (stmt->gsmem.membase.stores == NULL)
2506         stmt->gsmem.membase.stores = BITMAP_ALLOC (obs);
2507
2508       bitmap_copy (stmt->gsmem.membase.stores, syms);
2509     }
2510 }
2511
2512
2513 /* Deep copy SYMS into the set of symbols loaded by STMT.  If SYMS is
2514    NULL or empty, the storage used is freed up.  */
2515
2516 void
2517 gimple_set_loaded_syms (gimple stmt, bitmap syms, bitmap_obstack *obs)
2518 {
2519   gcc_assert (gimple_has_mem_ops (stmt));
2520
2521   if (syms == NULL || bitmap_empty_p (syms))
2522     BITMAP_FREE (stmt->gsmem.membase.loads);
2523   else
2524     {
2525       if (stmt->gsmem.membase.loads == NULL)
2526         stmt->gsmem.membase.loads = BITMAP_ALLOC (obs);
2527
2528       bitmap_copy (stmt->gsmem.membase.loads, syms);
2529     }
2530 }
2531
2532
2533 /* Return the number of operands needed on the RHS of a GIMPLE
2534    assignment for an expression with tree code CODE.  */
2535
2536 unsigned
2537 get_gimple_rhs_num_ops (enum tree_code code)
2538 {
2539   enum gimple_rhs_class rhs_class = get_gimple_rhs_class (code);
2540
2541   if (rhs_class == GIMPLE_UNARY_RHS || rhs_class == GIMPLE_SINGLE_RHS)
2542     return 1;
2543   else if (rhs_class == GIMPLE_BINARY_RHS)
2544     return 2;
2545   else
2546     gcc_unreachable ();
2547 }
2548
2549 #define DEFTREECODE(SYM, STRING, TYPE, NARGS)                               \
2550   (unsigned char)                                                           \
2551   ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS                                   \
2552    : ((TYPE) == tcc_binary                                                  \
2553       || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS                      \
2554    : ((TYPE) == tcc_constant                                                \
2555       || (TYPE) == tcc_declaration                                          \
2556       || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS                       \
2557    : ((SYM) == TRUTH_AND_EXPR                                               \
2558       || (SYM) == TRUTH_OR_EXPR                                             \
2559       || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS                       \
2560    : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS                             \
2561    : ((SYM) == COND_EXPR                                                    \
2562       || (SYM) == CONSTRUCTOR                                               \
2563       || (SYM) == OBJ_TYPE_REF                                              \
2564       || (SYM) == ASSERT_EXPR                                               \
2565       || (SYM) == ADDR_EXPR                                                 \
2566       || (SYM) == WITH_SIZE_EXPR                                            \
2567       || (SYM) == EXC_PTR_EXPR                                              \
2568       || (SYM) == SSA_NAME                                                  \
2569       || (SYM) == FILTER_EXPR                                               \
2570       || (SYM) == POLYNOMIAL_CHREC                                          \
2571       || (SYM) == DOT_PROD_EXPR                                             \
2572       || (SYM) == VEC_COND_EXPR                                             \
2573       || (SYM) == REALIGN_LOAD_EXPR) ? GIMPLE_SINGLE_RHS                    \
2574    : GIMPLE_INVALID_RHS),
2575 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2576
2577 const unsigned char gimple_rhs_class_table[] = {
2578 #include "all-tree.def"
2579 };
2580
2581 #undef DEFTREECODE
2582 #undef END_OF_BASE_TREE_CODES
2583
2584 /* For the definitive definition of GIMPLE, see doc/tree-ssa.texi.  */
2585
2586 /* Validation of GIMPLE expressions.  */
2587
2588 /* Return true if OP is an acceptable tree node to be used as a GIMPLE
2589    operand.  */
2590
2591 bool
2592 is_gimple_operand (const_tree op)
2593 {
2594   return op && get_gimple_rhs_class (TREE_CODE (op)) == GIMPLE_SINGLE_RHS;
2595 }
2596
2597
2598 /* Return true if T is a GIMPLE RHS for an assignment to a temporary.  */
2599
2600 bool
2601 is_gimple_formal_tmp_rhs (tree t)
2602 {
2603   if (is_gimple_lvalue (t) || is_gimple_val (t))
2604     return true;
2605
2606   return get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS;
2607 }
2608
2609 /* Returns true iff T is a valid RHS for an assignment to a renamed
2610    user -- or front-end generated artificial -- variable.  */
2611
2612 bool
2613 is_gimple_reg_rhs (tree t)
2614 {
2615   /* If the RHS of the MODIFY_EXPR may throw or make a nonlocal goto
2616      and the LHS is a user variable, then we need to introduce a formal
2617      temporary.  This way the optimizers can determine that the user
2618      variable is only modified if evaluation of the RHS does not throw.
2619
2620      Don't force a temp of a non-renamable type; the copy could be
2621      arbitrarily expensive.  Instead we will generate a VDEF for
2622      the assignment.  */
2623
2624   if (is_gimple_reg_type (TREE_TYPE (t)) && tree_could_throw_p (t))
2625     return false;
2626
2627   return is_gimple_formal_tmp_rhs (t);
2628 }
2629
2630 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
2631    LHS, or for a call argument.  */
2632
2633 bool
2634 is_gimple_mem_rhs (tree t)
2635 {
2636   /* If we're dealing with a renamable type, either source or dest must be
2637      a renamed variable.  */
2638   if (is_gimple_reg_type (TREE_TYPE (t)))
2639     return is_gimple_val (t);
2640   else
2641     return is_gimple_formal_tmp_rhs (t);
2642 }
2643
2644 /*  Return true if T is a valid LHS for a GIMPLE assignment expression.  */
2645
2646 bool
2647 is_gimple_lvalue (tree t)
2648 {
2649   return (is_gimple_addressable (t)
2650           || TREE_CODE (t) == WITH_SIZE_EXPR
2651           /* These are complex lvalues, but don't have addresses, so they
2652              go here.  */
2653           || TREE_CODE (t) == BIT_FIELD_REF);
2654 }
2655
2656 /*  Return true if T is a GIMPLE condition.  */
2657
2658 bool
2659 is_gimple_condexpr (tree t)
2660 {
2661   return (is_gimple_val (t) || (COMPARISON_CLASS_P (t)
2662                                 && !tree_could_trap_p (t)
2663                                 && is_gimple_val (TREE_OPERAND (t, 0))
2664                                 && is_gimple_val (TREE_OPERAND (t, 1))));
2665 }
2666
2667 /*  Return true if T is something whose address can be taken.  */
2668
2669 bool
2670 is_gimple_addressable (tree t)
2671 {
2672   return (is_gimple_id (t) || handled_component_p (t) || INDIRECT_REF_P (t));
2673 }
2674
2675 /* Return true if T is a valid gimple constant.  */
2676
2677 bool
2678 is_gimple_constant (const_tree t)
2679 {
2680   switch (TREE_CODE (t))
2681     {
2682     case INTEGER_CST:
2683     case REAL_CST:
2684     case FIXED_CST:
2685     case STRING_CST:
2686     case COMPLEX_CST:
2687     case VECTOR_CST:
2688       return true;
2689
2690     /* Vector constant constructors are gimple invariant.  */
2691     case CONSTRUCTOR:
2692       if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
2693         return TREE_CONSTANT (t);
2694       else
2695         return false;
2696
2697     default:
2698       return false;
2699     }
2700 }
2701
2702 /* Return true if T is a gimple address.  */
2703
2704 bool
2705 is_gimple_address (const_tree t)
2706 {
2707   tree op;
2708
2709   if (TREE_CODE (t) != ADDR_EXPR)
2710     return false;
2711
2712   op = TREE_OPERAND (t, 0);
2713   while (handled_component_p (op))
2714     {
2715       if ((TREE_CODE (op) == ARRAY_REF
2716            || TREE_CODE (op) == ARRAY_RANGE_REF)
2717           && !is_gimple_val (TREE_OPERAND (op, 1)))
2718             return false;
2719
2720       op = TREE_OPERAND (op, 0);
2721     }
2722
2723   if (CONSTANT_CLASS_P (op) || INDIRECT_REF_P (op))
2724     return true;
2725
2726   switch (TREE_CODE (op))
2727     {
2728     case PARM_DECL:
2729     case RESULT_DECL:
2730     case LABEL_DECL:
2731     case FUNCTION_DECL:
2732     case VAR_DECL:
2733     case CONST_DECL:
2734       return true;
2735
2736     default:
2737       return false;
2738     }
2739 }
2740
2741 /* Strip out all handled components that produce invariant
2742    offsets.  */
2743
2744 static const_tree
2745 strip_invariant_refs (const_tree op)
2746 {
2747   while (handled_component_p (op))
2748     {
2749       switch (TREE_CODE (op))
2750         {
2751         case ARRAY_REF:
2752         case ARRAY_RANGE_REF:
2753           if (!is_gimple_constant (TREE_OPERAND (op, 1))
2754               || TREE_OPERAND (op, 2) != NULL_TREE
2755               || TREE_OPERAND (op, 3) != NULL_TREE)
2756             return NULL;
2757           break;
2758
2759         case COMPONENT_REF:
2760           if (TREE_OPERAND (op, 2) != NULL_TREE)
2761             return NULL;
2762           break;
2763
2764         default:;
2765         }
2766       op = TREE_OPERAND (op, 0);
2767     }
2768
2769   return op;
2770 }
2771
2772 /* Return true if T is a gimple invariant address.  */
2773
2774 bool
2775 is_gimple_invariant_address (const_tree t)
2776 {
2777   const_tree op;
2778
2779   if (TREE_CODE (t) != ADDR_EXPR)
2780     return false;
2781
2782   op = strip_invariant_refs (TREE_OPERAND (t, 0));
2783
2784   return op && (CONSTANT_CLASS_P (op) || decl_address_invariant_p (op));
2785 }
2786
2787 /* Return true if T is a gimple invariant address at IPA level
2788    (so addresses of variables on stack are not allowed).  */
2789
2790 bool
2791 is_gimple_ip_invariant_address (const_tree t)
2792 {
2793   const_tree op;
2794
2795   if (TREE_CODE (t) != ADDR_EXPR)
2796     return false;
2797
2798   op = strip_invariant_refs (TREE_OPERAND (t, 0));
2799
2800   return op && (CONSTANT_CLASS_P (op) || decl_address_ip_invariant_p (op));
2801 }
2802
2803 /* Return true if T is a GIMPLE minimal invariant.  It's a restricted
2804    form of function invariant.  */
2805
2806 bool
2807 is_gimple_min_invariant (const_tree t)
2808 {
2809   if (TREE_CODE (t) == ADDR_EXPR)
2810     return is_gimple_invariant_address (t);
2811
2812   return is_gimple_constant (t);
2813 }
2814
2815 /* Return true if T is a GIMPLE interprocedural invariant.  It's a restricted
2816    form of gimple minimal invariant.  */
2817
2818 bool
2819 is_gimple_ip_invariant (const_tree t)
2820 {
2821   if (TREE_CODE (t) == ADDR_EXPR)
2822     return is_gimple_ip_invariant_address (t);
2823
2824   return is_gimple_constant (t);
2825 }
2826
2827 /* Return true if T looks like a valid GIMPLE statement.  */
2828
2829 bool
2830 is_gimple_stmt (tree t)
2831 {
2832   const enum tree_code code = TREE_CODE (t);
2833
2834   switch (code)
2835     {
2836     case NOP_EXPR:
2837       /* The only valid NOP_EXPR is the empty statement.  */
2838       return IS_EMPTY_STMT (t);
2839
2840     case BIND_EXPR:
2841     case COND_EXPR:
2842       /* These are only valid if they're void.  */
2843       return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
2844
2845     case SWITCH_EXPR:
2846     case GOTO_EXPR:
2847     case RETURN_EXPR:
2848     case LABEL_EXPR:
2849     case CASE_LABEL_EXPR:
2850     case TRY_CATCH_EXPR:
2851     case TRY_FINALLY_EXPR:
2852     case EH_FILTER_EXPR:
2853     case CATCH_EXPR:
2854     case CHANGE_DYNAMIC_TYPE_EXPR:
2855     case ASM_EXPR:
2856     case RESX_EXPR:
2857     case STATEMENT_LIST:
2858     case OMP_PARALLEL:
2859     case OMP_FOR:
2860     case OMP_SECTIONS:
2861     case OMP_SECTION:
2862     case OMP_SINGLE:
2863     case OMP_MASTER:
2864     case OMP_ORDERED:
2865     case OMP_CRITICAL:
2866     case OMP_TASK:
2867       /* These are always void.  */
2868       return true;
2869
2870     case CALL_EXPR:
2871     case MODIFY_EXPR:
2872     case PREDICT_EXPR:
2873       /* These are valid regardless of their type.  */
2874       return true;
2875
2876     default:
2877       return false;
2878     }
2879 }
2880
2881 /* Return true if T is a variable.  */
2882
2883 bool
2884 is_gimple_variable (tree t)
2885 {
2886   return (TREE_CODE (t) == VAR_DECL
2887           || TREE_CODE (t) == PARM_DECL
2888           || TREE_CODE (t) == RESULT_DECL
2889           || TREE_CODE (t) == SSA_NAME);
2890 }
2891
2892 /*  Return true if T is a GIMPLE identifier (something with an address).  */
2893
2894 bool
2895 is_gimple_id (tree t)
2896 {
2897   return (is_gimple_variable (t)
2898           || TREE_CODE (t) == FUNCTION_DECL
2899           || TREE_CODE (t) == LABEL_DECL
2900           || TREE_CODE (t) == CONST_DECL
2901           /* Allow string constants, since they are addressable.  */
2902           || TREE_CODE (t) == STRING_CST);
2903 }
2904
2905 /* Return true if TYPE is a suitable type for a scalar register variable.  */
2906
2907 bool
2908 is_gimple_reg_type (tree type)
2909 {
2910   /* In addition to aggregate types, we also exclude complex types if not
2911      optimizing because they can be subject to partial stores in GNU C by
2912      means of the __real__ and __imag__ operators and we cannot promote
2913      them to total stores (see gimplify_modify_expr_complex_part).  */
2914   return !(AGGREGATE_TYPE_P (type)
2915            || (TREE_CODE (type) == COMPLEX_TYPE && !optimize));
2916
2917 }
2918
2919 /* Return true if T is a non-aggregate register variable.  */
2920
2921 bool
2922 is_gimple_reg (tree t)
2923 {
2924   if (TREE_CODE (t) == SSA_NAME)
2925     t = SSA_NAME_VAR (t);
2926
2927   if (MTAG_P (t))
2928     return false;
2929
2930   if (!is_gimple_variable (t))
2931     return false;
2932
2933   if (!is_gimple_reg_type (TREE_TYPE (t)))
2934     return false;
2935
2936   /* A volatile decl is not acceptable because we can't reuse it as
2937      needed.  We need to copy it into a temp first.  */
2938   if (TREE_THIS_VOLATILE (t))
2939     return false;
2940
2941   /* We define "registers" as things that can be renamed as needed,
2942      which with our infrastructure does not apply to memory.  */
2943   if (needs_to_live_in_memory (t))
2944     return false;
2945
2946   /* Hard register variables are an interesting case.  For those that
2947      are call-clobbered, we don't know where all the calls are, since
2948      we don't (want to) take into account which operations will turn
2949      into libcalls at the rtl level.  For those that are call-saved,
2950      we don't currently model the fact that calls may in fact change
2951      global hard registers, nor do we examine ASM_CLOBBERS at the tree
2952      level, and so miss variable changes that might imply.  All around,
2953      it seems safest to not do too much optimization with these at the
2954      tree level at all.  We'll have to rely on the rtl optimizers to
2955      clean this up, as there we've got all the appropriate bits exposed.  */
2956   if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2957     return false;
2958
2959   /* Complex and vector values must have been put into SSA-like form.
2960      That is, no assignments to the individual components.  */
2961   if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
2962       || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
2963     return DECL_GIMPLE_REG_P (t);
2964
2965   return true;
2966 }
2967
2968
2969 /* Returns true if T is a GIMPLE formal temporary variable.  */
2970
2971 bool
2972 is_gimple_formal_tmp_var (tree t)
2973 {
2974   if (TREE_CODE (t) == SSA_NAME)
2975     return true;
2976
2977   return TREE_CODE (t) == VAR_DECL && DECL_GIMPLE_FORMAL_TEMP_P (t);
2978 }
2979
2980 /* Returns true if T is a GIMPLE formal temporary register variable.  */
2981
2982 bool
2983 is_gimple_formal_tmp_reg (tree t)
2984 {
2985   /* The intent of this is to get hold of a value that won't change.
2986      An SSA_NAME qualifies no matter if its of a user variable or not.  */
2987   if (TREE_CODE (t) == SSA_NAME)
2988     return true;
2989
2990   /* We don't know the lifetime characteristics of user variables.  */
2991   if (!is_gimple_formal_tmp_var (t))
2992     return false;
2993
2994   /* Finally, it must be capable of being placed in a register.  */
2995   return is_gimple_reg (t);
2996 }
2997
2998 /* Return true if T is a GIMPLE variable whose address is not needed.  */
2999
3000 bool
3001 is_gimple_non_addressable (tree t)
3002 {
3003   if (TREE_CODE (t) == SSA_NAME)
3004     t = SSA_NAME_VAR (t);
3005
3006   return (is_gimple_variable (t) && ! needs_to_live_in_memory (t));
3007 }
3008
3009 /* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant.  */
3010
3011 bool
3012 is_gimple_val (tree t)
3013 {
3014   /* Make loads from volatiles and memory vars explicit.  */
3015   if (is_gimple_variable (t)
3016       && is_gimple_reg_type (TREE_TYPE (t))
3017       && !is_gimple_reg (t))
3018     return false;
3019
3020   /* FIXME make these decls.  That can happen only when we expose the
3021      entire landing-pad construct at the tree level.  */
3022   if (TREE_CODE (t) == EXC_PTR_EXPR || TREE_CODE (t) == FILTER_EXPR)
3023     return true;
3024
3025   return (is_gimple_variable (t) || is_gimple_min_invariant (t));
3026 }
3027
3028 /* Similarly, but accept hard registers as inputs to asm statements.  */
3029
3030 bool
3031 is_gimple_asm_val (tree t)
3032 {
3033   if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
3034     return true;
3035
3036   return is_gimple_val (t);
3037 }
3038
3039 /* Return true if T is a GIMPLE minimal lvalue.  */
3040
3041 bool
3042 is_gimple_min_lval (tree t)
3043 {
3044   return (is_gimple_id (t) || TREE_CODE (t) == INDIRECT_REF);
3045 }
3046
3047 /* Return true if T is a typecast operation.  */
3048
3049 bool
3050 is_gimple_cast (tree t)
3051 {
3052   return (CONVERT_EXPR_P (t)
3053           || TREE_CODE (t) == FIX_TRUNC_EXPR);
3054 }
3055
3056 /* Return true if T is a valid function operand of a CALL_EXPR.  */
3057
3058 bool
3059 is_gimple_call_addr (tree t)
3060 {
3061   return (TREE_CODE (t) == OBJ_TYPE_REF || is_gimple_val (t));
3062 }
3063
3064 /* If T makes a function call, return the corresponding CALL_EXPR operand.
3065    Otherwise, return NULL_TREE.  */
3066
3067 tree
3068 get_call_expr_in (tree t)
3069 {
3070   if (TREE_CODE (t) == MODIFY_EXPR)
3071     t = TREE_OPERAND (t, 1);
3072   if (TREE_CODE (t) == WITH_SIZE_EXPR)
3073     t = TREE_OPERAND (t, 0);
3074   if (TREE_CODE (t) == CALL_EXPR)
3075     return t;
3076   return NULL_TREE;
3077 }
3078
3079
3080 /* Given a memory reference expression T, return its base address.
3081    The base address of a memory reference expression is the main
3082    object being referenced.  For instance, the base address for
3083    'array[i].fld[j]' is 'array'.  You can think of this as stripping
3084    away the offset part from a memory address.
3085
3086    This function calls handled_component_p to strip away all the inner
3087    parts of the memory reference until it reaches the base object.  */
3088
3089 tree
3090 get_base_address (tree t)
3091 {
3092   while (handled_component_p (t))
3093     t = TREE_OPERAND (t, 0);
3094
3095   if (SSA_VAR_P (t)
3096       || TREE_CODE (t) == STRING_CST
3097       || TREE_CODE (t) == CONSTRUCTOR
3098       || INDIRECT_REF_P (t))
3099     return t;
3100   else
3101     return NULL_TREE;
3102 }
3103
3104 void
3105 recalculate_side_effects (tree t)
3106 {
3107   enum tree_code code = TREE_CODE (t);
3108   int len = TREE_OPERAND_LENGTH (t);
3109   int i;
3110
3111   switch (TREE_CODE_CLASS (code))
3112     {
3113     case tcc_expression:
3114       switch (code)
3115         {
3116         case INIT_EXPR:
3117         case MODIFY_EXPR:
3118         case VA_ARG_EXPR:
3119         case PREDECREMENT_EXPR:
3120         case PREINCREMENT_EXPR:
3121         case POSTDECREMENT_EXPR:
3122         case POSTINCREMENT_EXPR:
3123           /* All of these have side-effects, no matter what their
3124              operands are.  */
3125           return;
3126
3127         default:
3128           break;
3129         }
3130       /* Fall through.  */
3131
3132     case tcc_comparison:  /* a comparison expression */
3133     case tcc_unary:       /* a unary arithmetic expression */
3134     case tcc_binary:      /* a binary arithmetic expression */
3135     case tcc_reference:   /* a reference */
3136     case tcc_vl_exp:        /* a function call */
3137       TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);
3138       for (i = 0; i < len; ++i)
3139         {
3140           tree op = TREE_OPERAND (t, i);
3141           if (op && TREE_SIDE_EFFECTS (op))
3142             TREE_SIDE_EFFECTS (t) = 1;
3143         }
3144       break;
3145
3146     default:
3147       /* Can never be used with non-expressions.  */
3148       gcc_unreachable ();
3149    }
3150 }
3151
3152 /* Canonicalize a tree T for use in a COND_EXPR as conditional.  Returns
3153    a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
3154    we failed to create one.  */
3155
3156 tree
3157 canonicalize_cond_expr_cond (tree t)
3158 {
3159   /* For (bool)x use x != 0.  */
3160   if (TREE_CODE (t) == NOP_EXPR
3161       && TREE_TYPE (t) == boolean_type_node)
3162     {
3163       tree top0 = TREE_OPERAND (t, 0);
3164       t = build2 (NE_EXPR, TREE_TYPE (t),
3165                   top0, build_int_cst (TREE_TYPE (top0), 0));
3166     }
3167   /* For !x use x == 0.  */
3168   else if (TREE_CODE (t) == TRUTH_NOT_EXPR)
3169     {
3170       tree top0 = TREE_OPERAND (t, 0);
3171       t = build2 (EQ_EXPR, TREE_TYPE (t),
3172                   top0, build_int_cst (TREE_TYPE (top0), 0));
3173     }
3174   /* For cmp ? 1 : 0 use cmp.  */
3175   else if (TREE_CODE (t) == COND_EXPR
3176            && COMPARISON_CLASS_P (TREE_OPERAND (t, 0))
3177            && integer_onep (TREE_OPERAND (t, 1))
3178            && integer_zerop (TREE_OPERAND (t, 2)))
3179     {
3180       tree top0 = TREE_OPERAND (t, 0);
3181       t = build2 (TREE_CODE (top0), TREE_TYPE (t),
3182                   TREE_OPERAND (top0, 0), TREE_OPERAND (top0, 1));
3183     }
3184
3185   if (is_gimple_condexpr (t))
3186     return t;
3187
3188   return NULL_TREE;
3189 }
3190
3191 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
3192    the positions marked by the set ARGS_TO_SKIP.  */
3193
3194 gimple
3195 gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)
3196 {
3197   int i;
3198   tree fn = gimple_call_fn (stmt);
3199   int nargs = gimple_call_num_args (stmt);
3200   VEC(tree, heap) *vargs = VEC_alloc (tree, heap, nargs);
3201   gimple new_stmt;
3202
3203   for (i = 0; i < nargs; i++)
3204     if (!bitmap_bit_p (args_to_skip, i))
3205       VEC_quick_push (tree, vargs, gimple_call_arg (stmt, i));
3206
3207   new_stmt = gimple_build_call_vec (fn, vargs);
3208   VEC_free (tree, heap, vargs);
3209   if (gimple_call_lhs (stmt))
3210     gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
3211
3212   gimple_set_block (new_stmt, gimple_block (stmt));
3213   if (gimple_has_location (stmt))
3214     gimple_set_location (new_stmt, gimple_location (stmt));
3215
3216   /* Carry all the flags to the new GIMPLE_CALL.  */
3217   gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
3218   gimple_call_set_tail (new_stmt, gimple_call_tail_p (stmt));
3219   gimple_call_set_cannot_inline (new_stmt, gimple_call_cannot_inline_p (stmt));
3220   gimple_call_set_return_slot_opt (new_stmt, gimple_call_return_slot_opt_p (stmt));
3221   gimple_call_set_from_thunk (new_stmt, gimple_call_from_thunk_p (stmt));
3222   gimple_call_set_va_arg_pack (new_stmt, gimple_call_va_arg_pack_p (stmt));
3223   return new_stmt;
3224 }
3225
3226 #include "gt-gimple.h"