170 lines
7.8 KiB
C
170 lines
7.8 KiB
C
|
|
/**-------------------------------------------------------------------**
|
|
** 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 */
|