race.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "db.h"
#include "defines.h"
#include "expr.h"
#include "func_unit.h"
#include "link.h"
#include "obfuscate.h"
#include "ovl.h"
#include "race.h"
#include "statement.h"
#include "stmt_blk.h"
#include "util.h"
#include "vector.h"
#include "vsignal.h"

Functions
static void	race_calc_assignments (statement *, int)
static race_blk *	race_blk_create (int reason, int start_line, int end_line)
static bool	race_find_head_statement_containing_statement_helper (statement *curr, statement *to_find)
static statement *	race_find_head_statement_containing_statement (statement *stmt)
static statement *	race_get_head_statement (expression *expr)
static int	race_find_head_statement (statement *stmt)
static void	race_calc_stmt_blk_type (expression *expr, int sb_index)
static void	race_calc_expr_assignment (expression *exp, int sb_index)
static void	race_handle_race_condition (expression *expr, func_unit *mod, statement *stmt, statement *base, int reason)
static void	race_check_assignment_types (func_unit *mod)
static void	race_check_one_block_assignment (func_unit *mod)
static void	race_check_race_count ()
void	race_check_modules ()
	Checks the current module for race conditions.
void	race_db_write (race_blk *rb, FILE *file)
	Writes contents of specified race condition block to specified file output.
void	race_db_read (char **line, func_unit *curr_mod)
	Reads contents from specified line for a race condition block and assigns the new block to the curr_mod.
void	race_get_stats (race_blk *curr, unsigned int *race_total, unsigned int type_total[][RACE_TYPE_NUM])
	Get statistic information for the specified race condition block list.
static bool	race_report_summary (FILE *ofile, funit_link *head)
static void	race_report_verbose (FILE *ofile, funit_link *head)
void	race_report (FILE *ofile, bool verbose)
	Displays report information for race condition blocks in design.
void	race_collect_lines (func_unit *funit, int **slines, int **elines, int **reasons, int *line_cnt)
	Collects all of the lines in the specified module that were not verified due to race condition breach.
void	race_blk_delete_list (race_blk *rb)
	Deallocates the specified race condition block from memory.
Variables
static stmt_blk *	sb = NULL
static int	sb_size
static int	races_found = 0
const char *	race_msgs [RACE_TYPE_NUM]
int	flag_race_check
char	user_msg [USER_MSG_LENGTH]
db **	db_list
unsigned int	curr_db
func_unit *	curr_funit
isuppl	info_suppl
int	stmt_conn_id
bool	debug_mode
str_link *	race_ignore_mod_head
str_link *	race_ignore_mod_tail

---

Detailed Description

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

12/15/2004

The contents of this file contain functions to handle race condition checking and information handling regarding race conditions. Since race conditions can cause the Covered simulator to not provide the same run-time order as the primary Verilog simulator, we need to be able to detect when race conditions are occurring within the design. The conditions that are checked within the design during the parsing stage can be found Race Condition Violation Types.

The failure of any one of these rules will cause Covered to either display warning type messages to the user when the race condition checking flag has not been set or error messages when the race condition checking flag has been set by the user.

---

Function Documentation

static race_blk* race_blk_create	(	int	reason,
		int	start_line,
		int	end_line
	)			[static]

Returns:

Returns a pointer to the newly allocated race condition block.

Allocates and initializes memory for a race condition block.

Parameters:

	reason	Numerical reason for why race condition was detected
	start_line	Starting line of race condition block
	end_line	Ending line of race condition block

References race_blk_s::end_line, malloc_safe, race_blk_s::next, PROFILE, PROFILE_END, race_blk_s::reason, and race_blk_s::start_line.

Referenced by race_db_read(), and race_handle_race_condition().

  { PROFILE(RACE_BLK_CREATE);

  race_blk* rb;  /* Pointer to newly allocated race condition block */

  rb             = (race_blk*)malloc_safe( sizeof( race_blk ) );
  rb->reason     = reason;
  rb->start_line = start_line;
  rb->end_line   = end_line;
  rb->next       = NULL;

  PROFILE_END;

  return( rb );

}

void race_blk_delete_list

(

race_blk *

rb

)

Deallocates the specified race condition block from memory.

Recursively deallocates the specified race condition block list.

Parameters:

rb

Pointer to race condition block to deallocate

References free_safe, race_blk_s::next, PROFILE, PROFILE_END, and race_blk_delete_list().

Referenced by funit_clean(), and race_blk_delete_list().

  { PROFILE(RACE_BLK_DELETE_LIST);

  if( rb != NULL ) {

    /* Delete the next race condition block first */
    race_blk_delete_list( rb->next );

    /* Deallocate the memory for this race condition block */
    free_safe( rb, sizeof( race_blk ) );

  }

  PROFILE_END;

}

void race_calc_assignments	(	statement *	stmt,
		int	sb_index
	)			[static]

Recursively iterates through the given statement block, searching for all assignment types used within the block.

Parameters:

	stmt	Pointer to statement to get assign type from
	sb_index	Current statement block index containing the given statement

References statement_s::conn_id, statement_s::exp, statement_s::next_false, statement_s::next_true, statement_s::part, PROFILE, PROFILE_END, race_calc_expr_assignment(), stmt_conn_id, and statement_s::suppl.

Referenced by race_calc_expr_assignment(), and race_check_modules().

  { PROFILE(RACE_CALC_ASSIGNMENTS);

  if( (stmt != NULL) && (stmt->conn_id != stmt_conn_id) ) {

    stmt->conn_id = stmt_conn_id;

    /* Calculate children statements */
    if( stmt->suppl.part.stop_true == 0 ) {
      race_calc_assignments( stmt->next_true, sb_index );
    }
    if( (stmt->suppl.part.stop_false == 0) && (stmt->next_true != stmt->next_false) ) {
      race_calc_assignments( stmt->next_false, sb_index );
    }

    /* Calculate assignment operator type */
    race_calc_expr_assignment( stmt->exp, sb_index );

  }

  PROFILE_END;

}

static void race_calc_expr_assignment	(	expression *	exp,
		int	sb_index
	)			[static]

Checks the given expression for its assignment type and sets the given statement block structure to the appropriate assign type value. If the given expression is a named block, iterate through that block searching for an assignment type.

Parameters:

	exp	Pointer to expression to check for expression assignment type
	sb_index	Current statement block index containing the given expression

