array_to_pointer.c File Reference

#include <ctype.h>
#include "genC.h"
#include "ri-util.h"
#include "effects.h"
#include "pipsdbm.h"
#include "workspace-util.h"
#include "pipsmake.h"
#include "properties.h"
#include "callgraph.h"
#include "misc.h"
#include "control.h"
#include "expressions.h"
#include "preprocessor.h"
#include "accel-util.h"

Include dependency graph for array_to_pointer.c:

Go to the source code of this file.

Data Structures
struct	param_t

Functions
bool	do_convert_this_array_to_pointer_p (entity e)
	array_to_pointer.c More...
size_t	type_dereferencement_depth (type t)
static void	do_linearize_array_reference (reference r)
static void	do_linearize_array_subscript (_UNUSED_ subscript s)
static bool	type_void_or_void_pointer_p (type t)
static bool	do_linearize_type (type *t, bool *rr)
static void	do_array_to_pointer_type_aux (type *t)
static bool	do_array_to_pointer_type (type *t)
	returns true if a dereferencment has been supressed More...
static void	do_linearize_array_manage_callers (entity m, set linearized_param, param_t *param)
static void	do_linearize_array_cast (cast c)
static void	do_linearize_array_walker (void *obj)
static void	do_linearize_expression_is_pointer (expression exp, hash_table ht)
static void	do_linearize_pointer_is_expression (expression exp, hash_table ht)
static hash_table	init_expression_is_pointer (void *obj)
static void	do_linearize_patch_expressions (void *obj, hash_table ht)
static void	do_linearize_array_init (value v)
static void	do_linearize_remove_dereferencment_walker (expression exp, entity e)
static void	do_linearize_remove_dereferencment (statement s, entity e)
static void	do_linearize_prepatch_type (type t)
static void	do_linearize_prepatch_subscript (subscript s)
	subscripts of the form (*a)[n] are transformed into a[n] it is coherent with other transformations scattered here and there in this file :p More...
static void	do_linearize_prepatch_subscripts (entity m, statement s)
	transform some subscripts for generic handling later More...
static void	do_linearize_prepatch (entity m, _UNUSED_ statement s)
static void	do_linearize_array (entity m, statement s, param_t *param)
static void	do_array_to_pointer_walk_expression (expression exp)
static bool	do_array_to_pointer_patch_call_expression (expression exp)
	fix some strange constructs introduced by previous processing More...
static void	do_array_to_pointer_patch_call_expr_rwt (expression e)
static void	do_array_to_pointer_walk_call_and_patch (call c)
	special ad-hoc handler for pointer to arrays More...
static void	do_array_to_pointer_walk_cast (cast ct)
static void	do_array_to_pointer_walker (void *obj)
	converts arrays to pointer More...
static list	initialization_list_to_statements (entity e)
	create a list of statements from entity declarations More...
static void	insert_statements_after_declarations (statement st, list stats)
	initialization statements are added right after declarations More...
static void	do_array_to_pointer (entity m, statement s, _UNUSED_ param_t *p)
	transform each array type in module m with statement s More...
bool	linearize_array_generic (const char *module_name)
	linearize accesses to an array, and use pointers if asked to More...
bool	linearize_array (const char *module_name)
	linearize accesses to an array, and use pointers if asked to More...
bool	linearize_array_fortran (const char *module_name)

Function Documentation

do_array_to_pointer()

static void do_array_to_pointer ( entity  m, statement  s, _UNUSED_ param_t *  p  )

static

transform each array type in module m with statement s

step1: the statements

step2: the declarations

step3: insert the initialization statement just after declarations

pips bonus step: the consistency

Definition at line 892 of file array_to_pointer.c.

                                                                            {
  /* step1: the statements */
  do_array_to_pointer_walker(s);
  FOREACH(ENTITY,e,entity_declarations(m)) {
    if(entity_variable_p(e) && do_convert_this_array_to_pointer_p(e) ) {
      do_array_to_pointer_walker(entity_initial(e));
    }
  }
 
  /* step2: the declarations */
  list inits = NIL;
  FOREACH(ENTITY,e,entity_declarations(m))
    if(entity_variable_p(e) && do_convert_this_array_to_pointer_p(e)) {
      // must do this before the type conversion
      inits=gen_append(inits,initialization_list_to_statements(e));
      if(do_array_to_pointer_type(&entity_type(e)))
        do_linearize_remove_dereferencment(s,e);
    }
  /* step3: insert the initialization statement just after declarations */
  insert_statements_after_declarations(get_current_module_statement(),inits);
 
  /* pips bonus step: the consistency */
  FOREACH(PARAMETER,p,module_functional_parameters(m)) {
    dummy d = parameter_dummy(p);
    if(dummy_identifier_p(d))
    {
      entity di = dummy_identifier(d);
      if( do_convert_this_array_to_pointer_p(di) )  {
        do_array_to_pointer_type(&entity_type(di));
        do_array_to_pointer_type(&parameter_type(p));
      }
    }
    pips_assert("everything went well",parameter_consistent_p(p));
  }
 
}

References do_array_to_pointer_type(), do_array_to_pointer_walker(), do_convert_this_array_to_pointer_p(), do_linearize_remove_dereferencment(), dummy_identifier, dummy_identifier_p, ENTITY, entity_declarations, entity_initial, entity_type, entity_variable_p, FOREACH, gen_append(), get_current_module_statement(), initialization_list_to_statements(), insert_statements_after_declarations(), module_functional_parameters, NIL, PARAMETER, parameter_consistent_p(), parameter_dummy, parameter_type, and pips_assert.

Referenced by linearize_array_generic().

Here is the call graph for this function:

Here is the caller graph for this function:

do_array_to_pointer_patch_call_expr_rwt()

static void do_array_to_pointer_patch_call_expr_rwt ( expression  e )

static

Definition at line 733 of file array_to_pointer.c.

{
  (void) do_array_to_pointer_patch_call_expression(e);
}

References do_array_to_pointer_patch_call_expression().

Referenced by do_array_to_pointer_walker().

Here is the call graph for this function:

Here is the caller graph for this function:

do_array_to_pointer_patch_call_expression()

static bool do_array_to_pointer_patch_call_expression ( expression  exp )

static

fix some strange constructs introduced by previous processing

Definition at line 711 of file array_to_pointer.c.

                                                                      {
  if(expression_call_p(exp)) {
    call c = expression_call(exp);
    entity op = call_function(c);
    if(ENTITY_ADDRESS_OF_P(op)) {
      expression arg = EXPRESSION(CAR(call_arguments(c)));
      if(expression_call_p(arg)) {
        call c2 = expression_call(arg);
        if(ENTITY_DEREFERENCING_P(call_function(c2))) {
          syntax syn = expression_syntax( EXPRESSION(CAR(call_arguments(c2))) );
          expression_syntax( EXPRESSION(CAR(call_arguments(c2))) )=syntax_undefined;
          update_expression_syntax(exp,syn);
        }
        else if( ENTITY_ADDRESS_OF_P(call_function(c2))) {
          update_expression_syntax(arg,copy_syntax(expression_syntax(EXPRESSION(CAR(call_arguments(c2))))));
        }
      }
    }
  }
  return true;
}

