25 #include "pips_config.h"
248 pips_assert(
"A meaningless control has one and ony one predecessor",
250 pips_assert(
"A meaningless control has no successor",
260 pips_assert(
"c is a successor of each of its predecessors",
false);
269 pips_assert(
"c is a predecessor of each of its successors",
false);
279 "ctr %p, %zd preds, %zd succs: %s",
284 fprintf(stderr,
"\tsuccessors:\n");
286 fprintf(stderr,
"\t\t%p %s", s,
289 fprintf(stderr,
"\tpredecessors:\n");
291 fprintf(stderr,
"\t\t%p %s", p,
333 pips_debug(2,
"Unstructured %p with nodes:\n", u);
349 char attributes[256];
350 bool arc_kind =
true;
353 attributes[0] =
'\000';
355 (void) strcpy(&attributes[0],
",a(\"BORDER\",\"double\")");
358 (void) strcat(&attributes[0],
",a(\"COLOR\",\"red\")");
361 (void) strcat(&attributes[0],
",a(\"FONTSTYLE\",\"bold_italic\")");
365 fprintf(
f,
"l(\"%p\",n(\"\",[a(\"_GO\",\"text\"),a(\"OBJECT\",\"%p\")],\n\t[\n", c, c);
370 "l(\"%p\",n(\"\",[a(\"_GO\",\"rhombus\"),a(\"OBJECT\",\"%p\\n(%d,%d)\")%s],\n\t[\n",
376 fprintf(
f,
"l(\"%p\",n(\"\",[a(\"OBJECT\",\"%p\\n(%d,%d)\")%s],\n\t[\n", c, c,
385 (void) strcpy(&attributes[0], arc_kind?
"green":
"red");
386 fprintf(
f,
"\tl(\"%p->%p\",e(\"\",[a(\"EDGECOLOR\",\"%s\")],r(\"%p\")))",
387 c, s, attributes, s);
390 fprintf(
f,
"\tl(\"%p->%p\",e(\"\",[],r(\"%p\")))", c, s, s);
394 arc_kind = !arc_kind;
449 fprintf(
f,
"l(\"%s\",n(\"\",[a(\"_GO\",\"text\"),a(\"OBJECT\",\"%s\\nSerial number for module %s: %d\\nEntry node: double border\\nExit node: red\\nCycles: bold italic\\nTrue arc: green\\nFalse arc: red\")],\n\t[])),\n",
492 pips_debug(1,
"Exit node %p in unstructured %p is not reachable\n", exit_c, u);
500 fprintf(
f,
"l(\"%s\",n(\"\",[a(\"_GO\",\"text\"),a(\"OBJECT\",\"%s\\nSerial number for module %s: %d\\nEntry node: double border\\nExit node: red\\nCycles: bold italic\\nTrue arc: green\\nFalse arc: red\")],\n\t[])),\n",
543 bool consistent_embedding_graph_p =
true;
545 pips_debug(2,
"Embedding graph for vertex %p:\n", c);
558 consistent_embedding_graph_p =
false;
559 fprintf(stderr,
"Control %p is a predecessor of control %p "
560 "but control %p is not a successor of control %p\n",
568 consistent_embedding_graph_p =
false;
569 fprintf(stderr,
"Control %p is a successor of control %p "
570 "but control %p is not a predecessor of control %p\n",
586 meaningless_p =
false;
591 consistent_embedding_graph_p =
false;
592 fprintf(stderr,
"Control %p only has meaningless successors\n",
602 consistent_embedding_graph_p =
false;
603 fprintf(stderr,
"Control %p has meaningless predecessor %p\n",
617 pips_assert(
"The embedding graph is consistent", consistent_embedding_graph_p);
621 pips_debug(2,
"End: the embedding graph for vertex %p is consistent.\n", c);
630 pips_debug(8,
"Linked nodes for vertex %p:\n", c);
668 pips_assert(
"A control test has at least two successors", ns>=2);
689 pips_assert(
"The rank of the last successors is the number of successors",
rank==ns);
690 pips_assert(
"true, false and empty successors are a partition", ns==
nts+nfs+nes);
693 if(nes >
nts-nfs && nes > nfs-
nts) {
695 list c_t_succs = t_succs;
696 list c_f_succs = f_succs;
697 list c_e_succs = e_succs;
700 if(!
ENDP(c_t_succs)) {
705 pips_assert(
"The empty successor list is not empty", !
ENDP(c_e_succs));
709 if(!
ENDP(c_f_succs)) {
714 pips_assert(
"The empty successor list is not empty", !
ENDP(c_e_succs));
727 pips_assert(
"The successor list is reduced", nel>0);
731 ifdebug(9)
fprintf(stderr,
"control %p is consistent and is going to be freed\n", e);
762 ifdebug(10)
fprintf(stderr,
"control %p is consistent first\n", ec);
792 ifdebug(9)
fprintf(stderr,
"control %p is consistent second\n", ec);
820 pips_debug(2,
"End: %d useless successors destroyed\n", nel);
828 fprintf(stderr,
"%p -> %p\n", c1, c2);
839 bool ancestor_p =
false;
843 if(c_old==(
void *) c) {
870 pips_debug(2,
"vertex=%p with statement %s\n",
872 pips_debug(2,
"ancestor=%p with statement %s\n",
884 bool registered_p =
true;
892 pips_debug(2,
"Control %p is not registered:\n", c);
895 registered_p =
false;
918 check_p =
ENDP(ancestors);
921 if(!
ENDP(ancestors)) {
922 pips_debug(2,
"Bug some control are children and ancestors:\n");
946 pips_assert(
"The child should not already be in ancestor_map",
951 hash_put(ancestor_map, (
void *) child, (
void *) ancestor);
961 fprintf(stderr,
"\nDump of replicate_map:\n");
964 fprintf(stderr,
"Old %p -> New %p\n", old_c, new_c);
1113 " then there must be two successors",
1118 pips_assert(
"The second successor is in partition and has been copied",
1153 bool is_entry_or_exit_p =
false;
1159 is_entry_or_exit_p =
true;
1165 return is_entry_or_exit_p;
1237 insert_non_deterministic_control_node(
list succs,
1252 pips_debug(2,
"Allocate new control node %p as CONTINUE for test control node %p"
1253 " with two successors, a new one, %p, and an old one %p\n",
1254 cnop, pred, new_c, old_c);
1265 pips_assert(
"old_c is already a successor of pred",
1267 pips_assert(
"new_c is not yet a successor of pred",
1272 bool insert_p =
false;
1294 pips_debug(8,
"%s meaningless control node added. New successor list of pred %p:\n",
1295 insert_p?
"A" :
"No", pred);
1309 pips_assert(
"old_c is already a predecessor of succ",
1311 pips_assert(
"new_c is not yet a predecessor of succ",
1320 bool slot_found =
false;
1324 pips_debug(8,
"Begin with t=%p, new_s=%p and is_true_successor=%d",
1325 t, new_s, is_true_successor);
1329 is_true_successor==0 || is_true_successor==1);
1338 pips_debug(2,
"Free meaningless control node %p\n", s);
1364 pips_debug(8,
"End with slot_found=%s, rank=%zd and pos=%zd\n",
1367 pips_assert(
"The position is consistent with is_true_successor",
1368 (
bool)pos%2 == is_true_successor);
1387 pips_debug(3,
"Begin for new_pred=%p, pred=%p, c=%p, new_c=%p\n",
1388 new_pred, pred, c, new_c);
1405 pips_assert(
"pred and new_pred share the same statement",
1407 pips_assert(
"c and new_c share the same statement",
1412 bool is_true_succ = pos%2;
1414 pips_assert(
"The position is not zero since c is among the sucessors of pred"
1415 " (see previous assert)", pos!=0);
1417 pips_debug(4,
"position=%d, is_true_succ=%d \n", pos, is_true_succ);
1419 pips_assert(
"pred is still a predecessor of new_c",
1431 pips_debug(3,
"End with new_pred=%p\n", new_pred);
1471 bool stable_graph_p =
false;
1478 pips_debug(3,
"Begin for vertex %p and partition:\n", root);
1482 while(!stable_graph_p) {
1486 stable_graph_p =
true;
1490 for(c_c = partition; !
ENDP(c_c);
POP(c_c)) {
1498 pips_assert(
"c has not yet been input replicated",
1506 pips_debug(4,
"Allocate new input control node new_c1=%p"
1507 " as a copy of node %p with depth %td\n",
1532 control new_succ_new_c1 =
hash_get(replicated_input_controls, succ_new_c1);
1545 stable_graph_p =
false;
1548 hash_put(replicated_input_controls, c, new_c1);
1555 pips_debug(4,
"Embedding graph after replication"
1556 " of %d input control node(s) at iteration %d:\n",
1558 sprintf(msg,
"Embedding graph after replication"
1559 " of %d input control node(s) at iteration %d:",
1562 pips_debug(4,
"End of embedding graph after replication"
1563 " of input control nodes\n");
1566 pips_debug(4,
"No new input control node at iteration %d\n",
1573 for(c_c = partition; !
ENDP(c_c);
POP(c_c)) {
1582 pips_assert(
"c has not yet been output replicated",
1590 pips_debug(4,
"Allocate new output control node new_c2=%p as a copy of node %p\n",
1611 !
ENDP(pred_new_c2_c);
POP(pred_new_c2_c)) {
1613 control new_pred_new_c2 =
hash_get(replicated_output_controls, pred_new_c2);
1634 stable_graph_p =
false;
1637 hash_put(replicated_output_controls, c, new_c2);
1644 pips_debug(3,
"Embedding graph after replication"
1645 " of output control nodes at iteration %d:\n", iteration);
1646 sprintf(msg,
"Embedding graph after replication"
1647 " of output control nodes at iteration %d:", iteration);
1649 pips_debug(3,
"End of embedding graph after replication"
1650 " of output control nodes\n");
1653 pips_debug(3,
"No new output control node at iteration %d\n", iteration);
1661 if(number_out>0 || number_in>0) {
1662 pips_assert(
"At least two iterations", iteration>1);
1663 pips_debug(3,
"Final embedding graph after replication of all input and output paths (%d iterations)\n", iteration);
1664 sprintf(msg,
"Final embedding graph after replication of all input and output paths (%d iterations)", iteration);
1666 pips_debug(3,
"End of final embedding graph after replication of all input and output paths\n");
1718 pips_debug(3,
"Nodes linked to root=%p\n", root);
1721 pips_debug(3,
"Nodes linked to new_root=%p\n", new_root);
1729 "Bug: l_root and l_new_root share at least one node and must be equal\n");
1730 fprintf(stderr,
"Common control nodes:\n");
1732 pips_assert(
"l_root and l_new_root have an empty intersection",
1748 pips_debug(3,
"Final embedding graph after replication and cycle removal\n");
1749 sprintf(msg,
"Final embedding graph after replication and cycle removal");
1751 pips_debug(3,
"End of final embedding graph after replication and cycle removal\n");
1753 sprintf(msg,
"Final cycle graph");
1761 pips_assert(
"All nodes in l_new_root are registered",
1763 pips_assert(
"Children and ancestors have an empty intersection",
1771 pips_debug(3,
"End with %d replicated control nodes:\n\n", number_in+number_out);
1774 replicated_input_controls);
1779 replicated_output_controls);
1788 pips_debug(3,
"End for vertex %p and partition:\n", root);
1806 list scc_to_process_next =
NIL;
1808 int replication_number = 0;
1809 int deletion_number = 0;
1811 pips_debug(1,
"Start with %d cycles for unstructured %p with entry %p\n",
1814 while(!
ENDP(scc_to_process)) {
1831 hash_put(scc_map, c, (
void *) scc_u_c);
1832 replication_number++;
1836 pips_debug(1,
"New scc %p with entry %p for node %p copy of ancestor node %p\n",
1848 live_scc =
gen_nconc(live_scc, scc_to_process);
1849 scc_to_process = scc_to_process_next;
1850 scc_to_process_next =
NIL;
1865 pips_debug(1,
"scc %p unlinked from node %p\n", u_u, c);
1872 replication_number >= deletion_number);
1876 pips_debug(1,
"End replication process with %d copies and %d deletions\n",
1877 replication_number, deletion_number);
1925 make_vertex_stack();
1932 pips_debug(3,
"Copied unstructured new_u:\n");
1935 scc_map, ancestor_map);
1949 free_vertex_stack();
1958 int number_of_fix_points = 0;
1965 number_of_fix_points++;
1966 fprintf(stderr,
"head=%p with unstructured=%p\n", h, uc);
1968 pips_debug(2,
"End with %d fix points\n", number_of_fix_points);
1971 pips_debug(2,
"\nControl nodes associated to a fix point via a sub-unstructured:\n");
1975 fprintf(stderr,
"head=%p copy of %p with unstructured=%p\n", c_n, c_o, su);
1980 pips_debug(2,
"End with %d sets of cycles:\n", number_of_fix_points);
1981 number_of_fix_points = 0;
1985 number_of_fix_points++;
1986 fprintf(stderr,
"Cycles associated to head=%p with unstructured=%p (fix point %d)\n",
1987 h, uc, number_of_fix_points);
1988 sprintf(msg,
"Cycles associated to head=%p\\n with unstructured=%p (fix point %d)",
1989 h, uc, number_of_fix_points);
1997 pips_debug(2,
"Final embedding graph %p:\n", new_u);
2005 *p_ancestor_map = ancestor_map;
2006 *p_scc_map = scc_map;
2017 bool path_p =
false;
2023 pips_debug(3,
"Begin with b=%p abd e=%p\n", b, e);
2034 while(!
ENDP(preds)){
2076 size_t eliminations = 0;
2089 pips_assert(
"c is not a meaningless control node",
2104 replacement_list =
CONS(
CONTROL, c_new, replacement_list);
2126 replacement_list =
gen_nconc(replacement_list,
CDR(c_c));
2127 CDR(c_c) =
CDR(replacement_list);
2128 CDR(replacement_list) =
NIL;
2151 pips_debug(2,
"After %d renamings, new partition:\n", changes);
2159 if(eliminations>0) {
2160 pips_debug(2,
"Untranslatable control(s) to be eliminated from partition:\n");
2170 pips_assert(
"There is a path from root to root in partition",
2175 eliminated =
gen_once(c, eliminated);
2183 pips_debug(2,
"Untranslatable and unreachable control(s) to be eliminated from partition:\n");
2189 pips_assert(
"root is the fist element in partition",
2198 if(eliminations==0 && changes==0) {
2199 pips_debug(2,
"End with same partition (no renaming, no elimination)\n");
2201 else if(eliminations==0){
2202 pips_debug(2,
"End with renamed partition (%d renamings, no elimination)\n",
2205 else if(changes==0){
2206 pips_debug(2,
"End with reduced partition (no renamings, %zd eliminations)\n",
2210 pips_debug(2,
"End with new partition (%d renamings, %zd eliminations):\n",
2211 changes, eliminations);
2270 hash_put(scc_map, vertex_ancestor, u);
2273 pips_debug(2,
"End with internal partition: ");
2275 pips_debug(2,
"End with Bourdoncle partition: ");
2390 bool is_cycle =
false;
2407 bool is_proper_cycle_head_p =
false;
2414 is_proper_cycle_head_p =
true;
2418 return is_proper_cycle_head_p;
2424 bool is_cycle =
false;
2453 bool one_kind_only_p =
false;
2454 bool is_true_successor_p =
true;
2455 bool real_successor_found_p =
false;
2461 if(is_true_successor_p && true_p) {
2469 one_kind_only_p &= real_successor_found_p;
2471 return one_kind_only_p;
2476 bool true_only_p =
false;
2483 bool true_only_p =
false;
unstructured make_unstructured(control a1, control a2)
void free_control(control p)
void free_unstructured(unstructured p)
bool control_consistent_p(control p)
control make_control(statement a1, list a2, list a3)
static void reset_dfn(control c)
static control make_meaningless_control(list preds, list succs)
With non-deterministic graph, the outcome of a test may be known in advance.
static int clean_up_control_test(control c)
Take care of two problems: meaningless control nodes may end up shared by effective nodes and they ma...
static control control_to_replicate(control old_c)
static hash_table dfn
bourdoncle.c
static _int get_dfn(control c)
bool meaningless_control_p(control c)
Is exported to exploit non-deterministic control flow graphs.
static int control_cons_compare(list l1, list l2)
void intersect_successors_with_partition_complement(control c, list partition)
static void add_test_successor(control t, control new_s, bool is_true_successor)
Called from within a loop where neither t nor new_s are consistent.
static void print_and_check_control_node(control c, bool check_p)
static list node_to_linked_nodes(control c)
Allocate a list of control nodes transitively linked to control c.
static void replicate_cycles(unstructured u_main, hash_table scc_map, hash_table ancestor_map)
bool control_test_p(control c)
Check that a node is used as a test in a CFG.
static bool ancestor_map_consistent_p(hash_table ancestor_map)
No control can be an ancestor and a child.
static bool exit_control_p(control c, list partition)
unstructured partition_to_unstructured(control vertex, list partition)
Build a new unstructured (CFG) for partition.
static void print_control_node_without_check(control)
Code partly replicated from semantics/unstructured.c to be able to taylor it to the exact needs.
static void __attribute__((unused))
control control_to_ancestor(control vertex, hash_table ancestor_map)
If vertex is an ancestor control node from the input control graph, return vertex,...
void bourdoncle_free(unstructured ndu, hash_table ancestor_map, hash_table scc_map)
static void update_dfn(control c, _int d)
static void update_predecessors_of_successor(control succ, control new_c, control old_c)
list bourdoncle_partition(unstructured u, unstructured *p_ndu, hash_table *p_ancestor_map, hash_table *p_scc_map)
static void print_embedding_graph(control c, string msg)
static void bourdoncle_unstructured_free(unstructured u)
static void update_partition(control root, list partition, hash_table ancestor_map)
static bool registered_controls_p(hash_table ancestor_map, list l)
static void davinci_print_control_nodes(list l, string msg)
unstructured unstructured_shallow_copy(unstructured u, hash_table ancestor_map)
static int davinci_count
This counter is pre-incremented each time a new graph is stored to generate a new file name.
bool direct_cycle_head_p(control c, hash_table scc_map)
This node is directly associated to a specific cycle.
static void davinci_print_non_deterministic_unstructured(unstructured u, string msg, hash_table scc_map, hash_table ancestor_map)
static void print_control_nodes_without_check(list l)
Was moved into ri-util/control, minus the check_control_statement()
bool proper_cycle_head_p(control c, hash_table scc_map)
This node is really the head of a cycle (red on daVinci pictures).
bool cycle_head_p(control c, hash_table ancestor_map, hash_table scc_map)
This node is a cycle call site.
unstructured ancestor_cycle_head_to_scc(control a, hash_table scc_map)
scc_map maps either the ancestor node to its scc if the transformers are computed without context,...
static unstructured scc_to_dag(control root, list partition, hash_table ancestor_map)
The nodes in scc partition but root must be removed.
static bool entry_control_p(control c, list partition)
static void davinci_print_control_node(control c, FILE *f, bool entry_p, bool exit_p, bool fix_point_p)
Output CFG in daVinci format.
static bool ancestor_control_p(hash_table ancestor_map, control c)
Functions to deal with the ancestor_map.
list bourdoncle_component(control vertex, hash_table ancestor_map, hash_table scc_map)
unstructured proper_cycle_head_to_scc(control h, hash_table scc_map)
Retrieve a scc_u from its head.
static void free_meaningless_control(control c)
static void clean_up_embedding_graph(control c)
static void copy_dfn(control new_c, control old_c)
static void print_control_node_b(control c)
static bool partition_successor_p(control b, control e, list partition)
FUNCTIONS FOR BOURDONCLE_COMPONENT()
static void set_davinci_count()
void intersect_successors_with_partition_or_complement(control c, list partition, bool complement_p)
If complement_p, preserve successors in the complement of partition.
static void print_replicate_map()
bool false_successors_only_p(control c)
bool true_successors_only_p(control c)
static bool entry_or_exit_control_p(control c, list partition, bool check_entry)
static void suppress_statement_reference(control c)
static void control_translate_arcs(control c)
static void print_unstructured(unstructured u)
static list embedding_control_list
static void update_successors_of_predecessor(control pred, control new_c, control old_c)
new_c is not consistent on entry and might not be on exit because it is called from within a loop
static void add_child_parent_pair(hash_table ancestor_map, control child, control parent)
void intersect_successors_with_partition(control c, list partition)
static void update_successor_in_copy(control new_pred, control pred, control c, control new_c)
Make new_c a successor of new_pred, the same way c is a successor of pred.
int bourdoncle_visit(control vertex, list *ppartition, hash_table ancestor_map, hash_table scc_map)
void add_control_to_embedding_control_list(control c)
control control_shallow_copy(control c)
unstructured cycle_head_to_scc(control c, hash_table ancestor_map, hash_table scc_map)
The ancestor of this node is associated to a specific cycle.
static hash_table replicate_map
Replication of unstructured (i.e.
bool one_successor_kind_only_p(control c, bool true_p)
useful for non-deterministic control flow graph only
static void print_control_to_control_mapping(string message, hash_table map)
static bool check_control_statement(control c)
struct _newgen_struct_vertex_ * vertex
FILE * safe_fopen(const char *filename, const char *what)
int safe_fclose(FILE *stream, const char *filename)
bool get_bool_property(const string)
FC 2015-07-20: yuk, moved out to prevent an include cycle dependency include "properties....
void print_control_nodes(list l)
Display identification of a list of control nodes.
void forward_control_map_get_blocs(c, l)
Build recursively the list of all controls forward-reachable from a control of an unstructured.
#define FORWARD_CONTROL_MAP(ctl, code, c, list)
Walk through all the controls forward-reachable from a given control node of an unstructured.
const char * get_current_module_name(void)
Get the name 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.
void gen_remove(list *cpp, const void *o)
remove all occurences of item o from list *cpp, which is thus modified.
void gen_list_and(list *a, const list b)
Compute A = A inter B: complexity in O(n2)
int gen_position(const void *item, const list l)
Element ranks are strictly positive as for first, second, and so on.
#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_once(const void *vo, list l)
Prepend an item to a list only if it is not already in the list.
list gen_copy_seq(list l)
Copy a list structure.
size_t gen_length(const list l)
void gen_list_and_not(list *a, const list b)
Compute A = A inter non B:
#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
bool gen_in_list_p(const void *vo, const list lx)
tell whether vo belongs to lx
#define CDR(pcons)
Get the list less its first element.
#define MAPL(_map_list_cp, _code, _l)
Apply some code on the addresses of all the elements of a list.
void gen_list_patch(list l, const void *x, const void *y)
Replace all the reference to x in list l by a reference to y:
#define list_undefined
Undefined list definition :-)
#define MAP(_map_CASTER, _map_item, _map_code, _map_list)
Apply/map an instruction block on all the elements of a list (old fashioned)
void gen_sort_list(list l, gen_cmp_func_t compare)
Sorts a list of gen_chunks in place, to avoid allocations...
test statement_test(statement)
Get the test of a statement.
bool empty_statement_or_labelless_continue_p(statement)
Return true if the statement is an empty instruction block without label or a continue without label ...
bool statement_test_p(statement)
string statement_identification(statement)
Like external_statement_identification(), but with internal information, the hexadecimal address of t...
string safe_statement_identification(statement)
statement make_continue_statement(entity)
hash_table hash_table_make(hash_key_type key_type, size_t size)
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.
void hash_update(hash_table htp, const void *key, const void *val)
update key->val in htp, that MUST be pre-existent.
void hash_table_free(hash_table htp)
this function deletes a hash table that is no longer useful.
void * hash_delget(hash_table htp, const void *key, void **pkey)
deletes key from the hash table.
int hash_table_entry_count(hash_table htp)
now we define observers in order to hide the hash_table type...
static int useless(Pproblem XX, int i)
#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
char * i2a(int)
I2A (Integer TO Ascii) yields a string for a given Integer.
string bool_to_string(bool)
string concatenate(const char *,...)
Return the concatenation of the given strings.
#define DEFINE_LOCAL_STACK(name, type)
#define HASH_MAP(k, v, code, ht)
#define HASH_UNDEFINED_VALUE
value returned by hash_get() when the key is not found; could also be called HASH_KEY_NOT_FOUND,...
#define hash_table_undefined_p(h)
#define hash_table_undefined
Value of an undefined hash_table.
int(* gen_cmp_func_t)(const void *, const void *)
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
string db_get_current_workspace_directory(void)
#define ORDERING_NUMBER(o)
#define ORDERING_STATEMENT(o)
#define unstructured_control
After the modification in Newgen: unstructured = entry:control x exit:control we have create a macro ...
entity entity_empty_label(void)
#define control_undefined
#define control_predecessors(x)
struct _newgen_struct_unstructured_ * unstructured
#define statement_ordering(x)
#define unstructured_undefined
#define statement_domain
newgen_sizeofexpression_domain_defined
#define control_domain
newgen_controlmap_domain_defined
#define CONTROL(x)
CONTROL.
#define control_successors(x)
#define control_undefined_p(x)
#define unstructured_exit(x)
#define unstructured_undefined_p(x)
#define control_statement(x)
#define statement_undefined_p(x)
#define UNSTRUCTURED(x)
UNSTRUCTURED.
#define statement_undefined
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
The structure used to build lists in NewGen.