size.c File Reference

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "linear.h"
#include "genC.h"
#include "ri.h"
#include "ri-util.h"
#include "misc.h"

Include dependency graph for size.c:

Go to the source code of this file.

Macros
#define	INTERVAL_INTERSECTION(a, b, c, d)   (!((b) <= (c) || (d) <= (a)))

Functions
int	number_of_initial_values (list args)
	Functions to compute the numer of bytes required to store a variable or an object of a given type in memory; used by memory allocation functions in parsers, when allocation is possible (STATIC and DYNAMIC). More...
bool	SizeOfArray (entity e, int *s)
	This function computes the total size of a variable in bytes, ie. More...
int	array_size (entity a)
Value	ValueSizeOfArray (entity e)
int	CSafeSizeOfArray (entity a)
	BEGIN_EOLE. More...
int	entity_memory_size (entity dt)
int	type_memory_size (type t)
_int	SizeOfElements (basic b)
	This function returns the length in bytes of the Fortran or C type represented by a basic, except for a varying size string (formal parameter). More...
int	element_number (basic b, list ld)
	END_EOLE. More...
bool	NumberOfElements (basic b, list ld, int *n)
Value	ValueNumberOfElements (list ld)
int	SizeOfIthDimension (entity e, int i)
	this function returns the size of the ith dimension of a variable e. More...
int	dimension_size (dimension d)
	this function computes the size of a dimension. More...
expression	SizeOfDimension (dimension d)
static void *	do_sizeofdimension_reduction (void *v, const list l)
expression	SizeOfDimensions (list dims)
	computes the product of all dimensions in dims More...
Value	ValueSizeOfDimension (dimension d)
	FI: I do not understand the "Value" cast. More...
int	ExpressionToInt (expression e)
	this function computes the value of an integer constant expression and returns it to the calling function. More...
int	NumberOfDimension (entity e)
void	set_entity_to_size ()
void	reset_entity_to_size ()
void	safe_reset_entity_to_size ()
	In case of error handling, PIPS may try to reset this table twice. More...
int	storage_space_of_variable (entity v)
bool	variable_entities_may_conflict_p (entity e1, entity e2)

Variables
static hash_table	entity_to_size = hash_table_undefined
	a hash table to map entities to their numbers of elements More...

Macro Definition Documentation

INTERVAL_INTERSECTION

#define INTERVAL_INTERSECTION	(		a,
			b,
			c,
			d
	)		(!((b) <= (c) || (d) <= (a)))

Definition at line 680 of file size.c.

Function Documentation

array_size()

int array_size

(

entity

a

)

Definition at line 195 of file size.c.

{
    int s = 0;
 
    if(!SizeOfArray(a, &s)) {
        pips_internal_error("Array \"%s\" with illegal varying array size",
                   entity_name(a));
    }
    return s;
}

References entity_name, pips_internal_error, and SizeOfArray().

Here is the call graph for this function:

CSafeSizeOfArray()

int CSafeSizeOfArray

(

entity

a

)

BEGIN_EOLE.

• please do not remove this line Lines between BEGIN_EOLE and END_EOLE tags are automatically included in the EOLE project (JZ - 11/98)

should be a pips_user_error() to avoid useless and dangerous results

Definition at line 225 of file size.c.

{
  int s;
 
  if(!SizeOfArray(a, &s)) {
      pips_user_warning("Varying size for array \"%s\"\n", entity_name(a));
      /* should be a pips_user_error() to avoid useless and dangerous
         results */
      pips_user_warning("Not yet supported properly by PIPS\n");
  }
 
  return s;
}

References entity_name, pips_user_warning, and SizeOfArray().

Referenced by ComputeAreaOffset(), SizeOfElements(), and type_memory_size().

Here is the call graph for this function:

Here is the caller graph for this function:

dimension_size()

int dimension_size

(

dimension

d

)

this function computes the size of a dimension.

Definition at line 491 of file size.c.

{
    expression sod= SizeOfDimension(d);
    intptr_t i;
    if(expression_integer_value(sod,&i))
        free_expression(sod);
    else
        pips_internal_error("dimension is not constant, use SizeOfDimension instead");
    return i;
}

References expression_integer_value(), free_expression(), intptr_t, pips_internal_error, and SizeOfDimension().

Referenced by ComputeNewSizeOfIthDimension(), loadstore_type_conversion_string(), make_emulated_shared_variable(), normalize_microcode_anotate(), reference_offset(), template_ranges_to_processors_ranges(), and type_memory_size().

Here is the call graph for this function:

Here is the caller graph for this function:

do_sizeofdimension_reduction()

static void* do_sizeofdimension_reduction ( void *  v, const list  l  )

static

