flint_check.c File Reference

#include "local.h"

Include dependency graph for flint_check.c:

Go to the source code of this file.

Macros
#define	FATAL(msg, value)   {(void) fprintf(stderr,msg,value); exit(1); }
#define	BOOL_UNDEF   -1
	some defines usefull to clean the code More...
#define	param_ref_p(P)    (mode_reference_p(parameter_mode(P)))
#define	arg_const_p(arg)
#define	call_constant_p(C)    (value_constant_p(entity_initial(call_function(C))))
#define	effect_may_or_must_p(my_effect)
	The following define may be replaced by #define ... More...
#define	effect_to_name(the_effect)    entity_name(reference_variable(effect_any_reference(the_effect)))
#define	entity_is_a_common_p(Ent)    (type_area_p(entity_type(Ent)))
#define	special_common(Ent)

Functions
bool	check_procedure (call c)
	extern char *current_module_name; unused and modified More...
bool	check_the_call (call c)
bool	check_call_intrinsic (list la, list __attribute__((unused)) lt, call c)
bool	check_call_args_number (list la, list lt, call c)
bool	check_call_types_compatibility (list la, list lt, call c)
bool	check_call_one_type (expression exp, parameter param, call c, int i)
bool	check_call_basic (basic be, basic bp, call c, int i)
bool	check_call_dim (list de, list dp, call c, int i)
	loose version More...
bool	check_call_basic_and_dim (expression exp, parameter param, call c, int i)
void	check_the_reference (reference ref)
bool	check_call_mode_consistency (list la, list lt, entity the_fnct)
bool	check_call_one_mode (expression exp, parameter param, entity the_fnct, list sefs_list, int i)
	This function checks that a reference to a constant in a call may not be modified, if it could happen, a message is broadcast. More...
bool	look_at_the_commons (entity module)
bool	position_in_the_area (entity the_var, intptr_t *inf, intptr_t *sup)
bool	check_commons (entity module)
void	check_one_common (entity local, entity module)
bool	check_overlap_in_common (entity the_common, entity e1, int inf1, int sup1, entity e2, int inf2, int sup2)

Macro Definition Documentation

arg_const_p

#define arg_const_p

(

arg

)

Value:

  (syntax_call_p(expression_syntax(arg)) &&      \
     value_constant_p(entity_initial(call_function( \
           syntax_call(expression_syntax(arg))))))

Definition at line 46 of file flint_check.c.

BOOL_UNDEF

#define BOOL_UNDEF   -1

some defines usefull to clean the code

Definition at line 42 of file flint_check.c.

call_constant_p

#define call_constant_p

(

C

)

(value_constant_p(entity_initial(call_function(C))))

Definition at line 51 of file flint_check.c.

effect_may_or_must_p

#define effect_may_or_must_p

(

my_effect

)

Value:

  ((approximation_may_p(effect_approximation(my_effect))) || \
   (approximation_exact_p(effect_approximation(my_effect))) )

The following define may be replaced by #define ...

(true)

Definition at line 55 of file flint_check.c.

effect_to_name

#define effect_to_name

(

the_effect

)

entity_name(reference_variable(effect_any_reference(the_effect)))

Definition at line 59 of file flint_check.c.

entity_is_a_common_p

#define entity_is_a_common_p

(

Ent

)

(type_area_p(entity_type(Ent)))

Definition at line 62 of file flint_check.c.

FATAL

#define FATAL	(		msg,
			value
	)		{(void) fprintf(stderr,msg,value); exit(1); }

Definition at line 38 of file flint_check.c.

param_ref_p

#define param_ref_p

(

P

)

(mode_reference_p(parameter_mode(P)))

Definition at line 43 of file flint_check.c.

special_common

#define special_common

(

Ent

)

Value:

  ((!strcmp(entity_local_name(Ent),DYNAMIC_AREA_LOCAL_NAME)) || \
   (!strcmp(entity_local_name(Ent),STATIC_AREA_LOCAL_NAME))   )

Definition at line 65 of file flint_check.c.

Function Documentation

check_call_args_number()

bool check_call_args_number	(	list	la,
		list	lt,
		call	c
	)

sometimes out...

Parameters

la	a
lt	list of actual arguments
c	list of parameters

Definition at line 222 of file flint_check.c.