References stmt_blk_s::bassign, expression_s::elem, EXP_OP_ASSIGN, EXP_OP_BASSIGN, EXP_OP_DASSIGN, EXP_OP_FORK, EXP_OP_NASSIGN, EXP_OP_NB_CALL, EXP_OP_TASK_CALL, func_unit_s::first_stmt, esuppl_u::for_cntrl, expression_s::funit, stmt_blk_s::nassign, expression_s::op, esuppl_u::part, PROFILE, PROFILE_END, race_calc_assignments(), expression_s::suppl, and TRUE.

Referenced by race_calc_assignments().

  { PROFILE(RACE_CALC_EXPR_ASSIGNMENT);

  switch( exp->op ) {
    case EXP_OP_ASSIGN    :
    case EXP_OP_DASSIGN   :  sb[sb_index].bassign = TRUE;  break;
    case EXP_OP_NASSIGN   :  sb[sb_index].nassign = TRUE;  break;
    case EXP_OP_BASSIGN   :  sb[sb_index].bassign = (exp->suppl.part.for_cntrl == 0);  break;
    case EXP_OP_TASK_CALL :
    case EXP_OP_FORK      :
    case EXP_OP_NB_CALL   :  race_calc_assignments( exp->elem.funit->first_stmt, sb_index );  break;
    default               :  break;
  }

  PROFILE_END;

}

static void race_calc_stmt_blk_type	(	expression *	expr,
		int	sb_index
	)			[static]

Recursively iterates down expression tree, searching for an expression which will indicate that its statement block is a sequential always block or a combinational always block.

Parameters:

	expr	Pointer to expression to check for statement block type (sequential/combinational)
	sb_index	Current statement block index containing the given expression

References stmt_blk_s::cmb, EXP_OP_AEDGE, EXP_OP_ALWAYS_COMB, EXP_OP_ALWAYS_LATCH, EXP_OP_NEDGE, EXP_OP_PEDGE, expression_s::left, expression_s::op, PROFILE, PROFILE_END, expression_s::right, stmt_blk_s::seq, and TRUE.

Referenced by race_check_modules().

  { PROFILE(RACE_CALC_STMT_BLK_TYPE);

  if( expr != NULL ) {

    /* Go to children to calculate further */
    race_calc_stmt_blk_type( expr->left,  sb_index );
    race_calc_stmt_blk_type( expr->right, sb_index );

    if( (expr->op == EXP_OP_PEDGE) || (expr->op == EXP_OP_NEDGE) || (expr->op == EXP_OP_ALWAYS_LATCH) ) {
      sb[sb_index].seq = TRUE;
    }

    if( (expr->op == EXP_OP_AEDGE) || (expr->op == EXP_OP_ALWAYS_COMB) ) {
      sb[sb_index].cmb = TRUE;
    }

  }

  PROFILE_END;

}

static void race_check_assignment_types

(

func_unit *

mod

)

[static]

Performs the race condition assignment checks for each statement block.

Parameters:

mod

Pointer to functional unit to check assignment types for

References PROFILE, PROFILE_END, race_handle_race_condition(), RACE_TYPE_CMB_USES_BLOCK, RACE_TYPE_HOMOGENOUS, RACE_TYPE_MIX_USES_NON_BLOCK, RACE_TYPE_SEQ_USES_NON_BLOCK, sb_size, and stmt_blk_s::stmt.

Referenced by race_check_modules().

  { PROFILE(RACE_CHECK_ASSIGNMENT_TYPES);

  int i;  /* Loop iterator */

  for( i=0; i<sb_size; i++ ) {

    if( sb[i].stmt->suppl.part.ignore_rc == 0 ) {

      /* Check that a sequential logic block contains only non-blocking assignments */
      if( sb[i].seq && !sb[i].cmb && sb[i].bassign ) {

        race_handle_race_condition( sb[i].stmt->exp, mod, sb[i].stmt, sb[i].stmt, RACE_TYPE_SEQ_USES_NON_BLOCK );

      /* Check that a combinational logic block contains only blocking assignments */
      } else if( !sb[i].seq && sb[i].cmb && sb[i].nassign ) {

        race_handle_race_condition( sb[i].stmt->exp, mod, sb[i].stmt, sb[i].stmt, RACE_TYPE_CMB_USES_BLOCK );

      /* Check that mixed logic block contains only non-blocking assignments */
      } else if( sb[i].seq && sb[i].cmb && sb[i].bassign ) {

        race_handle_race_condition( sb[i].stmt->exp, mod, sb[i].stmt, sb[i].stmt, RACE_TYPE_MIX_USES_NON_BLOCK );

      /* Check that a statement block doesn't contain both blocking and non-blocking assignments */
      } else if( sb[i].bassign && sb[i].nassign ) {

        race_handle_race_condition( sb[i].stmt->exp, mod, sb[i].stmt, sb[i].stmt, RACE_TYPE_HOMOGENOUS );

      }

    }

  }

  PROFILE_END;

}

void race_check_modules

(

)

Checks the current module for race conditions.

Exceptions:

anonymous

race_check_race_count funit_size_elements

Performs race checking for the currently loaded module. This function should be called when the endmodule keyword is detected in the current module.

References isuppl_u::assert_ovl, stmt_blk_s::bassign, stmt_blk_s::cmb, curr_db, DEBUG, debug_mode, FALSE, free_safe, funit_link_s::funit, db_s::funit_head, FUNIT_MODULE, funit_size_elements(), db_s::inst_head, inst_link_find_by_funit(), malloc_safe, func_unit_s::name, stmt_blk_s::nassign, funit_link_s::next, stmt_link_s::next, ovl_is_assertion_module(), statement_s::part, isuppl_u::part, print_output(), PROFILE, PROFILE_END, race_calc_assignments(), race_calc_stmt_blk_type(), race_check_assignment_types(), race_check_one_block_assignment(), race_check_race_count(), stmt_blk_s::remove, sb_size, stmt_blk_s::seq, stmt_blk_s::stmt, stmt_link_s::stmt, stmt_blk_add_to_remove_list(), stmt_conn_id, func_unit_s::stmt_head, str_link_find(), statement_s::suppl, and func_unit_s::type.

