2 /**-------------------------------------------------------------------**
4 **-------------------------------------------------------------------**
6 **-------------------------------------------------------------------**
7 ** First version: october 26th 2001 **
8 **-------------------------------------------------------------------**/
11 /******************************************************************************
12 * CLooG : the Chunky Loop Generator (experimental) *
13 ******************************************************************************
15 * Copyright (C) 2001-2005 Cedric Bastoul *
17 * This library is free software; you can redistribute it and/or *
18 * modify it under the terms of the GNU Lesser General Public *
19 * License as published by the Free Software Foundation; either *
20 * version 2.1 of the License, or (at your option) any later version. *
22 * This library is distributed in the hope that it will be useful, *
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
25 * Lesser General Public License for more details. *
27 * You should have received a copy of the GNU Lesser General Public *
28 * License along with this library; if not, write to the Free Software *
29 * Foundation, Inc., 51 Franklin Street, Fifth Floor, *
30 * Boston, MA 02110-1301 USA *
32 * CLooG, the Chunky Loop Generator *
33 * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
35 ******************************************************************************/
36 /* CAUTION: the english used for comments is probably the worst you ever read,
37 * please feel free to correct and improve it !
40 /* June 22nd 2005: General adaptation for GMP.
41 * October 26th 2005: General adaptation from CloogDomain to Matrix data
42 * structure for all constraint systems.
43 * October 27th 2005: General adaptation from CloogEqual to Matrix data
44 * structure for equality spreading.
51 # include "../include/cloog/cloog.h"
56 #include <osl/extensions/extbody.h>
57 #include <osl/statement.h>
62 static void pprint_name(FILE *dst
, struct clast_name
*n
);
63 static void pprint_term(struct cloogoptions
*i
, FILE *dst
, struct clast_term
*t
);
64 static void pprint_sum(struct cloogoptions
*opt
,
65 FILE *dst
, struct clast_reduction
*r
);
66 static void pprint_binary(struct cloogoptions
*i
,
67 FILE *dst
, struct clast_binary
*b
);
68 static void pprint_minmax_f(struct cloogoptions
*info
,
69 FILE *dst
, struct clast_reduction
*r
);
70 static void pprint_minmax_c(struct cloogoptions
*info
,
71 FILE *dst
, struct clast_reduction
*r
);
72 static void pprint_reduction(struct cloogoptions
*i
,
73 FILE *dst
, struct clast_reduction
*r
);
74 static void pprint_expr(struct cloogoptions
*i
, FILE *dst
, struct clast_expr
*e
);
75 static void pprint_equation(struct cloogoptions
*i
,
76 FILE *dst
, struct clast_equation
*eq
);
77 static void pprint_assignment(struct cloogoptions
*i
, FILE *dst
,
78 struct clast_assignment
*a
);
79 static void pprint_user_stmt(struct cloogoptions
*options
, FILE *dst
,
80 struct clast_user_stmt
*u
);
81 static void pprint_guard(struct cloogoptions
*options
, FILE *dst
, int indent
,
82 struct clast_guard
*g
);
83 static void pprint_for(struct cloogoptions
*options
, FILE *dst
, int indent
,
85 static void pprint_stmt_list(struct cloogoptions
*options
, FILE *dst
, int indent
,
86 struct clast_stmt
*s
);
89 void pprint_name(FILE *dst
, struct clast_name
*n
)
91 fprintf(dst
, "%s", n
->name
);
95 * This function returns a string containing the printing of a value (possibly
96 * an iterator or a parameter with its coefficient or a constant).
97 * - val is the coefficient or constant value,
98 * - name is a string containing the name of the iterator or of the parameter,
100 void pprint_term(struct cloogoptions
*i
, FILE *dst
, struct clast_term
*t
)
103 int group
= t
->var
->type
== clast_expr_red
&&
104 ((struct clast_reduction
*) t
->var
)->n
> 1;
105 if (cloog_int_is_one(t
->val
))
107 else if (cloog_int_is_neg_one(t
->val
))
110 cloog_int_print(dst
, t
->val
);
115 pprint_expr(i
, dst
, t
->var
);
119 cloog_int_print(dst
, t
->val
);
122 void pprint_sum(struct cloogoptions
*opt
, FILE *dst
, struct clast_reduction
*r
)
125 struct clast_term
*t
;
128 assert(r
->elts
[0]->type
== clast_expr_term
);
129 t
= (struct clast_term
*) r
->elts
[0];
130 pprint_term(opt
, dst
, t
);
132 for (i
= 1; i
< r
->n
; ++i
) {
133 assert(r
->elts
[i
]->type
== clast_expr_term
);
134 t
= (struct clast_term
*) r
->elts
[i
];
135 if (cloog_int_is_pos(t
->val
))
137 pprint_term(opt
, dst
, t
);
141 void pprint_binary(struct cloogoptions
*i
, FILE *dst
, struct clast_binary
*b
)
143 const char *s1
= NULL
, *s2
= NULL
, *s3
= NULL
;
144 int group
= b
->LHS
->type
== clast_expr_red
&&
145 ((struct clast_reduction
*) b
->LHS
)->n
> 1;
146 if (i
->language
== CLOOG_LANGUAGE_FORTRAN
) {
149 s1
= "FLOOR(REAL(", s2
= ")/REAL(", s3
= "))";
152 s1
= "CEILING(REAL(", s2
= ")/REAL(", s3
= "))";
156 s1
= "(", s2
= ")/", s3
= "";
158 s1
= "", s2
= "/", s3
= "";
161 s1
= "MOD(", s2
= ", ", s3
= ")";
167 s1
= "floord(", s2
= ",", s3
= ")";
170 s1
= "ceild(", s2
= ",", s3
= ")";
174 s1
= "(", s2
= ")/", s3
= "";
176 s1
= "", s2
= "/", s3
= "";
180 s1
= "(", s2
= ")%", s3
= "";
182 s1
= "", s2
= "%", s3
= "";
186 fprintf(dst
, "%s", s1
);
187 pprint_expr(i
, dst
, b
->LHS
);
188 fprintf(dst
, "%s", s2
);
189 cloog_int_print(dst
, b
->RHS
);
190 fprintf(dst
, "%s", s3
);
193 void pprint_minmax_f(struct cloogoptions
*info
, FILE *dst
, struct clast_reduction
*r
)
198 fprintf(dst
, r
->type
== clast_red_max
? "MAX(" : "MIN(");
199 pprint_expr(info
, dst
, r
->elts
[0]);
200 for (i
= 1; i
< r
->n
; ++i
) {
202 pprint_expr(info
, dst
, r
->elts
[i
]);
207 void pprint_minmax_c(struct cloogoptions
*info
, FILE *dst
, struct clast_reduction
*r
)
210 for (i
= 1; i
< r
->n
; ++i
)
211 fprintf(dst
, r
->type
== clast_red_max
? "max(" : "min(");
213 pprint_expr(info
, dst
, r
->elts
[0]);
214 for (i
= 1; i
< r
->n
; ++i
) {
216 pprint_expr(info
, dst
, r
->elts
[i
]);
221 void pprint_reduction(struct cloogoptions
*i
, FILE *dst
, struct clast_reduction
*r
)
225 pprint_sum(i
, dst
, r
);
230 pprint_expr(i
, dst
, r
->elts
[0]);
233 if (i
->language
== CLOOG_LANGUAGE_FORTRAN
)
234 pprint_minmax_f(i
, dst
, r
);
236 pprint_minmax_c(i
, dst
, r
);
243 void pprint_expr(struct cloogoptions
*i
, FILE *dst
, struct clast_expr
*e
)
248 case clast_expr_name
:
249 pprint_name(dst
, (struct clast_name
*) e
);
251 case clast_expr_term
:
252 pprint_term(i
, dst
, (struct clast_term
*) e
);
255 pprint_reduction(i
, dst
, (struct clast_reduction
*) e
);
258 pprint_binary(i
, dst
, (struct clast_binary
*) e
);
265 void pprint_equation(struct cloogoptions
*i
, FILE *dst
, struct clast_equation
*eq
)
267 pprint_expr(i
, dst
, eq
->LHS
);
269 fprintf(dst
, " == ");
270 else if (eq
->sign
> 0)
271 fprintf(dst
, " >= ");
273 fprintf(dst
, " <= ");
274 pprint_expr(i
, dst
, eq
->RHS
);
277 void pprint_assignment(struct cloogoptions
*i
, FILE *dst
,
278 struct clast_assignment
*a
)
281 fprintf(dst
, "%s = ", a
->LHS
);
282 pprint_expr(i
, dst
, a
->RHS
);
287 * pprint_osl_body function:
288 * this function pretty-prints the OpenScop body of a given statement.
289 * It returns 1 if it succeeds to find an OpenScop body to print for
290 * that statement, 0 otherwise.
291 * \param[in] options CLooG Options.
292 * \param[in] dst Output stream.
293 * \param[in] u Statement to print the OpenScop body.
294 * \return 1 on success to pretty-print an OpenScop body for u, 0 otherwise.
296 int pprint_osl_body(struct cloogoptions
*options
, FILE *dst
,
297 struct clast_user_stmt
*u
) {
301 struct clast_stmt
*t
;
302 osl_scop_p scop
= options
->scop
;
303 osl_statement_p stmt
;
306 if ((scop
!= NULL
) &&
307 (osl_statement_number(scop
->statement
) >= u
->statement
->number
)) {
308 stmt
= scop
->statement
;
310 /* Go to the convenient statement in the SCoP. */
311 for (i
= 1; i
< u
->statement
->number
; i
++)
314 /* Ensure it has a printable body. */
316 if (osl_generic_has_URI(stmt
->body
, OSL_URI_BODY
)) {
317 body
= stmt
->body
->data
;
318 } else if (osl_generic_has_URI(stmt
->body
, OSL_URI_EXTBODY
)) {
319 if (stmt
->body
->data
!= NULL
) {
320 body
= ((osl_extbody_p
)(stmt
->body
->data
))->body
;
323 if ((body
!= NULL
) &&
324 (body
->expression
!= NULL
) &&
325 (body
->iterators
!= NULL
)) {
326 expr
= osl_util_identifier_substitution(body
->expression
->string
[0],
327 body
->iterators
->string
);
329 /* Print the body expression, substituting the @...@ markers. */
333 expr
+= sscanf(expr
, "@%d", &iterator
) + 2; /* 2 for the @s */
334 t
= u
->substitutions
;
335 for (i
= 0; i
< iterator
; i
++)
337 pprint_assignment(options
, dst
, (struct clast_assignment
*)t
);
339 fprintf(dst
, "%c", *expr
++);
351 void pprint_user_stmt(struct cloogoptions
*options
, FILE *dst
,
352 struct clast_user_stmt
*u
)
354 struct clast_stmt
*t
;
356 if (pprint_osl_body(options
, dst
, u
))
359 if (u
->statement
->name
)
360 fprintf(dst
, "%s", u
->statement
->name
);
362 fprintf(dst
, "S%d", u
->statement
->number
);
364 for (t
= u
->substitutions
; t
; t
= t
->next
) {
365 assert(CLAST_STMT_IS_A(t
, stmt_ass
));
366 pprint_assignment(options
, dst
, (struct clast_assignment
*)t
);
371 if (options
->language
!= CLOOG_LANGUAGE_FORTRAN
)
376 void pprint_guard(struct cloogoptions
*options
, FILE *dst
, int indent
,
377 struct clast_guard
*g
)
380 if (options
->language
== CLOOG_LANGUAGE_FORTRAN
)
386 for (k
= 0; k
< g
->n
; ++k
) {
388 if (options
->language
== CLOOG_LANGUAGE_FORTRAN
)
389 fprintf(dst
," .AND. ");
394 pprint_equation(options
, dst
, &g
->eq
[k
]);
399 if (options
->language
== CLOOG_LANGUAGE_FORTRAN
)
400 fprintf(dst
," THEN\n");
404 pprint_stmt_list(options
, dst
, indent
+ INDENT_STEP
, g
->then
);
406 fprintf(dst
, "%*s", indent
, "");
407 if (options
->language
== CLOOG_LANGUAGE_FORTRAN
)
408 fprintf(dst
,"END IF\n");
413 void pprint_for(struct cloogoptions
*options
, FILE *dst
, int indent
,
416 if (options
->language
== CLOOG_LANGUAGE_C
) {
417 if ((f
->parallel
& CLAST_PARALLEL_OMP
) && !(f
->parallel
& CLAST_PARALLEL_MPI
)) {
419 fprintf(dst
, "lbp=");
420 pprint_expr(options
, dst
, f
->LB
);
424 fprintf(dst
, "%*s", indent
, "");
425 fprintf(dst
, "ubp=");
426 pprint_expr(options
, dst
, f
->UB
);
429 fprintf(dst
, "#pragma omp parallel for%s%s%s%s%s%s\n",
430 (f
->private_vars
)? " private(":"",
431 (f
->private_vars
)? f
->private_vars
: "",
432 (f
->private_vars
)? ")":"",
433 (f
->reduction_vars
)? " reduction(": "",
434 (f
->reduction_vars
)? f
->reduction_vars
: "",
435 (f
->reduction_vars
)? ")": "");
436 fprintf(dst
, "%*s", indent
, "");
438 if ((f
->parallel
& CLAST_PARALLEL_VEC
) && !(f
->parallel
& CLAST_PARALLEL_OMP
)
439 && !(f
->parallel
& CLAST_PARALLEL_MPI
)) {
441 fprintf(dst
, "lbv=");
442 pprint_expr(options
, dst
, f
->LB
);
446 fprintf(dst
, "%*s", indent
, "");
447 fprintf(dst
, "ubv=");
448 pprint_expr(options
, dst
, f
->UB
);
451 fprintf(dst
, "%*s#pragma ivdep\n", indent
, "");
452 fprintf(dst
, "%*s#pragma vector always\n", indent
, "");
453 fprintf(dst
, "%*s", indent
, "");
455 if (f
->parallel
& CLAST_PARALLEL_MPI
) {
457 fprintf(dst
, "_lb_dist=");
458 pprint_expr(options
, dst
, f
->LB
);
462 fprintf(dst
, "%*s", indent
, "");
463 fprintf(dst
, "_ub_dist=");
464 pprint_expr(options
, dst
, f
->UB
);
467 fprintf(dst
, "%*s", indent
, "");
468 fprintf(dst
, "polyrt_loop_dist(_lb_dist, _ub_dist, nprocs, my_rank, &lbp, &ubp);\n");
469 if (f
->parallel
& CLAST_PARALLEL_OMP
) {
470 fprintf(dst
, "#pragma omp parallel for%s%s%s%s%s%s\n",
471 (f
->private_vars
)? " private(":"",
472 (f
->private_vars
)? f
->private_vars
: "",
473 (f
->private_vars
)? ")":"",
474 (f
->reduction_vars
)? " reduction(": "",
475 (f
->reduction_vars
)? f
->reduction_vars
: "",
476 (f
->reduction_vars
)? ")": "");
478 fprintf(dst
, "%*s", indent
, "");
483 if (options
->language
== CLOOG_LANGUAGE_FORTRAN
)
486 fprintf(dst
, "for (");
489 fprintf(dst
, "%s=", f
->iterator
);
490 if (f
->parallel
& (CLAST_PARALLEL_OMP
| CLAST_PARALLEL_MPI
)) {
492 }else if (f
->parallel
& CLAST_PARALLEL_VEC
){
495 pprint_expr(options
, dst
, f
->LB
);
497 } else if (options
->language
== CLOOG_LANGUAGE_FORTRAN
)
498 cloog_die("unbounded loops not allowed in FORTRAN.\n");
500 if (options
->language
== CLOOG_LANGUAGE_FORTRAN
)
506 if (options
->language
!= CLOOG_LANGUAGE_FORTRAN
)
507 fprintf(dst
,"%s<=", f
->iterator
);
509 if (f
->parallel
& (CLAST_PARALLEL_OMP
| CLAST_PARALLEL_MPI
)) {
511 }else if (f
->parallel
& CLAST_PARALLEL_VEC
){
514 pprint_expr(options
, dst
, f
->UB
);
516 }else if (options
->language
== CLOOG_LANGUAGE_FORTRAN
)
517 cloog_die("unbounded loops not allowed in FORTRAN.\n");
519 if (options
->language
== CLOOG_LANGUAGE_FORTRAN
) {
520 if (cloog_int_gt_si(f
->stride
, 1))
521 cloog_int_print(dst
, f
->stride
);
525 if (cloog_int_gt_si(f
->stride
, 1)) {
526 fprintf(dst
,";%s+=", f
->iterator
);
527 cloog_int_print(dst
, f
->stride
);
528 fprintf(dst
, ") {\n");
530 fprintf(dst
, ";%s++) {\n", f
->iterator
);
533 pprint_stmt_list(options
, dst
, indent
+ INDENT_STEP
, f
->body
);
535 fprintf(dst
, "%*s", indent
, "");
536 if (options
->language
== CLOOG_LANGUAGE_FORTRAN
)
537 fprintf(dst
,"END DO\n") ;
542 void pprint_stmt_list(struct cloogoptions
*options
, FILE *dst
, int indent
,
543 struct clast_stmt
*s
)
545 for ( ; s
; s
= s
->next
) {
546 if (CLAST_STMT_IS_A(s
, stmt_root
))
548 fprintf(dst
, "%*s", indent
, "");
549 if (CLAST_STMT_IS_A(s
, stmt_ass
)) {
550 pprint_assignment(options
, dst
, (struct clast_assignment
*) s
);
551 if (options
->language
!= CLOOG_LANGUAGE_FORTRAN
)
554 } else if (CLAST_STMT_IS_A(s
, stmt_user
)) {
555 pprint_user_stmt(options
, dst
, (struct clast_user_stmt
*) s
);
556 } else if (CLAST_STMT_IS_A(s
, stmt_for
)) {
557 pprint_for(options
, dst
, indent
, (struct clast_for
*) s
);
558 } else if (CLAST_STMT_IS_A(s
, stmt_guard
)) {
559 pprint_guard(options
, dst
, indent
, (struct clast_guard
*) s
);
560 } else if (CLAST_STMT_IS_A(s
, stmt_block
)) {
562 pprint_stmt_list(options
, dst
, indent
+ INDENT_STEP
,
563 ((struct clast_block
*)s
)->body
);
564 fprintf(dst
, "%*s", indent
, "");
573 /******************************************************************************
574 * Pretty Printing (dirty) functions *
575 ******************************************************************************/
577 void clast_pprint(FILE *foo
, struct clast_stmt
*root
,
578 int indent
, CloogOptions
*options
)
580 pprint_stmt_list(options
, foo
, indent
, root
);