/**-------------------------------------------------------------------** ** CLooG ** **-------------------------------------------------------------------** ** options.c ** **-------------------------------------------------------------------** ** First version: april 19th 2003 ** **-------------------------------------------------------------------**/ /****************************************************************************** * CLooG : the Chunky Loop Generator (experimental) * ****************************************************************************** * * * Copyright (C) 2001-2005 Cedric Bastoul * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This library is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin Street, Fifth Floor, * * Boston, MA 02110-1301 USA * * * * CLooG, the Chunky Loop Generator * * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr * * * ******************************************************************************/ #include # include # include # include # include "../include/cloog/cloog.h" #ifdef OSL_SUPPORT #include #endif /****************************************************************************** * Error reporting functions * ******************************************************************************/ void cloog_vmsg(CloogOptions *options, enum cloog_msg_type type, const char *msg, va_list ap) { const char *type_msg; if (options && options->quiet && (type == CLOOG_WARNING || type == CLOOG_INFO)) return; switch(type) { case CLOOG_WARNING: type_msg = "WARNING"; break; case CLOOG_INFO: type_msg = "INFO"; break; case CLOOG_ERROR: default: type_msg = "ERROR"; break; } fprintf(stderr, "[CLooG] %s: ", type_msg); vfprintf(stderr, msg, ap); } /** * Print message to stderr. * @param msg printf format string */ void cloog_msg(CloogOptions *options, enum cloog_msg_type type, const char *msg, ...) { va_list args; va_start(args, msg); cloog_vmsg(options, type, msg, args); va_end(args); } /** * Print error message to stderr and exit. * @param msg printf format string */ void cloog_die(const char *msg, ...) { va_list args; va_start(args, msg); cloog_vmsg(NULL, CLOOG_ERROR, msg, args); va_end(args); exit(1); } /****************************************************************************** * Structure display function * ******************************************************************************/ /** * cloog_option_print function: * This function prints the content of a CloogOptions structure (program) into * a file (foo, possibly stdout). * - April 19th 2003: first version. */ void cloog_options_print(FILE * foo, CloogOptions * options) { int i; fprintf(foo,"Options:\n") ; fprintf(foo,"OPTIONS FOR LOOP GENERATION\n") ; fprintf(foo,"l = %3d,\n",options->l) ; fprintf(foo,"f = %3d,\n",options->f) ; fprintf(foo,"fs = %3d,\n",options->f) ; if (options->fs_ls_size>=1) { fprintf(foo,"fs = "); for (i=0; ifs_ls_size; i++) { fprintf(foo,"%3d,\n",options->fs[i]) ; } fprintf(foo,"\n"); fprintf(foo,"ls = "); for (i=0; ifs_ls_size; i++) { fprintf(foo,"%3d,\n",options->ls[i]) ; } fprintf(foo,"\n"); } fprintf(foo,"stop = %3d,\n",options->stop) ; fprintf(foo,"strides = %3d,\n",options->strides) ; fprintf(foo,"sh = %3d,\n",options->sh); fprintf(foo,"OPTIONS FOR PRETTY PRINTING\n") ; fprintf(foo,"esp = %3d,\n",options->esp) ; fprintf(foo,"fsp = %3d,\n",options->fsp) ; fprintf(foo,"otl = %3d.\n",options->otl) ; fprintf(foo,"block = %3d.\n",options->block) ; fprintf(foo,"compilable = %3d.\n",options->compilable) ; fprintf(foo,"callable = %3d.\n",options->callable) ; fprintf(foo,"MISC OPTIONS\n") ; fprintf(foo,"name = %3s.\n", options->name); fprintf(foo,"openscop = %3d.\n", options->openscop); if (options->scop != NULL) fprintf(foo,"scop = (present but not printed).\n"); else fprintf(foo,"scop = NULL.\n"); fprintf(foo,"UNDOCUMENTED OPTIONS FOR THE AUTHOR ONLY\n") ; fprintf(foo,"leaks = %3d.\n",options->leaks) ; fprintf(foo,"backtrack = %3d.\n",options->backtrack); fprintf(foo,"override = %3d.\n",options->override) ; fprintf(foo,"structure = %3d.\n",options->structure) ; fprintf(foo,"noscalars = %3d.\n",options->noscalars) ; fprintf(foo,"noblocks = %3d.\n",options->noblocks) ; fprintf(foo,"nosimplify = %3d.\n",options->nosimplify) ; } /****************************************************************************** * Memory deallocation function * ******************************************************************************/ /** * cloog_options_free function: * This function frees the allocated memory for a CloogOptions structure. * - April 19th 2003: first version. */ void cloog_options_free(CloogOptions *options) { #ifdef OSL_SUPPORT if (options->scop != NULL) { osl_scop_free(options->scop); } #endif free(options->fs); free(options->ls); free(options); } /****************************************************************************** * Processing functions * ******************************************************************************/ /** * cloog_options_help function: * This function displays the quick help when the user set the option -help * while calling cloog. Prints are cutted to respect the 509 characters * limitation of the ISO C 89 compilers. * - August 5th 2002: first version. */ void cloog_options_help() { printf( "Usage: cloog [ options | file ] ...\n" "Options for code generation:\n" " -l Last loop depth to optimize (-1: infinity)\n" " (default setting: -1).\n" " -f First loop depth to start loop separation (-1: " "infinity)\n (default setting: 1).\n") ; printf( " -stop Loop depth to stop code generation (-1: infinity)" "\n (default setting: -1).\n" " -strides Handle non-unit strides (1) or not (0)\n" " (default setting: 0).\n" " -first-unroll First loop dimension to unroll (-1: no unrolling)\n"); printf( "\nOptions for pretty printing:\n" " -otl Simplify loops running one time (1) or not (0)\n" " (default setting: 1).\n") ; printf( " -esp Allow complex equalities spreading (1) or not (0)\n" " (default setting: 0).\n"); printf( " -fsp First level to begin the spreading\n" " (default setting: 1).\n" " -block Make a new statement block per iterator in C\n" " programs (1) or not (0) (default setting: 0).\n") ; printf( " -compilable Compilable code by using preprocessor (not 0) or" "\n not (0), number being the value of the parameters" "\n (default setting: 0).\n" " -callable Testable code by using preprocessor (not 0) or" "\n not (0) (default setting: 0).\n"); printf( "\nGeneral options:\n" " -o Name of the output file; 'stdout' is a special\n" " value: when used, output is standard output\n" " (default setting: stdout).\n" #ifdef OSL_SUPPORT " -openscop Input file has OpenScop format.\n" #endif " -v, --version Display the version information (and more).\n" " -q, --quiet Don't print any informational messages.\n" " -h, --help Display this information.\n\n") ; printf( "The special value 'stdin' for 'file' makes CLooG to read data on\n" "standard input.\n\n" "For bug reporting or any suggestions, please send an email to the author\n" ".\n") ; } /** * cloog_options_version function: * This function displays some version informations when the user set the * option -version while calling cloog. Prints are cutted to respect the 509 * characters limitation of the ISO C 89 compilers. * - August 5th 2002: first version. */ void cloog_options_version() { printf("%s The Chunky Loop Generator\n", cloog_version()); printf( "-----\n" "This is a loop generator for scanning Z-polyhedra. It is based on the " "work of\nF. Quillere and C. Bastoul on high level code generation and of " "the PolyLib Team\non polyhedral computation. This program is distributed " "under the terms of the\nGNU Lesser General Public License " "(details at http://www.gnu.org/licenses/lgpl-2.1.html).\n" "-----\n") ; printf( "It would be fair to refer the following paper in any publication " "resulting from\nthe use of this software or its library:\n" "@InProceedings{Bas04,\n" "author = {Cedric Bastoul},\n" "title = {Code Generation in the Polyhedral Model Is Easier Than You " "Think},\n" "booktitle = {PACT'13 IEEE International Conference on Parallel " "Architecture\n and Compilation Techniques},\n" "pages = {7--16},\n" "month = {september},\n" "year = 2004,\n" "address = {Juan-les-Pins}\n" "}\n" "-----\n" "For any information, please ask the author at " ".\n") ; } /** * cloog_options_set function: * This function sets the value of an option thanks to the user's calling line. * - option is the value to set, * - argc are the elements of the user's calling line, * - number is the number of the element corresponding to the considered option, * this function adds 1 to number to pass away the option value. ** * - August 5th 2002: first version. * - June 29th 2003: (debug) lack of argument now detected. */ void cloog_options_set(int * option, int argv, char ** argc, int * number) { char ** endptr ; if (*number+1 >= argv) cloog_die("an option lacks of argument.\n"); endptr = NULL ; *option = strtol(argc[*number+1],endptr,10) ; if (endptr != NULL) cloog_die("value '%s' for option '%s' is not valid.\n", argc[*number+1], argc[*number]); *number = *number + 1 ; } /** * cloog_options_malloc function: * This functions allocate the memory space for a CLoogOptions structure and * fill its fields with the defaults values. It returns a pointer to the * allocated CloogOptions structure. * - April 19th 2003: first version. * - November 21th 2005: name changed (before it was cloog_options_init). */ CloogOptions *cloog_options_malloc(CloogState *state) { CloogOptions * options ; /* Memory allocation for the CloogOptions structure. */ options = (CloogOptions *)malloc(sizeof(CloogOptions)) ; if (options == NULL) cloog_die("memory overflow.\n"); options->state = state; /* We set the various fields with default values. */ /* OPTIONS FOR LOOP GENERATION */ options->l = -1 ; /* Last level to optimize: infinity. */ options->f = 1 ; /* First level to optimize: the first. */ options->ls = NULL ; /* Statement-wise l option is not set */ options->fs = NULL ; /* Statement-wise f option is not set */ options->fs_ls_size = 0; /* No statement-wise f/s control */ options->stop = -1 ; /* Generate all the code. */ options->strides = 0 ; /* Generate a code with unit strides. */ options->sh = 0; /* Compute actual convex hull. */ options->first_unroll = -1; /* First level to unroll: none. */ options->name = ""; /* OPTIONS FOR PRETTY PRINTING */ options->esp = 1 ; /* We want Equality SPreading.*/ options->fsp = 1 ; /* The First level to SPread is the first. */ options->otl = 1 ; /* We want to fire One Time Loops. */ options->block = 0 ; /* We don't want to force statement blocks. */ options->compilable = 0 ; /* No compilable code. */ options->callable = 0 ; /* No callable code. */ options->quiet = 0; /* Do print informational messages. */ options->save_domains = 0; /* Don't save domains. */ /* MISC OPTIONS */ options->language = CLOOG_LANGUAGE_C; /* The default output language is C. */ options->openscop = 0 ; /* The input file has not the OpenScop format.*/ options->scop = NULL;/* No default SCoP.*/ /* UNDOCUMENTED OPTIONS FOR THE AUTHOR ONLY */ options->leaks = 0 ; /* I don't want to print allocation statistics.*/ options->backtrack = 0; /* Perform backtrack in Quillere's algorithm.*/ options->override = 0 ; /* I don't want to override CLooG decisions.*/ options->structure = 0 ; /* I don't want to print internal structure.*/ options->noblocks = 0 ; /* I do want to make statement blocks.*/ options->noscalars = 0 ; /* I do want to use scalar dimensions.*/ options->nosimplify = 0 ; /* I do want to simplify polyhedra.*/ return options ; } /** * cloog_options_read function: * This functions reads all the options and the input/output files thanks * the the user's calling line elements (in argc). It fills a CloogOptions * structure and the FILE structure corresponding to input and output files. * - August 5th 2002: first version. * - April 19th 2003: now in options.c and support of the CloogOptions structure. */ void cloog_options_read(CloogState *state, int argc, char **argv, FILE **input, FILE **output, CloogOptions **options) { int i, infos=0, input_is_set=0 ; /* CloogOptions structure allocation and initialization. */ *options = cloog_options_malloc(state); /* The default output is the standard output. */ *output = stdout ; for (i=1;il,argc,argv,&i) ; else if (strcmp(argv[i],"-f") == 0) cloog_options_set(&(*options)->f,argc,argv,&i) ; else if (strcmp(argv[i],"-stop") == 0) cloog_options_set(&(*options)->stop,argc,argv,&i) ; else if (strcmp(argv[i],"-strides") == 0) cloog_options_set(&(*options)->strides,argc,argv,&i) ; else if (strcmp(argv[i],"-sh") == 0) cloog_options_set(&(*options)->sh,argc,argv,&i) ; else if (!strcmp(argv[i], "-first-unroll")) cloog_options_set(&(*options)->first_unroll, argc, argv, &i); else if (strcmp(argv[i],"-otl") == 0) cloog_options_set(&(*options)->otl,argc,argv,&i) ; else if (strcmp(argv[i],"-openscop") == 0) { #ifdef OSL_SUPPORT (*options)->openscop = 1 ; #else cloog_die("CLooG has not been compiled with OpenScop support.\n"); #endif } else if (strcmp(argv[i],"-esp") == 0) cloog_options_set(&(*options)->esp,argc,argv,&i) ; else if (strcmp(argv[i],"-fsp") == 0) cloog_options_set(&(*options)->fsp,argc,argv,&i) ; else if (strcmp(argv[i],"-block") == 0) cloog_options_set(&(*options)->block,argc,argv,&i) ; else if (strcmp(argv[i],"-compilable") == 0) cloog_options_set(&(*options)->compilable, argc, argv, &i); else if (strcmp(argv[i], "-callable") == 0) cloog_options_set(&(*options)->callable, argc, argv, &i); else if (strcmp(argv[i],"-loopo") == 0) /* Special option for the LooPo team ! */ { (*options)->esp = 0 ; (*options)->block = 1 ; } else if (strcmp(argv[i],"-bipbip") == 0)/* Special option for the author only !*/ (*options)->backtrack = 0; else if (strcmp(argv[i],"-leaks") == 0) (*options)->leaks = 1 ; else if (strcmp(argv[i],"-nobacktrack") == 0) (*options)->backtrack = 0; else if (strcmp(argv[i], "-backtrack") == 0) (*options)->backtrack = 1; else if (strcmp(argv[i],"-override") == 0) (*options)->override = 1 ; else if (strcmp(argv[i],"-noblocks") == 0) (*options)->noblocks = 1 ; else if (strcmp(argv[i],"-noscalars") == 0) (*options)->noscalars = 1 ; else if (strcmp(argv[i],"-nosimplify") == 0) (*options)->nosimplify = 1 ; else if ((strcmp(argv[i],"-struct") == 0) || (strcmp(argv[i],"-structure") == 0)) (*options)->structure = 1 ; else if ((strcmp(argv[i],"--help") == 0) || (strcmp(argv[i],"-h") == 0)) { cloog_options_help() ; infos = 1 ; } else if ((strcmp(argv[i],"--version") == 0) || (strcmp(argv[i],"-v") == 0)) { cloog_options_version() ; infos = 1 ; } else if ((strcmp(argv[i],"--quiet") == 0) || (strcmp(argv[i],"-q") == 0)) (*options)->quiet = 1; else if (strcmp(argv[i],"-o") == 0) { if (i+1 >= argc) cloog_die("no output name for -o option.\n"); /* stdout is a special value, when used, we set output to standard * output. */ if (strcmp(argv[i+1],"stdout") == 0) *output = stdout ; else { *output = fopen(argv[i+1],"w") ; if (*output == NULL) cloog_die("can't create output file %s.\n", argv[i+1]); } i ++ ; } else cloog_msg(*options, CLOOG_WARNING, "unknown %s option.\n", argv[i]); } else { if (!input_is_set) { input_is_set = 1 ; (*options)->name = argv[i] ; /* stdin is a special value, when used, we set input to standard input. */ if (strcmp(argv[i],"stdin") == 0) *input = stdin ; else { *input = fopen(argv[i],"r") ; if (*input == NULL) cloog_die("%s file does not exist.\n", argv[i]); } } else cloog_die("multiple input files.\n"); } if (!input_is_set) { if (!infos) cloog_die("no input file (-h for help).\n"); exit(1) ; } } #ifdef OSL_SUPPORT /** * This function extracts CLooG option values from an OpenScop scop and * updates an existing CloogOption structure with those values. If the * options were already set, they are updated without warning. * \param[in] scop Input Scop. * \param[in,out] options CLooG options to be updated. */ void cloog_options_copy_from_osl_scop(osl_scop_p scop, CloogOptions *options) { if (!options) cloog_die("Options must be provided.\n"); if (scop) { /* Extract the language. */ if (!strcmp(scop->language, "FORTRAN")) options->language = CLOOG_LANGUAGE_FORTRAN; else options->language = CLOOG_LANGUAGE_C; /* Store the input SCoP in the option structure. */ options->scop = scop; } } #endif