Referenced by parse_design().

                          { PROFILE(RACE_CHECK_MODULES);

  int         sb_index;  /* Index to statement block array */
  stmt_link*  curr;
  funit_link* modl;      /* Pointer to current module link */
  int         i;         /* Loop iterator */
  int         ignore;    /* Placeholder */
  funit_inst* inst;      /* Instance of this functional unit */

  modl = db_list[curr_db]->funit_head;

  while( modl != NULL ) {

    /* Get instance */
    ignore = 0;
    inst   = inst_link_find_by_funit( modl->funit, db_list[curr_db]->inst_head, &ignore );

    /* Only perform race condition checking for modules that are instantiated and are not OVL assertions and are not ignored */
    if( (modl->funit->type == FUNIT_MODULE) &&
        (inst != NULL) &&
        ((info_suppl.part.assert_ovl == 0) || !ovl_is_assertion_module( modl->funit )) &&
        (str_link_find( modl->funit->name, race_ignore_mod_head ) == NULL) ) {

      /* Size elements for the current module */
      funit_size_elements( modl->funit, inst, FALSE, FALSE );

      /* Clear statement block array size */
      sb_size = 0;

      /* First, get the size of the statement block array for this module */
      curr = modl->funit->stmt_head;
      while( curr != NULL ) {
        if( (curr->stmt->suppl.part.head == 1) &&
            (curr->stmt->suppl.part.is_called == 0) ) {
          sb_size++;
        }
        curr = curr->next;
      }

      if( sb_size > 0 ) {

        /* Allocate memory for the statement block array and clear current index */
        sb       = (stmt_blk*)malloc_safe( sizeof( stmt_blk ) * sb_size );
        sb_index = 0;

        /* Second, populate the statement block array with pointers to the head statements */
        curr = modl->funit->stmt_head;
        while( curr != NULL ) {
          if( (curr->stmt->suppl.part.head == 1) &&
              (curr->stmt->suppl.part.is_called == 0) ) {
            sb[sb_index].stmt    = curr->stmt;
            sb[sb_index].remove  = FALSE;
            sb[sb_index].seq     = FALSE;
            sb[sb_index].cmb     = FALSE;
            sb[sb_index].bassign = FALSE;
            sb[sb_index].nassign = FALSE;
            race_calc_stmt_blk_type( sb[sb_index].stmt->exp, sb_index );
            race_calc_assignments( sb[sb_index].stmt, sb_index );
            sb_index++; 
            stmt_conn_id++;
          }
          curr = curr->next;
        }

        /* Perform checks #1 - #5 */
        race_check_assignment_types( modl->funit );

        /* Perform check #6 */
        race_check_one_block_assignment( modl->funit );

        /* Cleanup statements to be removed */
        curr_funit = modl->funit;
        for( i=0; i<sb_size; i++ ) {
          if( sb[i].remove ) {
#ifdef DEBUG_MODE
            if( debug_mode ) {
              print_output( "Removing statement block because it was found to have a race condition", DEBUG, __FILE__, __LINE__ );
            }
#endif 
            stmt_blk_add_to_remove_list( sb[i].stmt );
          }
        }

        /* Deallocate stmt_blk list */
        free_safe( sb, (sizeof( stmt_blk ) * sb_size) );

      }

    }

    modl = modl->next;

  }

  /* Handle output if any race conditions were found */
  race_check_race_count();

  PROFILE_END;

}

static void race_check_one_block_assignment

(

func_unit *

mod

)

[static]

Verifies that every signal is assigned in only one statement block. If a signal is assigned in more than one statement block, both statement block's need to be removed from coverage consideration and a possible warning/error message generated to the user.

Parameters:

mod

Pointer to module containing signals to verify

References vsignal_s::dim, ESUPPL_IS_LHS, ESUPPL_IS_ROOT, statement_s::exp, exp_link_s::exp, vsignal_s::exp_head, EXP_OP_DIM, EXP_OP_MBIT_NEG, EXP_OP_MBIT_POS, EXP_OP_MBIT_SEL, EXP_OP_RASSIGN, EXP_OP_SBIT_SEL, EXP_OP_SIG, EXP_OP_STATIC, expr_stmt_u::expr, expression_get_curr_dimension(), expression_is_bit_select(), expression_is_in_rassign(), expression_is_last_select(), FALSE, expression_s::left, dim_range_s::lsb, dim_range_s::msb, sig_link_s::next, exp_link_s::next, expression_s::op, expression_s::parent, statement_s::part, ssuppl_u::part, PROFILE, PROFILE_END, race_find_head_statement(), race_get_head_statement(), race_handle_race_condition(), RACE_TYPE_ASSIGN_IN_ONE_BLOCK1, RACE_TYPE_ASSIGN_IN_ONE_BLOCK2, stmt_blk_s::remove, expression_s::right, sig_link_s::sig, func_unit_s::sig_head, SSUPPL_TYPE_GENVAR, SSUPPL_TYPE_INOUT_NET, SSUPPL_TYPE_INOUT_REG, SSUPPL_TYPE_INPUT_NET, SSUPPL_TYPE_INPUT_REG, SSUPPL_TYPE_MEM, stmt_blk_s::stmt, statement_s::suppl, expression_s::suppl, vsignal_s::suppl, TRUE, ssuppl_u::type, vsignal_s::value, expression_s::value, vector_set_assigned(), vector_to_int(), vsignal_calc_width_for_expr(), and vector_s::width.

