/Users/trevorw/projects/release/covered-0.7.4/src/binding.h File Reference

---

Detailed Description

Contains all functions for vsignal/expression binding.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

3/4/2002

#include "defines.h"

Go to the source code of this file.

Functions
void	bind_add (int type, const char *name, expression *exp, func_unit *funit)
	Adds vsignal and expression to binding list.
void	bind_append_fsm_expr (expression *fsm_exp, const expression *exp, const func_unit *curr_funit)
	Appends an FSM expression to a matching expression binding structure.
void	bind_remove (int id, bool clear_assigned)
	Removes the expression with ID of id from binding list.
char *	bind_find_sig_name (const expression *exp)
	Searches current binding list for the signal name associated with the given expression.
void	bind_rm_stmt (int id)
	Removes the statement block associated with the expression with ID of id after binding has occurred.
bool	bind_signal (char *name, expression *exp, func_unit *funit_exp, bool fsm_bind, bool cdd_reading, bool clear_assigned, int exp_line, bool bind_locally)
	Binds a signal to an expression.
void	bind_perform (bool cdd_reading, int pass)
	Performs vsignal/expression bind (performed after parse completed).
void	bind_dealloc ()
	Deallocates memory used for binding.

---

Function Documentation

void bind_add (  int  type, const char *  name, expression *  exp, func_unit *  funit )

Adds vsignal and expression to binding list. Adds the specified signal/function/task and expression to the bindings linked list. This bindings list will be handled after all input Verilog has been parsed. Parameters: type  Type of thing being bound with the specified expression (0=signal, 1=functional unit) name  Signal/Function/Task scope to bind exp  Expression ID to bind funit  Pointer to module containing specified expression { PROFILE(BIND_ADD); exp_bind* eb; /* Temporary pointer to signal/expressing binding */ assert( exp != NULL ); /* Create new signal/expression binding */ eb = (exp_bind *)malloc_safe( sizeof( exp_bind ) ); eb->type = type; eb->name = strdup_safe( name ); eb->clear_assigned = 0; eb->line = exp->line; eb->funit = funit; eb->exp = exp; eb->fsm = NULL; eb->next = NULL; /* Add new signal/expression binding to linked list */ if( eb_head == NULL ) { eb_head = eb_tail = eb; } else { eb_tail->next = eb; eb_tail = eb; } PROFILE_END; }

void bind_append_fsm_expr (  expression *  fsm_exp, const expression *  exp, const func_unit *  curr_funit )

Appends an FSM expression to a matching expression binding structure. Searches the expression binding list for the entry that matches the given exp and curr_funit parameters. When the entry is found, the FSM expression is added to the exp_bind structure to be sized when the expression is bound. Parameters: fsm_exp  Expression pertaining to an FSM input state that needs to be sized when its associated expression is bound to its signal exp  Expression to match curr_funit  Functional unit that the FSM expression resides in (this will be the same functional unit as the expression functional unit) { PROFILE(BIND_APPEND_FSM_EXPR); exp_bind* curr; curr = eb_head; while( (curr != NULL) && ((exp != curr->exp) || (curr_funit != curr->funit)) ) { curr = curr->next; } assert( curr != NULL ); curr->fsm = fsm_exp; PROFILE_END; }

void bind_dealloc (   )

Deallocates memory used for binding. Deallocates all memory used for the storage of the binding list. { PROFILE(BIND_DEALLOC); exp_bind* tmp; /* Temporary binding pointer */ while( eb_head != NULL ) { tmp = eb_head; eb_head = tmp->next; /* Deallocate the name, if specified */ if( tmp->name != NULL ) { free_safe( tmp->name, (strlen( tmp->name ) + 1) ); } /* Deallocate this structure */ free_safe( tmp, sizeof( exp_bind ) ); } /* Reset the head and tail pointers */ eb_head = eb_tail = NULL; PROFILE_END; }

char* bind_find_sig_name (  const expression *  exp  )

