type.c File Reference

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

Include dependency graph for type.c:

Go to the source code of this file.

Functions
basic	MakeBasicOverloaded ()
	generation of types
mode	MakeModeReference ()
mode	MakeModeValue ()
type	MakeTypeStatement ()
type	MakeTypeUnknown ()
type	MakeTypeVoid ()
type	MakeTypeVariable (basic b, cons *ld)
	BEGIN_EOLE.
basic	MakeBasic (int the_tag)
	END_EOLE.
type	MakeTypeArray (basic b, cons *ld)
	functions on types
parameter	MakeOverloadedParameter ()
parameter	MakeIntegerParameter ()
parameter	MakeRealParameter ()
parameter	MakeDoubleprecisionParameter ()
parameter	MakeLogicalParameter ()
parameter	MakeComplexParameter ()
parameter	MakeDoublecomplexParameter ()
parameter	MakeCharacterParameter ()
parameter	MakeAnyScalarParameter (tag t, _int size)
	For Fortran.
type	MakeOverloadedResult ()
	this function creates a default fortran operator result, i.e.
type	MakeIntegerResult ()
type	MakeRealResult ()
type	MakeDoubleprecisionResult ()
type	MakeLogicalResult ()
type	MakeComplexResult ()
type	MakeDoublecomplexResult ()
type	MakeCharacterResult ()
type	MakeAnyScalarResult (tag t, _int size)
bool	type_equal_p (type t1, type t2)
	Warning: the lengths of string basics are not checked!!! string_type_size() could be used but it is probably not very robust.
type	make_scalar_integer_type (_int n)
type	make_scalar_complex_type (_int n)
bool	area_equal_p (area a1, area a2)
bool	dimension_equal_p (dimension d1, dimension d2)
bool	variable_equal_p (variable v1, variable v2)
bool	basic_equal_strict_p (basic b1, basic b2)
bool	basic_equal_p (basic b1, basic b2)
bool	functional_equal_p (functional f1, functional f2)
bool	parameter_equal_p (parameter p1, parameter p2)
bool	mode_equal_p (mode m1, mode m2)
int	string_type_size (basic b)
int	basic_type_size (basic b)
	See also SizeOfElements().
basic	expression_basic (expression expr)
dimension	dimension_dup (dimension d)
list	ldimensions_dup (list l)
dimension	FindIthDimension (entity e, int i)
string	type_to_string (type t)
string	safe_type_to_string (type t)
string	basic_to_string (basic b)
	BEGIN_EOLE.
basic	some_basic_of_any_expression (expression exp, bool apply_p, bool ultimate_p)
	basic basic_of_any_expression(expression exp, bool apply_p): Makes a basic of the same basic as the expression "exp" if "apply_p" is FALSE.
basic	basic_of_any_expression (expression exp, bool apply_p)
basic	basic_of_expression (expression exp)
	basic basic_of_expression(expression exp): Makes a basic of the same basic as the expression "exp".
basic	basic_of_reference (reference r)
	retreives the basic of a reference in a newly allocated bsaic object
basic	basic_of_call (call c, bool apply_p, bool ultimate_p)
	basic basic_of_call(call c): returns the basic of the result given by the call "c".
basic	basic_of_external (call c)
	basic basic_of_external(call c): returns the basic of the result given by the call to an external function.
basic	basic_of_intrinsic (call c, bool apply_p, bool ultimate_p)
	basic basic_of_intrinsic(call c): returns the basic of the result given by call to an intrinsic function.
basic	basic_of_constant (call c)
	basic basic_of_constant(call c): returns the basic of the call to a constant.
basic	basic_union (expression exp1, expression exp2)
	basic basic_union(expression exp1 exp2): returns the basic of the expression which has the most global basic.
basic	basic_ultimate (basic b)
	get the ultimate basic from a basic typedef
basic	basic_maximum (basic fb1, basic fb2)
type	intrinsic_call_to_type (call c)
	END_EOLE.
type	call_to_type (call c)
type	reference_to_type (reference ref)
type	expression_to_type (expression exp)
	For an array declared as int a[10][20], the type returned for a[i] is int [20].
type	expression_to_uncasted_type (expression exp)
	If the expression is casted, return its type before cast.
type	expression_to_user_type (expression e)
	Preserve typedef'ed types when possible.
bool	overloaded_type_p (type t)
	Returns true if t is a variable type with a basic overloaded.
bool	is_inferior_basic (basic b1, basic b2)
	bool is_inferior_basic(basic1, basic2) return TRUE if basic1 is less complex than basic2 ex: int is less complex than float*4, float*4 is less complex than float*8, .
basic	simple_basic_dup (basic b)
entity	basic_to_generic_conversion (basic b)
	returns the corresponding generic conversion entity, if any.