References call_arguments, call_function, CAR, copy_syntax(), ENTITY_ADDRESS_OF_P, ENTITY_DEREFERENCING_P, exp, EXPRESSION, expression_call(), expression_call_p(), expression_syntax, syntax_undefined, and update_expression_syntax().

Referenced by do_array_to_pointer_patch_call_expr_rwt(), and do_array_to_pointer_walker().

Here is the call graph for this function:

Here is the caller graph for this function:

do_array_to_pointer_type()

static bool do_array_to_pointer_type ( type *  t )

static

returns true if a dereferencment has been supressed

Definition at line 268 of file array_to_pointer.c.

                                              {
  bool remove = false;
  if(!type_void_or_void_pointer_p(*t)) {
    if(pointer_type_p(*t)){
      variable vt = type_variable(*t);
      basic bt = variable_basic(vt);
      type t2 = basic_pointer(bt);
      if(array_type_p(t2)) {
        basic_pointer(bt) = type_undefined;
        free_type(*t);
        *t=t2;
        remove=true;
      }
    }
    do_array_to_pointer_type_aux(t);
  }
  return remove;
}

References array_type_p(), basic_pointer, do_array_to_pointer_type_aux(), free_type(), pointer_type_p(), type_undefined, type_variable, type_void_or_void_pointer_p(), and variable_basic.

Referenced by do_array_to_pointer(), do_array_to_pointer_walk_cast(), and do_linearize_array().

Here is the call graph for this function:

Here is the caller graph for this function:

do_array_to_pointer_type_aux()

static void do_array_to_pointer_type_aux ( type *  t )

static

Definition at line 251 of file array_to_pointer.c.

                                                  {
  variable v = type_variable(*t);
  if(basic_pointer_p(variable_basic(v)))
    do_array_to_pointer_type_aux(&basic_pointer(variable_basic(v)));
  list dimensions = variable_dimensions(v);
  variable_dimensions(v)=NIL;
  FOREACH(DIMENSION,d,dimensions) {
    *t=make_type_variable(
        make_variable(
          make_basic_pointer(*t),
          NIL,NIL
          )
        );
  }
}

References basic_pointer, basic_pointer_p, DIMENSION, FOREACH, make_basic_pointer(), make_type_variable(), make_variable(), NIL, type_variable, variable_basic, and variable_dimensions.

Referenced by do_array_to_pointer_type().

Here is the call graph for this function:

Here is the caller graph for this function:

do_array_to_pointer_walk_call_and_patch()

static void do_array_to_pointer_walk_call_and_patch ( call  c )

static

special ad-hoc handler for pointer to arrays

pointer to an array ...

Definition at line 739 of file array_to_pointer.c.

                                                            {
  entity op = call_function(c);
  if(ENTITY_DEREFERENCING_P(op)) {
    expression exp = EXPRESSION(CAR(call_arguments(c)));
    if(expression_reference_p(exp)) {
      reference r = expression_reference(exp);
      entity e = reference_variable(r);
      /* pointer to an array ... */
      if(entity_pointer_p(e)) {
        type pointed_type = basic_pointer(variable_basic(type_variable(ultimate_type(entity_type(e)))));
        if(array_type_p(pointed_type)) {
          update_expression_syntax(exp,
              make_syntax_call(
                make_call(
                  entity_intrinsic(ADDRESS_OF_OPERATOR_NAME),
                  CONS(EXPRESSION,copy_expression(exp),NIL)
                  )
                )
              );
        }
      }
    }
  }
}

References ADDRESS_OF_OPERATOR_NAME, array_type_p(), basic_pointer, call_arguments, call_function, CAR, CONS, copy_expression(), ENTITY_DEREFERENCING_P, entity_intrinsic(), entity_pointer_p(), entity_type, exp, EXPRESSION, expression_reference(), expression_reference_p(), make_call(), make_syntax_call(), NIL, pointed_type(), reference_variable, type_variable, ultimate_type(), update_expression_syntax(), and variable_basic.

Referenced by do_array_to_pointer_walker().

Here is the call graph for this function:

Here is the caller graph for this function:

do_array_to_pointer_walk_cast()

static void do_array_to_pointer_walk_cast ( cast  ct )

static

Definition at line 764 of file array_to_pointer.c.

                                                  {
  do_array_to_pointer_type(&cast_type(ct));
}

References cast_type, and do_array_to_pointer_type().

Referenced by do_array_to_pointer_walker().

Here is the call graph for this function:

Here is the caller graph for this function:

do_array_to_pointer_walk_expression()

static void do_array_to_pointer_walk_expression ( expression  exp )

static

Definition at line 677 of file array_to_pointer.c.

                                                                {
  if(expression_reference_p(exp)) {
    reference r = expression_reference(exp);
    entity e =reference_variable(r);
    if(do_convert_this_array_to_pointer_p(e)) {
      list indices = reference_indices(r);
      if(!ENDP(indices)) {
        expression new_expression = expression_undefined;
        reference_indices(r)=NIL;
        indices=gen_nreverse(indices);
        FOREACH(EXPRESSION,index,indices) {
          new_expression=MakeUnaryCall(
              entity_intrinsic(DEREFERENCING_OPERATOR_NAME),
              MakeBinaryCall(
                entity_intrinsic(PLUS_C_OPERATOR_NAME),
                expression_undefined_p(new_expression)?
                entity_to_expression(e):
                new_expression,
                index
                )
              );
        }
        syntax syn = expression_syntax(new_expression);
        expression_syntax(new_expression)=syntax_undefined;
        update_expression_syntax(exp,syn);
      }
    }
  }
  else if(syntax_subscript_p(expression_syntax(exp))) {
    pips_user_warning("subscript are not well handled (yet)!\n");
  }
}

References DEREFERENCING_OPERATOR_NAME, do_convert_this_array_to_pointer_p(), ENDP, entity_intrinsic(), entity_to_expression(), exp, EXPRESSION, expression_reference(), expression_reference_p(), expression_syntax, expression_undefined, expression_undefined_p, FOREACH, gen_nreverse(), indices, MakeBinaryCall(), MakeUnaryCall(), NIL, pips_user_warning, PLUS_C_OPERATOR_NAME, reference_indices, reference_variable, syntax_subscript_p, syntax_undefined, and update_expression_syntax().

Referenced by do_array_to_pointer_walker().

Here is the call graph for this function:

Here is the caller graph for this function:

do_array_to_pointer_walker()

static void do_array_to_pointer_walker ( void *  obj )

static

converts arrays to pointer

Definition at line 769 of file array_to_pointer.c.

                                                  {
  gen_multi_recurse(obj,
      expression_domain, gen_true, do_array_to_pointer_walk_expression,
      call_domain, gen_true, do_array_to_pointer_walk_call_and_patch,
      cast_domain, gen_true, do_array_to_pointer_walk_cast,
      NULL);
  gen_recurse(obj,expression_domain, do_array_to_pointer_patch_call_expression, do_array_to_pointer_patch_call_expr_rwt);
 
}

