flint.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
bool	flinter (const string)
	Routine of global module verification More...
void	flint_message (char *, char *,...)
void	flint_message_2 (char *, char *,...)
	Same as flint_message but without the function name More...
void	raw_flint_message (bool, char *,...)
	Same as flint_message but a bare bones version More...
void	flint_cons_dimension (list)
	flint_walk.c More...
dimension	flint_dimension (dimension)
call	flint_call (call)
	This function checks the syntax of a call and recursively. More...
range	flint_range (range)
	This function verifies that incremented or decremented More...
reference	flint_reference (reference)
	A reference is used when given a function the address of. More...
void	flint_syntax (syntax)
	verification of syntaxes More...
void	flint_cons_expression (list)
	These two functions operate on the list of expressions More...
void	flint_cons_actual_argument (list)
expression	flint_expression (expression)
loop	flint_loop (loop)
	Recursive verification of a loop as (range)+(expression) More...
test	flint_test (test)
	A test is taken as (expression)+(statement)+(statement) More...
instruction	flint_instruction (instruction)
	Verification of an instruction with branching according More...
void	flint_unstructured (unstructured)
void	flint_cons_statement (list)
statement	flint_statement (statement)
bool	check_procedure (call)
	flint_check.c More...
bool	check_the_call (call)
bool	check_call_intrinsic (list, list, call)
bool	check_call_args_number (list, list, call)
bool	check_call_types_compatibility (list, list, call)
bool	check_call_one_type (expression, parameter, call, int)
bool	check_call_basic (basic, basic, call, int)
bool	check_call_dim (list, list, call, int)
	loose version More...
bool	check_call_basic_and_dim (expression, parameter, call, int)
void	check_the_reference (reference)
bool	check_call_mode_consistency (list, list, entity)
bool	check_call_one_mode (expression, parameter, entity, list, int)
	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)
bool	position_in_the_area (entity, intptr_t *, intptr_t *)
bool	check_commons (entity)
void	check_one_common (entity, entity)
bool	check_overlap_in_common (entity, entity, int, int, entity, int, int)
bool	number_of_elements (list, intptr_t *)
	flint_utils.c More...
bool	size_of_dimension (dimension, intptr_t *)
	this function computes the size of a dimension. More...
bool	control_type_in_expression (enum basic_utype, int, expression)
bool	find_bd_parameter (parameter, basic *, list *)
bool	find_bd_type_variable (type, basic *, list *)
bool	find_bd_expression (expression, basic *, list *)
bool	find_bd_reference (reference, basic *, list *)
bool	find_bd_call (call, basic *, list *)
void	flint_uninitialized_variables (graph, statement)
	uninitialized_variables.c More...

Variables
statement	flint_current_statement
	Warning! Do not modify this file that is automatically generated! More...

Function Documentation

check_call_args_number()

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

sometimes out...

Parameters

la	a
lt	t
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	,
		list	,
		call
	)

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

)

flint_check.c

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:

control_type_in_expression()

bool control_type_in_expression	(	enum	basic_utype,
		int	,
		expression
	)

Referenced by check_the_reference().

Here is the caller graph for this function:

find_bd_call()

bool find_bd_call	(	call	c,
		basic *	base,
		list *	dims
	)

Parameters

base	ase
dims	ims

Definition at line 191 of file flint_utils.c.

{
    entity          fct = call_function(c);
    type            tp = entity_type(fct);
 
    if (!type_functional_p(tp)) {
        flint_message("find_bd_call",
                      "very strange function encountered\n");
        return (false);
    }
    return (find_bd_type_variable(functional_result(type_functional(tp)), base, dims));
}

References base, call_function, entity_type, find_bd_type_variable(), flint_message(), functional_result, type_functional, and type_functional_p.

Referenced by find_bd_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

find_bd_expression()

bool find_bd_expression	(	expression	exp,
		basic *	base,
		list *	dims
	)

Parameters

exp	xp
base	ase
dims	ims

Definition at line 141 of file flint_utils.c.