Searches current binding list for the signal name associated with the given expression. Returns: Returns the name of the signal to be bound with the given expression (if one exists); otherwise, returns NULL if no match was found. Parameters: exp  Pointer to expression to search for { PROFILE(BIND_FIND_SIG_NAME); exp_bind* curr; /* Pointer to current exp_bind link */ vsignal* found_sig; /* Placeholder */ func_unit* found_funit; /* Specifies the functional unit containing this signal */ char* name = NULL; /* Specifies the signal name relative to its parent module */ char* front; /* Front part of functional unit hierarchy */ char* rest; /* Rest of functional unit hierarchy (minus front) */ /* Find matching binding element that matches the given expression */ curr = eb_head; while( (curr != NULL) && (curr->exp != exp) ) { curr = curr->next; } /* If we found the matching expression, find the signal and construct its hierarchical pathname relative to its parent module. */ if( curr != NULL ) { if( scope_find_signal( curr->name, curr->funit, &found_sig, &found_funit, -1 ) ) { if( funit_get_curr_module_safe( curr->funit ) == funit_get_curr_module_safe( found_funit ) ) { front = strdup_safe( found_funit->name ); rest = strdup_safe( found_funit->name ); scope_extract_front( found_funit->name, front, rest ); if( rest[0] != '\0' ) { unsigned int sig_size = strlen( curr->name ) + strlen( rest ) + 2; unsigned int rv; name = (char*)malloc_safe( sig_size ); rv = snprintf( name, sig_size, "%s.%s", rest, curr->name ); assert( rv < sig_size ); } free_safe( front, (strlen( found_funit->name ) + 1) ); free_safe( rest, (strlen( found_funit->name ) + 1) ); } } if( name == NULL ) { name = strdup_safe( curr->name ); } } PROFILE_END; return( name ); }

void bind_perform (  bool  cdd_reading, int  pass )