Definition at line 513 of file size.c.

{
    return make_op_exp(MULTIPLY_OPERATOR_NAME,
            (expression)v,
            SizeOfDimension(DIMENSION(CAR(l))));
}

References CAR, DIMENSION, make_op_exp(), MULTIPLY_OPERATOR_NAME, and SizeOfDimension().

Referenced by SizeOfDimensions().

Here is the call graph for this function:

Here is the caller graph for this function:

element_number()

int element_number	(	basic	b,
		list	ld
	)

END_EOLE.

this function computes the number of elements of a variable. ld is the list of dimensions of the variable

Parameters

ld

d

Definition at line 391 of file size.c.

{
    int en = 0;
 
    if(!NumberOfElements(b, ld, &en)) {
        pips_internal_error("Probably varying size array");
    }
 
    return en;
}

References NumberOfElements(), and pips_internal_error.

Referenced by compile_one_reduction(), max_size_of_processors(), and processor_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_memory_size()

int entity_memory_size

(

entity

dt

)

dt is assumed to be a derived type: struct, union, and maybe enum

Parameters

dt

t

Definition at line 239 of file size.c.

{
  /* dt is assumed to be a derived type: struct, union, and maybe enum */
  type t = ultimate_type(entity_type(dt));
  int s = type_memory_size(t);
 
  return s;
}

References entity_type, type_memory_size(), and ultimate_type().

Referenced by reductions_rewrite(), and SizeOfElements().

Here is the call graph for this function:

Here is the caller graph for this function:

ExpressionToInt()

int ExpressionToInt

(

expression

e

)

this function computes the value of an integer constant expression and returns it to the calling function.

it aborts if the expression is not constant.

See expression_integer_value() to check before aborting

Definition at line 562 of file size.c.

{
    value v;
    constant c;
    int i = -1;
 
    v = EvalExpression(e);
 
    if (value_constant_p(v)) {
      c = value_constant(v);
      if (constant_int_p(c)) {
        i = constant_int(c);
      }
      else {
        pips_internal_error("integer constant expected");
      }
    }
    else {
      pips_internal_error("constant expected\n");
    }
 
    free_value(v);
    return i;
}

References constant_int, constant_int_p, EvalExpression(), free_value(), pips_internal_error, value_constant, and value_constant_p.

Referenced by get_entity_dimensions(), OffsetOfReference(), SizeOfRange(), and ValueOfIthLowerBound().

Here is the call graph for this function:

Here is the caller graph for this function:

number_of_initial_values()

int number_of_initial_values

(

list

args

)

Functions to compute the numer of bytes required to store a variable or an object of a given type in memory; used by memory allocation functions in parsers, when allocation is possible (STATIC and DYNAMIC).

size.c

If the size is unknown, the variable is allocated in the STACK area. See ri.pdf, section about "area".

Parameters

args

rgs

Definition at line 44 of file size.c.

{
  int niv = 0;
  list carg = list_undefined;
 
  for(carg=args; !ENDP(carg); POP(carg)) {
    expression e = EXPRESSION(CAR(carg));
 
    if(expression_call_p(e)) {
      call c = syntax_call(expression_syntax(e));
      entity f = call_function(c);
      list sargs = call_arguments(c);
 
      if(ENTITY_BRACE_INTRINSIC_P(f)) {
        niv += number_of_initial_values(sargs);
      }
      else
        niv++;
    }
    else
      niv++;
  }
 
  return niv;
}

References call_arguments, call_function, CAR, ENDP, ENTITY_BRACE_INTRINSIC_P, EXPRESSION, expression_call_p(), expression_syntax, f(), list_undefined, number_of_initial_values(), POP, and syntax_call.

Referenced by number_of_initial_values(), and SizeOfArray().

Here is the call graph for this function:

Here is the caller graph for this function:

NumberOfDimension()

int NumberOfDimension

(

entity

e

)

Definition at line 588 of file size.c.

{
    type t = entity_type(e);
    int nd;
    cons *pc;
 
    assert(type_variable_p(t));
 
    pc = variable_dimensions(type_variable(t));
    nd = 0;
 
    while (! ENDP(pc)) {
        nd += 1;
        pc = CDR(pc);
    }
 
    return(nd);
}

References assert, CDR, ENDP, entity_type, type_variable, type_variable_p, and variable_dimensions.