Referenced by race_check_modules().

  { PROFILE(RACE_CHECK_ONE_BLOCK_ASSIGNMENT);

  sig_link*  sigl;                /* Pointer to current signal */
  exp_link*  expl;                /* Pointer to current expression */
  statement* curr_stmt;           /* Pointer to current statement */
  int        sig_stmt;            /* Index of base signal statement in statement block array */
  bool       curr_race  = FALSE;  /* Set to TRUE if race condition was found in current iteration */
  int        lval;                /* Left expression value */
  int        rval;                /* Right expression value */
  int        exp_dim;             /* Current expression dimension */
  int        dim_lsb;             /* LSB of current dimension */
  bool       dim_be;              /* Big endianness of current dimension */
  int        dim_width;           /* Bit width of current dimension */
  int        intval;              /* Integer value */

  sigl = mod->sig_head;
  while( sigl != NULL ) {

    sig_stmt = -1;

    /* Skip checking the expressions of genvar signals */
    if( (sigl->sig->suppl.part.type != SSUPPL_TYPE_GENVAR) && (sigl->sig->suppl.part.type != SSUPPL_TYPE_MEM) ) {

      /* Iterate through expressions */
      expl = sigl->sig->exp_head;
      while( expl != NULL ) {
                                              
        /* Only look at expressions that are part of LHS and they are not part of a bit select */
        if( (ESUPPL_IS_LHS( expl->exp->suppl ) == 1) && !expression_is_bit_select( expl->exp ) && expression_is_last_select( expl->exp ) ) {

          /* Get head statement of current expression */
          curr_stmt = race_get_head_statement( expl->exp );

          /* If the head statement is being ignored from race condition checking, skip the rest */
          if( (curr_stmt != NULL) && (curr_stmt->suppl.part.ignore_rc == 0) ) {

            vector* src;
            int     vwidth;

            /* Get current dimension of the given expression */
            exp_dim = expression_get_curr_dimension( expl->exp );
  
            /* Calculate starting vector value bit and signal LSB/BE for LHS */
            if( (ESUPPL_IS_ROOT( expl->exp->suppl ) == 0) &&
                (expl->exp->parent->expr->op == EXP_OP_DIM) && (expl->exp->parent->expr->right == expl->exp) ) {
              src    = expl->exp->parent->expr->left->value;
              vwidth = src->width;
            } else {
              /* Get starting vector bit from signal itself */
              src    = sigl->sig->value;
              vwidth = src->width;
            }
            if( sigl->sig->dim[exp_dim].lsb < sigl->sig->dim[exp_dim].msb ) {
              dim_lsb = sigl->sig->dim[exp_dim].lsb;
              dim_be  = FALSE;
            } else {
              dim_lsb = sigl->sig->dim[exp_dim].msb;
              dim_be  = TRUE;
            }
            dim_width = vsignal_calc_width_for_expr( expl->exp, sigl->sig );

            /*
             If the signal was a part select, set the appropriate misc bits to indicate what
             bits have been assigned.
            */
            switch( expl->exp->op ) {
              case EXP_OP_SIG :
                if( (ESUPPL_IS_ROOT( expl->exp->suppl ) == 0) && !expression_is_in_rassign( expl->exp ) ) {
                  curr_race = vector_set_assigned( sigl->sig->value, (sigl->sig->value->width - 1), 0 );
                }
              break;
              case EXP_OP_SBIT_SEL :
                if( expl->exp->left->op == EXP_OP_STATIC ) {
                  intval = (vector_to_int( expl->exp->left->value ) - dim_lsb) * dim_width;
                  if( (intval >= 0) && ((unsigned int)intval < expl->exp->value->width) ) {
                    if( dim_be ) {
                      int lsb = (vwidth - (intval + expl->exp->value->width));
                      curr_race = vector_set_assigned( sigl->sig->value, ((expl->exp->value->width - 1) + lsb), lsb );
                    } else {
                      curr_race = vector_set_assigned( sigl->sig->value, ((expl->exp->value->width - 1) + intval), intval );
                    }
                  } else {
                    curr_race = FALSE;
                  }
                } else { 
                  curr_race = vector_set_assigned( sigl->sig->value, (sigl->sig->value->width - 1), 0 );
                }
              break;
              case EXP_OP_MBIT_SEL :
                if( (expl->exp->left->op == EXP_OP_STATIC) && (expl->exp->right->op == EXP_OP_STATIC) ) {
                  intval = ((dim_be ? vector_to_int( expl->exp->left->value ) : vector_to_int( expl->exp->right->value )) - dim_lsb) * dim_width;
                  if( dim_be ) {
                    int lsb = (vwidth - (intval + expl->exp->value->width));
                    curr_race = vector_set_assigned( sigl->sig->value, ((expl->exp->value->width - 1) + lsb), lsb );
                  } else {
                    curr_race = vector_set_assigned( sigl->sig->value, ((expl->exp->value->width - 1) + intval), intval );
                  }
                } else {
                  curr_race = vector_set_assigned( sigl->sig->value, (sigl->sig->value->width - 1), 0 );
                }
                break;
              case EXP_OP_MBIT_POS :
                if( expl->exp->left->op == EXP_OP_STATIC ) {
                  lval = vector_to_int( expl->exp->left->value );
                  rval = vector_to_int( expl->exp->right->value );
                  curr_race = vector_set_assigned( sigl->sig->value, ((lval + rval) - sigl->sig->dim[exp_dim].lsb), (lval - sigl->sig->dim[exp_dim].lsb) );
                } else {
                  curr_race = vector_set_assigned( sigl->sig->value, (sigl->sig->value->width - 1), 0 );
                }
                break;
              case EXP_OP_MBIT_NEG :
                if( expl->exp->left->op == EXP_OP_STATIC ) {
                  lval = vector_to_int( expl->exp->left->value );
                  rval = vector_to_int( expl->exp->right->value );
                  curr_race = vector_set_assigned( sigl->sig->value, ((lval + 1) - sigl->sig->dim[exp_dim].lsb), (((lval - rval) + 1) - sigl->sig->dim[exp_dim].lsb) );
                } else {
                  curr_race = vector_set_assigned( sigl->sig->value, (sigl->sig->value->width - 1), 0 );
                }
                break;
              default :
                curr_race = FALSE;
                break;  
            }
  
            /*
             Get expression's head statement and if the statement is not a register assignment, check for
             race conditions (the way that RASSIGNs are treated, they will not cause race conditions so omit
             them from being checked.
            */
            if( (curr_stmt != NULL) && (curr_stmt->exp->op != EXP_OP_RASSIGN) ) {

              /* Check to see if the current signal is already being assigned in another statement */
              if( sig_stmt == -1 ) {

                /* Get index of base signal statement in sb array */
                sig_stmt = race_find_head_statement( curr_stmt );
                assert( sig_stmt != -1 );
  
                /* Check to see if current signal is also an input port */ 
                if( (sigl->sig->suppl.part.type == SSUPPL_TYPE_INPUT_NET) ||
                    (sigl->sig->suppl.part.type == SSUPPL_TYPE_INPUT_REG) ||
                    (sigl->sig->suppl.part.type == SSUPPL_TYPE_INOUT_NET) ||
                    (sigl->sig->suppl.part.type == SSUPPL_TYPE_INOUT_REG) || curr_race ) {
                  race_handle_race_condition( expl->exp, mod, curr_stmt, NULL, RACE_TYPE_ASSIGN_IN_ONE_BLOCK2 );
                  sb[sig_stmt].remove = TRUE;
                }
  
              } else if( (sb[sig_stmt].stmt != curr_stmt) && curr_race ) {
  
                race_handle_race_condition( expl->exp, mod, curr_stmt, sb[sig_stmt].stmt, RACE_TYPE_ASSIGN_IN_ONE_BLOCK1 );
                sb[sig_stmt].remove = TRUE;
  
              }
  
            }

          }

        }

        expl = expl->next;

      }

    }

    sigl = sigl->next;

  }

  PROFILE_END;

}

