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"
45 /******************************************************************************
46 * Error reporting functions *
47 ******************************************************************************/
49 void cloog_vmsg(CloogOptions
*options
, enum cloog_msg_type type
,
50 const char *msg
, va_list ap
)
54 if (options
&& options
->quiet
&&
55 (type
== CLOOG_WARNING
|| type
== CLOOG_INFO
))
70 fprintf(stderr
, "[CLooG] %s: ", type_msg
);
71 vfprintf(stderr
, msg
, ap
);
75 * Print message to stderr.
76 * @param msg printf format string
78 void cloog_msg(CloogOptions
*options
, enum cloog_msg_type type
,
84 cloog_vmsg(options
, type
, msg
, args
);
89 * Print error message to stderr and exit.
90 * @param msg printf format string
92 void cloog_die(const char *msg
, ...)
97 cloog_vmsg(NULL
, CLOOG_ERROR
, msg
, args
);
102 /******************************************************************************
103 * Structure display function *
104 ******************************************************************************/
108 * cloog_option_print function:
109 * This function prints the content of a CloogOptions structure (program) into
110 * a file (foo, possibly stdout).
111 * - April 19th 2003: first version.
113 void cloog_options_print(FILE * foo
, CloogOptions
* options
)
114 { fprintf(foo
,"Options:\n") ;
115 fprintf(foo
,"OPTIONS FOR LOOP GENERATION\n") ;
116 fprintf(foo
,"l = %3d,\n",options
->l
) ;
117 fprintf(foo
,"f = %3d,\n",options
->f
) ;
118 fprintf(foo
,"stop = %3d,\n",options
->stop
) ;
119 fprintf(foo
,"strides = %3d,\n",options
->strides
) ;
120 fprintf(foo
,"sh = %3d,\n",options
->sh
);
121 fprintf(foo
,"OPTIONS FOR PRETTY PRINTING\n") ;
122 fprintf(foo
,"esp = %3d,\n",options
->esp
) ;
123 fprintf(foo
,"fsp = %3d,\n",options
->fsp
) ;
124 fprintf(foo
,"otl = %3d.\n",options
->otl
) ;
125 fprintf(foo
,"block = %3d.\n",options
->block
) ;
126 fprintf(foo
,"compilable = %3d.\n",options
->compilable
) ;
127 fprintf(foo
,"callable = %3d.\n",options
->callable
) ;
128 fprintf(foo
,"UNDOCUMENTED OPTIONS FOR THE AUTHOR ONLY\n") ;
129 fprintf(foo
,"leaks = %3d.\n",options
->leaks
) ;
130 fprintf(foo
,"backtrack = %3d.\n",options
->backtrack
);
131 fprintf(foo
,"override = %3d.\n",options
->override
) ;
132 fprintf(foo
,"structure = %3d.\n",options
->structure
) ;
133 fprintf(foo
,"noscalars = %3d.\n",options
->noscalars
) ;
134 fprintf(foo
,"noblocks = %3d.\n",options
->noblocks
) ;
135 fprintf(foo
,"nosimplify = %3d.\n",options
->nosimplify
) ;
139 /******************************************************************************
140 * Memory deallocation function *
141 ******************************************************************************/
145 * cloog_options_free function:
146 * This function frees the allocated memory for a CloogOptions structure.
147 * - April 19th 2003: first version.
149 void cloog_options_free(CloogOptions
*options
)
155 /******************************************************************************
156 * Processing functions *
157 ******************************************************************************/
161 * cloog_options_help function:
162 * This function displays the quick help when the user set the option -help
163 * while calling cloog. Prints are cutted to respect the 509 characters
164 * limitation of the ISO C 89 compilers.
165 * - August 5th 2002: first version.
167 void cloog_options_help()
169 "Usage: cloog [ options | file ] ...\n"
170 "Options for code generation:\n"
171 " -l <depth> Last loop depth to optimize (-1: infinity)\n"
172 " (default setting: -1).\n"
173 " -f <depth> First loop depth to start loop separation (-1: "
174 "infinity)\n (default setting: 1).\n") ;
176 " -stop <depth> Loop depth to stop code generation (-1: infinity)"
177 "\n (default setting: -1).\n"
178 " -strides <boolean> Handle non-unit strides (1) or not (0)\n"
179 " (default setting: 0).\n") ;
181 "\nOptions for pretty printing:\n"
182 " -otl <boolean> Simplify loops running one time (1) or not (0)\n"
183 " (default setting: 1).\n") ;
185 " -esp <boolean> Allow complex equalities spreading (1) or not (0)\n"
186 " (default setting: 0).\n");
188 " -fsp <level> First level to begin the spreading\n"
189 " (default setting: 1).\n"
190 " -block <boolean> Make a new statement block per iterator in C\n"
191 " programs (1) or not (0) (default setting: 0).\n") ;
193 " -compilable <number> Compilable code by using preprocessor (not 0) or"
194 "\n not (0), number being the value of the parameters"
195 "\n (default setting: 0).\n"
196 " -callable <boolean> Testable code by using preprocessor (not 0) or"
197 "\n not (0) (default setting: 0).\n");
199 "\nGeneral options:\n"
200 " -o <output> Name of the output file; 'stdout' is a special\n"
201 " value: when used, output is standard output\n"
202 " (default setting: stdout).\n"
203 " -v, --version Display the version information (and more).\n"
204 " -q, --quiet Don't print any informational messages.\n"
205 " -h, --help Display this information.\n\n") ;
207 "The special value 'stdin' for 'file' makes CLooG to read data on\n"
208 "standard input.\n\n"
209 "For bug reporting or any suggestions, please send an email to the author\n"
210 "<cedric.bastoul@inria.fr>.\n") ;
215 * cloog_options_version function:
216 * This function displays some version informations when the user set the
217 * option -version while calling cloog. Prints are cutted to respect the 509
218 * characters limitation of the ISO C 89 compilers.
219 * - August 5th 2002: first version.
221 void cloog_options_version()
222 { printf("%s The Chunky Loop Generator\n", cloog_version());
225 "This is a loop generator for scanning Z-polyhedra. It is based on the "
226 "work of\nF. Quillere and C. Bastoul on high level code generation and of "
227 "the PolyLib Team\non polyhedral computation. This program is distributed "
228 "under the terms of the\nGNU Lesser General Public License "
229 "(details at http://www.gnu.org/licenses/lgpl-2.1.html).\n"
232 "It would be fair to refer the following paper in any publication "
233 "resulting from\nthe use of this software or its library:\n"
234 "@InProceedings{Bas04,\n"
235 "author = {Cedric Bastoul},\n"
236 "title = {Code Generation in the Polyhedral Model Is Easier Than You "
238 "booktitle = {PACT'13 IEEE International Conference on Parallel "
239 "Architecture\n and Compilation Techniques},\n"
241 "month = {september},\n"
243 "address = {Juan-les-Pins}\n"
246 "For any information, please ask the author at "
247 "<cedric.bastoul@inria.fr>.\n") ;
252 * cloog_options_set function:
253 * This function sets the value of an option thanks to the user's calling line.
254 * - option is the value to set,
255 * - argc are the elements of the user's calling line,
256 * - number is the number of the element corresponding to the considered option,
257 * this function adds 1 to number to pass away the option value.
259 * - August 5th 2002: first version.
260 * - June 29th 2003: (debug) lack of argument now detected.
262 void cloog_options_set(int * option
, int argv
, char ** argc
, int * number
)
265 if (*number
+1 >= argv
)
266 cloog_die("an option lacks of argument.\n");
269 *option
= strtol(argc
[*number
+1],endptr
,10) ;
271 cloog_die("value '%s' for option '%s' is not valid.\n",
272 argc
[*number
+1], argc
[*number
]);
273 *number
= *number
+ 1 ;
278 * cloog_options_malloc function:
279 * This functions allocate the memory space for a CLoogOptions structure and
280 * fill its fields with the defaults values. It returns a pointer to the
281 * allocated CloogOptions structure.
282 * - April 19th 2003: first version.
283 * - November 21th 2005: name changed (before it was cloog_options_init).
285 CloogOptions
*cloog_options_malloc(CloogState
*state
)
286 { CloogOptions
* options
;
288 /* Memory allocation for the CloogOptions structure. */
289 options
= (CloogOptions
*)malloc(sizeof(CloogOptions
)) ;
291 cloog_die("memory overflow.\n");
293 options
->state
= state
;
295 /* We set the various fields with default values. */
296 /* OPTIONS FOR LOOP GENERATION */
297 options
->l
= -1 ; /* Last level to optimize: infinity. */
298 options
->f
= 1 ; /* First level to optimize: the first. */
299 options
->stop
= -1 ; /* Generate all the code. */
300 options
->strides
= 0 ; /* Generate a code with unit strides. */
301 options
->sh
= 0; /* Compute actual convex hull. */
303 /* OPTIONS FOR PRETTY PRINTING */
304 options
->esp
= 1 ; /* We don't want Equality SPreading.*/
305 options
->fsp
= 1 ; /* The First level to SPread is the first. */
306 options
->otl
= 1 ; /* We want to fire One Time Loops. */
307 options
->block
= 0 ; /* We don't want to force statement blocks. */
308 options
->compilable
= 0 ; /* No compilable code. */
309 options
->callable
= 0 ; /* No callable code. */
310 options
->quiet
= 0; /* Do print informational messages. */
311 options
->language
= LANGUAGE_C
; /* The default output language is C. */
312 /* UNDOCUMENTED OPTIONS FOR THE AUTHOR ONLY */
313 options
->leaks
= 0 ; /* I don't want to print allocation statistics.*/
314 options
->backtrack
= 0; /* Perform backtrack in Quillere's algorithm.*/
315 options
->override
= 0 ; /* I don't want to override CLooG decisions.*/
316 options
->structure
= 0 ; /* I don't want to print internal structure.*/
317 options
->noblocks
= 0 ; /* I do want to make statement blocks.*/
318 options
->noscalars
= 0 ; /* I do want to use scalar dimensions.*/
319 options
->nosimplify
= 0 ; /* I do want to simplify polyhedra.*/
327 * cloog_options_read function:
328 * This functions reads all the options and the input/output files thanks
329 * the the user's calling line elements (in argc). It fills a CloogOptions
330 * structure and the FILE structure corresponding to input and output files.
331 * - August 5th 2002: first version.
332 * - April 19th 2003: now in options.c and support of the CloogOptions structure.
334 void cloog_options_read(CloogState
*state
, int argc
, char **argv
,
335 FILE **input
, FILE **output
, CloogOptions
**options
)
336 { int i
, infos
=0, input_is_set
=0 ;
338 /* CloogOptions structure allocation and initialization. */
339 *options
= cloog_options_malloc(state
);
341 /* The default output is the standard output. */
345 if (argv
[i
][0] == '-')
346 { if (strcmp(argv
[i
],"-l") == 0)
347 cloog_options_set(&(*options
)->l
,argc
,argv
,&i
) ;
349 if (strcmp(argv
[i
],"-f") == 0)
350 cloog_options_set(&(*options
)->f
,argc
,argv
,&i
) ;
352 if (strcmp(argv
[i
],"-stop") == 0)
353 cloog_options_set(&(*options
)->stop
,argc
,argv
,&i
) ;
355 if (strcmp(argv
[i
],"-strides") == 0)
356 cloog_options_set(&(*options
)->strides
,argc
,argv
,&i
) ;
357 else if (strcmp(argv
[i
],"-sh") == 0)
358 cloog_options_set(&(*options
)->sh
,argc
,argv
,&i
) ;
360 if (strcmp(argv
[i
],"-otl") == 0)
361 cloog_options_set(&(*options
)->otl
,argc
,argv
,&i
) ;
363 if (strcmp(argv
[i
],"-esp") == 0)
364 cloog_options_set(&(*options
)->esp
,argc
,argv
,&i
) ;
366 if (strcmp(argv
[i
],"-fsp") == 0)
367 cloog_options_set(&(*options
)->fsp
,argc
,argv
,&i
) ;
369 if (strcmp(argv
[i
],"-block") == 0)
370 cloog_options_set(&(*options
)->block
,argc
,argv
,&i
) ;
372 if (strcmp(argv
[i
],"-compilable") == 0)
373 cloog_options_set(&(*options
)->compilable
, argc
, argv
, &i
);
374 else if (strcmp(argv
[i
], "-callable") == 0)
375 cloog_options_set(&(*options
)->callable
, argc
, argv
, &i
);
377 if (strcmp(argv
[i
],"-loopo") == 0) /* Special option for the LooPo team ! */
378 { (*options
)->esp
= 0 ;
379 (*options
)->block
= 1 ;
382 if (strcmp(argv
[i
],"-bipbip") == 0)/* Special option for the author only !*/
383 (*options
)->backtrack
= 0;
385 if (strcmp(argv
[i
],"-leaks") == 0)
386 (*options
)->leaks
= 1 ;
388 if (strcmp(argv
[i
],"-nobacktrack") == 0)
389 (*options
)->backtrack
= 0;
390 else if (strcmp(argv
[i
], "-backtrack") == 0)
391 (*options
)->backtrack
= 1;
393 if (strcmp(argv
[i
],"-override") == 0)
394 (*options
)->override
= 1 ;
396 if (strcmp(argv
[i
],"-noblocks") == 0)
397 (*options
)->noblocks
= 1 ;
399 if (strcmp(argv
[i
],"-noscalars") == 0)
400 (*options
)->noscalars
= 1 ;
402 if (strcmp(argv
[i
],"-nosimplify") == 0)
403 (*options
)->nosimplify
= 1 ;
405 if ((strcmp(argv
[i
],"-struct") == 0) || (strcmp(argv
[i
],"-structure") == 0))
406 (*options
)->structure
= 1 ;
408 if ((strcmp(argv
[i
],"--help") == 0) || (strcmp(argv
[i
],"-h") == 0))
409 { cloog_options_help() ;
413 if ((strcmp(argv
[i
],"--version") == 0) || (strcmp(argv
[i
],"-v") == 0))
414 { cloog_options_version() ;
416 } else if ((strcmp(argv
[i
],"--quiet") == 0) || (strcmp(argv
[i
],"-q") == 0))
417 (*options
)->quiet
= 1;
419 if (strcmp(argv
[i
],"-o") == 0)
421 cloog_die("no output name for -o option.\n");
423 /* stdout is a special value, when used, we set output to standard
426 if (strcmp(argv
[i
+1],"stdout") == 0)
429 { *output
= fopen(argv
[i
+1],"w") ;
431 cloog_die("can't create output file %s.\n", argv
[i
+1]);
436 cloog_msg(*options
, CLOOG_WARNING
, "unknown %s option.\n", argv
[i
]);
441 (*options
)->name
= argv
[i
] ;
442 /* stdin is a special value, when used, we set input to standard input. */
443 if (strcmp(argv
[i
],"stdin") == 0)
446 { *input
= fopen(argv
[i
],"r") ;
448 cloog_die("%s file does not exist.\n", argv
[i
]);
452 cloog_die("multiple input files.\n");
456 cloog_die("no input file (-h for help).\n");