{
    syntax          s = expression_syntax(exp);
    reference       re;
    call            c;
 
    switch (syntax_tag(s)) {
    case is_syntax_reference:
        re = syntax_reference(s);
        return (find_bd_reference(re, base, dims));
    case is_syntax_range:
        flint_message("find_bd_expression", "no basic in this expression\n");
        return (false);
    case is_syntax_call:
        c = syntax_call(s);
        return (find_bd_call(c, base, dims));
    default:
        FATAL("find_bd_expression : unexpected tag %u\n", syntax_tag(s));
    }
 
    return (false);
}

References base, exp, expression_syntax, FATAL, find_bd_call(), find_bd_reference(), flint_message(), is_syntax_call, is_syntax_range, is_syntax_reference, syntax_call, syntax_reference, and syntax_tag.

Referenced by check_call_basic_and_dim(), check_call_intrinsic(), and control_type_in_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

find_bd_parameter()

bool find_bd_parameter	(	parameter	param,
		basic *	base,
		list *	dims
	)

Parameters

param	aram
base	ase
dims	ims

Definition at line 116 of file flint_utils.c.

{
    type            tp = parameter_type(param);
    return (find_bd_type_variable(tp, base, dims));
}

References base, find_bd_type_variable(), and parameter_type.

Referenced by check_call_basic_and_dim().

Here is the call graph for this function:

Here is the caller graph for this function:

find_bd_reference()

bool find_bd_reference	(	reference	ref,
		basic *	base,
		list *	dims
	)

Parameters

ref	ef
base	ase
dims	ims

Definition at line 167 of file flint_utils.c.

{
    entity          var = reference_variable(ref);
    list            ind = reference_indices(ref);
    type            tp = entity_type(var);
    int             len_ind = gen_length(ind), len_dim, i;
    bool            ok;
 
    ok = find_bd_type_variable(tp, base, dims);
    if (!ok)
        return (false);
 
    len_dim = gen_length((*dims));
    if (len_dim < len_ind)
        return (false);
 
    for (i = 1; i <= len_ind; i++)
        (*dims) = CDR(*dims);
    return (true);
}

References base, CDR, entity_type, find_bd_type_variable(), gen_length(), ok, ref, reference_indices, and reference_variable.

Referenced by find_bd_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

find_bd_type_variable()

bool find_bd_type_variable	(	type	tp,
		basic *	base,
		list *	dims
	)

Parameters

tp	p
base	ase
dims	ims

Definition at line 125 of file flint_utils.c.

{
    if (!type_variable_p(tp)) {
        flint_message("find_bd_type_var",
                 "very strange type encountered, waiting for a variable\n");
        return (false);
    }
    *base = variable_basic(type_variable(tp));
    *dims = variable_dimensions(type_variable(tp));
 
    return (true);
}

References base, flint_message(), type_variable, type_variable_p, variable_basic, and variable_dimensions.

Referenced by check_overlap_in_common(), check_the_reference(), find_bd_call(), find_bd_parameter(), find_bd_reference(), and position_in_the_area().

Here is the call graph for this function:

Here is the caller graph for this function:

flint_call()

call flint_call

(

call

c

)

This function checks the syntax of a call and recursively.

verifies its arguments

Definition at line 74 of file flint_walk.c.

{
    list            la = call_arguments(c);
 
    check_the_call(c);
 
    gen_mapl((gen_iter_func_t)flint_cons_actual_argument, la);
 
    return (c);
}

References call_arguments, check_the_call(), flint_cons_actual_argument(), and gen_mapl().

Referenced by flint_instruction(), and flint_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

flint_cons_actual_argument()

void flint_cons_actual_argument

(

list

pc

)

An array actual argument may have no indices

Parameters

pc

c

Definition at line 158 of file flint_walk.c.

{
    expression e = EXPRESSION(CAR(pc));
 
    /* An array actual argument may have no indices */
    if(expression_reference_p(e)) {
        reference r = expression_reference(e);
 
        if(gen_length(reference_indices(r))!=0)
            flint_expression(e);
    }
    else {
        flint_expression(e);
    }
}

References CAR, EXPRESSION, expression_reference(), expression_reference_p(), flint_expression(), gen_length(), and reference_indices.

Referenced by flint_call().

Here is the call graph for this function:

Here is the caller graph for this function:

flint_cons_dimension()

