5 #include "pips_config.h"
155 tiled_loops_inner=
gen_append(tiled_loops_inner,tiled_loops_outer);
158 POP(tiled_loops_inner);
182 if(
depth == 0 )
return true;
192 pips_user_error(
"given loop is either not normalized or not parallel or not nested\n");
221 pips_user_warning(
"must provide a non empty array with expressions valid in current context\n");
instruction make_instruction_loop(loop _field_)
value make_value_expression(expression _field_)
loop make_loop(entity a1, range a2, statement a3, entity a4, execution a5, list a6)
type make_type_variable(variable _field_)
basic make_basic_int(intptr_t _field_)
expression copy_expression(expression p)
EXPRESSION.
statement copy_statement(statement p)
STATEMENT.
reference make_reference(entity a1, list a2)
variable make_variable(basic a1, list a2, list a3)
execution make_execution_parallel(void)
bool type_consistent_p(type p)
bool entity_consistent_p(entity p)
range make_range(expression a1, expression a2, expression a3)
syntax make_syntax_reference(reference _field_)
bdt base
Current expression.
bool clean_up_sequences(statement s)
Recursively clean up the statement sequences by fusing them if possible and by removing useless one.
void set_cumulated_rw_effects(statement_effects)
list load_cumulated_rw_effects_list(statement)
void reset_cumulated_rw_effects(void)
list proper_effects_of_expression(expression)
#define effect_any_reference(e)
FI: cannot be used as a left hand side.
#define effect_write_p(eff)
const char * module_name(const char *s)
Return the module part of an entity name.
list string_to_expressions(const char *str, const char *seed, entity module)
split a string using seed as separator and call string_to_expression on each chunk
char * get_string_property(const char *)
bool get_bool_property(const string)
FC 2015-07-20: yuk, moved out to prevent an include cycle dependency include "properties....
#define gen_recurse(start, domain_number, flt, rwt)
void gen_full_free_list(list l)
bool references_may_conflict_p(reference r1, reference r2)
Check if two references may conflict.
void set_conflict_testing_properties()
conflicts.c
statement instruction_to_statement(instruction)
Build a statement from a give instruction.
void reset_current_module_entity(void)
Reset the current module entity.
void reset_current_module_statement(void)
Reset the current module statement.
const char * get_current_module_name(void)
Get the name of the current module.
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 replace_entity(void *s, entity old, entity new)
per variable version of replace_entities.
bool gen_true(__attribute__((unused)) gen_chunk *unused)
Return true and ignore the argument.
instruction make_instruction_block(list statements)
Build an instruction block from a list of statements.
#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)
#define CAR(pcons)
Get the value of the first element of a list.
#define FOREACH(_fe_CASTER, _fe_item, _fe_list)
Apply/map an instruction block on all the elements of a list.
list gen_append(list l1, const list l2)
string db_get_memory_resource(const char *rname, const char *oname, bool pure)
Return the pointer to the resource, whatever it is.
#define DB_PUT_MEMORY_RESOURCE(res_name, own_name, res_val)
conform to old interface.
loop statement_loop(statement)
Get the loop of a statement.
bool statement_loop_p(statement)
statement make_assign_statement(expression, expression)
statement update_statement_instruction(statement, instruction)
Replace the instruction in statement s by instruction i.
#define pips_user_warning
#define pips_assert(what, predicate)
common macros, two flavors depending on NDEBUG
#define SET_FOREACH(type_name, the_item, the_set)
enumerate set elements in their internal order.
set set_add_element(set, const set, const void *)
bool module_reorder(statement body)
Reorder a module and recompute order to statement if any.
#define MINUS_OPERATOR_NAME
#define PLUS_OPERATOR_NAME
#define DEFAULT_INTEGER_TYPE_SIZE
#define binary_intrinsic_expression(name, e1, e2)
#define DIVIDE_OPERATOR_NAME
#define MULTIPLY_OPERATOR_NAME
#define MIN_OPERATOR_NAME
const char * entity_user_name(entity e)
Since entity_local_name may contain PIPS special characters such as prefixes (label,...
bool entity_formal_p(entity p)
is p a formal parameter?
bool local_entity_of_module_p(entity e, entity module)
This test shows that "e" has been declared in "module".
entity module_name_to_entity(const char *mn)
This is an alias for local_name_to_top_level_entity.
entity entity_empty_label(void)
set get_referenced_entities(void *elem)
retrieves the set of entities used in elem beware that this entities may be formal parameters,...
bool expression_integer_value(expression e, intptr_t *pval)
expression entity_to_expression(entity e)
if v is a constant, returns a constant call.
void update_expression_syntax(expression e, syntax s)
frees expression syntax of e and replace it by the new syntax s
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)
================================================================
entity make_new_scalar_variable(entity, basic)
void AddEntityToCurrentModule(entity)
Add a variable entity to the current module declarations.
bool unsigned_type_p(type)
Predicates on types.
entity make_new_scalar_variable_with_prefix(const char *, entity, basic)
Create a new scalar variable of type b in the given module.
entity find_label_entity(const char *, const char *)
util.c
#define loop_execution(x)
#define loop_domain
newgen_language_domain_defined
#define range_increment(x)
#define EXPRESSION(x)
EXPRESSION.
#define instruction_undefined
#define statement_label(x)
#define statement_instruction(x)
#define statement_undefined_p(x)
#define execution_parallel_p(x)
#define statement_undefined
#define STATEMENT(x)
STATEMENT.
#define entity_initial(x)
FI: I do not understand why the type is duplicated at the set level.
The structure used to build lists in NewGen.
void do_symbolic_tiling(statement base, list vector)
symbolic_tiling.c
static void fix_loop_index_sign(loop l)
symbolic tiling less general, but works for symbolics bounds
static bool symbolic_tiling_valid_p(statement sloop, size_t depth)
checks if sloop is a perfectly nested loop of depth @depth
bool symbolic_tiling(const char *module_name)
static int depth
la sequence de nids
1.9.1