fsm_var.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "binding.h"
#include "codegen.h"
#include "db.h"
#include "defines.h"
#include "expr.h"
#include "fsm.h"
#include "fsm_var.h"
#include "link.h"
#include "obfuscate.h"
#include "statement.h"
#include "util.h"

Functions
static void	fsm_var_remove (fsm_var *)
fsm_var *	fsm_var_add (const char *funit_name, int line, expression *in_state, expression *out_state, char *name, bool exclude)
	Allocates, initializes and adds FSM variable to global list.
static fsm_var *	fsm_var_is_output_state (expression *expr)
static void	fsm_var_bind_expr (char *sig_name, expression *expr, char *funit_name)
static void	fsm_var_add_expr (expression *expr, func_unit *funit)
static bool	fsm_var_bind_stmt (statement *stmt, const char *funit_name)
void	fsm_var_bind_add (char *sig_name, expression *expr, char *funit_name)
	Adds specified signal and expression to binding list.
void	fsm_var_stmt_add (statement *stmt, char *funit_name)
	Add specified functional unit and statement to binding list.
void	fsm_var_bind ()
	Performs FSM signal/expression binding process.
static void	fsm_var_dealloc (fsm_var *fv)
void	fsm_var_cleanup ()
	Cleans up the global lists used in this file.
Variables
char	user_msg [USER_MSG_LENGTH]
db **	db_list
unsigned int	curr_db
func_unit *	curr_funit
static fsm_var *	fsm_var_head = NULL
static fsm_var *	fsm_var_tail = NULL
static fv_bind *	fsm_var_bind_head = NULL
static fv_bind *	fsm_var_bind_tail = NULL
static fv_bind *	fsm_var_stmt_head = NULL
static fv_bind *	fsm_var_stmt_tail = NULL

---

Detailed Description

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

10/3/2003

---

Function Documentation

fsm_var* fsm_var_add	(	const char *	funit_name,
		int	line,
		expression *	in_state,
		expression *	out_state,
		char *	name,
		bool	exclude
	)

Allocates, initializes and adds FSM variable to global list.

Returns:

Returns pointer to newly allocated FSM variable.

Adds the specified Verilog hierarchical scope to a list of FSM scopes to find during the parsing phase.