Referenced by add_bound_arguments(), align_check(), array_as_template(), array_bounds_list(), array_distribution_similar_p(), array_ranges_to_template_ranges(), array_with_numerical_bounds_p(), block_distributed_p(), caller_list_of_bounds(), clean_distributed_io_system(), clean_shared_io_system(), compute_receive_content(), conformant_entities_p(), create_init_common_param_for_arrays(), create_init_common_param_for_processors(), create_init_common_param_for_templates(), create_parameters_h(), define_node_processor_id(), entity_unbounded_p(), extract_the_align(), extract_the_distribute(), full_linearization(), generate_compute_local_indices(), hpfc_broadcast_buffers(), hpfc_compute_align_constraints(), hpfc_compute_distribute_constraints(), hpfc_compute_entity_to_new_declaration(), hpfc_compute_lid(), hpfc_compute_unicity_constraints(), make_guard_expression(), make_reference_expression(), normalize_distribute(), number_of_distributed_dimensions(), one_message_guards_and_neighbour(), partial_linearization(), put_variables_in_ordered_lists(), reduction_parameters(), reference_to_points_to_sinks(), region_translation_init(), replicated_p(), st_generate_packing(), step_local_regionArray(), template_ranges_to_processors_ranges(), text_equivalence_class(), and update_overlaps_of().

Here is the caller graph for this function:

NumberOfElements()

bool NumberOfElements	(	basic	b,
		list	ld,
		int *	n
	)

do we have many elements at the lower typedef levels?

let's take care of the current level

Parameters

ld

d

Definition at line 403 of file size.c.

{
  list pc;
  int ne = 1;
  bool ok = true;
  int sne = 1;
 
  /* do we have many elements at the lower typedef levels? */
  if(basic_typedef_p(b)) {
    entity e = basic_typedef(b);
    // Lots of asserts skipped here
    variable ev = type_variable(entity_type(e));
 
    ok = NumberOfElements(variable_basic(ev), variable_dimensions(ev), &sne);
  }
 
  /* let's take care of the current level */
  if(ok) {
    for (pc = ld; pc != NULL && ok; pc = CDR(pc)) {
        expression sod = SizeOfDimension(DIMENSION(CAR(pc)));
        intptr_t s;
        ok=expression_integer_value(sod,&s);
        free_expression(sod);
        ne *= s;
    }
  }
 
  *n = ne*sne;
  return ok;
}

References basic_typedef, basic_typedef_p, CAR, CDR, DIMENSION, entity_type, expression_integer_value(), free_expression(), intptr_t, NumberOfElements(), ok, SizeOfDimension(), type_variable, variable_basic, and variable_dimensions.

Referenced by element_number(), expression_reference_number(), number_of_items(), NumberOfElements(), and SizeOfArray().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_entity_to_size()

void reset_entity_to_size

(

void

)

Definition at line 635 of file size.c.

{
    if (entity_to_size == hash_table_undefined) {
        pips_internal_error("hash table should have been allocated");
    }
    else {
        hash_table_free(entity_to_size);
        entity_to_size = hash_table_undefined;
    }
}

References entity_to_size, hash_table_free(), hash_table_undefined, and pips_internal_error.

Referenced by create_workspace().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_reset_entity_to_size()

void safe_reset_entity_to_size

(

void

)

In case of error handling, PIPS may try to reset this table twice.

Definition at line 647 of file size.c.

{
    if (entity_to_size != hash_table_undefined) {
        hash_table_free(entity_to_size);
        entity_to_size = hash_table_undefined;
    }
}

References entity_to_size, hash_table_free(), and hash_table_undefined.

Referenced by close_workspace().

Here is the call graph for this function:

Here is the caller graph for this function:

set_entity_to_size()

void set_entity_to_size

(

void

)

hash_table_clear(entity_to_size);

Definition at line 625 of file size.c.

{
    if (entity_to_size != hash_table_undefined) {
        pips_internal_error("hash table should have been deallocated");
        /* hash_table_clear(entity_to_size); */
    }
 
    entity_to_size = hash_table_make(hash_pointer, 0);
}

References entity_to_size, hash_pointer, hash_table_make(), hash_table_undefined, and pips_internal_error.

Referenced by create_workspace(), and open_workspace().

Here is the call graph for this function:

Here is the caller graph for this function:

SizeOfArray()

bool SizeOfArray	(	entity	e,
		int *	s
	)

This function computes the total size of a variable in bytes, ie.

the product of the number of elements and the size of each element in byte, when this size is a constant.

Arrays cannot be sized by a variable according to Fortran 77 standard, unless they are formal parameters (see SafeSizeOfArray). This restriction is lifted for arrays allocated in the area STACK.

Arrays can be sized by expressions according to C latest standard (see Validation/C_syntax/array_declarators.c). Then their sizes are not available at compile time and their addresses in stack cannot be computed at compiler time (see CSafeSizeOfArray).

Since the size is returned in a signed int, there is a maximum PIPS size for an array.

Let's try to use the initial value

FI: should eveb be freed?