Performs vsignal/expression bind (performed after parse completed). Exceptions: anonymous  Throw param_resolve bind_signal generate_resolve bind_task_function_namedblock bind_task_function_namedblock In the process of binding, we go through each element of the binding list, finding the signal to be bound in the specified tree, adding the expression to the signal's expression pointer list, and setting the expression vector pointer to point to the signal vector. Parameters: cdd_reading  Set to TRUE if we are binding after reading the CDD file; otherwise, set to FALSE pass  Specifies the starting pass to perform (setting this to 1 will bypass resolutions) { PROFILE(BIND_PERFORM); exp_bind* curr_eb; /* Pointer to current expression bind structure */ int id; /* Current expression id -- used for removal */ bool bound; /* Specifies if the current expression was successfully bound or not */ statement* tmp_stmt; /* Pointer to temporary statement */ Try { /* Make three passes through binding list, 0=local signal/param bindings, 1=remote signal/param bindings */ for( ; pass<2; pass++ ) { curr_eb = eb_head; while( curr_eb != NULL ) { /* Figure out ID to clear from the binding list after the bind occurs */ if( curr_eb->clear_assigned == 0 ) { id = curr_eb->exp->id; } else { id = curr_eb->clear_assigned; } /* If the expression has already been bound, do not attempt to do it again */ if( (curr_eb->exp != NULL) && (curr_eb->exp->name != NULL) ) { bound = TRUE; } else { /* Handle signal/parameter binding */ if( curr_eb->type == 0 ) { /* Attempt to bind the expression to a parameter; otherwise, bind to a signal */ if( !(bound = bind_param( curr_eb->name, curr_eb->exp, curr_eb->funit, curr_eb->line, (pass == 0) )) ) { bound = bind_signal( curr_eb->name, curr_eb->exp, curr_eb->funit, FALSE, cdd_reading, (curr_eb->clear_assigned > 0), curr_eb->line, (pass == 0) ); } /* If an FSM expression is attached, size it now */ if( curr_eb->fsm != NULL ) { curr_eb->fsm->value = vector_create( curr_eb->exp->value->width, VTYPE_EXP, VDATA_UL, TRUE ); } /* Otherwise, handle disable binding */ } else if( curr_eb->type == 1 ) { /* Attempt to bind a named block -- if unsuccessful, attempt to bind with a task */ if( !(bound = bind_task_function_namedblock( FUNIT_NAMED_BLOCK, curr_eb->name, curr_eb->exp, curr_eb->funit, cdd_reading, curr_eb->line, (pass == 0) )) ) { bound = bind_task_function_namedblock( FUNIT_TASK, curr_eb->name, curr_eb->exp, curr_eb->funit, cdd_reading, curr_eb->line, (pass == 0) ); } /* Otherwise, handle function/task binding */ } else { /* Bind the expression to the task/function. If it is unsuccessful, we need to remove the statement that this expression is a part of. */ bound = bind_task_function_namedblock( curr_eb->type, curr_eb->name, curr_eb->exp, curr_eb->funit, cdd_reading, curr_eb->line, (pass == 0) ); } /* If we have bound successfully, copy the name of this exp_bind to the expression */ if( bound && (curr_eb->exp != NULL) ) { curr_eb->exp->name = strdup_safe( curr_eb->name ); } } /* If the expression was unable to be bound, put its statement block in a list to be removed after binding has been completed. */ if( !bound && (curr_eb->clear_assigned == 0) && (pass == 1) ) { if( (tmp_stmt = expression_get_root_statement( curr_eb->exp )) != NULL ) { #ifdef DEBUG_MODE if( debug_mode ) { unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Removing statement block containing line %d in file \"%s\", because it was unbindable", curr_eb->exp->line, obf_file( curr_eb->funit->filename ) ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, DEBUG, __FILE__, __LINE__ ); } #endif stmt_blk_add_to_remove_list( tmp_stmt ); } } curr_eb = curr_eb->next; /* Remove this from the binding list */ if( bound ) { bind_remove( id, FALSE ); } } #ifndef VPI_ONLY /* If we are in parse mode, resolve all parameters and arrays of instances now */ if( !cdd_reading && (pass == 0) ) { inst_link* instl; #ifdef DEBUG_MODE if( debug_mode ) { print_output( "Resolving parameters...", DEBUG, __FILE__, __LINE__ ); } #endif instl = db_list[curr_db]->inst_head; while( instl != NULL ) { param_resolve( instl->inst ); instl = instl->next; } #ifdef DEBUG_MODE if( debug_mode ) { print_output( "Resolving generate statements...", DEBUG, __FILE__, __LINE__ ); } #endif instl = db_list[curr_db]->inst_head; while( instl != NULL ) { generate_resolve( instl->inst ); instl = instl->next; } #ifdef DEBUG_MODE if( debug_mode ) { print_output( "Resolving arrays of instances...", DEBUG, __FILE__, __LINE__ ); } #endif instl = db_list[curr_db]->inst_head; while( instl != NULL ) { instance_resolve( instl->inst ); instl = instl->next; } } #endif } } Catch_anonymous { exp_bind* tmp_eb; curr_eb = eb_head; while( curr_eb != NULL ) { tmp_eb = curr_eb; curr_eb = curr_eb->next; free_safe( tmp_eb->name, (strlen( tmp_eb->name ) + 1) ); free_safe( tmp_eb, sizeof( exp_bind ) ); } eb_head = eb_tail = NULL; Throw 0; } PROFILE_END; }

void bind_remove (  int  id, bool  clear_assigned )