Parameters:

	funit_name	String containing functional unit containing FSM state variable
	line	First line of FSM variable
	in_state	Pointer to expression containing input state
	out_state	Pointer to expression containing output state
	name	Name of this FSM (only valid for attributes
	exclude	If TRUE, excludes the FSM from coverage consideration

References curr_db, fsm_var_s::exclude, fsm_create(), func_unit_s::fsm_head, fsm_link_add(), func_unit_s::fsm_tail, funit_link_s::funit, fsm_var_s::funit, funit_head, funit_link_find(), FUNIT_MODULE, fsm_var_s::iexp, fsm_var_s::ivar, fsm_var_s::line, malloc_safe, fsm_s::name, fsm_var_s::name, fsm_var_s::next, fsm_var_s::ovar, PROFILE, strdup_safe, expression_s::table, and fsm_var_s::table.

Referenced by fsm_arg_parse(), and fsm_arg_parse_attr().

  { PROFILE(FSM_VAR_ADD);

  fsm_var*    new_var = NULL;  /* Pointer to newly created FSM variable */
  funit_link* funitl;          /* Pointer to functional unit link found */
  fsm*        table;           /* Pointer to newly create FSM */

  /* If we have not parsed design, add new FSM variable to list */
  if( db_list[curr_db]->funit_head == NULL ) {

    new_var          = (fsm_var*)malloc_safe( sizeof( fsm_var ) );
    new_var->funit   = strdup_safe( funit_name );
    new_var->name    = NULL;
    new_var->ivar    = in_state;
    new_var->ovar    = out_state;
    new_var->iexp    = NULL;
    new_var->table   = NULL;
    new_var->exclude = exclude;
    new_var->line    = line;
    new_var->next    = NULL;

    if( fsm_var_head == NULL ) {
      fsm_var_head = fsm_var_tail = new_var;
    } else {
      fsm_var_tail->next = new_var;
      fsm_var_tail       = new_var;
    }

  } else {

    if( (funitl = funit_link_find( funit_name, FUNIT_MODULE, db_list[curr_db]->funit_head )) != NULL ) {
      table = fsm_create( in_state, out_state, line, exclude );
      if( name != NULL ) {
        table->name = strdup_safe( name );
      }
      in_state->table  = table;
      out_state->table = table;
      fsm_link_add( table, &(funitl->funit->fsm_head), &(funitl->funit->fsm_tail) );
    } else {
      assert( funitl != NULL );
    }

  }

  return( new_var );

}

static void fsm_var_add_expr	(	expression *	expr,
		func_unit *	funit
	)			[static]

Iterates through specified expression tree, adding each expression to the specified functional unit if the expression does not already exist in the functional unit.

Parameters:

	expr	Pointer to expression to add to the specified functional unit
	funit	Pointer to functional unit structure to add expression to

References db_add_expression(), func_unit_s::exp_head, exp_link_add(), exp_link_find(), func_unit_s::exp_tail, expression_s::id, expression_s::left, PROFILE, PROFILE_END, and expression_s::right.

Referenced by fsm_var_bind_stmt().

  { PROFILE(FSM_VAR_ADD_EXPR);

  if( expr != NULL ) {

    if( exp_link_find( expr->id, funit->exp_head ) == NULL ) {

      /* Set the global curr_funit to the expression's functional unit */
      curr_funit = funit;

      /* Add expression's children first. */
      db_add_expression( expr->right );
      db_add_expression( expr->left );

      /* Now add this expression to the list. */
      exp_link_add( expr, &(funit->exp_head), &(funit->exp_tail) );

      /* Now clear the curr_funit */
      curr_funit = NULL;

    }

  }

  PROFILE_END;

}

void fsm_var_bind

(

)

Performs FSM signal/expression binding process.

Exceptions:

anonymous

fsm_var_bind_expr Throw

After Verilog parsing has completed, this function should be called to bind all signals to their associated FSM state expressions and functional units. For each entry in the FSM binding list the signal name is looked in the functional unit specified in the binding entry. If the signal is found, the associated expression pointer is added to the signal's expression list and the expression's signal pointer is set to point at the found signal structure. If the signal was not found, an error message is reported to the user, specifying the signal did not exist in the design.

After the signals and expressions have been bound, the FSM statement binding list is iterated through binding all statements containing FSM state expressions to the functional unit that it is a part of. If the statement contains an FSM state expression that is an output state expression, create the FSM structure for this FSM and add it to the design.

References Catch_anonymous, fv_bind_s::expr, free_safe, fsm_var_bind_expr(), fsm_var_bind_stmt(), fv_bind_s::funit_name, fv_bind_s::next, PROFILE, PROFILE_END, fv_bind_s::sig_name, fv_bind_s::stmt, Throw, and Try.

Referenced by parse_design().

                    { PROFILE(FSM_VAR_BIND);

  fv_bind* curr = NULL;  /* Pointer to current FSM variable */
  fv_bind* tmp;          /* Temporary pointer to FSM bind structure */

  Try {

    curr = fsm_var_bind_head;
    while( curr != NULL ) {

      /* Perform binding */
      fsm_var_bind_expr( curr->sig_name, curr->expr, curr->funit_name );

      tmp = curr->next;

      /* Deallocate memory for this bind structure */
      free_safe( curr->sig_name, (strlen( curr->sig_name ) + 1) );
      free_safe( curr->funit_name, (strlen( curr->funit_name ) + 1) );
      free_safe( curr, sizeof( fv_bind ) );

      curr = tmp;

    }

  } Catch_anonymous {
    while( curr != NULL ) {
      tmp = curr->next;
      free_safe( curr->sig_name, (strlen( curr->sig_name ) + 1) );
      free_safe( curr->funit_name, (strlen( curr->funit_name ) + 1) );
      free_safe( curr, sizeof( fv_bind ) );
      curr = tmp;
    } 
    curr = fsm_var_stmt_head;
    while( curr != NULL ) {
      tmp = curr->next;
      free_safe( curr->funit_name, (strlen( curr->funit_name ) + 1) );
      free_safe( curr, sizeof( fv_bind ) );
      curr = tmp;
    }
    Throw 0;
  }

  curr = fsm_var_stmt_head;
  while( curr != NULL ) {

    /* Bind statement to functional unit */
    (void)fsm_var_bind_stmt( curr->stmt, curr->funit_name );

    tmp = curr->next;

    /* Deallocate memory for this bind structure */
    free_safe( curr->funit_name, (strlen( curr->funit_name ) + 1) );
    free_safe( curr, sizeof( fv_bind ) );

    curr = tmp;

  }

  PROFILE_END;

}

void fsm_var_bind_add	(	char *	sig_name,
		expression *	expr,
		char *	funit_name
	)

Adds specified signal and expression to binding list.

Exceptions:

anonymous

fsm_var_bind_expr

Creates a new FSM binding structure and initializes it with the specified information. The FSM binding structure is then added to the global list of FSM binding structures to be bound after parsing is complete.

Parameters:

	sig_name	Name of signal to bind
	expr	Pointer to expression to bind
	funit_name	Name of functional unit that will contain the expression and signal being bound

References curr_db, fv_bind_s::expr, fsm_var_bind_expr(), funit_head, fv_bind_s::funit_name, malloc_safe, fv_bind_s::next, PROFILE, PROFILE_END, fv_bind_s::sig_name, and strdup_safe.

Referenced by fsm_arg_parse_state().

  { PROFILE(FSM_VAR_BIND_ADD);

  fv_bind* fvb;  /* Pointer to new FSM variable binding structure */

  /* If the functional unit list does not exist yet, we need to bind this later; otherwise, bind now */
  if( db_list[curr_db]->funit_head == NULL ) {

    /* Allocate and initialize FSM variable bind structure */
    fvb             = (fv_bind*)malloc_safe( sizeof( fv_bind ) );
    fvb->sig_name   = strdup_safe( sig_name );
    fvb->expr       = expr;
    fvb->funit_name = strdup_safe( funit_name );
    fvb->next       = NULL;

    /* Add new structure to the global list */
    if( fsm_var_bind_head == NULL ) {
      fsm_var_bind_head = fsm_var_bind_tail = fvb;
    } else {
      fsm_var_bind_tail->next = fvb;
      fsm_var_bind_tail       = fvb;
    }

  } else {

    fsm_var_bind_expr( sig_name, expr, funit_name );

  }

  PROFILE_END;

}

static void fsm_var_bind_expr	(	char *	sig_name,
		expression *	expr,
		char *	funit_name
	)			[static]

Exceptions:

anonymous

Throw Throw

Searches the functional unit list for the functional unit called funit_name. If the functional unit is found in the design, searches this functional unit for the signal called sig_name. If the signal is found, the signal and specified expression expr are bound to each other and this function returns a value of TRUE. If the signal name could not be found or the functional unit name could not be found in the design, no binding occurs and the function displays an error message and returns a value of FALSE to the calling function.

Parameters:

	sig_name	String name of signal to bind to specified expression
	expr	Pointer to expression to bind to signal called sig_name
	funit_name	String name of functional unit that contains the expression pointed to by expr

References bind_signal(), curr_db, FALSE, FATAL, funit_link_s::funit, funit_head, funit_link_find(), FUNIT_MODULE, expression_s::id, expression_s::line, obf_funit, obf_sig, print_output(), PROFILE, PROFILE_END, Throw, TRUE, user_msg, and USER_MSG_LENGTH.

Referenced by fsm_var_bind(), and fsm_var_bind_add().

  { PROFILE(FSM_VAR_BIND_EXPR);

  funit_link* funitl;  /* Pointer to found functional unit link element */

  if( (funitl = funit_link_find( funit_name, FUNIT_MODULE, db_list[curr_db]->funit_head )) != NULL ) {
    if( !bind_signal( sig_name, expr, funitl->funit, TRUE, FALSE, FALSE, expr->line, FALSE ) ) {
      unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Unable to bind FSM-specified signal (%s) to expression (%d) in module (%s)",
                                  obf_sig( sig_name ), expr->id, obf_funit( funit_name ) );
      assert( rv < USER_MSG_LENGTH );
      print_output( user_msg, FATAL, __FILE__, __LINE__ );
      Throw 0;
    }
  } else {
    unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Unable to find FSM-specified module (%s) in design", obf_funit( funit_name ) ); 
    assert( rv < USER_MSG_LENGTH );
    print_output( user_msg, FATAL, __FILE__, __LINE__ );
    Throw 0;
  }

  PROFILE_END;

}