Is it an array of characters initialized with a string expression?

Is it a call to the BRACE_INTRINSIC operator?

This is too simple unfortunately: OK, but why? which test case?

ne = gen_length(args);

Should be a call to CParserError()...

Check for other dimensions which must be all declared: the first dimension only can be implicit

Already taken care of by "ni"

Check for 32 bit signed overflows

Definition at line 87 of file size.c.

{
  type et = entity_type(e);
  type uet = ultimate_type(et);
  variable a, ua;
  bool ok = true;
  int se = -1;
  int ne = -1;
  int mne = -1;
 
  assert(type_variable_p(et) && type_variable_p(uet));
  a = type_variable(et);
  ua = type_variable(uet);
 
  se = SizeOfElements(variable_basic(ua));
 
  ok = NumberOfElements(variable_basic(a), variable_dimensions(a), &ne);
 
  if(!ok) {
    /* Let's try to use the initial value */
    value ev = entity_initial(e);
    if(!value_undefined_p(ev)) {
      if(value_expression_p(ev)) {
        expression eve = value_expression(ev);
        //type evet = expression_to_type(eve);
        basic eveb = basic_of_expression(eve); /* FI: should eveb be freed? */
 
        /* Is it an array of characters initialized with a string expression? */
        if(char_type_p(et) && !basic_undefined_p(eveb) && basic_string_p(eveb)) {
          ne = string_type_size(eveb);
          ok = true;
        }
        else if(expression_call_p(eve)) {
          call evec = syntax_call(expression_syntax(eve));
          entity f = call_function(evec);
          list args = call_arguments(evec);
 
          /* Is it a call to the BRACE_INTRINSIC operator? */
          if(ENTITY_BRACE_INTRINSIC_P(f)) {
            /* This is too simple unfortunately: OK, but why? which
               test case? */
            /* ne = gen_length(args); */
            int ni = number_of_initial_values(args);
            //int nf = number_of_fields(et);
            int nf = 1;
 
            if(type_variable_p(uet)) {
              variable ev = type_variable(uet);
              basic eb = variable_basic(ev);
              if(basic_derived_p(eb)) {
          entity de = basic_derived(eb);
          nf = number_of_items(entity_type(de));
              }
            }
            ne = ni/nf;
            if (nf*ne!=ni) {
              /* Should be a call to CParserError()... */
              //pips_user_error("Number of initialization values (%d) incompatible"
              //              " with number of type fields (%d)\n", ni, nf);
              // let's assume the source code is correct...
              ne = gen_length(args);
            }
            ok = true;
          }
          /* Check for other dimensions which must be all declared: the
             first dimension only can be implicit */
          /* Already taken care of by "ni" */
          /*
            if(ok && gen_length(variable_dimensions(a))>1) {
            bool sok = false;
            int sne = -1;
            sok = NumberOfElements(variable_basic(a), CDR(variable_dimensions(a)), &sne);
            if(sok) {
            ne *= sne;
            }
            else {
            ok = false;
            }
            }
          */
        }
      }
      else if(value_constant_p(ev)) {
        pips_internal_error("Not implemented yet");
      }
    }
  }
 
  /* Check for 32 bit signed overflows */
  mne = se>0 ? INT_MAX/se : INT_MAX;
 
  if(ok) {
    if(mne>=ne)
      *s = ne*se;
    else {
      pips_user_warning("Array size incompatible with 32 bit signed integers\n"
                        "Maximum number of elements: %d, number of elements declared: %d\n",
                        mne, ne);
      ok = false;
    }
  }
  else {
    *s = se;
  }
 
  return ok;
}

References assert, basic_derived, basic_derived_p, basic_of_expression(), basic_string_p, basic_undefined_p, call_arguments, call_function, char_type_p(), ENTITY_BRACE_INTRINSIC_P, entity_initial, entity_type, expression_call_p(), expression_syntax, f(), gen_length(), number_of_initial_values(), number_of_items(), NumberOfElements(), ok, pips_internal_error, pips_user_warning, SizeOfElements(), string_type_size(), syntax_call, type_variable, type_variable_p, ultimate_type(), value_constant_p, value_expression, value_expression_p, value_undefined_p, variable_basic, and variable_dimensions.

Referenced by add_any_variable_to_area(), alias_check(), array_size(), common_members_of_module(), ComputeAddresses(), CSafeSizeOfArray(), current_offset_of_area(), dump_common_layout(), formal_variable_add_aliases(), fprint_any_environment(), GenericAddLocalEntityToDeclarations(), gfc2pips_computeAdressesOfArea(), gfc2pips_symbol2data_instruction(), impact_check(), MakeStorageRam(), new_add_any_variable_to_area(), print_C_common_layout(), print_common_layout(), ram_variable_add_aliases(), SafeSizeOfArray(), same_or_equivalence_argument_add_aliases(), and storage_space_of_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

