]>
Commit | Line | Data |
---|---|---|
c6bb733d | 1 | /* Graphite polyhedral representation. |
fbd26352 | 2 | Copyright (C) 2009-2019 Free Software Foundation, Inc. |
c6bb733d | 3 | Contributed by Sebastian Pop <sebastian.pop@amd.com> and |
4 | Tobias Grosser <grosser@fim.uni-passau.de>. | |
5 | ||
6 | This file is part of GCC. | |
7 | ||
8 | GCC is free software; you can redistribute it and/or modify | |
9 | it under the terms of the GNU General Public License as published by | |
10 | the Free Software Foundation; either version 3, or (at your option) | |
11 | any later version. | |
12 | ||
13 | GCC is distributed in the hope that it will be useful, | |
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | GNU General Public License for more details. | |
17 | ||
18 | You should have received a copy of the GNU General Public License | |
19 | along with GCC; see the file COPYING3. If not see | |
20 | <http://www.gnu.org/licenses/>. */ | |
87e20041 | 21 | |
d8a2c81e | 22 | #define USES_ISL |
23 | ||
c6bb733d | 24 | #include "config.h" |
87e20041 | 25 | |
429cca51 | 26 | #ifdef HAVE_isl |
d8a2c81e | 27 | |
28 | #include "system.h" | |
29 | #include "coretypes.h" | |
30 | #include "backend.h" | |
31 | #include "tree.h" | |
32 | #include "gimple.h" | |
33 | #include "cfghooks.h" | |
d8a2c81e | 34 | #include "diagnostic-core.h" |
35 | #include "fold-const.h" | |
36 | #include "gimple-iterator.h" | |
37 | #include "tree-ssa-loop.h" | |
38 | #include "cfgloop.h" | |
39 | #include "tree-data-ref.h" | |
6fb10557 | 40 | #include "pretty-print.h" |
41 | #include "gimple-pretty-print.h" | |
39b8c5f3 | 42 | #include "graphite.h" |
23796153 | 43 | #include "dumpfile.h" |
c6bb733d | 44 | |
87e20041 | 45 | /* Print to STDERR the GMP value VAL. */ |
46 | ||
47 | DEBUG_FUNCTION void | |
48 | debug_gmp_value (mpz_t val) | |
49 | { | |
de2e6b8a | 50 | gmp_fprintf (stderr, "%Zd", val); |
87e20041 | 51 | } |
52 | ||
a765cde0 | 53 | /* Prints to FILE the iteration domain of PBB. */ |
c6bb733d | 54 | |
55 | void | |
a765cde0 | 56 | print_iteration_domain (FILE *file, poly_bb_p pbb) |
c6bb733d | 57 | { |
a765cde0 | 58 | print_pbb_domain (file, pbb); |
c6bb733d | 59 | } |
60 | ||
a765cde0 | 61 | /* Prints to FILE the iteration domains of every PBB of SCOP. */ |
c6bb733d | 62 | |
63 | void | |
a765cde0 | 64 | print_iteration_domains (FILE *file, scop_p scop) |
c6bb733d | 65 | { |
66 | int i; | |
67 | poly_bb_p pbb; | |
68 | ||
0e526381 | 69 | FOR_EACH_VEC_ELT (scop->pbbs, i, pbb) |
a765cde0 | 70 | print_iteration_domain (file, pbb); |
c6bb733d | 71 | } |
72 | ||
a765cde0 | 73 | /* Prints to STDERR the iteration domain of PBB. */ |
c6bb733d | 74 | |
4b987fac | 75 | DEBUG_FUNCTION void |
a765cde0 | 76 | debug_iteration_domain (poly_bb_p pbb) |
c6bb733d | 77 | { |
a765cde0 | 78 | print_iteration_domain (stderr, pbb); |
c6bb733d | 79 | } |
80 | ||
a765cde0 | 81 | /* Prints to STDERR the iteration domains of every PBB of SCOP. */ |
c6bb733d | 82 | |
4b987fac | 83 | DEBUG_FUNCTION void |
a765cde0 | 84 | debug_iteration_domains (scop_p scop) |
c6bb733d | 85 | { |
a765cde0 | 86 | print_iteration_domains (stderr, scop); |
c6bb733d | 87 | } |
88 | ||
85f74b79 | 89 | /* Create a new polyhedral data reference and add it to PBB. It is |
90 | defined by its ACCESSES, its TYPE, and the number of subscripts | |
91 | NB_SUBSCRIPTS. */ | |
c6bb733d | 92 | |
93 | void | |
30162daa | 94 | new_poly_dr (poly_bb_p pbb, gimple *stmt, enum poly_dr_type type, |
fc25c670 | 95 | isl_map *acc, isl_set *subscript_sizes) |
c6bb733d | 96 | { |
96b6d5d7 | 97 | static int id = 0; |
9e3531b5 | 98 | poly_dr_p pdr = XNEW (struct poly_dr); |
c6bb733d | 99 | |
30162daa | 100 | pdr->stmt = stmt; |
96b6d5d7 | 101 | PDR_ID (pdr) = id++; |
11b2102e | 102 | PDR_NB_REFS (pdr) = 1; |
c6bb733d | 103 | PDR_PBB (pdr) = pbb; |
87e20041 | 104 | pdr->accesses = acc; |
fc25c670 | 105 | pdr->subscript_sizes = subscript_sizes; |
c6bb733d | 106 | PDR_TYPE (pdr) = type; |
f1f41a6c | 107 | PBB_DRS (pbb).safe_push (pdr); |
6fb10557 | 108 | |
109 | if (dump_file) | |
110 | { | |
111 | fprintf (dump_file, "Converting dr: "); | |
112 | print_pdr (dump_file, pdr); | |
113 | fprintf (dump_file, "To polyhedral representation:\n"); | |
114 | fprintf (dump_file, " - access functions: "); | |
115 | print_isl_map (dump_file, acc); | |
116 | fprintf (dump_file, " - subscripts: "); | |
117 | print_isl_set (dump_file, subscript_sizes); | |
118 | } | |
c6bb733d | 119 | } |
120 | ||
121 | /* Free polyhedral data reference PDR. */ | |
122 | ||
c1616982 | 123 | static void |
c6bb733d | 124 | free_poly_dr (poly_dr_p pdr) |
125 | { | |
87e20041 | 126 | isl_map_free (pdr->accesses); |
fc25c670 | 127 | isl_set_free (pdr->subscript_sizes); |
c6bb733d | 128 | XDELETE (pdr); |
129 | } | |
130 | ||
131 | /* Create a new polyhedral black box. */ | |
132 | ||
8c6b3774 | 133 | poly_bb_p |
3b9ce1aa | 134 | new_poly_bb (scop_p scop, gimple_poly_bb_p black_box) |
c6bb733d | 135 | { |
136 | poly_bb_p pbb = XNEW (struct poly_bb); | |
137 | ||
87e20041 | 138 | pbb->domain = NULL; |
c1616982 | 139 | pbb->iterators = NULL; |
c6bb733d | 140 | PBB_SCOP (pbb) = scop; |
141 | pbb_set_black_box (pbb, black_box); | |
f1f41a6c | 142 | PBB_DRS (pbb).create (3); |
e0c0be18 | 143 | GBB_PBB ((gimple_poly_bb_p) black_box) = pbb; |
8c6b3774 | 144 | |
145 | return pbb; | |
c6bb733d | 146 | } |
147 | ||
148 | /* Free polyhedral black box. */ | |
149 | ||
c1616982 | 150 | static void |
c6bb733d | 151 | free_poly_bb (poly_bb_p pbb) |
152 | { | |
153 | int i; | |
154 | poly_dr_p pdr; | |
155 | ||
87e20041 | 156 | isl_set_free (pbb->domain); |
c1616982 | 157 | pbb->domain = NULL; |
c1616982 | 158 | isl_set_free (pbb->iterators); |
159 | pbb->iterators = NULL; | |
c6bb733d | 160 | |
f1f41a6c | 161 | if (PBB_DRS (pbb).exists ()) |
162 | FOR_EACH_VEC_ELT (PBB_DRS (pbb), i, pdr) | |
c6bb733d | 163 | free_poly_dr (pdr); |
164 | ||
f1f41a6c | 165 | PBB_DRS (pbb).release (); |
c6bb733d | 166 | XDELETE (pbb); |
167 | } | |
168 | ||
a765cde0 | 169 | /* Prints to FILE the polyhedral data reference PDR. */ |
c6bb733d | 170 | |
171 | void | |
a765cde0 | 172 | print_pdr (FILE *file, poly_dr_p pdr) |
c6bb733d | 173 | { |
a765cde0 | 174 | fprintf (file, "pdr_%d (", PDR_ID (pdr)); |
c6bb733d | 175 | |
a765cde0 | 176 | switch (PDR_TYPE (pdr)) |
177 | { | |
178 | case PDR_READ: | |
179 | fprintf (file, "read \n"); | |
180 | break; | |
c6bb733d | 181 | |
a765cde0 | 182 | case PDR_WRITE: |
183 | fprintf (file, "write \n"); | |
184 | break; | |
c6bb733d | 185 | |
a765cde0 | 186 | case PDR_MAY_WRITE: |
187 | fprintf (file, "may_write \n"); | |
188 | break; | |
ff4c7a5a | 189 | |
a765cde0 | 190 | default: |
191 | gcc_unreachable (); | |
c6bb733d | 192 | } |
193 | ||
30162daa | 194 | fprintf (file, "in gimple stmt: "); |
1ffa4346 | 195 | print_gimple_stmt (file, pdr->stmt, 0); |
a765cde0 | 196 | fprintf (file, "data accesses: "); |
197 | print_isl_map (file, pdr->accesses); | |
198 | fprintf (file, "subscript sizes: "); | |
199 | print_isl_set (file, pdr->subscript_sizes); | |
200 | fprintf (file, ")\n"); | |
c6bb733d | 201 | } |
202 | ||
a765cde0 | 203 | /* Prints to STDERR the polyhedral data reference PDR. */ |
c6bb733d | 204 | |
4b987fac | 205 | DEBUG_FUNCTION void |
a765cde0 | 206 | debug_pdr (poly_dr_p pdr) |
c6bb733d | 207 | { |
a765cde0 | 208 | print_pdr (stderr, pdr); |
c6bb733d | 209 | } |
210 | ||
118a202b | 211 | /* Store the GRAPHITE representation of BB. */ |
212 | ||
213 | gimple_poly_bb_p | |
30162daa | 214 | new_gimple_poly_bb (basic_block bb, vec<data_reference_p> drs, |
215 | vec<scalar_use> reads, vec<tree> writes) | |
118a202b | 216 | { |
30162daa | 217 | gimple_poly_bb_p gbb = XNEW (struct gimple_poly_bb); |
118a202b | 218 | GBB_BB (gbb) = bb; |
219 | GBB_DATA_REFS (gbb) = drs; | |
30162daa | 220 | gbb->read_scalar_refs = reads; |
221 | gbb->write_scalar_refs = writes; | |
118a202b | 222 | GBB_CONDITIONS (gbb).create (0); |
223 | GBB_CONDITION_CASES (gbb).create (0); | |
224 | ||
225 | return gbb; | |
226 | } | |
227 | ||
118a202b | 228 | /* Frees GBB. */ |
229 | ||
c1616982 | 230 | static void |
118a202b | 231 | free_gimple_poly_bb (gimple_poly_bb_p gbb) |
232 | { | |
118a202b | 233 | free_data_refs (GBB_DATA_REFS (gbb)); |
118a202b | 234 | GBB_CONDITIONS (gbb).release (); |
235 | GBB_CONDITION_CASES (gbb).release (); | |
30162daa | 236 | gbb->read_scalar_refs.release (); |
237 | gbb->write_scalar_refs.release (); | |
118a202b | 238 | XDELETE (gbb); |
239 | } | |
240 | ||
241 | /* Deletes all gimple bbs in SCOP. */ | |
242 | ||
243 | static void | |
244 | remove_gbbs_in_scop (scop_p scop) | |
245 | { | |
246 | int i; | |
247 | poly_bb_p pbb; | |
248 | ||
0e526381 | 249 | FOR_EACH_VEC_ELT (scop->pbbs, i, pbb) |
118a202b | 250 | free_gimple_poly_bb (PBB_BLACK_BOX (pbb)); |
251 | } | |
252 | ||
253 | /* Creates a new SCOP containing the region (ENTRY, EXIT). */ | |
c6bb733d | 254 | |
255 | scop_p | |
118a202b | 256 | new_scop (edge entry, edge exit) |
c6bb733d | 257 | { |
f032380c | 258 | sese_info_p region = new_sese_info (entry, exit); |
289af222 | 259 | scop_p s = XNEW (struct scop); |
18d73d6f | 260 | |
c1616982 | 261 | s->original_schedule = NULL; |
262 | s->transformed_schedule = NULL; | |
18d73d6f | 263 | s->param_context = NULL; |
264 | scop_set_region (s, region); | |
265 | s->pbbs.create (3); | |
266 | s->drs.create (3); | |
267 | s->dependence = NULL; | |
268 | return s; | |
c6bb733d | 269 | } |
270 | ||
271 | /* Deletes SCOP. */ | |
272 | ||
273 | void | |
274 | free_scop (scop_p scop) | |
275 | { | |
276 | int i; | |
277 | poly_bb_p pbb; | |
278 | ||
118a202b | 279 | remove_gbbs_in_scop (scop); |
5828c94d | 280 | free_sese_info (scop->scop_info); |
118a202b | 281 | |
0e526381 | 282 | FOR_EACH_VEC_ELT (scop->pbbs, i, pbb) |
c6bb733d | 283 | free_poly_bb (pbb); |
284 | ||
0e526381 | 285 | scop->pbbs.release (); |
5e6359b9 | 286 | scop->drs.release (); |
c6bb733d | 287 | |
3b9ce1aa | 288 | isl_set_free (scop->param_context); |
c1616982 | 289 | scop->param_context = NULL; |
18d73d6f | 290 | isl_union_map_free (scop->dependence); |
291 | scop->dependence = NULL; | |
c1616982 | 292 | isl_schedule_free (scop->original_schedule); |
293 | scop->original_schedule = NULL; | |
294 | isl_schedule_free (scop->transformed_schedule); | |
295 | scop->transformed_schedule = NULL; | |
c6bb733d | 296 | XDELETE (scop); |
297 | } | |
298 | ||
a765cde0 | 299 | /* Print to FILE the domain of PBB. */ |
c6bb733d | 300 | |
301 | void | |
a765cde0 | 302 | print_pbb_domain (FILE *file, poly_bb_p pbb) |
c6bb733d | 303 | { |
87e20041 | 304 | print_isl_set (file, pbb->domain); |
c6bb733d | 305 | } |
306 | ||
307 | /* Dump the cases of a graphite basic block GBB on FILE. */ | |
308 | ||
309 | static void | |
e0c0be18 | 310 | dump_gbb_cases (FILE *file, gimple_poly_bb_p gbb) |
c6bb733d | 311 | { |
312 | int i; | |
42acab1c | 313 | gimple *stmt; |
314 | vec<gimple *> cases; | |
c6bb733d | 315 | |
316 | if (!gbb) | |
317 | return; | |
318 | ||
319 | cases = GBB_CONDITION_CASES (gbb); | |
f1f41a6c | 320 | if (cases.is_empty ()) |
c6bb733d | 321 | return; |
322 | ||
a765cde0 | 323 | fprintf (file, "cases bb_%d (\n", GBB_BB (gbb)->index); |
c6bb733d | 324 | |
f1f41a6c | 325 | FOR_EACH_VEC_ELT (cases, i, stmt) |
1ffa4346 | 326 | print_gimple_stmt (file, stmt, 0); |
c6bb733d | 327 | |
a765cde0 | 328 | fprintf (file, ")\n"); |
c6bb733d | 329 | } |
330 | ||
331 | /* Dump conditions of a graphite basic block GBB on FILE. */ | |
332 | ||
333 | static void | |
e0c0be18 | 334 | dump_gbb_conditions (FILE *file, gimple_poly_bb_p gbb) |
c6bb733d | 335 | { |
336 | int i; | |
42acab1c | 337 | gimple *stmt; |
338 | vec<gimple *> conditions; | |
c6bb733d | 339 | |
340 | if (!gbb) | |
341 | return; | |
342 | ||
343 | conditions = GBB_CONDITIONS (gbb); | |
f1f41a6c | 344 | if (conditions.is_empty ()) |
c6bb733d | 345 | return; |
346 | ||
a765cde0 | 347 | fprintf (file, "conditions bb_%d (\n", GBB_BB (gbb)->index); |
c6bb733d | 348 | |
f1f41a6c | 349 | FOR_EACH_VEC_ELT (conditions, i, stmt) |
1ffa4346 | 350 | print_gimple_stmt (file, stmt, 0); |
c6bb733d | 351 | |
a765cde0 | 352 | fprintf (file, ")\n"); |
c6bb733d | 353 | } |
354 | ||
a765cde0 | 355 | /* Print to FILE all the data references of PBB. */ |
c6bb733d | 356 | |
357 | void | |
a765cde0 | 358 | print_pdrs (FILE *file, poly_bb_p pbb) |
c6bb733d | 359 | { |
360 | int i; | |
361 | poly_dr_p pdr; | |
5dc5fe13 | 362 | int nb_reads = 0; |
363 | int nb_writes = 0; | |
c6bb733d | 364 | |
a765cde0 | 365 | if (PBB_DRS (pbb).is_empty ()) |
366 | return; | |
ff4c7a5a | 367 | |
a765cde0 | 368 | fprintf (file, "Data references (\n"); |
5dc5fe13 | 369 | |
f1f41a6c | 370 | FOR_EACH_VEC_ELT (PBB_DRS (pbb), i, pdr) |
5dc5fe13 | 371 | if (PDR_TYPE (pdr) == PDR_READ) |
372 | nb_reads++; | |
373 | else | |
374 | nb_writes++; | |
375 | ||
a765cde0 | 376 | fprintf (file, "Read data references (\n"); |
ff4c7a5a | 377 | |
f1f41a6c | 378 | FOR_EACH_VEC_ELT (PBB_DRS (pbb), i, pdr) |
5dc5fe13 | 379 | if (PDR_TYPE (pdr) == PDR_READ) |
a765cde0 | 380 | print_pdr (file, pdr); |
5dc5fe13 | 381 | |
a765cde0 | 382 | fprintf (file, ")\n"); |
383 | fprintf (file, "Write data references (\n"); | |
f1f41a6c | 384 | FOR_EACH_VEC_ELT (PBB_DRS (pbb), i, pdr) |
5dc5fe13 | 385 | if (PDR_TYPE (pdr) != PDR_READ) |
a765cde0 | 386 | print_pdr (file, pdr); |
387 | fprintf (file, ")\n"); | |
388 | fprintf (file, ")\n"); | |
c6bb733d | 389 | } |
390 | ||
391 | /* Print to STDERR all the data references of PBB. */ | |
392 | ||
4b987fac | 393 | DEBUG_FUNCTION void |
a765cde0 | 394 | debug_pdrs (poly_bb_p pbb) |
c6bb733d | 395 | { |
a765cde0 | 396 | print_pdrs (stderr, pbb); |
c6bb733d | 397 | } |
398 | ||
a765cde0 | 399 | /* Print to FILE the body of PBB. */ |
5dc5fe13 | 400 | |
401 | static void | |
a765cde0 | 402 | print_pbb_body (FILE *file, poly_bb_p pbb) |
5dc5fe13 | 403 | { |
a765cde0 | 404 | fprintf (file, "Body (\n"); |
54e7de93 | 405 | dump_bb (file, pbb_bb (pbb), 0, TDF_NONE); |
a765cde0 | 406 | fprintf (file, ")\n"); |
5dc5fe13 | 407 | } |
408 | ||
a765cde0 | 409 | /* Print to FILE the domain and scattering function of PBB. */ |
c6bb733d | 410 | |
411 | void | |
a765cde0 | 412 | print_pbb (FILE *file, poly_bb_p pbb) |
ff4c7a5a | 413 | { |
a765cde0 | 414 | fprintf (file, "pbb_%d (\n", pbb_index (pbb)); |
415 | dump_gbb_conditions (file, PBB_BLACK_BOX (pbb)); | |
416 | dump_gbb_cases (file, PBB_BLACK_BOX (pbb)); | |
ff4c7a5a | 417 | |
a765cde0 | 418 | print_pbb_domain (file, pbb); |
419 | print_pdrs (file, pbb); | |
420 | print_pbb_body (file, pbb); | |
ff4c7a5a | 421 | |
a765cde0 | 422 | fprintf (file, ")\n"); |
c6bb733d | 423 | } |
424 | ||
a765cde0 | 425 | /* Print to FILE the parameters of SCOP. */ |
c6bb733d | 426 | |
427 | void | |
a765cde0 | 428 | print_scop_params (FILE *file, scop_p scop) |
c6bb733d | 429 | { |
30162daa | 430 | if (scop->scop_info->params.is_empty ()) |
a765cde0 | 431 | return; |
432 | ||
c6bb733d | 433 | int i; |
434 | tree t; | |
a765cde0 | 435 | fprintf (file, "parameters ("); |
30162daa | 436 | FOR_EACH_VEC_ELT (scop->scop_info->params, i, t) |
c6bb733d | 437 | { |
1ffa4346 | 438 | print_generic_expr (file, t); |
a765cde0 | 439 | fprintf (file, ", "); |
c6bb733d | 440 | } |
a765cde0 | 441 | fprintf (file, ")\n"); |
c6bb733d | 442 | } |
443 | ||
a765cde0 | 444 | /* Print to FILE the context of SCoP. */ |
ff4c7a5a | 445 | |
c6bb733d | 446 | void |
a765cde0 | 447 | print_scop_context (FILE *file, scop_p scop) |
c6bb733d | 448 | { |
a765cde0 | 449 | if (!scop->param_context) |
450 | return; | |
c6bb733d | 451 | |
a765cde0 | 452 | fprintf (file, "Context (\n"); |
453 | print_isl_set (file, scop->param_context); | |
454 | fprintf (file, ")\n"); | |
c6bb733d | 455 | } |
456 | ||
a765cde0 | 457 | /* Print to FILE the SCOP. */ |
c6bb733d | 458 | |
d2cd543b | 459 | void |
a765cde0 | 460 | print_scop (FILE *file, scop_p scop) |
c6bb733d | 461 | { |
d2cd543b | 462 | int i; |
463 | poly_bb_p pbb; | |
464 | ||
a765cde0 | 465 | fprintf (file, "SCoP (\n"); |
466 | print_scop_context (file, scop); | |
467 | print_scop_params (file, scop); | |
ff4c7a5a | 468 | |
a765cde0 | 469 | fprintf (file, "Number of statements: "); |
0e526381 | 470 | fprintf (file, "%d\n", scop->pbbs.length ()); |
c6bb733d | 471 | |
0e526381 | 472 | FOR_EACH_VEC_ELT (scop->pbbs, i, pbb) |
a765cde0 | 473 | print_pbb (file, pbb); |
95b2e0d3 | 474 | |
a765cde0 | 475 | fprintf (file, ")\n"); |
c6bb733d | 476 | } |
477 | ||
a765cde0 | 478 | /* Print to STDERR the domain of PBB. */ |
c6bb733d | 479 | |
4b987fac | 480 | DEBUG_FUNCTION void |
a765cde0 | 481 | debug_pbb_domain (poly_bb_p pbb) |
c6bb733d | 482 | { |
a765cde0 | 483 | print_pbb_domain (stderr, pbb); |
c6bb733d | 484 | } |
485 | ||
a765cde0 | 486 | /* Print to FILE the domain and scattering function of PBB. */ |
c6bb733d | 487 | |
4b987fac | 488 | DEBUG_FUNCTION void |
a765cde0 | 489 | debug_pbb (poly_bb_p pbb) |
c6bb733d | 490 | { |
a765cde0 | 491 | print_pbb (stderr, pbb); |
c6bb733d | 492 | } |
493 | ||
a765cde0 | 494 | /* Print to STDERR the context of SCOP. */ |
c6bb733d | 495 | |
4b987fac | 496 | DEBUG_FUNCTION void |
a765cde0 | 497 | debug_scop_context (scop_p scop) |
c6bb733d | 498 | { |
a765cde0 | 499 | print_scop_context (stderr, scop); |
c6bb733d | 500 | } |
501 | ||
a765cde0 | 502 | /* Print to STDERR the SCOP. */ |
c6bb733d | 503 | |
4b987fac | 504 | DEBUG_FUNCTION void |
a765cde0 | 505 | debug_scop (scop_p scop) |
c6bb733d | 506 | { |
a765cde0 | 507 | print_scop (stderr, scop); |
c6bb733d | 508 | } |
509 | ||
a765cde0 | 510 | /* Print to STDERR the parameters of SCOP. */ |
c6bb733d | 511 | |
4b987fac | 512 | DEBUG_FUNCTION void |
a765cde0 | 513 | debug_scop_params (scop_p scop) |
c6bb733d | 514 | { |
a765cde0 | 515 | print_scop_params (stderr, scop); |
c6bb733d | 516 | } |
517 | ||
87e20041 | 518 | extern isl_ctx *the_isl_ctx; |
519 | void | |
c1616982 | 520 | print_isl_set (FILE *f, __isl_keep isl_set *set) |
c6bb733d | 521 | { |
87e20041 | 522 | isl_printer *p = isl_printer_to_file (the_isl_ctx, f); |
c1616982 | 523 | p = isl_printer_set_yaml_style (p, ISL_YAML_STYLE_BLOCK); |
87e20041 | 524 | p = isl_printer_print_set (p, set); |
4cc0f4e2 | 525 | p = isl_printer_print_str (p, "\n"); |
87e20041 | 526 | isl_printer_free (p); |
527 | } | |
c6bb733d | 528 | |
87e20041 | 529 | DEBUG_FUNCTION void |
c1616982 | 530 | debug_isl_set (__isl_keep isl_set *set) |
87e20041 | 531 | { |
532 | print_isl_set (stderr, set); | |
533 | } | |
c6bb733d | 534 | |
87e20041 | 535 | void |
c1616982 | 536 | print_isl_map (FILE *f, __isl_keep isl_map *map) |
87e20041 | 537 | { |
538 | isl_printer *p = isl_printer_to_file (the_isl_ctx, f); | |
c1616982 | 539 | p = isl_printer_set_yaml_style (p, ISL_YAML_STYLE_BLOCK); |
87e20041 | 540 | p = isl_printer_print_map (p, map); |
4cc0f4e2 | 541 | p = isl_printer_print_str (p, "\n"); |
87e20041 | 542 | isl_printer_free (p); |
543 | } | |
c6bb733d | 544 | |
87e20041 | 545 | DEBUG_FUNCTION void |
c1616982 | 546 | debug_isl_map (__isl_keep isl_map *map) |
87e20041 | 547 | { |
548 | print_isl_map (stderr, map); | |
549 | } | |
c6bb733d | 550 | |
d9ac4c34 | 551 | void |
c1616982 | 552 | print_isl_union_map (FILE *f, __isl_keep isl_union_map *map) |
d9ac4c34 | 553 | { |
554 | isl_printer *p = isl_printer_to_file (the_isl_ctx, f); | |
c1616982 | 555 | p = isl_printer_set_yaml_style (p, ISL_YAML_STYLE_BLOCK); |
d9ac4c34 | 556 | p = isl_printer_print_union_map (p, map); |
557 | p = isl_printer_print_str (p, "\n"); | |
558 | isl_printer_free (p); | |
559 | } | |
560 | ||
561 | DEBUG_FUNCTION void | |
c1616982 | 562 | debug_isl_union_map (__isl_keep isl_union_map *map) |
d9ac4c34 | 563 | { |
564 | print_isl_union_map (stderr, map); | |
565 | } | |
566 | ||
87e20041 | 567 | void |
c1616982 | 568 | print_isl_aff (FILE *f, __isl_keep isl_aff *aff) |
87e20041 | 569 | { |
570 | isl_printer *p = isl_printer_to_file (the_isl_ctx, f); | |
571 | p = isl_printer_print_aff (p, aff); | |
4cc0f4e2 | 572 | p = isl_printer_print_str (p, "\n"); |
87e20041 | 573 | isl_printer_free (p); |
574 | } | |
c6bb733d | 575 | |
87e20041 | 576 | DEBUG_FUNCTION void |
c1616982 | 577 | debug_isl_aff (__isl_keep isl_aff *aff) |
87e20041 | 578 | { |
579 | print_isl_aff (stderr, aff); | |
580 | } | |
c6bb733d | 581 | |
87e20041 | 582 | void |
c1616982 | 583 | print_isl_constraint (FILE *f, __isl_keep isl_constraint *c) |
87e20041 | 584 | { |
585 | isl_printer *p = isl_printer_to_file (the_isl_ctx, f); | |
586 | p = isl_printer_print_constraint (p, c); | |
4cc0f4e2 | 587 | p = isl_printer_print_str (p, "\n"); |
87e20041 | 588 | isl_printer_free (p); |
589 | } | |
c6bb733d | 590 | |
87e20041 | 591 | DEBUG_FUNCTION void |
c1616982 | 592 | debug_isl_constraint (__isl_keep isl_constraint *c) |
87e20041 | 593 | { |
594 | print_isl_constraint (stderr, c); | |
c6bb733d | 595 | } |
596 | ||
c1616982 | 597 | void |
598 | print_isl_schedule (FILE *f, __isl_keep isl_schedule *s) | |
599 | { | |
600 | isl_printer *p = isl_printer_to_file (the_isl_ctx, f); | |
c1616982 | 601 | p = isl_printer_set_yaml_style (p, ISL_YAML_STYLE_BLOCK); |
c1616982 | 602 | p = isl_printer_print_schedule (p, s); |
603 | p = isl_printer_print_str (p, "\n"); | |
604 | isl_printer_free (p); | |
605 | } | |
606 | ||
607 | DEBUG_FUNCTION void | |
608 | debug_isl_schedule (__isl_keep isl_schedule *s) | |
609 | { | |
610 | print_isl_schedule (stderr, s); | |
611 | } | |
ee0d08ad | 612 | |
613 | void | |
c1616982 | 614 | print_isl_ast (FILE *file, __isl_keep isl_ast_node *n) |
615 | { | |
616 | isl_printer *prn = isl_printer_to_file (the_isl_ctx, file); | |
617 | prn = isl_printer_set_output_format (prn, ISL_FORMAT_C); | |
618 | prn = isl_printer_print_ast_node (prn, n); | |
619 | prn = isl_printer_print_str (prn, "\n"); | |
620 | isl_printer_free (prn); | |
621 | } | |
622 | ||
623 | DEBUG_FUNCTION void | |
624 | debug_isl_ast (isl_ast_node *n) | |
625 | { | |
626 | print_isl_ast (stderr, n); | |
627 | } | |
628 | ||
629 | DEBUG_FUNCTION void | |
630 | debug_scop_pbb (scop_p scop, int i) | |
631 | { | |
632 | debug_pbb (scop->pbbs[i]); | |
ee0d08ad | 633 | } |
634 | ||
26bd1f19 | 635 | #endif /* HAVE_isl */ |
c6bb733d | 636 |