ovl.h File Reference

Contains functions for handling OVL assertion extraction. More...

#include "defines.h"

Go to the source code of this file.

Functions
bool	ovl_is_assertion_module (const func_unit *funit)
	Returns TRUE if specified functional unit is an OVL assertion module.
bool	ovl_is_coverage_point (const expression *exp)
	Returns TRUE if specified expression corresponds to a functional coverage point.
void	ovl_add_assertions_to_no_score_list (bool rm_tasks)
	Adds all assertion modules to no score list.
void	ovl_get_funit_stats (const func_unit *funit, unsigned int *hit, unsigned int *excludes, unsigned int *total)
	Gathers the OVL assertion coverage summary statistics for the given functional unit.
void	ovl_display_verbose (FILE *ofile, const func_unit *funit, rpt_type rtype)
	Displays the verbose hit/miss information to the given output file for the given functional unit.
void	ovl_collect (func_unit *funit, int cov, char ***inst_names, int **excludes, unsigned int *inst_size)
	Finds the instance names of all uncovered and covered assertions in the specified functional unit.
void	ovl_get_coverage (const func_unit *funit, const char *inst_name, char **assert_mod, str_link **cp_head, str_link **cp_tail)
	Gets missed coverage points for the given assertion.

---

Detailed Description

Contains functions for handling OVL assertion extraction.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

04/13/2006

---

Function Documentation

void ovl_add_assertions_to_no_score_list

(

bool

rm_tasks

)

Adds all assertion modules to no score list.

Exceptions:

anonymous

search_add_no_score_funit search_add_no_score_funit search_add_no_score_funit search_add_no_score_funit

Adds all OVL assertions to the no_score list.

Parameters:

rm_tasks

Removes extraneous tasks only that are not used for coverage

References OVL_ASSERT_NUM, ovl_assertions, PROFILE, PROFILE_END, and search_add_no_score_funit().

Referenced by score_parse_args().

  { PROFILE(OVL_ADD_ASSERTIONS_TO_NO_SCORE_LIST);

  int  i;          /* Loop iterator */
  char tmp[4096];  /* Temporary string holder */

  for( i=0; i<OVL_ASSERT_NUM; i++ ) {
    if( rm_tasks ) {
      unsigned int rv;
      rv = snprintf( tmp, 4096, "%s.ovl_error_t", ovl_assertions[i] );
      assert( rv < 4096 );
      (void)search_add_no_score_funit( tmp );
      rv = snprintf( tmp, 4096, "%s.ovl_finish_t", ovl_assertions[i] );
      assert( rv < 4096 );
      (void)search_add_no_score_funit( tmp );
      rv = snprintf( tmp, 4096, "%s.ovl_init_msg_t", ovl_assertions[i] );
      assert( rv < 4096 );
      (void)search_add_no_score_funit( tmp );
    } else {
      (void)search_add_no_score_funit( ovl_assertions[i] );
    }
  }

  PROFILE_END;

}

void ovl_collect	(	func_unit *	funit,
		int	cov,
		char ***	inst_names,
		int **	excludes,
		unsigned int *	inst_size
	)

Finds the instance names of all uncovered and covered assertions in the specified functional unit.

Populates the uncovered or covered string arrays with the instance names of child modules that match the respective coverage level.

Parameters:

	funit	Pointer to functional unit to gather uncovered/covered assertion instances from
	cov	Specifies if uncovered (0) or covered (1) assertions should be gathered
	inst_names	Pointer to array of uncovered instance names in the specified functional unit
	excludes	Pointer to array of integers indicating exclusion of associated uncovered instance name
	inst_size	Number of valid elements in the uncov_inst_names array

References funit_inst_s::child_head, curr_db, ESUPPL_EXCLUDED, expression_s::exec_num, statement_s::exp, FALSE, func_iter_dealloc(), func_iter_get_next_statement(), func_iter_init(), funit_inst_s::funit, FUNIT_MODULE, inst_head, inst_link_find_by_funit(), funit_inst_s::name, funit_inst_s::next, ovl_is_assertion_module(), ovl_is_coverage_point(), PROFILE, PROFILE_END, realloc_safe, strdup_safe, expression_s::suppl, TRUE, and func_unit_s::type.