{
    int             na = gen_length(la);
    int             nt = gen_length(lt);
 
    if (na == nt ||
        (nt<=na && type_varargs_p(parameter_type(PARAMETER(CAR(gen_last(lt)))))))
        return (true);
 
    if (call_intrinsic_p(c) && (nt == 0)) {     /* sometimes out... */
        return (BOOL_UNDEF);
    }
    flint_message("check call",
                  "too %s arguments (%d) in call to %s (%d)\n",
                  ((na > nt) ? "many" : "few"),
                  na,
                  entity_name(call_function(c)),
                  nt);
    return (false);
}

References BOOL_UNDEF, call_function, call_intrinsic_p, CAR, entity_name, flint_message(), gen_last(), gen_length(), PARAMETER, parameter_type, and type_varargs_p.

Referenced by check_the_call().

Here is the call graph for this function:

Here is the caller graph for this function:

check_call_basic()

bool check_call_basic	(	basic	be,
		basic	bp,
		call	c,
		int	i
	)

---

Parameters

be	e
bp	p

Definition at line 305 of file flint_check.c.

{
    if (basic_tag(be) == basic_tag(bp))
        return (true);
 
    if (basic_overloaded_p(be))
        flint_message("check_call: WARNING",
                      "may be incompatible basic type, %dth arg in call to %s\n",
                      i, entity_name(call_function(c)));
    else
        flint_message("check_call",
                      "incompatible basic type, %dth arg in call to %s, %s>%s\n",
                      i, entity_name(call_function(c)),
                      basic_to_string(be), basic_to_string(bp));
    return (false);
}

References basic_overloaded_p, basic_tag, basic_to_string(), call_function, entity_name, and flint_message().

Referenced by check_call_basic_and_dim(), and check_call_intrinsic().

Here is the call graph for this function:

Here is the caller graph for this function:

check_call_basic_and_dim()

bool check_call_basic_and_dim	(	expression	exp,
		parameter	param,
		call	c,
		int	i
	)

---

else

else

Parameters

exp	xp
param	aram

Definition at line 367 of file flint_check.c.

{
    basic           bexp, bpar;
    list            dexp, dpar;
    bool            okexp = find_bd_expression(exp, &bexp, &dexp), okpar = find_bd_parameter(param, &bpar, &dpar);
 
    if (!(okexp && okpar))
        return (BOOL_UNDEF);
 
    /* else */
    if (!check_call_basic(bexp, bpar, c, i))
        return (false);
 
    /* else */
    return (check_call_dim(dexp, dpar, c, i));
}

References BOOL_UNDEF, check_call_basic(), check_call_dim(), exp, find_bd_expression(), and find_bd_parameter().

Referenced by check_call_one_type().

Here is the call graph for this function:

Here is the caller graph for this function:

check_call_dim()

bool check_call_dim	(	list	de,
		list	dp,
		call	c,
		int	i
	)

loose version

---

else

else

Parameters

de	e
dp	p

Definition at line 336 of file flint_check.c.

{
  intptr_t n_de, n_dp;
    bool
        ok_de = number_of_elements(de, &n_de),
        ok_dp = number_of_elements(dp, &n_dp);
 
    if (!(ok_de && ok_dp))
        return (BOOL_UNDEF);
 
    /* else */
    if (n_de >= n_dp)
        return (true);
 
    /* else */
    flint_message("check_call",
                  "incompatible dim, %dth arg in call to %s, (%d<%d)\n",
                  i, entity_name(call_function(c)),
                  n_de, n_dp);
    return (false);
}

References BOOL_UNDEF, call_function, entity_name, flint_message(), intptr_t, and number_of_elements().

Referenced by check_call_basic_and_dim(), and check_call_intrinsic().

Here is the call graph for this function:

Here is the caller graph for this function:

check_call_intrinsic()

bool check_call_intrinsic	(	list	la,
		list __attribute__((unused))	lt,
		call	c
	)

check a call to the assign operator

other intrinsics

Definition at line 184 of file flint_check.c.

