gcc/tree-vectorizer.c

   1 /* Vectorizer
   2    Copyright (C) 2003-2014 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 "tree-cfg.h"
  79 #include "cfgloop.h"
  80 #include "tree-vectorizer.h"
  81 #include "tree-pass.h"
  82 #include "tree-ssa-propagate.h"
  83 #include "dbgcnt.h"
  84 #include "gimple-fold.h"
  85
  86 /* Loop or bb location.  */
  87 source_location vect_location;
  88
  89 /* Vector mapping GIMPLE stmt to stmt_vec_info. */
  90 vec<vec_void_p> stmt_vec_info_vec;
  91 \f
  92 /* For mapping simduid to vectorization factor.  */
  93
  94 struct simduid_to_vf : typed_free_remove<simduid_to_vf>
  95 {
  96   unsigned int simduid;
  97   int vf;
  98
  99   /* hash_table support.  */
 100   typedef simduid_to_vf value_type;
 101   typedef simduid_to_vf compare_type;
 102   static inline hashval_t hash (const value_type *);
 103   static inline int equal (const value_type *, const compare_type *);
 104 };
 105
 106 inline hashval_t
 107 simduid_to_vf::hash (const value_type *p)
 108 {
 109   return p->simduid;
 110 }
 111
 112 inline int
 113 simduid_to_vf::equal (const value_type *p1, const value_type *p2)
 114 {
 115   return p1->simduid == p2->simduid;
 116 }
 117
 118 /* This hash maps the OMP simd array to the corresponding simduid used
 119    to index into it.  Like thus,
 120
 121         _7 = GOMP_SIMD_LANE (simduid.0)
 122         ...
 123         ...
 124         D.1737[_7] = stuff;
 125
 126
 127    This hash maps from the OMP simd array (D.1737[]) to DECL_UID of
 128    simduid.0.  */
 129
 130 struct simd_array_to_simduid : typed_free_remove<simd_array_to_simduid>
 131 {
 132   tree decl;
 133   unsigned int simduid;
 134
 135   /* hash_table support.  */
 136   typedef simd_array_to_simduid value_type;
 137   typedef simd_array_to_simduid compare_type;
 138   static inline hashval_t hash (const value_type *);
 139   static inline int equal (const value_type *, const compare_type *);
 140 };
 141
 142 inline hashval_t
 143 simd_array_to_simduid::hash (const value_type *p)
 144 {
 145   return DECL_UID (p->decl);
 146 }
 147
 148 inline int
 149 simd_array_to_simduid::equal (const value_type *p1, const value_type *p2)
 150 {
 151   return p1->decl == p2->decl;
 152 }
 153
 154 /* Fold IFN_GOMP_SIMD_LANE, IFN_GOMP_SIMD_VF and IFN_GOMP_SIMD_LAST_LANE
 155    into their corresponding constants.  */
 156
 157 static void
 158 adjust_simduid_builtins (hash_table <simduid_to_vf> &htab)
 159 {
 160   basic_block bb;
 161
 162   FOR_EACH_BB_FN (bb, cfun)
 163     {
 164       gimple_stmt_iterator i;
 165
 166       for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
 167         {
 168           unsigned int vf = 1;
 169           enum internal_fn ifn;
 170           gimple stmt = gsi_stmt (i);
 171           tree t;
 172           if (!is_gimple_call (stmt)
 173               || !gimple_call_internal_p (stmt))
 174             continue;
 175           ifn = gimple_call_internal_fn (stmt);
 176           switch (ifn)
 177             {
 178             case IFN_GOMP_SIMD_LANE:
 179             case IFN_GOMP_SIMD_VF:
 180             case IFN_GOMP_SIMD_LAST_LANE:
 181               break;
 182             default:
 183               continue;
 184             }
 185           tree arg = gimple_call_arg (stmt, 0);
 186           gcc_assert (arg != NULL_TREE);
 187           gcc_assert (TREE_CODE (arg) == SSA_NAME);
 188           simduid_to_vf *p = NULL, data;
 189           data.simduid = DECL_UID (SSA_NAME_VAR (arg));
 190           if (htab.is_created ())
 191             p = htab.find (&data);
 192           if (p)
 193             vf = p->vf;
 194           switch (ifn)
 195             {
 196             case IFN_GOMP_SIMD_VF:
 197               t = build_int_cst (unsigned_type_node, vf);
 198               break;
 199             case IFN_GOMP_SIMD_LANE:
 200               t = build_int_cst (unsigned_type_node, 0);
 201               break;
 202             case IFN_GOMP_SIMD_LAST_LANE:
 203               t = gimple_call_arg (stmt, 1);
 204               break;
 205             default:
 206               gcc_unreachable ();
 207             }
 208           update_call_from_tree (&i, t);
 209         }
 210     }
 211 }
 212
 213 /* Helper structure for note_simd_array_uses.  */
 214
 215 struct note_simd_array_uses_struct
 216 {
 217   hash_table <simd_array_to_simduid> *htab;
 218   unsigned int simduid;
 219 };
 220
 221 /* Callback for note_simd_array_uses, called through walk_gimple_op.  */
 222
 223 static tree
 224 note_simd_array_uses_cb (tree *tp, int *walk_subtrees, void *data)
 225 {
 226   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
 227   struct note_simd_array_uses_struct *ns
 228     = (struct note_simd_array_uses_struct *) wi->info;
 229
 230   if (TYPE_P (*tp))
 231     *walk_subtrees = 0;
 232   else if (VAR_P (*tp)
 233            && lookup_attribute ("omp simd array", DECL_ATTRIBUTES (*tp))
 234            && DECL_CONTEXT (*tp) == current_function_decl)
 235     {
 236       simd_array_to_simduid data;
 237       if (!ns->htab->is_created ())
 238         ns->htab->create (15);
 239       data.decl = *tp;
 240       data.simduid = ns->simduid;
 241       simd_array_to_simduid **slot = ns->htab->find_slot (&data, INSERT);
 242       if (*slot == NULL)
 243         {
 244           simd_array_to_simduid *p = XNEW (simd_array_to_simduid);
 245           *p = data;
 246           *slot = p;
 247         }
 248       else if ((*slot)->simduid != ns->simduid)
 249         (*slot)->simduid = -1U;
 250       *walk_subtrees = 0;
 251     }
 252   return NULL_TREE;
 253 }
 254
 255 /* Find "omp simd array" temporaries and map them to corresponding
 256    simduid.  */
 257
 258 static void
 259 note_simd_array_uses (hash_table <simd_array_to_simduid> *htab)
 260 {
 261   basic_block bb;
 262   gimple_stmt_iterator gsi;
 263   struct walk_stmt_info wi;
 264   struct note_simd_array_uses_struct ns;
 265
 266   memset (&wi, 0, sizeof (wi));
 267   wi.info = &ns;
 268   ns.htab = htab;
 269
 270   FOR_EACH_BB_FN (bb, cfun)
 271     for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 272       {
 273         gimple stmt = gsi_stmt (gsi);
 274         if (!is_gimple_call (stmt) || !gimple_call_internal_p (stmt))
 275           continue;
 276         switch (gimple_call_internal_fn (stmt))
 277           {
 278           case IFN_GOMP_SIMD_LANE:
 279           case IFN_GOMP_SIMD_VF:
 280           case IFN_GOMP_SIMD_LAST_LANE:
 281             break;
 282           default:
 283             continue;
 284           }
 285         tree lhs = gimple_call_lhs (stmt);
 286         if (lhs == NULL_TREE)
 287           continue;
 288         imm_use_iterator use_iter;
 289         gimple use_stmt;
 290         ns.simduid = DECL_UID (SSA_NAME_VAR (gimple_call_arg (stmt, 0)));
 291         FOR_EACH_IMM_USE_STMT (use_stmt, use_iter, lhs)
 292           if (!is_gimple_debug (use_stmt))
 293             walk_gimple_op (use_stmt, note_simd_array_uses_cb, &wi);
 294       }
 295 }
 296 \f
 297 /* A helper function to free data refs.  */
 298
 299 void
 300 vect_destroy_datarefs (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
 301 {
 302   vec<data_reference_p> datarefs;
 303   struct data_reference *dr;
 304   unsigned int i;
 305
 306  if (loop_vinfo)
 307     datarefs = LOOP_VINFO_DATAREFS (loop_vinfo);
 308   else
 309     datarefs = BB_VINFO_DATAREFS (bb_vinfo);
 310
 311   FOR_EACH_VEC_ELT (datarefs, i, dr)
 312     if (dr->aux)
 313       {
 314         free (dr->aux);
 315         dr->aux = NULL;
 316       }
 317
 318   free_data_refs (datarefs);
 319 }
 320
 321
 322 /* If LOOP has been versioned during ifcvt, return the internal call
 323    guarding it.  */
 324
 325 static gimple
 326 vect_loop_vectorized_call (struct loop *loop)
 327 {
 328   basic_block bb = loop_preheader_edge (loop)->src;
 329   gimple g;
 330   do
 331     {
 332       g = last_stmt (bb);
 333       if (g)
 334         break;
 335       if (!single_pred_p (bb))
 336         break;
 337       bb = single_pred (bb);
 338     }
 339   while (1);
 340   if (g && gimple_code (g) == GIMPLE_COND)
 341     {
 342       gimple_stmt_iterator gsi = gsi_for_stmt (g);
 343       gsi_prev (&gsi);
 344       if (!gsi_end_p (gsi))
 345         {
 346           g = gsi_stmt (gsi);
 347           if (is_gimple_call (g)
 348               && gimple_call_internal_p (g)
 349               && gimple_call_internal_fn (g) == IFN_LOOP_VECTORIZED
 350               && (tree_to_shwi (gimple_call_arg (g, 0)) == loop->num
 351                   || tree_to_shwi (gimple_call_arg (g, 1)) == loop->num))
 352             return g;
 353         }
 354     }
 355   return NULL;
 356 }
 357
 358 /* Fold LOOP_VECTORIZED internal call G to VALUE and
 359    update any immediate uses of it's LHS.  */
 360
 361 static void
 362 fold_loop_vectorized_call (gimple g, tree value)
 363 {
 364   tree lhs = gimple_call_lhs (g);
 365   use_operand_p use_p;
 366   imm_use_iterator iter;
 367   gimple use_stmt;
 368   gimple_stmt_iterator gsi = gsi_for_stmt (g);
 369
 370   update_call_from_tree (&gsi, value);
 371   FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
 372     {
 373       FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
 374         SET_USE (use_p, value);
 375       update_stmt (use_stmt);
 376     }
 377 }
 378
 379 /* Function vectorize_loops.
 380
 381    Entry point to loop vectorization phase.  */
 382
 383 unsigned
 384 vectorize_loops (void)
 385 {
 386   unsigned int i;
 387   unsigned int num_vectorized_loops = 0;
 388   unsigned int vect_loops_num;
 389   struct loop *loop;
 390   hash_table <simduid_to_vf> simduid_to_vf_htab;
 391   hash_table <simd_array_to_simduid> simd_array_to_simduid_htab;
 392   bool any_ifcvt_loops = false;
 393   unsigned ret = 0;
 394
 395   vect_loops_num = number_of_loops (cfun);
 396
 397   /* Bail out if there are no loops.  */
 398   if (vect_loops_num <= 1)
 399     {
 400       if (cfun->has_simduid_loops)
 401         adjust_simduid_builtins (simduid_to_vf_htab);
 402       return 0;
 403     }
 404
 405   if (cfun->has_simduid_loops)
 406     note_simd_array_uses (&simd_array_to_simduid_htab);
 407
 408   init_stmt_vec_info_vec ();
 409
 410   /*  ----------- Analyze loops. -----------  */
 411
 412   /* If some loop was duplicated, it gets bigger number
 413      than all previously defined loops.  This fact allows us to run
 414      only over initial loops skipping newly generated ones.  */
 415   FOR_EACH_LOOP (loop, 0)
 416     if (loop->dont_vectorize)
 417       any_ifcvt_loops = true;
 418     else if ((flag_tree_loop_vectorize
 419               && optimize_loop_nest_for_speed_p (loop))
 420              || loop->force_vect)
 421       {
 422         loop_vec_info loop_vinfo;
 423         vect_location = find_loop_location (loop);
 424         if (LOCATION_LOCUS (vect_location) != UNKNOWN_LOCATION
 425             && dump_enabled_p ())
 426           dump_printf (MSG_NOTE, "\nAnalyzing loop at %s:%d\n",
 427                        LOCATION_FILE (vect_location),
 428                        LOCATION_LINE (vect_location));
 429
 430         loop_vinfo = vect_analyze_loop (loop);
 431         loop->aux = loop_vinfo;
 432
 433         if (!loop_vinfo || !LOOP_VINFO_VECTORIZABLE_P (loop_vinfo))
 434           continue;
 435
 436         if (!dbg_cnt (vect_loop))
 437           break;
 438
 439         gimple loop_vectorized_call = vect_loop_vectorized_call (loop);
 440         if (loop_vectorized_call)
 441           {
 442             tree arg = gimple_call_arg (loop_vectorized_call, 1);
 443             basic_block *bbs;
 444             unsigned int i;
 445             struct loop *scalar_loop = get_loop (cfun, tree_to_shwi (arg));
 446
 447             LOOP_VINFO_SCALAR_LOOP (loop_vinfo) = scalar_loop;
 448             gcc_checking_assert (vect_loop_vectorized_call
 449                                         (LOOP_VINFO_SCALAR_LOOP (loop_vinfo))
 450                                  == loop_vectorized_call);
 451             bbs = get_loop_body (scalar_loop);
 452             for (i = 0; i < scalar_loop->num_nodes; i++)
 453               {
 454                 basic_block bb = bbs[i];
 455                 gimple_stmt_iterator gsi;
 456                 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
 457                      gsi_next (&gsi))
 458                   {
 459                     gimple phi = gsi_stmt (gsi);
 460                     gimple_set_uid (phi, 0);
 461                   }
 462                 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
 463                      gsi_next (&gsi))
 464                   {
 465                     gimple stmt = gsi_stmt (gsi);
 466                     gimple_set_uid (stmt, 0);
 467                   }
 468               }
 469             free (bbs);
 470           }
 471
 472         if (LOCATION_LOCUS (vect_location) != UNKNOWN_LOCATION
 473             && dump_enabled_p ())
 474           dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
 475                            "loop vectorized\n");
 476         vect_transform_loop (loop_vinfo);
 477         num_vectorized_loops++;
 478         /* Now that the loop has been vectorized, allow it to be unrolled
 479            etc.  */
 480         loop->force_vect = false;
 481
 482         if (loop->simduid)
 483           {
 484             simduid_to_vf *simduid_to_vf_data = XNEW (simduid_to_vf);
 485             if (!simduid_to_vf_htab.is_created ())
 486               simduid_to_vf_htab.create (15);
 487             simduid_to_vf_data->simduid = DECL_UID (loop->simduid);
 488             simduid_to_vf_data->vf = loop_vinfo->vectorization_factor;
 489             *simduid_to_vf_htab.find_slot (simduid_to_vf_data, INSERT)
 490               = simduid_to_vf_data;
 491           }
 492
 493         if (loop_vectorized_call)
 494           {
 495             fold_loop_vectorized_call (loop_vectorized_call, boolean_true_node);
 496             ret |= TODO_cleanup_cfg;
 497           }
 498       }
 499
 500   vect_location = UNKNOWN_LOCATION;
 501
 502   statistics_counter_event (cfun, "Vectorized loops", num_vectorized_loops);
 503   if (dump_enabled_p ()
 504       || (num_vectorized_loops > 0 && dump_enabled_p ()))
 505     dump_printf_loc (MSG_NOTE, vect_location,
 506                      "vectorized %u loops in function.\n",
 507                      num_vectorized_loops);
 508
 509   /*  ----------- Finalize. -----------  */
 510
 511   if (any_ifcvt_loops)
 512     for (i = 1; i < vect_loops_num; i++)
 513       {
 514         loop = get_loop (cfun, i);
 515         if (loop && loop->dont_vectorize)
 516           {
 517             gimple g = vect_loop_vectorized_call (loop);
 518             if (g)
 519               {
 520                 fold_loop_vectorized_call (g, boolean_false_node);
 521                 ret |= TODO_cleanup_cfg;
 522               }
 523           }
 524       }
 525
 526   for (i = 1; i < vect_loops_num; i++)
 527     {
 528       loop_vec_info loop_vinfo;
 529
 530       loop = get_loop (cfun, i);
 531       if (!loop)
 532         continue;
 533       loop_vinfo = (loop_vec_info) loop->aux;
 534       destroy_loop_vec_info (loop_vinfo, true);
 535       loop->aux = NULL;
 536     }
 537
 538   free_stmt_vec_info_vec ();
 539
 540   /* Fold IFN_GOMP_SIMD_{VF,LANE,LAST_LANE} builtins.  */
 541   if (cfun->has_simduid_loops)
 542     adjust_simduid_builtins (simduid_to_vf_htab);
 543
 544   /* Shrink any "omp array simd" temporary arrays to the
 545      actual vectorization factors.  */
 546   if (simd_array_to_simduid_htab.is_created ())
 547     {
 548       for (hash_table <simd_array_to_simduid>::iterator iter
 549            = simd_array_to_simduid_htab.begin ();
 550            iter != simd_array_to_simduid_htab.end (); ++iter)
 551         if ((*iter).simduid != -1U)
 552           {
 553             tree decl = (*iter).decl;
 554             int vf = 1;
 555             if (simduid_to_vf_htab.is_created ())
 556               {
 557                 simduid_to_vf *p = NULL, data;
 558                 data.simduid = (*iter).simduid;
 559                 p = simduid_to_vf_htab.find (&data);
 560                 if (p)
 561                   vf = p->vf;
 562               }
 563             tree atype
 564               = build_array_type_nelts (TREE_TYPE (TREE_TYPE (decl)), vf);
 565             TREE_TYPE (decl) = atype;
 566             relayout_decl (decl);
 567           }
 568
 569       simd_array_to_simduid_htab.dispose ();
 570     }
 571   if (simduid_to_vf_htab.is_created ())
 572     simduid_to_vf_htab.dispose ();
 573
 574   if (num_vectorized_loops > 0)
 575     {
 576       /* If we vectorized any loop only virtual SSA form needs to be updated.
 577          ???  Also while we try hard to update loop-closed SSA form we fail
 578          to properly do this in some corner-cases (see PR56286).  */
 579       rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa_only_virtuals);
 580       return TODO_cleanup_cfg;
 581     }
 582
 583   return ret;
 584 }
 585
 586
 587 /*  Entry point to basic block SLP phase.  */
 588
 589 static unsigned int
 590 execute_vect_slp (void)
 591 {
 592   basic_block bb;
 593
 594   init_stmt_vec_info_vec ();
 595
 596   FOR_EACH_BB_FN (bb, cfun)
 597     {
 598       vect_location = find_bb_location (bb);
 599
 600       if (vect_slp_analyze_bb (bb))
 601         {
 602           if (!dbg_cnt (vect_slp))
 603             break;
 604
 605           vect_slp_transform_bb (bb);
 606           if (dump_enabled_p ())
 607             dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
 608                              "basic block vectorized\n");
 609         }
 610     }
 611
 612   free_stmt_vec_info_vec ();
 613   return 0;
 614 }
 615
 616 static bool
 617 gate_vect_slp (void)
 618 {
 619   return flag_tree_slp_vectorize != 0;
 620 }
 621
 622 namespace {
 623
 624 const pass_data pass_data_slp_vectorize =
 625 {
 626   GIMPLE_PASS, /* type */
 627   "slp", /* name */
 628   OPTGROUP_LOOP | OPTGROUP_VEC, /* optinfo_flags */
 629   true, /* has_gate */
 630   true, /* has_execute */
 631   TV_TREE_SLP_VECTORIZATION, /* tv_id */
 632   ( PROP_ssa | PROP_cfg ), /* properties_required */
 633   0, /* properties_provided */
 634   0, /* properties_destroyed */
 635   0, /* todo_flags_start */
 636   ( TODO_verify_ssa | TODO_update_ssa
 637     | TODO_verify_stmts ), /* todo_flags_finish */
 638 };
 639
 640 class pass_slp_vectorize : public gimple_opt_pass
 641 {
 642 public:
 643   pass_slp_vectorize (gcc::context *ctxt)
 644     : gimple_opt_pass (pass_data_slp_vectorize, ctxt)
 645   {}
 646
 647   /* opt_pass methods: */
 648   bool gate () { return gate_vect_slp (); }
 649   unsigned int execute () { return execute_vect_slp (); }
 650
 651 }; // class pass_slp_vectorize
 652
 653 } // anon namespace
 654
 655 gimple_opt_pass *
 656 make_pass_slp_vectorize (gcc::context *ctxt)
 657 {
 658   return new pass_slp_vectorize (ctxt);
 659 }
 660
 661
 662 /* Increase alignment of global arrays to improve vectorization potential.
 663    TODO:
 664    - Consider also structs that have an array field.
 665    - Use ipa analysis to prune arrays that can't be vectorized?
 666      This should involve global alignment analysis and in the future also
 667      array padding.  */
 668
 669 static unsigned int
 670 increase_alignment (void)
 671 {
 672   varpool_node *vnode;
 673
 674   vect_location = UNKNOWN_LOCATION;
 675
 676   /* Increase the alignment of all global arrays for vectorization.  */
 677   FOR_EACH_DEFINED_VARIABLE (vnode)
 678     {
 679       tree vectype, decl = vnode->decl;
 680       tree t;
 681       unsigned int alignment;
 682
 683       t = TREE_TYPE (decl);
 684       if (TREE_CODE (t) != ARRAY_TYPE)
 685         continue;
 686       vectype = get_vectype_for_scalar_type (strip_array_types (t));
 687       if (!vectype)
 688         continue;
 689       alignment = TYPE_ALIGN (vectype);
 690       if (DECL_ALIGN (decl) >= alignment)
 691         continue;
 692
 693       if (vect_can_force_dr_alignment_p (decl, alignment))
 694         {
 695           DECL_ALIGN (decl) = TYPE_ALIGN (vectype);
 696           DECL_USER_ALIGN (decl) = 1;
 697           dump_printf (MSG_NOTE, "Increasing alignment of decl: ");
 698           dump_generic_expr (MSG_NOTE, TDF_SLIM, decl);
 699           dump_printf (MSG_NOTE, "\n");
 700         }
 701     }
 702   return 0;
 703 }
 704
 705
 706 static bool
 707 gate_increase_alignment (void)
 708 {
 709   return flag_section_anchors && flag_tree_loop_vectorize;
 710 }
 711
 712
 713 namespace {
 714
 715 const pass_data pass_data_ipa_increase_alignment =
 716 {
 717   SIMPLE_IPA_PASS, /* type */
 718   "increase_alignment", /* name */
 719   OPTGROUP_LOOP | OPTGROUP_VEC, /* optinfo_flags */
 720   true, /* has_gate */
 721   true, /* has_execute */
 722   TV_IPA_OPT, /* tv_id */
 723   0, /* properties_required */
 724   0, /* properties_provided */
 725   0, /* properties_destroyed */
 726   0, /* todo_flags_start */
 727   0, /* todo_flags_finish */
 728 };
 729
 730 class pass_ipa_increase_alignment : public simple_ipa_opt_pass
 731 {
 732 public:
 733   pass_ipa_increase_alignment (gcc::context *ctxt)
 734     : simple_ipa_opt_pass (pass_data_ipa_increase_alignment, ctxt)
 735   {}
 736
 737   /* opt_pass methods: */
 738   bool gate () { return gate_increase_alignment (); }
 739   unsigned int execute () { return increase_alignment (); }
 740
 741 }; // class pass_ipa_increase_alignment
 742
 743 } // anon namespace
 744
 745 simple_ipa_opt_pass *
 746 make_pass_ipa_increase_alignment (gcc::context *ctxt)
 747 {
 748   return new pass_ipa_increase_alignment (ctxt);
 749 }