void flint_cons_dimension

(

list

pc

)

flint_walk.c

flint_walk.c

extern char *current_module_name; unused and changed These two functions deal with the boundaries of finite
arrays, verifying their definition as expressions

Parameters

pc

c

Definition at line 52 of file flint_walk.c.

{
    flint_dimension(DIMENSION(CAR(pc)));
}

References CAR, DIMENSION, and flint_dimension().

Here is the call graph for this function:

flint_cons_expression()

void flint_cons_expression

(

list

pc

)

These two functions operate on the list of expressions

Parameters

pc

c

Definition at line 150 of file flint_walk.c.

{
    flint_expression(EXPRESSION(CAR(pc)));
}

References CAR, EXPRESSION, and flint_expression().

Referenced by flint_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

flint_cons_statement()

void flint_cons_statement

(

list

pc

)

Parameters

pc

c

Definition at line 269 of file flint_walk.c.

{
    flint_statement(STATEMENT(CAR(pc)));
}

References CAR, flint_statement(), and STATEMENT.

Referenced by flint_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

flint_dimension()

dimension flint_dimension

(

dimension

d

)

Definition at line 58 of file flint_walk.c.

{
    expression      el = dimension_lower(d);
    expression      eu = dimension_upper(d);
 
    flint_expression(el);
    flint_expression(eu);
 
    return (d);
}

References dimension_lower, dimension_upper, and flint_expression().

Referenced by flint_cons_dimension().

Here is the call graph for this function:

Here is the caller graph for this function:

flint_expression()

expression flint_expression

(

expression

e

)

Definition at line 174 of file flint_walk.c.

{
    syntax          s = expression_syntax(e);
 
    flint_syntax(s);
 
    return (e);
}

References expression_syntax, and flint_syntax().

Referenced by flint_cons_actual_argument(), flint_cons_expression(), flint_dimension(), flint_range(), and flint_test().

Here is the call graph for this function:

Here is the caller graph for this function:

flint_instruction()

instruction flint_instruction

(

instruction

i

)

Verification of an instruction with branching according

to its subclass as defined in the data structure

Definition at line 217 of file flint_walk.c.

{
    list            pc;
    test            t;
    loop            l;
    call            c;
    unstructured    u;
 
    switch (instruction_tag(i)) {
    case is_instruction_block:
        pc = instruction_block(i);
        gen_mapl((gen_iter_func_t)flint_cons_statement, pc);
        break;
    case is_instruction_test:
        t = instruction_test(i);
        flint_test(t);
        break;
    case is_instruction_loop:
        l = instruction_loop(i);
        flint_loop(l);
        break;
    case is_instruction_goto:
        break;
    case is_instruction_unstructured:
        u = instruction_unstructured(i);
        flint_unstructured(u);
        break;
    case is_instruction_call:
        c = instruction_call(i);
        (void) check_procedure(c);
        flint_call(c);
        break;
    default:
        FATAL("flint_instruction: unexpected tag %u\n", instruction_tag(i));
    }
 
    return (i);
}

References check_procedure(), FATAL, flint_call(), flint_cons_statement(), flint_loop(), flint_test(), flint_unstructured(), gen_mapl(), instruction_block, instruction_call, instruction_loop, instruction_tag, instruction_test, instruction_unstructured, is_instruction_block, is_instruction_call, is_instruction_goto, is_instruction_loop, is_instruction_test, and is_instruction_unstructured.

Referenced by flint_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

flint_loop()

loop flint_loop

(

loop

l

)

Recursive verification of a loop as (range)+(expression)

Definition at line 186 of file flint_walk.c.

{
    range           r = loop_range(l);
    statement       s = loop_body(l);
 
    flint_range(r);
    flint_statement(s);
 
    return (l);
}

References flint_range(), flint_statement(), loop_body, and loop_range.

Referenced by flint_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

flint_message()

void flint_message	(	char *	fun,
		char *	fmt,
			...
	)

print out remainder of message

Parameters

fun	un
fmt	mt

Definition at line 147 of file flint.c.