References call_domain, cast_domain, do_array_to_pointer_patch_call_expr_rwt(), do_array_to_pointer_patch_call_expression(), do_array_to_pointer_walk_call_and_patch(), do_array_to_pointer_walk_cast(), do_array_to_pointer_walk_expression(), expression_domain, gen_multi_recurse(), gen_recurse, and gen_true().

Referenced by do_array_to_pointer().

Here is the call graph for this function:

Here is the caller graph for this function:

do_convert_this_array_to_pointer_p()

bool do_convert_this_array_to_pointer_p

(

entity

e

)

array_to_pointer.c

Definition at line 68 of file array_to_pointer.c.

                                                  {
  if(get_bool_property("LINEARIZE_ARRAY_USE_POINTERS")) {
    if(get_bool_property("LINEARIZE_ARRAY_SKIP_STATIC_LENGTH_ARRAYS") && !entity_variable_length_array_p(e))
      return false;
    value v =entity_initial(e);
    if ( !value_undefined_p(v) && value_expression_p(v) && !expression_brace_p(value_expression(v) ) ) 
        return true;
    if( get_bool_property("LINEARIZE_ARRAY_SKIP_LOCAL_ARRAYS") && !entity_formal_p(e) ) 
      return false;
    return true;
  }
  return false;
}

References entity_formal_p(), entity_initial, entity_variable_length_array_p(), expression_brace_p(), get_bool_property(), value_expression, value_expression_p, and value_undefined_p.

Referenced by do_array_to_pointer(), do_array_to_pointer_walk_expression(), and do_linearize_array().

Here is the call graph for this function:

Here is the caller graph for this function:

do_linearize_array()

static void do_linearize_array ( entity  m, statement  s, param_t *  param  )

static

step 0: remind all expressions types

step 0.25: hack some subscripts typically found in pips inputs

step 0.5: transform int (*a) [3] into int a[*][3]

step1: the statements

step2: the declarations

pips bonus step: the consistency

step3: change the caller to reflect the new types accordingly

final step: fix expressions if we have disturbed typing in the process

Definition at line 608 of file array_to_pointer.c.

                                                                      {
  /* step 0: remind all expressions types */
  hash_table e2t = init_expression_is_pointer(s);
 
  /* step 0.25: hack some subscripts typically found in pips inputs */
  do_linearize_prepatch_subscripts(m,s);
 
  /* step 0.5: transform int (*a) [3] into int a[*][3] */
  do_linearize_prepatch(m,s);
 
  /* step1: the statements */
  do_linearize_array_walker(s);
  FOREACH(ENTITY,e,entity_declarations(m))
    if(entity_variable_p(e))
      do_linearize_array_walker(entity_initial(e));
 
  /* step2: the declarations */
  FOREACH(ENTITY,e,entity_declarations(m)) {
    if(entity_variable_p(e)) {
      bool rr;
      pips_debug (5, "linearizing entity %s\n", entity_name (e));
      do_linearize_type(&entity_type(e),&rr);
      if(rr) do_linearize_remove_dereferencment(s,e);
      do_linearize_array_init(entity_initial(e));
    }
  }
 
  /* pips bonus step: the consistency */
  set linearized_param = set_make(set_pointer);
  FOREACH(PARAMETER,p,module_functional_parameters(m)) {
    dummy d = parameter_dummy(p);
    pips_debug (5, "linearizing parameters\n");
    if(dummy_identifier_p(d))
    {
      entity di = dummy_identifier(d);
      do_linearize_type(&entity_type(di),NULL);
      pips_debug (5, "linearizing dummy parameter %s\n", entity_name (di));
    }
 
    if(do_linearize_type(&parameter_type(p),NULL))
      set_add_element(linearized_param,linearized_param,p);
 
    // Convert to pointer if requested
    if(param->use_pointers_p) {
      if(dummy_identifier_p(d)) {
        entity di = dummy_identifier(d);
        if(do_convert_this_array_to_pointer_p(di)) {
          do_array_to_pointer_type(&entity_type(di));
          do_array_to_pointer_type(&parameter_type(p));
        }
      }
    }
    pips_assert("everything went well",parameter_consistent_p(p));
  }
 
  /* step3: change the caller to reflect the new types accordingly */
  if (param->modify_call_site_p) {
    do_linearize_array_manage_callers(m,linearized_param,param);
  }
  set_free(linearized_param);
 
  /* final step: fix expressions if we have disturbed typing in the process */
  do_linearize_patch_expressions(s,e2t);
  hash_table_free(e2t);
  FOREACH(PARAMETER,p,module_functional_parameters(get_current_module_entity())) {
    pips_assert("everything went well",parameter_consistent_p(p));
  }
}

References do_array_to_pointer_type(), do_convert_this_array_to_pointer_p(), do_linearize_array_init(), do_linearize_array_manage_callers(), do_linearize_array_walker(), do_linearize_patch_expressions(), do_linearize_prepatch(), do_linearize_prepatch_subscripts(), do_linearize_remove_dereferencment(), do_linearize_type(), dummy_identifier, dummy_identifier_p, ENTITY, entity_declarations, entity_initial, entity_name, entity_type, entity_variable_p, FOREACH, get_current_module_entity(), hash_table_free(), init_expression_is_pointer(), module_functional_parameters, PARAMETER, parameter_consistent_p(), parameter_dummy, parameter_type, pips_assert, pips_debug, set_add_element(), set_free(), set_make(), and set_pointer.

Referenced by linearize_array_generic().

Here is the call graph for this function:

Here is the caller graph for this function:

do_linearize_array_cast()

static void do_linearize_array_cast ( cast  c )

static

Definition at line 397 of file array_to_pointer.c.

                                            {
  do_linearize_type(&cast_type(c),NULL);
}

References cast_type, and do_linearize_type().

Referenced by do_linearize_array_walker().

Here is the call graph for this function:

Here is the caller graph for this function:

do_linearize_array_init()

static void do_linearize_array_init ( value  v )

static

Definition at line 455 of file array_to_pointer.c.

                                             {
  if(value_expression_p(v)) {
    expression exp = value_expression(v);
    if(expression_call_p(exp)) {
      call c = expression_call(exp);
      entity op = call_function(c);
      if(ENTITY_BRACE_INTRINSIC_P(op)) {
        list inits = NIL;
        for(list iter = call_arguments(c); !ENDP(iter) ; POP(iter)) {
          expression *eiter = (expression*)REFCAR(iter);
          if(expression_call_p(*eiter)) {
            call c2 = expression_call(*eiter);
            if(ENTITY_BRACE_INTRINSIC_P(call_function(c2))) {
              iter=gen_append(iter,call_arguments(c2));
              call_arguments(c2)=NIL;
              continue;
            }
          }
          inits=CONS(EXPRESSION,copy_expression(*eiter),inits);
        }
        inits=gen_nreverse(inits);
        gen_full_free_list(call_arguments(c));
        call_arguments(c)=inits;
      }
    }
  }
}

References call_arguments, call_function, CONS, copy_expression(), ENDP, ENTITY_BRACE_INTRINSIC_P, exp, EXPRESSION, expression_call(), expression_call_p(), gen_append(), gen_full_free_list(), gen_nreverse(), NIL, POP, REFCAR, value_expression, and value_expression_p.

