comparison gcc/graphite.c @ 16:04ced10e8804

gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents f6334be47118
children 84e7813d76e9
comparison
equal deleted inserted replaced
15:561a7518be6b 16:04ced10e8804
1 /* Gimple Represented as Polyhedra. 1 /* Gimple Represented as Polyhedra.
2 Copyright (C) 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. 2 Copyright (C) 2006-2017 Free Software Foundation, Inc.
3 Contributed by Sebastian Pop <sebastian.pop@inria.fr>. 3 Contributed by Sebastian Pop <sebastian.pop@inria.fr>.
4 4
5 This file is part of GCC. 5 This file is part of GCC.
6 6
7 GCC is free software; you can redistribute it and/or modify 7 GCC is free software; you can redistribute it and/or modify
23 to GIMPLE. 23 to GIMPLE.
24 24
25 An early description of this pass can be found in the GCC Summit'06 25 An early description of this pass can be found in the GCC Summit'06
26 paper "GRAPHITE: Polyhedral Analyses and Optimizations for GCC". 26 paper "GRAPHITE: Polyhedral Analyses and Optimizations for GCC".
27 The wiki page http://gcc.gnu.org/wiki/Graphite contains pointers to 27 The wiki page http://gcc.gnu.org/wiki/Graphite contains pointers to
28 the related work. 28 the related work. */
29 29
30 One important document to read is CLooG's internal manual: 30 #define USES_ISL
31 http://repo.or.cz/w/cloog-ppl.git?a=blob_plain;f=doc/cloog.texi;hb=HEAD
32 that describes the data structure of loops used in this file, and
33 the functions that are used for transforming the code. */
34 31
35 #include "config.h" 32 #include "config.h"
36 #include "system.h" 33 #include "system.h"
37 #include "coretypes.h" 34 #include "coretypes.h"
35 #include "backend.h"
38 #include "diagnostic-core.h" 36 #include "diagnostic-core.h"
39 #include "tree-flow.h"
40 #include "tree-dump.h"
41 #include "cfgloop.h" 37 #include "cfgloop.h"
42 #include "tree-chrec.h" 38 #include "tree-pass.h"
39 #include "params.h"
40 #include "pretty-print.h"
41
42 #ifdef HAVE_isl
43 #include "cfghooks.h"
44 #include "tree.h"
45 #include "gimple.h"
46 #include "ssa.h"
47 #include "fold-const.h"
48 #include "gimple-iterator.h"
49 #include "tree-cfg.h"
50 #include "tree-ssa-loop.h"
43 #include "tree-data-ref.h" 51 #include "tree-data-ref.h"
44 #include "tree-scalar-evolution.h" 52 #include "tree-scalar-evolution.h"
45 #include "sese.h"
46 #include "dbgcnt.h" 53 #include "dbgcnt.h"
47 54 #include "tree-parloops.h"
48 #ifdef HAVE_cloog 55 #include "tree-cfgcleanup.h"
49 56 #include "tree-vectorizer.h"
50 #include "ppl_c.h" 57 #include "tree-ssa-loop-manip.h"
51 #include "graphite-ppl.h" 58 #include "tree-ssa.h"
52 #include "graphite-poly.h" 59 #include "tree-into-ssa.h"
53 #include "graphite-scop-detection.h" 60 #include "graphite.h"
54 #include "graphite-clast-to-gimple.h"
55 #include "graphite-sese-to-poly.h"
56
57 CloogState *cloog_state;
58 61
59 /* Print global statistics to FILE. */ 62 /* Print global statistics to FILE. */
60 63
61 static void 64 static void
62 print_global_statistics (FILE* file) 65 print_global_statistics (FILE* file)
63 { 66 {
64 long n_bbs = 0; 67 long n_bbs = 0;
65 long n_loops = 0; 68 long n_loops = 0;
66 long n_stmts = 0; 69 long n_stmts = 0;
67 long n_conditions = 0; 70 long n_conditions = 0;
68 long n_p_bbs = 0; 71 profile_count n_p_bbs = profile_count::zero ();
69 long n_p_loops = 0; 72 profile_count n_p_loops = profile_count::zero ();
70 long n_p_stmts = 0; 73 profile_count n_p_stmts = profile_count::zero ();
71 long n_p_conditions = 0; 74 profile_count n_p_conditions = profile_count::zero ();
72 75
73 basic_block bb; 76 basic_block bb;
74 77
75 FOR_ALL_BB (bb) 78 FOR_ALL_BB_FN (bb, cfun)
76 { 79 {
77 gimple_stmt_iterator psi; 80 gimple_stmt_iterator psi;
78 81
79 n_bbs++; 82 n_bbs++;
80 n_p_bbs += bb->count; 83 if (bb->count.initialized_p ())
84 n_p_bbs += bb->count;
81 85
82 /* Ignore artificial surrounding loop. */ 86 /* Ignore artificial surrounding loop. */
83 if (bb == bb->loop_father->header 87 if (bb == bb->loop_father->header
84 && bb->index != 0) 88 && bb->index != 0)
85 { 89 {
86 n_loops++; 90 n_loops++;
87 n_p_loops += bb->count; 91 n_p_loops += bb->count;
88 } 92 }
89 93
90 if (VEC_length (edge, bb->succs) > 1) 94 if (EDGE_COUNT (bb->succs) > 1)
91 { 95 {
92 n_conditions++; 96 n_conditions++;
93 n_p_conditions += bb->count; 97 if (bb->count.initialized_p ())
98 n_p_conditions += bb->count;
94 } 99 }
95 100
96 for (psi = gsi_start_bb (bb); !gsi_end_p (psi); gsi_next (&psi)) 101 for (psi = gsi_start_bb (bb); !gsi_end_p (psi); gsi_next (&psi))
97 { 102 {
98 n_stmts++; 103 n_stmts++;
99 n_p_stmts += bb->count; 104 if (bb->count.initialized_p ())
105 n_p_stmts += bb->count;
100 } 106 }
101 } 107 }
102 108
103 fprintf (file, "\nGlobal statistics ("); 109 fprintf (file, "\nGlobal statistics (");
104 fprintf (file, "BBS:%ld, ", n_bbs); 110 fprintf (file, "BBS:%ld, ", n_bbs);
105 fprintf (file, "LOOPS:%ld, ", n_loops); 111 fprintf (file, "LOOPS:%ld, ", n_loops);
106 fprintf (file, "CONDITIONS:%ld, ", n_conditions); 112 fprintf (file, "CONDITIONS:%ld, ", n_conditions);
107 fprintf (file, "STMTS:%ld)\n", n_stmts); 113 fprintf (file, "STMTS:%ld)\n", n_stmts);
108 fprintf (file, "\nGlobal profiling statistics ("); 114 fprintf (file, "Global profiling statistics (");
109 fprintf (file, "BBS:%ld, ", n_p_bbs); 115 fprintf (file, "BBS:");
110 fprintf (file, "LOOPS:%ld, ", n_p_loops); 116 n_p_bbs.dump (file);
111 fprintf (file, "CONDITIONS:%ld, ", n_p_conditions); 117 fprintf (file, ", LOOPS:");
112 fprintf (file, "STMTS:%ld)\n", n_p_stmts); 118 n_p_loops.dump (file);
119 fprintf (file, ", CONDITIONS:");
120 n_p_conditions.dump (file);
121 fprintf (file, ", STMTS:");
122 n_p_stmts.dump (file);
123 fprintf (file, ")\n\n");
113 } 124 }
114 125
115 /* Print statistics for SCOP to FILE. */ 126 /* Print statistics for SCOP to FILE. */
116 127
117 static void 128 static void
119 { 130 {
120 long n_bbs = 0; 131 long n_bbs = 0;
121 long n_loops = 0; 132 long n_loops = 0;
122 long n_stmts = 0; 133 long n_stmts = 0;
123 long n_conditions = 0; 134 long n_conditions = 0;
124 long n_p_bbs = 0; 135 profile_count n_p_bbs = profile_count::zero ();
125 long n_p_loops = 0; 136 profile_count n_p_loops = profile_count::zero ();
126 long n_p_stmts = 0; 137 profile_count n_p_stmts = profile_count::zero ();
127 long n_p_conditions = 0; 138 profile_count n_p_conditions = profile_count::zero ();
128 139
129 basic_block bb; 140 basic_block bb;
130 141
131 FOR_ALL_BB (bb) 142 FOR_ALL_BB_FN (bb, cfun)
132 { 143 {
133 gimple_stmt_iterator psi; 144 gimple_stmt_iterator psi;
134 loop_p loop = bb->loop_father; 145 loop_p loop = bb->loop_father;
135 146
136 if (!bb_in_sese_p (bb, SCOP_REGION (scop))) 147 if (!bb_in_sese_p (bb, scop->scop_info->region))
137 continue; 148 continue;
138 149
139 n_bbs++; 150 n_bbs++;
140 n_p_bbs += bb->count; 151 if (bb->count.initialized_p ())
141 152 n_p_bbs += bb->count;
142 if (VEC_length (edge, bb->succs) > 1) 153
154 if (EDGE_COUNT (bb->succs) > 1)
143 { 155 {
144 n_conditions++; 156 n_conditions++;
145 n_p_conditions += bb->count; 157 n_p_conditions += bb->count;
146 } 158 }
147 159
149 { 161 {
150 n_stmts++; 162 n_stmts++;
151 n_p_stmts += bb->count; 163 n_p_stmts += bb->count;
152 } 164 }
153 165
154 if (loop->header == bb && loop_in_sese_p (loop, SCOP_REGION (scop))) 166 if (loop->header == bb && loop_in_sese_p (loop, scop->scop_info->region))
155 { 167 {
156 n_loops++; 168 n_loops++;
157 n_p_loops += bb->count; 169 n_p_loops += bb->count;
158 } 170 }
159 } 171 }
172
173 fprintf (file, "\nFunction Name: %s\n", current_function_name ());
174
175 edge scop_begin = scop->scop_info->region.entry;
176 edge scop_end = scop->scop_info->region.exit;
177
178 fprintf (file, "\nSCoP (entry_edge (bb_%d, bb_%d), ",
179 scop_begin->src->index, scop_begin->dest->index);
180 fprintf (file, "exit_edge (bb_%d, bb_%d))",
181 scop_end->src->index, scop_end->dest->index);
160 182
161 fprintf (file, "\nSCoP statistics ("); 183 fprintf (file, "\nSCoP statistics (");
162 fprintf (file, "BBS:%ld, ", n_bbs); 184 fprintf (file, "BBS:%ld, ", n_bbs);
163 fprintf (file, "LOOPS:%ld, ", n_loops); 185 fprintf (file, "LOOPS:%ld, ", n_loops);
164 fprintf (file, "CONDITIONS:%ld, ", n_conditions); 186 fprintf (file, "CONDITIONS:%ld, ", n_conditions);
165 fprintf (file, "STMTS:%ld)\n", n_stmts); 187 fprintf (file, "STMTS:%ld)\n", n_stmts);
166 fprintf (file, "\nSCoP profiling statistics ("); 188 fprintf (file, "SCoP profiling statistics (");
167 fprintf (file, "BBS:%ld, ", n_p_bbs); 189 fprintf (file, "BBS:");
168 fprintf (file, "LOOPS:%ld, ", n_p_loops); 190 n_p_bbs.dump (file);
169 fprintf (file, "CONDITIONS:%ld, ", n_p_conditions); 191 fprintf (file, ", LOOPS:");
170 fprintf (file, "STMTS:%ld)\n", n_p_stmts); 192 n_p_loops.dump (file);
193 fprintf (file, ", CONDITIONS:");
194 n_p_conditions.dump (file);
195 fprintf (file, ", STMTS:");
196 n_p_stmts.dump (file);
197 fprintf (file, ")\n\n");
171 } 198 }
172 199
173 /* Print statistics for SCOPS to FILE. */ 200 /* Print statistics for SCOPS to FILE. */
174 201
175 static void 202 static void
176 print_graphite_statistics (FILE* file, VEC (scop_p, heap) *scops) 203 print_graphite_statistics (FILE* file, vec<scop_p> scops)
177 { 204 {
178 int i; 205 int i;
179
180 scop_p scop; 206 scop_p scop;
181 207
182 FOR_EACH_VEC_ELT (scop_p, scops, i, scop) 208 FOR_EACH_VEC_ELT (scops, i, scop)
183 print_graphite_scop_statistics (file, scop); 209 print_graphite_scop_statistics (file, scop);
184 } 210 }
185 211
186 /* Initialize graphite: when there are no loops returns false. */ 212 /* Deletes all scops in SCOPS. */
187 213
188 static bool 214 static void
189 graphite_initialize (void) 215 free_scops (vec<scop_p> scops)
190 { 216 {
191 int ppl_initialized; 217 int i;
192 218 scop_p scop;
193 if (number_of_loops () <= 1 219
194 /* FIXME: This limit on the number of basic blocks of a function 220 FOR_EACH_VEC_ELT (scops, i, scop)
195 should be removed when the SCOP detection is faster. */ 221 free_scop (scop);
196 || n_basic_blocks > PARAM_VALUE (PARAM_GRAPHITE_MAX_BBS_PER_FUNCTION)) 222
197 { 223 scops.release ();
198 if (dump_file && (dump_flags & TDF_DETAILS)) 224 }
199 print_global_statistics (dump_file); 225
200 226 /* Transforms LOOP to the canonical loop closed SSA form. */
201 return false; 227
202 } 228 static void
203 229 canonicalize_loop_closed_ssa (loop_p loop)
204 scev_reset (); 230 {
205 recompute_all_dominators (); 231 edge e = single_exit (loop);
206 initialize_original_copy_tables (); 232 basic_block bb;
207 233 gphi_iterator psi;
208 ppl_initialized = ppl_initialize (); 234
209 gcc_assert (ppl_initialized == 0); 235 if (!e || (e->flags & EDGE_COMPLEX))
210 236 return;
211 cloog_state = cloog_state_malloc (); 237
212 cloog_initialize (); 238 bb = e->dest;
213 239
214 if (dump_file && dump_flags) 240 /* Make the loop-close PHI node BB contain only PHIs and have a
215 dump_function_to_file (current_function_decl, dump_file, dump_flags); 241 single predecessor. */
216 242 if (single_pred_p (bb))
217 return true; 243 {
218 } 244 e = split_block_after_labels (bb);
219 245 bb = e->src;
220 /* Finalize graphite: perform CFG cleanup when NEED_CFG_CLEANUP_P is 246 }
221 true. */ 247 else
222 248 {
223 static void 249 basic_block close = split_edge (e);
224 graphite_finalize (bool need_cfg_cleanup_p) 250 e = single_succ_edge (close);
225 { 251 for (psi = gsi_start_phis (bb); !gsi_end_p (psi); gsi_next (&psi))
226 if (need_cfg_cleanup_p) 252 {
227 { 253 gphi *phi = psi.phi ();
228 scev_reset (); 254 use_operand_p use_p = PHI_ARG_DEF_PTR_FROM_EDGE (phi, e);
229 cleanup_tree_cfg (); 255 tree arg = USE_FROM_PTR (use_p);
230 profile_status = PROFILE_ABSENT; 256
231 release_recorded_exits (); 257 /* Only add close phi nodes for SSA_NAMEs defined in LOOP. */
232 tree_estimate_probability (); 258 if (TREE_CODE (arg) != SSA_NAME
233 } 259 || SSA_NAME_IS_DEFAULT_DEF (arg)
234 260 || ! flow_bb_inside_loop_p (loop,
235 cloog_state_free (cloog_state); 261 gimple_bb (SSA_NAME_DEF_STMT (arg))))
236 cloog_finalize (); 262 continue;
237 ppl_finalize (); 263
238 free_original_copy_tables (); 264 tree res = copy_ssa_name (arg);
239 265 gphi *close_phi = create_phi_node (res, close);
240 if (dump_file && dump_flags) 266 add_phi_arg (close_phi, arg, gimple_phi_arg_edge (close_phi, 0),
241 print_loops (dump_file, 3); 267 UNKNOWN_LOCATION);
242 } 268 SET_USE (use_p, res);
269 }
270 bb = close;
271 }
272
273 /* Eliminate duplicates. This relies on processing loops from
274 innermost to outer. */
275 for (psi = gsi_start_phis (bb); !gsi_end_p (psi); gsi_next (&psi))
276 {
277 gphi_iterator gsi = psi;
278 gphi *phi = psi.phi ();
279
280 /* At this point, PHI should be a close phi in normal form. */
281 gcc_assert (gimple_phi_num_args (phi) == 1);
282
283 /* Iterate over the next phis and remove duplicates. */
284 gsi_next (&gsi);
285 while (!gsi_end_p (gsi))
286 if (gimple_phi_arg_def (phi, 0) == gimple_phi_arg_def (gsi.phi (), 0))
287 {
288 replace_uses_by (gimple_phi_result (gsi.phi ()),
289 gimple_phi_result (phi));
290 remove_phi_node (&gsi, true);
291 }
292 else
293 gsi_next (&gsi);
294 }
295 }
296
297 /* Converts the current loop closed SSA form to a canonical form
298 expected by the Graphite code generation.
299
300 The loop closed SSA form has the following invariant: a variable
301 defined in a loop that is used outside the loop appears only in the
302 phi nodes in the destination of the loop exit. These phi nodes are
303 called close phi nodes.
304
305 The canonical loop closed SSA form contains the extra invariants:
306
307 - when the loop contains only one exit, the close phi nodes contain
308 only one argument. That implies that the basic block that contains
309 the close phi nodes has only one predecessor, that is a basic block
310 in the loop.
311
312 - the basic block containing the close phi nodes does not contain
313 other statements.
314
315 - there exist only one phi node per definition in the loop.
316 */
317
318 static void
319 canonicalize_loop_closed_ssa_form (void)
320 {
321 loop_p loop;
322 FOR_EACH_LOOP (loop, LI_FROM_INNERMOST)
323 canonicalize_loop_closed_ssa (loop);
324
325 checking_verify_loop_closed_ssa (true);
326 }
327
328 isl_ctx *the_isl_ctx;
243 329
244 /* Perform a set of linear transforms on the loops of the current 330 /* Perform a set of linear transforms on the loops of the current
245 function. */ 331 function. */
246 332
247 void 333 void
248 graphite_transform_loops (void) 334 graphite_transform_loops (void)
249 { 335 {
250 int i; 336 int i;
251 scop_p scop; 337 scop_p scop;
252 bool need_cfg_cleanup_p = false; 338 bool changed = false;
253 VEC (scop_p, heap) *scops = NULL; 339 vec<scop_p> scops = vNULL;
254 htab_t bb_pbb_mapping; 340 isl_ctx *ctx;
255 341
256 if (!graphite_initialize ()) 342 /* If a function is parallel it was most probably already run through graphite
343 once. No need to run again. */
344 if (parallelized_function_p (cfun->decl))
257 return; 345 return;
258 346
347 calculate_dominance_info (CDI_DOMINATORS);
348
349 ctx = isl_ctx_alloc ();
350 isl_options_set_on_error (ctx, ISL_ON_ERROR_ABORT);
351 the_isl_ctx = ctx;
352
353 sort_sibling_loops (cfun);
354 canonicalize_loop_closed_ssa_form ();
355
356 /* Print the loop structure. */
357 if (dump_file && (dump_flags & TDF_DETAILS))
358 {
359 print_loops (dump_file, 2);
360 print_loops (dump_file, 3);
361 }
362
363 calculate_dominance_info (CDI_POST_DOMINATORS);
259 build_scops (&scops); 364 build_scops (&scops);
365 free_dominance_info (CDI_POST_DOMINATORS);
260 366
261 if (dump_file && (dump_flags & TDF_DETAILS)) 367 if (dump_file && (dump_flags & TDF_DETAILS))
262 { 368 {
263 print_graphite_statistics (dump_file, scops); 369 print_graphite_statistics (dump_file, scops);
264 print_global_statistics (dump_file); 370 print_global_statistics (dump_file);
265 } 371 }
266 372
267 bb_pbb_mapping = htab_create (10, bb_pbb_map_hash, eq_bb_pbb_map, free); 373 FOR_EACH_VEC_ELT (scops, i, scop)
268
269 FOR_EACH_VEC_ELT (scop_p, scops, i, scop)
270 if (dbg_cnt (graphite_scop)) 374 if (dbg_cnt (graphite_scop))
271 { 375 {
272 build_poly_scop (scop); 376 scop->isl_context = ctx;
273 377 if (!build_poly_scop (scop))
274 if (POLY_SCOP_P (scop) 378 continue;
275 && apply_poly_transforms (scop) 379
276 && gloog (scop, bb_pbb_mapping)) 380 if (!apply_poly_transforms (scop))
277 need_cfg_cleanup_p = true; 381 continue;
382
383 changed = true;
384 if (graphite_regenerate_ast_isl (scop))
385 {
386 location_t loc = find_loop_location
387 (scops[i]->scop_info->region.entry->dest->loop_father);
388 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, loc,
389 "loop nest optimized\n");
390 }
278 } 391 }
279 392
280 htab_delete (bb_pbb_mapping); 393 if (changed)
394 {
395 mark_virtual_operands_for_renaming (cfun);
396 update_ssa (TODO_update_ssa);
397 checking_verify_ssa (true, true);
398 rewrite_into_loop_closed_ssa (NULL, 0);
399 scev_reset ();
400 checking_verify_loop_structure ();
401 }
402
403 if (dump_file && (dump_flags & TDF_DETAILS))
404 {
405 loop_p loop;
406 int num_no_dependency = 0;
407
408 FOR_EACH_LOOP (loop, 0)
409 if (loop->can_be_parallel)
410 num_no_dependency++;
411
412 fprintf (dump_file, "%d loops carried no dependency.\n",
413 num_no_dependency);
414 }
415
281 free_scops (scops); 416 free_scops (scops);
282 graphite_finalize (need_cfg_cleanup_p); 417 the_isl_ctx = NULL;
283 } 418 isl_ctx_free (ctx);
284 419
285 #else /* If Cloog is not available: #ifndef HAVE_cloog. */ 420 if (changed)
286 421 {
287 void 422 cleanup_tree_cfg ();
423 profile_status_for_fn (cfun) = PROFILE_ABSENT;
424 release_recorded_exits (cfun);
425 tree_estimate_probability (false);
426 }
427
428 }
429
430 #else /* If isl is not available: #ifndef HAVE_isl. */
431
432 static void
288 graphite_transform_loops (void) 433 graphite_transform_loops (void)
289 { 434 {
290 sorry ("Graphite loop optimizations cannot be used"); 435 sorry ("Graphite loop optimizations cannot be used (isl is not available).");
291 } 436 }
292 437
293 #endif 438 #endif
439
440
441 static unsigned int
442 graphite_transforms (struct function *fun)
443 {
444 if (number_of_loops (fun) <= 1)
445 return 0;
446
447 graphite_transform_loops ();
448
449 return 0;
450 }
451
452 static bool
453 gate_graphite_transforms (void)
454 {
455 /* Enable -fgraphite pass if any one of the graphite optimization flags
456 is turned on. */
457 if (flag_graphite_identity
458 || flag_loop_parallelize_all
459 || flag_loop_nest_optimize)
460 flag_graphite = 1;
461
462 return flag_graphite != 0;
463 }
464
465 namespace {
466
467 const pass_data pass_data_graphite =
468 {
469 GIMPLE_PASS, /* type */
470 "graphite0", /* name */
471 OPTGROUP_LOOP, /* optinfo_flags */
472 TV_GRAPHITE, /* tv_id */
473 ( PROP_cfg | PROP_ssa ), /* properties_required */
474 0, /* properties_provided */
475 0, /* properties_destroyed */
476 0, /* todo_flags_start */
477 0, /* todo_flags_finish */
478 };
479
480 class pass_graphite : public gimple_opt_pass
481 {
482 public:
483 pass_graphite (gcc::context *ctxt)
484 : gimple_opt_pass (pass_data_graphite, ctxt)
485 {}
486
487 /* opt_pass methods: */
488 virtual bool gate (function *) { return gate_graphite_transforms (); }
489
490 }; // class pass_graphite
491
492 } // anon namespace
493
494 gimple_opt_pass *
495 make_pass_graphite (gcc::context *ctxt)
496 {
497 return new pass_graphite (ctxt);
498 }
499
500 namespace {
501
502 const pass_data pass_data_graphite_transforms =
503 {
504 GIMPLE_PASS, /* type */
505 "graphite", /* name */
506 OPTGROUP_LOOP, /* optinfo_flags */
507 TV_GRAPHITE_TRANSFORMS, /* tv_id */
508 ( PROP_cfg | PROP_ssa ), /* properties_required */
509 0, /* properties_provided */
510 0, /* properties_destroyed */
511 0, /* todo_flags_start */
512 0, /* todo_flags_finish */
513 };
514
515 class pass_graphite_transforms : public gimple_opt_pass
516 {
517 public:
518 pass_graphite_transforms (gcc::context *ctxt)
519 : gimple_opt_pass (pass_data_graphite_transforms, ctxt)
520 {}
521
522 /* opt_pass methods: */
523 virtual bool gate (function *) { return gate_graphite_transforms (); }
524 virtual unsigned int execute (function *fun) { return graphite_transforms (fun); }
525
526 }; // class pass_graphite_transforms
527
528 } // anon namespace
529
530 gimple_opt_pass *
531 make_pass_graphite_transforms (gcc::context *ctxt)
532 {
533 return new pass_graphite_transforms (ctxt);
534 }
535
536