{
    va_list         args;
    int             order;
 
    va_start(args, fmt);
 
    /*
     * print name of function causing message, and in which module it
     * occured.
     */
 
    no_message = false;
    number_of_messages++;
 
    order = statement_ordering(flint_current_statement);
 
    (void) fprintf(flint_messages_file,
                   "flint message from %s, in module %s, in statement (%d.%d), number %td\n",
                   fun, flint_current_module_name,
                   ORDERING_NUMBER(order), ORDERING_STATEMENT(order),
                   statement_number(flint_current_statement));
 
 
    /* print out remainder of message */
    (void) vfprintf(flint_messages_file, fmt, args);
 
    va_end(args);
 
}

References flint_current_module_name, flint_current_statement, flint_messages_file, fprintf(), no_message, number_of_messages, ORDERING_NUMBER, ORDERING_STATEMENT, statement_number, and statement_ordering.

Referenced by check_call_args_number(), check_call_basic(), check_call_dim(), check_call_one_mode(), check_one_common(), check_procedure(), check_the_reference(), control_type_in_expression(), find_bd_call(), find_bd_expression(), and find_bd_type_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

flint_message_2()

void flint_message_2	(	char *	fun,
		char *	fmt,
			...
	)

Same as flint_message but without the function name

print out remainder of message

Parameters

fun	un
fmt	mt

Definition at line 183 of file flint.c.

{
    va_list         args;
 
    va_start(args, fmt);
 
    no_message = false;
    number_of_messages++;
 
    (void) fprintf(flint_messages_file,
                   "flint message from %s, in module %s\n",
                   fun, flint_current_module_name);
 
    /* print out remainder of message */
    (void) vfprintf(flint_messages_file, fmt, args);
 
    va_end(args);
 
}

References flint_current_module_name, flint_messages_file, fprintf(), no_message, and number_of_messages.

Referenced by check_overlap_in_common().

Here is the call graph for this function:

Here is the caller graph for this function:

flint_range()

range flint_range

(

range

r

)

This function verifies that incremented or decremented

loop(for) indices do not overflow or underflow their
limits

Definition at line 90 of file flint_walk.c.

{
    expression      el = range_lower(r);
    expression      eu = range_upper(r);
    expression      ei = range_increment(r);
 
    flint_expression(el);
    flint_expression(eu);
    flint_expression(ei);
 
    return (r);
}

References flint_expression(), range_increment, range_lower, and range_upper.

Referenced by flint_loop(), and flint_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

flint_reference()

reference flint_reference

(

reference

r

)

A reference is used when given a function the address of.

an element instead of its value.

Definition at line 107 of file flint_walk.c.

{
    list            pc = reference_indices(r);
 
    (void) check_the_reference(r);
 
    gen_mapl((gen_iter_func_t)flint_cons_expression, pc);
 
    return (r);
}

References check_the_reference(), flint_cons_expression(), gen_mapl(), and reference_indices.

Referenced by flint_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

flint_statement()

statement flint_statement

(

statement

s

)

Definition at line 278 of file flint_walk.c.

{
    instruction     
        i = statement_instruction(s);
    statement       
        saved = flint_current_statement;
    
    flint_current_statement = s;
    
    flint_instruction(i);
    
    flint_current_statement = saved;
    return (s);
}

References flint_current_statement, flint_instruction(), and statement_instruction.

Referenced by flint_cons_statement(), flint_loop(), flint_test(), flint_unstructured(), and flinter().

Here is the call graph for this function:

Here is the caller graph for this function:

flint_syntax()

void flint_syntax

(

syntax

s

)

verification of syntaxes

branch according to the syntax subclass

Definition at line 121 of file flint_walk.c.

{
    reference       re;
    range           ra;
    call            c;
 
    /* branch according to the syntax subclass */
    switch (syntax_tag(s)) {
    case is_syntax_reference:
        re = syntax_reference(s);
        flint_reference(re);
        break;
    case is_syntax_range:
        ra = syntax_range(s);
        flint_range(ra);
        break;
    case is_syntax_call:
        c = syntax_call(s);
        flint_call(c);
        break;
    default:
        FATAL("flint_syntax: unexpected tag %u\n", syntax_tag(s));
    }
}