Removes the expression with ID of id from binding list. Removes the binding containing the expression ID of id. This needs to be called before an expression is removed. Parameters: id  Expression ID of binding to remove clear_assigned  If set to TRUE, clears the assigned bit in the specified expression { PROFILE(BIND_REMOVE); exp_bind* curr; /* Pointer to current exp_bind link */ exp_bind* last; /* Pointer to last exp_bind link examined */ curr = eb_head; last = eb_head; while( curr != NULL ) { if( ((curr->exp != NULL) && (curr->exp->id == id)) || (curr->clear_assigned == id) ) { if( clear_assigned ) { curr->clear_assigned = id; curr->exp = NULL; } else { /* Remove this binding element */ if( (curr == eb_head) && (curr == eb_tail) ) { eb_head = eb_tail = NULL; } else if( curr == eb_head ) { eb_head = eb_head->next; } else if( curr == eb_tail ) { eb_tail = last; eb_tail->next = NULL; } else { last->next = curr->next; } /* Now free the binding element memory */ free_safe( curr->name, (strlen( curr->name ) + 1) ); free_safe( curr, sizeof( exp_bind ) ); } curr = NULL; } else { last = curr; curr = curr->next; } } PROFILE_END; }

void bind_rm_stmt (  int  id  )

Removes the statement block associated with the expression with ID of id after binding has occurred.

bool bind_signal (  char *  name, expression *  exp, func_unit *  funit_exp, bool  fsm_bind, bool  cdd_reading, bool  clear_assigned, int  exp_line, bool  bind_locally )