{
    entity          the_fnct = call_function(c);
    bool            ok1, ok2;
    basic           ba1, ba2;
    list            da1, da2;
 
    /* check a call to the assign operator */
    if (ENTITY_ASSIGN_P(the_fnct)) {
        ok1 = find_bd_expression(EXPRESSION(CAR(la)), &ba1, &da1);
        ok2 = find_bd_expression(EXPRESSION(CAR(CDR(la))), &ba2, &da2);
 
        if (!(ok1 && ok2))
            return (BOOL_UNDEF);
 
        if (basic_overloaded_p(ba1) || basic_overloaded_p(ba2))
            return (BOOL_UNDEF);
 
        if (!check_call_basic(ba2, ba1, c, 0))
            return (false);
 
        return (check_call_dim(da1, da2, c, 0) && check_call_dim(da2, da1, c, 0));
    }
    /* other intrinsics */
    return (BOOL_UNDEF);
}

References basic_overloaded_p, BOOL_UNDEF, call_function, CAR, CDR, check_call_basic(), check_call_dim(), ENTITY_ASSIGN_P, EXPRESSION, and find_bd_expression().

Referenced by check_the_call().

Here is the call graph for this function:

Here is the caller graph for this function:

check_call_mode_consistency()

bool check_call_mode_consistency	(	list	la,
		list	lt,
		entity	the_fnct
	)

FI: the last argument should be pure=TRUE since summary effects should not be touched

Parameters

la	a
lt	t
the_fnct	he_fnct

Definition at line 454 of file flint_check.c.

{
        const char*module_name;
    list
        sefs_list = list_undefined;
    expression
        exp;
    parameter
        param;
    bool
        ok = true,
        temp = -1;
    int
        i, len = gen_length(lt);
 
    module_name = module_local_name(the_fnct);
 
    /* FI: the last argument should be pure=TRUE
     * since summary effects should not be touched
     */
    sefs_list = effects_to_list( (effects)
        db_get_memory_resource(DBR_SUMMARY_EFFECTS, module_name, true));
 
    pips_debug(7, "summary effects list for %s (%p)\n",
               module_name, sefs_list);
 
    for (i = 1; i <= len; i++) {
        exp = EXPRESSION(CAR(la));
        la = CDR(la);
        param = PARAMETER(CAR(lt));
        lt = CDR(lt);
        temp = check_call_one_mode(exp, param, the_fnct, sefs_list, i);
        ok = (ok && temp);
    }
 
    return (ok);
}

References CAR, CDR, check_call_one_mode(), db_get_memory_resource(), effects_to_list(), exp, EXPRESSION, gen_length(), list_undefined, module_local_name(), module_name(), ok, PARAMETER, and pips_debug.

Here is the call graph for this function:

check_call_one_mode()

bool check_call_one_mode	(	expression	exp,
		parameter	param,
		entity	the_fnct,
		list	sefs_list,
		int	i
	)

This function checks that a reference to a constant in a call may not be modified, if it could happen, a message is broadcast.

locally

else : control

Parameters

exp	xp
param	aram
the_fnct	he_fnct
sefs_list	efs_list

Definition at line 499 of file flint_check.c.

{
  list            sefl = sefs_list;     /* locally */
  bool            encountered = false;
  effect          the_effect;
  entity          the_ent;
 
  if (!(param_ref_p(param) && arg_const_p(exp)))
    return (true);
 
  /* else : control */
 
  the_ent = find_ith_formal_parameter(the_fnct, i);
 
  while ((sefl != NULL) && (!encountered))
    {
      the_effect = EFFECT(CAR(sefl));
      sefl = CDR(sefl);
      encountered = (effect_write_p(the_effect) &&
                     effect_may_or_must_p(the_effect) &&
                     (!strcmp(entity_name(the_ent), effect_to_name(the_effect))));
    }
 
  if (encountered)
    flint_message("check call mode",
                  "modified reference to a constant, %dth argument in call to %s\n",
                  i, entity_name(the_fnct));
 
  return (!encountered);
}

References arg_const_p, CAR, CDR, EFFECT, effect_may_or_must_p, effect_to_name, effect_write_p, entity_name, exp, find_ith_formal_parameter(), flint_message(), and param_ref_p.

Referenced by check_call_mode_consistency().

Here is the call graph for this function:

Here is the caller graph for this function:

check_call_one_type()

bool check_call_one_type	(	expression	exp,
		parameter	param,
		call	c,
		int	i
	)

---

Parameters

exp	xp
param	aram

Definition at line 287 of file flint_check.c.

{
    return (check_call_basic_and_dim(exp, param, c, i));
}

References check_call_basic_and_dim(), and exp.

Referenced by check_call_types_compatibility().

Here is the call graph for this function:

Here is the caller graph for this function:

check_call_types_compatibility()

bool check_call_types_compatibility	(	list	la,
		list	lt,
		call	c
	)

Parameters

la	a
lt	t

Definition at line 254 of file flint_check.c.

{
    expression      exp;
    parameter       param;
    bool            ok = true;
    int             i, len = gen_length(lt);
    list            ca = la, ct = lt;
 
    for (i = 1; i <= len; i++) {
        bool            temp;
        exp = EXPRESSION(CAR(ca));
        POP(ca);
        param = PARAMETER(CAR(ct));
        POP(ct);
        temp = check_call_one_type(exp, param, c, i);
        ok = (ok && temp);
    }
 
    return (ok);
}

References CAR, check_call_one_type(), exp, EXPRESSION, gen_length(), ok, PARAMETER, and POP.

Referenced by check_the_call().

Here is the call graph for this function:

Here is the caller graph for this function:

check_commons()

bool check_commons

(

entity

module

)

---

Parameters

module

odule

Definition at line 632 of file flint_check.c.

{
    list
        ldecl = code_declarations(value_code(entity_initial(module)));
    entity
        local;
 
    while (ldecl != NULL)
    {
        local = ENTITY(CAR(ldecl));
        ldecl = CDR(ldecl);
 
        if (entity_is_a_common_p(local) && (!special_common(local)))
            check_one_common(local, module);
    }
 
    return (true);
}

References CAR, CDR, check_one_common(), code_declarations, ENTITY, entity_initial, entity_is_a_common_p, module, special_common, and value_code.

Referenced by flinter().

Here is the call graph for this function:

Here is the caller graph for this function:

check_one_common()

void check_one_common	(	entity	local,
		entity	module
	)

Parameters

local	ocal
module	odule

Definition at line 660 of file flint_check.c.

{
    list
        llayout_init = area_layout(type_area(entity_type(local))),
        llayout = llayout_init;
 
    pips_debug(4, "checking common %s of module %s\n",
               entity_local_name(local),
               module_local_name(module));
 
    while (!ENDP(llayout))
    {
        intptr_t
            common_beginning_offset = -1,
            common_ending_offset = -1,
            other_beginning_offset = -1,
            other_ending_offset = -1;
        entity
            current_variable = ENTITY(CAR(llayout));
        list
          lothers = llayout_init;
 
        llayout = CDR(llayout);
 
        if (strcmp(entity_module_name(current_variable),
                   module_local_name(module)))
            continue;
 
        if (!position_in_the_area(current_variable,
                                  &common_beginning_offset,
                                  &common_ending_offset))
            continue;
 
        while (lothers != NULL)
        {
            entity          head = ENTITY(CAR(lothers));
            int             synonymous = 0;
            lothers = CDR(lothers);
 
            if (!strcmp(entity_name(current_variable), entity_name(head)))
            {
                if (synonymous)
                    flint_message("check common",
                                  "%s used twice in common %s\n",
                                  entity_name(current_variable),
                                  module_local_name(local));
                synonymous++;
                continue;
            }
            if (!position_in_the_area(head,
                                      &other_beginning_offset,
                                      &other_ending_offset))
                continue;
 
            check_overlap_in_common(local,
                                    current_variable,
                                    common_beginning_offset,
                                    common_ending_offset,
                                    head,
                                    other_beginning_offset,
                                    other_ending_offset);
        }
    }
}

References area_layout, CAR, CDR, check_overlap_in_common(), ENDP, ENTITY, entity_local_name(), entity_module_name(), entity_name, entity_type, flint_message(), intptr_t, module, module_local_name(), pips_debug, position_in_the_area(), and type_area.

Referenced by check_commons().

Here is the call graph for this function:

Here is the caller graph for this function:

check_overlap_in_common()

bool check_overlap_in_common	(	entity	the_common,
		entity	e1,
		int	inf1,
		int	sup1,
		entity	e2,
		int	inf2,
		int	sup2
	)

---

unused

testing overlap

else I must check basic compatibility

benefice du doute!

Parameters

the_common	he_common
e1	1
inf1	nf1
sup1	up1
e2	2
inf2	nf2
sup2	up2

Definition at line 735 of file flint_check.c.