Referenced by assertion_collect().

  { PROFILE(OVL_COLLECT);
  
  funit_inst*  funiti;             /* Pointer to found functional unit instance containing this functional unit */
  funit_inst*  curr_child;         /* Current child of this functional unit's instance */
  int          ignore        = 0;  /* Number of functional units to ignore */
  unsigned int total         = 0;  /* Total number of coverage points for a given assertion module */
  unsigned int hit           = 0;  /* Number of hit coverage points for a given assertion module */
  int          exclude_found = 0;  /* Set to a value of 1 if at least one excluded coverage point was found */

  /* Get one instance of this module from the design */
  funiti = inst_link_find_by_funit( funit, db_list[curr_db]->inst_head, &ignore );
  assert( funiti != NULL );

  /* Find all child instances of this module that are assertion modules */
  curr_child = funiti->child_head;
  while( curr_child != NULL ) {

    /* If this child instance module type is an assertion module, get its assertion information */
    if( (curr_child->funit->type == FUNIT_MODULE) && ovl_is_assertion_module( curr_child->funit ) ) {

      func_iter  fi;
      statement* stmt;

      /* Initialize the total and hit values */
      total = 0;
      hit   = 0;

      /* Initialize the functional unit iterator */
      func_iter_init( &fi, curr_child->funit, TRUE, FALSE );

      while( (stmt = func_iter_get_next_statement( &fi )) != NULL ) {

        /* If this statement is a task call to the task "ovl_cover_t", get its total and hit information */
        if( ovl_is_coverage_point( stmt->exp ) ) {
          total = total + 1;
          if( (stmt->exp->exec_num > 0) || (ESUPPL_EXCLUDED( stmt->exp->suppl ) == 1) ) {
            hit++;
            exclude_found |= ESUPPL_EXCLUDED( stmt->exp->suppl );
          }
        }

      }

      /* Deallocate functional unit iterator */
      func_iter_dealloc( &fi );

      /* If there are uncovered coverage points, add this instance to the uncov array */
      if( (cov == 0) && (hit < total) ) {
        *inst_names = (char**)realloc_safe( *inst_names, (sizeof( char** ) * (*inst_size)), (sizeof( char** ) * (*inst_size + 1)) );
        *excludes   = (int*)  realloc_safe( *excludes,   (sizeof( int )    * (*inst_size)), (sizeof( int )    * (*inst_size + 1)) );
        (*inst_names)[*inst_size] = strdup_safe( curr_child->name );
        (*excludes)[*inst_size]   = 0;
        (*inst_size)++;
      
      /* Otherwise, populate the cov array */
      } else {
        if( (cov == 0) && (exclude_found == 1) ) {
          *inst_names = (char**)realloc_safe( *inst_names, (sizeof( char** ) * (*inst_size)), (sizeof( char** ) * (*inst_size + 1)) );
          *excludes   = (int*)  realloc_safe( *excludes,   (sizeof( int )    * (*inst_size)), (sizeof( int )    * (*inst_size + 1)) );
          (*inst_names)[*inst_size] = strdup_safe( curr_child->name );
          (*excludes)[*inst_size]   = 1;
          (*inst_size)++;
        } else if( cov == 1 ) {
          *inst_names = (char**)realloc_safe( *inst_names, (sizeof( char** ) * (*inst_size)), (sizeof( char** ) * (*inst_size + 1)) );
          (*inst_names)[*inst_size] = strdup_safe( curr_child->name );
          (*inst_size)++;
        }
      }

    }

    /* Advance child pointer to next child instance */
    curr_child = curr_child->next;

  }

  PROFILE_END;

}

void ovl_display_verbose	(	FILE *	ofile,
		const func_unit *	funit,
		rpt_type	rtype
	)