static void race_check_race_count

(

)

[static]

Returns:

Returns TRUE if no race conditions were found or the user specified that we should continue to score the design.

Exceptions:

anonymous

Throw

References FATAL, flag_race_check, print_output(), PROFILE, PROFILE_END, races_found, Throw, user_msg, and USER_MSG_LENGTH.

Referenced by race_check_modules().

                                    { PROFILE(RACE_CHECK_RACE_COUNT);

  /*
   If we were able to find race conditions and the user specified to check for race conditions
   and quit, display the number of race conditions found and return FALSE to cause everything to
   halt.
  */
  if( (races_found > 0) && (flag_race_check == FATAL) ) {

    unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "%d race conditions were detected.  Exiting score command.", races_found );
    assert( rv < USER_MSG_LENGTH );
    print_output( user_msg, FATAL, __FILE__, __LINE__ );
    Throw 0;

  }

  PROFILE_END;

}

void race_collect_lines	(	func_unit *	funit,
		int **	slines,
		int **	elines,
		int **	reasons,
		int *	line_cnt
	)

Collects all of the lines in the specified module that were not verified due to race condition breach.

Collects all of the line numbers in the specified module that were ignored from coverage due to detecting a race condition. This function is primarily used by the GUI for outputting purposes.

Parameters:

	funit	Pointer to functional unit
	slines	Pointer to an array of starting line numbers that contain line numbers of race condition statements
	elines	Pointer to an array of ending line numbers that contain line numbers of race condition statements
	reasons	Pointer to an array of race condition reason integers, one for each line in the lines array
	line_cnt	Pointer to number of elements that exist in lines array

References race_blk_s::end_line, race_blk_s::next, PROFILE, PROFILE_END, func_unit_s::race_head, realloc_safe, race_blk_s::reason, and race_blk_s::start_line.

  { PROFILE(RACE_COLLECT_LINES);

  race_blk* curr_race = NULL;  /* Pointer to current race condition block */

  /* Begin by allocating some memory for the lines */
  *slines   = NULL;
  *elines   = NULL;
  *reasons  = NULL;
  *line_cnt = 0;

  curr_race = funit->race_head;
  while( curr_race != NULL ) {

    *slines  = (int*)realloc_safe( *slines,  (sizeof( int ) * (*line_cnt)), (sizeof( int ) * (*line_cnt + 1)) );
    *elines  = (int*)realloc_safe( *elines,  (sizeof( int ) * (*line_cnt)), (sizeof( int ) * (*line_cnt + 1)) );
    *reasons = (int*)realloc_safe( *reasons, (sizeof( int ) * (*line_cnt)), (sizeof( int ) * (*line_cnt + 1)) );

    (*slines)[*line_cnt]  = curr_race->start_line;
    (*elines)[*line_cnt]  = curr_race->end_line;
    (*reasons)[*line_cnt] = curr_race->reason;
    (*line_cnt)++;

    curr_race = curr_race->next;

  }

  PROFILE_END;

}

void race_db_read	(	char **	line,
		func_unit *	curr_mod
	)

Reads contents from specified line for a race condition block and assigns the new block to the curr_mod.

Exceptions:

anonymous

Throw Throw

Reads the specified line from the CDD file and parses it for race condition block information.

Parameters:

	line	Pointer to line containing information for a race condition block
	curr_mod	Pointer to current module to store race condition block to

References FATAL, race_blk_s::next, print_output(), PROFILE, PROFILE_END, race_blk_create(), func_unit_s::race_head, func_unit_s::race_tail, and Throw.

Referenced by db_read(), and funit_db_mod_merge().

  { PROFILE(RACE_DB_READ);

  int       start_line;     /* Starting line for race condition block */
  int       end_line;       /* Ending line for race condition block */
  int       reason;         /* Reason for why the race condition block exists */
  int       chars_read;     /* Number of characters read via sscanf */
  race_blk* rb;             /* Pointer to newly created race condition block */

  if( sscanf( *line, "%d %d %d%n", &reason, &start_line, &end_line, &chars_read ) == 3 ) {

    *line = *line + chars_read;

    if( curr_mod == NULL ) {

      print_output( "Internal error:  race condition in database written before its functional unit", FATAL, __FILE__, __LINE__ );
      Throw 0;

    } else {

      /* Create the new race condition block */
      rb = race_blk_create( reason, start_line, end_line );

      /* Add the new race condition block to the current module */
      if( curr_mod->race_head == NULL ) {
        curr_mod->race_head = curr_mod->race_tail = rb;
      } else {
        curr_mod->race_tail->next = rb;
        curr_mod->race_tail       = rb;
      }

    }

  } else {

    print_output( "Unable to parse race condition line in database file.  Unable to read.", FATAL, __FILE__, __LINE__ );
    Throw 0;

  }

  PROFILE_END;

}

void race_db_write	(	race_blk *	rb,
		FILE *	file
	)

Writes contents of specified race condition block to specified file output.

Writes contents of specified race condition block to the specified output stream.

Parameters:

	rb	Pointer to race condition block to write to specified output file
	file	File handle of output stream to write

References DB_TYPE_RACE, race_blk_s::end_line, PROFILE, PROFILE_END, race_blk_s::reason, and race_blk_s::start_line.

Referenced by funit_db_write().

  { PROFILE(RACE_DB_WRITE);

  fprintf( file, "%d %d %d %d\n",
    DB_TYPE_RACE,
    rb->reason,
    rb->start_line,
    rb->end_line
  );

  PROFILE_END;

}

static int race_find_head_statement

(

statement *

stmt

)

[static]

Returns:

Returns index of found head statement in statement block array if found; otherwise, returns a value of -1 to indicate that no such statement block exists.

Parameters:

stmt

Pointer to statement to search for in statement block array

References PROFILE, PROFILE_END, and sb_size.

Referenced by race_check_one_block_assignment(), and race_handle_race_condition().

  { PROFILE(RACE_FIND_HEAD_STATEMENT);

  int i = 0;   /* Loop iterator */

  while( (i < sb_size) && (sb[i].stmt != stmt) ) {
    i++;
  }

  PROFILE_END;

  return( (i == sb_size) ? -1 : i );

}