References FATAL, flint_call(), flint_range(), flint_reference(), is_syntax_call, is_syntax_range, is_syntax_reference, syntax_call, syntax_range, syntax_reference, and syntax_tag.

Referenced by flint_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

flint_test()

test flint_test

(

test

t

)

A test is taken as (expression)+(statement)+(statement)

Definition at line 200 of file flint_walk.c.

{
    expression      e = test_condition(t);
    statement       st = test_true(t);
    statement       sf = test_false(t);
 
    flint_expression(e);
    flint_statement(st);
    flint_statement(sf);
 
    return (t);
}

References flint_expression(), flint_statement(), test_condition, test_false, and test_true.

Referenced by flint_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

flint_uninitialized_variables()

void flint_uninitialized_variables	(	graph	dependence_graph,
		statement	module_stat
	)

uninitialized_variables.c

uninitialized_variables.c

Parameters

dependence_graph	ependence_graph
module_stat	odule_stat

Definition at line 210 of file uninitialized_variables.c.

{
    flint_initialize_statement_def_use_variables(dependence_graph);
    flint_no_uninitialized_variable_ouput_yet = true;
    
    gen_recurse(module_stat,
                statement_domain,
                flint_check_uninitialized_variables_in_statement,
                gen_null);
    
    if (!flint_no_uninitialized_variable_ouput_yet)
        raw_flint_message(false,
                          "\n");
    
    flint_free_statement_def_use_variables();
}

References dependence_graph, flint_check_uninitialized_variables_in_statement(), flint_free_statement_def_use_variables(), flint_initialize_statement_def_use_variables(), flint_no_uninitialized_variable_ouput_yet, gen_null(), gen_recurse, raw_flint_message(), and statement_domain.

Referenced by flinter().

Here is the call graph for this function:

Here is the caller graph for this function:

flint_unstructured()

void flint_unstructured

(

unstructured

u

)

Definition at line 257 of file flint_walk.c.

{
    list            blocs = NIL;
 
    CONTROL_MAP(c, {
        flint_statement(control_statement(c));
    }, unstructured_control(u), blocs);
 
    gen_free_list(blocs);
}

References CONTROL_MAP, control_statement, flint_statement(), gen_free_list(), NIL, and unstructured_control.

Referenced by flint_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

flinter()

bool flinter

(

const

string

)

Routine of global module verification

user_error() is not used in flint, no need for an exception handler

Getting parsed code of module

the last parameter should be pure=true; the code should not be modified!

Resource to trace uninitialized variables:

what is done

checking commons

checking syntax

final message

Should have worked:

Parameters

string

odule_name

Definition at line 54 of file flint.c.

{
    graph dependence_graph;
    entity module = local_name_to_top_level_entity(module_name);
    statement module_stat;
    string localfilename = NULL;
    string filename = NULL;
    
    /* user_error() is not used in flint, no need for an exception handler */
 
    debug_on("FLINT_DEBUG_LEVEL");
 
    flint_current_module_name = module_name;
    flint_current_statement = statement_undefined;
    number_of_messages = 0;
    no_message = true;
 
    debug(1, "flinter", "flinting module %s\n", module_name);
    
    /* Getting parsed code of module */
    /* the last parameter should be pure=true; the code should not be modified! */
    module_stat = (statement)
        db_get_memory_resource(DBR_CODE, module_name, true);
 
    /* Resource to trace uninitialized variables: */
    dependence_graph =
        (graph) db_get_memory_resource(DBR_CHAINS, module_name, true);
    set_ordering_to_statement(module_stat);
 
    set_proper_rw_effects((statement_effects)
                          db_get_memory_resource(DBR_PROPER_EFFECTS,
                                                 module_name,
                                                 true)); 
    set_current_module_statement(module_stat);
    set_current_module_entity(local_name_to_top_level_entity(module_name));
 
    localfilename = db_build_file_resource_name(DBR_FLINTED_FILE,
                                                module_name,
                                                ".flinted");
    filename = strdup(concatenate(db_get_current_workspace_directory(), 
                                  "/", localfilename, NULL));
    flint_messages_file = 
        (FILE *) safe_fopen(filename, "w");
 
    /* what is  done */
    pips_debug(3, "checking uninitialized variables\n");
    flint_uninitialized_variables(dependence_graph, module_stat);
 
    debug(3, "flinter", "checking commons\n");
    check_commons(module);               /* checking commons */
 
    debug(3, "flinter", "checking statements\n");
    flint_statement(module_stat);        /* checking syntax  */
 
    if (no_message)                      /* final message */
      fprintf(flint_messages_file,
              "%s has been flinted : everything is ok.\n",
              module_name);
    else
      fprintf(flint_messages_file,
              "number of messages from flint for %s : %d\n",
              module_name,
              number_of_messages);
    
    safe_fclose(flint_messages_file, filename);
    DB_PUT_FILE_RESOURCE(DBR_FLINTED_FILE, strdup(module_name),
                         localfilename);
    free(filename);
 
    flint_current_module_name = NULL;
    flint_current_statement = statement_undefined;
    number_of_messages = 0;
    no_message = true;
 
    reset_proper_rw_effects();
    reset_current_module_statement();
    reset_current_module_entity();
        reset_ordering_to_statement();
 
    debug_off();
 
    /* Should have worked: */
    return true;
}