Displays the verbose hit/miss information to the given output file for the given functional unit.

Parameters:

	ofile	Pointer to output file to display verbose information to
	funit	Pointer to module containing assertions that were not covered
	rtype	Specifies the type of report to generate

References funit_inst_s::child_head, curr_db, db_gen_exclusion_id(), db_get_exclusion_id_size(), exclude_find_exclude_reason(), esuppl_u::excluded, expression_s::exec_num, statement_s::exp, FALSE, flag_output_exclusion_ids, free_safe, func_iter_dealloc(), func_iter_get_next_statement(), func_iter_init(), funit_inst_s::funit, funit_flatten_name(), FUNIT_MODULE, gen_char_string(), expression_s::id, inst_head, inst_link_find_by_funit(), funit_inst_s::name, funit_inst_s::next, obf_funit, obf_inst, ovl_get_coverage_point(), ovl_is_assertion_module(), ovl_is_coverage_point(), esuppl_u::part, PROFILE, PROFILE_END, exclude_reason_s::reason, report_covered, report_output_exclusion_reason(), RPT_TYPE_EXCL, RPT_TYPE_HIT, expression_s::suppl, TRUE, and func_unit_s::type.

Referenced by assertion_display_verbose().

  { PROFILE(OVL_DISPLAY_VERBOSE);

  funit_inst*  funiti;        /* Pointer to functional unit instance found for this functional unit */
  int          ignore   = 0;  /* Specifies that we do not want to ignore any modules */
  funit_inst*  curr_child;    /* Pointer to current child instance of this module */
  char*        cov_point;     /* Pointer to name of current coverage point */
  func_iter    fi;            /* Functional unit iterator */
  statement*   stmt;          /* Pointer to current statement */
  unsigned int eid_size = 1;  /* Number of characters needed to store an exclusion ID */
  char         tmp[30];       /* Temporary string */

  fprintf( ofile, "      " );
  if( flag_output_exclusion_ids && (rtype != RPT_TYPE_HIT) ) {
    eid_size = db_get_exclusion_id_size();
    gen_char_string( tmp, ' ', (eid_size - 2) );
    fprintf( ofile, "EID%s  ", tmp );
  }
  fprintf( ofile, "Instance Name               Assertion Name          Coverage Point" );
  if( rtype == RPT_TYPE_HIT ) {
    fprintf( ofile, "                            # of hits" );
  }
  fprintf( ofile, "\n" );
  gen_char_string( tmp, '-', (eid_size - 1) );
  fprintf( ofile, "      %s---------------------------------------------------------------------------------------------------------\n", tmp );

  /* Get one instance of this module from the design */
  funiti = inst_link_find_by_funit( funit, db_list[curr_db]->inst_head, &ignore );
  assert( funiti != NULL );

  /* Find all child instances of this module that are assertion modules */
  curr_child = funiti->child_head;
  while( curr_child != NULL ) {

    /* If this child instance module type is an assertion module, check its assertion information */
    if( (curr_child->funit->type == FUNIT_MODULE) && ovl_is_assertion_module( curr_child->funit ) ) {

      /* Initialize the functional unit iterator */
      func_iter_init( &fi, curr_child->funit, TRUE, FALSE );

      while( (stmt = func_iter_get_next_statement( &fi )) != NULL ) {

        if( ((((stmt->exp->exec_num > 0) ? 1 : 0) == report_covered) && (stmt->exp->suppl.part.excluded == 0) && (rtype != RPT_TYPE_EXCL)) ||
            ((stmt->exp->suppl.part.excluded == 1) && (rtype == RPT_TYPE_EXCL)) ) {

          /* If this statement is a task call to the task "ovl_cover_t", get its total and hit information */
          if( ovl_is_coverage_point( stmt->exp ) ) {

            /* Get coverage point name */
            cov_point = ovl_get_coverage_point( stmt );

            /* Output the coverage verbose results to the specified output file */
            if( (stmt->exp->exec_num == 0) && (rtype != RPT_TYPE_HIT) ) {
              if( flag_output_exclusion_ids ) {
                exclude_reason* er;
                fprintf( ofile, "      (%s)  %-26s  %-22s  \"%-38s\"\n", db_gen_exclusion_id( 'A', stmt->exp->id ),
                         obf_inst( curr_child->name ), obf_funit( funit_flatten_name( curr_child->funit ) ), cov_point );
                if( (rtype == RPT_TYPE_EXCL) && ((er = exclude_find_exclude_reason( 'A', stmt->exp->id, curr_child->funit )) != NULL) ) {
                  report_output_exclusion_reason( ofile, (12 + (db_get_exclusion_id_size() - 1)), er->reason, TRUE );
                }
              } else {
                exclude_reason* er;
                fprintf( ofile, "      %-26s  %-22s  \"%-38s\"\n",
                         obf_inst( curr_child->name ), obf_funit( funit_flatten_name( curr_child->funit ) ), cov_point );
                if( (rtype == RPT_TYPE_EXCL) && ((er = exclude_find_exclude_reason( 'A', stmt->exp->id, curr_child->funit )) != NULL) ) {
                  report_output_exclusion_reason( ofile, (8 + (db_get_exclusion_id_size() - 1)), er->reason, TRUE );
                }
              }
            } else if( (stmt->exp->exec_num > 0) && (rtype == RPT_TYPE_HIT) ) {
              fprintf( ofile, "      %-26s  %-22s  \"%-38s\"  %9u\n",
                       obf_inst( curr_child->name ), obf_funit( funit_flatten_name( curr_child->funit ) ), cov_point, stmt->exp->exec_num );
            }

            /* Deallocate the coverage point */
            free_safe( cov_point, (strlen( cov_point ) + 1) );
          
          }

        }

      }

      /* Deallocate functional unit iterator */
      func_iter_dealloc( &fi );

    }

    /* Advance child pointer to next child instance */
    curr_child = curr_child->next;

  }

  PROFILE_END;

}

