x86_64-linux-glibc2.15-4.8/include/cloog/options.h

   /**-------------------------------------------------------------------**
    **                               CLooG                               **
    **-------------------------------------------------------------------**
    **                             options.h                             **
    **-------------------------------------------------------------------**
    **                  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 <stdio.h>

#ifndef CLOOG_OPTIONS_H
#define CLOOG_OPTIONS_H
#if defined(__cplusplus)
extern "C" 
  {
#endif 


/* Uncomment the following line if you want some information about
 * maximum total allocated memory for code generation.
#define CLOOG_MEMORY 
 */
#define CLOOG_SCALARS

struct osl_scop;

struct cloogoptions;
typedef struct cloogoptions CloogOptions;
struct osl_scop;

struct cloogoptions
{
  CloogState *state; /* State. */
  /* OPTIONS FOR LOOP GENERATION */
  int l ;           /* Last level to optimize. */
  int f ;           /* First level to optimize. */

  int *ls;         /* Last level to optimize (statement-wise). */
  int *fs;         /* First level to optimize (statement-wise). */
  int fs_ls_size;  /* Size of the fs and ls arrays (same size) */
  int stop ;        /* Level to stop code generation. */
  int strides ;     /* 1 if user wants to handle non-unit strides (then loop
                     * increment can be something else than one), 0 otherwise.
                     */
  int sh;	    /* 1 for computing simple hulls */
  int first_unroll; /* The first dimension to unroll */

  /* OPTIONS FOR PRETTY PRINTING */
  int esp ;       /* 1 if user wants to spread all equalities, i.e. when there
                   * is something like "i = 3*j + 1 ; A[i] = 0 ;" the generator
                   * will write "A[3*j + 1] = 0 ;", 0 otherwise.
                   */
  int fsp ;       /* The iteration level where equalities spreading can begin
                   * (it might happen that the user wants not to spread values
                   * of scattering iterators).
                   */
  int otl ;       /* 1 for eliminate loops running just one time and write them
                   * as an affectation of the iterator, 0 otherwise.
                   */
  int block ;     /* 1 to make one new block {...} per new dimension,
                   * 0 otherwise.
                   */
  int compilable; /* 1 to generate a compilable code by using
                   * preprocessing, 0 otherwise.
                   */
  int callable;   /* 1 to generate callable code by using
                   * preprocessing, 0 otherwise.
                   */
  int language;   /* 1 to generate FORTRAN, 0 for C otherwise. */

  int save_domains;/* Save unsimplified copy of domain. */

  /* MISC OPTIONS */
  char * name ;   /* Name of the input file. */
  float time ;    /* Time spent for code generation in seconds. */
  int openscop;   /* 1 if the input file has OpenScop format, 0 otherwise. */
  struct osl_scop *scop; /* Input OpenScop scop if any, NULL otherwise. */
#ifdef CLOOG_MEMORY
  int memory ;    /* Memory spent for code generation in kilobytes. */
#endif
  int quiet;      /* Don't print any informational messages. */
  /* UNDOCUMENTED OPTIONS FOR THE AUTHOR ONLY */
  int leaks ;     /* 1 if I want to print the allocation statistics,
                   * 0 otherwise.
		   */
  int backtrack;  /* 1 to perform backtracking in 
                   * Quillere's algorithm, 0 otherwise.
		   */
  int override ;  /* 1 if I want to bypass CLooG decisions on option correctness
                   * (generated code may be incorrect), 0 otherwise.
		   */
  int structure ; /* 1 if I want to print the CloogProgram structure before the
                   * pretty printed code, 0 otherwise.
		   */
  int noblocks ;  /* 1 if I don't want to make statement blocks, 0 otherwise. */
  int noscalars ; /* 1 if I don't want to use scalar dimensions, 0 otherwise. */
  int nosimplify; /* 1 if I don't want to simplify polyhedra, 0 otherwise. */
} ;


/******************************************************************************
 *                          Error reporting functions                         *
 ******************************************************************************/

enum cloog_msg_type { CLOOG_ERROR, CLOOG_WARNING, CLOOG_INFO };

void cloog_msg(CloogOptions *options, enum cloog_msg_type type,
		const char *msg, ...);
void cloog_die(const char *msg, ...);


/******************************************************************************
 *                          Structure display function                        *
 ******************************************************************************/
void cloog_options_print(FILE *, CloogOptions *) ;


/******************************************************************************
 *                         Memory deallocation function                       *
 ******************************************************************************/
void cloog_options_free(CloogOptions *) ;


/******************************************************************************
 *                               Reading function                             *
 ******************************************************************************/
void cloog_options_read(CloogState *state, int argc, char **argv,
			FILE **input, FILE **output, CloogOptions **options);


/******************************************************************************
 *                            Processing functions                            *
 ******************************************************************************/
CloogOptions *cloog_options_malloc(CloogState *state);
void cloog_options_copy_from_osl_scop(struct osl_scop *, CloogOptions *);


#if defined(__cplusplus)
  }
#endif 
#endif /* define _H */