Referenced by do_linearize_array().

Here is the call graph for this function:

Here is the caller graph for this function:

do_linearize_array_manage_callers()

static void do_linearize_array_manage_callers ( entity  m, set  linearized_param, param_t *  param  )

static

we may have to change the call sites, prepare iterators over call sites arguments here

Definition at line 288 of file array_to_pointer.c.

                                                                                             {
  list callers = callees_callees((callees)db_get_memory_resource(DBR_CALLERS,module_local_name(m), true));
  list callers_statement = callers_to_statements(callers);
  list call_sites = callers_to_call_sites(callers_statement,m);
 
  /* we may have to change the call sites, prepare iterators over call sites arguments here */
  FOREACH(CALL,c,call_sites) {
    list args = call_arguments(c);
    FOREACH(PARAMETER,p,module_functional_parameters(m)) {
      if(set_belong_p(linearized_param,p)) {
        expression * arg = (expression*)REFCAR(args);
        type type_at_call_site = expression_to_type(*arg);
        type type_in_func_prototype = parameter_type(p);
        if(!pointer_type_p(type_at_call_site)) {
          /*
             type t = make_type_variable(
             make_variable(
             make_basic_pointer(
             copy_type(parameter_type(p))
             ),
             NIL,NIL)
             );
             */
          if(array_type_p(type_at_call_site)) {
            if(param->cast_at_call_site_p && !fixed_length_array_type_p(type_in_func_prototype)) {
              *arg = 
                make_expression(
                    make_syntax_cast(
                      make_cast(
                        copy_type(type_in_func_prototype),
                        *arg
                        )
                      ),
                    normalized_undefined
                    );
              if(!param->use_pointers_p) {
                *arg=MakeUnaryCall(
                    entity_intrinsic(DEREFERENCING_OPERATOR_NAME),
                    *arg);
              }
            }
          }
          else {
              if(!fixed_length_array_type_p(type_in_func_prototype))
            *arg = 
              make_expression(
                  make_syntax_cast(
                    make_cast(
                      copy_type(type_in_func_prototype),
                      MakeUnaryCall(
                        entity_intrinsic(ADDRESS_OF_OPERATOR_NAME),
                        *arg
                        )
                      )
                    ),
                  normalized_undefined
                  );
            if(!param->use_pointers_p) {
              *arg=MakeUnaryCall(
                  entity_intrinsic(DEREFERENCING_OPERATOR_NAME),
                  *arg);
            }
          }
        }
        else if(!param->use_pointers_p && !type_equal_p(type_at_call_site,type_in_func_prototype)) {
          *arg =
            MakeUnaryCall(
                entity_intrinsic(DEREFERENCING_OPERATOR_NAME),*arg);
        }
 
#if 0 // ***SG: optional, and I don't want to valdiate it
        /* handle call sites in the form *pointer_to_array */
        if( param->cast_at_call_site_p && expression_call_p(*arg) && ENTITY_DEREFERENCING_P(call_function(expression_call(*arg)))) {
            expression *dereferenced = (expression*)REFCAR(call_arguments(expression_call(*arg)));
            type dereferenced_type = expression_to_type(*dereferenced);
            if ( pointer_type_p(dereferenced_type)) {
                type dereferenced_pointed_type = basic_pointer(variable_basic(type_variable(dereferenced_type)));
                if(array_type_p(dereferenced_pointed_type)) {
                    *dereferenced = 
                        make_expression(
                                make_syntax_cast(
                                    make_cast(
                                        make_type_variable(
                                            make_variable(
                                                make_basic_pointer(copy_type(type_in_func_prototype)),
                                                NIL,
                                                NIL
                                                )
                                            ),
                                        *dereferenced
                                        )
                                    ),
                                normalized_undefined
                                );
 
                }
            }
 
        }
#endif
        free_type(type_at_call_site);
      }
      POP(args);
    }
  }
  for(list citer=callers,siter=callers_statement;!ENDP(citer);POP(citer),POP(siter))
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, STRING(CAR(citer)),STATEMENT(CAR(siter)));
 
}

References ADDRESS_OF_OPERATOR_NAME, array_type_p(), basic_pointer, CALL, call_arguments, call_function, callees_callees, callers_to_call_sites(), callers_to_statements(), CAR, copy_type(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, DEREFERENCING_OPERATOR_NAME, ENDP, ENTITY_DEREFERENCING_P, entity_intrinsic(), expression_call(), expression_call_p(), expression_to_type(), fixed_length_array_type_p(), FOREACH, free_type(), make_basic_pointer(), make_cast(), make_expression(), make_syntax_cast(), make_type_variable(), make_variable(), MakeUnaryCall(), module_functional_parameters, module_local_name(), NIL, normalized_undefined, PARAMETER, parameter_type, pointer_type_p(), POP, REFCAR, set_belong_p(), STATEMENT, STRING, type_equal_p(), type_variable, and variable_basic.

Referenced by do_linearize_array().

Here is the call graph for this function:

Here is the caller graph for this function:

do_linearize_array_reference()

static void do_linearize_array_reference ( reference  r )

static

must first check the dimensions , then the pointer type

one dimension variable, nothing to do

merge all

better start with this than nothing

it's a pointer: pop type

Definition at line 107 of file array_to_pointer.c.

                                                      {
  entity e =reference_variable(r);
  if(entity_variable_p(e)) {
    list indices = reference_indices(r);
    list to_be_free = indices;
    bool fortran_p = fortran_module_p(get_current_module_entity());
    if (fortran_p) {
      indices = gen_nreverse (indices);
    }
    if(!ENDP(indices)) {
      type et = ultimate_type(entity_type(e));
      list new_indices = NIL;
      while(!ENDP(indices)) {
        expression new_index = expression_undefined;
        variable v = type_variable(et);
        /* must first check the dimensions , then the pointer type */
        list vdims = variable_dimensions(v);
        /* one dimension variable, nothing to do */
        if(ENDP(vdims)||ENDP(CDR(vdims))) {
        }
        else {
          /* merge all */
          new_index=int_to_expression(0);/* better start with this than nothing */
          while(!ENDP(vdims) && !ENDP(indices) ) {
            expression curr_exp = copy_expression(EXPRESSION(CAR(indices)));
            if (fortran_p) {
              // in fortran we have to take care of the lower bound that can
              // be set to any value
              // First compute the lower bound
              expression lower = copy_expression(dimension_lower(DIMENSION(CAR(vdims))));
              if (ENDP(CDR(indices))) {
                // for the last dimension (the most contiguous in the memory)
                // substract the lower bound minus 1 since the first index is
                // one
                lower = add_integer_to_expression (lower, -1);
                curr_exp = make_op_exp (MINUS_OPERATOR_NAME, curr_exp, lower);
              }
              else {
                // substract the lower bound to the index to compute the
                // dimension stride in the linearized array
                curr_exp = make_op_exp (MINUS_OPERATOR_NAME, curr_exp, lower);
              }
            }
            new_index=make_op_exp(PLUS_OPERATOR_NAME,
                make_op_exp(MULTIPLY_OPERATOR_NAME,
                  curr_exp,
                  SizeOfDimensions(CDR(vdims))
                  ),
                new_index
                );
            POP(vdims);
            POP(indices);
          }
        }
        /* it's a pointer: pop type */
        if(basic_pointer_p(variable_basic(v))) {
          et = basic_pointer(variable_basic(v));
        }
        if(expression_undefined_p(new_index)) {
          new_index =copy_expression(EXPRESSION(CAR(indices)));
          POP(indices);
        }
        new_indices=CONS(EXPRESSION,new_index,new_indices);
      }
      reference_indices(r)=gen_nreverse(new_indices);
      gen_full_free_list (to_be_free);
    }
  }
}

References add_integer_to_expression(), basic_pointer, basic_pointer_p, CAR, CDR, CONS, copy_expression(), DIMENSION, dimension_lower, ENDP, entity_type, entity_variable_p, EXPRESSION, expression_undefined, expression_undefined_p, fortran_module_p(), gen_full_free_list(), gen_nreverse(), get_current_module_entity(), indices, int_to_expression(), make_op_exp(), MINUS_OPERATOR_NAME, MULTIPLY_OPERATOR_NAME, NIL, PLUS_OPERATOR_NAME, POP, reference_indices, reference_variable, SizeOfDimensions(), type_variable, ultimate_type(), variable_basic, and variable_dimensions.

Referenced by do_linearize_array_walker().

Here is the call graph for this function:

Here is the caller graph for this function:

do_linearize_array_subscript()

static void do_linearize_array_subscript ( _UNUSED_ subscript  s )

static

Definition at line 177 of file array_to_pointer.c.

                                                               {
  pips_user_warning("subscript linearization not handled yet\n");
}

References pips_user_warning.

Referenced by do_linearize_array_walker().

Here is the caller graph for this function:

do_linearize_array_walker()

static void do_linearize_array_walker ( void *  obj )

static

Definition at line 400 of file array_to_pointer.c.

                                                 {
  gen_multi_recurse(obj,
      reference_domain, do_linearize_array_reference, gen_null2,
      subscript_domain, do_linearize_array_subscript, gen_null2,
      cast_domain, gen_true2, do_linearize_array_cast,
      NULL);
}

References cast_domain, do_linearize_array_cast(), do_linearize_array_reference(), do_linearize_array_subscript(), gen_multi_recurse(), gen_null2(), gen_true2(), reference_domain, and subscript_domain.

Referenced by do_linearize_array().

Here is the call graph for this function:

Here is the caller graph for this function:

do_linearize_expression_is_pointer()

static void do_linearize_expression_is_pointer ( expression  exp, hash_table  ht  )

static

Definition at line 408 of file array_to_pointer.c.

                                                                              {
  basic b = basic_of_expression(exp);
  hash_put(ht,exp,(void*)(intptr_t)basic_pointer_p(b));
  free_basic(b);
}

References basic_of_expression(), basic_pointer_p, exp, free_basic(), hash_put(), and intptr_t.

Referenced by init_expression_is_pointer().

Here is the call graph for this function:

Here is the caller graph for this function:

do_linearize_patch_expressions()

static void do_linearize_patch_expressions ( void *  obj, hash_table  ht  )

static

Definition at line 447 of file array_to_pointer.c.

                                                                     {
  gen_context_recurse(obj,ht,expression_domain,gen_true2,do_linearize_pointer_is_expression);
  FOREACH(ENTITY,e,entity_declarations(get_current_module_entity())) {
    if(entity_variable_p(e))
      gen_context_recurse(entity_initial(e),ht,expression_domain,gen_true2,do_linearize_pointer_is_expression);
  }
}

References do_linearize_pointer_is_expression(), ENTITY, entity_declarations, entity_initial, entity_variable_p, expression_domain, FOREACH, gen_context_recurse, gen_true2(), and get_current_module_entity().

Referenced by do_linearize_array().

Here is the call graph for this function:

Here is the caller graph for this function:

do_linearize_pointer_is_expression()

static void do_linearize_pointer_is_expression ( expression  exp, hash_table  ht  )

static

G: let us hope that by fixing only references, it will be enough

Definition at line 414 of file array_to_pointer.c.

                                                                              {
  intptr_t t = (intptr_t)hash_get(ht,exp);
  if(t != (intptr_t)HASH_UNDEFINED_VALUE ) {
    basic b = basic_of_expression(exp);
    /*SG: let us hope that by fixing only references, it will be enough */
    if(t && !basic_pointer_p(b) && expression_reference_p(exp)){
      syntax syn = expression_syntax(exp);
      expression_syntax(exp) = syntax_undefined;
      update_expression_syntax(exp,
          make_syntax_call(
            make_call(
              entity_intrinsic(ADDRESS_OF_OPERATOR_NAME),
              CONS(EXPRESSION,
                make_expression(syn,normalized_undefined),
                NIL)
              )
            )
          );
    }
    free_basic(b);
  }
}

References ADDRESS_OF_OPERATOR_NAME, basic_of_expression(), basic_pointer_p, CONS, entity_intrinsic(), exp, EXPRESSION, expression_reference_p(), expression_syntax, free_basic(), hash_get(), HASH_UNDEFINED_VALUE, intptr_t, make_call(), make_expression(), make_syntax_call(), NIL, normalized_undefined, syntax_undefined, and update_expression_syntax().

Referenced by do_linearize_patch_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

do_linearize_prepatch()

static void do_linearize_prepatch ( entity  m, _UNUSED_ statement  s  )

static

Definition at line 585 of file array_to_pointer.c.

                                                                  {
  FOREACH(ENTITY,e,entity_declarations(m))
    if(entity_variable_p(e)) {
        if(local_entity_of_module_p(e,m) && 
                entity_pointer_p(e) &&
                value_unknown_p(entity_initial(e))) {
            free_value(entity_initial(e));
            entity_initial(e) = make_value_expression(int_to_expression(0));
        }
      do_linearize_prepatch_type(entity_type(e));
    }
  FOREACH(PARAMETER,p,module_functional_parameters(m)) {
    dummy d = parameter_dummy(p);
    if(dummy_identifier_p(d))
    {
      entity di = dummy_identifier(d);
      do_linearize_prepatch_type(entity_type(di));
    }
    do_linearize_prepatch_type(parameter_type(p));
    pips_assert("everything went well",parameter_consistent_p(p));
  }
}

References do_linearize_prepatch_type(), dummy_identifier, dummy_identifier_p, ENTITY, entity_declarations, entity_initial, entity_pointer_p(), entity_type, entity_variable_p, FOREACH, free_value(), int_to_expression(), local_entity_of_module_p(), make_value_expression(), module_functional_parameters, PARAMETER, parameter_consistent_p(), parameter_dummy, parameter_type, pips_assert, and value_unknown_p.

Referenced by do_linearize_array().

Here is the call graph for this function:

Here is the caller graph for this function:

do_linearize_prepatch_subscript()

static void do_linearize_prepatch_subscript ( subscript  s )

static

subscripts of the form (*a)[n] are transformed into a[n] it is coherent with other transformations scattered here and there in this file :p

Definition at line 550 of file array_to_pointer.c.

                                                         {
  expression exp = subscript_array(s);
  if(expression_call_p(exp)) {
    call c =expression_call(exp);
    entity op = call_function(c);
    if(ENTITY_DEREFERENCING_P(op)) {
      expression arg = EXPRESSION(CAR(call_arguments(c)));
      if(expression_reference_p(arg)) {
        reference r = expression_reference(arg);
        entity var = reference_variable(r);
        if(entity_pointer_p(var)) {
          type pointed_type = basic_pointer(variable_basic(type_variable(ultimate_type(entity_type(var)))));
          if(array_type_p(ultimate_type(pointed_type))) {
              reference_indices(r)=CONS(EXPRESSION,int_to_expression(0),reference_indices(r));
              update_expression_syntax(exp,copy_syntax(expression_syntax(arg)));
          }
        }
      }
    }
  }
}

References array_type_p(), basic_pointer, call_arguments, call_function, CAR, CONS, copy_syntax(), ENTITY_DEREFERENCING_P, entity_pointer_p(), entity_type, exp, EXPRESSION, expression_call(), expression_call_p(), expression_reference(), expression_reference_p(), expression_syntax, int_to_expression(), pointed_type(), reference_indices, reference_variable, subscript_array, type_variable, ultimate_type(), update_expression_syntax(), and variable_basic.

Referenced by do_linearize_prepatch_subscripts().

Here is the call graph for this function:

Here is the caller graph for this function:

do_linearize_prepatch_subscripts()

static void do_linearize_prepatch_subscripts ( entity  m, statement  s  )

static

transform some subscripts for generic handling later

Definition at line 573 of file array_to_pointer.c.

                                                                   {
  gen_recurse(s,subscript_domain,gen_true,do_linearize_prepatch_subscript);
  cleanup_subscripts(s);
  FOREACH(ENTITY,e,entity_declarations(m))
    if(entity_variable_p(e)) {
      gen_recurse(entity_initial(e),subscript_domain,gen_true,do_linearize_prepatch_subscript);
      cleanup_subscripts(entity_initial(e));
    }
 
 
}

References cleanup_subscripts(), do_linearize_prepatch_subscript(), ENTITY, entity_declarations, entity_initial, entity_variable_p, FOREACH, gen_recurse, gen_true(), and subscript_domain.

Referenced by do_linearize_array().

Here is the call graph for this function:

Here is the caller graph for this function:

do_linearize_prepatch_type()

static void do_linearize_prepatch_type ( type  t )

static

Definition at line 523 of file array_to_pointer.c.

                                               {
  if(pointer_type_p(t)) {
    type t2 = basic_pointer(variable_basic(type_variable(t)));
    type t3 = ultimate_type(t2);
    if(array_type_p(t2)) {
      variable v = type_variable(t2);
      variable_dimensions(v)=CONS(DIMENSION,
                make_dimension(int_to_expression(0),int_to_expression(0),NIL),
          variable_dimensions(v));
      basic_pointer(variable_basic(type_variable(t)))=type_undefined;
      free_variable(type_variable(t));
      type_variable(t)=v;
    }
    else if(array_type_p(t3)) {
      variable v = copy_variable(type_variable(t2));
      variable_dimensions(v)=CONS(DIMENSION,
                 make_dimension(int_to_expression(0),int_to_expression(0),NIL),
          variable_dimensions(v));
      free_variable(type_variable(t));
      type_variable(t)=v;
    }
  }
}

References array_type_p(), basic_pointer, CONS, copy_variable(), DIMENSION, free_variable(), int_to_expression(), make_dimension(), NIL, pointer_type_p(), type_undefined, type_variable, ultimate_type(), variable_basic, and variable_dimensions.

Referenced by do_linearize_prepatch().

Here is the call graph for this function:

Here is the caller graph for this function:

do_linearize_remove_dereferencment()

static void do_linearize_remove_dereferencment ( statement  s, entity  e  )

static

Definition at line 515 of file array_to_pointer.c.

                                                                      {
  gen_context_recurse(s,e,expression_domain,gen_true2,do_linearize_remove_dereferencment_walker);
  FOREACH(ENTITY,e,entity_declarations(get_current_module_entity()))
    if(entity_variable_p(e))
      gen_context_recurse(entity_initial(e),e,
        expression_domain,gen_true2,do_linearize_remove_dereferencment_walker);
}

References do_linearize_remove_dereferencment_walker(), ENTITY, entity_declarations, entity_initial, entity_variable_p, expression_domain, FOREACH, gen_context_recurse, gen_true2(), and get_current_module_entity().

Referenced by do_array_to_pointer(), and do_linearize_array().

Here is the call graph for this function:

Here is the caller graph for this function:

do_linearize_remove_dereferencment_walker()

static void do_linearize_remove_dereferencment_walker ( expression  exp, entity  e  )

static

Definition at line 483 of file array_to_pointer.c.

                                                                                {
  if(expression_call_p(exp)) {
    call c = expression_call(exp);
    if(ENTITY_DEREFERENCING_P(call_function(c))) {
      expression arg = EXPRESSION(CAR(call_arguments(c)));
      if(expression_reference_p(arg)) {
        reference r = expression_reference(arg);
        if(same_entity_p(reference_variable(r),e)) {
          syntax syn = expression_syntax(arg);
          expression_syntax(arg)=syntax_undefined;
          update_expression_syntax(exp,syn);
        }
      }
      else if(expression_call_p(arg)) {
        call c2 = expression_call(arg);
        if(ENTITY_PLUS_C_P(call_function(c2))) {
          bool remove =false;
          FOREACH(EXPRESSION,exp2,call_arguments(c2)) {
            if(expression_reference_p(exp2))
              remove|=same_entity_p(reference_variable(expression_reference(exp2)),e);
          }
          if(remove) {
            syntax syn = expression_syntax(arg);
            expression_syntax(arg)=syntax_undefined;
            update_expression_syntax(exp,syn);
          }
        }
 
      }
    }
  }
}

References call_arguments, call_function, CAR, ENTITY_DEREFERENCING_P, ENTITY_PLUS_C_P, exp, EXPRESSION, expression_call(), expression_call_p(), expression_reference(), expression_reference_p(), expression_syntax, FOREACH, reference_variable, same_entity_p(), syntax_undefined, and update_expression_syntax().

Referenced by do_linearize_remove_dereferencment().

Here is the call graph for this function:

Here is the caller graph for this function:

do_linearize_type()

static bool do_linearize_type ( type *  t, bool *  rr  )

static

Definition at line 191 of file array_to_pointer.c.

                                                 {
  bool linearized =false;
  if(type_void_or_void_pointer_p(*t)) {
    pips_user_warning("cannot linearize void type\n");
  }
  else {
    pips_assert ("variable expected", type_variable_p (*t));
    pips_debug (5, "try to linearize type: %s\n", type_to_string (*t));
    if(rr)*rr=false;
    variable v = type_variable(*t);
    type ut = ultimate_type(*t);
    variable uv = type_variable(ut);
    size_t uvl = gen_length(variable_dimensions(uv));
    size_t vl = gen_length(variable_dimensions(v));
    if(uvl > 1 ) {
      dimension nd = dimension_undefined;
      if (fortran_module_p(get_current_module_entity()) ) {
        nd = make_dimension(int_to_expression(1),
                            SizeOfDimensions(variable_dimensions(uv)),
                            NIL);
      }
      else {
        nd = make_dimension(int_to_expression(0),
                            make_op_exp(MINUS_OPERATOR_NAME,
                                        SizeOfDimensions(variable_dimensions(uv)),
                                        int_to_expression(1)),
                            NIL);
      }
 
      type nt = type_undefined;
      bool free_it = false;
      // copy only if needed, otherwise modify in place
      if (ut == *t) {
        nt = *t;
        free_it = false;
      }
      else {
        nt = copy_type(uvl>vl?ut:*t);
        free_it = true;
      }
      variable nv = type_variable(nt);
      gen_full_free_list(variable_dimensions(nv));
      variable_dimensions(nv)=CONS(DIMENSION,nd,NIL);
      if (free_it) {
        // it might be dangerous to free the type that can be reused somewhere
        // else in the RI
        free_type(*t);
        *t=nt;
      }
      linearized=true;
      if(rr)*rr=true;
      pips_debug (5, "type has been linearized\n");
    }
 
    if(basic_pointer_p(variable_basic(type_variable(*t))))
      return do_linearize_type(&basic_pointer(variable_basic(type_variable(*t))),rr) || linearized;
  }
  return linearized;
}

References basic_pointer, basic_pointer_p, CONS, copy_type(), DIMENSION, dimension_undefined, fortran_module_p(), free_type(), gen_full_free_list(), gen_length(), get_current_module_entity(), int_to_expression(), make_dimension(), make_op_exp(), MINUS_OPERATOR_NAME, NIL, pips_assert, pips_debug, pips_user_warning, SizeOfDimensions(), type_to_string(), type_undefined, type_variable, type_variable_p, type_void_or_void_pointer_p(), ultimate_type(), variable_basic, and variable_dimensions.

Referenced by do_linearize_array(), and do_linearize_array_cast().

Here is the call graph for this function:

Here is the caller graph for this function:

init_expression_is_pointer()

static hash_table init_expression_is_pointer ( void *  obj )

static

Definition at line 437 of file array_to_pointer.c.

                                                        {
  hash_table ht = hash_table_make(hash_int,HASH_DEFAULT_SIZE);
  gen_context_recurse(obj,ht,expression_domain,gen_true2,do_linearize_expression_is_pointer);
  FOREACH(ENTITY,e,entity_declarations(get_current_module_entity())) {
    if(entity_variable_p(e))
      gen_context_recurse(entity_initial(e),ht,expression_domain,gen_true2,do_linearize_expression_is_pointer);
  }
  return ht;
}

References do_linearize_expression_is_pointer(), ENTITY, entity_declarations, entity_initial, entity_variable_p, expression_domain, FOREACH, gen_context_recurse, gen_true2(), get_current_module_entity(), HASH_DEFAULT_SIZE, hash_int, and hash_table_make().

Referenced by do_linearize_array().

Here is the call graph for this function:

Here is the caller graph for this function:

initialization_list_to_statements()

static list initialization_list_to_statements ( entity  e )

static

create a list of statements from entity declarations

we assume that we only have one level of braces, linearize_array should have done the previous job incomplete type are not handled ...

use alloca when converting array to pointers, to make sure everything is initialized correctly

Definition at line 781 of file array_to_pointer.c.

                                                 {
  list stats = NIL;
  if(entity_array_p(e)) {
    value v = entity_initial(e);
    if(value_expression_p(v)) {
      expression exp = value_expression(v);
      if(expression_call_p(exp)) {
        call c = expression_call(exp);
        entity op = call_function(c);
        /* we assume that we only have one level of braces, linearize_array should have done the previous job 
         * incomplete type are not handled ...
         * */
        if(ENTITY_BRACE_INTRINSIC_P(op)) {
          expression i = copy_expression(dimension_lower(DIMENSION(CAR(variable_dimensions(type_variable(ultimate_type(entity_type(e))))))));
          FOREACH(EXPRESSION,exp,call_arguments(c)) {
            stats=CONS(STATEMENT,
                make_assign_statement(
                  reference_to_expression(
                    make_reference(
                      e,
                      CONS(EXPRESSION,i,NIL)
                      )
                    ),
                  make_expression(
                    expression_syntax(exp),
                    normalized_undefined
                    )
                  ),
                stats);
            expression_syntax(exp)=syntax_undefined;
            i=make_op_exp(PLUS_OPERATOR_NAME,
                copy_expression(i),
                int_to_expression(1)
                );
          }
        }
      }
    }
    if(!formal_parameter_p(e)) {
        value v = entity_initial(e);
        expression ev;
        if(value_expression_p(v) && (!expression_call_p(ev=value_expression(v)) ||
                !ENTITY_BRACE_INTRINSIC_P(call_function(expression_call(ev)) ))) {
        }
        else {
            /* use alloca when converting array to pointers, to make sure everything is initialized correctly */
            free_value(entity_initial(e));
            type ct = copy_type(ultimate_type(entity_type(e)));
            if(array_type_p(ct)) {
                POP(variable_dimensions(type_variable(ct))); //leak spotted !
                ct = make_type_variable(
                        make_variable(
                            make_basic_pointer(ct),NIL,NIL
                            )
                        );
            }
 
            entity_initial(e) = make_value_expression(
                    syntax_to_expression(
                        make_syntax_cast(
                            make_cast(ct,
                                MakeUnaryCall(
                                    entity_intrinsic(ALLOCA_FUNCTION_NAME),
                                    make_expression(
                                        make_syntax_sizeofexpression(
                                            make_sizeofexpression_type(
                                                copy_type(entity_type(e))
                                                )
                                            ),
                                        normalized_undefined
                                        )
                                    )
                                )
                            )
                        )
                    );
            AddEntityToModuleCompilationUnit(entity_intrinsic(ALLOCA_FUNCTION_NAME),
                    get_current_module_entity());
        }
    }
  }
  return gen_nreverse(stats);
}

References AddEntityToModuleCompilationUnit(), ALLOCA_FUNCTION_NAME, array_type_p(), call_arguments, call_function, CAR, CONS, copy_expression(), copy_type(), DIMENSION, dimension_lower, entity_array_p(), ENTITY_BRACE_INTRINSIC_P, entity_initial, entity_intrinsic(), entity_type, exp, EXPRESSION, expression_call(), expression_call_p(), expression_syntax, FOREACH, formal_parameter_p(), free_value(), gen_nreverse(), get_current_module_entity(), int_to_expression(), make_assign_statement(), make_basic_pointer(), make_cast(), make_expression(), make_op_exp(), make_reference(), make_sizeofexpression_type(), make_syntax_cast(), make_syntax_sizeofexpression(), make_type_variable(), make_value_expression(), make_variable(), MakeUnaryCall(), NIL, normalized_undefined, PLUS_OPERATOR_NAME, POP, reference_to_expression(), STATEMENT, syntax_to_expression(), syntax_undefined, type_variable, ultimate_type(), value_expression, value_expression_p, and variable_dimensions.

Referenced by do_array_to_pointer().

Here is the call graph for this function:

Here is the caller graph for this function:

insert_statements_after_declarations()

static void insert_statements_after_declarations ( statement  st, list  stats  )

static

initialization statements are added right after declarations

No declarations

Definition at line 866 of file array_to_pointer.c.

                                                                           {
  if(!ENDP(stats)) {
    if(ENDP(statement_declarations(st))) {
      insert_statement(st,make_block_statement(stats),true);
    }
    else {
      for(list iter=statement_block(st),prev=NIL;!ENDP(iter);POP(iter)) {
        if(declaration_statement_p(STATEMENT(CAR(iter)))) {
          prev=iter;
        } else if(prev == NIL) {
          /* No declarations */
          insert_statement(st, make_block_statement(stats), true);
        } else {
          CDR(prev) = stats;
          while(!ENDP(CDR(stats)))
            POP(stats);
          CDR(stats) = iter;
          break;
        }
      }
    }
 
  }
}

References CAR, CDR, declaration_statement_p(), ENDP, insert_statement(), make_block_statement(), NIL, POP, STATEMENT, statement_block(), and statement_declarations.

Referenced by do_array_to_pointer().

Here is the call graph for this function:

Here is the caller graph for this function:

linearize_array()

bool linearize_array

(

const char *

module_name

)

linearize accesses to an array, and use pointers if asked to

Parameters

module_name

odule_name

Definition at line 987 of file array_to_pointer.c.

{
  return linearize_array_generic (module_name);
}

References linearize_array_generic(), and module_name().

Here is the call graph for this function:

linearize_array_fortran()

bool linearize_array_fortran

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 992 of file array_to_pointer.c.

{
  return linearize_array_generic (module_name);
}

References linearize_array_generic(), and module_name().

Here is the call graph for this function:

linearize_array_generic()

bool linearize_array_generic

(

const char *

module_name

)

linearize accesses to an array, and use pointers if asked to

prelude

Do we have to cast the array at call site ?

it is too dangerous to perform this task on compilation unit, system variables may be changed

just linearize accesses and change signature from n-D arrays to 1-D arrays

additionally perform array-to-pointer conversion for c modules only

validate

ostlude

Parameters

module_name

odule_name

Definition at line 930 of file array_to_pointer.c.

{
 
  debug_on("LINEARIZE_ARRAY_DEBUG_LEVEL");
  /* prelude */
  set_current_module_entity(module_name_to_entity( module_name ));
 
  param_t param = { .use_pointers_p = false , .modify_call_site_p = false, .cast_at_call_site_p = false };
  /* Do we have to cast the array at call site ? */
  if (c_module_p(get_current_module_entity())) {
    param.use_pointers_p      = get_bool_property("LINEARIZE_ARRAY_USE_POINTERS");
    param.cast_at_call_site_p = get_bool_property("LINEARIZE_ARRAY_CAST_AT_CALL_SITE");
  }
  param.modify_call_site_p  = get_bool_property("LINEARIZE_ARRAY_MODIFY_CALL_SITE");
 
  /* it is too dangerous to perform this task on compilation unit, system variables may be changed */
  if(!compilation_unit_entity_p(get_current_module_entity())) {
 
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
 
    /* just linearize accesses and change signature from n-D arrays to 1-D arrays */
    do_linearize_array(get_current_module_entity(),get_current_module_statement(),&param);
 
    /* additionally perform array-to-pointer conversion for c modules only */
    if(param.use_pointers_p) {
      if(c_module_p(get_current_module_entity())) {
        do_array_to_pointer(get_current_module_entity(),get_current_module_statement(),&param);
        cleanup_subscripts(get_current_module_statement());
        FOREACH(ENTITY,e,entity_declarations(get_current_module_entity())) {
          if(entity_variable_p(e)) {
            cleanup_subscripts(entity_initial(e));
          }
        }
      }
      else pips_user_warning("no pointers in fortran !,LINEARIZE_ARRAY_USE_POINTERS ignored\n");
    }
 
    /* validate */
    pips_assert("everything went well",statement_consistent_p(get_current_module_statement()));
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
    if (fortran_module_p(get_current_module_entity()) ) {
      // remove decls_text or the prettyprinter will use that field
      discard_module_declaration_text (get_current_module_entity ());
    } else {
      //compilation unti doesn't exit in fortran
      db_touch_resource(DBR_CODE,compilation_unit_of_module(module_name));
    }
    /*postlude*/
    reset_current_module_statement();
  }
  reset_current_module_entity();
  debug_off();
  return true;
}

References c_module_p(), cleanup_subscripts(), compilation_unit_entity_p(), compilation_unit_of_module(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, db_touch_resource(), debug_off, debug_on, discard_module_declaration_text(), do_array_to_pointer(), do_linearize_array(), ENTITY, entity_declarations, entity_initial, entity_variable_p, false, FOREACH, fortran_module_p(), get_bool_property(), get_current_module_entity(), get_current_module_statement(), module_name(), module_name_to_entity(), module_reorder(), pips_assert, pips_user_warning, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), and statement_consistent_p().

Referenced by linearize_array(), and linearize_array_fortran().

Here is the call graph for this function:

Here is the caller graph for this function:

type_dereferencement_depth()

size_t type_dereferencement_depth

(

type

t

)

Returns

the number of dimensions in

Parameters

t,counting

pointers as a dimension

BEWARE: does not take structs and unions into account

Definition at line 89 of file array_to_pointer.c.

                                          {
  t = ultimate_type(t);
  if(type_variable_p(t)) {
    ifdebug(8) {
      pips_debug(8,"Type is : ");
      print_type(t);
    }
    variable v = type_variable(t);
    basic b = variable_basic(v);
    return gen_length(variable_dimensions(v)) + (basic_pointer_p(b) ? 1
        + type_dereferencement_depth(basic_pointer(b)) : 0);
  }
  return 0;
}

References basic_pointer, basic_pointer_p, gen_length(), ifdebug, pips_debug, print_type(), type_dereferencement_depth(), type_variable, type_variable_p, ultimate_type(), variable_basic, and variable_dimensions.

Referenced by type_dereferencement_depth().

Here is the call graph for this function:

Here is the caller graph for this function:

type_void_or_void_pointer_p()

static bool type_void_or_void_pointer_p ( type  t )

static

Definition at line 181 of file array_to_pointer.c.

                                                {
  if(type_void_p(t)) return true;
  else if(type_variable_p(t)) {
    basic b = variable_basic(type_variable(t));
    return basic_pointer_p(b) &&
      type_void_or_void_pointer_p(ultimate_type(basic_pointer(b)));
  }
  return false;
}

References basic_pointer, basic_pointer_p, type_variable, type_variable_p, type_void_p, ultimate_type(), and variable_basic.

Referenced by do_array_to_pointer_type(), and do_linearize_type().

Here is the call graph for this function:

Here is the caller graph for this function: