* tree.h (TYPE_OVERFLOW_SANITIZED): Define.
[official-gcc.git] / gcc / tree-vectorizer.c
blobdc37d1fc029fa15b63333aa2040ff53ddf153487
1 /* Vectorizer
2 Copyright (C) 2003-2014 Free Software Foundation, Inc.
3 Contributed by Dorit Naishlos <dorit@il.ibm.com>
5 This file is part of GCC.
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.
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.
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/>. */
21 /* Loop and basic block vectorizer.
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
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)
41 Here's a poor attempt at illustrating that:
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
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 "predict.h"
66 #include "vec.h"
67 #include "hashtab.h"
68 #include "hash-set.h"
69 #include "machmode.h"
70 #include "hard-reg-set.h"
71 #include "input.h"
72 #include "function.h"
73 #include "dominance.h"
74 #include "cfg.h"
75 #include "basic-block.h"
76 #include "tree-ssa-alias.h"
77 #include "internal-fn.h"
78 #include "gimple-expr.h"
79 #include "is-a.h"
80 #include "gimple.h"
81 #include "gimple-iterator.h"
82 #include "gimple-walk.h"
83 #include "gimple-ssa.h"
84 #include "hash-map.h"
85 #include "plugin-api.h"
86 #include "ipa-ref.h"
87 #include "cgraph.h"
88 #include "tree-phinodes.h"
89 #include "ssa-iterators.h"
90 #include "tree-ssa-loop-manip.h"
91 #include "tree-cfg.h"
92 #include "cfgloop.h"
93 #include "tree-vectorizer.h"
94 #include "tree-pass.h"
95 #include "tree-ssa-propagate.h"
96 #include "dbgcnt.h"
97 #include "gimple-fold.h"
98 #include "tree-scalar-evolution.h"
101 /* Loop or bb location. */
102 source_location vect_location;
104 /* Vector mapping GIMPLE stmt to stmt_vec_info. */
105 vec<vec_void_p> stmt_vec_info_vec;
107 /* For mapping simduid to vectorization factor. */
109 struct simduid_to_vf : typed_free_remove<simduid_to_vf>
111 unsigned int simduid;
112 int vf;
114 /* hash_table support. */
115 typedef simduid_to_vf value_type;
116 typedef simduid_to_vf compare_type;
117 static inline hashval_t hash (const value_type *);
118 static inline int equal (const value_type *, const compare_type *);
121 inline hashval_t
122 simduid_to_vf::hash (const value_type *p)
124 return p->simduid;
127 inline int
128 simduid_to_vf::equal (const value_type *p1, const value_type *p2)
130 return p1->simduid == p2->simduid;
133 /* This hash maps the OMP simd array to the corresponding simduid used
134 to index into it. Like thus,
136 _7 = GOMP_SIMD_LANE (simduid.0)
139 D.1737[_7] = stuff;
142 This hash maps from the OMP simd array (D.1737[]) to DECL_UID of
143 simduid.0. */
145 struct simd_array_to_simduid : typed_free_remove<simd_array_to_simduid>
147 tree decl;
148 unsigned int simduid;
150 /* hash_table support. */
151 typedef simd_array_to_simduid value_type;
152 typedef simd_array_to_simduid compare_type;
153 static inline hashval_t hash (const value_type *);
154 static inline int equal (const value_type *, const compare_type *);
157 inline hashval_t
158 simd_array_to_simduid::hash (const value_type *p)
160 return DECL_UID (p->decl);
163 inline int
164 simd_array_to_simduid::equal (const value_type *p1, const value_type *p2)
166 return p1->decl == p2->decl;
169 /* Fold IFN_GOMP_SIMD_LANE, IFN_GOMP_SIMD_VF and IFN_GOMP_SIMD_LAST_LANE
170 into their corresponding constants. */
172 static void
173 adjust_simduid_builtins (hash_table<simduid_to_vf> **htab)
175 basic_block bb;
177 FOR_EACH_BB_FN (bb, cfun)
179 gimple_stmt_iterator i;
181 for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
183 unsigned int vf = 1;
184 enum internal_fn ifn;
185 gimple stmt = gsi_stmt (i);
186 tree t;
187 if (!is_gimple_call (stmt)
188 || !gimple_call_internal_p (stmt))
189 continue;
190 ifn = gimple_call_internal_fn (stmt);
191 switch (ifn)
193 case IFN_GOMP_SIMD_LANE:
194 case IFN_GOMP_SIMD_VF:
195 case IFN_GOMP_SIMD_LAST_LANE:
196 break;
197 default:
198 continue;
200 tree arg = gimple_call_arg (stmt, 0);
201 gcc_assert (arg != NULL_TREE);
202 gcc_assert (TREE_CODE (arg) == SSA_NAME);
203 simduid_to_vf *p = NULL, data;
204 data.simduid = DECL_UID (SSA_NAME_VAR (arg));
205 if (*htab)
206 p = (*htab)->find (&data);
207 if (p)
208 vf = p->vf;
209 switch (ifn)
211 case IFN_GOMP_SIMD_VF:
212 t = build_int_cst (unsigned_type_node, vf);
213 break;
214 case IFN_GOMP_SIMD_LANE:
215 t = build_int_cst (unsigned_type_node, 0);
216 break;
217 case IFN_GOMP_SIMD_LAST_LANE:
218 t = gimple_call_arg (stmt, 1);
219 break;
220 default:
221 gcc_unreachable ();
223 update_call_from_tree (&i, t);
228 /* Helper structure for note_simd_array_uses. */
230 struct note_simd_array_uses_struct
232 hash_table<simd_array_to_simduid> **htab;
233 unsigned int simduid;
236 /* Callback for note_simd_array_uses, called through walk_gimple_op. */
238 static tree
239 note_simd_array_uses_cb (tree *tp, int *walk_subtrees, void *data)
241 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
242 struct note_simd_array_uses_struct *ns
243 = (struct note_simd_array_uses_struct *) wi->info;
245 if (TYPE_P (*tp))
246 *walk_subtrees = 0;
247 else if (VAR_P (*tp)
248 && lookup_attribute ("omp simd array", DECL_ATTRIBUTES (*tp))
249 && DECL_CONTEXT (*tp) == current_function_decl)
251 simd_array_to_simduid data;
252 if (!*ns->htab)
253 *ns->htab = new hash_table<simd_array_to_simduid> (15);
254 data.decl = *tp;
255 data.simduid = ns->simduid;
256 simd_array_to_simduid **slot = (*ns->htab)->find_slot (&data, INSERT);
257 if (*slot == NULL)
259 simd_array_to_simduid *p = XNEW (simd_array_to_simduid);
260 *p = data;
261 *slot = p;
263 else if ((*slot)->simduid != ns->simduid)
264 (*slot)->simduid = -1U;
265 *walk_subtrees = 0;
267 return NULL_TREE;
270 /* Find "omp simd array" temporaries and map them to corresponding
271 simduid. */
273 static void
274 note_simd_array_uses (hash_table<simd_array_to_simduid> **htab)
276 basic_block bb;
277 gimple_stmt_iterator gsi;
278 struct walk_stmt_info wi;
279 struct note_simd_array_uses_struct ns;
281 memset (&wi, 0, sizeof (wi));
282 wi.info = &ns;
283 ns.htab = htab;
285 FOR_EACH_BB_FN (bb, cfun)
286 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
288 gimple stmt = gsi_stmt (gsi);
289 if (!is_gimple_call (stmt) || !gimple_call_internal_p (stmt))
290 continue;
291 switch (gimple_call_internal_fn (stmt))
293 case IFN_GOMP_SIMD_LANE:
294 case IFN_GOMP_SIMD_VF:
295 case IFN_GOMP_SIMD_LAST_LANE:
296 break;
297 default:
298 continue;
300 tree lhs = gimple_call_lhs (stmt);
301 if (lhs == NULL_TREE)
302 continue;
303 imm_use_iterator use_iter;
304 gimple use_stmt;
305 ns.simduid = DECL_UID (SSA_NAME_VAR (gimple_call_arg (stmt, 0)));
306 FOR_EACH_IMM_USE_STMT (use_stmt, use_iter, lhs)
307 if (!is_gimple_debug (use_stmt))
308 walk_gimple_op (use_stmt, note_simd_array_uses_cb, &wi);
312 /* A helper function to free data refs. */
314 void
315 vect_destroy_datarefs (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
317 vec<data_reference_p> datarefs;
318 struct data_reference *dr;
319 unsigned int i;
321 if (loop_vinfo)
322 datarefs = LOOP_VINFO_DATAREFS (loop_vinfo);
323 else
324 datarefs = BB_VINFO_DATAREFS (bb_vinfo);
326 FOR_EACH_VEC_ELT (datarefs, i, dr)
327 if (dr->aux)
329 free (dr->aux);
330 dr->aux = NULL;
333 free_data_refs (datarefs);
337 /* If LOOP has been versioned during ifcvt, return the internal call
338 guarding it. */
340 static gimple
341 vect_loop_vectorized_call (struct loop *loop)
343 basic_block bb = loop_preheader_edge (loop)->src;
344 gimple g;
347 g = last_stmt (bb);
348 if (g)
349 break;
350 if (!single_pred_p (bb))
351 break;
352 bb = single_pred (bb);
354 while (1);
355 if (g && gimple_code (g) == GIMPLE_COND)
357 gimple_stmt_iterator gsi = gsi_for_stmt (g);
358 gsi_prev (&gsi);
359 if (!gsi_end_p (gsi))
361 g = gsi_stmt (gsi);
362 if (is_gimple_call (g)
363 && gimple_call_internal_p (g)
364 && gimple_call_internal_fn (g) == IFN_LOOP_VECTORIZED
365 && (tree_to_shwi (gimple_call_arg (g, 0)) == loop->num
366 || tree_to_shwi (gimple_call_arg (g, 1)) == loop->num))
367 return g;
370 return NULL;
373 /* Fold LOOP_VECTORIZED internal call G to VALUE and
374 update any immediate uses of it's LHS. */
376 static void
377 fold_loop_vectorized_call (gimple g, tree value)
379 tree lhs = gimple_call_lhs (g);
380 use_operand_p use_p;
381 imm_use_iterator iter;
382 gimple use_stmt;
383 gimple_stmt_iterator gsi = gsi_for_stmt (g);
385 update_call_from_tree (&gsi, value);
386 FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
388 FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
389 SET_USE (use_p, value);
390 update_stmt (use_stmt);
394 /* Function vectorize_loops.
396 Entry point to loop vectorization phase. */
398 unsigned
399 vectorize_loops (void)
401 unsigned int i;
402 unsigned int num_vectorized_loops = 0;
403 unsigned int vect_loops_num;
404 struct loop *loop;
405 hash_table<simduid_to_vf> *simduid_to_vf_htab = NULL;
406 hash_table<simd_array_to_simduid> *simd_array_to_simduid_htab = NULL;
407 bool any_ifcvt_loops = false;
408 unsigned ret = 0;
410 vect_loops_num = number_of_loops (cfun);
412 /* Bail out if there are no loops. */
413 if (vect_loops_num <= 1)
415 if (cfun->has_simduid_loops)
416 adjust_simduid_builtins (&simduid_to_vf_htab);
417 return 0;
420 if (cfun->has_simduid_loops)
421 note_simd_array_uses (&simd_array_to_simduid_htab);
423 init_stmt_vec_info_vec ();
425 /* ----------- Analyze loops. ----------- */
427 /* If some loop was duplicated, it gets bigger number
428 than all previously defined loops. This fact allows us to run
429 only over initial loops skipping newly generated ones. */
430 FOR_EACH_LOOP (loop, 0)
431 if (loop->dont_vectorize)
432 any_ifcvt_loops = true;
433 else if ((flag_tree_loop_vectorize
434 && optimize_loop_nest_for_speed_p (loop))
435 || loop->force_vectorize)
437 loop_vec_info loop_vinfo;
438 vect_location = find_loop_location (loop);
439 if (LOCATION_LOCUS (vect_location) != UNKNOWN_LOCATION
440 && dump_enabled_p ())
441 dump_printf (MSG_NOTE, "\nAnalyzing loop at %s:%d\n",
442 LOCATION_FILE (vect_location),
443 LOCATION_LINE (vect_location));
445 loop_vinfo = vect_analyze_loop (loop);
446 loop->aux = loop_vinfo;
448 if (!loop_vinfo || !LOOP_VINFO_VECTORIZABLE_P (loop_vinfo))
449 continue;
451 if (!dbg_cnt (vect_loop))
452 break;
454 gimple loop_vectorized_call = vect_loop_vectorized_call (loop);
455 if (loop_vectorized_call)
457 tree arg = gimple_call_arg (loop_vectorized_call, 1);
458 basic_block *bbs;
459 unsigned int i;
460 struct loop *scalar_loop = get_loop (cfun, tree_to_shwi (arg));
462 LOOP_VINFO_SCALAR_LOOP (loop_vinfo) = scalar_loop;
463 gcc_checking_assert (vect_loop_vectorized_call
464 (LOOP_VINFO_SCALAR_LOOP (loop_vinfo))
465 == loop_vectorized_call);
466 bbs = get_loop_body (scalar_loop);
467 for (i = 0; i < scalar_loop->num_nodes; i++)
469 basic_block bb = bbs[i];
470 gimple_stmt_iterator gsi;
471 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
472 gsi_next (&gsi))
474 gimple phi = gsi_stmt (gsi);
475 gimple_set_uid (phi, 0);
477 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
478 gsi_next (&gsi))
480 gimple stmt = gsi_stmt (gsi);
481 gimple_set_uid (stmt, 0);
484 free (bbs);
487 if (LOCATION_LOCUS (vect_location) != UNKNOWN_LOCATION
488 && dump_enabled_p ())
489 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
490 "loop vectorized\n");
491 vect_transform_loop (loop_vinfo);
492 num_vectorized_loops++;
493 /* Now that the loop has been vectorized, allow it to be unrolled
494 etc. */
495 loop->force_vectorize = false;
497 if (loop->simduid)
499 simduid_to_vf *simduid_to_vf_data = XNEW (simduid_to_vf);
500 if (!simduid_to_vf_htab)
501 simduid_to_vf_htab = new hash_table<simduid_to_vf> (15);
502 simduid_to_vf_data->simduid = DECL_UID (loop->simduid);
503 simduid_to_vf_data->vf = loop_vinfo->vectorization_factor;
504 *simduid_to_vf_htab->find_slot (simduid_to_vf_data, INSERT)
505 = simduid_to_vf_data;
508 if (loop_vectorized_call)
510 fold_loop_vectorized_call (loop_vectorized_call, boolean_true_node);
511 ret |= TODO_cleanup_cfg;
515 vect_location = UNKNOWN_LOCATION;
517 statistics_counter_event (cfun, "Vectorized loops", num_vectorized_loops);
518 if (dump_enabled_p ()
519 || (num_vectorized_loops > 0 && dump_enabled_p ()))
520 dump_printf_loc (MSG_NOTE, vect_location,
521 "vectorized %u loops in function.\n",
522 num_vectorized_loops);
524 /* ----------- Finalize. ----------- */
526 if (any_ifcvt_loops)
527 for (i = 1; i < vect_loops_num; i++)
529 loop = get_loop (cfun, i);
530 if (loop && loop->dont_vectorize)
532 gimple g = vect_loop_vectorized_call (loop);
533 if (g)
535 fold_loop_vectorized_call (g, boolean_false_node);
536 ret |= TODO_cleanup_cfg;
541 for (i = 1; i < vect_loops_num; i++)
543 loop_vec_info loop_vinfo;
545 loop = get_loop (cfun, i);
546 if (!loop)
547 continue;
548 loop_vinfo = (loop_vec_info) loop->aux;
549 destroy_loop_vec_info (loop_vinfo, true);
550 loop->aux = NULL;
553 free_stmt_vec_info_vec ();
555 /* Fold IFN_GOMP_SIMD_{VF,LANE,LAST_LANE} builtins. */
556 if (cfun->has_simduid_loops)
557 adjust_simduid_builtins (&simduid_to_vf_htab);
559 /* Shrink any "omp array simd" temporary arrays to the
560 actual vectorization factors. */
561 if (simd_array_to_simduid_htab)
563 for (hash_table<simd_array_to_simduid>::iterator iter
564 = simd_array_to_simduid_htab->begin ();
565 iter != simd_array_to_simduid_htab->end (); ++iter)
566 if ((*iter)->simduid != -1U)
568 tree decl = (*iter)->decl;
569 int vf = 1;
570 if (simduid_to_vf_htab)
572 simduid_to_vf *p = NULL, data;
573 data.simduid = (*iter)->simduid;
574 p = simduid_to_vf_htab->find (&data);
575 if (p)
576 vf = p->vf;
578 tree atype
579 = build_array_type_nelts (TREE_TYPE (TREE_TYPE (decl)), vf);
580 TREE_TYPE (decl) = atype;
581 relayout_decl (decl);
584 delete simd_array_to_simduid_htab;
586 delete simduid_to_vf_htab;
587 simduid_to_vf_htab = NULL;
589 if (num_vectorized_loops > 0)
591 /* If we vectorized any loop only virtual SSA form needs to be updated.
592 ??? Also while we try hard to update loop-closed SSA form we fail
593 to properly do this in some corner-cases (see PR56286). */
594 rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa_only_virtuals);
595 return TODO_cleanup_cfg;
598 return ret;
602 /* Entry point to basic block SLP phase. */
604 namespace {
606 const pass_data pass_data_slp_vectorize =
608 GIMPLE_PASS, /* type */
609 "slp", /* name */
610 OPTGROUP_LOOP | OPTGROUP_VEC, /* optinfo_flags */
611 TV_TREE_SLP_VECTORIZATION, /* tv_id */
612 ( PROP_ssa | PROP_cfg ), /* properties_required */
613 0, /* properties_provided */
614 0, /* properties_destroyed */
615 0, /* todo_flags_start */
616 TODO_update_ssa, /* todo_flags_finish */
619 class pass_slp_vectorize : public gimple_opt_pass
621 public:
622 pass_slp_vectorize (gcc::context *ctxt)
623 : gimple_opt_pass (pass_data_slp_vectorize, ctxt)
626 /* opt_pass methods: */
627 opt_pass * clone () { return new pass_slp_vectorize (m_ctxt); }
628 virtual bool gate (function *) { return flag_tree_slp_vectorize != 0; }
629 virtual unsigned int execute (function *);
631 }; // class pass_slp_vectorize
633 unsigned int
634 pass_slp_vectorize::execute (function *fun)
636 basic_block bb;
638 bool in_loop_pipeline = scev_initialized_p ();
639 if (!in_loop_pipeline)
641 loop_optimizer_init (LOOPS_NORMAL);
642 scev_initialize ();
645 init_stmt_vec_info_vec ();
647 FOR_EACH_BB_FN (bb, fun)
649 vect_location = find_bb_location (bb);
651 if (vect_slp_analyze_bb (bb))
653 if (!dbg_cnt (vect_slp))
654 break;
656 vect_slp_transform_bb (bb);
657 if (dump_enabled_p ())
658 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
659 "basic block vectorized\n");
663 free_stmt_vec_info_vec ();
665 if (!in_loop_pipeline)
667 scev_finalize ();
668 loop_optimizer_finalize ();
671 return 0;
674 } // anon namespace
676 gimple_opt_pass *
677 make_pass_slp_vectorize (gcc::context *ctxt)
679 return new pass_slp_vectorize (ctxt);
683 /* Increase alignment of global arrays to improve vectorization potential.
684 TODO:
685 - Consider also structs that have an array field.
686 - Use ipa analysis to prune arrays that can't be vectorized?
687 This should involve global alignment analysis and in the future also
688 array padding. */
690 static unsigned int
691 increase_alignment (void)
693 varpool_node *vnode;
695 vect_location = UNKNOWN_LOCATION;
697 /* Increase the alignment of all global arrays for vectorization. */
698 FOR_EACH_DEFINED_VARIABLE (vnode)
700 tree vectype, decl = vnode->decl;
701 tree t;
702 unsigned int alignment;
704 t = TREE_TYPE (decl);
705 if (TREE_CODE (t) != ARRAY_TYPE)
706 continue;
707 vectype = get_vectype_for_scalar_type (strip_array_types (t));
708 if (!vectype)
709 continue;
710 alignment = TYPE_ALIGN (vectype);
711 if (DECL_ALIGN (decl) >= alignment)
712 continue;
714 if (vect_can_force_dr_alignment_p (decl, alignment))
716 DECL_ALIGN (decl) = TYPE_ALIGN (vectype);
717 DECL_USER_ALIGN (decl) = 1;
718 if (TREE_STATIC (decl))
720 tree target = symtab_node::get (decl)->ultimate_alias_target ()->decl;
721 DECL_ALIGN (target) = TYPE_ALIGN (vectype);
722 DECL_USER_ALIGN (target) = 1;
724 dump_printf (MSG_NOTE, "Increasing alignment of decl: ");
725 dump_generic_expr (MSG_NOTE, TDF_SLIM, decl);
726 dump_printf (MSG_NOTE, "\n");
729 return 0;
733 namespace {
735 const pass_data pass_data_ipa_increase_alignment =
737 SIMPLE_IPA_PASS, /* type */
738 "increase_alignment", /* name */
739 OPTGROUP_LOOP | OPTGROUP_VEC, /* optinfo_flags */
740 TV_IPA_OPT, /* tv_id */
741 0, /* properties_required */
742 0, /* properties_provided */
743 0, /* properties_destroyed */
744 0, /* todo_flags_start */
745 0, /* todo_flags_finish */
748 class pass_ipa_increase_alignment : public simple_ipa_opt_pass
750 public:
751 pass_ipa_increase_alignment (gcc::context *ctxt)
752 : simple_ipa_opt_pass (pass_data_ipa_increase_alignment, ctxt)
755 /* opt_pass methods: */
756 virtual bool gate (function *)
758 return flag_section_anchors && flag_tree_loop_vectorize;
761 virtual unsigned int execute (function *) { return increase_alignment (); }
763 }; // class pass_ipa_increase_alignment
765 } // anon namespace
767 simple_ipa_opt_pass *
768 make_pass_ipa_increase_alignment (gcc::context *ctxt)
770 return new pass_ipa_increase_alignment (ctxt);