gcc/tree-ssa-loop.c

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