SizeOfDimension()

expression SizeOfDimension

(

dimension

d

)

Definition at line 503 of file size.c.

{
    return 
        make_op_exp(PLUS_OPERATOR_NAME,
                make_op_exp(MINUS_OPERATOR_NAME,copy_expression(dimension_upper(d)),copy_expression(dimension_lower(d))),
                int_to_expression(1)
                )
                ;
}

References copy_expression(), dimension_lower, dimension_upper, int_to_expression(), make_op_exp(), MINUS_OPERATOR_NAME, and PLUS_OPERATOR_NAME.

Referenced by dimension_size(), dimensions_to_dma(), do_sizeofdimension_reduction(), do_terapix_warmup_patching(), NumberOfElements(), and SizeOfIthDimension().

Here is the call graph for this function:

Here is the caller graph for this function:

SizeOfDimensions()

expression SizeOfDimensions

(

list

dims

)

computes the product of all dimensions in dims

Parameters

dims

ims

Definition at line 522 of file size.c.

{
    return (expression)gen_reduce(int_to_expression(1),do_sizeofdimension_reduction,dims);
}

References do_sizeofdimension_reduction(), gen_reduce(), and int_to_expression().

Referenced by dimensions_to_dma(), do_group_constants_terapix(), do_group_count_elements_reduce(), do_linearize_array_reference(), do_linearize_type(), and makeTransfertSizeExpression().

Here is the call graph for this function:

Here is the caller graph for this function:

SizeOfElements()

_int SizeOfElements

(

basic

b

)

This function returns the length in bytes of the Fortran or C type represented by a basic, except for a varying size string (formal parameter).

What is the semantics for bitfields? Return its size rounded to a byte number large enough to fit, and not the size in bit.

Some of these values are target architecture dependent: e == 1 character e == 2 short int e == 4 int e == 6 long int e == 8 long long int They are defined in ri-util-local.h To be consistent with the machine compiling and executing PIPS, we could use a switch(e) and the corresponding sizeof().

As for int, e encodes some fine typing information: remove it

pips_assert("SizeOfElements", gen_consistent_p(b));

Size can be zero, i.e. unknown, for an external variable

Definition at line 297 of file size.c.

{
  int e = -1;
 
  switch (basic_tag(b)) {
  case is_basic_int:
    {
      /* Some of these values are target architecture dependent:
         e == 1 character
         e == 2 short int
         e == 4 int
         e == 6 long int
         e == 8 long long int
         They are defined in ri-util-local.h
         To be consistent with the machine compiling and executing
         PIPS, we could use a switch(e) and the corresponding sizeof().
       */
 
    e = basic_int(b);
    e = e % 10;
    if(e==DEFAULT_LONG_INTEGER_TYPE_SIZE)
      e = DEFAULT_INTEGER_TYPE_SIZE;
    break;
    }
  case is_basic_float:
    e = basic_float(b);
    break;
  case is_basic_logical:
    e = basic_logical(b);
    break;
  case is_basic_complex:
    e = basic_complex(b);
    /* As for int, e encodes some fine typing information: remove it */
    e = (e/8)*8;
    break;
  case is_basic_string: {
    constant c = constant_undefined;
 
    /* pips_assert("SizeOfElements", gen_consistent_p(b)); */
 
    if(value_constant_p(basic_string(b)))
      c = value_constant(basic_string(b));
    else if(value_symbolic_p(basic_string(b)))
      c = symbolic_constant(value_symbolic(basic_string(b)));
    else
      user_error("SizeOfElements",
                 "Sizing of character variable by illegal value (tag=%d)",
                 basic_tag(b));
 
    if(constant_int_p(c))
      e = constant_int(c);
    else
      user_error("SizeOfElements",
                 "Sizing of character variable by non-integer constant");
    break;
  }
  case is_basic_bit: {
    constant c = symbolic_constant(basic_bit(b));
    if(constant_int_p(c))
    // Get the size in bits:
      e = constant_int(c);
    else
      user_error("SizeOfElements",
                 "Sizing of bit-field is non-integer constant");
    // Round the size to full byte number:
    e = (e + 7)/8;
  }
    break;
  case is_basic_pointer:
    e = DEFAULT_POINTER_TYPE_SIZE;
    break;
  case is_basic_derived:
    e = entity_memory_size(basic_derived(b));
    break;
  case is_basic_typedef:
    e = CSafeSizeOfArray(basic_typedef(b));
    break;
  default:
    pips_internal_error("Ill. tag %d for basic", basic_tag(b));
  }
 
  /* Size can be zero, i.e. unknown, for an external variable */
  //pips_assert("e is not zero", e!=0);
 
  return e;
}