bool	signed_type_p (type t)
bool	unsigned_type_p (type t)
bool	long_type_p (type t)
bool	bit_type_p (type t)
bool	string_type_p (type t)
bool	char_type_p (type t)
bool	basic_type_p (type t)
	Safer than the other implementation? bool pointer_type_p(type t) { bool is_pointer = FALSE;.
bool	array_type_p (type t)
bool	pointer_type_p (type t)
bool	derived_type_p (type t)
	Returns TRUE if t is of type struct, union or enum.
bool	typedef_type_p (type t)
	Returns TRUE if t is a typedefED type.
type	make_standard_integer_type (type t, int size)
type	make_standard_long_integer_type (type t)
type	ultimate_type (type t)
	FI: there are different notions of "ultimate" types in C.
type	basic_concrete_type (type t)
bool	call_compatible_type_p (type t)
	Is an object of type t compatible with a call?
type	call_compatible_type (type t)
	returns the type necessary to generate or check a call to an object of type t.
type	call_to_functional_type (call c, bool ultimate_p)
	The function called can have a functional type, or a typedef type or a pointer type to a functional type.
int	number_of_fields (type t)
list	recursive_functional_type_supporting_entities (list sel, set vt, functional f)
list	functional_type_supporting_entities (list sel, functional f)
list	enum_supporting_entities (list sel, set vt, entity e)
list	generic_constant_expression_supporting_entities (list sel, set vt, expression e, bool language_c_p)
list	constant_expression_supporting_entities (list sel, set vt, expression e)
	C version.
list	fortran_constant_expression_supporting_entities (list sel, expression e)
	Fortran version.
list	generic_symbolic_supporting_entities (list sel, set vt, symbolic s, bool language_c_p)
list	symbolic_supporting_entities (list sel, set vt, symbolic s)
	C version.
list	basic_supporting_entities (list sel, set vt, basic b)
list	variable_type_supporting_entities (list sel, set vt, variable v)
list	recursive_type_supporting_entities (list sel, set vt, type t)
list	type_supporting_entities (list sel, type t)
static list	recursive_type_supporting_references (list srl, type t)
	Compute the list of references implied in the definition of a type.
list	functional_type_supporting_references (list srl, functional f)
list	enum_supporting_references (list srl, entity e)
list	constant_expression_supporting_references (list srl, expression e)
	Only applicable to C expressions.
list	symbolic_supporting_references (list srl, symbolic s)
list	basic_supporting_references (list srl, basic b)
list	variable_type_supporting_references (list srl, variable v)
list	fortran_type_supporting_entities (list srl, type t)
list	type_supporting_references (list srl, type t)
bool	check_C_function_type (entity f, list args)
	Check that an effective parameter list is compatible with a function type.
size_t	type_depth (type t)
	Number of steps to access the lowest leave of type t.
int	basic_depth (basic b)
int	effect_type_depth (type t)
	Number of steps to access the lowest leave of type t.
int	effect_basic_depth (basic b)
static list	recursive_type_supporting_types (list stl, set vt, type t)
	Compute the list of types implied in the definition of a type.
void	print_types (list tl)
	Very basic and crude debugging function.
void	print_type (type t)
	For debugging.
static list	recursive_functional_type_supporting_types (list stl, set vt, functional f)
list	functional_type_supporting_types (functional f)
	FI: I'm not sure this function is of any use.
static list	basic_supporting_types (list stl, set vt, basic b)
static list	variable_type_supporting_types (list stl, set vt, variable v)
list	type_supporting_types (type t)
	Return the list of types used to define type t.
type	make_char_array_type (int n)
bool	overloaded_parameters_p (list lparams)
type	type_to_pointer_type (type t)
type	type_to_pointed_type (type t)
	returns t if t is not a pointer type, and the pointed type if t is a pointer type.
type	type_to_final_pointed_type (type t)
	returns t if t is not a pointer type, and the first indirectly pointed type that is not a pointer if t is a pointer type.
Variables
static set	supporting_types = set_undefined
	Compute the list of entities implied in the definition of a type.

---

Function Documentation

bool area_equal_p	(	area	a1,
		area	a2
	)

layouts are independent ?

Parameters:

	a1	1
	a2	2

Definition at line 341 of file type.c.

References area_size, area_undefined, FALSE, and TRUE.

Referenced by type_equal_p().

{
    if(a1 == a2)
        return TRUE;
    else if (a1 == area_undefined && a2 != area_undefined)
        return FALSE;
    else if (a1 != area_undefined && a2 == area_undefined)
        return FALSE;
    else
        /* layouts are independent ? */
        return (area_size(a1) == area_size(a2));
}

Here is the caller graph for this function:

bool array_type_p

(

type

t

)

Definition at line 2168 of file type.c.

References NIL, type_variable, type_variable_p, and variable_dimensions.

Referenced by generic_c_words_simplified_entity().

{
  return (type_variable_p(t) && (variable_dimensions(type_variable(t)) != NIL));
}

Here is the caller graph for this function:

type basic_concrete_type

(

type

t

)

Parameters:

t

is a type

Returns:

: a new type in which typedefs have been expanded to reach a basic concrete type, except for struct, union, and enum because the inner types of the fields cannot be changed (they are entities).

Definition at line 2358 of file type.c.

References basic_concrete_type(), basic_pointer, basic_pointer_p, basic_to_string(), basic_typedef, basic_typedef_p, copy_type(), e, entity_type, gen_full_copy_list(), gen_length(), gen_nconc(), ifdebug, is_type_variable, make_basic_pointer(), make_type_variable(), make_variable(), pips_assert, pips_debug, TRUE, type_tag, type_to_string(), type_variable, type_variable_p, variable_basic, variable_dimensions, and variable_qualifiers.

Referenced by basic_concrete_type(), basic_of_intrinsic(), c_convex_effects_on_formal_parameter_backward_translation(), effect_indices_contain_pointer_dimension_p(), effect_pointer_type_p(), effect_reference_contains_pointer_dimension_p(), entity_non_pointer_scalar_p(), generic_p_proper_effect_of_reference(), generic_proper_effects_of_declaration(), make_reference_region(), make_whole_array_predicate(), reference_to_simple_effect(), reference_to_type(), rw_effects_of_declarations(), and simple_effect_reference_type().

{
  type nt;

  pips_debug(9, "Begin with type \"%s\"\n", type_to_string(t));

  switch (type_tag(t))
    {
    case is_type_variable:
      {
        variable vt = type_variable(t);
        basic bt = variable_basic(vt);
        list lt = variable_dimensions(vt);
        
        pips_debug(9, "of basic \"%s\"and number of dimensions %d.\n", 
                   basic_to_string(bt),
                   (int) gen_length(lt));
        
        if(basic_typedef_p(bt))
          {
            entity e = basic_typedef(bt);
            type st = entity_type(e);

            pips_debug(9, "typedef  : %s\n", type_to_string(st));
            nt = basic_concrete_type(st);
            if (type_variable_p(nt))
              {
                variable_dimensions(type_variable(nt)) =
                  gen_nconc(gen_full_copy_list(lt),
                            variable_dimensions(type_variable(nt)));
              }
          }
        else if(basic_pointer_p(bt))
          {
            type npt = basic_concrete_type(basic_pointer(bt));

             pips_debug(9, "pointer \n");
             nt = make_type_variable
               (make_variable(make_basic_pointer(npt),
                              gen_full_copy_list(lt),
                              gen_full_copy_list(variable_qualifiers(vt))));
          }
        else
          {
            pips_debug(9, "other  variable case \n");
             nt = copy_type(t);
          }
      }
      break;

    default:
      nt = copy_type(t);
    }

  pips_debug(9, "Ends with type \"%s\"\n", type_to_string(nt));
  ifdebug(9)
    {
    if(type_variable_p(nt))
      {
        variable nvt = type_variable(nt);
        basic nbt = variable_basic(nvt);
        list nlt = variable_dimensions(nvt);
        pips_debug(9, "of basic \"%s\"and number of dimensions %d.\n",
                 basic_to_string(nbt),
                 (int) gen_length(nlt));
      }
    }

  pips_assert("nt is not a typedef",
              type_variable_p(nt)?
              !basic_typedef_p(variable_basic(type_variable(nt))) : TRUE);

  return nt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int basic_depth

(

basic

b

)

Definition at line 3342 of file type.c.

References basic_derived, basic_tag, basic_typedef, e, entity_type, is_basic_bit, is_basic_complex, is_basic_derived, is_basic_float, is_basic_int, is_basic_logical, is_basic_overloaded, is_basic_pointer, is_basic_string, is_basic_typedef, pips_internal_error, and type_depth().

Referenced by type_depth().

{
  int d = 0;

  switch(basic_tag(b)) {
  case is_basic_int:
  case is_basic_float:
  case is_basic_logical:
  case is_basic_overloaded:
  case is_basic_complex:
  case is_basic_string:
  case is_basic_bit:
  case is_basic_pointer:
    break;
  case is_basic_derived:
    {
      entity e = basic_derived(b);
      type t = entity_type(e);
      d = type_depth(t);
      break;
    }
  case is_basic_typedef:
    {
      entity e = basic_typedef(b);
      type t = entity_type(e);

      d = type_depth(t);
      break;
    }
  default:
    pips_internal_error("Unexpected basic tag %d\n", basic_tag(b));
  }

  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool basic_equal_p	(	basic	b1,
		basic	b2
	)

Parameters:

	b1	1
	b2	2

Definition at line 465 of file type.c.

References basic_equal_strict_p(), basic_typedef, basic_typedef_p, entity_type, type_variable, ultimate_type(), and variable_basic.

Referenced by add_formal_to_actual_bindings(), basic_equal_strict_p(), c_user_function_call_to_transformer(), convert_constant(), declaration_to_transformer(), fortran_user_call_to_transformer(), fortran_user_function_call_to_transformer(), is_constant_of_basic(), is_varibale_array_element_specifier(), make_substitution(), same_basic_and_scalar_p(), simd_check_argType(), simplification_conversion(), store_initial_value(), type_loop_range(), type_this_entity_if_needed(), typing_arguments(), typing_arguments_of_user_function(), typing_of_assign(), typing_power_operator(), and variable_equal_p().

{
  if( basic_typedef_p(b1) )
    {
      type t1 = ultimate_type( entity_type(basic_typedef(b1)) );
      b1 = variable_basic(type_variable(t1));
    }

  if( basic_typedef_p(b2) )
    {
      type t2 = ultimate_type( entity_type(basic_typedef(b2)) );
      b2 = variable_basic(type_variable(t2));
    }
  return basic_equal_strict_p(b1,b2);

}

Here is the call graph for this function:

Here is the caller graph for this function:

bool basic_equal_strict_p	(	basic	b1,
		basic	b2
	)

assertion: b1 and b2 are defined and have the same tag (see previous tests)

Do we want string types to be equal only if lengths are equal? I do not think so

could be a star or an expression; a value_equal_p() is needed!

FI->BC (?): suffixes _p should be removed

just to avoid a warning

Parameters:

	b1	1
	b2	2

Definition at line 405 of file type.c.

References basic_complex, basic_derived, basic_equal_p(), basic_float, basic_int, basic_logical, basic_pointer, basic_tag, basic_typedef_p, basic_undefined, FALSE, is_basic_complex, is_basic_derived, is_basic_float, is_basic_int, is_basic_logical, is_basic_overloaded, is_basic_pointer, is_basic_string, is_basic_typedef, pips_error(), same_entity_p(), TRUE, type_variable, type_variable_p, and variable_basic.

Referenced by add_declaration_statement(), and basic_equal_p().

{
  if(b1 == b2)
    return TRUE;
  else if (b1 == basic_undefined && b2 != basic_undefined)
    return FALSE;
  else if (b1 != basic_undefined && b2 == basic_undefined)
    return FALSE;
  else if (basic_tag(b1) != basic_tag(b2))
    return FALSE;

  /* assertion: b1 and b2 are defined and have the same tag
     (see previous tests) */

  switch(basic_tag(b1)) {
  case is_basic_int:
    return basic_int(b1) == basic_int(b2);
  case is_basic_float:
    return basic_float(b1) == basic_float(b2);
  case is_basic_logical:
    return basic_logical(b1) == basic_logical(b2);
  case is_basic_overloaded:
    return TRUE;
  case is_basic_complex:
    return basic_complex(b1) == basic_complex(b2);
  case is_basic_pointer:
    {
      type t1 = basic_pointer(b1);
      type t2 = basic_pointer(b2);

      return type_variable_p(t1) &&
        type_variable_p(t2) &&
        basic_equal_p( variable_basic(type_variable(t1)) , variable_basic(type_variable(t2)) );
    }
  case is_basic_derived:
    {
      entity e1 = basic_derived(b1);
      entity e2 = basic_derived(b2);

      return e1==e2;
    }
  case is_basic_string:
    /* Do we want string types to be equal only if lengths are equal?
     * I do not think so
     */
    /*
      pips_error("basic_equal_p",
      "string type comparison not implemented\n");
    */
    /* could be a star or an expression; a value_equal_p() is needed! */
    return TRUE;
  case is_basic_typedef:
    /* FI->BC (?): suffixes _p should be removed */
    return basic_typedef_p(b2)
      && same_entity_p(basic_typedef_p(b1),basic_typedef_p(b2));
  default: pips_error("basic_equal_p", "unexpected tag %d\n", basic_tag(b1));
  }
  return FALSE; /* just to avoid a warning */
}

Here is the call graph for this function:

Here is the caller graph for this function:

basic basic_maximum	(	basic	fb1,
		basic	fb2
	)

FI: I do not believe this is correct for all intrinsics!

Type checking problem for ? : with gcc...

NN: More cases are added for C. To be refined

bit is a lesser type

Are they really comparable?

How can we compare two pointer types? Equality? Comparison of the pointed types?

pips_internal_error("Comparison of two pointer types not implemented\n");

FI: not convvincing. As in other palces, assuming this is meaning ful, it would be better to use a basic comparator, basic_greater_p(), which could return 1, -1 or 0 or ??? and deal with non comparable type.

How do you compare a structure or a union to another type? The only case which seems to make sense is equality.

Parameters:

	fb1	b1
	fb2	b2

Definition at line 1264 of file type.c.

References b, b1, b2, basic_bit, basic_bit_p, basic_complex_p, basic_derived, basic_derived_p, basic_float_p, basic_int_p, basic_logical, basic_logical_p, basic_maximum(), basic_overloaded_p, basic_pointer, basic_pointer_p, basic_string_p, basic_tag, basic_typedef_p, basic_ultimate(), basic_undefined, copy_basic(), entity_enum_p(), free_basic(), is_basic_bit, is_basic_complex, is_basic_derived, is_basic_float, is_basic_int, is_basic_logical, is_basic_overloaded, is_basic_pointer, is_basic_string, is_basic_typedef, make_basic(), pips_debug, pips_internal_error, s1, SizeOfElements(), type_variable, type_variable_p, type_void_p, UU, UUINT, and variable_basic.

Referenced by basic_maximum(), basic_of_intrinsic(), basic_union(), and intrinsic_call_to_type().

{
  basic b = basic_undefined;
  basic b1 = basic_ultimate(fb1);
  basic b2 = basic_ultimate(fb2);


  if(basic_derived_p(fb1)) {
    entity e1 = basic_derived(fb1);

    if(entity_enum_p(e1)) {
      b1 = make_basic(is_basic_int, (void *) 4);
      b = basic_maximum(b1, fb2);
      free_basic(b1);
      return b;
    }
    else
      pips_internal_error("Unanalyzed derived basic b1\n");
  }

  if(basic_derived_p(fb2)) {
    entity e2 = basic_derived(fb2);

    if(entity_enum_p(e2)) {
      b2 = make_basic(is_basic_int, (void *) 4);
      b = basic_maximum(fb1, b2);
      free_basic(b2);
      return b;
    }
    else
      pips_internal_error("Unanalyzed derived basic b2\n");
  }

  /* FI: I do not believe this is correct for all intrinsics! */

  pips_debug(7, "Tags: tag exp1 = %d, tag exp2 = %d\n",
             basic_tag(b1), basic_tag(b2));


  if(basic_overloaded_p(b2)) {
    b = copy_basic(b2);
  }
  else {
    switch(basic_tag(b1)) {

    case is_basic_overloaded:
      b = copy_basic(b1);
      break;

    case is_basic_string:
      if(basic_string_p(b2)) {
        int s1 = SizeOfElements(b1);
        int s2 = SizeOfElements(b2);

        /* Type checking problem for ? : with gcc... */
        if(s1>s2)
          b = copy_basic(b1);
        else
          b = copy_basic(b2);
      }
      else
        b = make_basic(is_basic_overloaded, UU);
      break;

    case is_basic_logical:
      if(basic_logical_p(b2)) {
        _int s1 = basic_logical(b1);
        _int s2 = basic_logical(b2);

        b = make_basic(is_basic_logical,UUINT(s1>s2?s1:s2));
      }
      else
        b = make_basic(is_basic_overloaded, UU);
      break;

    case is_basic_complex:
      if(basic_complex_p(b2) || basic_float_p(b2) || basic_int_p(b2)) {
        _int s1 = SizeOfElements(b1);
        _int s2 = SizeOfElements(b2);

        b = make_basic(is_basic_complex, UUINT(s1>s2?s1:s2));
      }
      else
        b = make_basic(is_basic_overloaded, UU);
      break;

    case is_basic_float:
      if(basic_complex_p(b2)) {
        _int s1 = SizeOfElements(b1);
        _int s2 = SizeOfElements(b2);

        b = make_basic(is_basic_complex, UUINT(s1>s2?s1:s2));
      }
      else if(basic_float_p(b2) || basic_int_p(b2)) {
        _int s1 = SizeOfElements(b1);
        _int s2 = SizeOfElements(b2);

        b = make_basic(is_basic_float, UUINT(s1>s2?s1:s2));
      }
      else
        b = make_basic(is_basic_overloaded, UU);
      break;

    case is_basic_int:
      if(basic_complex_p(b2) || basic_float_p(b2)) {
        _int s1 = SizeOfElements(b1);
        _int s2 = SizeOfElements(b2);

        b = make_basic(basic_tag(b2), UUINT(s1>s2?s1:s2));
      }
      else if(basic_int_p(b2)) {
        _int s1 = SizeOfElements(b1);
        _int s2 = SizeOfElements(b2);

        b = make_basic(is_basic_int, UUINT(s1>s2?s1:s2));
      }
      else
        b = make_basic(is_basic_overloaded, UU);
      break;
      /* NN: More cases are added for C. To be refined  */
    case is_basic_bit:
      if(basic_bit_p(b2)) {
        if(basic_bit(b1)>=basic_bit(b2))
          b = copy_basic(b1);
        else
          b = copy_basic(b2);
      }
      else
        /* bit is a lesser type */
        b = copy_basic(b2);
      break;
    case is_basic_pointer:
      {
        if(basic_int_p(b2) || basic_bit_p(b2))
          b = copy_basic(b1);
        else if(basic_float_p(b2) || basic_logical_p(b2) || basic_complex_p(b2)) {
          /* Are they really comparable? */
          b = copy_basic(b1);
        }
        else if(basic_overloaded_p(b2))
          b = copy_basic(b1);
        else if(basic_pointer_p(b2)) {
          /* How can we compare two pointer types? Equality? Comparison of the pointed types? */
          /* pips_internal_error("Comparison of two pointer types not implemented\n"); */
          type t1 = basic_pointer(b1);
          type t2 = basic_pointer(b2);

          if(type_variable_p(t1) && type_variable_p(t2)) {
            basic nb1 = variable_basic(type_variable(t1));
            basic nb2 = variable_basic(type_variable(t2));

            /* FI: not convvincing. As in other palces, assuming this
               is meaning ful, it would be better to use a basic
               comparator, basic_greater_p(), which could return 1, -1
               or 0 or ??? and deal with non comparable type. */
            b = basic_maximum(nb1, nb2);
          }
          else if (type_void_p(t1) && type_void_p(t2) )
          b = copy_basic(b1);
      else
            pips_internal_error("Comparison of two pointer types not meaningful\n");
        }
        else if(basic_derived_p(b2))
          pips_internal_error("Comparison between pointer and struct/union not implemented\n");
        else if(basic_typedef_p(b2))
          pips_internal_error("b2 cannot be a typedef basic\n");
        else
          pips_internal_error("unknown tag %d for basic b2\n", basic_tag(b2));
      break;
       }
     case is_basic_derived:
      /* How do you compare a structure or a union to another type?
         The only case which seems to make sense is equality. */
      pips_internal_error("Derived basic b1 it not comparable to another basic\n");
      break;
    case is_basic_typedef:
      pips_internal_error("b1 cannot be a typedef basic\n");
      break;
    default: pips_internal_error("Ill. basic tag %d\n", basic_tag(b1));
    }
  }

  return b;

  /*
    if( (t1 != is_basic_complex) && (t1 != is_basic_float) &&
    (t1 != is_basic_int) && (t2 != is_basic_complex) &&
    (t2 != is_basic_float) && (t2 != is_basic_int) )
    pips_error("basic_union",
    "Bad basic tag for expression in numerical function");

    if(t1 == is_basic_complex)
    return(b1);
    if(t2 == is_basic_complex)
    return(b2);
    if(t1 == is_basic_float) {
    if( (t2 != is_basic_float) ||
    (basic_float(b1) == DOUBLE_PRECISION_SIZE) )
    return(b1);
    return(b2);
    }
    if(t2 == is_basic_float)
    return(b2);
    return(b1);
  */
}

Here is the call graph for this function:

Here is the caller graph for this function:

basic basic_of_any_expression	(	expression	exp,
		bool	apply_p
	)

Parameters:

	exp	xp
	apply_p	pply_p

Definition at line 925 of file type.c.

References some_basic_of_any_expression(), and TRUE.

Referenced by basic_of_expression(), and some_basic_of_any_expression().

{
  return some_basic_of_any_expression(exp, apply_p, TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

basic basic_of_call	(	call	c,
		bool	apply_p,
		bool	ultimate_p
	)

basic basic_of_call(call c): returns the basic of the result given by the call "c".

If ultimate_p is true, replaced typdef'ed types by their definitions recursively. If not, preserve typedef'ed types.

WARNING: a new basic is allocated

b = make_basic(is_basic_overloaded, UU);

Never go there...

Parameters:

	apply_p	pply_p
	ultimate_p	ltimate_p

Definition at line 971 of file type.c.

References b, basic_of_constant(), basic_of_external(), basic_of_intrinsic(), basic_undefined, call_function, copy_basic(), e, entity_initial, entity_name, is_value_code, is_value_constant, is_value_intrinsic, is_value_symbolic, is_value_unknown, pips_debug, pips_internal_error, tag, and value_tag.

Referenced by c_user_function_call_to_transformer(), fortran_user_function_call_to_transformer(), some_basic_of_any_expression(), and type_this_call().

{
    entity e = call_function(c);
    tag t = value_tag(entity_initial(e));
    basic b = basic_undefined;

    switch (t)
    {
    case is_value_code:
        b = copy_basic(basic_of_external(c));
        break;
    case is_value_intrinsic:
      b = basic_of_intrinsic(c, apply_p, ultimate_p);
        break;
    case is_value_symbolic:
        /* b = make_basic(is_basic_overloaded, UU); */
        b = copy_basic(basic_of_constant(c));
        break;
    case is_value_constant:
        b = copy_basic(basic_of_constant(c));
        break;
    case is_value_unknown:
        pips_debug(1, "function %s has no initial value.\n"
              " Maybe it has not been parsed yet.\n",
              entity_name(e));
        b = copy_basic(basic_of_external(c));
        break;
    default: pips_internal_error("unknown tag %d\n", t);
        /* Never go there... */
    }
    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

basic basic_of_constant

(

call

c

)

basic basic_of_constant(call c): returns the basic of the call to a constant.

WARNING: returns a pointer towards an existing data structure

Definition at line 1211 of file type.c.

References call_function, debug(), entity_type, functional_result, is_type_functional, is_type_variable, pips_error(), type_functional, type_tag, type_variable, and variable_basic.

Referenced by basic_of_call(), and call_to_type().

{
    type call_type, return_type;

    debug(7, "basic_of_constant", "Constant call\n");

    call_type = entity_type(call_function(c));

    if (type_tag(call_type) != is_type_functional)
        pips_error("basic_of_constant", "Bad call type tag");

    return_type = functional_result(type_functional(call_type));

    if (type_tag(return_type) != is_type_variable)
        pips_error("basic_of_constant", "Bad return call type tag");

    return(variable_basic(type_variable(return_type)));
}

Here is the call graph for this function:

Here is the caller graph for this function:

basic basic_of_expression

(

expression

exp

)

basic basic_of_expression(expression exp): Makes a basic of the same basic as the expression "exp".

Indeed, "exp" will be assigned to a temporary variable, which will have the same declaration as "exp".

Does not work if the expression is a reference to a functional entity, as may be the case in a Fortran call.

WARNING: a new basic object is allocated

PREFER (???) expression_basic

Parameters:

exp

xp

Definition at line 942 of file type.c.

References basic_of_any_expression(), and FALSE.

Referenced by add_formal_to_actual_bindings(), any_expression_to_transformer(), any_user_call_site_to_transformer(), assign_tmp_to_exp(), atomize_this_expression(), atomizer_of_external(), basic_of_intrinsic(), basic_of_reference(), basic_union(), condition_to_transformer(), declaration_to_transformer(), do_loop_expansion(), fortran_user_call_to_transformer(), get_optimal_opcode(), get_vect_name_from_data(), integer_expression_p(), inv_call_flt(), logical_binary_function_to_transformer(), make_substitution(), MakeComplexConstantExpression(), MemberIdentifierToExpression(), partial_eval_minus_c_operator(), partial_eval_plus_c_operator(), simd_atomize_this_expression(), simd_fill_curArgType_call(), simplify_C_expression(), simplify_complex_expression(), simplify_subscript(), SizeOfArray(), some_basic_of_any_expression(), split_update_call(), store_initial_value(), transformer_add_any_relation_information(), update_functional_type_with_actual_arguments(), and words_infix_binary_op().

{
  return basic_of_any_expression(exp, FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

basic basic_of_external

(

call

c

)

basic basic_of_external(call c): returns the basic of the result given by the call to an external function.

WARNING: returns a pointer

Definition at line 1011 of file type.c.

References b, basic_to_string(), basic_undefined, call_function, entity_name, entity_type, f, functional_result, is_type_functional, pips_debug, pips_error(), pips_internal_error, pips_user_error, type_functional, type_tag, type_to_string(), type_undefined, type_variable, type_variable_p, type_void_p, and variable_basic.

Referenced by basic_of_call(), and call_to_type().

{
    type return_type = type_undefined;
    entity f = call_function(c);
    basic b = basic_undefined;
    type call_type = entity_type(f);

    pips_debug(7, "External call to %s\n", entity_name(f));

    if (type_tag(call_type) != is_type_functional)
        pips_error("basic_of_external", "Bad call type tag");

    return_type = functional_result(type_functional(call_type));

    if (!type_variable_p(return_type)) {
      if(type_void_p(return_type)) {
        pips_user_error("A subroutine or void returning function is used as an expression\n");
      }
      else {
        pips_internal_error("Bad return call type tag \"%s\"\n", type_to_string(return_type));
      }
    }

    b = (variable_basic(type_variable(return_type)));

    pips_debug(7, "Returned type is %s\n", basic_to_string(b));

    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

basic basic_of_intrinsic	(	call	c,
		bool	apply_p,
		bool	ultimate_p
	)

basic basic_of_intrinsic(call c): returns the basic of the result given by call to an intrinsic function.

This basic must be computed with the basic of the arguments of the intrinsic for overloaded operators. It should be able to accomodate more than two arguments as for generic min and max operators. ultimate_p controls the behavior when typedef'ed types are encountered: should they be replaced by their definitions or not?

WARNING: returns a newly allocated basic object

I don't know the type since there is no arguments ! Bug encountered with a FMT=* in a PRINT. RK, 21/02/1994 :

leave it overloaded

Too bad, this may happen in the parser

Too bad for "void"...

This can also be a user error, but if the function is called from the parser, a CParserError() should be called: how to guess what to do?

We should reconstruct a struct type or an array type...

returns the type of the left hand side

The value returned is the value of the last expression in the list.

The value returned is the value of the first expression in the list after the condition. The second expression is assumed to have the same value because the code is assumed correct.

Parameters:

	apply_p	pply_p
	ultimate_p	ltimate_p

Definition at line 1050 of file type.c.

References b, basic_concrete_type(), basic_maximum(), basic_of_expression(), basic_overloaded_p, basic_pointer, basic_pointer_p, basic_to_string(), basic_undefined, call_arguments, call_function, call_to_type(), CAR, CDR, copy_basic(), copy_type(), e, ENDP, ENTITY_ADDRESS_OF_P, ENTITY_ASSIGN_P, ENTITY_BRACE_INTRINSIC_P, ENTITY_COMMA_P, ENTITY_CONDITIONAL_P, ENTITY_DEREFERENCING_P, ENTITY_FIELD_P, ENTITY_POINT_TO_P, entity_type, EXPRESSION, f, FALSE, free_basic(), free_type(), functional_result, gen_last(), gen_length(), ifdebug, is_basic_pointer, is_type_variable, make_basic(), make_basic_overloaded(), make_type(), make_variable(), MAP, module_local_name(), NIL, pips_assert, pips_debug, pips_internal_error, print_expression(), rt, some_basic_of_any_expression(), type_consistent_p(), type_functional, type_functional_p, type_undefined, type_undefined_p, type_variable, type_variable_p, ultimate_type(), and variable_basic.

Referenced by basic_of_call().

{
    entity f = call_function(c);
    type rt = functional_result(type_functional(entity_type(f)));
    basic rb = copy_basic(variable_basic(type_variable(rt)));

    pips_debug(7, "Intrinsic call to intrinsic \"%s\" with a priori result type \"%s\"\n",
            module_local_name(f),
            basic_to_string(rb));

    if(basic_overloaded_p(rb)) {
        list args = call_arguments(c);

        if (ENDP(args)) {
            /* I don't know the type since there is no arguments !
               Bug encountered with a FMT=* in a PRINT.
               RK, 21/02/1994 : */
            /* leave it overloaded */
            ;
        }
        else if(ENTITY_ADDRESS_OF_P(f)) {
            //string s = entity_user_name(f);
            //bool b = ENTITY_ADDRESS_OF_P(f);
            expression e = EXPRESSION(CAR(args));
            basic eb = some_basic_of_any_expression(e, FALSE, ultimate_p);
            // Forget multidimensional types
            type et = make_type(is_type_variable,
                    make_variable(eb, NIL, NIL));

            //fprintf(stderr, "b=%d, s=%s\n", b, s);
            free_basic(rb);
            rb = make_basic(is_basic_pointer, et);
        }
        else if(ENTITY_DEREFERENCING_P(f)) {
            expression e = EXPRESSION(CAR(args));
            free_basic(rb);
            rb = basic_of_expression(e);
            if(basic_pointer_p(rb)) {
                type pt = type_undefined;

                if(ultimate_p && !type_undefined_p(basic_pointer(rb)))
                    pt = copy_type(ultimate_type(basic_pointer(rb)));
                else
                    pt = copy_type(basic_pointer(rb));

                pips_assert("The pointed type is consistent", type_consistent_p(pt));
                if(type_undefined_p(pt)) {
                  /* Too bad, this may happen in the parser */
                  free_basic(rb);
                  rb = basic_undefined;
                }
                else if(type_variable_p(pt) && !apply_p) {
                    free_basic(rb);
                    rb = copy_basic(variable_basic(type_variable(pt)));
                }
                else if(type_functional_p(pt)) {
                    if(apply_p) {
                        free_basic(rb);
                        type rt = ultimate_type(functional_result(type_functional(pt)));
                        if(type_variable_p(rt))
                            rb = copy_basic(variable_basic(type_variable(rt)));
                        else {
                            /* Too bad for "void"... */
                            pips_internal_error("result type of a functional type must be a variable type\n");
                        }
                    }
                    else {
                        return rb;
                    }
                }
                else {
                    pips_internal_error("unhandled case\n");
                }
            }
            else {
                type et = call_to_type(c);
                if(ultimate_p) et=basic_concrete_type(et);
                if( type_variable_p(et) )
                {
                    free_basic(rb);
                    rb=copy_basic(variable_basic(type_variable(et)));
                }
                if( !type_variable_p(et) ) {

                    /* This can also be a user error, but if the function is
                       called from the parser, a CParserError() should be called:
                       how to guess what to do? */
                    pips_internal_error("Dereferencing of a non-pointer, non array expression\n"
                            "Please use gcc to check that your source code is legal\n");
                }
                if(ultimate_p) free_type(et);
            }
        }
        else if(ENTITY_POINT_TO_P(f)) {
            //pips_internal_error("Point to case not implemented yet\n");
            expression e1 = EXPRESSION(CAR(args));
            expression e2 = EXPRESSION(CAR(CDR(args)));
            free_basic(rb);
            pips_assert("Two arguments for ENTITY_POINT_TO", gen_length(args)==2);
            ifdebug(8) {
                pips_debug(8, "Point to case, e1 = ");
                print_expression(e1);
                pips_debug(8, " and e2 = ");
                print_expression(e1);
                pips_debug(8, "\n");
            }
            rb = basic_of_expression(e2);
        }
        else if(ENTITY_BRACE_INTRINSIC_P(f)) {
            /* We should reconstruct a struct type or an array type... */
            rb = make_basic_overloaded();
        }
        else if(ENTITY_ASSIGN_P(f)) {
            /* returns the type of the left hand side */
            rb = basic_of_expression(EXPRESSION(CAR(args)));
        }
        else if(ENTITY_FIELD_P(f)) {
            free_basic(rb);
            rb = basic_of_expression(EXPRESSION(CAR(CDR(args))));
        }
        else if(ENTITY_COMMA_P(f)) {
            /* The value returned is the value of the last expression in the list. */
            free_basic(rb);
            rb = basic_of_expression(EXPRESSION(CAR(gen_last(args))));
        }
        else if(ENTITY_CONDITIONAL_P(f)) {
            /* The value returned is the value of the first expression in
               the list after the condition. The second expression is
               assumed to have the same value because the code is assumed
               correct. */
            free_basic(rb);
            rb = basic_of_expression(EXPRESSION(CAR(CDR(args))));
        }
        else {
            free_basic(rb);
            rb = basic_of_expression(EXPRESSION(CAR(args)));

            MAP(EXPRESSION, arg, {
                    basic b = basic_of_expression(arg);
                    basic new_rb = basic_maximum(rb, b);

                    free_basic(rb);
                    free_basic(b);
                    rb = new_rb;
                    }, CDR(args));
        }

    }

    pips_debug(7, "Intrinsic call to intrinsic \"%s\" with a posteriori result type \"%s\"\n",
            module_local_name(f),
            basic_to_string(rb));

    return rb;
}

Here is the call graph for this function:

Here is the caller graph for this function:

basic basic_of_reference

(

reference

r

)

retreives the basic of a reference in a newly allocated bsaic object

Parameters:

r

reference we want the basic of

Returns:

allocated basic of the reference

Definition at line 954 of file type.c.

References basic_of_expression(), expression_syntax, expression_undefined, expression_undefined_p, make_expression(), make_syntax_reference(), normalized_undefined, reference_undefined, and syntax_reference.

Referenced by build_new_ref(), generate_prelude(), generate_scalar_variables(), generate_scalar_variables_from_list(), get_type_max_width(), make_reduction_vector_entity(), make_substitution(), match_call(), my_build_new_ref(), process_true_call_stat(), rename_statement_reductions(), and variables_width_filter().

{
    static expression sexp = expression_undefined;
    if(expression_undefined_p(sexp)) sexp=make_expression(make_syntax_reference(reference_undefined),normalized_undefined);
    syntax_reference(expression_syntax(sexp)) = r;
    return basic_of_expression(sexp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

list basic_supporting_entities	(	list	sel,
		set	vt,
		basic	b
	)

Parameters:

	sel	el
	vt	t

Definition at line 2758 of file type.c.

References basic_bit, basic_bit_p, basic_complex_p, basic_derived, basic_derived_p, basic_float_p, basic_int_p, basic_logical_p, basic_overloaded_p, basic_pointer, basic_pointer_p, basic_string_p, basic_tag, basic_typedef, basic_typedef_p, CONS, ENTITY, entity_type, fprintf(), gen_nconc(), ifdebug, NIL, pips_debug, pips_internal_error, print_entities(), recursive_type_supporting_entities(), and symbolic_supporting_entities().

Referenced by variable_type_supporting_entities().

{

  ifdebug(8) {
    pips_debug(8, "Begin: ");
    print_entities(sel);
    fprintf(stderr, "\n\n");
  }

  if(basic_int_p(b) ||
     basic_float_p(b) ||
     basic_logical_p(b) ||
     basic_overloaded_p(b) ||
     basic_complex_p(b) ||
     basic_string_p(b))
    ;
  else if(basic_bit_p(b))
    sel = symbolic_supporting_entities(sel, vt, basic_bit(b));
  else if(basic_pointer_p(b))
    sel = recursive_type_supporting_entities(sel, vt, basic_pointer(b));
  else if(basic_derived_p(b)) {
    //sel = CONS(ENTITY, basic_derived(b), sel);
    sel = recursive_type_supporting_entities(sel, vt, entity_type(basic_derived(b)));
    sel = gen_nconc(sel, CONS(ENTITY, basic_derived(b), NIL));
  }
  else if(basic_typedef_p(b)) {
    entity se = basic_typedef(b);
    //sel = CONS(ENTITY, se, sel);
    sel = recursive_type_supporting_entities(sel, vt, entity_type(se));
    sel = gen_nconc(sel, CONS(ENTITY, se, NIL));
  }
  else
    pips_internal_error("Unrecognized basic tag %d\n", basic_tag(b));

  ifdebug(8) {
    pips_debug(8, "End: ");
    print_entities(sel);
    fprintf(stderr, "\n\n");
  }

  return sel;
}

Here is the call graph for this function:

Here is the caller graph for this function:

list basic_supporting_references	(	list	srl,
		basic	b
	)

Parameters:

srl

rl

Definition at line 3036 of file type.c.

References basic_bit, basic_bit_p, basic_complex_p, basic_derived, basic_derived_p, basic_float_p, basic_int_p, basic_logical_p, basic_overloaded_p, basic_pointer, basic_pointer_p, basic_string_p, basic_tag, basic_typedef, basic_typedef_p, entity_type, fprintf(), ifdebug, pips_debug, pips_internal_error, print_references(), recursive_type_supporting_references(), and symbolic_supporting_references().

Referenced by variable_type_supporting_references().

{

  ifdebug(9) {
    pips_debug(8, "Begin: ");
    print_references(srl);
    fprintf(stderr, "\n");
  }

  if(basic_int_p(b) ||
     basic_float_p(b) ||
     basic_logical_p(b) ||
     basic_overloaded_p(b) ||
     basic_complex_p(b) ||
     basic_string_p(b))
    ;
  else if(basic_bit_p(b))
    srl = symbolic_supporting_references(srl, basic_bit(b));
  else if(basic_pointer_p(b))
    srl = recursive_type_supporting_references(srl, basic_pointer(b));
  else if(basic_derived_p(b)) {
    //srl = CONS(ENTITY, basic_derived(b), srl);
    srl = recursive_type_supporting_references(srl, entity_type(basic_derived(b)));
  }
  else if(basic_typedef_p(b)) {
    entity se = basic_typedef(b);
    //srl = CONS(ENTITY, se, srl);
    srl = recursive_type_supporting_references(srl, entity_type(se));
  }
  else
    pips_internal_error("Unrecognized basic tag %d\n", basic_tag(b));

  ifdebug(9) {
    pips_debug(8, "End: ");
    print_references(srl);
    fprintf(stderr, "\n");
  }

  return srl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static list basic_supporting_types	(	list	stl,
		set	vt,
		basic	b
	)			[static]

Definition at line 3528 of file type.c.

References basic_bit_p, basic_complex_p, basic_derived, basic_derived_p, basic_float_p, basic_int_p, basic_logical_p, basic_overloaded_p, basic_pointer, basic_pointer_p, basic_string_p, basic_tag, basic_typedef, basic_typedef_p, CONS, ENTITY, entity_type, fprintf(), ifdebug, pips_debug, pips_internal_error, print_entities(), recursive_type_supporting_entities(), and recursive_type_supporting_types().

Referenced by variable_type_supporting_types().

{

  ifdebug(8) {
    pips_debug(8, "Begin: ");
    print_entities(stl);
    fprintf(stderr, "\n");
  }

  if(basic_int_p(b) ||
     basic_float_p(b) ||
     basic_logical_p(b) ||
     basic_overloaded_p(b) ||
     basic_complex_p(b) ||
     basic_string_p(b))
    ;
  else if(basic_bit_p(b))
    ;
  else if(basic_pointer_p(b))
    stl = recursive_type_supporting_types(stl, vt, basic_pointer(b));
  else if(basic_derived_p(b)) {
    entity de = basic_derived(b);
    type dt = entity_type(de);
    stl = CONS(ENTITY, de, stl);
    stl = recursive_type_supporting_types(stl, vt, dt);
  }
  else if(basic_typedef_p(b)) {
    entity se = basic_typedef(b);
    type st = entity_type(se);
    stl = CONS(ENTITY, se, stl);
    stl = recursive_type_supporting_entities(stl, vt, st);
  }
  else
    pips_internal_error("Unrecognized basic tag %d\n", basic_tag(b));

  ifdebug(8) {
    pips_debug(8, "End: ");
    print_entities(stl);
    fprintf(stderr, "\n");
  }

  return stl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

entity basic_to_generic_conversion

(

basic

b

)

returns the corresponding generic conversion entity, if any.

otherwise returns entity_undefined.

what about INTEGER*{2,4,8} ?

Definition at line 2024 of file type.c.

References basic_complex, basic_float, basic_tag, CMPLX_GENERIC_CONVERSION_NAME, DBLE_GENERIC_CONVERSION_NAME, DCMPLX_GENERIC_CONVERSION_NAME, entity_intrinsic(), entity_undefined, INT_GENERIC_CONVERSION_NAME, is_basic_complex, is_basic_float, is_basic_int, and REAL_GENERIC_CONVERSION_NAME.

Referenced by make_substitution().

{
    entity result;

    switch (basic_tag(b))
    {
    case is_basic_int:
        /* what about INTEGER*{2,4,8} ?
         */
        result = entity_intrinsic(INT_GENERIC_CONVERSION_NAME);
        break;
    case is_basic_float:
    {
        if (basic_float(b)==4)
            result = entity_intrinsic(REAL_GENERIC_CONVERSION_NAME);
        else if (basic_float(b)==8)
            result = entity_intrinsic(DBLE_GENERIC_CONVERSION_NAME);
        else
            result = entity_undefined;
        break;
    }
    case is_basic_complex:
    {
        if (basic_complex(b)==8)
            result = entity_intrinsic(CMPLX_GENERIC_CONVERSION_NAME);
        else if (basic_complex(b)==16)
            result = entity_intrinsic(DCMPLX_GENERIC_CONVERSION_NAME);
        else
            result = entity_undefined;
        break;
    }
    default:
        result = entity_undefined;
    }

    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

string basic_to_string

(

basic

b

)

BEGIN_EOLE.

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

Nga Nguyen, 19/09/2003: To not rewrite the same thing, I use the words_basic() function

Definition at line 736 of file type.c.

References list_to_string(), NIL, and words_basic().

Referenced by add_formal_to_actual_bindings(), any_expression_to_transformer(), any_user_call_site_to_transformer(), arguments_are_something(), basic_concrete_type(), basic_of_external(), basic_of_intrinsic(), can_terapixify_expression_p(), codegen_commenter(), DeclareVariable(), dump_functional(), fortran_user_call_to_transformer(), fprint_any_environment(), fprint_functional(), generic_p_proper_effect_of_reference(), get_symbol_table(), is_varibale_array_element_specifier(), register_scalar_communications(), relation_to_transformer(), sentence_basic_declaration(), some_basic_of_any_expression(), string_expression_to_transformer(), stub_head(), stub_var_decl(), this_entity_cdeclaration(), type_this_call(), type_this_entity_if_needed(), type_this_expression(), type_this_instruction(), TypeFunctionalEntity(), typing_arguments_of_user_function(), typing_function_argument_type_to_return_type(), ultimate_type(), and variable_to_string().

{
  /* Nga Nguyen, 19/09/2003: To not rewrite the same thing, I use the words_basic() function*/
  return list_to_string(words_basic(b, NIL));
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool basic_type_p

(

type

t

)

Safer than the other implementation? bool pointer_type_p(type t) { bool is_pointer = FALSE;.

if (!type_undefined_p(t) && type_variable_p(t)) { basic b = variable_basic(type_variable(t)); if (!basic_undefined_p(b) && basic_pointer_p(b)) { is_pointer = TRUE; } } return is_pointer; }Here is the set of mapping functions, from the RI to C language typesReturns TRUE if t is one of the following types : void, char, short, int, long, float, double, signed, unsigned, and there is no array dimensions, of course

Definition at line 2155 of file type.c.

References b, basic_bit_p, basic_complex_p, basic_float_p, basic_int_p, basic_logical_p, basic_overloaded_p, basic_string_p, NIL, type_unknown_p, type_variable, type_variable_p, type_void_p, variable_basic, and variable_dimensions.

Referenced by generic_c_words_simplified_entity().

{
  if (type_variable_p(t))
    {
      basic b = variable_basic(type_variable(t));
      return ((variable_dimensions(type_variable(t)) == NIL) &&
              (basic_int_p(b) || basic_float_p(b) || basic_logical_p(b)
               || basic_overloaded_p(b) || basic_complex_p(b) || basic_string_p(b)
               || basic_bit_p(b)));
    }
  return (type_void_p(t) || type_unknown_p(t)) ;
}

Here is the caller graph for this function:

int basic_type_size

(

basic

b

)

See also SizeOfElements().

pips_error("basic_type_size", "undefined for type string\n");

Definition at line 561 of file type.c.

References basic_complex, basic_float, basic_int, basic_logical, basic_tag, is_basic_complex, is_basic_float, is_basic_int, is_basic_logical, is_basic_overloaded, is_basic_string, pips_error(), and string_type_size().

Referenced by DeclareVariable(), MakeAtom(), MakeComplexConstant(), and MakeComplexConstantExpression().

{
    int size = -1;

    switch(basic_tag(b)) {
    case is_basic_int: size = basic_int(b);
        break;
    case is_basic_float: size = basic_float(b);
        break;
    case is_basic_logical: size = basic_logical(b);
        break;
    case is_basic_overloaded:
        pips_error("basic_type_size", "undefined for type overloaded\n");
        break;
    case is_basic_complex: size = basic_complex(b);
        break;
    case is_basic_string:
      /* pips_error("basic_type_size", "undefined for type string\n"); */
      size = string_type_size(b);
        break;
    default: size = basic_int(b);
        pips_error("basic_type_size", "ill. tag %d\n", basic_tag(b));
        break;
    }

    return size;
}

Here is the call graph for this function:

Here is the caller graph for this function:

basic basic_ultimate

(

basic

b

)

get the ultimate basic from a basic typedef

Definition at line 1254 of file type.c.

References basic_typedef, basic_typedef_p, entity_type, pips_assert, type_variable, type_variable_p, ultimate_type(), and variable_basic.

Referenced by basic_maximum(), and make_new_scalar_variable_with_prefix().

{
  if(basic_typedef_p(b)) {
    type t = ultimate_type(entity_type(basic_typedef(b)));
    pips_assert("typedef really has a variable type", type_variable_p(t) );
    b = variable_basic(type_variable(t));
  }
  return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

basic basic_union	(	expression	exp1,
		expression	exp2
	)

basic basic_union(expression exp1 exp2): returns the basic of the expression which has the most global basic.

Then, between "int" and "float", the most global is "float".

Note: there are two different "float" : DOUBLE PRECISION and REAL.

WARNING: a new basic data structure is allocated (because you cannot always find a proper data structure to return simply a pointer

Parameters:

	exp1	xp1
	exp2	xp2

Definition at line 1240 of file type.c.

References b, b1, b2, basic_maximum(), basic_of_expression(), and free_basic().

{
  basic b1 = basic_of_expression(exp1);
  basic b2 = basic_of_expression(exp2);
  basic b = basic_maximum(b1, b2);

  free_basic(b1);
  free_basic(b2);
  return b;
}

Here is the call graph for this function:

bool bit_type_p

(

type

t

)

Definition at line 2098 of file type.c.

References b, basic_bit_p, basic_undefined_p, FALSE, TRUE, type_undefined_p, type_variable, type_variable_p, and variable_basic.

Referenced by generic_c_words_simplified_entity(), make_standard_integer_type(), make_standard_long_integer_type(), and UpdateDerivedEntity().

{
  if (!type_undefined_p(t) && type_variable_p(t))
    {
      basic b = variable_basic(type_variable(t));
      if (!basic_undefined_p(b) && basic_bit_p(b))
        return TRUE;
    }
  return FALSE;
}

Here is the caller graph for this function:

type call_compatible_type

(

type

t

)

returns the type necessary to generate or check a call to an object of type t.

Does not allocate a new type. Previous function could be implemented with this one.

Definition at line 2461 of file type.c.

References b, basic_pointer, basic_pointer_p, basic_typedef, basic_typedef_p, call_compatible_type(), entity_type, FALSE, pips_assert, type_consistent_p(), type_functional_p, type_variable, type_variable_p, and variable_basic.

Referenced by call_compatible_type(), check_C_function_type(), words_genuine_regular_call(), and words_regular_call().

{
  type compatible = t;

  pips_assert("t is a consistent type", type_consistent_p(t));

  if(!type_functional_p(t)) {
    if(type_variable_p(t)) {
      basic b = variable_basic(type_variable(t));

      if(basic_pointer_p(b))
        compatible = call_compatible_type(basic_pointer(b));
      else if(basic_typedef_p(b)) {
        entity te = basic_typedef(b);

        compatible = call_compatible_type(entity_type(te));
      }
      else
        compatible = FALSE;
    }
    else
      compatible = FALSE;
  }
  pips_assert("compatible is a functional type", type_functional_p(compatible));
  pips_assert("compatible is a consistent type", type_consistent_p(compatible));
  return compatible;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool call_compatible_type_p

(

type

t

)

Is an object of type t compatible with a call?

Definition at line 2434 of file type.c.

References b, basic_pointer, basic_pointer_p, basic_typedef, basic_typedef_p, call_compatible_type_p(), entity_type, FALSE, TRUE, type_functional_p, type_variable, type_variable_p, and variable_basic.

Referenced by call_compatible_type_p(), check_C_function_type(), and MakeFunctionExpression().

{
  bool compatible_p = TRUE;

  if(!type_functional_p(t)) {
    if(type_variable_p(t)) {
      basic b = variable_basic(type_variable(t));

      if(basic_pointer_p(b))
        compatible_p = call_compatible_type_p(basic_pointer(b));
      else if(basic_typedef_p(b)) {
        entity te = basic_typedef(b);

        compatible_p = call_compatible_type_p(entity_type(te));
      }
      else
        compatible_p = FALSE;
    }
    else
      compatible_p = FALSE;
  }
  return compatible_p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

type call_to_functional_type	(	call	c,
		bool	ultimate_p
	)

The function called can have a functional type, or a typedef type or a pointer type to a functional type.

FI: I'm not sure this is correctly implemented. I do not know if a new type is always allocated. I do not understand the semantics if ultimate is turned off.

assertion will fail anyway

must be a functional type

Parameters:

ultimate_p

ltimate_p

Definition at line 2494 of file type.c.

References basic_pointer, basic_pointer_p, basic_typedef, basic_typedef_p, call_function, copy_type(), entity_type, f, free_type(), pips_assert, pips_internal_error, rt, type_functional_p, type_undefined, type_variable, type_variable_p, ultimate_type(), and variable_basic.

Referenced by MemberIdentifierToExpression(), and simplify_C_expression().

{
  entity f = call_function(c);
  type ft = entity_type(f);
  type rt = type_undefined;

  if(type_functional_p(ft))
    rt = entity_type(f);
  else if(type_variable_p(ft)) {
    basic ftb = variable_basic(type_variable(ft));
    if(basic_pointer_p(ftb)) {
      type pt = basic_pointer(ftb);
      rt = ultimate_p? ultimate_type(pt) : copy_type(pt);
    }
    else if(basic_typedef_p(ftb)) {
      entity te = basic_typedef(ftb);
      type ut = ultimate_type(entity_type(te));

      if(type_variable_p(ut)) {
        basic utb = variable_basic(type_variable(ut));
        if(basic_pointer_p(utb)) {
          type pt = basic_pointer(utb);
          rt = ultimate_p? ultimate_type(pt): copy_type(pt);
        }
        else
          /* assertion will fail anyway */
          free_type(ut);
      }
      else /* must be a functional type */
        rt = ut;
    }
    else {
      pips_internal_error("Basic for called function unknown");
    }
  }
  else
    pips_internal_error("Type for called function unknown");

  pips_assert("The typedef type is functional", type_functional_p(rt));

  return rt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

type call_to_type

(

call

c

)

b = make_basic(is_basic_overloaded, UU);

Never go there...

Definition at line 1636 of file type.c.

References basic_of_constant(), basic_of_external(), call_function, copy_basic(), e, entity_initial, entity_name, intrinsic_call_to_type(), is_type_variable, is_value_code, is_value_constant, is_value_intrinsic, is_value_symbolic, is_value_unknown, make_type(), make_variable(), NIL, pips_debug, pips_internal_error, type_undefined, and value_tag.

Referenced by basic_of_intrinsic(), and expression_to_type().

{
    entity e = call_function(c);
    type t = type_undefined;

    switch (value_tag(entity_initial(e)))
    {
    case is_value_code:
      t = make_type(is_type_variable,
                    make_variable(copy_basic(basic_of_external(c)),
                                  NIL, NIL));
      break;
    case is_value_intrinsic:
      t = intrinsic_call_to_type(c);
      break;
    case is_value_symbolic:
      /* b = make_basic(is_basic_overloaded, UU); */
      t = make_type(is_type_variable,
                    make_variable(copy_basic(basic_of_constant(c)),
                                  NIL, NIL));
      break;
    case is_value_constant:
      t = make_type(is_type_variable,
                    make_variable(copy_basic(basic_of_constant(c)),
                                  NIL, NIL));
      break;
    case is_value_unknown:
      pips_debug(1, "function %s has no initial value.\n"
                 " Maybe it has not been parsed yet.\n",
                 entity_name(e));
      t = make_type(is_type_variable,
                    make_variable(copy_basic(basic_of_external(c)),
                                  NIL, NIL));
      break;
    default: pips_internal_error("unknown tag %d\n", t);
      /* Never go there... */
    }

    return t;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool char_type_p

(

type

t

)

see words_basic()

Definition at line 2120 of file type.c.

References b, basic_int, basic_int_p, basic_undefined_p, FALSE, i, type_undefined_p, type_variable, type_variable_p, and variable_basic.

Referenced by SizeOfArray().

{
  bool is_char = FALSE;

  if (!type_undefined_p(t) && type_variable_p(t)) {
    basic b = variable_basic(type_variable(t));
    if (!basic_undefined_p(b) && basic_int_p(b)) {
      int i = basic_int(b);
    is_char = (i==1); /* see words_basic() */
    }
  }
  return is_char;
}

Here is the caller graph for this function:

bool check_C_function_type	(	entity	f,
		list	args
	)

Check that an effective parameter list is compatible with a function type.

Or improve the function type when it is not precise as with "extern int f()". This is (a bit/partially) redundant with undeclared function detection since undeclared functions are declared "extern int f()".

FI: well, for debugging only...

Use parms to improve the type of f, probably declared f() with no type information.

Should be very similar to call_to_functional_type().

Must be a typedef or a pointer to a function. No need to refine the type

Take care of the void case

Take care of the varargs case

Check type compatibility: find function in flint? type_equal_p() requires lots of extensions to handle C types. And you would probably need type conversion to concrete type.

Parameters:

args

rgs

Definition at line 3225 of file type.c.

References b, c_text_entity(), call_compatible_type(), call_compatible_type_p(), CAR, CONS, DEFAULT_INTEGER_TYPE_SIZE, e, ENDP, entity_type, entity_user_name(), EXPRESSION, expression_to_user_type(), FALSE, functional_parameters, functional_result, gen_last(), gen_length(), gen_nconc(), get_current_module_entity(), ifdebug, lp, make_basic_int(), make_dummy_unknown(), make_mode_value(), make_parameter(), make_type_variable(), make_variable(), MAP, NIL, ok, PARAMETER, parameter_type, pips_assert, pips_debug, pips_user_warning, pl, print_text(), TRUE, type_functional, type_functional_p, type_unknown_p, type_varargs_p, and type_void_p.

Referenced by MakeFunctionExpression().

{
  bool ok = TRUE;
  type t = entity_type(f);
  type ct = call_compatible_type(t);
  list parms = functional_parameters(type_functional(ct));
  extern void print_text(FILE *, text); /* FI: well, for debugging only... */

  pips_assert("f can be used to generate a call", call_compatible_type_p(t));

  if(ENDP(parms)) {
    if(ENDP(args))
      ;
    else {
      if(type_functional_p(t)) {
        /* Use parms to improve the type of f, probably declared f()
           with no type information. */
        /* Should be very similar to call_to_functional_type(). */
        list pl = NIL;
        MAP(EXPRESSION, e, {
            type et = expression_to_user_type(e);
            parameter p = make_parameter(et, make_mode_value(), make_dummy_unknown());
            pl = gen_nconc(pl, CONS(PARAMETER, p, NIL));
          },
          args);
        functional_parameters(type_functional(t)) = pl;

        if(type_unknown_p(functional_result(type_functional(t)))) {
          basic b = make_basic_int(DEFAULT_INTEGER_TYPE_SIZE);
          functional_result(type_functional(t)) = make_type_variable(make_variable(b, NIL, NIL));
        }

        pips_user_warning("Type updated for function \"%s\"\n", entity_user_name(f));
        ifdebug(8) {
          text txt = c_text_entity(get_current_module_entity(), f, 0, NIL);
          print_text(stderr, txt);
        }
      }
      else {
        /* Must be a typedef or a pointer to a function. No need to refine the type*/
        ifdebug(8) {
          text txt = c_text_entity(get_current_module_entity(), f, 0, NIL);
          pips_debug(8, "Type not updated for function \"%s\"\n", entity_user_name(f));
          print_text(stderr, txt);
        }
      }
    }
  }
  else if(gen_length(args)!=gen_length(parms)) {
    /* Take care of the void case */
    if(gen_length(args)==0 && gen_length(parms)==1) {
      parameter p = PARAMETER(CAR(parms));
      type pt = parameter_type(p);
      ok = type_void_p(pt);
    }
    /* Take care of the varargs case*/
    else if(gen_length(parms) >= 2 && gen_length(args) > gen_length(parms)) {
      parameter lp = PARAMETER(CAR(gen_last(parms)));
      type pt = parameter_type(lp);
      ok = type_varargs_p(pt);
    }
    else
      ok = FALSE;
  }
  else {
    /* Check type compatibility: find function in flint?
       type_equal_p() requires lots of extensions to handle C
       types. And you would probably need type conversion to concrete
       type.*/
    ;
  }

  return ok;
}

Here is the call graph for this function:

Here is the caller graph for this function:

list constant_expression_supporting_entities	(	list	sel,
		set	vt,
		expression	e
	)

C version.

Parameters:

	sel	el
	vt	t

Definition at line 2728 of file type.c.

References generic_constant_expression_supporting_entities(), and TRUE.

Referenced by enum_supporting_entities(), and variable_type_supporting_entities().

{
  return generic_constant_expression_supporting_entities(sel, vt, e, TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

list constant_expression_supporting_references	(	list	srl,
		expression	e
	)

Only applicable to C expressions.

We need to know if we are dealing with C or Fortran code.

In C, f cannot be declared directly, we need its enum

But in Fortran, we are done

FI: suggested kludge: use a Fortran incompatible type for enum member. But currently they are four byte signed integer (c89) and this Fortran INTEGER type :-(

Could be guarded so as not to be added twice. Guard might be useless with because types are visited only once.

do nothing for the time being...

Parameters:

srl

rl

Definition at line 2973 of file type.c.

References c, call_arguments, call_function, CONS, constant_expression_supporting_references(), enum_supporting_references(), EXPRESSION, expression_syntax, f, find_enum_of_member(), fprintf(), gen_nconc(), ifdebug, MAP, NIL, pips_debug, print_references(), REFERENCE, reference_indices, s, symbolic_constant_entity_p(), syntax_call, syntax_call_p, syntax_reference, and syntax_reference_p.

Referenced by constant_expression_supporting_references(), enum_supporting_references(), symbolic_supporting_references(), and variable_type_supporting_references().

{
  syntax s = expression_syntax(e);

  ifdebug(9) {
    pips_debug(8, "Begin: ");
    print_references(srl);
    fprintf(stderr, "\n");
  }

  if(syntax_call_p(s)) {
    call c = syntax_call(s);
    entity f = call_function(c);

    if(symbolic_constant_entity_p(f)) {
      /* We need to know if we are dealing with C or Fortran code. */
      /* In C, f cannot be declared directly, we need its enum */
      /* But in Fortran, we are done */
      /* FI: suggested kludge: use a Fortran incompatible type for
         enum member. But currently they are four byte signed integer (c89)
         and this Fortran INTEGER type :-( */

      extern entity find_enum_of_member(entity);
      entity e_of_f = find_enum_of_member(f);
      //srl = CONS(ENTITY, e_of_f, srl);
      srl = enum_supporting_references(srl, e_of_f);
    }

    MAP(EXPRESSION, se, {
      srl = constant_expression_supporting_references(srl, se);
    }, call_arguments(c));
  }
  else if(syntax_reference_p(s)) {
    reference r = syntax_reference(s);
    list inds = reference_indices(r);
    /* Could be guarded so as not to be added twice. Guard might be
       useless with because types are visited only once. */
    srl = gen_nconc(srl, CONS(REFERENCE, r, NIL));
    MAP(EXPRESSION, se, {
        srl = constant_expression_supporting_references(srl, se);
      }, inds);
  }
  else {
    /* do nothing for the time being... */
    ;
  }

  ifdebug(9) {
    pips_debug(8, "End: ");
    print_references(srl);
    fprintf(stderr, "\n");
  }

  return srl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool derived_type_p

(

type

t

)

Returns TRUE if t is of type struct, union or enum.

Need to distinguish with the case struct/union/enum in type in RI, these are the definitions of the struct/union/enum themselve, not a variable of this type.

Example : struct foo var;

Definition at line 2186 of file type.c.

References basic_derived_p, NIL, type_variable, type_variable_p, variable_basic, and variable_dimensions.

Referenced by c_convex_effects_on_formal_parameter_backward_translation(), c_text_entities(), generic_c_words_simplified_entity(), and words_sizeofexpression().

{
  return (type_variable_p(t) && basic_derived_p(variable_basic(type_variable(t)))
          && (variable_dimensions(type_variable(t)) == NIL));
}

Here is the caller graph for this function:

dimension dimension_dup

(

dimension

d

)

Definition at line 643 of file type.c.

References copy_expression(), dimension_lower, dimension_upper, and make_dimension().

Referenced by ldimensions_dup().

{
    return(make_dimension(copy_expression(dimension_lower(d)),
                          copy_expression(dimension_upper(d))));
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool dimension_equal_p	(	dimension	d1,
		dimension	d2
	)

same values

and same names...

Parameters:

	d1	1
	d2	2

Definition at line 355 of file type.c.

References dimension_lower, dimension_upper, same_expression_name_p(), and same_expression_p().

Referenced by variable_equal_p().

{
    return /* same values */
        same_expression_p(dimension_lower(d1), dimension_lower(d2)) &&
        same_expression_p(dimension_upper(d1), dimension_upper(d2)) &&
        /* and same names... */
        same_expression_name_p(dimension_lower(d1), dimension_lower(d2)) &&
        same_expression_name_p(dimension_upper(d1), dimension_upper(d2));
}

Here is the call graph for this function:

Here is the caller graph for this function:

int effect_basic_depth

(

basic

b

)

Definition at line 3420 of file type.c.

References basic_derived, basic_pointer, basic_tag, basic_typedef, e, effect_type_depth(), entity_type, is_basic_bit, is_basic_complex, is_basic_derived, is_basic_float, is_basic_int, is_basic_logical, is_basic_overloaded, is_basic_pointer, is_basic_string, is_basic_typedef, pips_internal_error, and type_depth().

Referenced by effect_type_depth().

{
  int d = 0;

  switch(basic_tag(b)) {
  case is_basic_int:
  case is_basic_float:
  case is_basic_logical:
  case is_basic_overloaded:
  case is_basic_complex:
  case is_basic_string:
  case is_basic_bit:
    break;
  case is_basic_pointer:
    {
      d = effect_type_depth(basic_pointer(b))+1;
      break;
    }
  case is_basic_derived:
    {
      entity e = basic_derived(b);
      type t = entity_type(e);
      d = type_depth(t);
      break;
    }
  case is_basic_typedef:
    {
      entity e = basic_typedef(b);
      type t = entity_type(e);

      d = type_depth(t);
      break;
    }
  default:
    pips_internal_error("Unexpected basic tag %d\n", basic_tag(b));
  }

  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int effect_type_depth

(

type

t

)

Number of steps to access the lowest leave of type t.

Number of dimensions for an array. One for a struct or an union field, plus its dimension. The difference with type_depth is that it does not stop recursing when encountering a pointer, and that a pointer is considered as having dimension 1. (BC)

Definition at line 3383 of file type.c.

References e, effect_basic_depth(), ENTITY, entity_type, gen_length(), i, MAP, type_depth(), type_enum_p, type_struct, type_struct_p, type_union, type_union_p, type_varargs_p, type_variable, type_variable_p, type_void_p, v, variable_basic, and variable_dimensions.

Referenced by c_actual_argument_to_may_summary_effects(), effect_basic_depth(), generic_effect_generate_all_accessible_paths_effects(), and make_reference_region().

{
  int d = 0;

  if(type_variable_p(t)) {
    variable v = type_variable(t);

    d = gen_length(variable_dimensions(v))+effect_basic_depth(variable_basic(v));
  }
  else if(type_void_p(t))
    d = 0;
  else if(type_varargs_p(t))
    d = 0;
  else if(type_struct_p(t)) {
    list fl = type_struct(t);
    d = 0;
    MAP(ENTITY, e, {
        int i = type_depth(entity_type(e));
        d = d>i?d:i;
      }, fl);
    d++;
  }
  else if(type_union_p(t)) {
    list fl = type_union(t);
    d = 0;
    MAP(ENTITY, e, {
        int i = type_depth(entity_type(e));
        d = d>i?d:i;
      }, fl);
    d++;
  }
  else if(type_enum_p(t))
    d = 0;

  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

list enum_supporting_entities	(	list	sel,
		set	vt,
		entity	e
	)

Parameters:

	sel	el
	vt	t

Definition at line 2629 of file type.c.

References CAR, constant_expression_supporting_entities(), ENDP, ENTITY, entity_initial, entity_type, fprintf(), ifdebug, list_undefined, pips_assert, pips_debug, POP, print_entities(), s, symbolic_expression, type_enum, type_enum_p, v, value_symbolic, and value_symbolic_p.

Referenced by generic_constant_expression_supporting_entities().

{
  type t = entity_type(e);
  list ml = type_enum(t);
  list cm = list_undefined;

  pips_assert("type is of enum kind", type_enum_p(t));

  ifdebug(8) {
    pips_debug(8, "Begin: ");
    print_entities(sel);
    fprintf(stderr, "\n\n");
  }

  for(cm = ml; !ENDP(cm); POP(cm)) {
    entity m = ENTITY(CAR(cm));
    value v = entity_initial(m);
    symbolic s = value_symbolic(v);

    pips_assert("m is an enum member", value_symbolic_p(v));

    sel = constant_expression_supporting_entities(sel, vt, symbolic_expression(s));
  }

  ifdebug(8) {
    pips_debug(8, "End: ");
    print_entities(sel);
    fprintf(stderr, "\n\n");
  }

  return sel;
}

Here is the call graph for this function:

Here is the caller graph for this function:

list enum_supporting_references	(	list	srl,
		entity	e
	)

Parameters:

srl

rl

Definition at line 2939 of file type.c.

References CAR, constant_expression_supporting_references(), ENDP, ENTITY, entity_initial, entity_type, fprintf(), ifdebug, list_undefined, pips_assert, pips_debug, POP, print_references(), s, symbolic_expression, type_enum, type_enum_p, v, value_symbolic, and value_symbolic_p.

Referenced by constant_expression_supporting_references().

{
  type t = entity_type(e);
  list ml = type_enum(t);
  list cm = list_undefined;

  pips_assert("type is of enum kind", type_enum_p(t));

  ifdebug(9) {
    pips_debug(8, "Begin: ");
    print_references(srl);
    fprintf(stderr, "\n");
  }

  for(cm = ml; !ENDP(cm); POP(cm)) {
    entity m = ENTITY(CAR(cm));
    value v = entity_initial(m);
    symbolic s = value_symbolic(v);

    pips_assert("m is an enum member", value_symbolic_p(v));

    srl = constant_expression_supporting_references(srl, symbolic_expression(s));
  }

  ifdebug(9) {
    pips_debug(8, "End: ");
    print_references(srl);
    fprintf(stderr, "\n");
  }

  return srl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

basic expression_basic

(

expression

expr

)

should be int

How to void a memory leak? Where can we find a basic int? A static variable?

Parameters:

expr

xpr

Definition at line 599 of file type.c.

References b, basic_undefined, c, call_function, cast_type, entity_basic(), expression_basic(), expression_syntax, is_basic_int, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, make_basic(), pips_assert, pips_internal_error, range_lower, reference_variable, syntax_call, syntax_cast, syntax_range, syntax_reference, syntax_tag, type_variable, type_variable_p, ultimate_type(), and variable_basic.

Referenced by can_terapixify_expression_p(), change_basic_if_needed(), expression_basic(), prepare_expansion(), suggest_basic_for_expression(), and words_nullary_op_c().

{
    syntax the_syntax=expression_syntax(expr);
    basic b = basic_undefined;

    switch(syntax_tag(the_syntax))
    {
    case is_syntax_reference:
        b = entity_basic(reference_variable(syntax_reference(the_syntax)));
        break;
    case is_syntax_range:
        /* should be int */
        b = expression_basic(range_lower(syntax_range(the_syntax)));
        break;
    case is_syntax_call:
        /*
         * here is a little problem with pips...  every intrinsics are
         * overloaded, what is not exactly what is desired...
         */
        return(entity_basic(call_function(syntax_call(the_syntax))));
        break;
    case is_syntax_cast:
      {
        cast c = syntax_cast(the_syntax);
        type t = cast_type(c);
        type ut = ultimate_type(t);
        b = variable_basic(type_variable(ut));
        pips_assert("Type is \"variable\"", type_variable_p(ut));
      break;
      }
    case is_syntax_sizeofexpression:
      {
        /* How to void a memory leak? Where can we find a basic int? A static variable? */
        b = make_basic(is_basic_int, (void *) 4);
      break;
      }
    default:
        pips_internal_error("unexpected syntax tag\n");
        break;
    }

    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

type expression_to_type

(

expression

exp

)

For an array declared as int a[10][20], the type returned for a[i] is int [20].

Parameters:

exp

is an expression

Returns:

a new allocated type which is the ntype of the expression in which typedef's are replaced by combination of basic types.

does not cover references to functions ...

Could be more elaborated with array types for array expressions

Well, let's assume range are well formed...

current type

current basic

current dimensions

Warning : qualifiers are set to NIL, because I do not see the need for something else for the moment. BC.

Never go there...

Parameters:

exp

xp

Definition at line 1759 of file type.c.

References application_function, basic_pointer, basic_pointer_p, call_to_type(), CAR, cast_type, CDR, copy_basic(), copy_type(), DEFAULT_POINTER_TYPE_SIZE, ENDP, expression_syntax, expression_to_type(), fprintf(), gen_full_copy_list(), ifdebug, is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, is_syntax_va_arg, is_type_variable, make_basic_int(), make_type(), make_type_variable(), make_variable(), NIL, pips_assert, pips_debug, pips_internal_error, POP, print_expression(), range_lower, reference_to_type(), SIZEOFEXPRESSION, sizeofexpression_type, subscript_array, subscript_indices, syntax_application, syntax_call, syntax_cast, syntax_range, syntax_reference, syntax_subscript, syntax_tag, syntax_va_arg, type_tag, type_undefined, type_variable, type_variable_p, type_void_p, variable_basic, variable_dimensions, words_to_string(), and words_type().

Referenced by any_user_call_site_to_transformer(), c_actual_argument_to_may_summary_effects(), c_convex_effects_on_formal_parameter_backward_translation(), c_simple_effects_on_formal_parameter_backward_translation(), c_summary_effect_to_proper_effects(), EvalSizeofexpression(), expression_to_transformer(), expression_to_type(), expression_to_uncasted_type(), generic_proper_effects_of_address_expression(), generic_proper_effects_of_complex_address_expression(), integer_expression_and_precondition_to_integer_interval(), and intrinsic_call_to_type().

{
  /* does not cover references to functions ...*/
  /* Could be more elaborated with array types for array expressions */
  type t = type_undefined;

  syntax s_exp = expression_syntax(exp);

  ifdebug(6){
    pips_debug(6, "begins with expression :");
    print_expression(exp);
    fprintf(stderr, "\n");
  }

  switch(syntax_tag(s_exp))
    {
    case is_syntax_reference:
      {
        pips_debug(6, "reference case \n");
        t = reference_to_type(syntax_reference(s_exp));
        break;
      }
    case is_syntax_call:
      {
        pips_debug(6, "call case \n");
        t = call_to_type(syntax_call(s_exp));
        break;
      }
    case is_syntax_range:
      {
        pips_debug(6, "range case \n");
        /* Well, let's assume range are well formed... */
        t = expression_to_type(range_lower(syntax_range(s_exp)));
        break;
      }
    case is_syntax_cast:
      {
        pips_debug(6, "cast case \n");
        t = copy_type(cast_type(syntax_cast(s_exp)));
        if (!type_void_p(t) && type_tag(t) != is_type_variable)
          pips_internal_error("Bad reference type tag %d\n",type_tag(t));
        break;
      }
    case is_syntax_sizeofexpression:
      {
          /*
        sizeofexpression se = syntax_sizeofexpression(s_exp);
        pips_debug(6, "size of case \n");
        if (sizeofexpression_type_p(se))
          {
            t = copy_type(sizeofexpression_type(se));
            if (type_tag(t) != is_type_variable)
              pips_internal_error("Bad reference type tag %d\n",type_tag(t));
          }
        else
          {
            t = expression_to_type(sizeofexpression_expression(se));
          }*/
          t = make_type_variable(make_variable(make_basic_int(DEFAULT_POINTER_TYPE_SIZE),NIL,NIL));
        break;
      }
    case is_syntax_subscript:
      {
        /* current type */
        type ct = expression_to_type(subscript_array(syntax_subscript(s_exp)));
        /* current basic */
        basic cb = variable_basic(type_variable(ct));
        /* current dimensions */
        list cd = variable_dimensions(type_variable(ct));
        list l_inds = subscript_indices(syntax_subscript(s_exp));

        pips_debug(6, "subscript case \n");

        while (!ENDP(l_inds))
          {
            if(!ENDP(cd))
              {
                POP(cd);                
              }
            else
              {
                pips_assert("reference has too many indices : pointer expected\n", basic_pointer_p(cb));
                ct= basic_pointer(cb);
                if( type_variable_p(ct) ) {
                  cb = variable_basic(type_variable(ct));
                  cd = variable_dimensions(type_variable(ct));
                }
                else {
                  pips_internal_error("unhandled case\n");
                }
              }
            POP(l_inds);        
          }
        
        /* Warning : qualifiers are set to NIL, because I do not see
           the need for something else for the moment. BC.
        */
    t = make_type(is_type_variable,
            make_variable(copy_basic(cb),
                gen_full_copy_list(cd),
                NIL));
        break;
      }
    case is_syntax_application:
      {
        pips_debug(6, "application case \n");
        t = expression_to_type(application_function(syntax_application(s_exp)));
        break;
      }
    case is_syntax_va_arg:
      {
        pips_debug(6, "va_arg case\n");
        list vararg_list = syntax_va_arg(s_exp);
        sizeofexpression soe = SIZEOFEXPRESSION(CAR(CDR(vararg_list)));

        t = copy_type(sizeofexpression_type(soe));
        break;
      }
      
    default:
      pips_internal_error("Bad syntax tag %d\n", syntax_tag(s_exp));
      /* Never go there... */
    }

  pips_debug(6, "returns with %s\n", words_to_string(words_type(t, NIL)));

  return t;
}

Here is the call graph for this function:

Here is the caller graph for this function:

type expression_to_uncasted_type

(

expression

exp

)

If the expression is casted, return its type before cast.

Parameters:

exp

xp

Definition at line 1889 of file type.c.

References cast_expression, expression_syntax, expression_to_type(), expression_to_uncasted_type(), ifdebug, pips_debug, print_expression(), syntax_cast, syntax_cast_p, and type_undefined.

Referenced by expression_to_uncasted_type().

{
  type t = type_undefined;
  syntax s_exp = expression_syntax(exp);

  ifdebug(6){
    pips_debug(6, "begins with expression :");
    print_expression(exp);
    pips_debug(6, "\n");
  }

  if(syntax_cast_p(s_exp)) {
    expression sub_exp = cast_expression(syntax_cast(s_exp));

    t = expression_to_uncasted_type(sub_exp);
  }
  else {
    t = expression_to_type(exp);
  }

  return t;
}

Here is the call graph for this function:

Here is the caller graph for this function:

type expression_to_user_type

(

expression

e

)

Preserve typedef'ed types when possible.

does not cover references to functions ...

Could be more elaborated with array types for array expressions

Definition at line 1913 of file type.c.

References b, FALSE, is_type_variable, make_type(), make_variable(), NIL, some_basic_of_any_expression(), type_undefined, and v.

Referenced by callnodeclfilter(), and check_C_function_type().

{
  /* does not cover references to functions ...*/
  /* Could be more elaborated with array types for array expressions */
  type t = type_undefined;
  basic b = some_basic_of_any_expression(e, FALSE, FALSE);
  variable v = make_variable(b, NIL, NIL);

  t = make_type(is_type_variable, v);

  return t;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dimension FindIthDimension	(	entity	e,
		int	i
	)

Definition at line 663 of file type.c.

References CAR, CDR, DIMENSION, entity_type, NULL, pips_error(), pips_internal_error, type_variable, type_variable_p, and variable_dimensions.

Referenced by array_ranges_to_template_ranges(), complementary_range(), compute_receive_content(), create_init_common_param_for_arrays(), create_parameters_h(), expr_compute_local_index(), generate_one_message(), make_guard_expression(), processor_number(), same_alignment_p(), template_cell_local_mapping(), and template_ranges_to_processors_ranges().

{
    cons * pc;

    if (!type_variable_p(entity_type(e)))
        pips_error("FindIthDimension", "not a variable\n");

    if (i <= 0)
        pips_error("FindIthDimension", "invalid dimension\n");

    pc = variable_dimensions(type_variable(entity_type(e)));

    while (pc != NULL && --i > 0)
        pc = CDR(pc);

    if (pc == NULL)
        pips_internal_error("not enough dimensions\n");

    return(DIMENSION(CAR(pc)));
}

Here is the call graph for this function:

Here is the caller graph for this function:

list fortran_constant_expression_supporting_entities	(	list	sel,
		expression	e
	)

Fortran version.

Parameters:

sel

el

Definition at line 2734 of file type.c.

References FALSE, generic_constant_expression_supporting_entities(), hash_pointer, set_free(), and set_make().

Referenced by fortran_type_supporting_entities().

{
  set vt = set_make(hash_pointer);

  sel = generic_constant_expression_supporting_entities(sel, vt, e, FALSE);

  set_free(vt);

  return sel;
}

Here is the call graph for this function:

Here is the caller graph for this function:

list fortran_type_supporting_entities	(	list	srl,
		type	t
	)

In Fortran, dependencies are due to the dimension expressions.

Parameters:

srl

rl

Definition at line 3106 of file type.c.

References DIMENSION, dimension_lower, dimension_upper, FOREACH, fortran_constant_expression_supporting_entities(), fprintf(), ifdebug, pips_debug, pips_internal_error, print_references(), type_functional_p, type_tag, type_variable, type_variable_p, type_void_p, v, and variable_dimensions.

Referenced by check_fortran_declaration_dependencies().

{
  ifdebug(9) {
    pips_debug(8, "Begin: ");
    print_references(srl);
    fprintf(stderr, "\n");
  }

  if(type_functional_p(t))
    ;
  else if(type_variable_p(t)) {
    /* In Fortran, dependencies are due to the dimension expressions.*/
    variable v = type_variable(t);
    list dims = variable_dimensions(v);

    FOREACH(DIMENSION, d, dims) {
      expression l = dimension_lower(d);
      expression u = dimension_upper(d);
      srl = fortran_constant_expression_supporting_entities(srl, l);
      srl = fortran_constant_expression_supporting_entities(srl, u);
    }
  }
  else if(type_void_p(t))
    ;
  else
    pips_internal_error("Unexpected Fortran type with tag %d\n", type_tag(t));

  ifdebug(9) {
    pips_debug(8, "End: ");
    print_references(srl);
    fprintf(stderr, "\n");
  }

  return srl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool functional_equal_p	(	functional	f1,
		functional	f2
	)

Parameters:

	f1	1
	f2	2

Definition at line 482 of file type.c.

References CAR, ENDP, FALSE, functional_parameters, functional_result, functional_undefined, gen_length(), PARAMETER, parameter_equal_p(), POP, TRUE, and type_equal_p().

Referenced by type_equal_p().

{
    if(f1 == f2)
        return TRUE;
    else if (f1 == functional_undefined && f2 != functional_undefined)
        return FALSE;
    else if (f1 != functional_undefined && f2 == functional_undefined)
        return FALSE;
    else {
        list lp1 = functional_parameters(f1);
        list lp2 = functional_parameters(f2);

        if(gen_length(lp1) != gen_length(lp2))
            return FALSE;

        for( ; !ENDP(lp1); POP(lp1), POP(lp2)) {
            parameter p1 = PARAMETER(CAR(lp1));
            parameter p2 = PARAMETER(CAR(lp2));

            if(!parameter_equal_p(p1, p2))
                return FALSE;
        }

        return type_equal_p(functional_result(f1), functional_result(f2));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

list functional_type_supporting_entities	(	list	sel,
		functional	f
	)

Parameters:

sel

el

Definition at line 2618 of file type.c.

References hash_pointer, recursive_functional_type_supporting_entities(), set_free(), and set_make().

Referenced by compilation_unit_text().

{
  set vt = set_make(hash_pointer);

  sel = recursive_functional_type_supporting_entities(sel, vt, f);

  set_free(vt);

  return sel;
}

Here is the call graph for this function:

Here is the caller graph for this function:

list functional_type_supporting_references	(	list	srl,
		functional	f
	)

Parameters:

srl

rl

Definition at line 2916 of file type.c.

References fprintf(), functional_parameters, functional_result, ifdebug, MAP, PARAMETER, parameter_type, pips_debug, print_references(), and recursive_type_supporting_references().

Referenced by recursive_type_supporting_references().

{
  ifdebug(9) {
    pips_debug(8, "Begin: ");
    print_references(srl);
    fprintf(stderr, "\n");
  }

  MAP(PARAMETER, p,
      srl = recursive_type_supporting_references(srl, parameter_type(p)),
      functional_parameters(f));

  srl = recursive_type_supporting_references(srl, functional_result(f));

  ifdebug(9) {
    pips_debug(8, "End: ");
    print_references(srl);
    fprintf(stderr, "\n");
  }

  return srl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

list functional_type_supporting_types

(

functional

f

)

FI: I'm not sure this function is of any use.

Definition at line 3516 of file type.c.

References hash_pointer, NIL, recursive_functional_type_supporting_types(), set_free(), and set_make().

{
  set vt = set_make(hash_pointer);
  list stl = NIL;

  stl = recursive_functional_type_supporting_types(stl, vt, f);

  set_free(vt);

  return stl;
}

Here is the call graph for this function:

list generic_constant_expression_supporting_entities	(	list	sel,
		set	vt,
		expression	e,
		bool	language_c_p
	)

In C, f cannot be declared directly, we need its enum

In Fortran, symbolic constant are declared directly, but the may depend on other symbolic constants

Could be guarded so as not to be added twice. Guard might be useless with because types are visited only once.

do nothing

Parameters:

	sel	el
	vt	t
	language_c_p	anguage_c_p

Definition at line 2662 of file type.c.

References c, call_arguments, call_function, CONS, ENTITY, entity_initial, enum_supporting_entities(), EXPRESSION, expression_syntax, f, find_enum_of_member(), fprintf(), gen_nconc(), generic_constant_expression_supporting_entities(), generic_symbolic_supporting_entities(), ifdebug, MAP, NIL, pips_debug, print_entities(), reference_indices, reference_variable, s, symbolic_constant_entity_p(), syntax_call, syntax_call_p, syntax_reference, syntax_reference_p, v, and value_symbolic.

Referenced by constant_expression_supporting_entities(), fortran_constant_expression_supporting_entities(), generic_constant_expression_supporting_entities(), and generic_symbolic_supporting_entities().

{
  syntax s = expression_syntax(e);

  ifdebug(8) {
    pips_debug(8, "Begin: ");
    print_entities(sel);
    fprintf(stderr, "\n\n");
  }

  if(syntax_call_p(s)) {
    call c = syntax_call(s);
    entity f = call_function(c);

    if(symbolic_constant_entity_p(f)) {
      if(language_c_p) {
        /* In C, f cannot be declared directly, we need its enum */
        extern entity find_enum_of_member(entity);
        entity e_of_f = find_enum_of_member(f);
        //sel = CONS(ENTITY, e_of_f, sel);
        sel = enum_supporting_entities(sel, vt, e_of_f);
        sel = gen_nconc(sel, CONS(ENTITY, e_of_f, NIL));
      }
      else {
        /* In Fortran, symbolic constant are declared directly, but
           the may depend on other symbolic constants */
        value v = entity_initial(f);
        symbolic s = value_symbolic(v);

        //sel = CONS(ENTITY, f, sel);
        sel = generic_symbolic_supporting_entities(sel, vt, s, language_c_p);
        sel = gen_nconc(sel, CONS(ENTITY, f, NIL));
      }
    }

    MAP(EXPRESSION, se, {
        sel = generic_constant_expression_supporting_entities(sel, vt, se, language_c_p);
    }, call_arguments(c));
  }
  else if(syntax_reference_p(s)) {
    reference r = syntax_reference(s);
    entity v = reference_variable(r);
    list inds = reference_indices(r);
    /* Could be guarded so as not to be added twice. Guard might be
       useless with because types are visited only once. */
    //sel = gen_nconc(sel, CONS(ENTITY, v, NIL));
    MAP(EXPRESSION, se, {
        sel = generic_constant_expression_supporting_entities(sel, vt, se, language_c_p);
      }, inds);
        sel = gen_nconc(sel, CONS(ENTITY, v, NIL));
  }
  else {
    /* do nothing */
    ;
  }

  ifdebug(8) {
    pips_debug(8, "End: ");
    print_entities(sel);
    fprintf(stderr, "\n\n");
  }

  return sel;
}

Here is the call graph for this function:

Here is the caller graph for this function:

list generic_symbolic_supporting_entities	(	list	sel,
		set	vt,
		symbolic	s,
		bool	language_c_p
	)

Parameters:

	sel	el
	vt	t
	language_c_p	anguage_c_p

Definition at line 2745 of file type.c.

References e, generic_constant_expression_supporting_entities(), and symbolic_expression.

Referenced by generic_constant_expression_supporting_entities(), and symbolic_supporting_entities().

{
  expression e = symbolic_expression(s);
  sel = generic_constant_expression_supporting_entities(sel, vt, e, language_c_p);
  return sel;
}

Here is the call graph for this function:

Here is the caller graph for this function:

type intrinsic_call_to_type

(

call

c

)

END_EOLE.

Returns:

the (newly allocated) type of the result given by call to an intrinsic function.

This type must be computed with the basic of the arguments of the intrinsic for overloaded operators. It should be able to accomodate more than two arguments as for generic min and max operators.

the result

I don't know the type since there is no arguments ! Bug encountered with a FMT=* in a PRINT. RK, 21/02/1994 :

leave it overloaded

We should reconstruct a struct type or an array type...

returns the type of the left hand side

The value returned is the value of the last expression in the list.

let us assume that the two last arguments have the same type : basic_maximum does not preserve types enough (see Effects/lhs01.c, expression *(i>2?&i:&j) ). BC.

re-use an existing function. we do not take into account variable dimensions here. It may not be correct. but it's not worse than the previously existing version of expression_to_type

Definition at line 1484 of file type.c.

References b, basic_maximum(), basic_overloaded_p, basic_pointer, basic_pointer_p, basic_string_p, call_arguments, call_function, CAR, cons::cdr, CDR, copy_type(), DEFAULT_CHARACTER_TYPE_SIZE, e, ENDP, ENTITY_ADDRESS_OF_P, ENTITY_ASSIGN_P, ENTITY_BRACE_INTRINSIC_P, ENTITY_COMMA_P, ENTITY_CONDITIONAL_P, ENTITY_DEREFERENCING_P, ENTITY_FIELD_P, ENTITY_POINT_TO_P, entity_type, EXPRESSION, expression_to_type(), f, free_type(), functional_result, gen_full_free_list(), gen_last(), gen_length(), ifdebug, is_basic_pointer, is_type_variable, make_basic(), make_basic_int(), make_basic_overloaded(), make_type(), make_type_variable(), make_variable(), MAP, module_local_name(), NIL, pips_assert, pips_debug, pips_internal_error, print_expression(), rt, type_consistent_p(), type_functional, type_undefined, type_variable, type_variable_p, ultimate_type(), variable_basic, variable_dimensions, words_to_string(), and words_type().

Referenced by call_to_type().

{

  entity f = call_function(c);
  list args = call_arguments(c);

  type rt = functional_result(type_functional(entity_type(f)));
  basic rb = variable_basic(type_variable(rt));

  type t = type_undefined; /* the result */

  pips_debug(7, "Intrinsic call to intrinsic \"%s\" with a priori result type \"%s\"\n",
             module_local_name(f),
             words_to_string(words_type(rt, NIL)));

  if(basic_overloaded_p(rb))
    {

      if (ENDP(args))
        {
          /* I don't know the type since there is no arguments !
             Bug encountered with a FMT=* in a PRINT.
             RK, 21/02/1994 : */
          /* leave it overloaded */
          t = copy_type(rt);
        }
      else if(ENTITY_ADDRESS_OF_P(f))
        {
          expression e = EXPRESSION(CAR(args));
          t = expression_to_type(e);
          t = make_type(is_type_variable,
                        make_variable( make_basic(is_basic_pointer,t),
                                       NIL, NIL ));

        }
      else if(ENTITY_DEREFERENCING_P(f))
        {
          expression e = EXPRESSION(CAR(args));
          type ct = expression_to_type(e);

          if (type_variable_p(ct))
            {
              variable cv = type_variable(ct);
              basic cb = variable_basic(cv);
              list cd = variable_dimensions(cv);

              if(basic_pointer_p(cb))
                {
                  t = copy_type(ultimate_type(basic_pointer(cb)));
                  pips_assert("The pointed type is consistent",
                              type_consistent_p(t));
                  free_type(ct);
                }
              else if(basic_string_p(cb))
                {
                  t = make_type_variable(make_variable(make_basic_int(DEFAULT_CHARACTER_TYPE_SIZE), NIL, NIL));
                }
              else
                {
                  pips_assert("Dereferencing of a non-pointer expression : it must be an array\n", !ENDP(cd));

                  variable_dimensions(cv) = CDR(cd);
                  cd->cdr = NIL;
                  gen_full_free_list(cd);
                  t = ct;
                }
            }
          else
            {
              pips_internal_error("dereferencing of a non-variable : not handled yet\n");
            }
        }
      else if(ENTITY_POINT_TO_P(f) || ENTITY_FIELD_P(f))
        {
          expression e1 = EXPRESSION(CAR(args));
          expression e2 = EXPRESSION(CAR(CDR(args)));

          pips_assert("Two arguments for POINT_TO or FIELD \n",
                      gen_length(args)==2);

          ifdebug(8)
            {
              pips_debug(8, "Point to case, e1 = ");
              print_expression(e1);
              pips_debug(8, " and e2 = ");
              print_expression(e2);
              pips_debug(8, "\n");
            }
          t = expression_to_type(e2);
        }
      else if(ENTITY_BRACE_INTRINSIC_P(f))
        {
          /* We should reconstruct a struct type or an array type... */
          t = make_type(is_type_variable, make_variable(make_basic_overloaded(),
                                                       NIL,NIL));
        }
      else if(ENTITY_ASSIGN_P(f))
        {
          /* returns the type of the left hand side */
          t = expression_to_type(EXPRESSION(CAR(args)));
        }
      else if(ENTITY_COMMA_P(f))
        {
          /* The value returned is the value of the last expression in the list. */

          t = expression_to_type(EXPRESSION(CAR(gen_last(args))));
        }
      else if( ENTITY_CONDITIONAL_P(f))
        {
          /* let us assume that the two last arguments have the same
           type : basic_maximum does not preserve types enough
          (see Effects/lhs01.c, expression *(i>2?&i:&j) ). BC.
          */
          t = expression_to_type(EXPRESSION(CAR(CDR(args))));
        }
      else
        {

          type ct = expression_to_type(EXPRESSION(CAR(args)));

          MAP(EXPRESSION, arg, {
              type nt = expression_to_type(arg);
              basic nb = variable_basic(type_variable(nt));
              basic cb = variable_basic(type_variable(ct));

              /* re-use an existing function. we do not take into
                 account variable dimensions here. It may not be correct.
                 but it's not worse than the previously existing version
                 of expression_to_type
              */
              basic b = basic_maximum(cb, nb);

              free_type(ct);
              free_type(nt);
              ct = make_type(is_type_variable, make_variable(b, NIL, NIL));

            }, CDR(args));
          t = ct;
        }
    }
  else {
    t = copy_type(rt);
  }

  pips_debug(7, "Intrinsic call to intrinsic \"%s\" with a posteriori result type \"%s\"\n",
             module_local_name(f),
             words_to_string(words_type(t, NIL)));

  return t;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool is_inferior_basic	(	basic	b1,
		basic	b2
	)

bool is_inferior_basic(basic1, basic2) return TRUE if basic1 is less complex than basic2 ex: int is less complex than float*4, float*4 is less complex than float*8, .

..

• overloaded is inferior to any basic.
• logical is inferior to any other but overloaded.
• string is inferior to any other but overloaded and logical. Used to decide that the sum of an int and a float is a floating-point addition (for ex.)

Parameters:

	b1	1
	b2	2

Definition at line 1953 of file type.c.

References basic_complex, basic_complex_p, basic_float, basic_float_p, basic_int, basic_int_p, basic_logical_p, basic_overloaded_p, basic_string_p, basic_undefined, FALSE, pips_error(), and TRUE.

Referenced by arguments_to_complexity(), basic_union_arguments(), indices_to_complexity(), intrinsic_cost(), and typing_power_operator().

{
    if ( b1 == basic_undefined )
        pips_error("is_inferior_basic", "first  basic_undefined\n");
    else if ( b2 == basic_undefined )
        pips_error("is_inferior_basic", "second basic_undefined\n");

    if (basic_overloaded_p(b1))
        return (TRUE);
    else if (basic_overloaded_p(b2))
        return (FALSE);
    else if (basic_logical_p(b1))
        return (TRUE);
    else if (basic_logical_p(b2))
        return (FALSE);
    else if (basic_string_p(b1))
        return (TRUE);
    else if (basic_string_p(b2))
        return (FALSE);
    else if (basic_int_p(b1)) {
        if (basic_int_p(b2))
            return (basic_int(b1) <= basic_int(b2));
        else
            return (TRUE);
    }
    else if (basic_float_p(b1)) {
        if (basic_int_p(b2))
            return (FALSE);
        else if (basic_float_p(b2))
            return (basic_float(b1) <= basic_float(b2));
        else
            return (TRUE);
    }
    else if (basic_complex_p(b1)) {
        if (basic_int_p(b2) || basic_float_p(b2))
            return (FALSE);
        else if (basic_complex_p(b2))
            return (basic_complex(b1) <= basic_complex(b2));
        else
            return (TRUE);
    }
    else
        pips_error("is_inferior_basic", "Case never occurs.\n");
    return (TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

list ldimensions_dup

(

list

l

)

Definition at line 649 of file type.c.

References CAR, CONS, DIMENSION, dimension_dup(), gen_nreverse(), MAPL, and NIL.

Referenced by type_variable_dup().

{
    list result = NIL ;

    MAPL(cd,
     {
         result = CONS(DIMENSION, dimension_dup(DIMENSION(CAR(cd))),
                       result);
     },
         l);

    return(gen_nreverse(result));
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool long_type_p

(

type

t

)

Definition at line 2086 of file type.c.

References b, basic_int, basic_int_p, DEFAULT_LONG_INTEGER_TYPE_SIZE, FALSE, TRUE, type_variable, type_variable_p, and variable_basic.

Referenced by make_standard_long_integer_type().

{
  if (type_variable_p(t))
    {
      basic b = variable_basic(type_variable(t));
      if (basic_int_p(b))
        if (basic_int(b) == DEFAULT_LONG_INTEGER_TYPE_SIZE)
          return TRUE;
    }
  return FALSE;
}

Here is the caller graph for this function:

type make_char_array_type

(

int

n

)

Two options: a string of n characters or an array of n char, i.e. int.

Definition at line 3670 of file type.c.

References b, c, make_basic_string(), make_constant_int(), make_type_variable(), make_value_constant(), make_variable(), and NIL.

Referenced by init_c_implicit_variables().

{
  /* Two options: a string of n characters or an array of n char,
     i.e. int. */
  constant c = make_constant_int(n);
  value val = make_value_constant(c);
  basic b = make_basic_string(val);
  variable var = make_variable(b, NIL, NIL);
  type t = make_type_variable(var);

  return t;
}

Here is the call graph for this function:

Here is the caller graph for this function:

type make_scalar_complex_type

(

_int

n

)

Definition at line 334 of file type.c.

References is_basic_complex, is_type_variable, make_basic(), make_type(), make_variable(), NIL, and UUINT.

{
    type t = make_type(is_type_variable,
                       make_variable(make_basic(is_basic_complex, UUINT(n)), NIL,NIL));
    return t;
}

Here is the call graph for this function:

type make_scalar_integer_type

(

_int

n

)

Definition at line 327 of file type.c.

References is_basic_int, is_type_variable, make_basic(), make_type(), make_variable(), NIL, and UUINT.

Referenced by CreateAbstractStateVariable(), make_beta_entity(), make_dummy_io_ptr(), make_phi_entity(), make_psi_entity(), make_rho_entity(), UpdateEntity(), and UpdateType().

{
    type t = make_type(is_type_variable,
                       make_variable(make_basic(is_basic_int, UUINT(n)), NIL,NIL));
    return t;
}

Here is the call graph for this function:

Here is the caller graph for this function:

type make_standard_integer_type	(	type	t,
		int	size
	)

If it is int i:5, keep the bit basic type

Parameters:

size

ize

Definition at line 2204 of file type.c.

References b, basic_int, bit_type_p(), i, make_basic_int(), make_type_variable(), make_variable(), NIL, pips_debug, signed_type_p(), type_undefined, type_variable, unsigned_type_p(), user_warning(), v, and variable_basic.

Referenced by c_parse(), and yyparse().

{
  if (t == type_undefined)
    {
      variable v = make_variable(make_basic_int(size),NIL,NIL);
      return make_type_variable(v);
    }
  else
    {
      if (signed_type_p(t) || unsigned_type_p(t))
        {
          basic b = variable_basic(type_variable(t));
          int i = basic_int(b);
          variable v = make_variable(make_basic_int(10*(i/10)+size),NIL,NIL);
          pips_debug(8,"Old basic size: %d, new size : %d\n",i,10*(i/10)+size);
          return make_type_variable(v);
        }
      else
        {
          if (bit_type_p(t))
            /* If it is int i:5, keep the bit basic type*/
            return t;
          else
            user_warning("Parse error", "Standard integer types\n");
          return type_undefined;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

type make_standard_long_integer_type

(

type

t

)

long

long long

If it is long int i:5, keep the bit basic type

Definition at line 2233 of file type.c.

References b, basic_int, bit_type_p(), DEFAULT_INTEGER_TYPE_SIZE, DEFAULT_LONG_INTEGER_TYPE_SIZE, DEFAULT_LONG_LONG_INTEGER_TYPE_SIZE, i, long_type_p(), make_basic_int(), make_type_variable(), make_variable(), NIL, pips_debug, signed_type_p(), type_undefined, type_variable, unsigned_type_p(), user_warning(), v, and variable_basic.

Referenced by c_parse(), and yyparse().

{
  if (t == type_undefined)
    {
      variable v = make_variable(make_basic_int(DEFAULT_LONG_INTEGER_TYPE_SIZE),NIL,NIL);
      return make_type_variable(v);
    }
  else
    {
      if (signed_type_p(t) || unsigned_type_p(t) || long_type_p(t))
        {
          basic b = variable_basic(type_variable(t));
          int i = basic_int(b);
          variable v;
          if (i%10 == DEFAULT_INTEGER_TYPE_SIZE)
            {
              /* long */
              v = make_variable(make_basic_int(10*(i/10)+DEFAULT_LONG_INTEGER_TYPE_SIZE),NIL,NIL);
              pips_debug(8,"Old basic size: %d, new size : %d\n",i,10*(i/10)+DEFAULT_LONG_INTEGER_TYPE_SIZE);
            }
          else
            {
              /* long long */
              v = make_variable(make_basic_int(10*(i/10)+DEFAULT_LONG_LONG_INTEGER_TYPE_SIZE),NIL,NIL);
              pips_debug(8,"Old basic size: %d, new size : %d\n",i,10*(i/10)+DEFAULT_LONG_LONG_INTEGER_TYPE_SIZE);
            }
          return make_type_variable(v);
        }
      else
        {
          if (bit_type_p(t))
            /* If it is long int i:5, keep the bit basic type*/
            return t;
          else
            user_warning("Parse error", "Standard long integer types\n");
          return type_undefined;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

parameter MakeAnyScalarParameter	(	tag	t,
		_int	size
	)

For Fortran.

Parameters:

size

ize

Definition at line 173 of file type.c.

References make_basic(), make_dummy_unknown(), make_mode_reference(), make_parameter(), MakeTypeArray(), NIL, and UUINT.

Referenced by MakeComplexParameter(), MakeDoublecomplexParameter(), MakeDoubleprecisionParameter(), MakeIntegerParameter(), MakeLogicalParameter(), MakeOverloadedParameter(), and MakeRealParameter().

{
  return make_parameter(MakeTypeArray(make_basic(t, UUINT(size)), NIL),
                        make_mode_reference(),
                        make_dummy_unknown());
}

Here is the call graph for this function:

Here is the caller graph for this function:

type MakeAnyScalarResult	(	tag	t,
		_int	size
	)

Parameters:

size

ize

Definition at line 228 of file type.c.

References make_basic(), MakeTypeArray(), NIL, and UUINT.

Referenced by MakeComplexResult(), MakeDoublecomplexResult(), MakeDoubleprecisionResult(), MakeIntegerResult(), MakeLogicalResult(), MakeOverloadedResult(), and MakeRealResult().

{
    return MakeTypeArray(make_basic(t, UUINT(size)), NIL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

basic MakeBasic

(

int

the_tag

)

END_EOLE.

Parameters:

the_tag

he_tag

Definition at line 87 of file type.c.

References basic_undefined, is_basic_complex, is_basic_float, is_basic_int, is_basic_logical, is_basic_overloaded, is_basic_string, make_basic(), pips_error(), string_undefined, UU, and UUINT.

Referenced by add_one_bound_argument(), complexity_sigma(), create_integer_parameter_for_new_module(), create_new_integer_scalar_common_variable(), create_private_integer_variable_for_new_module(), DeclarePointer(), extract_lattice(), find_or_create_scalar_entity(), find_or_create_typed_entity(), generate_copy_loop_nest(), generate_optimized_code_for_loop_nest(), loop_flt(), loop_to_complexity(), remove_if_statement_according_to_write_effects(), simplify_sc_to_complexity(), and st_compute_ith_local_index().

{
    switch(the_tag)
    {
    case is_basic_int:
        return(make_basic(is_basic_int, UUINT(4)));
        break;
    case is_basic_float:
        return(make_basic(is_basic_float, UUINT(4)));
        break;
    case is_basic_logical:
        return(make_basic(is_basic_logical, UUINT(4)));
        break;
    case is_basic_complex:
        return(make_basic(is_basic_complex, UUINT(8)));
        break;
    case is_basic_overloaded:
        return(make_basic(is_basic_overloaded, UU));
        break;
    case is_basic_string:
        return(make_basic(is_basic_string, string_undefined));
        break;
    default:
        pips_error("MakeBasic", "unexpected basic tag: %d\n",
                   the_tag);
        break;
    }

    return(basic_undefined);
}

Here is the call graph for this function:

Here is the caller graph for this function:

basic MakeBasicOverloaded

(

void

)

generation of types

type.c

Definition at line 40 of file type.c.

References is_basic_overloaded, make_basic(), and NIL.

{
    return(make_basic(is_basic_overloaded, NIL));
}

Here is the call graph for this function:

parameter MakeCharacterParameter

(

void

)

Definition at line 161 of file type.c.

References DEFAULT_CHARACTER_TYPE_SIZE, is_basic_string, is_constant_int, is_mode_reference, is_value_constant, make_basic(), make_constant(), make_dummy_unknown(), make_mode(), make_parameter(), make_value(), MakeTypeArray(), NIL, UU, and UUINT.

Referenced by assign_substring_type(), character_to_character_type(), character_to_integer_type(), character_to_logical_type(), logical_to_logical_type(), and substring_type().

{
  return make_parameter(MakeTypeArray(make_basic(is_basic_string,
         make_value(is_value_constant,
                    make_constant(is_constant_int,
                                  UUINT(DEFAULT_CHARACTER_TYPE_SIZE)))),
                                      NIL),
                        make_mode(is_mode_reference, UU),
                        make_dummy_unknown());
}

Here is the call graph for this function:

Here is the caller graph for this function:

type MakeCharacterResult

(

void

)

Definition at line 219 of file type.c.

References DEFAULT_CHARACTER_TYPE_SIZE, is_basic_string, is_constant_int, is_value_constant, make_basic(), make_constant(), make_value(), MakeTypeArray(), NIL, and UUINT.

Referenced by assign_substring_type(), char_pointer_to_double_type(), character_to_character_type(), and substring_type().

{
  return MakeTypeArray(make_basic(is_basic_string,
         make_value(is_value_constant,
                    make_constant(is_constant_int,
                                  UUINT(DEFAULT_CHARACTER_TYPE_SIZE)))),
                       NIL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

parameter MakeComplexParameter

(

void

)

Definition at line 151 of file type.c.

References DEFAULT_COMPLEX_TYPE_SIZE, is_basic_complex, and MakeAnyScalarParameter().

Referenced by complex_to_complex_type(), and complex_to_real_type().

{
  return MakeAnyScalarParameter(is_basic_complex, DEFAULT_COMPLEX_TYPE_SIZE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

type MakeComplexResult

(

void

)

Definition at line 208 of file type.c.

References DEFAULT_COMPLEX_TYPE_SIZE, is_basic_complex, and MakeAnyScalarResult().

Referenced by complex_to_complex_type(), and overloaded_to_complex_type().

{
    return MakeAnyScalarResult(is_basic_complex, DEFAULT_COMPLEX_TYPE_SIZE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

parameter MakeDoublecomplexParameter

(

void

)

Definition at line 156 of file type.c.

References DEFAULT_DOUBLECOMPLEX_TYPE_SIZE, is_basic_complex, and MakeAnyScalarParameter().

Referenced by doublecomplex_to_double_type(), and doublecomplex_to_doublecomplex_type().

{
  return MakeAnyScalarParameter(is_basic_complex, DEFAULT_DOUBLECOMPLEX_TYPE_SIZE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

type MakeDoublecomplexResult

(

void

)

Definition at line 213 of file type.c.

References DEFAULT_DOUBLECOMPLEX_TYPE_SIZE, is_basic_complex, and MakeAnyScalarResult().

Referenced by doublecomplex_to_doublecomplex_type(), and overloaded_to_doublecomplex_type().

{
    return MakeAnyScalarResult(is_basic_complex,
                               DEFAULT_DOUBLECOMPLEX_TYPE_SIZE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

parameter MakeDoubleprecisionParameter

(

void

)

Definition at line 141 of file type.c.

References DEFAULT_DOUBLEPRECISION_TYPE_SIZE, is_basic_float, and MakeAnyScalarParameter().

Referenced by double_to_double_type(), and double_to_integer_type().

{
  return MakeAnyScalarParameter(is_basic_float, DEFAULT_DOUBLEPRECISION_TYPE_SIZE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

type MakeDoubleprecisionResult

(

void

)

Definition at line 198 of file type.c.

References DEFAULT_DOUBLEPRECISION_TYPE_SIZE, is_basic_float, and MakeAnyScalarResult().

Referenced by char_pointer_to_double_type(), double_to_double_type(), doublecomplex_to_double_type(), overloaded_to_double_type(), and real_to_double_type().

{
    return MakeAnyScalarResult(is_basic_float, DEFAULT_DOUBLEPRECISION_TYPE_SIZE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

parameter MakeIntegerParameter

(

void

)

Definition at line 131 of file type.c.

References DEFAULT_REAL_TYPE_SIZE, is_basic_int, and MakeAnyScalarParameter().

Referenced by assign_substring_type(), integer_to_integer_type(), integer_to_logical_type(), integer_to_overloaded_type(), integer_to_real_type(), integer_to_void_type(), and substring_type().

{
  return MakeAnyScalarParameter(is_basic_int, DEFAULT_REAL_TYPE_SIZE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

type MakeIntegerResult

(

void

)

Definition at line 188 of file type.c.

References DEFAULT_INTEGER_TYPE_SIZE, is_basic_int, and MakeAnyScalarResult().

Referenced by character_to_integer_type(), double_to_integer_type(), integer_to_integer_type(), MakeEntityFunction(), MakeFunctionExpression(), MakeRunTimeSupportFunction(), overloaded_to_integer_type(), real_to_integer_type(), void_to_integer_type(), void_to_void_to_int_pointer_type(), and yyparse().

{
    return MakeAnyScalarResult(is_basic_int, DEFAULT_INTEGER_TYPE_SIZE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

parameter MakeLogicalParameter

(

void

)

Definition at line 146 of file type.c.

References DEFAULT_LOGICAL_TYPE_SIZE, is_basic_logical, and MakeAnyScalarParameter().

{
  return MakeAnyScalarParameter(is_basic_logical, DEFAULT_LOGICAL_TYPE_SIZE);
}

Here is the call graph for this function:

type MakeLogicalResult

(

void

)

Definition at line 203 of file type.c.

References DEFAULT_LOGICAL_TYPE_SIZE, is_basic_logical, and MakeAnyScalarResult().

Referenced by character_to_logical_type(), integer_to_logical_type(), logical_to_logical_type(), and overloaded_to_logical_type().

{
    return MakeAnyScalarResult(is_basic_logical, DEFAULT_LOGICAL_TYPE_SIZE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mode MakeModeReference

(

void

)

Definition at line 45 of file type.c.

References is_mode_reference, make_mode(), and NIL.

Referenced by outlining_make_argument(), step_add_formal_copy(), update_functional_type_with_actual_arguments(), and UpdateFunctionalType().

{
    return(make_mode(is_mode_reference, NIL));
}

Here is the call graph for this function:

Here is the caller graph for this function:

mode MakeModeValue

(

void

)

Definition at line 50 of file type.c.

References is_mode_value, make_mode(), and NIL.

{
    return(make_mode(is_mode_value, NIL));
}

Here is the call graph for this function:

parameter MakeOverloadedParameter

(

void

)

Definition at line