array_resizing_statistic.c

Go to the documentation of this file.

/*
 
  $Id: array_resizing_statistic.c 23065 2016-03-02 09:05:50Z coelho $
 
  Copyright 1989-2016 MINES ParisTech
 
  This file is part of PIPS.
 
  PIPS is free software: you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  any later version.
 
  PIPS 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 General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with PIPS.  If not, see <http://www.gnu.org/licenses/>.
 
*/
 
// do not compile unless required
#include "phases.h"
#ifdef BUILDER_ARRAY_RESIZING_STATISTIC
 
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
/*
  This phase computes the number of pointer-type A(1) and assumed-size A(*)
  array declarators in one program.
  There are two cases: these unnormalized declarations are formal array
  parameters or not
*/
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "genC.h"
#include "linear.h"
 
#include "ri.h"
#include "ri-util.h"
 
#include "misc.h"
 
static int number_of_pointer_type_and_formal_arrays = 0;
static int number_of_assumed_size_and_formal_arrays = 0;
static int number_of_formal_arrays = 0;
static int number_of_pointer_type_and_not_formal_arrays = 0;
static int number_of_assumed_size_and_not_formal_arrays = 0;
static int number_of_not_formal_arrays = 0;
 
static int number_of_processed_modules = 0;
 
bool array_resizing_statistic(const string module_name)
{
  entity module_ent = module_name_to_entity(module_name);
  list l_decl = code_declarations(entity_code(module_ent));
 
  number_of_processed_modules++;
 
  debug_on("ARRAY_RESIZING_STATISTIC_DEBUG_LEVEL");
  ifdebug(1)
    fprintf(stderr, " \n Begin array resizing statistic for %s \n", module_name);   
   
  /* search for unnormalized array declarations in the list */  
  while(!ENDP(l_decl))
    {
      entity e = ENTITY(CAR(l_decl));
      if (entity_variable_p(e))
        {
          variable v = type_variable(entity_type(e));   
          list l_dims = variable_dimensions(v);
          if (l_dims != NIL)
            {
              int length = gen_length(l_dims);
              dimension last_dim =  find_ith_dimension(l_dims,length);
              expression exp = dimension_upper(last_dim);
              storage s = entity_storage(e);
              if (storage_formal_p(s))   
                number_of_formal_arrays++;
              else 
                number_of_not_formal_arrays++;
              if (unbounded_dimension_p(last_dim)) 
                {
                  if (storage_formal_p(s))  
                    number_of_assumed_size_and_formal_arrays++;
                  else 
                    number_of_assumed_size_and_not_formal_arrays++;
                }
              if (expression_equal_integer_p(exp,1))
                {
                  if (storage_formal_p(s)) 
                    number_of_pointer_type_and_formal_arrays++;
                  else 
                    number_of_pointer_type_and_not_formal_arrays++;
                }
            }
        }
      l_decl = CDR(l_decl);
    }
  
  user_log(" \n Number of pointer-type A(1), formal arrays : %d \n"
          ,number_of_pointer_type_and_formal_arrays );
  user_log(" \n Number of assumed-size A(*), formal arrays : %d \n"
           ,number_of_assumed_size_and_formal_arrays );
  user_log(" \n Number of formal array declarators : %d\n"
           ,number_of_formal_arrays );
  user_log(" \n Number of pointer-type A(1), local arrays : %d \n"
          ,number_of_pointer_type_and_not_formal_arrays );
  user_log(" \n Number of assumed-size A(*), local arrays : %d \n"
           ,number_of_assumed_size_and_not_formal_arrays );
  user_log(" \n Number of local array declarators : %d\n"
           ,number_of_not_formal_arrays );
  user_log(" \n Total number of pointer-type arrays : %d\n"
          ,number_of_pointer_type_and_formal_arrays + 
           number_of_pointer_type_and_not_formal_arrays );
  user_log(" \n Total number of assumed-size arrays : %d\n"
           ,number_of_assumed_size_and_formal_arrays + 
           number_of_assumed_size_and_not_formal_arrays);
  user_log(" \n Total number of arrays : %d\n"
           ,number_of_formal_arrays +
           number_of_not_formal_arrays);
 
  user_log("\n Number of processed modules: %d \n"
           ,number_of_processed_modules);
 
  ifdebug(1)
    fprintf(stderr, " \n End array resizing statistic for %s \n", module_name);
  debug_off();
  return true;
}
 
#endif // BUILDER_ARRAY_RESIZING_STATISTIC