void ovl_get_coverage	(	const func_unit *	funit,
		const char *	inst_name,
		char **	assert_mod,
		str_link **	cp_head,
		str_link **	cp_tail
	)

Gets missed coverage points for the given assertion.

Retrieves the coverage point strings and execution counts from the specified assertion module.

Parameters:

	funit	Pointer to functional unit to get assertion information from
	inst_name	Name of assertion instance to get coverage points from
	assert_mod	Pointer to the assertion module name and filename of instance being retrieved
	cp_head	Pointer to head of coverage point list
	cp_tail	Pointer to tail of coverage point list

References funit_inst_s::child_head, curr_db, ESUPPL_EXCLUDED, exclude_find_exclude_reason(), expression_s::exec_num, statement_s::exp, FALSE, func_unit_s::filename, func_iter_dealloc(), func_iter_get_next_statement(), func_iter_init(), funit_inst_s::funit, expression_s::id, inst_head, inst_link_find_by_funit(), malloc_safe, func_unit_s::name, funit_inst_s::name, funit_inst_s::next, ovl_get_coverage_point(), ovl_is_coverage_point(), PROFILE, PROFILE_END, exclude_reason_s::reason, str_link_add(), strdup_safe, expression_s::suppl, str_link_s::suppl, and TRUE.

