binding.h File Reference

Contains all functions for vsignal/expression binding. More...

#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.

---

Detailed Description

Contains all functions for vsignal/expression binding.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

3/4/2002

---

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

References exp_bind_s::clear_assigned, exp_bind_s::exp, exp_bind_s::fsm, exp_bind_s::funit, expression_s::line, exp_bind_s::line, malloc_safe, exp_bind_s::name, exp_bind_s::next, PROFILE, PROFILE_END, strdup_safe, and exp_bind_s::type.

Referenced by bind_task_function_ports(), db_bind_expr_tree(), db_create_expression(), expression_db_read(), gen_item_resolve(), and static_expr_gen().

  { 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)

References exp_bind_s::exp, exp_bind_s::fsm, exp_bind_s::funit, exp_bind_s::next, PROFILE, and PROFILE_END.

Referenced by fsm_db_read().

  { 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.

References free_safe, exp_bind_s::name, exp_bind_s::next, PROFILE, and PROFILE_END.

Referenced by db_close().

                    { 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

References exp_bind_s::exp, free_safe, exp_bind_s::funit, funit_get_curr_module_safe(), malloc_safe, func_unit_s::name, exp_bind_s::name, exp_bind_s::next, PROFILE, PROFILE_END, scope_extract_front(), scope_find_signal(), and strdup_safe.

Referenced by expression_find_rhs_sigs().

  { 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)

References bind_param(), bind_remove(), bind_signal(), bind_task_function_namedblock(), Catch_anonymous, exp_bind_s::clear_assigned, curr_db, DEBUG, debug_mode, exp_bind_s::exp, expression_get_root_statement(), FALSE, func_unit_s::filename, free_safe, exp_bind_s::fsm, exp_bind_s::funit, FUNIT_NAMED_BLOCK, FUNIT_TASK, expression_s::id, inst_link_s::inst, db_s::inst_head, instance_resolve(), expression_s::line, exp_bind_s::line, exp_bind_s::name, expression_s::name, inst_link_s::next, exp_bind_s::next, obf_file, print_output(), PROFILE, PROFILE_END, stmt_blk_add_to_remove_list(), strdup_safe, Throw, TRUE, Try, exp_bind_s::type, user_msg, USER_MSG_LENGTH, expression_s::value, VDATA_UL, vector_create(), VTYPE_EXP, and vector_s::width.

Referenced by command_exclude(), command_merge(), command_report(), covered_sim_calltf(), parse_and_score_dumpfile(), parse_design(), rank_read_cdd(), and report_read_cdd_and_ready().

  { 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 ) {
              assert( curr_eb->exp != 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, generate blocks and arrays of instances now */
      if( !cdd_reading && (pass == 0) ) {
        inst_link* 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

References exp_bind_s::clear_assigned, exp_bind_s::exp, free_safe, expression_s::id, exp_bind_s::name, exp_bind_s::next, PROFILE, and PROFILE_END.

Referenced by bind_perform(), and expression_dealloc().

  { 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

References ssuppl_u::assigned, expression_s::col, DEBUG, debug_mode, vsignal_s::dim, ESUPPL_IS_LHS, statement_s::exp, exp_link_s::exp, vsignal_s::exp_head, exp_link_add(), EXP_OP_MBIT_NEG, EXP_OP_MBIT_POS, EXP_OP_MBIT_SEL, EXP_OP_PARAM, EXP_OP_PARAM_MBIT, EXP_OP_PARAM_MBIT_NEG, EXP_OP_PARAM_MBIT_POS, EXP_OP_PARAM_SBIT, EXP_OP_PASSIGN, EXP_OP_SBIT_SEL, EXP_OP_SIG, EXP_OP_TRIGGER, vsignal_s::exp_tail, expression_create_nba(), expression_get_root_statement(), expression_is_nba_lhs(), expression_set_assigned(), expression_set_signed(), expression_set_value(), FALSE, FATAL, func_unit_s::filename, esuppl_u::gen_expr, expression_s::id, expression_s::line, dim_range_s::lsb, malloc_safe, ssuppl_u::mba, dim_range_s::msb, func_unit_s::name, exp_link_s::next, ssuppl_u::not_handled, obf_file, obf_funit, obf_sig, expression_s::op, ovl_is_assertion_module(), esuppl_u::owns_vec, ssuppl_u::part, expression_s::part, esuppl_u::part, vsignal_s::pdim_num, print_output(), PROFILE, PROFILE_END, expression_s::right, scope_find_signal(), scope_local(), expression_s::sig, func_unit_s::sig_head, sig_link_add(), func_unit_s::sig_tail, SSUPPL_TYPE_GENVAR, SSUPPL_TYPE_IMPLICIT, SSUPPL_TYPE_MEM, stmt_blk_add_to_remove_list(), vsignal_s::suppl, expression_s::suppl, Throw, TRUE, ssuppl_u::type, user_msg, USER_MSG_LENGTH, vsignal_s::value, expression_s::value, vector_dealloc(), vsignal_create(), WARNING, and WARNING_WRAP.

Referenced by bind_perform(), and fsm_var_bind_expr().

  { 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;

      /* If the expression is within a generate expression, emit an error message */
      } else if( (exp != NULL) && (exp->suppl.part.gen_expr == 1) ) {
        rv = snprintf( user_msg, USER_MSG_LENGTH, "Generate expression could not find variable (%s), file %s, line %d",
                       obf_sig( name ), obf_file( funit_exp->filename ), exp_line );
        assert( rv < USER_MSG_LENGTH );
        print_output( user_msg, FATAL, __FILE__, __LINE__ );
        Throw 0;

      /* Otherwise, implicitly create the signal and bind to it if the signal exists on the LHS of the equation */
      } else if( (exp != NULL) && (ESUPPL_IS_LHS( exp->suppl ) == 1) ) {
        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.part.first );
        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 the expression is a generate expression on the LHS and the found signal is not a generate variable, emit an error message
       and exit immediately.
      */
      if( (exp != NULL) && (exp->suppl.part.gen_expr == 1) && (ESUPPL_IS_LHS( exp->suppl ) == 1) && (found_sig->suppl.part.type != SSUPPL_TYPE_GENVAR) ) {
        rv = snprintf( user_msg, USER_MSG_LENGTH, "Attempting to bind an generate expression to a signal that is not a genvar, file %s, line %d",
                       obf_file( funit_exp->filename ), exp_line );
        assert( rv < USER_MSG_LENGTH );
        print_output( user_msg, FATAL, __FILE__, __LINE__ );
        Throw 0;
      }

    }

    if( retval ) {

      /* Bind signal and expression if we are not clearing or this is an MBA */
      if( !clear_assigned ) {

        assert( exp != NULL );

        /* 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 );

}