Haiku/buildtools
1
0
Fork 0
mirror of https://review.haiku-os.org/buildtools synced 2025-02-07 14:34:51 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
buildtools/cloog/source/names.c
Jerome Duval 5873a060ca imported PPL 0.11.1 and CLooG 0.18.0. 
* these are dependencies for gcc 4 Graphite engine build.
* CLooG 0.18.0 includes ISL 0.11.1 which is the backend that the build script enables.
* PPL is needed by GCC build even if it isn't the chosen backend.
2013-04-06 15:10:34 +02:00

527 lines
18 KiB
C
Raw Blame History

/**-------------------------------------------------------------------**
** CLooG **
**-------------------------------------------------------------------**
** names.c **
**-------------------------------------------------------------------**
** First version: august 1st 2002 **
**-------------------------------------------------------------------**/
/******************************************************************************
* CLooG : the Chunky Loop Generator (experimental) *
******************************************************************************
* *
* Copyright (C) 2002-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 *
* *
******************************************************************************/
/* CAUTION: the english used for comments is probably the worst you ever read,
* please feel free to correct and improve it !
*/
# include <stdlib.h>
# include <stdio.h>
# include <ctype.h>
# include "../include/cloog/cloog.h"
/******************************************************************************
* Structure display function *
******************************************************************************/
/**
* cloog_names_print function:
* this function is a human-friendly way to display the CloogNames data
* structure, it shows all the different fields and includes an indentation
* level (level) in order to work with others print_structure functions.
* - July 1st 2005: first version based on the old cloog_names_print function,
* it was the first modification in this file since two years !
*/
void cloog_names_print_structure(FILE * file, CloogNames * names, int level)
{ int i ;
/* Go to the right level. */
for (i=0; i<level; i++)
fprintf(file,"|\t") ;
if (names != NULL)
{ fprintf(file,"+-- CloogNames\n") ;
/* A blank line. */
for (i=0; i<=level+1; i++)
fprintf(file,"|\t") ;
fprintf(file,"\n") ;
/* Print the scalar dimension number. */
for (i=0; i<=level; i++)
fprintf(file,"|\t") ;
fprintf(file,"Scalar dimension number ---: %d\n",names->nb_scalars) ;
/* A blank line. */
for (i=0; i<=level+1; i++)
fprintf(file,"|\t") ;
fprintf(file,"\n") ;
/* Print the scalar iterators. */
for (i=0; i<=level; i++)
fprintf(file,"|\t") ;
if (names->nb_scalars > 0)
{ fprintf(file,"+-- Scalar iterator strings:") ;
for (i=0;i<names->nb_scalars;i++)
fprintf(file," %s",names->scalars[i]) ;
fprintf(file,"\n") ;
}
else
fprintf(file,"+-- No scalar string\n") ;
/* A blank line. */
for (i=0; i<=level+1; i++)
fprintf(file,"|\t") ;
fprintf(file,"\n") ;
/* Print the scattering dimension number. */
for (i=0; i<=level; i++)
fprintf(file,"|\t") ;
fprintf(file,"Scattering dimension number: %d\n",names->nb_scattering) ;
/* A blank line. */
for (i=0; i<=level+1; i++)
fprintf(file,"|\t") ;
fprintf(file,"\n") ;
/* Print the scattering iterators. */
for (i=0; i<=level; i++)
fprintf(file,"|\t") ;
if (names->nb_scattering > 0)
{ fprintf(file,"+-- Scattering strings ----:") ;
for (i=0;i<names->nb_scattering;i++)
fprintf(file," %s",names->scattering[i]) ;
fprintf(file,"\n") ;
}
else
fprintf(file,"+-- No scattering string\n") ;
/* A blank line. */
for (i=0; i<=level+1; i++)
fprintf(file,"|\t") ;
fprintf(file,"\n") ;
/* Print the iterator number. */
for (i=0; i<=level; i++)
fprintf(file,"|\t") ;
fprintf(file,"Iterator number -----------: %d\n",names->nb_iterators) ;
/* A blank line. */
for (i=0; i<=level+1; i++)
fprintf(file,"|\t") ;
fprintf(file,"\n") ;
/* Print the iterators. */
for (i=0; i<=level; i++)
fprintf(file,"|\t") ;
if (names->nb_iterators > 0)
{ fprintf(file,"+-- Iterator strings ------:") ;
for (i=0;i<names->nb_iterators;i++)
fprintf(file," %s",names->iterators[i]) ;
fprintf(file,"\n") ;
}
else
fprintf(file,"+-- No iterators\n") ;
/* A blank line. */
for (i=0; i<=level+1; i++)
fprintf(file,"|\t") ;
fprintf(file,"\n") ;
/* Print the parameter number. */
for (i=0; i<=level; i++)
fprintf(file,"|\t") ;
fprintf(file,"Parameter number ----------: %d\n",names->nb_parameters) ;
/* A blank line. */
for (i=0; i<=level+1; i++)
fprintf(file,"|\t") ;
fprintf(file,"\n") ;
/* Print the parameters. */
for (i=0; i<=level; i++)
fprintf(file,"|\t") ;
if (names->nb_parameters > 0)
{ fprintf(file,"+-- Parameter strings -----:") ;
for (i=0;i<names->nb_parameters;i++)
fprintf(file," %s",names->parameters[i]) ;
fprintf(file,"\n") ;
}
else
fprintf(file,"No parameters\n") ;
}
else
fprintf(file,"+-- No CloogNames\n") ;
fprintf(file, "Number of active references: %d\n", names->references);
}
/**
* cloog_names_print function:
* This function prints the content of a CloogNames structure (names) into a
* file (file, possibly stdout).
* - July 1st 2005: Now this function is only a frontend to
* cloog_program_print_structure, with a quite better
* human-readable representation.
*/
void cloog_names_print(FILE * file, CloogNames * names)
{ cloog_names_print_structure(file,names,0) ;
}
/******************************************************************************
* Memory deallocation function *
******************************************************************************/
/**
* cloog_names_free function:
* This function decrements the number of active references to
* a CloogNames structure and frees the allocated memory for this structure
* if the count drops to zero.
*/
void cloog_names_free(CloogNames * names)
{ int i ;
if (--names->references)
return;
if (names->scalars != NULL)
{ for (i=0;i<names->nb_scalars;i++)
free(names->scalars[i]) ;
free(names->scalars) ;
}
if (names->scattering != NULL)
{ for (i=0;i<names->nb_scattering;i++)
free(names->scattering[i]) ;
free(names->scattering) ;
}
if (names->iterators != NULL)
{ for (i=0;i<names->nb_iterators;i++)
free(names->iterators[i]) ;
free(names->iterators) ;
}
if (names->parameters != NULL)
{ for (i=0;i<names->nb_parameters;i++)
free(names->parameters[i]) ;
free(names->parameters) ;
}
free(names) ;
}
/**
* cloog_names_copy function:
* As usual in CLooG, "copy" means incrementing the reference count.
*/
CloogNames *cloog_names_copy(CloogNames *names)
{
names->references++;
return names;
}
/******************************************************************************
* Reading functions *
******************************************************************************/
/**
* cloog_names_read_strings function:
* This function reads names data from a file (file, possibly stdin). It first
* reads the naming option to know if whether it can read the names from the
* file. If not, NULL is returned. Otherwise, the names are stored
* into an array of strings, and a pointer to this array is returned.
* - nb_items is the number of names the function will have to read if the
* naming option is set to read.
*/
char ** cloog_names_read_strings(FILE *file, int nb_items)
{ int i, option, n ;
char s[MAX_STRING], str[MAX_STRING], * c, **names = NULL;
/* We first read name option. */
while (fgets(s,MAX_STRING,file) == 0) ;
while ((*s=='#' || *s=='\n') || (sscanf(s," %d",&option)<1))
fgets(s,MAX_STRING,file) ;
/* If there is no item to read, then return NULL. */
if (nb_items == 0)
return NULL ;
/* If option is to read them in the file, then we do it and put them into
* the array.
*/
if (option)
{ /* Memory allocation. */
names = (char **)malloc(nb_items*sizeof(char *)) ;
if (names == NULL)
cloog_die("memory overflow.\n");
for (i=0;i<nb_items;i++)
{ names[i] = (char *)malloc(MAX_NAME*sizeof(char)) ;
if (names[i] == NULL)
cloog_die("memory overflow.\n");
}
do /* Skip the comments, spaces and empty lines... */
{ c = fgets(s,MAX_STRING,file) ;
while ((c != NULL) && isspace(*c) && (*c != '\n'))
c++ ;
}
while (c != NULL && (*c == '#' || *c == '\n'));
if (c == NULL)
cloog_die("no names in input file.\n");
for (i=0;i<nb_items;i++)
{ /* All names must be on the same line. */
while (isspace(*c))
c++ ;
if (!*c || *c == '#' || *c == '\n')
cloog_die("not enough names in input file.\n");
/* n is strlen(str). */
if (sscanf(c,"%s%n",str,&n) == 0)
cloog_die("no names in input file.\n");
sscanf(str,"%s",names[i]) ;
c += n ;
}
}
return names ;
}
/******************************************************************************
* Processing functions *
******************************************************************************/
/**
* cloog_names_malloc function:
* This function allocates the memory space for a CloogNames structure and
* sets its fields with default values. Then it returns a pointer to the
* allocated space.
* - November 21th 2005: first version.
*/
CloogNames * cloog_names_malloc()
{ CloogNames * names ;
/* Memory allocation for the CloogNames structure. */
names = (CloogNames *)malloc(sizeof(CloogNames)) ;
if (names == NULL)
cloog_die("memory overflow.\n");
/* We set the various fields with default values. */
names->nb_scalars = 0 ;
names->nb_scattering = 0 ;
names->nb_iterators = 0 ;
names->nb_parameters = 0 ;
names->scalars = NULL ;
names->scattering = NULL ;
names->iterators = NULL ;
names->parameters = NULL ;
names->references = 1;
return names ;
}
/**
* cloog_names_alloc function:
* This function allocates the memory space for a CloogNames structure and
* sets its fields with those given as input. Then it returns a pointer to the
* allocated space.
* - July 7th 2005: first version.
* - September 11th 2005: addition of both scalar and scattering informations.
* - November 21th 2005: use of cloog_names_malloc.
*/
CloogNames * cloog_names_alloc()
{ CloogNames * names ;
/* Memory allocation for the CloogNames structure. */
names = cloog_names_malloc() ;
names->nb_scalars = 0;
names->nb_scattering = 0;
names->nb_iterators = 0;
names->nb_parameters = 0;
names->scalars = NULL;
names->scattering = NULL;
names->iterators = NULL;
names->parameters = NULL;
return names ;
}
/**
* cloog_names_generate_items function:
* This function returns a pointer to an array of strings with entries set
* based on the function's parameters.
* - nb_items will be the number of entries in the string array.
* - prefix is the name prefix of each item or NULL.
* If not NULL, then the remainder of the name will be an integer
* in the range [0, nb_items-1].
* - first_item is the name of the first item (if prefix == NULL),
* the nb_items-1 following items will be the nb_items-1
* following letters in ASCII code.
**
* - September 9th 2002 : first version, extracted from cloog_names_generate.
*/
char ** cloog_names_generate_items(int nb_items, char * prefix, char first_item)
{ int i ;
char ** names ;
if (nb_items == 0)
return NULL ;
names = (char **)malloc(nb_items*sizeof(char *)) ;
if (names == NULL)
cloog_die("memory overflow.\n");
for (i=0;i<nb_items;i++)
{ names[i] = (char *)malloc(MAX_NAME*sizeof(char)) ;
if (names[i] == NULL)
cloog_die("memory overflow.\n");
if (prefix == NULL)
sprintf(names[i],"%c",first_item+i) ;
else
sprintf(names[i], "%s%d", prefix, 1+i);
}
return names ;
}
/**
* cloog_names_generate function:
* This function returns a pointer to a CloogNames structure with fields set
* thanks to the function's parameters.
* - nb_scalars will be the number of scalar dimensions in the structure.
* - nb_scattering will be the number of scattering dimensions in the structure.
* - nb_iterators will be the number of iterators in the CloogNames structure.
* - nb_parameters will be the number of parameters in the CloogNames structure.
* - first_s is the name of the first scalar iterator, the nb_scalars-1
* following iterators will be the nb_scalars-1 following letters in ASCII.
* - first_t is the name of the first scattering iterator, the nb_scattering-1
* following iterators will be the nb_scattering-1 following letters in ASCII.
* - first_i is the name of the first iterator, the nb_iterators-1 following
* iterators will be the nb_iterators-1 following letters in ASCII code.
* - first_i is the name of the first iterator, the nb_iterators-1 following
* iterators will be the nb_iterators-1 following letters in ASCII code.
* - first_p is the name of the first parameter, the nb_parameters-1 following
* parameters will be the nb_parameters-1 following letters in ASCII code.
**
* - July 1st 2002 : first version.
* - September 9th 2002 : use of cloog_names_generate_items.
* - September 11th 2005 : addition of both scalar and scattering informations.
*/
CloogNames * cloog_names_generate(
int nb_scalars, int nb_scattering, int nb_iterators, int nb_parameters,
char first_s, char first_t, char first_i, char first_p)
{ CloogNames * names ;
names = (CloogNames *)malloc(sizeof(CloogNames)) ;
if (names == NULL)
cloog_die("memory overflow.\n");
names->nb_scalars = nb_scalars ;
names->nb_scattering = nb_scattering ;
names->nb_parameters = nb_parameters ;
names->nb_iterators = nb_iterators ;
names->scalars = cloog_names_generate_items(nb_scalars, NULL,first_s);
names->scattering = cloog_names_generate_items(nb_scattering,NULL,first_t);
names->parameters = cloog_names_generate_items(nb_parameters,NULL,first_p);
names->iterators = cloog_names_generate_items(nb_iterators, NULL,first_i);
return names ;
}
/* Lastly we update the CLoogNames structure: the iterators corresponding to
* scalar dimensions have to be removed since these dimensions have been
* erased and do not need to be print. We copy all the iterator names except
* the scalar ones in a new string array.
* - September 12th 2005: first version.
*/
void cloog_names_scalarize(CloogNames * names, int nb_scattdims, int * scaldims)
{ int nb_scalars, nb_scattering, i, current_scalar, current_scattering ;
char ** scalars, ** scattering ;
if (!nb_scattdims || (scaldims == NULL))
return ;
nb_scalars = 0 ;
for (i=0;i<nb_scattdims;i++)
if (scaldims[i])
nb_scalars ++ ;
if (!nb_scalars)
return ;
nb_scattering = names->nb_scattering - nb_scalars ;
scattering = (char **)malloc(nb_scattering * sizeof(char *)) ;
if (scattering == NULL)
cloog_die("memory overflow.\n");
scalars = (char **)malloc(nb_scalars * sizeof(char *)) ;
if (scalars == NULL)
cloog_die("memory overflow.\n");
current_scalar = 0 ;
current_scattering = 0 ;
for (i=0;i<nb_scattdims;i++)
{ if (!scaldims[i])
{ scattering[current_scattering] = names->scattering[i] ;
current_scattering ++ ;
}
else
{ scalars[current_scalar] = names->scattering[i] ;
current_scalar ++ ;
}
}
free(names->scattering) ;
names->scattering = scattering ;
names->scalars = scalars ;
names->nb_scattering = nb_scattering ;
names->nb_scalars = nb_scalars ;
}
/**
* Return the name at a given level (starting at one).
* May be a scattering dimension or an iterator of the original domain.
*/
const char *cloog_names_name_at_level(CloogNames *names, int level)
{
if (level <= names->nb_scattering)
return names->scattering[level - 1];
else
return names->iterators[level - names->nb_scattering - 1];
}
Reference in New Issue View Git Blame Copy Permalink