static bool fsm_var_bind_stmt	(	statement *	stmt,
		const char *	funit_name
	)			[static]

Returns:

Returns a value of TRUE if the statement was successfully bound to the specified functional unit name; otherwise, returns a value of FALSE.

Searches the design functional unit list for a functional unit called funit_name. If the functional unit is found in the design, adds the statement's expression tree to the design, sets the STMT_ADDED bit in the statement's supplemental field, adds this statement to the found functional unit structure, and finally creates an FSM table if the statement contains an output state FSM expression tree and returns a value of TRUE to the calling function. If the functional unit could not be found, this function, returns a value of FALSE to the calling function.

Parameters:

	stmt	Pointer to statement to bind
	funit_name	String name of functional unit which will contain stmt

References curr_db, fsm_var_s::exclude, statement_s::exp, FALSE, fsm_create(), func_unit_s::fsm_head, fsm_link_add(), func_unit_s::fsm_tail, fsm_var_add_expr(), fsm_var_is_output_state(), fsm_var_remove(), statement_s::funit, funit_link_s::funit, funit_head, funit_link_find(), FUNIT_MODULE, fsm_var_s::ivar, fsm_var_s::line, fsm_var_s::ovar, statement_s::part, PROFILE, PROFILE_END, func_unit_s::stmt_head, stmt_link_add(), func_unit_s::stmt_tail, statement_s::suppl, expression_s::table, fsm_var_s::table, and TRUE.