References basic_bit, basic_complex, basic_derived, basic_float, basic_int, basic_logical, basic_string, basic_tag, basic_typedef, constant_int, constant_int_p, constant_undefined, CSafeSizeOfArray(), DEFAULT_INTEGER_TYPE_SIZE, DEFAULT_LONG_INTEGER_TYPE_SIZE, DEFAULT_POINTER_TYPE_SIZE, entity_memory_size(), is_basic_bit, is_basic_complex, is_basic_derived, is_basic_float, is_basic_int, is_basic_logical, is_basic_pointer, is_basic_string, is_basic_typedef, pips_internal_error, symbolic_constant, user_error, value_constant, value_constant_p, value_symbolic, and value_symbolic_p.

Referenced by abc_with_allocation_size(), alias_check(), array_size_stride(), basic_maximum(), consecutive_expression_p(), distance_between_expression(), edge_cost_polynome(), formal_variable_add_aliases(), get_optimal_opcode(), get_symbol_table(), get_vect_name_from_data(), impact_check(), interprocedural_abc_arrays(), make_datum_movement(), make_movement_scalar_wp65(), make_movements_loop_body_wp65(), ram_variable_add_aliases(), region_translation_init(), same_or_equivalence_argument_add_aliases(), size_of_regions(), SizeOfArray(), SizeOfIthDimension(), subscript_value_stride(), text_equivalence_class(), type_and_size_of_var(), type_memory_size(), ValueSizeOfArray(), and variables_width_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

SizeOfIthDimension()

int SizeOfIthDimension	(	entity	e,
		int	i
	)

this function returns the size of the ith dimension of a variable e.

if called for the 0th dimension, it returns the variable element size.

Definition at line 453 of file size.c.

{
    list pc = NIL;
    intptr_t s = 0;
 
    if (!type_variable_p(entity_type(e))) {
        fprintf(stderr, "[SizeOfIthDimension] not a variable\n");
        abort();
    }
 
    if (i == 0)
        return(SizeOfElements((variable_basic(type_variable(entity_type(e))))));
 
    pc = variable_dimensions(type_variable(entity_type(e)));
 
    while (pc != NULL && --i > 0)
        pc = CDR(pc);
 
    if (pc == NULL) {
        fprintf(stderr, "[SizeOfIthDimension] not enough dimensions\n");
        abort();
    }
 
    expression sod = SizeOfDimension(DIMENSION(CAR(pc)));
    if(!(expression_integer_value(sod, &s))) {
        fprintf(stderr, "[SizeOfIthDimension] Non constant %dth dimension\n", i);
        abort();
    }
    free_expression(sod);
 
    return s;
}

References abort, CAR, CDR, DIMENSION, entity_type, expression_integer_value(), fprintf(), free_expression(), intptr_t, NIL, SizeOfDimension(), SizeOfElements(), type_variable, type_variable_p, variable_basic, and variable_dimensions.

Referenced by array_distribution_similar_p(), ComputeNewSizeOfIthDimension(), create_init_common_param_for_arrays(), hpfc_broadcast_buffers(), hpfc_compute_distribute_constraints(), NormalizeOneTemplateDistribution(), OffsetOfReference(), one_message_guards_and_neighbour(), processor_number(), same_alignment_p(), and text_equivalence_class().

Here is the call graph for this function:

Here is the caller graph for this function:

storage_space_of_variable()

int storage_space_of_variable

(

entity

v

)

Storage size is expressed in bytes

Definition at line 656 of file size.c.

{
    /* Storage size is expressed in bytes */
    int l;
    char * s;
 
    if (entity_to_size == hash_table_undefined) {
        user_warning("storage_space_of_variable",
                     "hash table should have been allocated\n");
        entity_to_size = hash_table_make(hash_pointer, 0);
    }
    s = hash_get(entity_to_size, (char *) v);
    l = (_int) s;
    if (s == HASH_UNDEFINED_VALUE) {
      if(!SizeOfArray(v, &l)) {
        fprintf(stderr, "[storage_space_of_variable] Non constant array size\n");
        abort();
      }
      hash_put(entity_to_size, (char *) v, (char *) (_int) l);
    }
 
    return l;
}

References abort, entity_to_size, fprintf(), hash_get(), hash_pointer, hash_put(), hash_table_make(), hash_table_undefined, HASH_UNDEFINED_VALUE, SizeOfArray(), and user_warning.

Referenced by create_new_common_variable(), and variable_entities_may_conflict_p().

Here is the call graph for this function:

Here is the caller graph for this function:

type_memory_size()

int type_memory_size

(

type

t

)

Seems to be the case for defined types; FI: why are they allocated in RAM while they only exist at compile time ?

How is it implemented? 32 bit integer?

A struct (or a union) may be hidden, with its declaration located in the source code of a library. For instance, "_IO_FILE_plus" in stdio.h. Since it contains at least one byte, let set s to 1? Or let the caller deal with the problem?

Definition at line 248 of file size.c.

{
  int s = 0;
 
  switch(type_tag(t)) {
  case is_type_statement:
  case is_type_area:
  case is_type_functional:
  case is_type_varargs:
  case is_type_unknown:
  case is_type_void:
    pips_internal_error("arg. with ill. tag %d", type_tag(t));
    break;
  case is_type_variable:
    {
        /* Seems to be the case for defined types; FI: why are they
           allocated in RAM while they only exist at compile time ? */
        s = SizeOfElements(variable_basic(type_variable(t)));
        FOREACH(DIMENSION,dim, variable_dimensions(type_variable(t)))
            s*=dimension_size(dim);
 
    } break;
  case is_type_struct:
    MAP(ENTITY, v, {s+=CSafeSizeOfArray(v);}, type_struct(t));
    break;
  case is_type_union:
    MAP(ENTITY, v, {s = s>CSafeSizeOfArray(v)? s : CSafeSizeOfArray(v);}, type_union(t));
    break;
  case is_type_enum:
    s = 4; /* How is it implemented? 32 bit integer? */
    break;
  default:
    pips_internal_error("arg. with unknown tag %d", type_tag(t));
    break;
  }
  /* A struct (or a union) may be hidden, with its declaration
     located in the source code of a library. For instance,
     "_IO_FILE_plus" in stdio.h. Since it contains at least one byte,
     let set s to 1? Or let the caller deal with the problem? */
  // s = s>0? s : 1;
  return s;
}

References CSafeSizeOfArray(), DIMENSION, dimension_size(), ENTITY, FOREACH, is_type_area, is_type_enum, is_type_functional, is_type_statement, is_type_struct, is_type_union, is_type_unknown, is_type_varargs, is_type_variable, is_type_void, MAP, pips_internal_error, SizeOfElements(), type_struct, type_tag, type_union, type_variable, variable_basic, and variable_dimensions.

Referenced by entity_memory_size(), EvalSizeofexpression(), get_type_max_width(), and partial_eval_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

ValueNumberOfElements()

Value ValueNumberOfElements

(

list

ld

)

Parameters

ld

d

Definition at line 435 of file size.c.

{
    list pc;
    Value ne = VALUE_ONE;
 
    for (pc = ld; pc != NULL; pc = CDR(pc)) {
        ne = value_mult(ne, ValueSizeOfDimension(DIMENSION(CAR(pc))));
    }
 
    return(ne);
}

References CAR, CDR, DIMENSION, value_mult, VALUE_ONE, and ValueSizeOfDimension().

Referenced by simd_replace_parameters(), and ValueSizeOfArray().

Here is the call graph for this function:

Here is the caller graph for this function:

ValueSizeOfArray()

Value ValueSizeOfArray

(

entity

e

)

Definition at line 206 of file size.c.

{
        variable a;
        Value longueur, taille_elt;
 
        assert(type_variable_p(entity_type(e)));
        a = type_variable(entity_type(e));
 
        taille_elt = (Value) SizeOfElements(variable_basic(a));
        longueur = ValueNumberOfElements(variable_dimensions(a));
 
        return(value_mult(taille_elt,longueur));
}

References assert, entity_type, SizeOfElements(), type_variable, type_variable_p, value_mult, ValueNumberOfElements(), variable_basic, and variable_dimensions.

Referenced by equivalent_entity_compare(), and text_equivalence_class().

Here is the call graph for this function:

Here is the caller graph for this function:

ValueSizeOfDimension()

Value ValueSizeOfDimension

(

dimension

d

)

FI: I do not understand the "Value" cast.

Definition at line 531 of file size.c.

{
    Value dl, du;
    intptr_t l = 0 ;
    intptr_t u = 0;
    bool ok;
 
    ok = expression_integer_value(dimension_upper(d), &u);
    du = (Value) u;
    ok = ok && expression_integer_value(dimension_lower(d), &l);
    dl = (Value) l;
 
    if(!ok) {
        fprintf(stderr, "[ValueSizeOfIthDimension] Non constant dimension\n");
        abort();
    }
    
    return(value_plus(value_minus(du,dl), VALUE_ONE));
}

References abort, dimension_lower, dimension_upper, expression_integer_value(), fprintf(), intptr_t, ok, value_minus, VALUE_ONE, and value_plus.

