spaghettify.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	INDEX_VARIABLE_NAME   "DO%d_INDEX"
#define	BEGIN_VARIABLE_NAME   "DO%d_BEGIN"
#define	END_VARIABLE_NAME   "DO%d_END"
#define	INCREMENT_VARIABLE_NAME   "DO%d_INCREMENT"

Functions
statement	spaghettify_loop (statement stat, const char *module_name)
	This function takes the statement stat as parameter and return a new spaghettized statement, asserting stat is a LOOP statement. More...
statement	spaghettify_whileloop (statement stat, const char *module_name)
	whileloop_spaghettify.c More...
statement	spaghettify_forloop (statement stat, const char *module_name)
	This function takes the statement stat as parameter and return a new spaghettized statement, asserting stat is a FORLOOP statement. More...
statement	spaghettify_test (statement stat, const char *module_name)
	test_spaghettify.c More...
statement	spaghettify_statement (statement stat, const char *module_name)
	The spaghettifier is used in context of PHRASE project while creating "Finite State Machine"-like code portions in order to synthetise them in reconfigurables units. More...

Macro Definition Documentation

BEGIN_VARIABLE_NAME

#define BEGIN_VARIABLE_NAME   "DO%d_BEGIN"

Definition at line 28 of file spaghettify.h.

END_VARIABLE_NAME

#define END_VARIABLE_NAME   "DO%d_END"

Definition at line 29 of file spaghettify.h.

INCREMENT_VARIABLE_NAME

#define INCREMENT_VARIABLE_NAME   "DO%d_INCREMENT"

Definition at line 30 of file spaghettify.h.

INDEX_VARIABLE_NAME

#define INDEX_VARIABLE_NAME   "DO%d_INDEX"

Definition at line 27 of file spaghettify.h.

Function Documentation

spaghettify_forloop()

statement spaghettify_forloop	(	statement	stat,
		const char *	module_name
	)

This function takes the statement stat as parameter and return a new spaghettized statement, asserting stat is a FORLOOP statement.

forloop_spaghettify.c

Parameters

stat	tat
module_name	odule_name

Definition at line 135 of file forloop_spaghettify.c.

{
  statement returned_statement = stat;
  instruction unstructured_instruction;
  unstructured new_unstructured;  
 
  pips_assert("Statement is FORLOOP in FSM_GENERATION", 
              instruction_tag(statement_instruction(stat)) 
              == is_instruction_forloop);
 
  pips_debug(2, "spaghettify_forloop, module %s\n", module_name);
 
  new_unstructured 
    = make_unstructured_from_forloop 
    (instruction_forloop(statement_instruction(stat)),
     stat,
     module_name);
  
  unstructured_instruction = make_instruction(is_instruction_unstructured,
                                              new_unstructured);
  
  statement_instruction(returned_statement) = unstructured_instruction;
 
  return returned_statement;
}

References instruction_forloop, instruction_tag, is_instruction_forloop, is_instruction_unstructured, make_instruction(), make_unstructured_from_forloop(), module_name(), pips_assert, pips_debug, and statement_instruction.

Referenced by full_spaghettify_statement(), and spaghettify_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

spaghettify_loop()

statement spaghettify_loop	(	statement	stat,
		const char *	module_name
	)

This function takes the statement stat as parameter and return a new spaghettized statement, asserting stat is a LOOP statement.

loop_spaghettify.c

Parameters

stat	tat
module_name	odule_name

Definition at line 391 of file loop_spaghettify.c.

{
  statement returned_statement = stat;
  instruction unstructured_instruction;
  unstructured new_unstructured;  
 
  pips_assert("Statement is LOOP in FSM_GENERATION", 
              instruction_tag(statement_instruction(stat)) 
              == is_instruction_loop);
 
  pips_debug(2, "spaghettify_loop, module %s\n", module_name);   
  new_unstructured = make_unstructured_from_loop (statement_loop(stat), 
                                                  stat,
                                                  module_name);
  
  unstructured_instruction = make_instruction(is_instruction_unstructured,
                                              new_unstructured);
  
  statement_instruction(returned_statement) = unstructured_instruction;
 
  return returned_statement;
}

References instruction_tag, is_instruction_loop, is_instruction_unstructured, make_instruction(), make_unstructured_from_loop(), module_name(), pips_assert, pips_debug, statement_instruction, and statement_loop().

Referenced by full_spaghettify_statement(), and spaghettify_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

spaghettify_statement()

statement spaghettify_statement	(	statement	stat,
		const char *	module_name
	)

The spaghettifier is used in context of PHRASE project while creating "Finite State Machine"-like code portions in order to synthetise them in reconfigurables units.

spaghettify.c

This phase transforms structured code portions (eg. loops) in unstructured statements.

To add flexibility, the behavior of \texttt{spaghettifier} is controlled by the properties

• DESTRUCTURE_TESTS
• DESTRUCTURE_LOOPS
• DESTRUCTURE_WHILELOOPS
• DESTRUCTURE_FORLOOPS to allow more or less destruction power !

spaghettify > MODULE.code < PROGRAM.entities < MODULE.code This function is recursively called during spaghettization. It takes the statement stat as parameter and return a new spaghettized statement (or the same if nothing has been done). Spaguettization is done:

• on Tests (if property DESTRUCTURE_TESTS set to true)
• on Loops (if property DESTRUCTURE_LOOPS set to true)
• on WhileLoops (if property DESTRUCTURE_WHILELOOPS set to true)
• on ForLoops (if property DESTRUCTURE_FORLOOPS set to true)

Parameters

stat	tat
module_name	odule_name

Definition at line 85 of file spaghettify.c.

{
  // Defaut behaviour is to return parameter statement stat
  statement returned_statement = stat;
  instruction i = statement_instruction(stat);
 
  pips_debug(2,"\nSPAGHETTIFY: Module statement: =====================================\n");
  ifdebug(2) {
    print_statement(stat);
  }
  pips_debug(2,"domain number = %"PRIdPTR"\n", statement_domain_number(stat));
  pips_debug(2,"entity = UNDEFINED\n");
  pips_debug(2,"statement number = %"PRIdPTR"\n", statement_number(stat));
  pips_debug(2,"statement ordering = %"PRIdPTR"\n", statement_ordering(stat));
  if (statement_with_empty_comment_p(stat)) {
    pips_debug(2,"statement comments = EMPTY\n");
  }
  else {
    pips_debug(2,"statement comments = %s\n", statement_comments(stat));
  }
  pips_debug(2,"statement instruction = %s\n", statement_type_as_string(stat));
  switch (instruction_tag(i)) {
  case is_instruction_test: 
    {
      pips_debug(2, "TEST\n");   
    if (get_bool_property("DESTRUCTURE_TESTS")) {
      returned_statement = spaghettify_test (stat, module_name);
    }
      break;
  }
  case is_instruction_sequence: 
    {
      sequence seq = instruction_sequence(i);
      pips_debug(2, "SEQUENCE\n");   
      MAP(STATEMENT, current_stat,
      {
        statement new_stat = spaghettify_statement(current_stat, module_name);
        if (new_stat != NULL) {
          gen_list_patch (sequence_statements(seq), current_stat, new_stat);
        }
      }, sequence_statements(seq));
      break;
    }
  case is_instruction_loop: {
    pips_debug(2, "LOOP\n");   
    if (get_bool_property("DESTRUCTURE_LOOPS")) {
      returned_statement = spaghettify_loop (stat, module_name);
    }
    break;
  }
  case is_instruction_whileloop: {
    pips_debug(2, "WHILELOOP\n");   
    if (get_bool_property("DESTRUCTURE_WHILELOOPS")) {
      returned_statement = spaghettify_whileloop (stat, module_name);
    }
    break;
  }
  case is_instruction_forloop: {
    pips_debug(2, "FORLOOP\n");   
    if (get_bool_property("DESTRUCTURE_FORLOOPS")) {
      returned_statement = spaghettify_forloop (stat, module_name);
    }
    break;
  }
  case is_instruction_call: {
    pips_debug(2, "CALL\n");   
    break;
  }
  case is_instruction_unstructured: {
    pips_debug(2, "UNSTRUCTURED\n");  
    break;
  }
  case is_instruction_goto: {
    pips_debug(2, "GOTO\n");   
    break;
  }
  default:
    pips_debug(2, "UNDEFINED\n");   
    break;
  }
 
  return returned_statement;
}

Referenced by spaghettify(), and spaghettify_statement().

Here is the caller graph for this function:

spaghettify_test()

statement spaghettify_test	(	statement	stat,
		const char *	module_name
	)

test_spaghettify.c

Parameters

stat	tat
module_name	odule_name

Definition at line 142 of file test_spaghettify.c.

{
  statement returned_statement = stat;
  instruction unstructured_instruction;
  unstructured new_unstructured;
 
  pips_assert("Statement is TEST in FSM_GENERATION",
              instruction_tag(statement_instruction(stat))
              == is_instruction_test);
 
  pips_debug(2, "spaghettify_test, module %s\n", module_name);
 
  new_unstructured
    = make_unstructured_from_test
    (instruction_test(statement_instruction(stat)),
     stat,
     module_name);
 
  unstructured_instruction = make_instruction(is_instruction_unstructured,
                                              new_unstructured);
 
  statement_instruction(returned_statement) = unstructured_instruction;
  return returned_statement;
}

spaghettify_whileloop()

statement spaghettify_whileloop	(	statement	stat,
		const char *	module_name
	)

whileloop_spaghettify.c

Parameters

stat	tat
module_name	odule_name

Definition at line 142 of file whileloop_spaghettify.c.

{
  statement returned_statement = stat;
  instruction unstructured_instruction;
  unstructured new_unstructured; 
 
  pips_assert("Statement is WHILELOOP in FSM_GENERATION",
              instruction_tag(statement_instruction(stat))
              == is_instruction_whileloop);
 
  pips_debug(2, "spaghettify_whileloop, module %s\n", module_name);  
  new_unstructured
    = make_unstructured_from_whileloop
    (instruction_whileloop(statement_instruction(stat)),
     stat,
     module_name);
 
  unstructured_instruction = make_instruction(is_instruction_unstructured,
                                              new_unstructured);
 
  statement_instruction(returned_statement) = unstructured_instruction;
 
  return returned_statement;
}