Referenced by fsm_var_bind().

  { PROFILE(FSM_VAR_BIND_STMT);

  bool        retval = FALSE;  /* Return value for this function */
  funit_link* funitl;          /* Pointer to found functional unit link element */
  fsm_var*    fv;              /* Pointer to found FSM variable */

  if( (funitl = funit_link_find( funit_name, FUNIT_MODULE, db_list[curr_db]->funit_head )) != NULL ) {

    /* First, add expression tree to found functional unit expression list */
    fsm_var_add_expr( stmt->exp, funitl->funit );

    /* Set ADDED bit of this statement */
    stmt->suppl.part.added = 1;

    /* Second, add our statement to this functional unit's statement list */
    (void)stmt_link_add( stmt, TRUE, &(funitl->funit->stmt_head), &(funitl->funit->stmt_tail) );

    /* Third, add the functional unit to this statement's pointer */
    stmt->funit = funitl->funit;

    /* Finally, create the new FSM if we are the output state */
    if( (fv = fsm_var_is_output_state( stmt->exp )) != NULL ) {
      fv->table       = fsm_create( fv->ivar, fv->ovar, fv->line, fv->exclude );
      fv->ivar->table = fv->table;
      fv->ovar->table = fv->table;
      fsm_link_add( fv->table, &(funitl->funit->fsm_head), &(funitl->funit->fsm_tail) );
      fsm_var_remove( fv );
    }

  } else {

    retval = FALSE;

  }

  PROFILE_END;

  return( retval );

}

void fsm_var_cleanup

(

)

Cleans up the global lists used in this file.

Iterates through the various global lists in this file, deallocating all memory. This function is called when an error has occurred during the parsing stage.

References statement_s::exp, fv_bind_s::expr, expression_dealloc(), FALSE, free_safe, fsm_var_s::funit, fv_bind_s::funit_name, fsm_var_s::ivar, fv_bind_s::next, fsm_var_s::next, fsm_var_s::ovar, PROFILE, PROFILE_END, fv_bind_s::sig_name, statement_dealloc(), and fv_bind_s::stmt.