References check_commons(), concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_FILE_RESOURCE, debug(), debug_off, debug_on, dependence_graph, flint_current_module_name, flint_current_statement, flint_messages_file, flint_statement(), flint_uninitialized_variables(), fprintf(), free(), local_name_to_top_level_entity(), module, module_name(), no_message, number_of_messages, pips_debug, reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_proper_rw_effects(), safe_fclose(), safe_fopen(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_proper_rw_effects(), statement_undefined, and strdup().

Here is the call 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:

number_of_elements()

bool number_of_elements	(	list	ld,
		intptr_t *	the_result
	)

flint_utils.c

Parameters

ld	d
the_result	he_result

Definition at line 50 of file flint_utils.c.

{
    list            pc;
    intptr_t             a_temp_int;
    bool            ok = true;
 
    (*the_result) = 1;
 
    for (pc = ld;
         (pc != NULL) && (ok = size_of_dimension(DIMENSION(CAR(pc)), &a_temp_int));
         pc = CDR(pc)) {
        (*the_result) *= a_temp_int;
    }
 
    return (ok);
}

References CAR, CDR, DIMENSION, intptr_t, ok, and size_of_dimension().

Referenced by check_call_dim(), control_type_in_expression(), make_emulated_shared_variable(), and position_in_the_area().

Here is the call graph for this function:

Here is the caller 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:

raw_flint_message()

void raw_flint_message	(	bool	count,
		char *	fmt,
			...
	)

Same as flint_message but a bare bones version

count is used to decide if we count tjis message or not.

Parameters

count	ount
fmt	mt

Definition at line 211 of file flint.c.

{
    va_list         args;
 
    va_start(args, fmt);
 
    no_message = false;
    if (count)
        number_of_messages++;
 
    (void) vfprintf(flint_messages_file, fmt, args);
 
    va_end(args);
}

References count, flint_messages_file, no_message, and number_of_messages.

Referenced by flint_check_uninitialized_variables_in_statement(), and flint_uninitialized_variables().

Here is the caller graph for this function:

size_of_dimension()

bool size_of_dimension	(	dimension	d,
		intptr_t *	the_int
	)

this function computes the size of a dimension.

else

Parameters

the_int

he_int

Definition at line 71 of file flint_utils.c.

{
    intptr_t             upper_dim, lower_dim;
 
    if (expression_integer_value(dimension_upper(d), &upper_dim) &&
        expression_integer_value(dimension_lower(d), &lower_dim)) {
        (*the_int) = upper_dim - lower_dim + 1;
        return (true);
    }
    /* else */
    return (false);
}

References dimension_lower, dimension_upper, expression_integer_value(), and intptr_t.

Referenced by number_of_elements().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

flint_current_statement

statement flint_current_statement

extern

Warning! Do not modify this file that is automatically generated!

cproto-generated files

Modify src/Libs/flint/flint-local.h instead, to add your own modifications. header file built by cproto flint-local.h

flint.c

Warning! Do not modify this file that is automatically generated!

flint.c

Definition at line 35 of file flint.h.