gcc/tree-vectorizer.c

   1 /* Vectorizer
   2    Copyright (C) 2003-2013 Free Software Foundation, Inc.
   3    Contributed by Dorit Naishlos <dorit@il.ibm.com>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 /* Loop and basic block vectorizer.
  22
  23   This file contains drivers for the three vectorizers:
  24   (1) loop vectorizer (inter-iteration parallelism),
  25   (2) loop-aware SLP (intra-iteration parallelism) (invoked by the loop
  26       vectorizer)
  27   (3) BB vectorizer (out-of-loops), aka SLP
  28
  29   The rest of the vectorizer's code is organized as follows:
  30   - tree-vect-loop.c - loop specific parts such as reductions, etc. These are
  31     used by drivers (1) and (2).
  32   - tree-vect-loop-manip.c - vectorizer's loop control-flow utilities, used by
  33     drivers (1) and (2).
  34   - tree-vect-slp.c - BB vectorization specific analysis and transformation,
  35     used by drivers (2) and (3).
  36   - tree-vect-stmts.c - statements analysis and transformation (used by all).
  37   - tree-vect-data-refs.c - vectorizer specific data-refs analysis and
  38     manipulations (used by all).
  39   - tree-vect-patterns.c - vectorizable code patterns detector (used by all)
  40
  41   Here's a poor attempt at illustrating that:
  42
  43      tree-vectorizer.c:
  44      loop_vect()  loop_aware_slp()  slp_vect()
  45           |        /           \          /
  46           |       /             \        /
  47           tree-vect-loop.c  tree-vect-slp.c
  48                 | \      \  /      /   |
  49                 |  \      \/      /    |
  50                 |   \     /\     /     |
  51                 |    \   /  \   /      |
  52          tree-vect-stmts.c  tree-vect-data-refs.c
  53                        \      /
  54                     tree-vect-patterns.c
  55 */
  56
  57 #include "config.h"
  58 #include "system.h"
  59 #include "coretypes.h"
  60 #include "dumpfile.h"
  61 #include "tm.h"
  62 #include "tree.h"
  63 #include "stor-layout.h"
  64 #include "tree-pretty-print.h"
  65 #include "basic-block.h"
  66 #include "tree-ssa-alias.h"
  67 #include "internal-fn.h"
  68 #include "gimple-expr.h"
  69 #include "is-a.h"
  70 #include "gimple.h"
  71 #include "gimple-iterator.h"
  72 #include "gimple-walk.h"
  73 #include "gimple-ssa.h"
  74 #include "cgraph.h"
  75 #include "tree-phinodes.h"
  76 #include "ssa-iterators.h"
  77 #include "tree-ssa-loop-manip.h"
  78 #include "cfgloop.h"
  79 #include "tree-vectorizer.h"
  80 #include "tree-pass.h"
  81 #include "tree-ssa-propagate.h"
  82 #include "dbgcnt.h"
  83
  84 /* Loop or bb location.  */
  85 source_location vect_location;
  86
  87 /* Vector mapping GIMPLE stmt to stmt_vec_info. */
  88 vec<vec_void_p> stmt_vec_info_vec;
  89 \f
  90 /* For mapping simduid to vectorization factor.  */
  91
  92 struct simduid_to_vf : typed_free_remove<simduid_to_vf>
  93 {
  94   unsigned int simduid;
  95   int vf;
  96
  97   /* hash_table support.  */
  98   typedef simduid_to_vf value_type;
  99   typedef simduid_to_vf compare_type;
 100   static inline hashval_t hash (const value_type *);
 101   static inline int equal (const value_type *, const compare_type *);
 102 };
 103
 104 inline hashval_t
 105 simduid_to_vf::hash (const value_type *p)
 106 {
 107   return p->simduid;
 108 }
 109
 110 inline int
 111 simduid_to_vf::equal (const value_type *p1, const value_type *p2)
 112 {
 113   return p1->simduid == p2->simduid;
 114 }
 115
 116 /* This hash maps the OMP simd array to the corresponding simduid used
 117    to index into it.  Like thus,
 118
 119         _7 = GOMP_SIMD_LANE (simduid.0)
 120         ...
 121         ...
 122         D.1737[_7] = stuff;
 123
 124
 125    This hash maps from the OMP simd array (D.1737[]) to DECL_UID of
 126    simduid.0.  */
 127
 128 struct simd_array_to_simduid : typed_free_remove<simd_array_to_simduid>
 129 {
 130   tree decl;
 131   unsigned int simduid;
 132
 133   /* hash_table support.  */
 134   typedef simd_array_to_simduid value_type;
 135   typedef simd_array_to_simduid compare_type;
 136   static inline hashval_t hash (const value_type *);
 137   static inline int equal (const value_type *, const compare_type *);
 138 };
 139
 140 inline hashval_t
 141 simd_array_to_simduid::hash (const value_type *p)
 142 {
 143   return DECL_UID (p->decl);
 144 }
 145
 146 inline int
 147 simd_array_to_simduid::equal (const value_type *p1, const value_type *p2)
 148 {
 149   return p1->decl == p2->decl;
 150 }
 151
 152 /* Fold IFN_GOMP_SIMD_LANE, IFN_GOMP_SIMD_VF and IFN_GOMP_SIMD_LAST_LANE
 153    into their corresponding constants.  */
 154
 155 static void
 156 adjust_simduid_builtins (hash_table <simduid_to_vf> &htab)
 157 {
 158   basic_block bb;
 159
 160   FOR_EACH_BB (bb)
 161     {
 162       gimple_stmt_iterator i;
 163
 164       for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
 165         {
 166           unsigned int vf = 1;
 167           enum internal_fn ifn;
 168           gimple stmt = gsi_stmt (i);
 169           tree t;
 170           if (!is_gimple_call (stmt)
 171               || !gimple_call_internal_p (stmt))
 172             continue;
 173           ifn = gimple_call_internal_fn (stmt);
 174           switch (ifn)
 175             {
 176             case IFN_GOMP_SIMD_LANE:
 177             case IFN_GOMP_SIMD_VF:
 178             case IFN_GOMP_SIMD_LAST_LANE:
 179               break;
 180             default:
 181               continue;
 182             }
 183           tree arg = gimple_call_arg (stmt, 0);
 184           gcc_assert (arg != NULL_TREE);
 185           gcc_assert (TREE_CODE (arg) == SSA_NAME);
 186           simduid_to_vf *p = NULL, data;
 187           data.simduid = DECL_UID (SSA_NAME_VAR (arg));
 188           if (htab.is_created ())
 189             p = htab.find (&data);
 190           if (p)
 191             vf = p->vf;
 192           switch (ifn)
 193             {
 194             case IFN_GOMP_SIMD_VF:
 195               t = build_int_cst (unsigned_type_node, vf);
 196               break;
 197             case IFN_GOMP_SIMD_LANE:
 198               t = build_int_cst (unsigned_type_node, 0);
 199               break;
 200             case IFN_GOMP_SIMD_LAST_LANE:
 201               t = gimple_call_arg (stmt, 1);
 202               break;
 203             default:
 204               gcc_unreachable ();
 205             }
 206           update_call_from_tree (&i, t);
 207         }
 208     }
 209 }
 210
 211 /* Helper structure for note_simd_array_uses.  */
 212
 213 struct note_simd_array_uses_struct
 214 {
 215   hash_table <simd_array_to_simduid> *htab;
 216   unsigned int simduid;
 217 };
 218
 219 /* Callback for note_simd_array_uses, called through walk_gimple_op.  */
 220
 221 static tree
 222 note_simd_array_uses_cb (tree *tp, int *walk_subtrees, void *data)
 223 {
 224   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
 225   struct note_simd_array_uses_struct *ns
 226     = (struct note_simd_array_uses_struct *) wi->info;
 227
 228   if (TYPE_P (*tp))
 229     *walk_subtrees = 0;
 230   else if (VAR_P (*tp)
 231            && lookup_attribute ("omp simd array", DECL_ATTRIBUTES (*tp))
 232            && DECL_CONTEXT (*tp) == current_function_decl)
 233     {
 234       simd_array_to_simduid data;
 235       if (!ns->htab->is_created ())
 236         ns->htab->create (15);
 237       data.decl = *tp;
 238       data.simduid = ns->simduid;
 239       simd_array_to_simduid **slot = ns->htab->find_slot (&data, INSERT);
 240       if (*slot == NULL)
 241         {
 242           simd_array_to_simduid *p = XNEW (simd_array_to_simduid);
 243           *p = data;
 244           *slot = p;
 245         }
 246       else if ((*slot)->simduid != ns->simduid)
 247         (*slot)->simduid = -1U;
 248       *walk_subtrees = 0;
 249     }
 250   return NULL_TREE;
 251 }
 252
 253 /* Find "omp simd array" temporaries and map them to corresponding
 254    simduid.  */
 255
 256 static void
 257 note_simd_array_uses (hash_table <simd_array_to_simduid> *htab)
 258 {
 259   basic_block bb;
 260   gimple_stmt_iterator gsi;
 261   struct walk_stmt_info wi;
 262   struct note_simd_array_uses_struct ns;
 263
 264   memset (&wi, 0, sizeof (wi));
 265   wi.info = &ns;
 266   ns.htab = htab;
 267
 268   FOR_EACH_BB (bb)
 269     for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 270       {
 271         gimple stmt = gsi_stmt (gsi);
 272         if (!is_gimple_call (stmt) || !gimple_call_internal_p (stmt))
 273           continue;
 274         switch (gimple_call_internal_fn (stmt))
 275           {
 276           case IFN_GOMP_SIMD_LANE:
 277           case IFN_GOMP_SIMD_VF:
 278           case IFN_GOMP_SIMD_LAST_LANE:
 279             break;
 280           default:
 281             continue;
 282           }
 283         tree lhs = gimple_call_lhs (stmt);
 284         if (lhs == NULL_TREE)
 285           continue;
 286         imm_use_iterator use_iter;
 287         gimple use_stmt;
 288         ns.simduid = DECL_UID (SSA_NAME_VAR (gimple_call_arg (stmt, 0)));
 289         FOR_EACH_IMM_USE_STMT (use_stmt, use_iter, lhs)
 290           if (!is_gimple_debug (use_stmt))
 291             walk_gimple_op (use_stmt, note_simd_array_uses_cb, &wi);
 292       }
 293 }
 294 \f
 295 /* A helper function to free data refs.  */
 296
 297 void
 298 vect_destroy_datarefs (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
 299 {
 300   vec<data_reference_p> datarefs;
 301   struct data_reference *dr;
 302   unsigned int i;
 303
 304  if (loop_vinfo)
 305     datarefs = LOOP_VINFO_DATAREFS (loop_vinfo);
 306   else
 307     datarefs = BB_VINFO_DATAREFS (bb_vinfo);
 308
 309   FOR_EACH_VEC_ELT (datarefs, i, dr)
 310     if (dr->aux)
 311       {
 312         free (dr->aux);
 313         dr->aux = NULL;
 314       }
 315
 316   free_data_refs (datarefs);
 317 }
 318
 319
 320 /* Function vectorize_loops.
 321
 322    Entry point to loop vectorization phase.  */
 323
 324 unsigned
 325 vectorize_loops (void)
 326 {
 327   unsigned int i;
 328   unsigned int num_vectorized_loops = 0;
 329   unsigned int vect_loops_num;
 330   struct loop *loop;
 331   hash_table <simduid_to_vf> simduid_to_vf_htab;
 332   hash_table <simd_array_to_simduid> simd_array_to_simduid_htab;
 333
 334   vect_loops_num = number_of_loops (cfun);
 335
 336   /* Bail out if there are no loops.  */
 337   if (vect_loops_num <= 1)
 338     {
 339       if (cfun->has_simduid_loops)
 340         adjust_simduid_builtins (simduid_to_vf_htab);
 341       return 0;
 342     }
 343
 344   if (cfun->has_simduid_loops)
 345     note_simd_array_uses (&simd_array_to_simduid_htab);
 346
 347   init_stmt_vec_info_vec ();
 348
 349   /*  ----------- Analyze loops. -----------  */
 350
 351   /* If some loop was duplicated, it gets bigger number
 352      than all previously defined loops.  This fact allows us to run
 353      only over initial loops skipping newly generated ones.  */
 354   FOR_EACH_LOOP (loop, 0)
 355     if ((flag_tree_loop_vectorize && optimize_loop_nest_for_speed_p (loop))
 356         || loop->force_vect)
 357       {
 358         loop_vec_info loop_vinfo;
 359         vect_location = find_loop_location (loop);
 360         if (LOCATION_LOCUS (vect_location) != UNKNOWN_LOCATION
 361             && dump_enabled_p ())
 362           dump_printf (MSG_NOTE, "\nAnalyzing loop at %s:%d\n",
 363                        LOCATION_FILE (vect_location),
 364                        LOCATION_LINE (vect_location));
 365
 366         loop_vinfo = vect_analyze_loop (loop);
 367         loop->aux = loop_vinfo;
 368
 369         if (!loop_vinfo || !LOOP_VINFO_VECTORIZABLE_P (loop_vinfo))
 370           continue;
 371
 372         if (!dbg_cnt (vect_loop))
 373           break;
 374
 375         if (LOCATION_LOCUS (vect_location) != UNKNOWN_LOCATION
 376             && dump_enabled_p ())
 377           dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
 378                            "loop vectorized\n");
 379         vect_transform_loop (loop_vinfo);
 380         num_vectorized_loops++;
 381         /* Now that the loop has been vectorized, allow it to be unrolled
 382            etc.  */
 383         loop->force_vect = false;
 384
 385         if (loop->simduid)
 386           {
 387             simduid_to_vf *simduid_to_vf_data = XNEW (simduid_to_vf);
 388             if (!simduid_to_vf_htab.is_created ())
 389               simduid_to_vf_htab.create (15);
 390             simduid_to_vf_data->simduid = DECL_UID (loop->simduid);
 391             simduid_to_vf_data->vf = loop_vinfo->vectorization_factor;
 392             *simduid_to_vf_htab.find_slot (simduid_to_vf_data, INSERT)
 393               = simduid_to_vf_data;
 394           }
 395       }
 396
 397   vect_location = UNKNOWN_LOCATION;
 398
 399   statistics_counter_event (cfun, "Vectorized loops", num_vectorized_loops);
 400   if (dump_enabled_p ()
 401       || (num_vectorized_loops > 0 && dump_enabled_p ()))
 402     dump_printf_loc (MSG_NOTE, vect_location,
 403                      "vectorized %u loops in function.\n",
 404                      num_vectorized_loops);
 405
 406   /*  ----------- Finalize. -----------  */
 407
 408   for (i = 1; i < vect_loops_num; i++)
 409     {
 410       loop_vec_info loop_vinfo;
 411
 412       loop = get_loop (cfun, i);
 413       if (!loop)
 414         continue;
 415       loop_vinfo = (loop_vec_info) loop->aux;
 416       destroy_loop_vec_info (loop_vinfo, true);
 417       loop->aux = NULL;
 418     }
 419
 420   free_stmt_vec_info_vec ();
 421
 422   /* Fold IFN_GOMP_SIMD_{VF,LANE,LAST_LANE} builtins.  */
 423   if (cfun->has_simduid_loops)
 424     adjust_simduid_builtins (simduid_to_vf_htab);
 425
 426   /* Shrink any "omp array simd" temporary arrays to the
 427      actual vectorization factors.  */
 428   if (simd_array_to_simduid_htab.is_created ())
 429     {
 430       for (hash_table <simd_array_to_simduid>::iterator iter
 431            = simd_array_to_simduid_htab.begin ();
 432            iter != simd_array_to_simduid_htab.end (); ++iter)
 433         if ((*iter).simduid != -1U)
 434           {
 435             tree decl = (*iter).decl;
 436             int vf = 1;
 437             if (simduid_to_vf_htab.is_created ())
 438               {
 439                 simduid_to_vf *p = NULL, data;
 440                 data.simduid = (*iter).simduid;
 441                 p = simduid_to_vf_htab.find (&data);
 442                 if (p)
 443                   vf = p->vf;
 444               }
 445             tree atype
 446               = build_array_type_nelts (TREE_TYPE (TREE_TYPE (decl)), vf);
 447             TREE_TYPE (decl) = atype;
 448             relayout_decl (decl);
 449           }
 450
 451       simd_array_to_simduid_htab.dispose ();
 452     }
 453   if (simduid_to_vf_htab.is_created ())
 454     simduid_to_vf_htab.dispose ();
 455
 456   if (num_vectorized_loops > 0)
 457     {
 458       /* If we vectorized any loop only virtual SSA form needs to be updated.
 459          ???  Also while we try hard to update loop-closed SSA form we fail
 460          to properly do this in some corner-cases (see PR56286).  */
 461       rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa_only_virtuals);
 462       return TODO_cleanup_cfg;
 463     }
 464
 465   return 0;
 466 }
 467
 468
 469 /*  Entry point to basic block SLP phase.  */
 470
 471 static unsigned int
 472 execute_vect_slp (void)
 473 {
 474   basic_block bb;
 475
 476   init_stmt_vec_info_vec ();
 477
 478   FOR_EACH_BB (bb)
 479     {
 480       vect_location = find_bb_location (bb);
 481
 482       if (vect_slp_analyze_bb (bb))
 483         {
 484           if (!dbg_cnt (vect_slp))
 485             break;
 486
 487           vect_slp_transform_bb (bb);
 488           if (dump_enabled_p ())
 489             dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
 490                              "basic block vectorized\n");
 491         }
 492     }
 493
 494   free_stmt_vec_info_vec ();
 495   return 0;
 496 }
 497
 498 static bool
 499 gate_vect_slp (void)
 500 {
 501   return flag_tree_slp_vectorize != 0;
 502 }
 503
 504 namespace {
 505
 506 const pass_data pass_data_slp_vectorize =
 507 {
 508   GIMPLE_PASS, /* type */
 509   "slp", /* name */
 510   OPTGROUP_LOOP | OPTGROUP_VEC, /* optinfo_flags */
 511   true, /* has_gate */
 512   true, /* has_execute */
 513   TV_TREE_SLP_VECTORIZATION, /* tv_id */
 514   ( PROP_ssa | PROP_cfg ), /* properties_required */
 515   0, /* properties_provided */
 516   0, /* properties_destroyed */
 517   0, /* todo_flags_start */
 518   ( TODO_verify_ssa | TODO_update_ssa
 519     | TODO_verify_stmts ), /* todo_flags_finish */
 520 };
 521
 522 class pass_slp_vectorize : public gimple_opt_pass
 523 {
 524 public:
 525   pass_slp_vectorize (gcc::context *ctxt)
 526     : gimple_opt_pass (pass_data_slp_vectorize, ctxt)
 527   {}
 528
 529   /* opt_pass methods: */
 530   bool gate () { return gate_vect_slp (); }
 531   unsigned int execute () { return execute_vect_slp (); }
 532
 533 }; // class pass_slp_vectorize
 534
 535 } // anon namespace
 536
 537 gimple_opt_pass *
 538 make_pass_slp_vectorize (gcc::context *ctxt)
 539 {
 540   return new pass_slp_vectorize (ctxt);
 541 }
 542
 543
 544 /* Increase alignment of global arrays to improve vectorization potential.
 545    TODO:
 546    - Consider also structs that have an array field.
 547    - Use ipa analysis to prune arrays that can't be vectorized?
 548      This should involve global alignment analysis and in the future also
 549      array padding.  */
 550
 551 static unsigned int
 552 increase_alignment (void)
 553 {
 554   struct varpool_node *vnode;
 555
 556   vect_location = UNKNOWN_LOCATION;
 557
 558   /* Increase the alignment of all global arrays for vectorization.  */
 559   FOR_EACH_DEFINED_VARIABLE (vnode)
 560     {
 561       tree vectype, decl = vnode->decl;
 562       tree t;
 563       unsigned int alignment;
 564
 565       t = TREE_TYPE (decl);
 566       if (TREE_CODE (t) != ARRAY_TYPE)
 567         continue;
 568       vectype = get_vectype_for_scalar_type (strip_array_types (t));
 569       if (!vectype)
 570         continue;
 571       alignment = TYPE_ALIGN (vectype);
 572       if (DECL_ALIGN (decl) >= alignment)
 573         continue;
 574
 575       if (vect_can_force_dr_alignment_p (decl, alignment))
 576         {
 577           DECL_ALIGN (decl) = TYPE_ALIGN (vectype);
 578           DECL_USER_ALIGN (decl) = 1;
 579           dump_printf (MSG_NOTE, "Increasing alignment of decl: ");
 580           dump_generic_expr (MSG_NOTE, TDF_SLIM, decl);
 581           dump_printf (MSG_NOTE, "\n");
 582         }
 583     }
 584   return 0;
 585 }
 586
 587
 588 static bool
 589 gate_increase_alignment (void)
 590 {
 591   return flag_section_anchors && flag_tree_loop_vectorize;
 592 }
 593
 594
 595 namespace {
 596
 597 const pass_data pass_data_ipa_increase_alignment =
 598 {
 599   SIMPLE_IPA_PASS, /* type */
 600   "increase_alignment", /* name */
 601   OPTGROUP_LOOP | OPTGROUP_VEC, /* optinfo_flags */
 602   true, /* has_gate */
 603   true, /* has_execute */
 604   TV_IPA_OPT, /* tv_id */
 605   0, /* properties_required */
 606   0, /* properties_provided */
 607   0, /* properties_destroyed */
 608   0, /* todo_flags_start */
 609   0, /* todo_flags_finish */
 610 };
 611
 612 class pass_ipa_increase_alignment : public simple_ipa_opt_pass
 613 {
 614 public:
 615   pass_ipa_increase_alignment (gcc::context *ctxt)
 616     : simple_ipa_opt_pass (pass_data_ipa_increase_alignment, ctxt)
 617   {}
 618
 619   /* opt_pass methods: */
 620   bool gate () { return gate_increase_alignment (); }
 621   unsigned int execute () { return increase_alignment (); }
 622
 623 }; // class pass_ipa_increase_alignment
 624
 625 } // anon namespace
 626
 627 simple_ipa_opt_pass *
 628 make_pass_ipa_increase_alignment (gcc::context *ctxt)
 629 {
 630   return new pass_ipa_increase_alignment (ctxt);
 631 }