{
    basic           b1, b2;
    bool            ok1, ok2;
    list            l1, l2;     /* unused */
 
    /* testing overlap */
    if ((sup1 < inf2) || (sup2 < inf1))
        return (true);
 
    /* else I must check basic compatibility */
    ok1 = find_bd_type_variable(entity_type(e1), &b1, &l1);
    ok2 = find_bd_type_variable(entity_type(e2), &b2, &l2);
 
    if (!(ok1 && ok2))
        return (true);          /* benefice du doute! */
 
    if (basic_tag(b1) == basic_tag(b2))
        return (true);
 
    if ((basic_float_p(b1) && (basic_complex_p(b2))) ||
        (basic_float_p(b2) && (basic_complex_p(b1))))
        return (true);
 
    flint_message_2("check common",
                "overlap of incompatible variables (%s, %s) in common %s\n",
                    entity_name(e1),
                    entity_name(e2),
                    module_local_name(the_common));
    return (false);
}

References b1, b2, basic_complex_p, basic_float_p, basic_tag, entity_name, entity_type, find_bd_type_variable(), flint_message_2(), and module_local_name().

Referenced by check_one_common().

Here is the call graph for this function:

Here is the caller graph for this function:

check_procedure()

bool check_procedure

(

call

c

)

extern char *current_module_name; unused and modified

flint_check.c

Definition at line 88 of file flint_check.c.

{
    entity          the_fnct;
    type            the_tp;
    functional      ft;
    type            result;
    bool            tmpbool= BOOL_UNDEF;
 
    if (call_intrinsic_p(c))
        tmpbool = BOOL_UNDEF;
    else {
        the_fnct = call_function(c);
        the_tp = entity_type(the_fnct);
        if (!type_functional_p(the_tp))
            tmpbool = BOOL_UNDEF;
        else {
            ft = type_functional(the_tp);
            result = functional_result(ft);
            if (!type_void_p(result)) {
                flint_message("check procedure",
                              "warning, function used as a procedure : %s\n",
                              entity_name(the_fnct));
                tmpbool = false;
            }
        }
    }
    return (tmpbool);
}

References BOOL_UNDEF, call_function, call_intrinsic_p, entity_name, entity_type, flint_message(), functional_result, type_functional, type_functional_p, and type_void_p.

Referenced by flint_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

check_the_call()

bool check_the_call

(

call

c

)

else

else

else

else

Errors in parameter modes are found out by effect computation. A second check, later, is meaningless.

return (check_call_mode_consistency(la, lt, the_fnct));

Definition at line 130 of file flint_check.c.

{
    list            la = call_arguments(c);
    entity          the_fnct = call_function(c);
    type            the_tp = entity_type(the_fnct);
    functional      ft;
    list            lt;
 
    if (!type_functional_p(the_tp))
        return (BOOL_UNDEF);
 
    ft = type_functional(the_tp);
    lt = functional_parameters(ft);
 
 
    if (!check_call_args_number(la, lt, c))
        return (false);
 
    /* else */
    if (call_intrinsic_p(c))
        return (check_call_intrinsic(la, lt, c));
 
    if ((int) gen_length(la) == 0)
        return (true);
 
    /* else */
    if (!check_call_types_compatibility(la, lt, c))
        return (false);
 
    /* else */
    if (call_constant_p(c))
        return (true);
 
    /* else */
    /* Errors in parameter modes are found out by effect computation.
     * A second check, later, is meaningless.
     */
    /* return (check_call_mode_consistency(la, lt, the_fnct)); */
 
    return true;
}

References BOOL_UNDEF, call_arguments, call_constant_p, call_function, call_intrinsic_p, check_call_args_number(), check_call_intrinsic(), check_call_types_compatibility(), entity_type, functional_parameters, gen_length(), type_functional, and type_functional_p.

Referenced by flint_call().

Here is the call graph for this function:

Here is the caller graph for this function:

check_the_reference()

void check_the_reference

(

reference

ref

)

Parameters

ref

ef

Definition at line 396 of file flint_check.c.

