Functions to manage control the graph and

unstructured More...

Collaboration diagram for Functions to manage control the graph and:

Functions
bool	is_control_in_list_p (control c, list cs)
	Test if a control node is in a list of control nodes. More...
int	occurences_in_control_list (control c, list cs)
	Count the number of occurences of a control node in a list of control nodes. More...
void	control_list_patch (list l, control c_old, control c_new)
	Replace in a list of control nodes all the instance of a control node by another one. More...
void	transfer_control_predecessor (control old_node, control new_node, control c)
	Transfer a control node as a predecessor from one node to another one. More...
void	transfer_control_successor (control old_node, control new_node, control c)
	Transfer a control node as a successor of one node to another one. More...
void	replace_control_related_to_a_list (control old_node, control new_node, list controls)
	Replace all the references to a control node by a new one in the successors & predecessors of a list of controls. More...
void	check_control_coherency (control c)
	Test the coherency of a control node network from a control node. More...
void	print_control_node (control c)
void	print_control_nodes (list l)
	Display identification of a list of control nodes. More...
void	display_address_of_control_nodes (list cs)
	Display the adresses a list of control nodes. More...
void	display_linked_control_nodes (control c)
	Display all the control nodes reached or reachable from c for debugging purpose. More...
void	remove_unreachable_following_control (control c, control do_not_delete_node, control do_not_delete_node_either)
	Remove all the control nodes (with their statements) from c in the successor tree of c up to the nodes with more than 1 predecessor, that is when it reach another flow. More...
void	remove_some_unreachable_controls_of_an_unstructured (unstructured u)
	Remove all the control sequences that are unreachable and that begin with a node without any predecessor. More...
void	remove_all_unreachable_controls_of_an_unstructured (unstructured u)
	Remove all control nodes that are not forward reachable from the entry node. More...
void	remove_a_control_from_a_list_and_relink (control c, list a_source_control_list_of_c, list a_dest_control_list_of_c, remove_a_control_from_a_list_and_relink_direction which_way)
	Replace each occurence of c in a_source_control_list_of_c with a a_dest_control_list_of_c: More...
void	remove_a_control_from_an_unstructured (control c)
	Remove a control node from a control graph. More...
void	remove_a_control_from_an_unstructured_without_relinking (control c)
	It removes a control node from its successor and predecessor. More...
void	discard_an_unstructured_without_its_statements (unstructured u)
	Used to discard an unstructured without touching its statements. More...
void	free_a_control_without_its_statement (control c)
	Remove a control node without touching its statement, its predecessors and successors, if any. More...
void	discard_a_control_sequence_without_its_statements (control begin, control end)
	Remove a control sequence without touching its statements. More...
