source/options.c

   1
   2    /**-------------------------------------------------------------------**
   3     **                              CLooG                                **
   4     **-------------------------------------------------------------------**
   5     **                            options.c                              **
   6     **-------------------------------------------------------------------**
   7     **                  First version: april 19th 2003                   **
   8     **-------------------------------------------------------------------**/
   9
  10
  11 /******************************************************************************
  12  *               CLooG : the Chunky Loop Generator (experimental)             *
  13  ******************************************************************************
  14  *                                                                            *
  15  * Copyright (C) 2001-2005 Cedric Bastoul                                     *
  16  *                                                                            *
  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.         *
  21  *                                                                            *
  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.                            *
  26  *                                                                            *
  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                                                *
  31  *                                                                            *
  32  * CLooG, the Chunky Loop Generator                                           *
  33  * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr                         *
  34  *                                                                            *
  35  ******************************************************************************/
  36
  37
  38 #include <stdarg.h>
  39 # include <stdlib.h>
  40 # include <stdio.h>
  41 # include <string.h>
  42 # include "../include/cloog/cloog.h"
  43
  44 #ifdef OSL_SUPPORT
  45 #include <osl/scop.h>
  46 #endif
  47
  48
  49 /******************************************************************************
  50  *                          Error reporting functions                         *
  51  ******************************************************************************/
  52
  53 void cloog_vmsg(CloogOptions *options, enum cloog_msg_type type,
  54                 const char *msg, va_list ap)
  55 {
  56   const char *type_msg;
  57
  58   if (options && options->quiet &&
  59       (type == CLOOG_WARNING || type == CLOOG_INFO))
  60     return;
  61
  62   switch(type) {
  63   case CLOOG_WARNING:
  64         type_msg = "WARNING";
  65         break;
  66   case CLOOG_INFO:
  67         type_msg = "INFO";
  68         break;
  69   case CLOOG_ERROR:
  70   default:
  71         type_msg = "ERROR";
  72         break;
  73   }
  74   fprintf(stderr, "[CLooG] %s: ", type_msg);
  75   vfprintf(stderr, msg, ap);
  76 }
  77
  78 /**
  79  * Print message to stderr.
  80  * @param msg printf format string
  81  */
  82 void cloog_msg(CloogOptions *options, enum cloog_msg_type type,
  83                 const char *msg, ...)
  84 {
  85   va_list args;
  86
  87   va_start(args, msg);
  88   cloog_vmsg(options, type, msg, args);
  89   va_end(args);
  90 }
  91
  92 /**
  93  * Print error message to stderr and exit.
  94  * @param msg printf format string
  95  */
  96 void cloog_die(const char *msg, ...)
  97 {
  98   va_list args;
  99
 100   va_start(args, msg);
 101   cloog_vmsg(NULL, CLOOG_ERROR, msg, args);
 102   va_end(args);
 103   exit(1);
 104 }
 105
 106 /******************************************************************************
 107  *                          Structure display function                        *
 108  ******************************************************************************/
 109
 110
 111 /**
 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.
 116  */
 117 void cloog_options_print(FILE * foo, CloogOptions * options)
 118 { fprintf(foo,"Options:\n") ;
 119   fprintf(foo,"OPTIONS FOR LOOP GENERATION\n") ;
 120   fprintf(foo,"l           = %3d,\n",options->l) ;
 121   fprintf(foo,"f           = %3d,\n",options->f) ;
 122   fprintf(foo,"stop        = %3d,\n",options->stop) ;
 123   fprintf(foo,"strides     = %3d,\n",options->strides) ;
 124   fprintf(foo,"sh          = %3d,\n",options->sh);
 125   fprintf(foo,"OPTIONS FOR PRETTY PRINTING\n") ;
 126   fprintf(foo,"esp         = %3d,\n",options->esp) ;
 127   fprintf(foo,"fsp         = %3d,\n",options->fsp) ;
 128   fprintf(foo,"otl         = %3d.\n",options->otl) ;
 129   fprintf(foo,"block       = %3d.\n",options->block) ;
 130   fprintf(foo,"compilable  = %3d.\n",options->compilable) ;
 131   fprintf(foo,"callable    = %3d.\n",options->callable) ;
 132   fprintf(foo,"MISC OPTIONS\n") ;
 133   fprintf(foo,"name        = %3s.\n", options->name);
 134   fprintf(foo,"openscop    = %3d.\n", options->openscop);
 135   if (options->scop != NULL)
 136     fprintf(foo,"scop        = (present but not printed).\n");
 137   else
 138     fprintf(foo,"scop        = NULL.\n");
 139   fprintf(foo,"UNDOCUMENTED OPTIONS FOR THE AUTHOR ONLY\n") ;
 140   fprintf(foo,"leaks       = %3d.\n",options->leaks) ;
 141   fprintf(foo,"backtrack   = %3d.\n",options->backtrack);
 142   fprintf(foo,"override    = %3d.\n",options->override) ;
 143   fprintf(foo,"structure   = %3d.\n",options->structure) ;
 144   fprintf(foo,"noscalars   = %3d.\n",options->noscalars) ;
 145   fprintf(foo,"noblocks    = %3d.\n",options->noblocks) ;
 146   fprintf(foo,"nosimplify  = %3d.\n",options->nosimplify) ;
 147 }
 148
 149
 150 /******************************************************************************
 151  *                         Memory deallocation function                       *
 152  ******************************************************************************/
 153
 154
 155 /**
 156  * cloog_options_free function:
 157  * This function frees the allocated memory for a CloogOptions structure.
 158  * - April 19th 2003: first version.
 159  */
 160 void cloog_options_free(CloogOptions *options)
 161 {
 162 #ifdef OSL_SUPPORT
 163   if (options->scop != NULL) {
 164     osl_scop_free(options->scop);
 165   }
 166 #endif
 167   free(options);
 168 }
 169
 170
 171 /******************************************************************************
 172  *                            Processing functions                            *
 173  ******************************************************************************/
 174
 175
 176 /**
 177  * cloog_options_help function:
 178  * This function displays the quick help when the user set the option -help
 179  * while calling cloog. Prints are cutted to respect the 509 characters
 180  * limitation of the ISO C 89 compilers.
 181  * - August 5th 2002: first version.
 182  */
 183 void cloog_options_help()
 184 { printf(
 185   "Usage: cloog [ options | file ] ...\n"
 186   "Options for code generation:\n"
 187   "  -l <depth>            Last loop depth to optimize (-1: infinity)\n"
 188   "                        (default setting: -1).\n"
 189   "  -f <depth>            First loop depth to start loop separation (-1: "
 190   "infinity)\n                        (default setting:  1).\n") ;
 191   printf(
 192   "  -stop <depth>         Loop depth to stop code generation (-1: infinity)"
 193   "\n                        (default setting: -1).\n"
 194   "  -strides <boolean>    Handle non-unit strides (1) or not (0)\n"
 195   "                        (default setting:  0).\n"
 196   "  -first-unroll <depth> First loop dimension to unroll (-1: no unrolling)\n");
 197   printf(
 198   "\nOptions for pretty printing:\n"
 199   "  -otl <boolean>        Simplify loops running one time (1) or not (0)\n"
 200   "                        (default setting:  1).\n") ;
 201   printf(
 202   "  -esp <boolean>        Allow complex equalities spreading (1) or not (0)\n"
 203   "                        (default setting:  0).\n");
 204   printf(
 205   "  -fsp <level>          First level to begin the spreading\n"
 206   "                        (default setting:  1).\n"
 207   "  -block <boolean>      Make a new statement block per iterator in C\n"
 208   "                        programs (1) or not (0) (default setting: 0).\n") ;
 209   printf(
 210   "  -compilable <number>  Compilable code by using preprocessor (not 0) or"
 211   "\n                        not (0), number being the value of the parameters"
 212   "\n                        (default setting:  0).\n"
 213   "  -callable <boolean>   Testable code by using preprocessor (not 0) or"
 214   "\n                        not (0) (default setting:  0).\n");
 215   printf(
 216   "\nGeneral options:\n"
 217   "  -o <output>           Name of the output file; 'stdout' is a special\n"
 218   "                        value: when used, output is standard output\n"
 219   "                        (default setting: stdout).\n"
 220 #ifdef OSL_SUPPORT
 221   "  -openscop             Input file has OpenScop format.\n"
 222 #endif
 223   "  -v, --version         Display the version information (and more).\n"
 224   "  -q, --quiet           Don't print any informational messages.\n"
 225   "  -h, --help            Display this information.\n\n") ;
 226   printf(
 227   "The special value 'stdin' for 'file' makes CLooG to read data on\n"
 228   "standard input.\n\n"
 229   "For bug reporting or any suggestions, please send an email to the author\n"
 230   "<cedric.bastoul@inria.fr>.\n") ;
 231 }
 232
 233
 234 /**
 235  * cloog_options_version function:
 236  * This function displays some version informations when the user set the
 237  * option -version while calling cloog. Prints are cutted to respect the 509
 238  * characters limitation of the ISO C 89 compilers.
 239  * - August 5th 2002: first version.
 240  */
 241 void cloog_options_version()
 242 { printf("%s       The Chunky Loop Generator\n", cloog_version());
 243   printf(
 244   "-----\n"
 245   "This is a loop generator for scanning Z-polyhedra. It is based on the "
 246   "work of\nF. Quillere and C. Bastoul on high level code generation and of "
 247   "the PolyLib Team\non polyhedral computation. This program is distributed "
 248   "under the terms of the\nGNU Lesser General Public License "
 249   "(details at http://www.gnu.org/licenses/lgpl-2.1.html).\n"
 250   "-----\n") ;
 251   printf(
 252   "It would be fair to refer the following paper in any publication "
 253   "resulting from\nthe use of this software or its library:\n"
 254   "@InProceedings{Bas04,\n"
 255   "author    =  {Cedric Bastoul},\n"
 256   "title     =  {Code Generation in the Polyhedral Model Is Easier Than You "
 257   "Think},\n"
 258   "booktitle =  {PACT'13 IEEE International Conference on Parallel "
 259   "Architecture\n             and Compilation Techniques},\n"
 260   "pages     =  {7--16},\n"
 261   "month     =  {september},\n"
 262   "year      =  2004,\n"
 263   "address   =  {Juan-les-Pins}\n"
 264   "}\n"
 265   "-----\n"
 266   "For any information, please ask the author at "
 267   "<cedric.bastoul@inria.fr>.\n") ;
 268 }
 269
 270
 271 /**
 272  * cloog_options_set function:
 273  * This function sets the value of an option thanks to the user's calling line.
 274  * - option is the value to set,
 275  * - argc are the elements of the user's calling line,
 276  * - number is the number of the element corresponding to the considered option,
 277  *   this function adds 1 to number to pass away the option value.
 278  **
 279  * - August 5th 2002: first version.
 280  * - June 29th 2003: (debug) lack of argument now detected.
 281  */
 282 void cloog_options_set(int * option, int argv, char ** argc, int * number)
 283 { char ** endptr ;
 284
 285   if (*number+1 >= argv)
 286     cloog_die("an option lacks of argument.\n");
 287
 288   endptr = NULL ;
 289   *option = strtol(argc[*number+1],endptr,10) ;
 290   if (endptr != NULL)
 291     cloog_die("value '%s' for option '%s' is not valid.\n",
 292               argc[*number+1], argc[*number]);
 293   *number = *number + 1 ;
 294 }
 295
 296
 297 /**
 298  * cloog_options_malloc function:
 299  * This functions allocate the memory space for a CLoogOptions structure and
 300  * fill its fields with the defaults values. It returns a pointer to the
 301  * allocated CloogOptions structure.
 302  * - April    19th 2003: first version.
 303  * - November 21th 2005: name changed (before it was cloog_options_init).
 304  */
 305 CloogOptions *cloog_options_malloc(CloogState *state)
 306 { CloogOptions * options ;
 307
 308   /* Memory allocation for the CloogOptions structure. */
 309   options = (CloogOptions *)malloc(sizeof(CloogOptions)) ;
 310   if (options == NULL)
 311     cloog_die("memory overflow.\n");
 312
 313   options->state = state;
 314
 315   /* We set the various fields with default values. */
 316   /* OPTIONS FOR LOOP GENERATION */
 317   options->l           = -1 ;  /* Last level to optimize: infinity. */
 318   options->f           =  1 ;  /* First level to optimize: the first. */
 319   options->stop        = -1 ;  /* Generate all the code. */
 320   options->strides     =  0 ;  /* Generate a code with unit strides. */
 321   options->sh          =  0;   /* Compute actual convex hull. */
 322   options->first_unroll = -1;  /* First level to unroll: none. */
 323   options->name        = "";
 324   /* OPTIONS FOR PRETTY PRINTING */
 325   options->esp         =  1 ;  /* We want Equality SPreading.*/
 326   options->fsp         =  1 ;  /* The First level to SPread is the first. */
 327   options->otl         =  1 ;  /* We want to fire One Time Loops. */
 328   options->block       =  0 ;  /* We don't want to force statement blocks. */
 329   options->compilable  =  0 ;  /* No compilable code. */
 330   options->callable    =  0 ;  /* No callable code. */
 331   options->quiet       =  0;   /* Do print informational messages. */
 332   options->save_domains = 0;   /* Don't save domains. */
 333   /* MISC OPTIONS */
 334   options->language    = CLOOG_LANGUAGE_C; /* The default output language is C. */
 335   options->openscop    =  0 ;  /* The input file has not the OpenScop format.*/
 336   options->scop        =  NULL;/* No default SCoP.*/
 337   /* UNDOCUMENTED OPTIONS FOR THE AUTHOR ONLY */
 338   options->leaks       =  0 ;  /* I don't want to print allocation statistics.*/
 339   options->backtrack   =  0;   /* Perform backtrack in Quillere's algorithm.*/
 340   options->override    =  0 ;  /* I don't want to override CLooG decisions.*/
 341   options->structure   =  0 ;  /* I don't want to print internal structure.*/
 342   options->noblocks    =  0 ;  /* I do want to make statement blocks.*/
 343   options->noscalars   =  0 ;  /* I do want to use scalar dimensions.*/
 344   options->nosimplify  =  0 ;  /* I do want to simplify polyhedra.*/
 345
 346   return options ;
 347 }
 348
 349
 350
 351 /**
 352  * cloog_options_read function:
 353  * This functions reads all the options and the input/output files thanks
 354  * the the user's calling line elements (in argc). It fills a CloogOptions
 355  * structure and the FILE structure corresponding to input and output files.
 356  * - August 5th 2002: first version.
 357  * - April 19th 2003: now in options.c and support of the CloogOptions structure.
 358  */
 359 void cloog_options_read(CloogState *state, int argc, char **argv,
 360                         FILE **input, FILE **output, CloogOptions **options)
 361 { int i, infos=0, input_is_set=0 ;
 362
 363   /* CloogOptions structure allocation and initialization. */
 364   *options = cloog_options_malloc(state);
 365
 366   /* The default output is the standard output. */
 367   *output = stdout ;
 368
 369   for (i=1;i<argc;i++)
 370   if (argv[i][0] == '-')
 371   { if (strcmp(argv[i],"-l")   == 0)
 372     cloog_options_set(&(*options)->l,argc,argv,&i) ;
 373     else
 374     if (strcmp(argv[i],"-f")   == 0)
 375     cloog_options_set(&(*options)->f,argc,argv,&i) ;
 376     else
 377     if (strcmp(argv[i],"-stop")   == 0)
 378     cloog_options_set(&(*options)->stop,argc,argv,&i) ;
 379     else
 380     if (strcmp(argv[i],"-strides")   == 0)
 381     cloog_options_set(&(*options)->strides,argc,argv,&i) ;
 382     else if (strcmp(argv[i],"-sh")   == 0)
 383       cloog_options_set(&(*options)->sh,argc,argv,&i) ;
 384     else if (!strcmp(argv[i], "-first-unroll"))
 385       cloog_options_set(&(*options)->first_unroll, argc, argv, &i);
 386     else
 387     if (strcmp(argv[i],"-otl") == 0)
 388     cloog_options_set(&(*options)->otl,argc,argv,&i) ;
 389     else
 390     if (strcmp(argv[i],"-openscop") == 0) {
 391 #ifdef OSL_SUPPORT
 392       (*options)->openscop = 1 ;
 393 #else
 394       cloog_die("CLooG has not been compiled with OpenScop support.\n");
 395 #endif
 396     }
 397     else
 398     if (strcmp(argv[i],"-esp") == 0)
 399     cloog_options_set(&(*options)->esp,argc,argv,&i) ;
 400     else
 401     if (strcmp(argv[i],"-fsp") == 0)
 402     cloog_options_set(&(*options)->fsp,argc,argv,&i) ;
 403     else
 404     if (strcmp(argv[i],"-block") == 0)
 405     cloog_options_set(&(*options)->block,argc,argv,&i) ;
 406     else
 407     if (strcmp(argv[i],"-compilable") == 0)
 408       cloog_options_set(&(*options)->compilable, argc, argv, &i);
 409     else if (strcmp(argv[i], "-callable") == 0)
 410       cloog_options_set(&(*options)->callable, argc, argv, &i);
 411     else
 412     if (strcmp(argv[i],"-loopo") == 0) /* Special option for the LooPo team ! */
 413     { (*options)->esp   = 0 ;
 414       (*options)->block = 1 ;
 415     }
 416     else
 417     if (strcmp(argv[i],"-bipbip") == 0)/* Special option for the author only !*/
 418       (*options)->backtrack = 0;
 419     else
 420     if (strcmp(argv[i],"-leaks") == 0)
 421     (*options)->leaks = 1 ;
 422     else
 423     if (strcmp(argv[i],"-nobacktrack") == 0)
 424       (*options)->backtrack = 0;
 425     else if (strcmp(argv[i], "-backtrack") == 0)
 426       (*options)->backtrack = 1;
 427     else
 428     if (strcmp(argv[i],"-override") == 0)
 429     (*options)->override = 1 ;
 430     else
 431     if (strcmp(argv[i],"-noblocks") == 0)
 432     (*options)->noblocks = 1 ;
 433     else
 434     if (strcmp(argv[i],"-noscalars") == 0)
 435     (*options)->noscalars = 1 ;
 436     else
 437     if (strcmp(argv[i],"-nosimplify") == 0)
 438     (*options)->nosimplify = 1 ;
 439     else
 440     if ((strcmp(argv[i],"-struct") == 0) || (strcmp(argv[i],"-structure") == 0))
 441     (*options)->structure = 1 ;
 442     else
 443     if ((strcmp(argv[i],"--help") == 0) || (strcmp(argv[i],"-h") == 0))
 444     { cloog_options_help() ;
 445       infos = 1 ;
 446     }
 447     else
 448     if ((strcmp(argv[i],"--version") == 0) || (strcmp(argv[i],"-v") == 0))
 449     { cloog_options_version() ;
 450       infos = 1 ;
 451     } else if ((strcmp(argv[i],"--quiet") == 0) || (strcmp(argv[i],"-q") == 0))
 452       (*options)->quiet = 1;
 453     else
 454     if (strcmp(argv[i],"-o") == 0)
 455     { if (i+1 >= argc)
 456         cloog_die("no output name for -o option.\n");
 457
 458       /* stdout is a special value, when used, we set output to standard
 459        * output.
 460        */
 461       if (strcmp(argv[i+1],"stdout") == 0)
 462       *output = stdout ;
 463       else
 464       { *output = fopen(argv[i+1],"w") ;
 465         if (*output == NULL)
 466           cloog_die("can't create output file %s.\n", argv[i+1]);
 467       }
 468       i ++ ;
 469     }
 470     else
 471       cloog_msg(*options, CLOOG_WARNING, "unknown %s option.\n", argv[i]);
 472   }
 473   else
 474   { if (!input_is_set)
 475     { input_is_set = 1 ;
 476       (*options)->name = argv[i] ;
 477       /* stdin is a special value, when used, we set input to standard input. */
 478       if (strcmp(argv[i],"stdin") == 0)
 479       *input = stdin ;
 480       else
 481       { *input = fopen(argv[i],"r") ;
 482         if (*input == NULL)
 483           cloog_die("%s file does not exist.\n", argv[i]);
 484       }
 485     }
 486     else
 487       cloog_die("multiple input files.\n");
 488   }
 489   if (!input_is_set)
 490   { if (!infos)
 491       cloog_die("no input file (-h for help).\n");
 492     exit(1) ;
 493   }
 494 }
 495
 496 #ifdef OSL_SUPPORT
 497 /**
 498  * This function extracts CLooG option values from an OpenScop scop and
 499  * updates an existing CloogOption structure with those values. If the
 500  * options were already set, they are updated without warning.
 501  * \param[in]     scop    Input Scop.
 502  * \param[in,out] options CLooG options to be updated.
 503  */
 504 void cloog_options_copy_from_osl_scop(osl_scop_p scop,
 505                                       CloogOptions *options) {
 506   if (!options)
 507     cloog_die("Options must be provided.\n");
 508
 509   if (scop) {
 510     /* Extract the language. */
 511     if (!strcmp(scop->language, "FORTRAN"))
 512       options->language = CLOOG_LANGUAGE_FORTRAN;
 513     else
 514       options->language = CLOOG_LANGUAGE_C;
 515
 516     /* Store the input SCoP in the option structure. */
 517     options->scop = scop;
 518   }
 519 }
 520 #endif
 521