Referenced by command_score(), and parse_design().

                       { PROFILE(FSM_VAR_CLEANUP);

  fsm_var* curr_fv;   /* Pointer to the current fsm_var structure */
  fsm_var* tmp_fv;    /* Temporary pointer */
  fv_bind* curr_fvb;  /* Pointer to the current fv_bind structure */ 
  fv_bind* tmp_fvb;   /* Temporary pointer */

  /* Deallocate fsm_var list */
  curr_fv = fsm_var_head;
  while( curr_fv != NULL ) {
    tmp_fv  = curr_fv;
    curr_fv = curr_fv->next;

    free_safe( tmp_fv->funit, (strlen( curr_fv->funit ) + 1) );
    expression_dealloc( tmp_fv->ivar, FALSE );
    expression_dealloc( tmp_fv->ovar, FALSE );
    free_safe( tmp_fv, sizeof( fsm_var ) );
  }
  fsm_var_head = fsm_var_tail = NULL;

  /* Deallocate fsm_var_bind list */
  curr_fvb = fsm_var_bind_head;
  while( curr_fvb != NULL ) {
    tmp_fvb  = curr_fvb;
    curr_fvb = curr_fvb->next;

    free_safe( tmp_fvb->sig_name,   (strlen( tmp_fvb->sig_name ) + 1) );
    free_safe( tmp_fvb->funit_name, (strlen( tmp_fvb->funit_name ) + 1) );
    expression_dealloc( tmp_fvb->expr, FALSE );
    free_safe( tmp_fvb, sizeof( fv_bind ) );
  }
  fsm_var_bind_head = fsm_var_bind_tail = NULL;

  /* Deallocate fsm_var_stmt list */
  curr_fvb = fsm_var_stmt_head;
  while( curr_fvb != NULL ) {
    tmp_fvb  = curr_fvb;
    curr_fvb = curr_fvb->next;
    
    free_safe( tmp_fvb->funit_name, (strlen( tmp_fvb->funit_name ) + 1) );
    expression_dealloc( tmp_fvb->stmt->exp, FALSE );
    statement_dealloc( tmp_fvb->stmt );
    free_safe( tmp_fvb, sizeof( fv_bind ) );
  }
  fsm_var_stmt_head = fsm_var_stmt_tail = NULL;

  PROFILE_END;

}

static void fsm_var_dealloc

(

fsm_var *

fv

)

[static]

Deallocates an FSM variable entry from memory.

Parameters:

fv

Pointer to FSM variable to deallocate

References free_safe, fsm_var_s::funit, PROFILE, and PROFILE_END.

Referenced by fsm_var_remove().

  { PROFILE(FSM_VAR_DEALLOC);

  if( fv != NULL ) {

    /* Deallocate the functional unit name string */
    free_safe( fv->funit, (strlen( fv->funit ) + 1) );

    /* Finally, deallocate ourself */
    free_safe( fv, sizeof( fsm_var ) );

  }

  PROFILE_END;

}

static fsm_var* fsm_var_is_output_state

(

expression *

expr

)

[static]

Returns:

Returns pointer to found FSM variable that contains this expression as an output expression.

Searches the FSM variable list for the FSM variable that contains the specified expression as its output state expression. If no FSM variable was found, returns a value of NULL to the calling function.

Parameters:

expr

Pointer to expression to evaluate

References fsm_var_s::next, fsm_var_s::ovar, PROFILE, and PROFILE_END.

Referenced by fsm_var_bind_stmt().

  { PROFILE(FSM_VAR_IS_OUTPUT_STATE);

  fsm_var* curr;  /* Pointer to current FSM variable structure */

  curr = fsm_var_head;
  while( (curr != NULL) && (curr->ovar != expr) ) {
    curr = curr->next;
  }

  PROFILE_END;

  return( curr );

}

void fsm_var_remove

(

fsm_var *

fv

)

[static]

Searches global FSM variable list for matching FSM variable structure. When match is found, remove the structure and deallocate it from memory being sure to keep the global list intact.

Parameters:

fv

Pointer to FSM variable structure to remove from global list

References fsm_var_dealloc(), fsm_var_s::next, PROFILE, and PROFILE_END.