{
    list            the_indices = reference_indices(ref);
    int             i, len = gen_length(the_indices);
    basic           base;
    list            dims;
    entity          var = reference_variable(ref);
    type            tp = entity_type(var);
    int             len_ind = gen_length(the_indices), len_dim;
    bool            ok;
 
    ok = find_bd_type_variable(tp, &base, &dims);
    if (!ok)
        return;
 
    len_dim = gen_length(dims);
 
    if (len_dim < len_ind) {
        flint_message("reference",
                      "too many indices (%d>%d) in reference to %s\n",
                      len_ind, len_dim, entity_local_name(var));
        return;
    }
 
    if (len_dim > len_ind) {
        flint_message("reference",
                      "too few indices (%d<%d) in reference to %s\n",
                      len_ind, len_dim, entity_local_name(var));
        return;
    }
 
    if (basic_overloaded_p(base))
        return;
 
    for (i = 1; i <= len; i++) {
        if (control_type_in_expression(is_basic_overloaded, 1,
                                       EXPRESSION(CAR(the_indices))))
            flint_message("check reference: WARNING",
                          "the %dth index may not be a mere integer\n", i);
        else
            if (!control_type_in_expression(is_basic_int, 1,
                                            EXPRESSION(CAR(the_indices))))
                flint_message("check reference",
                          "the %dth index is not a mere integer\n", i);
 
        the_indices = CDR(the_indices);
    }
}

References base, basic_overloaded_p, CAR, CDR, control_type_in_expression(), entity_local_name(), entity_type, EXPRESSION, find_bd_type_variable(), flint_message(), gen_length(), is_basic_int, is_basic_overloaded, ok, ref, reference_indices, and reference_variable.

Referenced by flint_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

look_at_the_commons()

bool look_at_the_commons

(

entity

module

)

---

Parameters

module

odule

Definition at line 543 of file flint_check.c.

{
    list            ldecl = code_declarations(value_code(entity_initial(module)));
    entity          local;
 
    while (ldecl != NULL) {
        local = ENTITY(CAR(ldecl));
        ldecl = CDR(ldecl);
 
        if (type_area_p(entity_type(local))) {
            fprintf(stdout,
                    "common : %s, in module %s\n",
                    entity_name(local),
                    entity_name(module));
            if (!special_common(local)) {
                list            llayout = area_layout(type_area(entity_type(local)));
                while (llayout != NULL) {
 
                    fprintf(stdout, "variable %s at offset %td\n",
                            entity_name(ENTITY(CAR(llayout))),
                            ram_offset(storage_ram(entity_storage(ENTITY(CAR(llayout))))));
                    llayout = CDR(llayout);
                }
            }
        }
    }
    return (true);
}

References area_layout, CAR, CDR, code_declarations, ENTITY, entity_initial, entity_name, entity_storage, entity_type, fprintf(), module, ram_offset, special_common, storage_ram, type_area, type_area_p, and value_code.

Here is the call graph for this function:

position_in_the_area()

bool position_in_the_area	(	entity	the_var,
		intptr_t *	inf,
		intptr_t *	sup
	)

---

Parameters

the_var	he_var
inf	nf
sup	up

Definition at line 580 of file flint_check.c.

{
    basic           base;
    list            dims;
    intptr_t             len_unit = 0;
    intptr_t             nb_of_elements = 0;
 
    if (!find_bd_type_variable(entity_type(the_var), &base, &dims))
        return (false);
    if (!number_of_elements(dims, &nb_of_elements))
        return (false);
    if (!(basic_int_p(base) || basic_float_p(base) ||
          basic_logical_p(base) || basic_complex_p(base)))
        return (false);
 
    switch (basic_tag(base)) {
    case is_basic_int:{
            len_unit = basic_int(base);
            break;
        }
    case is_basic_float:{
            len_unit = basic_float(base);
            break;
        }
    case is_basic_logical:{
            len_unit = basic_logical(base);
            break;
        }
    case is_basic_complex:{
            len_unit = basic_complex(base);
            break;
        }
    default:
        pips_internal_error("unknown basic tag %d", basic_tag(base));
    }
 
    *inf = ram_offset(storage_ram(entity_storage(the_var)));
    *sup = (*inf) + (nb_of_elements * len_unit) - 1;
 
    return (true);
}

References base, basic_complex, basic_complex_p, basic_float, basic_float_p, basic_int, basic_int_p, basic_logical, basic_logical_p, basic_tag, entity_storage, entity_type, find_bd_type_variable(), intptr_t, is_basic_complex, is_basic_float, is_basic_int, is_basic_logical, number_of_elements(), pips_internal_error, ram_offset, and storage_ram.

Referenced by check_one_common().

Here is the call graph for this function:

Here is the caller graph for this function: