source/statement.c

   1
   2    /**-------------------------------------------------------------------**
   3     **                              CLooG                                **
   4     **-------------------------------------------------------------------**
   5     **                           statement.c                             **
   6     **-------------------------------------------------------------------**
   7     **                 First version: november 4th 2001                  **
   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 /* CAUTION: the english used for comments is probably the worst you ever read,
  37  *          please feel free to correct and improve it !
  38  */
  39
  40 # include <stdlib.h>
  41 # include <stdio.h>
  42 # include <string.h>
  43 # include "../include/cloog/cloog.h"
  44
  45
  46 /******************************************************************************
  47  *                             Memory leaks hunting                           *
  48  ******************************************************************************/
  49
  50
  51 /**
  52  * These functions and global variables are devoted to memory leaks hunting: we
  53  * want to know at each moment how many CloogStatement structures had been
  54  * allocated (cloog_statement_allocated) and how many had been freed
  55  * (cloog_statement_freed). Each time a CloogStatement structure is allocated,
  56  * a call to the function cloog_statement_leak_up() must be carried out, and
  57  * respectively cloog_statement_leak_down() when a CloogStatement structure is
  58  * freed. The special variable cloog_statement_max gives the maximal number of
  59  * CloogStatement structures simultaneously alive (i.e. allocated and
  60  * non-freed) in memory.
  61  * - July 3rd->11th 2003: first version (memory leaks hunt and correction).
  62  */
  63
  64
  65 static void cloog_statement_leak_up(CloogState *state)
  66 {
  67   state->statement_allocated++;
  68   if ((state->statement_allocated - state->statement_freed) > state->statement_max)
  69   state->statement_max = state->statement_allocated - state->statement_freed ;
  70 }
  71
  72
  73 static void cloog_statement_leak_down(CloogState *state)
  74 {
  75   state->statement_freed++;
  76 }
  77
  78
  79 /******************************************************************************
  80  *                          Structure display function                        *
  81  ******************************************************************************/
  82
  83
  84 /**
  85  * cloog_domain_print_structure :
  86  * this function is a human-friendly way to display the CloogDomain data
  87  * structure, it includes an indentation level (level) in order to work with
  88  * others print_structure functions.
  89  * - June  16th 2005: first version.
  90  */
  91 void cloog_statement_print_structure(file, statement, level)
  92 FILE * file ;
  93 CloogStatement * statement ;
  94 int level ;
  95 { int i ;
  96
  97   if (statement != NULL)
  98   { /* Go to the right level. */
  99     for (i=0; i<level; i++)
 100     fprintf(file,"|\t") ;
 101     fprintf(file,"+-- CloogStatement %d \n",statement->number) ;
 102
 103     statement = statement->next ;
 104
 105     while (statement != NULL)
 106     { for (i=0; i<level; i++)
 107       fprintf(file,"|\t") ;
 108       fprintf(file,"|          |\n");
 109       for (i=0; i<level; i++)
 110       fprintf(file,"|\t") ;
 111       fprintf(file,"|          V\n");
 112
 113       for (i=0; i<level; i++)
 114       fprintf(file,"|\t") ;
 115       fprintf(file,"|   CloogStatement %d \n",statement->number) ;
 116       statement = statement->next ;
 117     }
 118   }
 119   else
 120   { for (i=0; i<level; i++)
 121     fprintf(file,"|\t") ;
 122
 123     fprintf(file,"+-- No CloogStatement\n") ;
 124   }
 125 }
 126
 127
 128 /**
 129  * cloog_statement_print function:
 130  * This function prints the content of a CloogStatement structure (statement)
 131  * into a file (file, possibly stdout).
 132  */
 133 void cloog_statement_print(FILE * file, CloogStatement * statement)
 134 { cloog_statement_print_structure(file,statement,0) ;
 135 }
 136
 137
 138 /******************************************************************************
 139  *                         Memory deallocation function                       *
 140  ******************************************************************************/
 141
 142
 143 /**
 144  * cloog_statement_free function:
 145  * This function frees the allocated memory for a CloogStatement structure.
 146  */
 147 void cloog_statement_free(CloogStatement * statement)
 148 { CloogStatement * next ;
 149
 150   while (statement != NULL) {
 151     cloog_statement_leak_down(statement->state);
 152
 153     next = statement->next ;
 154     /* free(statement->usr) ; Actually, this is user's job ! */
 155     free(statement->name);
 156     free(statement) ;
 157     statement = next ;
 158   }
 159 }
 160
 161
 162 /******************************************************************************
 163  *                            Processing functions                            *
 164  ******************************************************************************/
 165
 166
 167 /**
 168  * cloog_statement_malloc function:
 169  * This function allocates the memory space for a CloogStatement structure and
 170  * sets its fields with default values. Then it returns a pointer to the
 171  * allocated space.
 172  * - November 21th 2005: first version.
 173  */
 174 CloogStatement *cloog_statement_malloc(CloogState *state)
 175 { CloogStatement * statement ;
 176
 177   /* Memory allocation for the CloogStatement structure. */
 178   statement = (CloogStatement *)malloc(sizeof(CloogStatement)) ;
 179   if (statement == NULL)
 180     cloog_die("memory overflow.\n");
 181   cloog_statement_leak_up(state);
 182
 183   /* We set the various fields with default values. */
 184   statement->state = state;
 185   statement->number = 0;
 186   statement->name = NULL;
 187   statement->usr  = NULL ; /* To fill it is actually user's job ! */
 188   statement->next = NULL ;
 189
 190   return statement ;
 191 }
 192
 193
 194 /**
 195  * cloog_statement_alloc function:
 196  * This function allocates the memory space for a CloogStatement structure and
 197  * sets its fields with those given as input. Then it returns a pointer to the
 198  * allocated space.
 199  * - number is the statement number.
 200  **
 201  * - September 9th 2002: first version.
 202  * - March    17th 2003: fix for the usr field in CloogStatement structure.
 203  * - April    16th 2005: adaptation to new CloogStatement structure (with
 204  *                       number), cloog_statement_read becomes
 205  *                       cloog_statement_alloc sincethere is nothing more to
 206  *                       read on a file.
 207  * - November 21th 2005: use of cloog_statement_malloc.
 208  */
 209 CloogStatement *cloog_statement_alloc(CloogState *state, int number)
 210 { CloogStatement * statement ;
 211
 212   /* Memory allocation and initialization of the structure. */
 213   statement = cloog_statement_malloc(state);
 214
 215   statement->number = number ;
 216
 217   return statement ;
 218 }
 219
 220
 221 /**
 222  * cloog_statement_copy function:
 223  * This function returns a copy of the CloogStatement structure given as input.
 224  * - October 28th 2001: first version (in loop.c).
 225  * - March   17th 2003: fix for the usr field in CloogStatement structure.
 226  * - April   16th 2005: adaptation to new CloogStatement struct (with number).
 227  */
 228 CloogStatement * cloog_statement_copy(CloogStatement * source)
 229 { CloogStatement * statement, * temp, * now = NULL ;
 230
 231   statement = NULL ;
 232
 233   while (source != NULL) {
 234     cloog_statement_leak_up(source->state);
 235
 236     temp = (CloogStatement *)malloc(sizeof(CloogStatement)) ;
 237     if (temp == NULL)
 238       cloog_die("memory overflow.\n");
 239
 240     temp->state  = source->state;
 241     temp->number = source->number ;
 242     temp->name = source->name ? strdup(source->name) : NULL;
 243     temp->usr    = source->usr ;
 244     temp->next   = NULL ;
 245
 246     if (statement == NULL)
 247     { statement = temp ;
 248       now = statement ;
 249     }
 250     else
 251     { now->next = temp ;
 252       now = now->next ;
 253     }
 254     source = source->next ;
 255   }
 256   return(statement) ;
 257 }
 258
 259
 260 /**
 261  * cloog_statement_add function:
 262  * This function adds a CloogStatement structure (statement) at a given place
 263  * (now) of a NULL terminated list of CloogStatement structures. The beginning
 264  * of this list is (start). This function updates (now) to (loop), and
 265  * updates (start) if the added element is the first one -that is when (start)
 266  * is NULL-.
 267  * - March 27th 2004: first version.
 268  */
 269 void cloog_statement_add(start, now, statement)
 270 CloogStatement ** start, ** now, * statement ;
 271 { if (*start == NULL)
 272   { *start = statement ;
 273     *now = *start ;
 274   }
 275   else
 276   { (*now)->next = statement ;
 277     *now = (*now)->next ;
 278   }
 279 }
 280