list	generate_a_statement_list_from_a_control_sequence (control begin, control end)
	Take a control sequence and return a list of all the statements in the sequence (in the same order... More...
void	link_2_control_nodes (control source, control target)
	Add an edge between 2 control nodes. More...
void	link_3_control_nodes (control c_test, control c_then, control c_else)
	Add an edge between 2 control nodes. More...
void	unlink_2_control_nodes (control source, control target)
	Remove all edged between 2 control nodes. More...
void	insert_control_in_arc (control c, control before, control after)
	Insert a control node between 2 connected control nodes. More...
void	fuse_2_control_nodes (control first, control second)
	Fuse a 2 control nodes. More...

Detailed Description

unstructured

Function Documentation

check_control_coherency()

void check_control_coherency

(

control

c

)

Test the coherency of a control node network from a control node.

Do not verify the fact that nodes could appear twice in the case of unstructured tests.

Parameters

c	is the control node we want to start the verification from

Test the coherency of the successors

if (!is_control_in_list_p(ctl, control_predecessors(cc))) {

Test the coherency of the predecessors

if (!is_control_in_list_p(ctl, control_successors(cc))) {

Check that the statement are consistent

Check that two nodes do not point towards the same statement as this makes label resolution ambiguous

Definition at line 487 of file control.c.

{
    list blocs = NIL;
    int i1, i2;
    set stmts = set_make(set_pointer);
 
    control_consistent_p(c);
 
    CONTROL_MAP(ctl, {
 
        /* Test the coherency of the successors */
        MAP(CONTROL, cc, {
            /* if (!is_control_in_list_p(ctl, control_predecessors(cc))) { */
            if ((i1=occurences_in_control_list(ctl, control_predecessors(cc)))
                != (i2=occurences_in_control_list(cc, control_successors(ctl)))) {
                if(i1==0) {
                    pips_debug(0, "Control node %p not in the predecessor list of %p\n", ctl, cc);
                }
                else {
                    pips_debug(0, "Control %p occurs %d times in the predecessor list of %p"
                               " while control %p occurs %d times in the successor list of %p\n",
                               ctl, i1, cc, cc, i2, ctl);
                }
                ifdebug(8)
                    pips_assert("Control is correct", false);
            }
        }, control_successors(ctl));
 
        /* Test the coherency of the predecessors */
        MAP(CONTROL, cc, {
            /* if (!is_control_in_list_p(ctl, control_successors(cc))) { */
            if ((i1=occurences_in_control_list(ctl, control_successors(cc)))
                != (i2=occurences_in_control_list(cc, control_predecessors(ctl)))) {
              bool consistent_p = false;
                if(i1==0) {
                    pips_debug(0, "Control node %p not in the successor list of %p\n", ctl, cc);
                }
                else {
                  if(statement_test_p(control_statement(cc)) && i1>=2 && i2==1) {
                    consistent_p = true;
                  }
                  else {
                    pips_debug(0, "Control %p occurs %d times in the successor list of %p"
                               " while control %p occurs %d times in the predecessor list of %p\n",
                               ctl, i1, cc, cc, i2, ctl);
                  }
                }
                ifdebug(8) {
                  if(!consistent_p) {
                    pips_debug(8, "control %p is not correct\n", cc);
                    pips_assert("Control is correct", consistent_p);
                  }
                }
            }
        }, control_predecessors(ctl));
 
        /* Check that the statement are consistent */
        statement_consistent_p(control_statement(ctl));
 
        /* Check that two nodes do not point towards the same
           statement as this makes label resolution ambiguous */
        if(set_belong_p(stmts, control_statement(ctl))) {
          fprintf(stderr, "Statement %p is pointed by two different control nodes\n", control_statement(ctl));
          pips_assert("each statement appears in at most one control node", false);
        }
        else
          stmts = set_add_element(stmts, stmts, (void *) control_statement(ctl));
    }, c, blocs);
 
    set_free(stmts);
    gen_free_list(blocs);
}

References CONTROL, control_consistent_p(), CONTROL_MAP, control_predecessors, control_statement, control_successors, fprintf(), gen_free_list(), ifdebug, MAP, NIL, occurences_in_control_list(), pips_assert, pips_debug, set_add_element(), set_belong_p(), set_free(), set_make(), set_pointer, statement_consistent_p(), and statement_test_p().

Referenced by control_graph(), controlize(), controlize_forloop(), controlize_goto(), controlize_list(), controlize_list_1(), controlize_sequence(), controlize_statement(), controlize_test(), controlize_whileloop(), find_exit_control_node(), find_or_create_exit_control_node(), get_label_control(), hierarchize_control_list(), and simplified_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

control_list_patch()

void control_list_patch	(	list	l,
		control	c_old,
		control	c_new
	)

Replace in a list of control nodes all the instance of a control node by another one.

Parameters

l	is the list of control nodes
c_old	is the control node to remove
c_new	is the control node to put instead

Parameters

c_old	_old
c_new	_new

Definition at line 336 of file control.c.

{
    gen_list_patch(l, (gen_chunk *) c_old, (gen_chunk *) c_new);
}

References gen_list_patch().

Referenced by hierarchize_control_list(), transfer_control_predecessor(), and transfer_control_successor().

Here is the call graph for this function:

Here is the caller graph for this function:

discard_a_control_sequence_without_its_statements()

void discard_a_control_sequence_without_its_statements	(	control	begin,
		control	end
	)

Remove a control sequence without touching its statements.

It also removes the reference to the sequence from the predecessors or the successors.

Parameters

begin	is the control node we start from
end	is the control node to stop at

Of course, there should be a unique path from begin to end.

Unlink any extern reference to the control sequence:

To pass through the free:

Parameters

begin	egin
end	nd

Definition at line 1111 of file control.c.

{
   control c;
   list successor_list;
 
   /* Unlink any extern reference to the control sequence: */
   MAP(CONTROL, a_predecessor,
       {
          gen_remove(&control_successors(a_predecessor),
                     begin);
       },
       control_predecessors(begin));
 
   MAP(CONTROL, a_successor,
       {
          gen_remove(&control_predecessors(a_successor) ,
                     end);
       },
       control_successors(end));
 
   for(c = begin; ; c = CONTROL(CAR(successor_list))) {
      /* To pass through the free: */
      successor_list = control_successors(c);
 
      pips_assert("discard_a_control_sequence_without_its_statements: not a sequence.", gen_length(successor_list) <= 1);
 
      free_a_control_without_its_statement(c);
 
      if (c == end)
         break;
   }
}

References CAR, CONTROL, control_predecessors, control_successors, end, free_a_control_without_its_statement(), gen_length(), gen_remove(), MAP, and pips_assert.

Referenced by __attribute__(), restructure_this_test(), and take_out_the_entry_node_of_the_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

discard_an_unstructured_without_its_statements()

void discard_an_unstructured_without_its_statements

(

unstructured

u

)

Used to discard an unstructured without touching its statements.

The statements are assumed to be referenced in another way.

Parameters

he	unstructured to free

Protect the statements by unlinking them:

And then free the discard the unstructured:

Definition at line 1063 of file control.c.

{
   list blocs = NIL;
 
   /* Protect the statements by unlinking them: */
   CONTROL_MAP(c,
               {
                  control_statement(c) = statement_undefined;
               },
               unstructured_control(u),
               blocs);
   gen_free_list(blocs);
 
   /* And then free the discard the unstructured: */
   free_unstructured(u);
}

References CONTROL_MAP, control_statement, free_unstructured(), gen_free_list(), NIL, statement_undefined, and unstructured_control.

Referenced by __attribute__().

Here is the call graph for this function:

Here is the caller graph for this function:

display_address_of_control_nodes()

void display_address_of_control_nodes

(

list

cs

)

Display the adresses a list of control nodes.

Parameters

cs	is the control node list

Parameters

cs

s

Definition at line 612 of file control.c.

{
        MAP(CONTROL, cc,
            {
                fprintf(stderr, "%p,", cc);
            }, cs);
}

References CONTROL, fprintf(), and MAP.

Referenced by compact_list(), display_interval_graph(), display_linked_control_nodes(), hierarchize_control_list(), and interval_exit_nodes().

Here is the call graph for this function:

Here is the caller graph for this function:

display_linked_control_nodes()

void display_linked_control_nodes

(

control

c

)

Display all the control nodes reached or reachable from c for debugging purpose.

Display also the statement of each control node if the debug level is high enough

Parameters

c	is the control node we start the visit from

safe_print_statement(control_statement(ctl));

Definition at line 629 of file control.c.

{
  list blocs = NIL;
  set stmts = set_make(set_pointer);
 
  CONTROL_MAP(ctl, {
    fprintf(stderr, "%p (pred (#%zd)=", ctl,
            gen_length(control_predecessors(ctl)));
    display_address_of_control_nodes(control_predecessors(ctl));
    fprintf(stderr, " succ (#%zd)=", gen_length(control_successors(ctl)));
    display_address_of_control_nodes(control_successors(ctl));
    fprintf(stderr, "), ");
    ifdebug(8) {
      fprintf(stderr, "\n");
      pips_debug(8, "Statement %p of control %p:\n", control_statement(ctl), ctl);
      // FI: no cycle with prettyprint
      /* safe_print_statement(control_statement(ctl)); */
    }
    if(set_belong_p(stmts, control_statement(ctl))) {
      fprintf(stderr, "Statement %p is pointed by two different control nodes\n",
              control_statement(ctl));
    }
    else
      stmts = set_add_element(stmts, stmts, (void *) control_statement(ctl));
  }, c, blocs);
  gen_free_list(blocs);
  set_free(stmts);
 
  fprintf(stderr, "---\n");
}

References CONTROL_MAP, control_predecessors, control_statement, control_successors, display_address_of_control_nodes(), fprintf(), gen_free_list(), gen_length(), ifdebug, NIL, pips_debug, set_add_element(), set_belong_p(), set_free(), set_make(), and set_pointer.

Referenced by clean_up_control(), control_graph(), control_graph_recursive_decomposition(), controlize(), controlize_goto(), controlize_list(), controlize_list_1(), controlize_sequence(), controlize_statement(), controlize_test(), hierarchize_control_list(), recover_structured_while(), remove_all_unreachable_controls_of_an_unstructured(), remove_some_unreachable_controls_of_an_unstructured(), remove_unreachable_following_control(), simplified_unstructured(), unstructured_consistency_p(), and unstructured_while_p().

Here is the call graph for this function:

Here is the caller graph for this function:

free_a_control_without_its_statement()

void free_a_control_without_its_statement

(

control

c

)

Remove a control node without touching its statement, its predecessors and successors, if any.

Parameters

c	is the control node to free

Protect the statement:

Definition at line 1087 of file control.c.

                                                {
  /* Protect the statement: */
  control_statement(c) = statement_undefined;
  gen_free_list(control_successors(c));
  control_successors(c) = NIL;
  gen_free_list(control_predecessors(c));
  control_predecessors(c) = NIL;
 
  free_control(c);
}

References control_predecessors, control_statement, control_successors, free_control(), gen_free_list(), NIL, and statement_undefined.

Referenced by controlize_test(), discard_a_control_sequence_without_its_statements(), and hcfg().

Here is the call graph for this function:

Here is the caller graph for this function:

fuse_2_control_nodes()

void fuse_2_control_nodes	(	control	first,
		control	second
	)

Fuse a 2 control nodes.

It adds the statement of the second one to the statement of the first one. Assumes that the second node is the only successor of the first one.

The second control node is freed.

It does not update the entry or exit field of the unstructured.

Parameters

first	is the first control node
second	is the control node to fuse in the first one. It is precised because it is possible that there are not connected.

If the second node has 2 successors, it is a test node. The fused node has 2 successors and must be a test too. So, the only thing I can do is to remove the first statement, just keeping its comments. And how about the label? It might be useful for syntactic reasons and only reachable via END=nnn after prettyprinting (see Validation/redlec2.f)

A return might be OK?!? What does the caller expect? The first label must be useless and is dropped.

pips_user_warning("Useless label %s\n", entity_name(first_label));

pips_internal_error("Two labels for one control node");

If not, build a block with the two statements:

Reconnect the new statement to the node to fuse:

Unlink the second node from the first one:

Link the first node with the successors of the second one in the forward direction:

Update all the predecessors of the successors:

Transfer the predecessors of the second node to the first one. Note that the original second -> first predecessor link has already been removed. But a loop from second to second appear at this point as a link from first to second. Nasty bug...

Now we remove the useless intermediate node "second":

Do not gen_free_list(control_successors(second)) since it is used as control_successors(first) now:

Parameters

first	irst
second	econd

Definition at line 1391 of file control.c.

{
    if (gen_length(control_successors(second)) == 2) {
        /* If the second node has 2 successors, it is a test node. The
           fused node has 2 successors and must be a test too. So, the
           only thing I can do is to remove the first statement, just
           keeping its comments. And how about the label? It might be
           useful for syntactic reasons and only reachable via END=nnn
           after prettyprinting (see Validation/redlec2.f) */
        string first_comment =
            gather_all_comments_of_a_statement(control_statement(first));
        entity first_label = statement_to_label(control_statement(first));
 
        if(!entity_empty_label_p(first_label)) {
          entity second_label = statement_to_label(control_statement(second));
            pips_user_warning("Useless label %s\n",
                              entity_name(first_label));
          if(!entity_empty_label_p(second_label)) {
            /* A return might be OK?!? What does the caller expect? The
               first label must be useless and is dropped. */
            /* pips_user_warning("Useless label %s\n",
               entity_name(first_label)); */
            /* pips_internal_error("Two labels for one control node"); */
            ;
          }
          else {
            statement_label(control_statement(second)) = first_label;
            ;
          }
        }
        insert_comments_to_statement(control_statement(second),
                                     first_comment);
        control_statement(first) = control_statement(second);
    }
    else {
        /* If not, build a block with the two statements: */
        statement st = make_empty_statement();
        statement_instruction(st) =
            make_instruction_block(CONS(STATEMENT,
                                        control_statement(first),
                                        CONS(STATEMENT,
                                             control_statement(second), NIL)));
        /* Reconnect the new statement to the node to fuse: */
        control_statement(first) = st;
    }
    control_statement(second) = statement_undefined;
 
    /* Unlink the second node from the first one: */
    gen_free_list(control_successors(first));
    gen_remove(&control_predecessors(second), first);
 
    /* Link the first node with the successors of the second one in
       the forward direction: */
    control_successors(first) =
        control_successors(second);
    /* Update all the predecessors of the successors: */
    MAP(CONTROL, c,
        {
            MAPL(cp,
                 {
                     if (CONTROL(CAR(cp)) == second)
                         CONTROL_(CAR(cp)) = first;
                 }, control_predecessors(c));
        }, control_successors(first));
 
    /* Transfer the predecessors of the second node to the first one.
       Note that the original second -> first predecessor link has
       already been removed. But a loop from second to second appear
       at this point as a link from first to second. Nasty bug... */
    MAP(CONTROL, c,
        {
            control_predecessors(first) = CONS(CONTROL,
                                               c,
                                               control_predecessors(first));
            MAPL(cp,
                 {
                     if (CONTROL(CAR(cp)) == second) {
                         CONTROL_(CAR(cp)) = first;
                     }
                 }, control_successors(c));
        }, control_predecessors(second));
 
    /* Now we remove the useless intermediate node "second": */
    /* Do not gen_free_list(control_successors(second)) since it is
       used as control_successors(first) now: */
    control_successors(second) = NIL;
    gen_free_list(control_predecessors(second));
    control_predecessors(second) = NIL;
    free_control(second);
}

References CAR, CONS, CONTROL, CONTROL_, control_predecessors, control_statement, control_successors, cp, entity_empty_label_p(), entity_name, free_control(), gather_all_comments_of_a_statement(), gen_free_list(), gen_length(), gen_remove(), insert_comments_to_statement(), make_empty_statement, make_instruction_block(), MAP, MAPL, NIL, pips_user_warning, STATEMENT, statement_instruction, statement_label, statement_to_label(), and statement_undefined.

Referenced by fuse_sequences_in_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_a_statement_list_from_a_control_sequence()

list generate_a_statement_list_from_a_control_sequence	(	control	begin,
		control	end
	)

Take a control sequence and return a list of all the statements in the sequence (in the same order...

:-) ).

Parameters

begin	is the control node we start from
end	is the control node to stop at

Of course, there should be a unique path from begin to end.

Because of the way CONS is working, reversed the walk through the sequence.

Add the statement to the list:

Parameters

begin	egin
end	nd

Definition at line 1156 of file control.c.

{
   control c;
   list the_statements_of_the_sequence = NIL;
 
   /* Because of the way CONS is working, reversed the walk through
      the sequence. */
 
   for(c = end; ; c = CONTROL(CAR(control_predecessors(c)))) {
      int number_of_predecessor = gen_length(control_predecessors(c));
      pips_assert("discard_a_control_sequence_without_its_statements: not a sequence.", number_of_predecessor <= 1);
 
      /* Add the statement to the list: */
      the_statements_of_the_sequence = CONS(STATEMENT,
                                            control_statement(c),
                                            the_statements_of_the_sequence);
      if (c == begin)
         break;
   }
 
   return the_statements_of_the_sequence;
}

References CAR, CONS, CONTROL, control_predecessors, control_statement, end, gen_length(), NIL, pips_assert, and STATEMENT.

Referenced by __attribute__().

Here is the call graph for this function:

Here is the caller graph for this function:

insert_control_in_arc()

void insert_control_in_arc	(	control	c,
		control	before,
		control	after
	)

Insert a control node between 2 connected control nodes.

Parameters

c	is the control node to insert
before	is the control node before where c is to be inserted
after	is the control node after where c is to be inserted

Assume that c is not already connected and that after is the successor of before.

Note: statements associated to nodes are not tested in case they are undefined.

If there is no ambiguity about the linking, use Ronan's technique

Let's try to preserve the true and false branch

Parameters

before	efore
after	fter

Definition at line 1299 of file control.c.

                                                                     {
  // These first two assertions are wrong when "before" is a test whose two
  // branches reach "after":
  //
  // if(c) goto l1; else goto l1; l1: ;
  //
  // This is unlikely but does happen when macros are used or when
  // some code is generated automatically. FI assumes that the two
  // substitutions will happen simultaneously thanks to the
  // substitutions in the list
  pips_assert("c is not already a successor of before",
              !is_control_in_list_p(c, control_successors(before)));
 
  // This may be wrong if c has already been inserted in another
  //arc. Nevertheless it may be useful to insert it in the "before->after" arc.
  //
  //pips_assert("c is not a predecessor of after",
  //          !is_control_in_list_p(c, control_predecessors(after)));
 
  // Make sure that before and after are properly linked
  pips_assert("after is a successor of before",
              is_control_in_list_p(after, control_successors(before)));
  pips_assert("before is a predecessor of after",
              is_control_in_list_p(before, control_predecessors(after)));
 
  // FI: we might also assert that the statement associated to c is
  // not a test... but it is not possible when sequences are
  // transformed into a chain of nodes. So, temporarily, you can have
  // test control nodes with only one successor. May be definitely if
  // they are structured?
  //pips_assert("c is not a test: it has only one successor at most",
  //          !statement_test_p(control_statement(c)));
 
  // FI: when before is a test, how do you know if c must be in the
  // true or in the false branch?
  /* If there is no ambiguity about the linking, use Ronan's technique */
  if(gen_length(control_successors(before))==1
     && gen_length(control_successors(c))==0) {
    unlink_2_control_nodes(before, after);
    link_2_control_nodes(before, c);
    link_2_control_nodes(c, after);
  }
  else if(gen_length(control_successors(c))==0) {
    /* Let's try to preserve the true and false branch */
    bool success1 = gen_replace_in_list(control_successors(before), after, c);
    bool success2 = gen_replace_in_list(control_predecessors(after), before, c);
    // The order is meaning less, but it is easier to debug if the
    // order is preserved
    control_predecessors(c)
      = gen_nconc(control_predecessors(c), CONS(CONTROL, before, NIL));
    //control_predecessors(c) = CONS(CONTROL, before, NIL);
    control_successors(c) = CONS(CONTROL, after, NIL);
 
    pips_assert("after and before were linked", success1 && success2);
    pips_debug(8, "control %p inserted between before=%p and after=%p\n",
               c, before, after);
  }
  else if(gen_length(control_successors(c))==1
       && CONTROL(CAR(control_successors(c)))==after) {
    // We may handle the case outlined above?
    // The two substitutions should have occured simultaneously?
    // No, simply the more general case:
    // precondition: x -> c && c -> after && before -> after
    // postcondition x -> c && before -> c && c -> after
    // pips_internal_error("Should not happen\n");
    // Preserve the branch positions for tests
    bool success = gen_replace_in_list(control_successors(before), after, c);
    gen_remove(&control_predecessors(after), before);
    control_predecessors(c)
      = gen_nconc(control_predecessors(c), CONS(CONTROL, before, NIL));
    pips_assert("after and before were linked", success);
  }
  else
    pips_internal_error("No semantics, no implementation...\n");
}

References CAR, CONS, CONTROL, control_predecessors, control_successors, gen_length(), gen_nconc(), gen_remove(), gen_replace_in_list(), is_control_in_list_p(), link_2_control_nodes(), NIL, pips_assert, pips_debug, pips_internal_error, and unlink_2_control_nodes().

Referenced by controlize_forloop(), controlize_loop(), and find_exit_control_node().

Here is the call graph for this function:

Here is the caller graph for this function:

is_control_in_list_p()

bool is_control_in_list_p	(	control	c,
		list	cs
	)

Test if a control node is in a list of control nodes.

FI: is this different from gen_in_list_p(), but for the c type and the qualifiers?

Parameters

c	control node to look for
cs	is the list of control to search through

Returns

true if the control node is in the list

Parameters

cs

s

Definition at line 299 of file control.c.

{
    MAP(CONTROL, cc, {
        if (cc == c)
            return true;
    }, cs);
    return false;
}

References CONTROL, and MAP.

Referenced by insert_control_in_arc(), and wide_forward_control_map_get_blocs().

Here is the caller graph for this function:

link_2_control_nodes()

void link_2_control_nodes	(	control	source,
		control	target
	)

Add an edge between 2 control nodes.

Assume that this edge does not already exist or the source should be an unstructured IF. FI: I am still puzzled how this can work when tests are involved since the semantics of the first and second successor is not paid attention at at all.

Parameters

source	is the control node the edge starts from
target	is the control node the edge ends to

Parameters

source	ource
target	arget

Definition at line 1193 of file control.c.

{
  // FI: should we check here that the statement of "source" is
  // defined and if it is defined and that it already has a successor
  // then it is a test? Might be better done here than later when
  // trying to print out the statements...
  // FI: I think this explains why for loops are improperly desugared...
 
  // FI: this assert is too strong because if statements are
  // considered potentially structured and are linked like any other
  // statement when processing a statement
  //
  // pips_assert("source is not a test\n",
  //      statement_undefined_p(control_statement(source))
  //      || !statement_test_p(control_statement(source)));
 
  // FI: to avoid memory leaks and/or inconsistency
  //pips_assert("source has no successor\n", ENDP(control_successors(source)));
 
#if 0
  if(!ENDP(control_successors(source)))
    // FI: this should never happen if the graph is properly
    // handled...
    // I could re-instate the assert and/or just set a breakpoint on
    // the gen_free_list()
    gen_free_list(control_successors(source));
  control_successors(source) = CONS(CONTROL, target, NIL);
#endif
 
  // FI: assume the callers knows what it is doing when dealing with tests...
  control_successors(source) = CONS(CONTROL,
                                    target,
                                    control_successors(source));
 
  // FI: guess to get for loop properly desugared... but it breaks
  // something else...
  //control_successors(source) =
  //    gen_nconc(control_successors(source), CONS(CONTROL, target, NIL));
  control_predecessors(target) = CONS(CONTROL,
                                      source,
                                      control_predecessors(target));
}

References CONS, CONTROL, control_predecessors, control_successors, ENDP, gen_free_list(), and NIL.

Referenced by connect_unstructured(), controlize(), controlize_forloop(), controlize_goto(), controlize_list(), controlize_loop(), controlize_repeatloop(), controlize_sequence(), controlize_test(), controlize_whileloop(), full_spaghettify_module(), full_spaghettify_statement(), hcfg(), hierarchize_control_list(), insert_control_in_arc(), make_unstructured_from_forloop(), make_unstructured_from_loop(), make_unstructured_from_test(), move_declaration_control_node_declarations_to_statement(), recover_structured_while(), reduce_sequence(), replace_control_with_unstructured(), and restructure_this_test().

Here is the call graph for this function:

Here is the caller graph for this function:

link_3_control_nodes()

void link_3_control_nodes	(	control	c_test,
		control	c_then,
		control	c_else
	)

Add an edge between 2 control nodes.

Assume that this edge does not already exist or the source should be an unstructured IF. FI: I am still puzzled how this can work when tests are involved since the semantics of the first and second successor is not paid attention at at all.

Parameters

source	is the control node the edge starts from
target	is the control node the edge ends to

Parameters

c_test	_test
c_then	_then
c_else	_else

Definition at line 1249 of file control.c.

{
  if(!ENDP(control_successors(c_test)))
    gen_free_list(control_successors(c_test));
  control_successors(c_test) =
    CONS(CONTROL, c_then, CONS(CONTROL, c_else, NIL));
 
  control_predecessors(c_then) = CONS(CONTROL,
                                      c_test,
                                      control_predecessors(c_then));
  control_predecessors(c_else) = CONS(CONTROL,
                                      c_test,
                                      control_predecessors(c_else));
}

References c_test(), CONS, CONTROL, control_predecessors, control_successors, ENDP, gen_free_list(), and NIL.

Referenced by controlize_repeatloop(), controlize_test(), controlize_whileloop(), make_unstructured_from_test(), and make_unstructured_from_whileloop().

Here is the call graph for this function:

Here is the caller graph for this function:

occurences_in_control_list()

int occurences_in_control_list	(	control	c,
		list	cs
	)

Count the number of occurences of a control node in a list of control nodes.

Parameters

c	control node to look for
cs	is the list of control to count through

Returns

the number of occurences

Parameters

cs

s

Definition at line 319 of file control.c.

{
    return gen_occurences((gen_chunk *) c, cs);
}

References gen_occurences().

Referenced by check_control_coherency().

Here is the call graph for this function:

Here is the caller graph for this function:

print_control_node()

void print_control_node

(

control

c

)

Definition at line 566 of file control.c.

{
  fprintf(stderr,
          "ctr %p, %zd preds, %zd succs: %s",
          c,
          gen_length(control_predecessors(c)),
          gen_length(control_successors(c)),
          safe_statement_identification(control_statement(c)));
  fprintf(stderr,"\tsuccessors:\n");
  MAP(CONTROL, s, {
    fprintf(stderr, "\t\t%p %s", s,
            safe_statement_identification(control_statement(s)));
  }, control_successors(c));
  fprintf(stderr,"\tpredecessors:\n");
  MAP(CONTROL, p, {
    fprintf(stderr, "\t\t%p %s", p,
            safe_statement_identification(control_statement(p)));
  }, control_predecessors(c));
  fprintf(stderr, "\n");
}

References CONTROL, control_predecessors, control_statement, control_successors, fprintf(), gen_length(), MAP, and safe_statement_identification().

Here is the call graph for this function:

print_control_nodes()

void print_control_nodes

(

list

l

)

Display identification of a list of control nodes.

Definition at line 589 of file control.c.

{
  if(ENDP(l)) {
    fprintf(stderr, "empty control list");
  }
  else {
    MAP(CONTROL, c, {
      fprintf(stderr, "%p, %s", c,
              safe_statement_identification(control_statement(c)));
      // The version used in control/bourdoncle.c also had this check
      // (void) check_control_statement(c);
    }, l);
  }
  fprintf(stderr, "\n");
}

References CONTROL, control_statement, ENDP, fprintf(), MAP, and safe_statement_identification().

Referenced by ancestor_map_consistent_p(), bourdoncle_component(), bourdoncle_partition(), controlize_sequence(), node_to_linked_nodes(), scc_to_dag(), and update_partition().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_a_control_from_a_list_and_relink()

void remove_a_control_from_a_list_and_relink	(	control	c,
		list	a_source_control_list_of_c,
		list	a_dest_control_list_of_c,
		remove_a_control_from_a_list_and_relink_direction	which_way
	)

Replace each occurence of c in a_source_control_list_of_c with a a_dest_control_list_of_c:

Parameters

c	is the control node to unlink. It is not freed
a_source_control_list_of_c	is the list of control nodes to be linked to the a_dest_control_list_of_c list of control nodes
a_dest_control_list_of_c	is the list of control nodes to be linked from the a_source_control_list_of_c list of control nodes
which_way	precise if we deal with successors or predecessors:

• if it is source_is_predecessor_and_dest_is_successor: a_source_control_list_of_c is considered as predecessors of c and a_dest_control_list_of_c is considered as successors of c

-if it is source_is_successor_and_dest_is_predecessor: a_source_control_list_of_c is considered as successors of c and a_dest_control_list_of_c is considered as predecessors of c

Now, find the corresponding dest in the source list with the same value as c:

Find the reference to c in the the_dest_of_a_source_list:

l is local to the MAPL...

And add the a_dest_control_list_of_c instead of c:

First concatenate (with copy) a_dest_control_list_of_c before what follow c in the list:

Then place this list instead of c in the_dest_of_a_source_list:

Modify the begin of the list:

Deallocate the cons that point to c:

c is now in the memory nowhere:

Parameters

a_source_control_list_of_c	_source_control_list_of_c
a_dest_control_list_of_c	_dest_control_list_of_c
which_way	hich_way

Definition at line 913 of file control.c.

{
   MAPL(a_control_list,
        {
           list *the_dest_of_a_source_list = NULL;
           list the_position_of_c = NIL;
           list the_position_before_c = NIL;
           list l = NIL;
 
           control a_dest_of_a_source = CONTROL(CAR(a_control_list));
           /* Now, find the corresponding dest in the source list
              with the same value as c: */
           switch(which_way) {
             case source_is_predecessor_and_dest_is_successor:
               the_dest_of_a_source_list = &control_successors(a_dest_of_a_source);
               break;
             case source_is_successor_and_dest_is_predecessor:
               the_dest_of_a_source_list = &control_predecessors(a_dest_of_a_source);
               break;
             default:
               pips_assert("remove_a_control_from_a_list_and_relink with not a good \"which_way\".\n", false);
           }
 
           /* Find the reference to c in the the_dest_of_a_source_list: */
           the_position_before_c = NIL;
           MAPL(a_list,
                {
                   /* l is local to the MAPL... */
                   if (CONTROL(CAR(the_position_of_c = a_list)) == c)
                      break;
                   the_position_before_c = the_position_of_c;
                },
                   *the_dest_of_a_source_list);
 
           /* And add the a_dest_control_list_of_c instead of c: */
           /* First concatenate (with copy) a_dest_control_list_of_c
              before what follow c in the list: */
           l = gen_append(a_dest_control_list_of_c, CDR(the_position_of_c));
 
           /* Then place this list instead of c in
              *the_dest_of_a_source_list: */
           if (the_position_before_c == NIL)
              /* Modify the begin of the list: */
              *the_dest_of_a_source_list = l;
           else
              CDR(the_position_before_c) = l;
 
           /* Deallocate the cons that point to c: */
           CDR(the_position_of_c) = NIL;
           gen_free_list(the_position_of_c);
        },
           a_source_control_list_of_c);
 
   /* c is now in the memory nowhere: */
   control_predecessors(c) = NIL;
   control_successors(c) = NIL;
}

References CAR, CDR, CONTROL, control_predecessors, control_successors, gen_append(), gen_free_list(), MAPL, NIL, pips_assert, source_is_predecessor_and_dest_is_successor, and source_is_successor_and_dest_is_predecessor.

Referenced by remove_a_control_from_an_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_a_control_from_an_unstructured()

void remove_a_control_from_an_unstructured

(

control

c

)

Remove a control node from a control graph.

The control node is freed and its predecessors are relinked to its successor and relink the successor and the predecessor.

If you want to preserve the control statement, do a control_statement(c) = statement_undefined before calling this function.

Parameters

[in,out]

c

is the control node to unlink and to free

Assume that it cannot have more than 1 successor (so no test node)

If the graph is in an unstructured and c is either the entry or exit node, do not forget to update the entry or exit node.

Unlink from the predecessor. Note that a node may have more than one predecessor. Since we cannot discard an IF this way, we have at most 1 successor:

Unlink from the successor:

Remove the control node:

Definition at line 992 of file control.c.

{
   list the_predecessors = control_predecessors(c);
   list the_successors = control_successors(c);
 
   int number_of_successors = gen_length(the_successors);
 
   /* Unlink from the predecessor. Note that a node may have more than
      one predecessor. Since we cannot discard an IF this way, we have
      at most 1 successor: */
   pips_assert("remove_a_control_from_an_unstructured:"
               " no more than one successor",
               number_of_successors <= 1);
   remove_a_control_from_a_list_and_relink(c,
                                           the_predecessors,
                                           the_successors,
                                           source_is_predecessor_and_dest_is_successor);
 
   /* Unlink from the successor: */
   remove_a_control_from_a_list_and_relink(c,
                                           the_successors,
                                           the_predecessors,
                                           source_is_successor_and_dest_is_predecessor);
 
   /* Remove the control node: */
   free_control(c);
}

References control_predecessors, control_successors, free_control(), gen_length(), pips_assert, remove_a_control_from_a_list_and_relink(), source_is_predecessor_and_dest_is_successor, and source_is_successor_and_dest_is_predecessor.

Referenced by compact_list(), controlize_forloop(), controlize_loop(), controlize_repeatloop(), controlize_sequence(), controlize_whileloop(), and remove_useless_continue_or_empty_code_in_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_a_control_from_an_unstructured_without_relinking()

void remove_a_control_from_an_unstructured_without_relinking

(

control

c

)

It removes a control node from its successor and predecessor.

It can be applied to an unstructured "IF".

Parameters

c	is the control node to unlink and to free

If the graph is in an unstructured and

Parameters

c	is either the entry or exit node, do not forget to update the entry or exit node.

Use a copy since we iterate and discard at the same time:

Remove the control node itself:

Definition at line 1031 of file control.c.

{
   /* Use a copy since we iterate and discard at the same time: */
   list the_predecessors = gen_copy_seq(control_predecessors(c));
   list the_successors = gen_copy_seq(control_successors(c));
 
   MAP(CONTROL, a_predecessor, {
      unlink_2_control_nodes(a_predecessor, c);
   }, the_predecessors);
   gen_free_list(the_predecessors);
 
   MAP(CONTROL, a_successor, {
      unlink_2_control_nodes(c, a_successor);
   }, the_successors);
   gen_free_list(the_successors);
 
   pips_assert("The control node should not have any connection here,",
               control_predecessors(c) == NIL && control_successors(c) == NIL);
   /* Remove the control node itself: */
   free_control(c);
}

References CONTROL, control_predecessors, control_successors, free_control(), gen_copy_seq(), gen_free_list(), MAP, NIL, pips_assert, and unlink_2_control_nodes().

Referenced by controlize_sequence(), controlize_test(), recover_structured_while(), and remove_all_unreachable_controls_of_an_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_all_unreachable_controls_of_an_unstructured()

void remove_all_unreachable_controls_of_an_unstructured

(

unstructured

u

)

Remove all control nodes that are not forward reachable from the entry node.

Warning: useful FORMAT that are unreachable are also discarded, so...

Parameters

u	is the unstructured to clean

The entry point of the unstructured:

Mark all the forward-reachable nodes:

Now build the remove list from all the non-marked nodes:

The same thing from the exit node that may be not reachable from the entry node:

And delete them:

Definition at line 812 of file control.c.

{
    list blocs = NIL;
 
    set useful_controls = set_make(set_pointer);
    set unreachable_controls = set_make(set_pointer);
 
    /* The entry point of the unstructured: */
    control entry_node = unstructured_control(u);
    control exit_node = unstructured_exit(u);
    pips_debug(7, "From control %p, exit %p.\n", entry_node, exit_node);
    ifdebug(7) {
        display_linked_control_nodes(entry_node);
    }
 
    /* Mark all the forward-reachable nodes: */
    FORWARD_CONTROL_MAP(c, {
       pips_debug(5, "Forward visiting control node %p.\n", c);
       set_add_element(useful_controls,
                       useful_controls,
                       (char *) c);
    },
       entry_node,
       blocs);
    gen_free_list(blocs);
    blocs = NIL;
 
    /* Now build the remove list from all the non-marked nodes: */
    CONTROL_MAP(c, {
       pips_debug(5, "Testing control node %p.\n", c);
       if (! set_belong_p(useful_controls, (char *) c)) {
          pips_debug(5, "Adding to the removing list control node %p.\n", c);
          set_add_element(unreachable_controls,
                          unreachable_controls,
                          (char *) c);
       }
    },
       entry_node,
       blocs);
    gen_free_list(blocs);
    blocs = NIL;
 
    /* The same thing from the exit node that may be not reachable
       from the entry node: */
    CONTROL_MAP(c, {
       pips_debug(5, "Testing from exit control node %p.\n", c);
       if (! set_belong_p(useful_controls, (char *) c)) {
          pips_debug(5, "From exit node: Adding to the removing list control node %p.\n", c);
          set_add_element(unreachable_controls,
                          unreachable_controls,
                          (char *) c);
       }
    },
       exit_node,
       blocs);
    gen_free_list(blocs);
 
    /* And delete them: */
    SET_MAP(cc, {
       control c = (control) cc;
       if (c == exit_node) {
          pips_debug(5, "Skipping discarding exit control node %p.\n", c);
       }
       else {
          pips_debug(5, "Discarding control node %p.\n", c);
          if (format_inside_statement_p(control_statement(c)))
             pips_user_warning("Discarding an unreachable FORMAT that may be "
                               "usefull. "
                               "Try to use the GATHER_FORMATS_AT_BEGINNING "
                               "property.\n");
          remove_a_control_from_an_unstructured_without_relinking(c);
       }
    },
       unreachable_controls);
    set_free(useful_controls);
    set_free(unreachable_controls);
}

References CONTROL_MAP, control_statement, display_linked_control_nodes(), format_inside_statement_p(), FORWARD_CONTROL_MAP, gen_free_list(), ifdebug, NIL, pips_debug, pips_user_warning, remove_a_control_from_an_unstructured_without_relinking(), set_add_element(), set_belong_p(), set_free(), set_make(), SET_MAP, set_pointer, unstructured_control, and unstructured_exit.

Referenced by clean_up_control().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_some_unreachable_controls_of_an_unstructured()

void remove_some_unreachable_controls_of_an_unstructured

(

unstructured

u

)

Remove all the control sequences that are unreachable and that begin with a node without any predecessor.

It is an old version and a normal user should use remove_all_unreachable_controls_of_an_unstructured() instead.

It is still buggy on Validation/Syntax/asgoto.f...

The entry point of the unstructured:

Well, the entry node is guessed as reachable... :-)

A control without predecessor is unreachable, so it is dead code:

Note that we could have entry_node == exit_node...

Now remove all the marqued sequences from the entry_node:

Do not forget the unreachable exit part if it is not connex to the entry_node:

Do not remove the exit_node...

A control without predecessor is unreachable, so it is dead code:

Now remove all the marqued sequences from the entry_node:

Definition at line 730 of file control.c.

{
    list blocs = NIL;
    list control_remove_list = NIL;
 
    /* The entry point of the unstructured: */
    control entry_node = unstructured_control(u);
    control exit_node = unstructured_exit(u);
    bool exit_node_has_been_seen = false;
    pips_debug(7, "From control %p, exit %p.\n", entry_node, exit_node);
    ifdebug(7) {
        display_linked_control_nodes(entry_node);
    }
 
    CONTROL_MAP(c,
                {
                    if (c != entry_node)
                        /* Well, the entry node is guessed as
                           reachable... :-) */
                        if (control_predecessors(c) == NIL) {
                            /* A control without predecessor is
                               unreachable, so it is dead code: */
                            pips_debug(7, "Want to discard control %p.\n", c);
                            control_remove_list = CONS(CONTROL,
                                                       c,
                                                       control_remove_list);
                        }
                    if (c == exit_node)
                        /* Note that we could have entry_node ==
                           exit_node... */
                        exit_node_has_been_seen = true;
                },
                entry_node,
                blocs);
    gen_free_list(blocs);
 
    /* Now remove all the marqued sequences from the entry_node: */
    MAP(CONTROL, c,
        {
            remove_unreachable_following_control(c, entry_node, exit_node);
        },
        control_remove_list);
    gen_free_list(control_remove_list);
 
    if (!exit_node_has_been_seen) {
        /* Do not forget the unreachable exit part if it is not connex
           to the entry_node: */
        blocs = NIL;
        control_remove_list = NIL;
        CONTROL_MAP(c,
                    {
                        if (c != exit_node)
                            /* Do not remove the exit_node... */
                            if (control_predecessors(c) == NIL) {
                                /* A control without predecessor is
                                   unreachable, so it is dead code: */
                                control_remove_list = CONS(CONTROL,
                                                           c,
                                                           control_remove_list);
                            }
                    },
                    exit_node,
                    blocs);
        gen_free_list(blocs);
        /* Now remove all the marqued sequences from the entry_node: */
        MAP(CONTROL, c,
            {
                remove_unreachable_following_control(c, entry_node, exit_node);
            },
            control_remove_list);
        gen_free_list(control_remove_list);
    }
}

References CONS, CONTROL, CONTROL_MAP, control_predecessors, display_linked_control_nodes(), gen_free_list(), ifdebug, MAP, NIL, pips_debug, remove_unreachable_following_control(), unstructured_control, and unstructured_exit.

Here is the call graph for this function:

remove_unreachable_following_control()

void remove_unreachable_following_control	(	control	c,
		control	do_not_delete_node,
		control	do_not_delete_node_either
	)

Remove all the control nodes (with their statements) from c in the successor tree of c up to the nodes with more than 1 predecessor, that is when it reach another flow.

The entry node of the unstructured is given to avoid removing it when there is an unreachable sequence pointing on it.

If a control node contains a FORMAT, assume that it is useful and stop removing.

The

Parameters

do_not_delete_node	is expected to be the entry or the exit node for example in order not to delete them.
c	is the control we start the deletion from.
do_not_delete_node	is a control node we stop at when encountered
do_not_delete_node_either	is another control node we stop at when encountered

If this is the do_not_delete_node nodes: stop deleting:

If this is not or no more the begin of a sequence, stop deleting:

If there is a FORMAT inside a control node, just stop deleting the control nodes since we cannot decide locally if the FORMAT is useful or not:

Save the successor list since we iterate o it and discard it at the same time:

Ok, we can delete. For each successor of c:

Remove any predecessor reference of itself in this successor:

Discard the control node itself:

Parameters

do_not_delete_node	o_not_delete_node
do_not_delete_node_either	o_not_delete_node_either

Definition at line 682 of file control.c.

{
    list the_successors;
 
    /* If this is the do_not_delete_node nodes: stop deleting: */
    if (c == do_not_delete_node || c == do_not_delete_node_either)
        return;
    /* If this is not or no more the begin of a sequence, stop deleting: */
    if (control_predecessors(c) != NIL)
        return;
    /* If there is a FORMAT inside a control node, just stop deleting
       the control nodes since we cannot decide locally if the FORMAT
       is useful or not: */
    if (format_inside_statement_p(control_statement(c)))
        return;
 
    /* Save the successor list since we iterate o it and discard it at
       the same time: */
    the_successors = gen_copy_seq(control_successors(c));
    /* Ok, we can delete. For each successor of c: */
    MAP(CONTROL, a_successor, {
       /* Remove any predecessor reference of itself in this
          successor: */
       unlink_2_control_nodes(c, a_successor);
       remove_unreachable_following_control(a_successor,
                                            do_not_delete_node,
                                            do_not_delete_node_either);
    }, the_successors);
    gen_free_list(the_successors);
 
    /* Discard the control node itself: */
    pips_debug(7, "Discarding control node %p.\n", c);
    ifdebug(7) {
        display_linked_control_nodes(c);
    }
    free_control(c);
}

References CONTROL, control_predecessors, control_statement, control_successors, display_linked_control_nodes(), format_inside_statement_p(), free_control(), gen_copy_seq(), gen_free_list(), ifdebug, MAP, NIL, pips_debug, and unlink_2_control_nodes().

Referenced by remove_some_unreachable_controls_of_an_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_control_related_to_a_list()

void replace_control_related_to_a_list	(	control	old_node,
		control	new_node,
		list	controls
	)

Replace all the references to a control node by a new one in the successors & predecessors of a list of controls.

Parameters

old_node	is the control node to replace
new_node	is the control node to replace
controls	is a list of controls we want to disconnect from old_node and reconnect to new_node instead

Need a intermediate list since we cannot iterate on control_successors(old_node) for example and modifying it...

Since we need to keep successors order (to avoid for example IF/THEN/ELSE transformed in IF/ELSE/THEN), iterate directly on the links of old_node instead of on controls:

First transfer the successors in controls from old_node to new_node:

Use gen_nconc to keep test order:

And then do the modification:

Hmmm... We need to transfer a loop around old_node to a loop around new_node:

Create the new loop around new_node:

Delete the old one. Use gen_remove_once() instead of gen_remove() to deal with double loops around a node (See hierarchy02.f in validation):

And then transfer the predecessors in controls from old_node to new_node (the previous double loops have disappeared here):

Use gen_nconc to keep test order:

And then do the modification:

Parameters

old_node	ld_node
new_node	ew_node
controls	ontrols

Definition at line 419 of file control.c.

{
    /* Need a intermediate list since we cannot iterate on
       control_successors(old_node) for example and modifying it...*/
    list controls_to_change = NIL;
    /* Since we need to keep successors order (to avoid for example
       IF/THEN/ELSE transformed in IF/ELSE/THEN), iterate directly on
       the links of old_node instead of on controls: */
    /* First transfer the successors in controls from old_node to
       new_node: */
    MAP(CONTROL, c, {
        if (gen_in_list_p(c, controls))
            /* Use gen_nconc to keep test order: */
            controls_to_change = gen_nconc(controls_to_change,
                                           CONS(CONTROL, c, NIL));
    }, control_successors(old_node));
    /* And then do the modification: */
    MAP(CONTROL, c, {
        pips_debug(8, "Transfer old node %p to new node %p in successor %p\n", old_node, new_node, c);
        if (c != old_node)
            transfer_control_successor(old_node, new_node, c);
        else {
            /* Hmmm... We need to transfer a loop around old_node to a
               loop around new_node: */
            /* Create the new loop around new_node: */
            control_successors(new_node) =
                gen_nconc(control_successors(new_node),
                          CONS(CONTROL, new_node, NIL));
            control_predecessors(new_node) =
                gen_nconc(control_predecessors(new_node),
                          CONS(CONTROL, new_node, NIL));
            /* Delete the old one. Use gen_remove_once() instead of
               gen_remove() to deal with double loops around a node
               (See hierarchy02.f in validation): */
            gen_remove_once(&control_successors(old_node), (gen_chunk *) old_node);
            gen_remove_once(&control_predecessors(old_node), (gen_chunk *) old_node);
        }
    }, controls_to_change);
    gen_free_list(controls_to_change);
 
    /* And then transfer the predecessors in controls from old_node to
       new_node (the previous double loops have disappeared here): */
    controls_to_change = NIL;
    MAP(CONTROL, c, {
        if (gen_in_list_p(c, controls))
            /* Use gen_nconc to keep test order: */
            controls_to_change = gen_nconc(controls_to_change,
                                           CONS(CONTROL, c, NIL));
    }, control_predecessors(old_node));
    /* And then do the modification: */
    MAP(CONTROL, c, {
        pips_debug(8, "Transfer old node %p to new node %p in predecessor %p\n", old_node, new_node, c);
        transfer_control_predecessor(old_node, new_node, c);
    }, controls_to_change);
    gen_free_list(controls_to_change);
}

References CONS, CONTROL, control_predecessors, control_successors, gen_free_list(), gen_in_list_p(), gen_nconc(), gen_remove_once(), MAP, NIL, pips_debug, transfer_control_predecessor(), and transfer_control_successor().

Here is the call graph for this function:

transfer_control_predecessor()

void transfer_control_predecessor	(	control	old_node,
		control	new_node,
		control	c
	)

Transfer a control node as a predecessor from one node to another one.

It disconnected a node c that was pointing to (was a predecessor of) old_node and reconnect it to new_node that becomes its new successor instead.

Parameters

old_node	the control node that was a successor of c
new_node	the control node that will be a successor of c
c	the control node that is disconnected of old_node and connected to new_node

Add c as a predecessor of new_node:

Remove c as a predecessor of old_node:

Correct the reverse link c->old_node to c->new_node:

Parameters

old_node	ld_node
new_node	ew_node

Definition at line 358 of file control.c.

{
    MAP(CONTROL, predecessor, {
        if (predecessor == c)
            /* Add c as a predecessor of new_node: */
            control_predecessors(new_node) =
                gen_nconc(control_predecessors(new_node),
                          CONS(CONTROL, c, NIL));
    }, control_predecessors(old_node));
    /* Remove c as a predecessor of old_node: */
    gen_remove(&control_predecessors(old_node), c);
    /* Correct the reverse link c->old_node to c->new_node: */
    control_list_patch(control_successors(c), old_node, new_node);
}

References CONS, CONTROL, control_list_patch(), control_predecessors, control_successors, gen_nconc(), gen_remove(), MAP, and NIL.

Referenced by replace_control_related_to_a_list().

Here is the call graph for this function:

Here is the caller graph for this function:

transfer_control_successor()

void transfer_control_successor	(	control	old_node,
		control	new_node,
		control	c
	)

Transfer a control node as a successor of one node to another one.

It disconnected a node c that was coming from (was a successor of) old_node and reconnect it to new_node that becomes its new predecessor instead.

Parameters

old_node	the control node that was a predecessor of c
new_node	the control node that will be a predecessor of c
c	the control node that is disconnected of old_node and connected to new_node

Add c as a predecessor of new_node:

Remove c as a successor of old_node:

Correct the reverse link c->old_node to c->new_node:

Parameters

old_node	ld_node
new_node	ew_node

Definition at line 390 of file control.c.

{
    MAP(CONTROL, successor, {
        if (successor == c)
            /* Add c as a predecessor of new_node: */
            control_successors(new_node) =
                gen_nconc(control_successors(new_node),
                          CONS(CONTROL, c, NIL));
    }, control_successors(old_node));
    /* Remove c as a successor of old_node: */
    gen_remove(&control_successors(old_node), c);
    /* Correct the reverse link c->old_node to c->new_node: */
    control_list_patch(control_predecessors(c), old_node, new_node);
}

References CONS, CONTROL, control_list_patch(), control_predecessors, control_successors, gen_nconc(), gen_remove(), MAP, and NIL.

Referenced by replace_control_related_to_a_list().

Here is the call graph for this function:

Here is the caller graph for this function:

unlink_2_control_nodes()

void unlink_2_control_nodes	(	control	source,
		control	target
	)

Remove all edged between 2 control nodes.

Note: if the source is a test, the false branch may be come the true branch if the true branch is unlinked

Parameters

source	is the control node the edges start from
target	is the control node the edges end to

Parameters

source	ource
target	arget

Definition at line 1276 of file control.c.

{
  // FI: no check that the nodes are properly linked before unlinking
    gen_remove(&control_successors(source), target);
    gen_remove(&control_predecessors(target), source);
}

References control_predecessors, control_successors, and gen_remove().

Referenced by connect_unstructured(), controlize(), controlize_forloop(), controlize_goto(), controlize_list(), controlize_loop(), controlize_repeatloop(), controlize_sequence(), controlize_test(), controlize_whileloop(), full_spaghettify_statement(), hierarchize_control_list(), insert_control_in_arc(), move_declaration_control_node_declarations_to_statement(), recover_structured_while(), reduce_sequence(), remove_a_control_from_an_unstructured_without_relinking(), remove_unreachable_following_control(), replace_control_with_unstructured(), and restructure_this_test().

Here is the call graph for this function:

Here is the caller graph for this function: