gcc/tree-ssa-loop.c

   1 /* Loop optimizations over tree-ssa.
   2    Copyright (C) 2003-2016 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it
   7 under the terms of the GNU General Public License as published by the
   8 Free Software Foundation; either version 3, or (at your option) any
   9 later version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT
  12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "backend.h"
  24 #include "tree.h"
  25 #include "gimple.h"
  26 #include "tree-pass.h"
  27 #include "tm_p.h"
  28 #include "fold-const.h"
  29 #include "gimple-iterator.h"
  30 #include "tree-ssa-loop-ivopts.h"
  31 #include "tree-ssa-loop-manip.h"
  32 #include "tree-ssa-loop-niter.h"
  33 #include "tree-ssa-loop.h"
  34 #include "cfgloop.h"
  35 #include "tree-inline.h"
  36 #include "tree-scalar-evolution.h"
  37 #include "tree-vectorizer.h"
  38 #include "omp-low.h"
  39 #include "diagnostic-core.h"
  40
  41
  42 /* A pass making sure loops are fixed up.  */
  43
  44 namespace {
  45
  46 const pass_data pass_data_fix_loops =
  47 {
  48   GIMPLE_PASS, /* type */
  49   "fix_loops", /* name */
  50   OPTGROUP_LOOP, /* optinfo_flags */
  51   TV_TREE_LOOP, /* tv_id */
  52   PROP_cfg, /* properties_required */
  53   0, /* properties_provided */
  54   0, /* properties_destroyed */
  55   0, /* todo_flags_start */
  56   0, /* todo_flags_finish */
  57 };
  58
  59 class pass_fix_loops : public gimple_opt_pass
  60 {
  61 public:
  62   pass_fix_loops (gcc::context *ctxt)
  63     : gimple_opt_pass (pass_data_fix_loops, ctxt)
  64   {}
  65
  66   /* opt_pass methods: */
  67   virtual bool gate (function *) { return flag_tree_loop_optimize; }
  68
  69   virtual unsigned int execute (function *fn);
  70 }; // class pass_fix_loops
  71
  72 unsigned int
  73 pass_fix_loops::execute (function *)
  74 {
  75   if (loops_state_satisfies_p (LOOPS_NEED_FIXUP))
  76     {
  77       calculate_dominance_info (CDI_DOMINATORS);
  78       fix_loop_structure (NULL);
  79     }
  80   return 0;
  81 }
  82
  83 } // anon namespace
  84
  85 gimple_opt_pass *
  86 make_pass_fix_loops (gcc::context *ctxt)
  87 {
  88   return new pass_fix_loops (ctxt);
  89 }
  90
  91
  92 /* Gate for loop pass group.  The group is controlled by -ftree-loop-optimize
  93    but we also avoid running it when the IL doesn't contain any loop.  */
  94
  95 static bool
  96 gate_loop (function *fn)
  97 {
  98   if (!flag_tree_loop_optimize)
  99     return false;
 100
 101   /* For -fdump-passes which runs before loop discovery print the
 102      state of -ftree-loop-optimize.  */
 103   if (!loops_for_fn (fn))
 104     return true;
 105
 106   return number_of_loops (fn) > 1;
 107 }
 108
 109 /* The loop superpass.  */
 110
 111 namespace {
 112
 113 const pass_data pass_data_tree_loop =
 114 {
 115   GIMPLE_PASS, /* type */
 116   "loop", /* name */
 117   OPTGROUP_LOOP, /* optinfo_flags */
 118   TV_TREE_LOOP, /* tv_id */
 119   PROP_cfg, /* properties_required */
 120   0, /* properties_provided */
 121   0, /* properties_destroyed */
 122   0, /* todo_flags_start */
 123   0, /* todo_flags_finish */
 124 };
 125
 126 class pass_tree_loop : public gimple_opt_pass
 127 {
 128 public:
 129   pass_tree_loop (gcc::context *ctxt)
 130     : gimple_opt_pass (pass_data_tree_loop, ctxt)
 131   {}
 132
 133   /* opt_pass methods: */
 134   virtual bool gate (function *fn) { return gate_loop (fn); }
 135
 136 }; // class pass_tree_loop
 137
 138 } // anon namespace
 139
 140 gimple_opt_pass *
 141 make_pass_tree_loop (gcc::context *ctxt)
 142 {
 143   return new pass_tree_loop (ctxt);
 144 }
 145
 146 /* Gate for oacc kernels pass group.  */
 147
 148 static bool
 149 gate_oacc_kernels (function *fn)
 150 {
 151   if (!flag_openacc)
 152     return false;
 153
 154   tree oacc_function_attr = get_oacc_fn_attrib (fn->decl);
 155   if (oacc_function_attr == NULL_TREE)
 156     return false;
 157   if (!oacc_fn_attrib_kernels_p (oacc_function_attr))
 158     return false;
 159
 160   struct loop *loop;
 161   FOR_EACH_LOOP (loop, 0)
 162     if (loop->in_oacc_kernels_region)
 163       return true;
 164
 165   return false;
 166 }
 167
 168 /* The oacc kernels superpass.  */
 169
 170 namespace {
 171
 172 const pass_data pass_data_oacc_kernels =
 173 {
 174   GIMPLE_PASS, /* type */
 175   "oacc_kernels", /* name */
 176   OPTGROUP_LOOP, /* optinfo_flags */
 177   TV_TREE_LOOP, /* tv_id */
 178   PROP_cfg, /* properties_required */
 179   0, /* properties_provided */
 180   0, /* properties_destroyed */
 181   0, /* todo_flags_start */
 182   0, /* todo_flags_finish */
 183 };
 184
 185 class pass_oacc_kernels : public gimple_opt_pass
 186 {
 187 public:
 188   pass_oacc_kernels (gcc::context *ctxt)
 189     : gimple_opt_pass (pass_data_oacc_kernels, ctxt)
 190   {}
 191
 192   /* opt_pass methods: */
 193   virtual bool gate (function *fn) { return gate_oacc_kernels (fn); }
 194
 195 }; // class pass_oacc_kernels
 196
 197 } // anon namespace
 198
 199 gimple_opt_pass *
 200 make_pass_oacc_kernels (gcc::context *ctxt)
 201 {
 202   return new pass_oacc_kernels (ctxt);
 203 }
 204
 205 /* The ipa oacc superpass.  */
 206
 207 namespace {
 208
 209 const pass_data pass_data_ipa_oacc =
 210 {
 211   SIMPLE_IPA_PASS, /* type */
 212   "ipa_oacc", /* name */
 213   OPTGROUP_LOOP, /* optinfo_flags */
 214   TV_TREE_LOOP, /* tv_id */
 215   PROP_cfg, /* properties_required */
 216   0, /* properties_provided */
 217   0, /* properties_destroyed */
 218   0, /* todo_flags_start */
 219   0, /* todo_flags_finish */
 220 };
 221
 222 class pass_ipa_oacc : public simple_ipa_opt_pass
 223 {
 224 public:
 225   pass_ipa_oacc (gcc::context *ctxt)
 226     : simple_ipa_opt_pass (pass_data_ipa_oacc, ctxt)
 227   {}
 228
 229   /* opt_pass methods: */
 230   virtual bool gate (function *)
 231   {
 232     return (optimize
 233             && flag_openacc
 234             /* Don't bother doing anything if the program has errors.  */
 235             && !seen_error ());
 236   }
 237
 238 }; // class pass_ipa_oacc
 239
 240 } // anon namespace
 241
 242 simple_ipa_opt_pass *
 243 make_pass_ipa_oacc (gcc::context *ctxt)
 244 {
 245   return new pass_ipa_oacc (ctxt);
 246 }
 247
 248 /* The ipa oacc kernels pass.  */
 249
 250 namespace {
 251
 252 const pass_data pass_data_ipa_oacc_kernels =
 253 {
 254   SIMPLE_IPA_PASS, /* type */
 255   "ipa_oacc_kernels", /* name */
 256   OPTGROUP_LOOP, /* optinfo_flags */
 257   TV_TREE_LOOP, /* tv_id */
 258   PROP_cfg, /* properties_required */
 259   0, /* properties_provided */
 260   0, /* properties_destroyed */
 261   0, /* todo_flags_start */
 262   0, /* todo_flags_finish */
 263 };
 264
 265 class pass_ipa_oacc_kernels : public simple_ipa_opt_pass
 266 {
 267 public:
 268   pass_ipa_oacc_kernels (gcc::context *ctxt)
 269     : simple_ipa_opt_pass (pass_data_ipa_oacc_kernels, ctxt)
 270   {}
 271
 272 }; // class pass_ipa_oacc_kernels
 273
 274 } // anon namespace
 275
 276 simple_ipa_opt_pass *
 277 make_pass_ipa_oacc_kernels (gcc::context *ctxt)
 278 {
 279   return new pass_ipa_oacc_kernels (ctxt);
 280 }
 281
 282 /* The no-loop superpass.  */
 283
 284 namespace {
 285
 286 const pass_data pass_data_tree_no_loop =
 287 {
 288   GIMPLE_PASS, /* type */
 289   "no_loop", /* name */
 290   OPTGROUP_NONE, /* optinfo_flags */
 291   TV_TREE_NOLOOP, /* tv_id */
 292   PROP_cfg, /* properties_required */
 293   0, /* properties_provided */
 294   0, /* properties_destroyed */
 295   0, /* todo_flags_start */
 296   0, /* todo_flags_finish */
 297 };
 298
 299 class pass_tree_no_loop : public gimple_opt_pass
 300 {
 301 public:
 302   pass_tree_no_loop (gcc::context *ctxt)
 303     : gimple_opt_pass (pass_data_tree_no_loop, ctxt)
 304   {}
 305
 306   /* opt_pass methods: */
 307   virtual bool gate (function *fn) { return !gate_loop (fn); }
 308
 309 }; // class pass_tree_no_loop
 310
 311 } // anon namespace
 312
 313 gimple_opt_pass *
 314 make_pass_tree_no_loop (gcc::context *ctxt)
 315 {
 316   return new pass_tree_no_loop (ctxt);
 317 }
 318
 319
 320 /* Loop optimizer initialization.  */
 321
 322 namespace {
 323
 324 const pass_data pass_data_tree_loop_init =
 325 {
 326   GIMPLE_PASS, /* type */
 327   "loopinit", /* name */
 328   OPTGROUP_LOOP, /* optinfo_flags */
 329   TV_NONE, /* tv_id */
 330   PROP_cfg, /* properties_required */
 331   0, /* properties_provided */
 332   0, /* properties_destroyed */
 333   0, /* todo_flags_start */
 334   0, /* todo_flags_finish */
 335 };
 336
 337 class pass_tree_loop_init : public gimple_opt_pass
 338 {
 339 public:
 340   pass_tree_loop_init (gcc::context *ctxt)
 341     : gimple_opt_pass (pass_data_tree_loop_init, ctxt)
 342   {}
 343
 344   /* opt_pass methods: */
 345   virtual unsigned int execute (function *);
 346
 347 }; // class pass_tree_loop_init
 348
 349 unsigned int
 350 pass_tree_loop_init::execute (function *fun ATTRIBUTE_UNUSED)
 351 {
 352   /* When processing a loop in the loop pipeline, we should be able to assert
 353      that:
 354        (loops_state_satisfies_p (LOOPS_NORMAL | LOOPS_HAVE_RECORDED_EXITS
 355                                               | LOOP_CLOSED_SSA)
 356         && scev_initialized_p ())
 357   */
 358   loop_optimizer_init (LOOPS_NORMAL
 359                        | LOOPS_HAVE_RECORDED_EXITS);
 360   rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa);
 361   scev_initialize ();
 362
 363   return 0;
 364 }
 365
 366 } // anon namespace
 367
 368 gimple_opt_pass *
 369 make_pass_tree_loop_init (gcc::context *ctxt)
 370 {
 371   return new pass_tree_loop_init (ctxt);
 372 }
 373
 374 /* Loop autovectorization.  */
 375
 376 namespace {
 377
 378 const pass_data pass_data_vectorize =
 379 {
 380   GIMPLE_PASS, /* type */
 381   "vect", /* name */
 382   OPTGROUP_LOOP | OPTGROUP_VEC, /* optinfo_flags */
 383   TV_TREE_VECTORIZATION, /* tv_id */
 384   ( PROP_cfg | PROP_ssa ), /* properties_required */
 385   0, /* properties_provided */
 386   0, /* properties_destroyed */
 387   0, /* todo_flags_start */
 388   0, /* todo_flags_finish */
 389 };
 390
 391 class pass_vectorize : public gimple_opt_pass
 392 {
 393 public:
 394   pass_vectorize (gcc::context *ctxt)
 395     : gimple_opt_pass (pass_data_vectorize, ctxt)
 396   {}
 397
 398   /* opt_pass methods: */
 399   virtual bool gate (function *fun)
 400     {
 401       return flag_tree_loop_vectorize || fun->has_force_vectorize_loops;
 402     }
 403
 404   virtual unsigned int execute (function *);
 405
 406 }; // class pass_vectorize
 407
 408 unsigned int
 409 pass_vectorize::execute (function *fun)
 410 {
 411   if (number_of_loops (fun) <= 1)
 412     return 0;
 413
 414   return vectorize_loops ();
 415 }
 416
 417 } // anon namespace
 418
 419 gimple_opt_pass *
 420 make_pass_vectorize (gcc::context *ctxt)
 421 {
 422   return new pass_vectorize (ctxt);
 423 }
 424
 425 /* Propagation of constants using scev.  */
 426
 427 namespace {
 428
 429 const pass_data pass_data_scev_cprop =
 430 {
 431   GIMPLE_PASS, /* type */
 432   "sccp", /* name */
 433   OPTGROUP_LOOP, /* optinfo_flags */
 434   TV_SCEV_CONST, /* tv_id */
 435   ( PROP_cfg | PROP_ssa ), /* properties_required */
 436   0, /* properties_provided */
 437   0, /* properties_destroyed */
 438   0, /* todo_flags_start */
 439   ( TODO_cleanup_cfg
 440     | TODO_update_ssa_only_virtuals ), /* todo_flags_finish */
 441 };
 442
 443 class pass_scev_cprop : public gimple_opt_pass
 444 {
 445 public:
 446   pass_scev_cprop (gcc::context *ctxt)
 447     : gimple_opt_pass (pass_data_scev_cprop, ctxt)
 448   {}
 449
 450   /* opt_pass methods: */
 451   virtual bool gate (function *) { return flag_tree_scev_cprop; }
 452   virtual unsigned int execute (function *) { return scev_const_prop (); }
 453
 454 }; // class pass_scev_cprop
 455
 456 } // anon namespace
 457
 458 gimple_opt_pass *
 459 make_pass_scev_cprop (gcc::context *ctxt)
 460 {
 461   return new pass_scev_cprop (ctxt);
 462 }
 463
 464 /* Record bounds on numbers of iterations of loops.  */
 465
 466 namespace {
 467
 468 const pass_data pass_data_record_bounds =
 469 {
 470   GIMPLE_PASS, /* type */
 471   "*record_bounds", /* name */
 472   OPTGROUP_NONE, /* optinfo_flags */
 473   TV_TREE_LOOP_BOUNDS, /* tv_id */
 474   ( PROP_cfg | PROP_ssa ), /* properties_required */
 475   0, /* properties_provided */
 476   0, /* properties_destroyed */
 477   0, /* todo_flags_start */
 478   0, /* todo_flags_finish */
 479 };
 480
 481 class pass_record_bounds : public gimple_opt_pass
 482 {
 483 public:
 484   pass_record_bounds (gcc::context *ctxt)
 485     : gimple_opt_pass (pass_data_record_bounds, ctxt)
 486   {}
 487
 488   /* opt_pass methods: */
 489   virtual unsigned int execute (function *);
 490
 491 }; // class pass_record_bounds
 492
 493 unsigned int
 494 pass_record_bounds::execute (function *fun)
 495 {
 496   if (number_of_loops (fun) <= 1)
 497     return 0;
 498
 499   estimate_numbers_of_iterations ();
 500   scev_reset ();
 501   return 0;
 502 }
 503
 504 } // anon namespace
 505
 506 gimple_opt_pass *
 507 make_pass_record_bounds (gcc::context *ctxt)
 508 {
 509   return new pass_record_bounds (ctxt);
 510 }
 511
 512 /* Induction variable optimizations.  */
 513
 514 namespace {
 515
 516 const pass_data pass_data_iv_optimize =
 517 {
 518   GIMPLE_PASS, /* type */
 519   "ivopts", /* name */
 520   OPTGROUP_LOOP, /* optinfo_flags */
 521   TV_TREE_LOOP_IVOPTS, /* tv_id */
 522   ( PROP_cfg | PROP_ssa ), /* properties_required */
 523   0, /* properties_provided */
 524   0, /* properties_destroyed */
 525   0, /* todo_flags_start */
 526   TODO_update_ssa, /* todo_flags_finish */
 527 };
 528
 529 class pass_iv_optimize : public gimple_opt_pass
 530 {
 531 public:
 532   pass_iv_optimize (gcc::context *ctxt)
 533     : gimple_opt_pass (pass_data_iv_optimize, ctxt)
 534   {}
 535
 536   /* opt_pass methods: */
 537   virtual bool gate (function *) { return flag_ivopts != 0; }
 538   virtual unsigned int execute (function *);
 539
 540 }; // class pass_iv_optimize
 541
 542 unsigned int
 543 pass_iv_optimize::execute (function *fun)
 544 {
 545   if (number_of_loops (fun) <= 1)
 546     return 0;
 547
 548   tree_ssa_iv_optimize ();
 549   return 0;
 550 }
 551
 552 } // anon namespace
 553
 554 gimple_opt_pass *
 555 make_pass_iv_optimize (gcc::context *ctxt)
 556 {
 557   return new pass_iv_optimize (ctxt);
 558 }
 559
 560 /* Loop optimizer finalization.  */
 561
 562 static unsigned int
 563 tree_ssa_loop_done (void)
 564 {
 565   free_numbers_of_iterations_estimates (cfun);
 566   scev_finalize ();
 567   loop_optimizer_finalize ();
 568   return 0;
 569 }
 570
 571 namespace {
 572
 573 const pass_data pass_data_tree_loop_done =
 574 {
 575   GIMPLE_PASS, /* type */
 576   "loopdone", /* name */
 577   OPTGROUP_LOOP, /* optinfo_flags */
 578   TV_NONE, /* tv_id */
 579   PROP_cfg, /* properties_required */
 580   0, /* properties_provided */
 581   0, /* properties_destroyed */
 582   0, /* todo_flags_start */
 583   TODO_cleanup_cfg, /* todo_flags_finish */
 584 };
 585
 586 class pass_tree_loop_done : public gimple_opt_pass
 587 {
 588 public:
 589   pass_tree_loop_done (gcc::context *ctxt)
 590     : gimple_opt_pass (pass_data_tree_loop_done, ctxt)
 591   {}
 592
 593   /* opt_pass methods: */
 594   virtual unsigned int execute (function *) { return tree_ssa_loop_done (); }
 595
 596 }; // class pass_tree_loop_done
 597
 598 } // anon namespace
 599
 600 gimple_opt_pass *
 601 make_pass_tree_loop_done (gcc::context *ctxt)
 602 {
 603   return new pass_tree_loop_done (ctxt);
 604 }
 605
 606 /* Calls CBCK for each index in memory reference ADDR_P.  There are two
 607    kinds situations handled; in each of these cases, the memory reference
 608    and DATA are passed to the callback:
 609
 610    Access to an array: ARRAY_{RANGE_}REF (base, index).  In this case we also
 611    pass the pointer to the index to the callback.
 612
 613    Pointer dereference: INDIRECT_REF (addr).  In this case we also pass the
 614    pointer to addr to the callback.
 615
 616    If the callback returns false, the whole search stops and false is returned.
 617    Otherwise the function returns true after traversing through the whole
 618    reference *ADDR_P.  */
 619
 620 bool
 621 for_each_index (tree *addr_p, bool (*cbck) (tree, tree *, void *), void *data)
 622 {
 623   tree *nxt, *idx;
 624
 625   for (; ; addr_p = nxt)
 626     {
 627       switch (TREE_CODE (*addr_p))
 628         {
 629         case SSA_NAME:
 630           return cbck (*addr_p, addr_p, data);
 631
 632         case MEM_REF:
 633           nxt = &TREE_OPERAND (*addr_p, 0);
 634           return cbck (*addr_p, nxt, data);
 635
 636         case BIT_FIELD_REF:
 637         case VIEW_CONVERT_EXPR:
 638         case REALPART_EXPR:
 639         case IMAGPART_EXPR:
 640           nxt = &TREE_OPERAND (*addr_p, 0);
 641           break;
 642
 643         case COMPONENT_REF:
 644           /* If the component has varying offset, it behaves like index
 645              as well.  */
 646           idx = &TREE_OPERAND (*addr_p, 2);
 647           if (*idx
 648               && !cbck (*addr_p, idx, data))
 649             return false;
 650
 651           nxt = &TREE_OPERAND (*addr_p, 0);
 652           break;
 653
 654         case ARRAY_REF:
 655         case ARRAY_RANGE_REF:
 656           nxt = &TREE_OPERAND (*addr_p, 0);
 657           if (!cbck (*addr_p, &TREE_OPERAND (*addr_p, 1), data))
 658             return false;
 659           break;
 660
 661         case VAR_DECL:
 662         case PARM_DECL:
 663         case CONST_DECL:
 664         case STRING_CST:
 665         case RESULT_DECL:
 666         case VECTOR_CST:
 667         case COMPLEX_CST:
 668         case INTEGER_CST:
 669         case REAL_CST:
 670         case FIXED_CST:
 671         case CONSTRUCTOR:
 672           return true;
 673
 674         case ADDR_EXPR:
 675           gcc_assert (is_gimple_min_invariant (*addr_p));
 676           return true;
 677
 678         case TARGET_MEM_REF:
 679           idx = &TMR_BASE (*addr_p);
 680           if (*idx
 681               && !cbck (*addr_p, idx, data))
 682             return false;
 683           idx = &TMR_INDEX (*addr_p);
 684           if (*idx
 685               && !cbck (*addr_p, idx, data))
 686             return false;
 687           idx = &TMR_INDEX2 (*addr_p);
 688           if (*idx
 689               && !cbck (*addr_p, idx, data))
 690             return false;
 691           return true;
 692
 693         default:
 694           gcc_unreachable ();
 695         }
 696     }
 697 }
 698
 699
 700 /* The name and the length of the currently generated variable
 701    for lsm.  */
 702 #define MAX_LSM_NAME_LENGTH 40
 703 static char lsm_tmp_name[MAX_LSM_NAME_LENGTH + 1];
 704 static int lsm_tmp_name_length;
 705
 706 /* Adds S to lsm_tmp_name.  */
 707
 708 static void
 709 lsm_tmp_name_add (const char *s)
 710 {
 711   int l = strlen (s) + lsm_tmp_name_length;
 712   if (l > MAX_LSM_NAME_LENGTH)
 713     return;
 714
 715   strcpy (lsm_tmp_name + lsm_tmp_name_length, s);
 716   lsm_tmp_name_length = l;
 717 }
 718
 719 /* Stores the name for temporary variable that replaces REF to
 720    lsm_tmp_name.  */
 721
 722 static void
 723 gen_lsm_tmp_name (tree ref)
 724 {
 725   const char *name;
 726
 727   switch (TREE_CODE (ref))
 728     {
 729     case MEM_REF:
 730     case TARGET_MEM_REF:
 731       gen_lsm_tmp_name (TREE_OPERAND (ref, 0));
 732       lsm_tmp_name_add ("_");
 733       break;
 734
 735     case ADDR_EXPR:
 736       gen_lsm_tmp_name (TREE_OPERAND (ref, 0));
 737       break;
 738
 739     case BIT_FIELD_REF:
 740     case VIEW_CONVERT_EXPR:
 741     case ARRAY_RANGE_REF:
 742       gen_lsm_tmp_name (TREE_OPERAND (ref, 0));
 743       break;
 744
 745     case REALPART_EXPR:
 746       gen_lsm_tmp_name (TREE_OPERAND (ref, 0));
 747       lsm_tmp_name_add ("_RE");
 748       break;
 749
 750     case IMAGPART_EXPR:
 751       gen_lsm_tmp_name (TREE_OPERAND (ref, 0));
 752       lsm_tmp_name_add ("_IM");
 753       break;
 754
 755     case COMPONENT_REF:
 756       gen_lsm_tmp_name (TREE_OPERAND (ref, 0));
 757       lsm_tmp_name_add ("_");
 758       name = get_name (TREE_OPERAND (ref, 1));
 759       if (!name)
 760         name = "F";
 761       lsm_tmp_name_add (name);
 762       break;
 763
 764     case ARRAY_REF:
 765       gen_lsm_tmp_name (TREE_OPERAND (ref, 0));
 766       lsm_tmp_name_add ("_I");
 767       break;
 768
 769     case SSA_NAME:
 770     case VAR_DECL:
 771     case PARM_DECL:
 772     case FUNCTION_DECL:
 773     case LABEL_DECL:
 774       name = get_name (ref);
 775       if (!name)
 776         name = "D";
 777       lsm_tmp_name_add (name);
 778       break;
 779
 780     case STRING_CST:
 781       lsm_tmp_name_add ("S");
 782       break;
 783
 784     case RESULT_DECL:
 785       lsm_tmp_name_add ("R");
 786       break;
 787
 788     case INTEGER_CST:
 789     default:
 790       /* Nothing.  */
 791       break;
 792     }
 793 }
 794
 795 /* Determines name for temporary variable that replaces REF.
 796    The name is accumulated into the lsm_tmp_name variable.
 797    N is added to the name of the temporary.  */
 798
 799 char *
 800 get_lsm_tmp_name (tree ref, unsigned n, const char *suffix)
 801 {
 802   char ns[2];
 803
 804   lsm_tmp_name_length = 0;
 805   gen_lsm_tmp_name (ref);
 806   lsm_tmp_name_add ("_lsm");
 807   if (n < 10)
 808     {
 809       ns[0] = '0' + n;
 810       ns[1] = 0;
 811       lsm_tmp_name_add (ns);
 812     }
 813   return lsm_tmp_name;
 814   if (suffix != NULL)
 815     lsm_tmp_name_add (suffix);
 816 }
 817
 818 /* Computes an estimated number of insns in LOOP, weighted by WEIGHTS.  */
 819
 820 unsigned
 821 tree_num_loop_insns (struct loop *loop, eni_weights *weights)
 822 {
 823   basic_block *body = get_loop_body (loop);
 824   gimple_stmt_iterator gsi;
 825   unsigned size = 0, i;
 826
 827   for (i = 0; i < loop->num_nodes; i++)
 828     for (gsi = gsi_start_bb (body[i]); !gsi_end_p (gsi); gsi_next (&gsi))
 829       size += estimate_num_insns (gsi_stmt (gsi), weights);
 830   free (body);
 831
 832   return size;
 833 }
 834
 835
 836