Binds a signal to an expression. Returns: Returns TRUE if bind occurred successfully; otherwise, returns FALSE. Exceptions: anonymous  expression_set_value Performs a binding of an expression and signal based on the name of the signal. Looks up signal name in the specified functional unit and sets the expression and signal to point to each other. If the signal is unused, the bind does not occur and the function returns a value of FALSE. If the signal does not exist, it is considered to be an implicit signal and a 1-bit signal is created. Parameters: name  String name of signal to bind to specified expression exp  Pointer to expression to bind funit_exp  Pointer to functional unit containing expression fsm_bind  If set to TRUE, handling binding for FSM binding cdd_reading  If set to TRUE, specifies that we are binding after reading a design from a CDD file (instead of the design files) clear_assigned  If set to TRUE, clears signal assigned bit exp_line  Line of specified expression (when expression is NULL) bind_locally  If TRUE, only search for specified signal within the same functional unit as this expression { PROFILE(BIND_SIGNAL); bool retval = TRUE; /* Return value for this function */ vsignal* found_sig; /* Pointer to found signal in design for the given name */ func_unit* found_funit; /* Pointer to found functional unit containing given signal */ statement* stmt; /* Pointer to root statement for the given expression */ exp_link* expl; /* Pointer to current expression link */ unsigned int rv; /* Return value from snprintf calls */ /* Skip signal binding if the name is not local and we are binding locally */ if( scope_local( name ) || !bind_locally || (!clear_assigned && (exp->op == EXP_OP_PASSIGN)) ) { /* Search for specified signal in current functional unit */ if( !scope_find_signal( name, funit_exp, &found_sig, &found_funit, exp_line ) ) { /* If we are binding an FSM, output an error message */ if( fsm_bind ) { rv = snprintf( user_msg, USER_MSG_LENGTH, "Unable to find specified FSM signal \"%s\" in module \"%s\" in file %s", obf_sig( name ), obf_funit( funit_exp->name ), obf_file( funit_exp->filename ) ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, FATAL, __FILE__, __LINE__ ); retval = FALSE; /* Otherwise, implicitly create the signal and bind to it if the signal exists on the LHS of the equation */ } else if( ESUPPL_IS_LHS( exp->suppl ) == 1 ) { assert( exp != NULL ); rv = snprintf( user_msg, USER_MSG_LENGTH, "Implicit declaration of signal \"%s\", creating 1-bit version of signal", obf_sig( name ) ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, WARNING, __FILE__, __LINE__ ); rv = snprintf( user_msg, USER_MSG_LENGTH, "module \"%s\", file \"%s\", line %d", obf_funit( funit_exp->name ), obf_file( funit_exp->filename ), exp_line ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, WARNING_WRAP, __FILE__, __LINE__ ); found_sig = vsignal_create( name, SSUPPL_TYPE_IMPLICIT, 1, exp->line, ((exp->col >> 16) & 0xffff) ); found_sig->pdim_num = 1; found_sig->dim = (dim_range*)malloc_safe( sizeof( dim_range ) * 1 ); found_sig->dim[0].msb = 0; found_sig->dim[0].lsb = 0; sig_link_add( found_sig, &(funit_exp->sig_head), &(funit_exp->sig_tail) ); /* Otherwise, don't attempt to bind the signal */ } else { retval = FALSE; } } else { /* If the found signal is not handled, do not attempt to bind to it */ if( found_sig->suppl.part.not_handled == 1 ) { retval = FALSE; } } if( retval ) { /* Bind signal and expression if we are not clearing or this is an MBA */ if( !clear_assigned ) { /* Add expression to signal expression list */ exp_link_add( exp, &(found_sig->exp_head), &(found_sig->exp_tail) ); /* Set expression to point at signal */ exp->sig = found_sig; /* If this is a port assignment, we need to link the expression and signal together immediately */ if( exp->op == EXP_OP_PASSIGN ) { vector_dealloc( exp->value ); exp->suppl.part.owns_vec = 0; exp->value = found_sig->value; } if( ((exp->op == EXP_OP_SIG) || (exp->op == EXP_OP_SBIT_SEL) || (exp->op == EXP_OP_MBIT_SEL) || (exp->op == EXP_OP_MBIT_POS) || (exp->op == EXP_OP_MBIT_NEG) || (exp->op == EXP_OP_PARAM) || (exp->op == EXP_OP_PARAM_SBIT) || (exp->op == EXP_OP_PARAM_MBIT) || (exp->op == EXP_OP_PARAM_MBIT_POS) || (exp->op == EXP_OP_PARAM_MBIT_NEG) || (exp->op == EXP_OP_TRIGGER)) && (cdd_reading || (found_sig->suppl.part.type == SSUPPL_TYPE_GENVAR)) ) { expression_set_value( exp, found_sig, funit_exp ); } /* Create a non-blocking assignment handler for the given expression if the attached signal is a memory and the expression is assignable on the LHS of a non-blocking assignment operator. Only perform this if we are reading from the CDD file and binding. */ if( cdd_reading && (found_sig->suppl.part.type == SSUPPL_TYPE_MEM) ) { expression* nba_exp; if( (nba_exp = expression_is_nba_lhs( exp )) != NULL ) { expression_create_nba( exp, found_sig, nba_exp->right->value ); } } } if( !cdd_reading ) { /* Check to see if this signal should be assigned by Covered or the dumpfile */ if( clear_assigned ) { found_sig->suppl.part.assigned = 0; } if( !clear_assigned && ((exp->op == EXP_OP_SIG) || (exp->op == EXP_OP_SBIT_SEL) || (exp->op == EXP_OP_MBIT_SEL) || (exp->op == EXP_OP_MBIT_POS) || (exp->op == EXP_OP_MBIT_NEG)) && !ovl_is_assertion_module( funit_exp ) ) { expression_set_assigned( exp ); } /* Set signed bits */ if( !clear_assigned ) { expression_set_signed( exp ); } /* If the signal is found for the given expression but the signal is marked as "must be assigned" but is also marked as "won't be assigned", we need to remove all statement blocks that contain this signal from coverage consideration. */ if( (found_sig->suppl.part.assigned == 0) && (found_sig->suppl.part.mba == 1) ) { expl = found_sig->exp_head; while( expl != NULL ) { if( (stmt = expression_get_root_statement( expl->exp )) != NULL ) { #ifdef DEBUG_MODE if( debug_mode ) { unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Removing statement block %d, line %d because it needed to be assigned but would not be", stmt->exp->id, stmt->exp->line ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, DEBUG, __FILE__, __LINE__ ); } #endif stmt_blk_add_to_remove_list( stmt ); } expl = expl->next; } } } } } else { retval = FALSE; } PROFILE_END; return( retval ); }

---