Referenced by assertion_get_coverage().

  { PROFILE(OVL_GET_COVERAGE);

  funit_inst*  funiti;      /* Pointer to found functional unit instance */
  funit_inst*  curr_child;  /* Pointer to current child functional instance */
  int          ignore = 0;  /* Number of functional units to ignore */
  func_iter    fi;          /* Functional unit iterator to iterate through statements */
  statement*   stmt;        /* Pointer to current statement */
  int          str_size;    /* Size of assert_mod string needed for memory allocation */
  unsigned int rv;          /* Return value */

  /* Get one instance of this module from the design */
  funiti = inst_link_find_by_funit( funit, db_list[curr_db]->inst_head, &ignore );
  assert( funiti != NULL );

  /* Find child instance */
  curr_child = funiti->child_head;
  while( (curr_child != NULL) && (strcmp( curr_child->name, inst_name ) != 0) ) {
    curr_child = curr_child->next;
  }
  assert( curr_child != NULL );
  
  /* Get the module name and store it in assert_mod */
  str_size    = strlen( curr_child->funit->name ) + 1 + strlen( curr_child->funit->filename ) + 1;
  *assert_mod = (char*)malloc_safe( str_size ); 
  rv = snprintf( *assert_mod, str_size, "%s %s", curr_child->funit->name, curr_child->funit->filename );
  assert( rv < str_size );

  /* Initialize the functional unit iterator */
  func_iter_init( &fi, curr_child->funit, TRUE, FALSE );

  /* Gather all missed coverage points */
  while( (stmt = func_iter_get_next_statement( &fi )) != NULL ) {

    /* If this statement is a task call to the task "ovl_cover_t", get its total and hit information */
    if( ovl_is_coverage_point( stmt->exp ) ) {

      exclude_reason* er;

      /* Store the coverage point string and execution count */
      (void)str_link_add( ovl_get_coverage_point( stmt ), cp_head, cp_tail );
      (*cp_tail)->suppl  = stmt->exp->exec_num;
      (*cp_tail)->suppl2 = stmt->exp->id;
      (*cp_tail)->suppl3 = ESUPPL_EXCLUDED( stmt->exp->suppl );

      /* If the toggle is currently excluded, check to see if there's a reason associated with it */
      if( (ESUPPL_EXCLUDED( stmt->exp->suppl ) == 1) && ((er = exclude_find_exclude_reason( 'A', stmt->exp->id, curr_child->funit )) != NULL) ) {
        (*cp_tail)->str2 = strdup_safe( er->reason );
      } else {
        (*cp_tail)->str2 = NULL;
      }

    }

  }

  /* Deallocate functional unit iterator */
  func_iter_dealloc( &fi );

  PROFILE_END;

  PROFILE_END;

}

void ovl_get_funit_stats	(	const func_unit *	funit,
		unsigned int *	hit,
		unsigned int *	excluded,
		unsigned int *	total
	)

Gathers the OVL assertion coverage summary statistics for the given functional unit.

Gathers the total and hit assertion coverage information for the specified functional unit and stores this information in the total and hit pointers.

Parameters:

	funit	Pointer to functional unit to gather OVL assertion coverage information for
	hit	Pointer to the number of assertions hit in the given module during simulation
	excluded	Pointer to the number of excluded assertions
	total	Pointer to the total number of assertions in the given module

References funit_inst_s::child_head, curr_db, ESUPPL_EXCLUDED, expression_s::exec_num, statement_s::exp, FALSE, func_iter_dealloc(), func_iter_get_next_statement(), func_iter_init(), funit_inst_s::funit, FUNIT_MODULE, inst_head, inst_link_find_by_funit(), funit_inst_s::next, ovl_is_assertion_module(), ovl_is_coverage_point(), PROFILE, PROFILE_END, expression_s::suppl, TRUE, and func_unit_s::type.

