25 #include "pips_config.h"
50 #include "constants.h"
58 #include "resources.h"
83 static bool contract_p =
true;
104 error_reset_current_downward_cumulated_range_effects_stack();
112 if(! current_downward_cumulated_range_effects_empty_p())
115 (current_downward_cumulated_range_effects_head());
117 return(l_cumu_range);
121 free_cumu_range_effects()
123 if(! current_downward_cumulated_range_effects_empty_p())
124 free_effects(current_downward_cumulated_range_effects_head());
154 static list generic_r_proper_effects_of_derived_reference(
effect input_eff,
type input_type)
183 effect current_eff = (*effect_dup_func)(input_eff);
199 le =
gen_nconc(generic_r_proper_effects_of_derived_reference(current_eff, current_type),le);
243 effect eff = (*reference_to_effect_func)(
250 le = generic_r_proper_effects_of_derived_reference(eff, t);
263 list l_ind = l_ind_orig;
273 pips_debug(4,
"reference %s to entity %s of basic %s and"
274 " number of dimensions %d.\n",
285 pips_debug(8,
"it's a pointer type. l_dim_tmp = %d, "
300 pips_debug(8,
"l_dim_tmp = %d, l_inds_tmp = %d\n",
304 while (!
ENDP(l_dim_tmp))
314 pips_debug(4,
"adding a read effect on reference %s\n",
335 pips_debug(4,
"adding an index for pointer dimension \n");
376 bool allow_partials_on_pme)
382 list l_inds_tmp = l_inds;
398 pips_debug(4,
"reference %s to entity %s of basic %s and"
399 " number of dimensions %d.\n",
410 pips_debug(8,
"it's a pointer type. l_dim_tmp = %d, "
425 pips_debug(8,
"l_dim_tmp = %d, l_inds_tmp = %d\n",
429 while (!
ENDP(l_dim_tmp))
439 pips_debug(4,
"adding a read effect on reference %s\n",
458 if(!
ENDP(l_inds_tmp))
460 pips_debug(4,
"adding an index for pointer dimension \n");
478 || allow_partials_on_pme
482 (allow_partials_on_pme ||
490 *pme = (*reference_to_effect_func)(
ref, a,
true);
514 *pme = (*reference_to_effect_func)(
536 "(e.g. a non-subscribed reference to an array)\n");
685 (*effects_precondition_composition_op)(le,
context,
false);
724 static list generic_proper_effects_of_complex_address_field_op(
list l_args,
list *l_pme,
int write_p)
741 (struct_exp, l_pme, write_p);
765 static
list generic_proper_effects_of_complex_address_point_to_op(
list l_args,
list *l_pme,
int write_p)
837 static
list generic_proper_effects_of_complex_address_pre_update_dereferencing_op(
entity op,
expression e1,
list *l_pme,
int write_p)
874 (e1, l_pme, write_p);
881 pips_debug(4,
"It's a pointer; we add a read and write effect \n");
887 effect eff_read = (*effect_dup_func)(pme);
894 effect eff_write = (*effect_dup_func)(pme);
914 pips_debug(8,
"*(p+q) case, with p = %s and q = %s\n",
945 pips_debug(8,
"p is itself a complicated expression, with e11 = %s and e22 = %s\n",
951 pips_user_warning(
"Pips does not currently handle this complicated arithmetic pointer expression\n");
964 (e1, l_pme, write_p);
992 pips_debug(4,
"It's a pointer; we add a read effect \n");
998 eff_read = (*effect_dup_func)(pme);
1004 (*effect_add_expression_dimension_func)(pme, current_e2);
1019 (*effect_add_expression_dimension_func)(pme, current_e2);
1023 pips_user_warning(
"Pips does not precisely handle linearized array references\n");
1088 (deref_exp, l_pme,
false);
1121 "PIPS doesn't know how to handled that precisely\n");
1143 pips_debug(4,
"adding a read effect on dereferenced expression\n");
1152 pips_debug(8,
"adding read effect on argument \n");
1157 eff_read = (*effect_dup_func)(pme);
1165 pips_debug(8,
"adding dereferencing dimension \n");
1209 effect e1 = (*reference_to_effect_func)(r1, a1,
true);
1233 static list generic_proper_effects_of_complex_address_call_dereferencing_op(
entity s_op,
list s_args,
expression deref_exp,
list *l_pme,
int write_p)
1239 pips_debug(4,
"The dereferenced expression is a call itself (%s)\n",
1253 le = generic_proper_effects_of_complex_address_addition_dereferencing_op(e1, e2, l_pme, write_p);
1262 le = generic_proper_effects_of_complex_address_post_update_dereferencing_op(s_op, e1, l_pme, write_p);
1268 le = generic_proper_effects_of_complex_address_pre_update_dereferencing_op(s_op, e1, l_pme, write_p);
1285 le = generic_proper_effects_of_complex_address_default_call_dereferencing_op(s_op, s_args, deref_exp, l_pme, write_p);
1290 le = generic_proper_effects_of_complex_address_default_call_dereferencing_op(s_op, s_args, deref_exp, l_pme, write_p);
1295 le = generic_proper_effects_of_complex_address_default_call_dereferencing_op(s_op, s_args, deref_exp, l_pme, write_p);
1306 le = generic_proper_effects_of_complex_address_default_call_dereferencing_op(s_op, s_args, deref_exp, l_pme, write_p);
1342 static list generic_proper_effects_of_complex_address_default_dereferencing_op(
expression deref_exp,
list *l_pme,
int write_p)
1345 (deref_exp, l_pme, write_p);
1350 "PIPS doesn't know how to handle that precisely\n");
1366 pips_debug(4,
"adding a read effect on dereferenced expression\n");
1375 pips_debug(8,
"adding read effect on argument \n");
1380 eff_read = (*effect_dup_func)(pme);
1388 pips_debug(8,
"adding dereferencing dimension \n");
1402 static list generic_proper_effects_of_complex_address_dereferencing_op(
list l_args,
list *l_pme,
int write_p)
1415 le = generic_proper_effects_of_complex_address_call_dereferencing_op(s_op, s_args, deref_exp, l_pme, write_p);
1426 pips_debug(4,
"The dereferenced expression is a va_arg\n");
1448 pips_debug(4,
"The dereferenced expression is not a call, nor a va_arg, nor a cast itself: we go down recursively\n");
1449 le = generic_proper_effects_of_complex_address_default_dereferencing_op(deref_exp, l_pme, write_p);
1502 pips_debug(4,
"Dereferencing a cast expression \n");
1538 effect read_eff = (*effect_dup_func)(eff);
1562 "complex cast expressions\n");
1572 "PIPS doesn't know how to handled that precisely\n");
1582 le = generic_proper_effects_of_complex_address_dereferencing_op(args, l_pme, write_p);
1672 static list generic_proper_effects_of_complex_address_call_expression(
expression call_exp,
list *l_pme,
int write_p)
1687 le = generic_proper_effects_of_complex_address_field_op(args, l_pme, write_p);
1691 pips_debug(4,
"Call is a point to operator\n");
1692 le = generic_proper_effects_of_complex_address_point_to_op(args, l_pme, write_p);
1696 pips_debug(4,
"Call is a dereferencing operator \n");
1697 le = generic_proper_effects_of_complex_address_dereferencing_op(args, l_pme, write_p);
1701 pips_debug(4,
"Call is a conditional operator\n");
1708 pips_debug(4,
"Call is an assignment operator\n");
1713 pips_debug(4,
"Call is an address-of operator\n");
1723 pips_debug(4,
"Call is an update operator\n");
1737 "address values used in complex call expressions expression\n");
1746 pips_debug(8,
"constant return value: -> no main effects\n");
1757 static list generic_proper_effects_of_complex_address_cast_expression(
cast c,
list *l_pme,
int write_p
__attribute__((unused)))
1762 pips_user_warning(
"Property ALIASING_ACROSS_TYPE should be set to true because casts are used in the source code.\n");
1769 pips_user_warning(
"Cast impact on pointer arithmetic and indexing is ignored\n");
1780 pips_debug(8,
"We go down recursively on the cast expression \n");
1783 (cast_exp, l_pme, write_p));
1794 static list generic_proper_effects_of_complex_address_subscript_expression(
subscript subsc,
list *l_pme,
int write_p)
1803 pips_debug(8,
"We go down recursively on the subscripted expression \n");
1805 (subsc_exp, l_pme, write_p);
1820 effect eff_read = (*effect_dup_func)(pme);
1822 pips_debug(5,
"adding read effect on array expression\n");
1836 (*effect_add_expression_dimension_func)(pme, ind_exp);
1848 static list generic_proper_effects_of_complex_address_va_arg_expression(
list __attribute__((unused)) v,
list *l_pme,
int write_p)
1931 le = generic_proper_effects_of_complex_address_call_expression(add_exp, l_pme, write_p);
1936 le = generic_proper_effects_of_complex_address_cast_expression(
syntax_cast(s), l_pme, write_p);
1942 le = generic_proper_effects_of_complex_address_subscript_expression(
syntax_subscript(s), l_pme, write_p);
1947 le = generic_proper_effects_of_complex_address_va_arg_expression(
syntax_va_arg(s), l_pme, write_p);
2010 *lpme =
gen_nconc(generic_r_proper_effects_of_derived_reference(pme, addexp_t), *lpme);
2015 pips_debug(8,
"main effect is on array name \n");
2033 (*effects_precondition_composition_op)(*lpme,
context,
false);
2097 list l_tmp = generic_r_proper_effects_of_derived_reference(e, addexp_t);
2105 pips_debug(8,
"main read effect is on array name : discarded\n");
2127 (*effects_precondition_composition_op)(le,
context,
false);
2134 pips_debug(8,
"Effect for a call or a subscripted expression:\n");
2135 (*effects_prettyprint_func)(le);
2141 pips_user_error(
"use of cast expressions as lvalues is deprecated\n");
2152 pips_user_error(
"use of indirect function call as lhs is not allowed\n");
2163 (*effects_prettyprint_func)(le);
2201 (*effects_precondition_composition_op)(le,
context,
false);
2212 pips_user_warning(
"Effect of indirect calls not implemented -> returning anywhere\n");
2351 pips_debug(8,
"Proper effects of expression \"%s\":\n",
2353 (*effects_prettyprint_func)(le);
2397 bool check_p =
true;
2403 for(ce = func_sdfi; !
ENDP(ce);
POP(ce)) {
2414 if(called_function!=func) {
2415 fprintf(stderr,
"Summary effect %p for function \"%s\" refers to "
2416 "formal parameter \"%s\" of function \"%s\"\n",
2422 fprintf(stderr,
"Formal parameter \"%s\" is ranked %d out of %zd!\n",
2432 generic_proper_effects_of_external(
entity func,
list args)
2437 pips_debug(4,
"translating effects for %s\n", func_name);
2449 func_eff = (*db_get_summary_rw_effects_func)(func_name);
2533 le = generic_proper_effects_of_external(e, pc);
2588 proper_effects_of_call(
call c)
2597 pips_debug(2,
"Effects for statement %03zd:\n",
2608 pips_debug(2,
"Proper effects for statement %03zd:\n",
2610 (*effects_prettyprint_func)(l_proper);
2640 list l_tmp = l_proper;
2650 static void proper_effects_of_expression_instruction(
instruction i)
2711 pips_user_warning(
"call through a function pointer in a structure -> anywhere effects\n");
2733 pips_debug(2,
"Effects for expression instruction in statement%03zd:\n",
2741 pips_debug(2,
"Proper effects for statement%03zd:\n",
2743 (*effects_prettyprint_func)(l_proper);
2760 list l_tmp = l_proper;
2780 current_downward_cumulated_range_effects_push(
make_effects(l_eff));
2784 static void proper_effects_of_loop(
loop l)
2794 pips_debug(2,
"Effects for statement%03zd:\n",
2797 free_cumu_range_effects();
2798 current_downward_cumulated_range_effects_pop();
2829 pips_debug(2,
"Proper effects for statement%03zd:\n",
2831 (*effects_prettyprint_func)(l_proper);
2846 list l_tmp = l_proper;
2853 static void proper_effects_of_forloop(
forloop l)
2863 pips_debug(2,
"Effects for statement%03zd:\n",
2891 pips_debug(2,
"Proper effects for statement%03zd:\n",
2893 (*effects_prettyprint_func)(l_proper);
2902 list l_tmp = l_proper;
2909 static void proper_effects_of_while(
whileloop w)
2916 list l_tmp = l_proper;
2924 static void proper_effects_of_test(
test t)
2929 pips_debug(2,
"Effects for statement%03zd:\n",
2938 pips_debug(2,
"Proper effects for statement%03zd:\n",
2940 (*effects_prettyprint_func)(l_proper);
2948 list l_tmp = l_proper;
2964 pips_debug(1,
"Entering statement with ordering: %03zd and number: %03zd\n",
3062 static list generic_proper_effects_of_declaration(
entity decl)
3164 static void proper_effects_of_statement(
statement s)
3194 l_eff =
gen_nconc(l_eff, generic_proper_effects_of_declaration(e));
3215 pips_debug(2,
"Warning, proper effects undefined, set to NIL\n");
3230 make_current_downward_cumulated_range_effects_stack();
3254 free_current_downward_cumulated_range_effects_stack();
3282 debug_on(
"PROPER_EFFECTS_DEBUG_LEVEL");
3331 debug_on(
"PROPER_EFFECTS_DEBUG_LEVEL");
float a2sf[2] __attribute__((aligned(16)))
USER generates a user error (i.e., non fatal) by printing the given MSG according to the FMT.
action make_action_read(action_kind _field_)
action_kind make_action_kind_environment(void)
cell make_cell_reference(reference _field_)
void free_effect(effect p)
action_kind make_action_kind_type_declaration(void)
effects make_effects(list a)
approximation make_approximation_exact(void)
action make_action_write(action_kind _field_)
void free_action(action p)
effect make_effect(cell a1, action a2, approximation a3, descriptor a4)
void free_effects(effects p)
descriptor make_descriptor_none(void)
void free_descriptor(descriptor p)
cast make_cast(type a1, expression a2)
void free_reference(reference p)
expression copy_expression(expression p)
EXPRESSION.
reference make_reference(entity a1, list a2)
void free_expression(expression p)
reference copy_reference(reference p)
REFERENCE.
syntax make_syntax_cast(cast _field_)
static reference ref
Current stmt (an integer)
static bool stmt_filter(statement s)
modifies global var current_caller_stmt
void const char const char const int
static bool loop_filter(loop l)
static bool written_p(entity e)
#define pips_debug_effects(level, message, l_eff)
#define pips_debug_effect(level, message, eff)
for debug
void free_effects_private_current_context_stack(void)
list make_anywhere_read_write_memory_effects(void)
list generic_proper_effects_of_complex_address_expression(expression, list *, int)
bool effects_private_current_context_empty_p(void)
void error_reset_effects_private_current_stmt_stack(void)
void proper_effects_error_handler(void)
bool effect_pointer_type_p(effect)
list generic_proper_effects_of_complex_address_dereferencing_cast_op(list, list *, bool)
void effects_to_may_effects(list)
list old_generic_proper_effects_of_complex_address_conditional_op(list, list *, bool)
list generic_proper_effects_of_address_expression(expression, int)
effect make_anywhere_effect(action)
transformer effects_private_current_context_head(void)
bool(* empty_context_test)(transformer)
list generic_proper_effects_of_complex_address_update_op(list, list *, bool)
void make_effects_private_current_context_stack(void)
void effect_add_dereferencing_dimension(effect)
transformer(* load_context_func)(statement)
list generic_proper_effects_of_read_reference(reference)
void make_effects_private_current_stmt_stack(void)
utils.c
list generic_proper_effects_of_complex_address_cast_dereferencing_op(cast, expression, list *, bool)
list generic_proper_effects_of_range(range)
list generic_proper_effects_of_reference(reference, bool)
list generic_r_proper_effects_of_call(call)
list generic_proper_effects_of_complex_address_assign_dereferencing_op(expression, expression, list *, bool)
list type_to_effects(type)
pointer_info_val get_pointer_info_kind(void)
list proper_effects_contract(list)
void store_proper_rw_effects_list(statement, list)
void expression_proper_effects_engine(const char *, statement)
void proper_effects_of_module_statement(statement)
void update_proper_rw_effects_list(statement, list)
list generic_proper_effects_of_complex_memory_access_expression(expression, list *, list *, int)
list generic_proper_effects_of_written_reference(reference)
list load_proper_rw_effects_list(statement)
bool bound_proper_rw_effects_p(statement)
list generic_proper_effects_of_any_lhs(expression)
effect(* reference_to_effect_func)(reference, action, bool)
statement effects_private_current_stmt_pop(void)
bool expr_prw_effects_undefined_p(void)
bool region_weakly_consistent_p(effect)
effect make_declaration_effect(entity, bool)
bool regions_weakly_consistent_p(list)
void error_reset_effects_private_current_context_stack(void)
bool bound_expr_prw_effects_p(expression)
void reset_proper_rw_effects(void)
void free_effects_private_current_stmt_stack(void)
list recursive_type_to_effects(type, set)
list generic_proper_effects_of_complex_address_address_of_dereferencing_op(expression, list *, bool)
void init_proper_rw_effects(void)
list generic_proper_effects_of_derived_reference(reference, bool)
list generic_effects_backward_translation(entity, list, list, transformer)
bool effects_private_current_context_stack_initialized_p(void)
bool check_sdfi_effects_p(entity, list)
statement effects_private_current_stmt_head(void)
list generic_proper_effects_of_complex_address_assign_op(list, list *, bool)
list generic_proper_effects_of_c_function_call_argument(expression)
list generic_proper_effects_of_subscript(subscript)
void effects_private_current_stmt_push(statement)
void effect_to_may_effect(effect)
list generic_intermediary_proper_effects_of_reference(reference)
list generic_p_proper_effect_of_reference(reference, effect *, bool, bool)
void set_contracted_proper_effects(bool)
end of effects-generic-local.h
bool get_constant_paths_p(void)
effect make_typed_anywhere_effect(action, type)
list new_generic_proper_effects_of_complex_address_conditional_op(list, list *, bool)
list generic_proper_effects_of_complex_address_conditional_dereferencing_op(expression, expression, expression, list *, bool)
type simple_effect_reference_type(reference)
list generic_proper_effects_of_expression(expression)
void effect_to_read_effect(effect)
list generic_proper_effects_of_application(application)
effect(* effect_dup_func)(effect eff)
transformer effects_private_current_context_pop(void)
void effects_private_current_context_push(transformer)
list pointer_effects_to_constant_path_effects(list)
list effect_to_list(effect)
bool proper_effects_engine(const char *)
void effect_add_field_dimension(effect, entity)
void init_expr_prw_effects(void)
list generic_proper_effects_of_intrinsic(entity, list)
intrinsics.c
list generic_effect_generate_all_accessible_paths_effects(effect, type, tag)
void store_expr_prw_effects(expression, effects)
statement_effects get_proper_rw_effects(void)
list generic_proper_effects_of_expressions(list)
#define effect_any_reference(e)
FI: cannot be used as a left hand side.
action make_action_write_memory(void)
To ease the extension of action with action_kind.
bool effect_list_consistent_p(list)
Debugging.
void set_pt_to_list(statement_points_to)
bool effects_all_read_p(list)
Check that all effects in el are read effects.
bool anywhere_effect_p(effect)
Is it an anywhere effect? ANYMMODULE:ANYWHERE
void reset_pt_to_list(void)
action make_action_read_memory(void)
bool types_compatible_for_effects_interprocedural_translation_p(type, type)
tests if the actual argument type and the formal argument type are compatible with the current state ...
#define effect_undefined_p(x)
#define action_kind_undefined
#define effect_descriptor(x)
#define effects_effects(x)
#define descriptor_undefined
#define effect_action_(x)
const char * module_name(const char *s)
Return the module part of an entity name.
bool get_bool_property(const string)
FC 2015-07-20: yuk, moved out to prevent an include cycle dependency include "properties....
void gen_full_free_list(list l)
void reset_current_module_entity(void)
Reset the current module entity.
void reset_current_module_statement(void)
Reset the current module statement.
statement set_current_module_statement(statement)
Set the current module statement.
statement get_current_module_statement(void)
Get the current module statement.
entity set_current_module_entity(entity)
static.c
entity get_current_module_entity(void)
Get the entity of the current module.
void gen_multi_recurse(void *o,...)
Multi recursion visitor function.
bool gen_false(__attribute__((unused)) gen_chunk *unused)
Return false and ignore the argument.
void gen_null(__attribute__((unused)) void *unused)
Ignore the argument.
bool gen_true(__attribute__((unused)) gen_chunk *unused)
Return true and ignore the argument.
#define ENDP(l)
Test if a list is empty.
list gen_nreverse(list cp)
reverse a list in place
#define POP(l)
Modify a list pointer to point on the next element of the list.
#define NIL
The empty list (nil in Lisp)
size_t gen_length(const list l)
#define CONS(_t_, _i_, _l_)
List element cell constructor (insert an element at the beginning of a list)
list gen_nconc(list cp1, list cp2)
physically concatenates CP1 and CP2 but do not duplicates the elements
#define CAR(pcons)
Get the value of the first element of a list.
void gen_free_list(list l)
free the spine of the list
#define FOREACH(_fe_CASTER, _fe_item, _fe_list)
Apply/map an instruction block on all the elements of a list.
#define CDR(pcons)
Get the list less its first element.
#define list_undefined
Undefined list definition :-)
list gen_full_copy_list(list l)
Copy a list structure with element copy.
string db_get_memory_resource(const char *rname, const char *oname, bool pure)
Return the pointer to the resource, whatever it is.
bool format_statement_p(statement)
Test if a statement is a Fortran FORMAT.
bool statement_may_have_control_effects_p(statement)
bool declaration_statement_p(statement)
Had to be optimized according to Beatrice Creusillet.
#define pips_debug
these macros use the GNU extensions that allow variadic macros, including with an empty list.
#define pips_user_warning
#define pips_assert(what, predicate)
common macros, two flavors depending on NDEBUG
#define pips_internal_error
#define DEFINE_LOCAL_STACK(name, type)
bool set_belong_p(const set, const void *)
set set_make(set_type)
Create an empty set of any type but hash_private.
set set_add_element(set, const set, const void *)
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
void set_pv(statement_cell_relations)
statement_cell_relations db_get_simple_pv(const char *)
I don't know how to deal with these mappings if we have to analyse several modules at the same time w...
void print_expressions(list le)
string reference_to_string(reference r)
void print_expression(expression e)
no file descriptor is passed to make is easier to use in a debugging stage.
string expression_to_string(expression e)
list Words_Syntax(syntax obj)
string string_of_type(const type)
void print_type(type)
For debugging.
string basic_to_string(basic)
static hash_table pl
properties are stored in this hash table (string -> property) for fast accesses.
#define ENTITY_ASSIGN_P(e)
#define ENTITY_DEREFERENCING_P(e)
#define ENTITY_POINT_TO_P(e)
#define ENTITY_PRE_DECREMENT_P(e)
#define ENTITY_POST_DECREMENT_P(e)
#define ENTITY_POST_INCREMENT_P(e)
#define ENTITY_CONDITIONAL_P(e)
#define ENTITY_PRE_INCREMENT_P(e)
#define ENTITY_PLUS_C_P(e)
#define entity_variable_p(e)
An entity_variable_p(e) may hide a typedef and hence a functional type.
#define ENTITY_FIELD_P(e)
C data structure and pointer management.
#define ENTITY_MINUS_C_P(e)
#define ENTITY_ADDRESS_OF_P(e)
const char * entity_local_name(entity e)
entity_local_name modified so that it does not core when used in vect_fprint, since someone thought t...
bool c_module_p(entity m)
Test if a module "m" is written in C.
entity module_name_to_entity(const char *mn)
This is an alias for local_name_to_top_level_entity.
bool typedef_entity_p(entity e)
bool entity_field_p(entity e)
e is the field of a structure
const char * module_local_name(entity e)
Returns the module local user name.
bool fortran_module_p(entity m)
Test if a module is in Fortran.
bool entity_module_p(entity e)
expression make_unbounded_expression()
expression MakeBinaryCall(entity f, expression eg, expression ed)
Creates a call expression to a function with 2 arguments.
call expression_call(expression e)
expression int_to_expression(_int i)
transform an int into an expression and generate the corresponding entity if necessary; it is not cle...
expression expression_to_dereferencing_expression(expression e)
Reuse expression e to build expression *(e) without cheking the legality of the construct.
bool expression_reference_p(expression e)
Test if an expression is a reference.
reference expression_reference(expression e)
Short cut, meaningful only if expression_reference_p(e) holds.
expression syntax_to_expression(syntax s)
generates an expression from a syntax
basic basic_of_expression(expression)
basic basic_of_expression(expression exp): Makes a basic of the same basic as the expression "exp".
type expression_to_type(expression)
For an array declared as int a[10][20], the type returned for a[i] is int [20].
statement pop_statement_global_stack(void)
bool place_holder_variable_p(entity)
type type_to_pointed_type(type)
returns t if t is not a pointer type, and the pointed type if t is a pointer type.
type entity_basic_concrete_type(entity)
retrieves or computes and then returns the basic concrete type of an entity
bool pointer_type_p(type)
Check for scalar pointers.
bool formal_parameter_p(entity)
void push_statement_on_statement_global_stack(statement)
type compute_basic_concrete_type(type)
computes a new type which is the basic concrete type of the input type (this new type is not stored i...
type reference_to_type(reference)
void free_statement_global_stack(void)
bool typedef_type_p(type)
Returns true if t is a typedefED type.
bool variable_static_p(entity)
true if v appears in a SAVE statement, or in a DATA statement, or is declared static i C.
void make_statement_global_stack(void)
string type_to_string(const type)
type.c
#define type_functional_p(x)
#define forloop_domain
newgen_extensions_domain_defined
#define test_domain
newgen_entity_domain_defined
#define syntax_reference_p(x)
#define expression_domain
newgen_execution_domain_defined
#define transformer_undefined
#define functional_result(x)
#define transformer_undefined_p(x)
#define unstructured_domain
newgen_type_domain_defined
#define parameter_type(x)
#define value_constant(x)
#define syntax_reference(x)
#define reference_undefined
#define forloop_initialization(x)
#define reference_variable(x)
#define loop_domain
newgen_language_domain_defined
#define basic_typedef_p(x)
#define SIZEOFEXPRESSION(x)
SIZEOFEXPRESSION.
#define sizeofexpression_type(x)
#define forloop_increment(x)
#define statement_ordering(x)
#define sizeofexpression_expression(x)
#define type_functional(x)
#define value_unknown_p(x)
#define syntax_application(x)
#define dimension_lower(x)
#define basic_pointer_p(x)
#define basic_derived_p(x)
#define syntax_va_arg_p(x)
#define entity_storage(x)
#define statement_domain
newgen_sizeofexpression_domain_defined
#define type_statement_p(x)
@ is_syntax_sizeofexpression
#define range_increment(x)
#define instruction_domain
newgen_functional_domain_defined
#define call_domain
newgen_callees_domain_defined
#define storage_formal(x)
#define EXPRESSION(x)
EXPRESSION.
#define cast_expression(x)
#define subscript_indices(x)
#define constant_int_p(x)
#define expression_undefined
#define functional_parameters(x)
#define PARAMETER(x)
PARAMETER.
#define formal_function(x)
#define dimension_upper(x)
#define reference_indices(x)
#define syntax_sizeofexpression(x)
#define sizeofexpression_expression_p(x)
#define instruction_call_p(x)
#define instruction_expression(x)
#define expression_undefined_p(x)
#define test_condition(x)
#define subscript_array(x)
#define variable_dimensions(x)
#define whileloop_domain
newgen_variable_domain_defined
#define statement_declarations(x)
#define statement_instruction(x)
#define instruction_call(x)
#define syntax_subscript(x)
#define forloop_condition(x)
#define call_arguments(x)
#define whileloop_condition(x)
#define basic_string_p(x)
#define statement_number(x)
#define value_expression_p(x)
#define expression_syntax(x)
#define sequence_domain
newgen_reference_domain_defined
#define type_variable_p(x)
#define value_expression(x)
#define variable_basic(x)
#define instruction_expression_p(x)
#define entity_initial(x)
#define syntax_subscript_p(x)
Value b1
booleen indiquant quel membre est en cours d'analyse
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
FI: I do not understand why the type is duplicated at the set level.
The structure used to build lists in NewGen.
string words_to_string(cons *lw)
#define exp
Avoid some warnings from "gcc -Wshadow".