25 #include "pips_config.h"
71 #include "constants.h"
86 #define entity_assigned_by_array_p(ent) (gen_find_eq(ent, assigned_var) != chunk_undefined)
523 "expression_undefined" );
608 if (ndf_list !=
NIL) {
610 ndf_list =
CDR( ndf_list );
636 if (l ==
NIL)
return(
NIL);
672 pips_debug(7,
" result : %s\n", (ONLY_SPLC?
"TRUE":
"FALSE") );
702 bool bo, ret_bo =
true;
708 if (l ==
NIL)
return(
true);
722 ret_bo = ret_bo && bo;
766 if ( l ==
NIL )
return(
NIL );
783 if ( l ==
NIL )
return(
NIL);
842 for (pc = *swfl; pc !=
NIL; pc = pc->
cdr ) {
843 if ((
void *) ent ==
CAR(pc).p)
861 pips_debug(9,
"scalar written_forward = %s\n",
903 list formals_or_ram_integer =
NIL;
917 formals_or_ram_integer);},
920 return formals_or_ram_integer;
953 " result : %s\n", (ONLY_SP?
"TRUE":
"FALSE") );
987 (b?
"TRUE":
"FALSE") );
1020 (b?
"TRUE":
"FALSE") );
1040 "returning : %s \n",
1062 bool ret_bool =
false;
1068 pips_debug(9,
"struct param. before : %s \n",
1096 hash_put(fst, (
char*) lhs_ent, (
char*) nsp_exp );
1104 pips_debug(9,
"call has to be modified : %s \n",
1105 ((ret_bool ==
true)?
"TRUE":
"FALSE") );
range copy_range(range p)
RANGE.
loop make_loop(entity a1, range a2, statement a3, entity a4, execution a5, list a6)
expression copy_expression(expression p)
EXPRESSION.
bool call_consistent_p(call p)
struct _newgen_struct_entity_ * entity
static reference ref
Current stmt (an integer)
bool normalizable_and_linear_loop_p(entity, range)
#define chunk_undefined
obsolete
void control_map_get_blocs(control c, list *l)
Build recursively the list of all controls reachable from a control of an unstructured.
void gen_context_multi_recurse(void *o, void *context,...)
Multi-recursion with context function visitor.
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)
list gen_cons(const void *item, const list next)
#define CONS(_t_, _i_, _l_)
List element cell constructor (insert an element at the beginning of a list)
#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.
void * gen_find_eq(const void *item, const list seq)
#define MAPL(_map_list_cp, _code, _l)
Apply some code on the addresses of all the elements of a list.
bool assignment_statement_p(statement)
Test if a statement is an assignment.
statement make_continue_statement(entity)
void * hash_get(const hash_table htp, const void *key)
this function retrieves in the hash table pointed to by htp the couple whose key is equal to key.
void hash_put(hash_table htp, const void *key, const void *val)
This functions stores a couple (key,val) in the hash table pointed to by htp.
bool expression_constant_p(expression)
HPFC module by Fabien COELHO.
#define ADD_ELEMENT_TO_LIST(_list, _type, _element)
#define pips_debug
these macros use the GNU extensions that allow variadic macros, including with an empty list.
#define pips_assert(what, predicate)
common macros, two flavors depending on NDEBUG
#define pips_internal_error
entity scalar_assign_call(call c)
entity scalar_assign_call((call) c) Detects if the call is an assignement and if the value assigned i...
entity expression_int_scalar(expression exp)
================================================================
entity make_nsp_entity()
entity make_nsp_entity() Makes a new NSP (for New Structural Parameter) .
#define GET_STATEMENT_MAPPING(map, stat)
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
dfg_arc_label arc_label
Name : utils.c Package : paf-util Author : Alexis Platonoff Date : july 1993.
dfg_vertex_label vertex_label
#define static_control_loops(x)
struct _newgen_struct_static_control_ * static_control
void unnormalize_expression(void *st)
void unnormalize_expression(expression exp): puts all the normalized field of expressions in "st" to ...
string expression_to_string(expression e)
list Words_Regular_Call(call obj, bool is_a_subroutine)
static hash_table pl
properties are stored in this hash table (string -> property) for fast accesses.
#define ENTITY_DIVIDE_P(e)
#define ENTITY_RELATIONAL_OPERATOR_P(e)
#define ENTITY_NON_EQUAL_P(e)
#define ENTITY_EQUAL_P(e)
#define MINUS_OPERATOR_NAME
#define ENTITY_LESS_THAN_P(e)
#define NORMALIZE_EXPRESSION(e)
#define unstructured_control
After the modification in Newgen: unstructured = entry:control x exit:control we have create a macro ...
#define is_instruction_block
soft block->sequence transition
#define ENTITY_GREATER_THAN_P(e)
#define ENTITY_NON_EQUIV_P(e)
#define instruction_block(i)
#define ENTITY_LESS_OR_EQUAL_P(e)
#define ENTITY_GREATER_OR_EQUAL_P(e)
#define ENTITY_EQUIV_P(e)
code entity_code(entity e)
entity entity_empty_label(void)
bool entity_module_p(entity e)
expression make_entity_expression(entity e, cons *inds)
expression MakeBinaryCall(entity f, expression eg, expression ed)
Creates a call expression to a function with 2 arguments.
expression int_to_expression(_int i)
transform an int into an expression and generate the corresponding entity if necessary; it is not cle...
expression make_op_exp(char *op_name, expression exp1, expression exp2)
================================================================
expression MakeUnaryCall(entity f, expression a)
Creates a call expression to a function with one argument.
bool expression_equal_integer_p(expression exp, int i)
================================================================
entity expression_to_entity(expression e)
just returns the entity of an expression, or entity_undefined
bool entity_integer_scalar_p(entity)
for variables (like I), not constants (like 1)! use integer_constant_p() for constants
#define syntax_reference_p(x)
#define expression_domain
newgen_execution_domain_defined
#define loop_execution(x)
#define storage_formal_p(x)
#define syntax_reference(x)
#define reference_variable(x)
#define instruction_loop(x)
#define statement_ordering(x)
#define sizeofexpression_expression(x)
#define instruction_goto(x)
#define syntax_application(x)
#define entity_storage(x)
#define code_declarations(x)
#define CONTROL(x)
CONTROL.
@ is_syntax_sizeofexpression
#define range_increment(x)
#define EXPRESSION(x)
EXPRESSION.
#define cast_expression(x)
#define application_arguments(x)
#define subscript_indices(x)
#define entity_undefined_p(x)
#define expression_undefined
@ is_instruction_unstructured
@ is_instruction_whileloop
@ is_instruction_expression
#define instruction_tag(x)
#define normalized_tag(x)
#define expression_normalized(x)
#define reference_indices(x)
#define syntax_sizeofexpression(x)
#define instruction_call_p(x)
#define expression_undefined_p(x)
#define subscript_array(x)
#define application_function(x)
#define statement_instruction(x)
#define instruction_call(x)
#define syntax_subscript(x)
#define call_arguments(x)
#define control_statement(x)
#define instruction_test(x)
#define statement_number(x)
#define normalized_linear(x)
#define expression_syntax(x)
#define type_variable_p(x)
#define instruction_unstructured(x)
#define STATEMENT(x)
STATEMENT.
#define ENTITY_STRICT_LOGICAL_OPERATOR_P(e)
list words_entity_list(list obj)
================================================================
static void substitute_variable_by_expression(expression e, hash_table fst)
rewriting of forward_substitute_in_exp, in_loop,...
bool is_expression_in_list(expression exp, list l)
State if an expression OR part of that expression corresponds to one of the entity of the list l.
int stco_renumber_code(statement in_st, int in_ct)
================================================================
bool splc_linear_expression_list_p(list l, list *ell)
================================================================
string print_structurals(list l)
================================================================
int in_forward_defined(entity ent, list *swfl)
================================================================
list sc_list_of_loop_dup(list l)
================================================================
bool get_sp_of_call_p(call c, hash_table fst, list *swfl)
================================================================
list make_undefined_list()
================================================================
void forward_substitute_in_exp(expression *pe, hash_table fst)
list assigned_var
=================================================================
bool sp_feautrier_expression_p(expression exp)
================================================================
#define entity_assigned_by_array_p(ent)
void forward_substitute_in_anyloop(void *pl, hash_table fst)
void verify_structural_parameters(list the_list, list *swfl)
================================================================
bool splc_linear_expression_p(expression exp, list *ell)
================================================================
bool splc_feautrier_expression_p(expression exp, list *ell)
================================================================
bool splc_linear_access_to_arrays_p(list l, list *ell)
================================================================
void forward_substitute_in_call(call *pc, hash_table fst)
bool normalizable_loop_p(loop l)
bool normalizable_loop_p(loop l) Returns true if "l" has a constant step.
bool splc_positive_relation_p(expression exp, list *ell)
================================================================
list sc_list_of_exp_dup(list l)
================================================================
list loops_to_indices(list l)
================================================================
entity sp_feautrier_scalar_assign_call(call c)
================================================================
bool get_reference_assignments(statement s, list *l)
Allows the static_controlize phase to keep and update a list containing all the variables of the prog...
bool sp_linear_expression_p(expression exp)
================================================================
list stco_same_loops(statement_mapping in_map, statement in_s, statement in_s2)
======================================================================
expression sc_opposite_exp_of_conjunction(expression exp, list *ell)
================================================================
expression sc_conditional(expression exp, list *ell)
================================================================
bool in_forward_defined_p(entity ent, list *swfl)
================================================================
list sc_list_of_entity_dup(list l)
================================================================
list Gstructure_parameters
Global variables
loop sc_loop_dup(loop l)
================================================================
bool normalizable_loop_p_retrieved(loop l)
Code retrieved from revision 14476, transformations/loop_normalize.c.
list sc_entity_to_formal_integer_parameters(entity f)
================================================================
expression normalize_test_leaves(expression exp, list *ell)
================================================================
list ndf_normalized_test(expression exp, list *ell)
================================================================
le type des coefficients dans les vecteurs: Value est defini dans le package arithmetique
The structure used to build lists in NewGen.
struct cons * cdr
The pointer to the next element.
string words_to_string(cons *lw)
#define exp
Avoid some warnings from "gcc -Wshadow".
struct Svecteur * Pvecteur