static statement* race_find_head_statement_containing_statement

(

statement *

stmt

)

[static]

Returns:

Returns a pointer to the statement block containing the given statement (if one is found); otherwise, returns a value of NULL.

Searches all statement blocks for one that contains the given statement within it. Once it is found, a pointer to the head statement block is returned to the calling function. If it is not found, a value of NULL is returned, indicating that the statement block could not be found for the given statement.

Parameters:

stmt

Pointer to statement to search for matching statement block

References PROFILE, PROFILE_END, race_find_head_statement_containing_statement_helper(), sb_size, and stmt_conn_id.

Referenced by race_get_head_statement().

  { PROFILE(RACE_FIND_HEAD_STATEMENT_CONTAINING_STATEMENT);

  int i = 0;   /* Loop iterator */

  while( (i < sb_size) && !race_find_head_statement_containing_statement_helper( sb[i].stmt, stmt ) ) {
    i++;
    stmt_conn_id++;
  }

  if( i < sb_size ) {
    stmt_conn_id++;
  }

  PROFILE_END;

  return( (i == sb_size) ? NULL : sb[i].stmt );

}

static bool race_find_head_statement_containing_statement_helper	(	statement *	curr,
		statement *	to_find
	)			[static]

Returns:

Returns TRUE if the specified to_find statement was found in the statement block specified by curr; otherwise, returns FALSE.

Recursively iterates through specified statement block, searching for statement pointed to by to_find. If the statement is found, a value of TRUE is returned to the calling function; otherwise, a value of FALSE is returned.

Parameters:

	curr	Pointer to current statement to check
	to_find	Pointer to statement to find

References statement_s::conn_id, expression_s::elem, statement_s::exp, EXP_OP_FORK, EXP_OP_NB_CALL, EXP_OP_TASK_CALL, FALSE, func_unit_s::first_stmt, expression_s::funit, statement_s::next_false, statement_s::next_true, expression_s::op, statement_s::part, PROFILE, PROFILE_END, stmt_conn_id, statement_s::suppl, and TRUE.

Referenced by race_find_head_statement_containing_statement().

  { PROFILE(RACE_FIND_HEAD_STATEMENT_CONTAINING_STATEMENT_HELPER);

  bool retval = FALSE;  /* Return value for this function */

  if( (curr != NULL) && (curr->conn_id != stmt_conn_id) ) {

    curr->conn_id = stmt_conn_id;

    if( curr == to_find ) {

      retval = TRUE;

    } else {

      /* 
       If the current statement is a named block call, task call or fork statement, look for specified
       statement in its statement block.
      */
      if( (curr->exp->op == EXP_OP_NB_CALL)   ||
          (curr->exp->op == EXP_OP_TASK_CALL) ||
          (curr->exp->op == EXP_OP_FORK) ) {
        retval = race_find_head_statement_containing_statement_helper( curr->exp->elem.funit->first_stmt, to_find );
      }

      if( !retval && (curr->suppl.part.stop_true == 0) ) {
        retval = race_find_head_statement_containing_statement_helper( curr->next_true, to_find );
      }
   
      if( !retval && (curr->suppl.part.stop_false == 0) && (curr->next_true != curr->next_false) ) {
        retval = race_find_head_statement_containing_statement_helper( curr->next_false, to_find );
      }

    }

  }

  PROFILE_END;

  return( retval );

}

static statement* race_get_head_statement

(

expression *

expr

)

[static]

Returns:

Returns pointer to head statement of statement block containing the specified expression

Finds the head statement of the statement block containing the expression specified in the parameter list. Verifies that the return value is never NULL (this would be an internal error if it existed).

Parameters:

expr

Pointer to root expression to find in statement list

References expression_get_root_statement(), PROFILE, PROFILE_END, and race_find_head_statement_containing_statement().

Referenced by race_check_one_block_assignment().

  { PROFILE(RACE_GET_HEAD_STATEMENT);

  statement* curr_stmt;  /* Pointer to current statement containing the expression */

  /* First, find the statement associated with this expression */
  if( (curr_stmt = expression_get_root_statement( expr )) != NULL ) {

    curr_stmt = race_find_head_statement_containing_statement( curr_stmt );

  }

  PROFILE_END;

  return( curr_stmt );

}

void race_get_stats	(	race_blk *	curr,
		unsigned int *	race_total,
		unsigned int	type_total[][RACE_TYPE_NUM]
	)

Get statistic information for the specified race condition block list.

Iterates through specified race condition block list, totaling the number of race conditions found as well as tallying each type of race condition.

Parameters:

	curr	Pointer to head of race condition block list
	race_total	Pointer to value that will hold the total number of race conditions in this module
	type_total	Pointer to array containing number of race conditions found for each violation type

References race_blk_s::next, PROFILE, PROFILE_END, and race_blk_s::reason.

Referenced by report_gather_funit_stats(), and report_gather_instance_stats().

  { PROFILE(RACE_GET_STATS);

  int i;  /* Loop iterator */

  /* Clear totals */
  *race_total = 0;
  for( i=0; i<RACE_TYPE_NUM; i++ ) {
    (*type_total)[i] = 0;
  }

  /* Tally totals */
  while( curr != NULL ) {
    (*type_total)[curr->reason]++;
    (*race_total)++;
    curr = curr->next;
  }

  PROFILE_END;

}

static void race_handle_race_condition	(	expression *	expr,
		func_unit *	mod,
		statement *	stmt,
		statement *	base,
		int	reason
	)			[static]

Outputs necessary information to user regarding the race condition that was detected and performs any necessary memory cleanup to remove the statement block involved in the race condition.

Parameters:

	expr	Pointer to expression containing signal that was found to be in a race condition
	mod	Pointer to module containing detected race condition
	stmt	Pointer to expr's head statement
	base	Pointer to head statement block that was found to be in conflict with stmt
	reason	Specifies what type of race condition was being checked that failed

References race_blk_s::end_line, statement_s::exp, func_unit_s::filename, flag_race_check, expression_s::line, race_blk_s::next, NORMAL, obf_file, print_output(), PROFILE, PROFILE_END, race_blk_create(), race_find_head_statement(), func_unit_s::race_head, race_msgs, func_unit_s::race_tail, races_found, stmt_blk_s::remove, race_blk_s::start_line, statement_get_last_line(), TRUE, user_msg, USER_MSG_LENGTH, WARNING, and WARNING_WRAP.