Referenced by assertion_get_funit_summary(), and assertion_get_stats().

  { PROFILE(OVL_GET_FUNIT_STATS);

  funit_inst* funiti;      /* Pointer to found functional unit instance containing this functional unit */
  funit_inst* curr_child;  /* Current child of this functional unit's instance */
  int         ignore = 0;  /* Number of functional units to ignore */
  func_iter   fi;          /* Functional unit iterator */
  statement*  stmt;        /* Pointer to current statement */

  /* If the current functional unit is not an OVL module, get the statistics */
  if( !ovl_is_assertion_module( funit ) ) {

    /* Get one instance of this module from the design */
    funiti = inst_link_find_by_funit( funit, db_list[curr_db]->inst_head, &ignore );
    assert( funiti != NULL );

    /* Find all child instances of this module that are assertion modules */
    curr_child = funiti->child_head;
    while( curr_child != NULL ) {

      /* If this child instance module type is an assertion module, get its assertion information */
      if( (curr_child->funit->type == FUNIT_MODULE) && ovl_is_assertion_module( curr_child->funit ) ) {

        /* Initialize the functional unit iterator */
        func_iter_init( &fi, curr_child->funit, TRUE, FALSE );

        while( (stmt = func_iter_get_next_statement( &fi )) != NULL ) {

          /* If this statement is a task call to the task "ovl_cover_t", get its total and hit information */
          if( ovl_is_coverage_point( stmt->exp ) ) {
            *total = *total + 1;
            if( (stmt->exp->exec_num > 0) || (ESUPPL_EXCLUDED( stmt->exp->suppl ) == 1) ) {
              (*hit)++;
              if( ESUPPL_EXCLUDED( stmt->exp->suppl ) == 1 ) {
                (*excluded)++;
              }
            }
          }

        }

        /* Deallocate functional unit iterator */
        func_iter_dealloc( &fi );

      }

      /* Advance child pointer to next child instance */
      curr_child = curr_child->next;

    }

  }

  PROFILE_END;

}

bool ovl_is_assertion_module

(

const func_unit *

funit

)

Returns TRUE if specified functional unit is an OVL assertion module.

Returns:

Returns TRUE if the specified module name is a supported OVL assertion; otherwise, returns FALSE.

Parameters:

funit

Pointer to the functional unit to check

References FALSE, funit_link_s::funit, FUNIT_TASK, func_unit_s::name, funit_link_s::next, ovl_is_assertion_name(), PROFILE, PROFILE_END, func_unit_s::tf_head, and func_unit_s::type.

Referenced by assertion_funit_summary(), assertion_instance_summary(), bind_signal(), combination_funit_summary(), combination_instance_summary(), exclude_expr_assign_and_recalc(), fsm_funit_summary(), fsm_instance_summary(), line_funit_summary(), line_instance_summary(), memory_ae_funit_summary(), memory_ae_instance_summary(), memory_toggle_funit_summary(), memory_toggle_instance_summary(), ovl_collect(), ovl_display_verbose(), ovl_get_funit_stats(), race_check_modules(), report_gather_funit_stats(), report_gather_instance_stats(), toggle_funit_summary(), and toggle_instance_summary().

  { PROFILE(OVL_IS_ASSERTION_MODULE);

  bool        retval = FALSE;  /* Return value for this function */
  funit_link* funitl;          /* Pointer to current functional unit link */

  if( (funit != NULL) && ovl_is_assertion_name( funit->name ) ) {

    /*
     If the module matches in name, check to see if the ovl_cover_t task exists (this
     will tell us if coverage was enabled for this module.
    */
    funitl = funit->tf_head;
    while( (funitl != NULL) && ((strcmp( funitl->funit->name, "ovl_cover_t" ) != 0) || (funitl->funit->type != FUNIT_TASK)) ) {
      funitl = funitl->next;
    }
    retval = (funitl == NULL);

  }

  PROFILE_END;

  return( retval );

}

bool ovl_is_coverage_point

(

const expression *

exp

)

Returns TRUE if specified expression corresponds to a functional coverage point.

Returns:

Returns TRUE if the specifies expression corresponds to a coverage point; otherwise, returns FALSE.

Parameters:

exp

Pointer to expression to check

References EXP_OP_TASK_CALL, expression_s::name, expression_s::op, PROFILE, and PROFILE_END.

Referenced by exclude_expr_assign_and_recalc(), ovl_collect(), ovl_display_verbose(), ovl_get_coverage(), and ovl_get_funit_stats().

  { PROFILE(OVL_IS_COVERAGE_POINT);

  bool retval = (exp->op == EXP_OP_TASK_CALL) && (strcmp( exp->name, "ovl_cover_t" ) == 0);

  PROFILE_END;

  return( retval );

}