Referenced by fsm_var_bind_stmt().

  { PROFILE(FSM_VAR_REMOVE);

  fsm_var* curr;  /* Pointer to current FSM variable structure in list */
  fsm_var* last;  /* Pointer to last FSM variable structure evaluated */

  /* Find matching FSM variable structure */
  curr = fsm_var_head;
  last = NULL;
  while( (curr != NULL) && (curr != fv) ) {
    last = curr;
    curr = curr->next;
  }

  /* If a matching FSM variable structure was found, remove it from the global list. */
  if( curr != NULL ) {

    if( (curr == fsm_var_head) && (curr == fsm_var_tail) ) {
      fsm_var_head = fsm_var_tail = NULL;
    } else if( curr == fsm_var_head ) {
      fsm_var_head = curr->next;
    } else if( curr == fsm_var_tail ) {
      fsm_var_tail = last;
    } else {
      last->next = curr->next;
    }

    fsm_var_dealloc( curr );

  }

  PROFILE_END;

}

void fsm_var_stmt_add	(	statement *	stmt,
		char *	funit_name
	)

Add specified functional unit and statement to binding list.

Allocates and initializes an FSM variable binding entry and adds it to the fsm_var_stmt list for later processing.

Parameters:

	stmt	Pointer to statement containing FSM state expression
	funit_name	Name of functional unit that will contain stmt

References fv_bind_s::funit_name, malloc_safe, fv_bind_s::next, PROFILE, PROFILE_END, fv_bind_s::stmt, and strdup_safe.

Referenced by fsm_arg_parse_state().

  { PROFILE(FSM_VAR_STMT_ADD);

  fv_bind* fvb;  /* Pointer to new FSM variable binding structure */

  fvb             = (fv_bind*)malloc_safe( sizeof( fv_bind ) );
  fvb->stmt       = stmt;
  fvb->funit_name = strdup_safe( funit_name );
  fvb->next       = NULL;

  /* Add new structure to the head of the global list */
  if( fsm_var_stmt_head == NULL ) {
    fsm_var_stmt_head = fsm_var_stmt_tail = fvb;
  } else {
    fvb->next         = fsm_var_stmt_head;
    fsm_var_stmt_head = fvb;
  }

  PROFILE_END;

}

---

Variable Documentation

unsigned int curr_db

Index of current database in db_list array that is being handled.

func_unit* curr_funit

Pointer to the functional unit structure for the functional unit that is currently being parsed.

db** db_list

Array of database pointers storing all currently loaded databases.

fv_bind* fsm_var_bind_head = NULL [static]

Pointer to the head of the list of FSM variable bindings between signal names and expression pointers. During the command-line parse of FSM variables, bindings will be submitted into this list for processing after Verilog parsing has completed. After Verilog parsing has completed, the FSM bind function needs to be called to bind all FSM signals/expressions to each other.

fv_bind* fsm_var_bind_tail = NULL [static]

Pointer to the tail of the list of FSM variable bindings.

fsm_var* fsm_var_head = NULL [static]

Pointer to the head of the list of FSM scopes in the design. To extract an FSM, the user must specify the scope to the FSM state variable of the FSM to extract. When the parser finds this signal in the design, the appropriate FSM is created and initialized. As a note, we may make the FSM extraction more automatic (smarter) in the future, but we will always allow the user to make these choices with the -F option to the score command.

fv_bind* fsm_var_stmt_head = NULL [static]

Pointer to the head of the list of FSM variable statement/functional unit bindings. During the command-line parse of FSM variables, bindings will be submitted into this list for processing after Verilog parsing has completed. After Verilog parsing has completed, the FSM bind function needs to be called to bind all FSM statements/functional units to each other.

fv_bind* fsm_var_stmt_tail = NULL [static]

Pointer to the tail of the list of FSM statement/functional unit bindings.

fsm_var* fsm_var_tail = NULL [static]

Pointer to the tail of the list of FSM scopes in the design.

char user_msg[USER_MSG_LENGTH]

Holds some output that will be displayed via the print_output command. This is created globally so that memory does not need to be reallocated for each function that wishes to use it.