Referenced by race_check_assignment_types(), and race_check_one_block_assignment().

  { PROFILE(RACE_HANDLE_RACE_CONDITION);

  race_blk*    rb;         /* Pointer to race condition block to add to specified module */
  int          i;          /* Loop iterator */
  int          last_line;  /* Holds the line number of the last line in the specified statement */
  unsigned int rv;         /* Return value from snprintf calls */

  /* If the base pointer is NULL, the stmt refers to a statement block that conflicts with an input port */
  if( base == NULL ) {

    if( flag_race_check != NORMAL ) {

      print_output( "", (flag_race_check + 1), __FILE__, __LINE__ );
      rv = snprintf( user_msg, USER_MSG_LENGTH, "Possible race condition detected - %s", race_msgs[reason] );
      assert( rv < USER_MSG_LENGTH );
      print_output( user_msg, flag_race_check, __FILE__, __LINE__ );
      rv = snprintf( user_msg, USER_MSG_LENGTH, "  Signal assigned in file: %s, line: %d", obf_file( mod->filename ), expr->line );
      assert( rv < USER_MSG_LENGTH );
      print_output( user_msg, (flag_race_check + 1), __FILE__, __LINE__ );

      if( flag_race_check == WARNING ) {
        print_output( "  * Safely removing statement block from coverage consideration", WARNING_WRAP, __FILE__, __LINE__ );
        rv = snprintf( user_msg, USER_MSG_LENGTH, "    Statement block starting at file: %s, line: %d",
                       obf_file( mod->filename ), stmt->exp->line );
        assert( rv < USER_MSG_LENGTH );
        print_output( user_msg, WARNING_WRAP, __FILE__, __LINE__ );
      }
              
    }

  /* If the stmt and base pointers are pointing to different statements, we will output conflict for stmt */
  } else if( stmt != base ) { 

    if( flag_race_check != NORMAL ) {

      print_output( "", (flag_race_check + 1), __FILE__, __LINE__ );
      rv = snprintf( user_msg, USER_MSG_LENGTH, "Possible race condition detected - %s", race_msgs[reason] );
      assert( rv < USER_MSG_LENGTH );
      print_output( user_msg, flag_race_check, __FILE__, __LINE__ );
      rv = snprintf( user_msg, USER_MSG_LENGTH, "  Signal assigned in file: %s, line: %d", obf_file( mod->filename ), expr->line );
      assert( rv < USER_MSG_LENGTH );
      print_output( user_msg, (flag_race_check + 1), __FILE__, __LINE__ );
      rv = snprintf( user_msg, USER_MSG_LENGTH, "  Signal also assigned in statement starting at file: %s, line: %d",
                     obf_file( mod->filename ), base->exp->line );
      assert( rv < USER_MSG_LENGTH );
      print_output( user_msg, (flag_race_check + 1), __FILE__, __LINE__ );

      if( flag_race_check == WARNING ) {
        print_output( "  * Safely removing statement block from coverage consideration", WARNING_WRAP, __FILE__, __LINE__ );
        rv = snprintf( user_msg, USER_MSG_LENGTH, "    Statement block starting at file: %s, line: %d",
                       obf_file( mod->filename ), stmt->exp->line );
        assert( rv < USER_MSG_LENGTH );
        print_output( user_msg, WARNING_WRAP, __FILE__, __LINE__ );
      }

    }

  /* If stmt and base are pointing to the same statement, just report that we are removing the base statement */
  } else {

    if( flag_race_check != NORMAL ) {

      if( reason != 6 ) {
        
        print_output( "", (flag_race_check + 1), __FILE__, __LINE__ );
        rv = snprintf( user_msg, USER_MSG_LENGTH, "Possible race condition detected - %s", race_msgs[reason] );
        assert( rv < USER_MSG_LENGTH );
        print_output( user_msg, flag_race_check, __FILE__, __LINE__ );
        rv = snprintf( user_msg, USER_MSG_LENGTH, "  Statement block starting in file: %s, line: %d",
                       obf_file( mod->filename ), stmt->exp->line );
        assert( rv < USER_MSG_LENGTH );
        print_output( user_msg, (flag_race_check + 1), __FILE__, __LINE__ );
        if( flag_race_check == WARNING ) {
          print_output( "  * Safely removing statement block from coverage consideration", WARNING_WRAP, __FILE__, __LINE__ );
        }

      } else {

        if( flag_race_check == WARNING ) {
          print_output( "", WARNING_WRAP, __FILE__, __LINE__ );
          print_output( "* Safely removing statement block from coverage consideration", WARNING, __FILE__, __LINE__ );
          rv = snprintf( user_msg, USER_MSG_LENGTH, "  Statement block starting at file: %s, line: %d",
                         obf_file( mod->filename ), stmt->exp->line );
          assert( rv < USER_MSG_LENGTH );
          print_output( user_msg, WARNING_WRAP, __FILE__, __LINE__ );
        }

      }

    }

  }

  /* Calculate the last line of this statement so that we are not constantly doing it */
  last_line = statement_get_last_line( stmt );

  /* Search this module's race list to see if this statement block already exists */
  rb = mod->race_head;
  while( (rb != NULL) && (rb->start_line != stmt->exp->line) && (rb->end_line != last_line) ) {
    rb = rb->next;
  }  

  /* If a matching statement block was not found, go ahead and create it */
  if( rb == NULL ) {

    /* Create a race condition block and add it to current module */
    rb = race_blk_create( reason, stmt->exp->line, last_line );

    /* Add the newly created race condition block to the current module */
    if( mod->race_head == NULL ) {
      mod->race_head = mod->race_tail = rb;
    } else {
      mod->race_tail->next = rb;
      mod->race_tail       = rb;
    }

  }

  /* Set remove flag in stmt_blk array to remove this module from memory */
  i = race_find_head_statement( stmt );
  assert( i != -1 );
  sb[i].remove = TRUE;

  /* Increment races found flag */
  races_found++;

  PROFILE_END;

}

void race_report	(	FILE *	ofile,
		bool	verbose
	)

Displays report information for race condition blocks in design.

Generates the race condition report information and displays it to the specified output stream.

Parameters:

	ofile	Output stream to display report information to
	verbose	Specifies if summary or verbose output should be displayed

References curr_db, funit_head, PROFILE, PROFILE_END, race_report_summary(), and race_report_verbose().

