2 /**-------------------------------------------------------------------**
4 **-------------------------------------------------------------------**
6 **-------------------------------------------------------------------**
7 ** First version: april 19th 2003 **
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 ******************************************************************************/
42 # include "../include/cloog/cloog.h"
49 /******************************************************************************
50 * Error reporting functions *
51 ******************************************************************************/
53 void cloog_vmsg(CloogOptions
*options
, enum cloog_msg_type type
,
54 const char *msg
, va_list ap
)
58 if (options
&& options
->quiet
&&
59 (type
== CLOOG_WARNING
|| type
== CLOOG_INFO
))
74 fprintf(stderr
, "[CLooG] %s: ", type_msg
);
75 vfprintf(stderr
, msg
, ap
);
79 * Print message to stderr.
80 * @param msg printf format string
82 void cloog_msg(CloogOptions
*options
, enum cloog_msg_type type
,
88 cloog_vmsg(options
, type
, msg
, args
);
93 * Print error message to stderr and exit.
94 * @param msg printf format string
96 void cloog_die(const char *msg
, ...)
101 cloog_vmsg(NULL
, CLOOG_ERROR
, msg
, args
);
106 /******************************************************************************
107 * Structure display function *
108 ******************************************************************************/
112 * cloog_option_print function:
113 * This function prints the content of a CloogOptions structure (program) into
114 * a file (foo, possibly stdout).
115 * - April 19th 2003: first version.
117 void cloog_options_print(FILE * foo
, CloogOptions
* options
)
121 fprintf(foo
,"Options:\n") ;
122 fprintf(foo
,"OPTIONS FOR LOOP GENERATION\n") ;
123 fprintf(foo
,"l = %3d,\n",options
->l
) ;
124 fprintf(foo
,"f = %3d,\n",options
->f
) ;
125 fprintf(foo
,"fs = %3d,\n",options
->f
) ;
126 if (options
->fs_ls_size
>=1) {
127 fprintf(foo
,"fs = ");
128 for (i
=0; i
<options
->fs_ls_size
; i
++) {
129 fprintf(foo
,"%3d,\n",options
->fs
[i
]) ;
132 fprintf(foo
,"ls = ");
133 for (i
=0; i
<options
->fs_ls_size
; i
++) {
134 fprintf(foo
,"%3d,\n",options
->ls
[i
]) ;
138 fprintf(foo
,"stop = %3d,\n",options
->stop
) ;
139 fprintf(foo
,"strides = %3d,\n",options
->strides
) ;
140 fprintf(foo
,"sh = %3d,\n",options
->sh
);
141 fprintf(foo
,"OPTIONS FOR PRETTY PRINTING\n") ;
142 fprintf(foo
,"esp = %3d,\n",options
->esp
) ;
143 fprintf(foo
,"fsp = %3d,\n",options
->fsp
) ;
144 fprintf(foo
,"otl = %3d.\n",options
->otl
) ;
145 fprintf(foo
,"block = %3d.\n",options
->block
) ;
146 fprintf(foo
,"compilable = %3d.\n",options
->compilable
) ;
147 fprintf(foo
,"callable = %3d.\n",options
->callable
) ;
148 fprintf(foo
,"MISC OPTIONS\n") ;
149 fprintf(foo
,"name = %3s.\n", options
->name
);
150 fprintf(foo
,"openscop = %3d.\n", options
->openscop
);
151 if (options
->scop
!= NULL
)
152 fprintf(foo
,"scop = (present but not printed).\n");
154 fprintf(foo
,"scop = NULL.\n");
155 fprintf(foo
,"use_c99 = %3d.\n", options
->use_c99
);
156 fprintf(foo
,"UNDOCUMENTED OPTIONS FOR THE AUTHOR ONLY\n") ;
157 fprintf(foo
,"leaks = %3d.\n",options
->leaks
) ;
158 fprintf(foo
,"backtrack = %3d.\n",options
->backtrack
);
159 fprintf(foo
,"override = %3d.\n",options
->override
) ;
160 fprintf(foo
,"structure = %3d.\n",options
->structure
) ;
161 fprintf(foo
,"noscalars = %3d.\n",options
->noscalars
) ;
162 fprintf(foo
,"noblocks = %3d.\n",options
->noblocks
) ;
163 fprintf(foo
,"nosimplify = %3d.\n",options
->nosimplify
) ;
167 /******************************************************************************
168 * Memory deallocation function *
169 ******************************************************************************/
173 * cloog_options_free function:
174 * This function frees the allocated memory for a CloogOptions structure.
175 * - April 19th 2003: first version.
177 void cloog_options_free(CloogOptions
*options
)
180 if (options
->scop
!= NULL
) {
181 osl_scop_free(options
->scop
);
190 /******************************************************************************
191 * Processing functions *
192 ******************************************************************************/
196 * cloog_options_help function:
197 * This function displays the quick help when the user set the option -help
198 * while calling cloog. Prints are cutted to respect the 509 characters
199 * limitation of the ISO C 89 compilers.
200 * - August 5th 2002: first version.
202 void cloog_options_help()
204 "Usage: cloog [ options | file ] ...\n"
205 "Options for code generation:\n"
206 " -l <depth> Last loop depth to optimize (-1: infinity)\n"
207 " (default setting: -1).\n"
208 " -f <depth> First loop depth to start loop separation (-1: "
209 "infinity)\n (default setting: 1).\n") ;
211 " -stop <depth> Loop depth to stop code generation (-1: infinity)"
212 "\n (default setting: -1).\n"
213 " -strides <boolean> Handle non-unit strides (1) or not (0)\n"
214 " (default setting: 0).\n"
215 " -first-unroll <depth> First loop dimension to unroll (-1: no unrolling)\n");
217 "\nOptions for pretty printing:\n"
218 " -otl <boolean> Simplify loops running one time (1) or not (0)\n"
219 " (default setting: 1).\n") ;
221 " -esp <boolean> Allow complex equalities spreading (1) or not (0)\n"
222 " (default setting: 0).\n");
224 " -fsp <level> First level to begin the spreading\n"
225 " (default setting: 1).\n"
226 " -block <boolean> Make a new statement block per iterator in C\n"
227 " programs (1) or not (0) (default setting: 0).\n") ;
229 " -compilable <number> Compilable code by using preprocessor (not 0) or"
230 "\n not (0), number being the value of the parameters"
231 "\n (default setting: 0).\n"
232 " -callable <boolean> Testable code by using preprocessor (not 0) or"
233 "\n not (0) (default setting: 0).\n");
235 "\nGeneral options:\n"
236 " -o <output> Name of the output file; 'stdout' is a special\n"
237 " value: when used, output is standard output\n"
238 " (default setting: stdout).\n"
240 " -openscop Input file has OpenScop format.\n"
242 " -use_c99 Use C99 features in generated code.\n"
243 " -v, --version Display the version information (and more).\n"
244 " -q, --quiet Don't print any informational messages.\n"
245 " -h, --help Display this information.\n\n") ;
247 "The special value 'stdin' for 'file' makes CLooG to read data on\n"
248 "standard input.\n\n"
249 "For bug reporting or any suggestions, please send an email to the author\n"
250 "<cedric.bastoul@inria.fr>.\n") ;
255 * cloog_options_version function:
256 * This function displays some version informations when the user set the
257 * option -version while calling cloog. Prints are cutted to respect the 509
258 * characters limitation of the ISO C 89 compilers.
259 * - August 5th 2002: first version.
261 void cloog_options_version()
262 { printf("%s The Chunky Loop Generator\n", cloog_version());
265 "This is a loop generator for scanning Z-polyhedra. It is based on the "
266 "work of\nF. Quillere and C. Bastoul on high level code generation and of "
267 "the PolyLib Team\non polyhedral computation. This program is distributed "
268 "under the terms of the\nGNU Lesser General Public License "
269 "(details at http://www.gnu.org/licenses/lgpl-2.1.html).\n"
272 "It would be fair to refer the following paper in any publication "
273 "resulting from\nthe use of this software or its library:\n"
274 "@InProceedings{Bas04,\n"
275 "author = {Cedric Bastoul},\n"
276 "title = {Code Generation in the Polyhedral Model Is Easier Than You "
278 "booktitle = {PACT'13 IEEE International Conference on Parallel "
279 "Architecture\n and Compilation Techniques},\n"
281 "month = {september},\n"
283 "address = {Juan-les-Pins}\n"
286 "For any information, please ask the author at "
287 "<cedric.bastoul@inria.fr>.\n") ;
292 * cloog_options_set function:
293 * This function sets the value of an option thanks to the user's calling line.
294 * - option is the value to set,
295 * - argc are the elements of the user's calling line,
296 * - number is the number of the element corresponding to the considered option,
297 * this function adds 1 to number to pass away the option value.
299 * - August 5th 2002: first version.
300 * - June 29th 2003: (debug) lack of argument now detected.
302 void cloog_options_set(int * option
, int argv
, char ** argc
, int * number
)
305 if (*number
+1 >= argv
)
306 cloog_die("an option lacks of argument.\n");
309 *option
= strtol(argc
[*number
+1],endptr
,10) ;
311 cloog_die("value '%s' for option '%s' is not valid.\n",
312 argc
[*number
+1], argc
[*number
]);
313 *number
= *number
+ 1 ;
318 * cloog_options_malloc function:
319 * This functions allocate the memory space for a CLoogOptions structure and
320 * fill its fields with the defaults values. It returns a pointer to the
321 * allocated CloogOptions structure.
322 * - April 19th 2003: first version.
323 * - November 21th 2005: name changed (before it was cloog_options_init).
325 CloogOptions
*cloog_options_malloc(CloogState
*state
)
326 { CloogOptions
* options
;
328 /* Memory allocation for the CloogOptions structure. */
329 options
= (CloogOptions
*)malloc(sizeof(CloogOptions
)) ;
331 cloog_die("memory overflow.\n");
333 options
->state
= state
;
335 /* We set the various fields with default values. */
336 /* OPTIONS FOR LOOP GENERATION */
337 options
->l
= -1 ; /* Last level to optimize: infinity. */
338 options
->f
= 1 ; /* First level to optimize: the first. */
339 options
->ls
= NULL
; /* Statement-wise l option is not set */
340 options
->fs
= NULL
; /* Statement-wise f option is not set */
341 options
->fs_ls_size
= 0; /* No statement-wise f/s control */
342 options
->stop
= -1 ; /* Generate all the code. */
343 options
->strides
= 0 ; /* Generate a code with unit strides. */
344 options
->sh
= 0; /* Compute actual convex hull. */
345 options
->first_unroll
= -1; /* First level to unroll: none. */
347 /* OPTIONS FOR PRETTY PRINTING */
348 options
->esp
= 1 ; /* We want Equality SPreading.*/
349 options
->fsp
= 1 ; /* The First level to SPread is the first. */
350 options
->otl
= 1 ; /* We want to fire One Time Loops. */
351 options
->block
= 0 ; /* We don't want to force statement blocks. */
352 options
->compilable
= 0 ; /* No compilable code. */
353 options
->callable
= 0 ; /* No callable code. */
354 options
->quiet
= 0; /* Do print informational messages. */
355 options
->save_domains
= 0; /* Don't save domains. */
357 options
->language
= CLOOG_LANGUAGE_C
; /* The default output language is C. */
358 options
->openscop
= 0 ; /* The input file has not the OpenScop format.*/
359 options
->scop
= NULL
;/* No default SCoP.*/
360 options
->use_c99
= 0; /* No C99 features */
361 /* UNDOCUMENTED OPTIONS FOR THE AUTHOR ONLY */
362 options
->leaks
= 0 ; /* I don't want to print allocation statistics.*/
363 options
->backtrack
= 0; /* Perform backtrack in Quillere's algorithm.*/
364 options
->override
= 0 ; /* I don't want to override CLooG decisions.*/
365 options
->structure
= 0 ; /* I don't want to print internal structure.*/
366 options
->noblocks
= 0 ; /* I do want to make statement blocks.*/
367 options
->noscalars
= 0 ; /* I do want to use scalar dimensions.*/
368 options
->nosimplify
= 0 ; /* I do want to simplify polyhedra.*/
376 * cloog_options_read function:
377 * This functions reads all the options and the input/output files thanks
378 * the the user's calling line elements (in argc). It fills a CloogOptions
379 * structure and the FILE structure corresponding to input and output files.
380 * - August 5th 2002: first version.
381 * - April 19th 2003: now in options.c and support of the CloogOptions structure.
383 void cloog_options_read(CloogState
*state
, int argc
, char **argv
,
384 FILE **input
, FILE **output
, CloogOptions
**options
)
385 { int i
, infos
=0, input_is_set
=0 ;
387 /* CloogOptions structure allocation and initialization. */
388 *options
= cloog_options_malloc(state
);
390 /* The default output is the standard output. */
394 if (argv
[i
][0] == '-')
395 { if (strcmp(argv
[i
],"-l") == 0)
396 cloog_options_set(&(*options
)->l
,argc
,argv
,&i
) ;
398 if (strcmp(argv
[i
],"-f") == 0)
399 cloog_options_set(&(*options
)->f
,argc
,argv
,&i
) ;
401 if (strcmp(argv
[i
],"-stop") == 0)
402 cloog_options_set(&(*options
)->stop
,argc
,argv
,&i
) ;
404 if (strcmp(argv
[i
],"-strides") == 0)
405 cloog_options_set(&(*options
)->strides
,argc
,argv
,&i
) ;
406 else if (strcmp(argv
[i
],"-sh") == 0)
407 cloog_options_set(&(*options
)->sh
,argc
,argv
,&i
) ;
408 else if (!strcmp(argv
[i
], "-first-unroll"))
409 cloog_options_set(&(*options
)->first_unroll
, argc
, argv
, &i
);
411 if (strcmp(argv
[i
],"-otl") == 0)
412 cloog_options_set(&(*options
)->otl
,argc
,argv
,&i
) ;
414 if (strcmp(argv
[i
],"-openscop") == 0) {
416 (*options
)->openscop
= 1 ;
418 cloog_die("CLooG has not been compiled with OpenScop support.\n");
422 if (strcmp(argv
[i
],"-use_c99") == 0)
423 cloog_options_set(&(*options
)->use_c99
,argc
,argv
,&i
) ;
425 if (strcmp(argv
[i
],"-esp") == 0)
426 cloog_options_set(&(*options
)->esp
,argc
,argv
,&i
) ;
428 if (strcmp(argv
[i
],"-fsp") == 0)
429 cloog_options_set(&(*options
)->fsp
,argc
,argv
,&i
) ;
431 if (strcmp(argv
[i
],"-block") == 0)
432 cloog_options_set(&(*options
)->block
,argc
,argv
,&i
) ;
434 if (strcmp(argv
[i
],"-compilable") == 0)
435 cloog_options_set(&(*options
)->compilable
, argc
, argv
, &i
);
436 else if (strcmp(argv
[i
], "-callable") == 0)
437 cloog_options_set(&(*options
)->callable
, argc
, argv
, &i
);
439 if (strcmp(argv
[i
],"-loopo") == 0) /* Special option for the LooPo team ! */
440 { (*options
)->esp
= 0 ;
441 (*options
)->block
= 1 ;
444 if (strcmp(argv
[i
],"-bipbip") == 0)/* Special option for the author only !*/
445 (*options
)->backtrack
= 0;
447 if (strcmp(argv
[i
],"-leaks") == 0)
448 (*options
)->leaks
= 1 ;
450 if (strcmp(argv
[i
],"-nobacktrack") == 0)
451 (*options
)->backtrack
= 0;
452 else if (strcmp(argv
[i
], "-backtrack") == 0)
453 (*options
)->backtrack
= 1;
455 if (strcmp(argv
[i
],"-override") == 0)
456 (*options
)->override
= 1 ;
458 if (strcmp(argv
[i
],"-noblocks") == 0)
459 (*options
)->noblocks
= 1 ;
461 if (strcmp(argv
[i
],"-noscalars") == 0)
462 (*options
)->noscalars
= 1 ;
464 if (strcmp(argv
[i
],"-nosimplify") == 0)
465 (*options
)->nosimplify
= 1 ;
467 if ((strcmp(argv
[i
],"-struct") == 0) || (strcmp(argv
[i
],"-structure") == 0))
468 (*options
)->structure
= 1 ;
470 if ((strcmp(argv
[i
],"--help") == 0) || (strcmp(argv
[i
],"-h") == 0))
471 { cloog_options_help() ;
475 if ((strcmp(argv
[i
],"--version") == 0) || (strcmp(argv
[i
],"-v") == 0))
476 { cloog_options_version() ;
478 } else if ((strcmp(argv
[i
],"--quiet") == 0) || (strcmp(argv
[i
],"-q") == 0))
479 (*options
)->quiet
= 1;
481 if (strcmp(argv
[i
],"-o") == 0)
483 cloog_die("no output name for -o option.\n");
485 /* stdout is a special value, when used, we set output to standard
488 if (strcmp(argv
[i
+1],"stdout") == 0)
491 { *output
= fopen(argv
[i
+1],"w") ;
493 cloog_die("can't create output file %s.\n", argv
[i
+1]);
498 cloog_msg(*options
, CLOOG_WARNING
, "unknown %s option.\n", argv
[i
]);
503 (*options
)->name
= argv
[i
] ;
504 /* stdin is a special value, when used, we set input to standard input. */
505 if (strcmp(argv
[i
],"stdin") == 0)
508 { *input
= fopen(argv
[i
],"r") ;
510 cloog_die("%s file does not exist.\n", argv
[i
]);
514 cloog_die("multiple input files.\n");
518 cloog_die("no input file (-h for help).\n");
525 * This function extracts CLooG option values from an OpenScop scop and
526 * updates an existing CloogOption structure with those values. If the
527 * options were already set, they are updated without warning.
528 * \param[in] scop Input Scop.
529 * \param[in,out] options CLooG options to be updated.
531 void cloog_options_copy_from_osl_scop(osl_scop_p scop
,
532 CloogOptions
*options
) {
534 cloog_die("Options must be provided.\n");
537 /* Extract the language. */
538 if (!strcmp(scop
->language
, "FORTRAN"))
539 options
->language
= CLOOG_LANGUAGE_FORTRAN
;
541 options
->language
= CLOOG_LANGUAGE_C
;
543 /* Store the input SCoP in the option structure. */
544 options
->scop
= scop
;