Referenced by ValueNumberOfElements().

Here is the call graph for this function:

Here is the caller graph for this function:

variable_entities_may_conflict_p()

bool variable_entities_may_conflict_p	(	entity	e1,
		entity	e2
	)

Can we have and check static aliasing in a1?

Let's assume we are dealing with Fortran code, but another test should be added about the current module language. No test on dynamic aliasing since we are dealing here with direct read and write effects.

return(r1 != ram_undefined && r2 != ram_undefined && f1 == f2 && a1 == a2 && INTERVAL_INTERSECTION(o1, l1, o2, l2));

FI: it's too late to check if r1 and r2 are defined: you already have core dumped! also, f1 and f2 are not relevant since location are governed by area a1 and a2

Parameters

e1	1
e2	2

Definition at line 689 of file size.c.

{
    bool intersect_p = false;
    storage s1, s2;
    ram r1 = ram_undefined, r2 = ram_undefined;
    int o1, o2, l1, l2;
    entity f1, f2, a1, a2;
 
    if(same_entity_p(e1, e2)) return true;
 
    s1 = entity_storage(e1);
    s2 = entity_storage(e2);
 
    if (! (storage_ram_p(s1) && storage_ram_p(s2))) {
        // Conflicts may exist beween array elements when an array is
        // a formal parameter
      if( ! (storage_formal_p(s1) && storage_formal_p(s2)) ) {
        return false;
      }
      else {
        formal f1 = storage_formal(s1);
        formal f2 = storage_formal(s2);
        entity e1 = formal_function(f1);
        entity e2 = formal_function(f2);
        if(e1==e2) {
          int o1 = formal_offset(f1);
          int o2 = formal_offset(f2);
          return o1==o2;
        }
        return false;
      }
    }
 
    r1 = storage_ram(s1);
    r2 = storage_ram(s2);
 
    a1 = ram_section(r1);
    a2 = ram_section(r2);
 
    if(a1!=a2) return false;
 
    /* Can we have and check static aliasing in a1? */
    if(stack_area_p(a1))
      return false;
 
    if(heap_area_p(a1))
      return false;
 
    // FI: we create aliasing in C between an array and its elements
    // This is used to analyse the value of array elements
    if (false && c_module_p(get_current_module_entity()))
      return false;
 
    /* Let's assume we are dealing with Fortran code, but another test
       should be added about the current module language. No test on
       dynamic aliasing since we are dealing here with direct read and
       write effects. */
    o1 = ram_offset(r1);
    o2 = ram_offset(r2);
 
    if(o1==o2) return true;
 
    f1 = ram_function(r1);
    f2 = ram_function(r2);
 
    if(f1==f2 && (ENDP(ram_shared(r1)) || ENDP(ram_shared(r2))))
       return false;
 
    l1 = storage_space_of_variable(e1);
    l1 = l1+o1-1;
 
 
    l2 = storage_space_of_variable(e2);
    l2 = l2+o2-1;
 
    /* return(r1 != ram_undefined && r2 != ram_undefined &&
           f1 == f2 && a1 == a2 &&
           INTERVAL_INTERSECTION(o1, l1, o2, l2)); */
 
    /* FI: it's too late to check if r1 and r2 are defined:
     * you already have core dumped!
     * also, f1 and f2 are not relevant since location are governed
     * by area a1 and a2
     */
 
    intersect_p = ( a1 == a2 && INTERVAL_INTERSECTION(o1, l1, o2, l2));
 
    return intersect_p;
}

References c_module_p(), ENDP, entity_storage, f2(), formal_function, formal_offset, get_current_module_entity(), heap_area_p(), INTERVAL_INTERSECTION, ram_function, ram_offset, ram_section, ram_shared, ram_undefined, s1, same_entity_p(), stack_area_p(), storage_formal, storage_formal_p, storage_ram, storage_ram_p, and storage_space_of_variable().

Referenced by entities_maymust_conflict_p(), references_may_conflict_p(), and SaveChains().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

entity_to_size

hash_table entity_to_size = hash_table_undefined

static

a hash table to map entities to their numbers of elements

This table is critical to compute use-def chains at an acceptable speed because the computation of a variable allocated space is very slow. Declaration are preserved in PIPS and constant expressions must be evaluated.

Note: the current implementation is not safe. The hash table may be kept from module to module (which should be OK) and from workspace to workspace, which is not.

This is an unusual object because it's life time is the workspace life time and not the module analysis life time. This hash table acts as a cache of the symbol table.

Definition at line 623 of file size.c.

Referenced by reset_entity_to_size(), safe_reset_entity_to_size(), set_entity_to_size(), and storage_space_of_variable().