Referenced by report_generate().

  { PROFILE(RACE_REPORT);

  bool found;  /* If set to TRUE, race conditions were found */

  fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" );
  fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   RACE CONDITION VIOLATIONS   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" );
  fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" );
  fprintf( ofile, "Module                    Filename                 Number of Violations found\n" );
  fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" );

  found = race_report_summary( ofile, db_list[curr_db]->funit_head );

  if( verbose && found ) {
    fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" );
    race_report_verbose( ofile, db_list[curr_db]->funit_head );
  }

  fprintf( ofile, "\n\n" );

  PROFILE_END;

}

static bool race_report_summary	(	FILE *	ofile,
		funit_link *	head
	)			[static]

Returns:

Returns TRUE if any race conditions were found in the functional unit list

Displays the summary report for race conditions for all functional units in design.

Parameters:

	ofile	Pointer to output file to use
	head	Pointer to head of functional unit list to report

References FALSE, func_unit_s::filename, funit_link_s::funit, funit_flatten_name(), FUNIT_MODULE, get_basename(), funit_link_s::next, obf_file, PROFILE, PROFILE_END, statistic_s::race_total, func_unit_s::stat, TRUE, and func_unit_s::type.

Referenced by race_report().

  { PROFILE(RACE_REPORT_SUMMARY);

  bool found = FALSE;  /* Return value for this function */

  while( head != NULL ) {

    if( (head->funit->type == FUNIT_MODULE) && (head->funit->stat != NULL) ) {

      found = (head->funit->stat->race_total > 0) ? TRUE : found;

      fprintf( ofile, "  %-20.20s    %-20.20s        %u\n", 
               funit_flatten_name( head->funit ),
               get_basename( obf_file( head->funit->filename ) ),
               head->funit->stat->race_total );

    }

    head = head->next;

  }

  PROFILE_END;

  return( found );

}

static void race_report_verbose	(	FILE *	ofile,
		funit_link *	head
	)			[static]

Outputs a verbose race condition report to the specified output file specifying the line number and race condition reason for all functional units in the design.

Parameters:

	ofile	Pointer to output file to use
	head	Pointer to head of functional unit list being reported

References func_unit_s::filename, funit_link_s::funit, FUNIT_AFUNCTION, FUNIT_ANAMED_BLOCK, FUNIT_ATASK, funit_flatten_name(), FUNIT_FUNCTION, FUNIT_MODULE, FUNIT_NAMED_BLOCK, FUNIT_TASK, funit_link_s::next, race_blk_s::next, obf_file, obf_funit, PROFILE, PROFILE_END, func_unit_s::race_head, race_msgs, statistic_s::race_total, race_blk_s::reason, race_blk_s::start_line, func_unit_s::stat, and func_unit_s::type.

Referenced by race_report().

  { PROFILE(RACE_REPORT_VERBOSE);

  race_blk* curr_race;  /* Pointer to current race condition block */

  while( head != NULL ) {

    if( (head->funit->stat != NULL) && (head->funit->stat->race_total > 0) ) {

      fprintf( ofile, "\n" );
      switch( head->funit->type ) {
        case FUNIT_MODULE       :  fprintf( ofile, "    Module: " );       break;
        case FUNIT_ANAMED_BLOCK :
        case FUNIT_NAMED_BLOCK  :  fprintf( ofile, "    Named Block: " );  break;
        case FUNIT_AFUNCTION    :
        case FUNIT_FUNCTION     :  fprintf( ofile, "    Function: " );     break;
        case FUNIT_ATASK        :
        case FUNIT_TASK         :  fprintf( ofile, "    Task: " );         break;
        default                 :  fprintf( ofile, "    UNKNOWN: " );      break;
      }
      fprintf( ofile, "%s, File: %s\n", obf_funit( funit_flatten_name( head->funit ) ), obf_file( head->funit->filename ) );
      fprintf( ofile, "    -------------------------------------------------------------------------------------------------------------\n" );

      fprintf( ofile, "      Starting Line #     Race Condition Violation Reason\n" );
      fprintf( ofile, "      ---------------------------------------------------------------------------------------------------------\n" );

      curr_race = head->funit->race_head;
      while( curr_race != NULL ) {
        fprintf( ofile, "              %7d:    %s\n", curr_race->start_line, race_msgs[curr_race->reason] );
        curr_race = curr_race->next;
      }

      fprintf( ofile, "\n" );

    }

    head = head->next;
                                                                                               
  }

  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.

bool debug_mode

If set to TRUE, causes debug information to be spewed to screen.

int flag_race_check

Specifies how race conditions should be handled

Referenced by race_check_race_count(), race_handle_race_condition(), and score_parse_args().

isuppl info_suppl

Informational line for the CDD file.

str_link* race_ignore_mod_head

Pointer to head of string list containing the names of modules that should be ignored for race condition checking.

str_link* race_ignore_mod_tail

Pointer to tail of string list containing the names of modules that should be ignored for race condition checking.

const char* race_msgs[RACE_TYPE_NUM]

Initial value:

 {
  "Sequential statement block contains blocking assignment(s)",
  "Combinational statement block contains non-blocking assignment(s)",
  "Mixed statement block contains blocking assignment(s)",
  "Statement block contains both blocking and non-blocking assignment(s)", 
  "Signal assigned in two different statement blocks",
  "Signal assigned both in statement block and via input/inout port",
  "System call $strobe used to output signal assigned via blocking assignment",
  "Procedural assignment with #0 delay performed"
}

This array is used to output the various race condition violation messages in both the parsing and report functions

Referenced by race_handle_race_condition(), and race_report_verbose().

int races_found = 0 [static]

Tracks the number of race conditions that were detected during the race-condition checking portion of the scoring command.

Referenced by race_check_race_count(), and race_handle_race_condition().

stmt_blk* sb = NULL [static]

Pointer to array of statement blocks for the specified design.

int sb_size [static]

Number of entries loaded in the sb array.

Referenced by race_check_assignment_types(), race_check_modules(), race_find_head_statement(), and race_find_head_statement_containing_statement().

int stmt_conn_id

Specifies current connection ID to use for connecting statements. This value should be passed to the statement_connect function and incremented immediately after.

Referenced by db_statement_connect(), race_calc_assignments(), race_check_modules(), race_find_head_statement_containing_statement(), and race_find_head_statement_containing_statement_helper().

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.