/Users/trevorw/projects/release/covered-0.7.4/src/assertion.c File Reference

---

Detailed Description

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

4/4/2006

#include <stdio.h>
#include <assert.h>
#include "assertion.h"
#include "db.h"
#include "defines.h"
#include "func_unit.h"
#include "link.h"
#include "obfuscate.h"
#include "ovl.h"
#include "profiler.h"
#include "util.h"

Functions
void	assertion_parse (const char *arg)
	Parses -A command-line option to score command.
void	assertion_parse_attr (attr_param *ap, const func_unit *funit, bool exclude)
	Parses an in-line attribute for assertion coverage information.
void	assertion_get_stats (const func_unit *funit, unsigned int *hit, unsigned int *excluded, unsigned int *total)
	Gather statistics for assertion coverage.
bool	assertion_display_instance_summary (FILE *ofile, const char *name, int hits, int total)
bool	assertion_instance_summary (FILE *ofile, const funit_inst *root, const char *parent_inst, int *hits, int *total)
bool	assertion_display_funit_summary (FILE *ofile, const char *name, const char *fname, int hits, int total)
bool	assertion_funit_summary (FILE *ofile, const funit_link *head, int *hits, int *total)
void	assertion_display_verbose (FILE *ofile, const func_unit *funit, rpt_type rtype)
void	assertion_instance_verbose (FILE *ofile, funit_inst *root, char *parent_inst)
void	assertion_funit_verbose (FILE *ofile, const funit_link *head)
void	assertion_report (FILE *ofile, bool verbose)
	Generates report output for assertion coverage.
void	assertion_get_funit_summary (func_unit *funit, unsigned int *hit, unsigned int *excluded, unsigned int *total)
	Retrieves the total and hit counts of assertions for the specified functional unit.
void	assertion_collect (func_unit *funit, int cov, char ***inst_names, int **excludes, unsigned int *inst_size)
	Collects uncovered and covered assertion instance names for the given module.
void	assertion_get_coverage (const func_unit *funit, const char *inst_name, char **assert_mod, str_link **cp_head, str_link **cp_tail)
	Gets missed coverage point descriptions for the given assertion module.
Variables
db **	db_list
unsigned int	curr_db
bool	report_covered
bool	report_instance
isuppl	info_suppl
bool	report_exclusions

---

Function Documentation

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

Collects uncovered and covered assertion instance names for the given module. Searches the specified functional unit, collecting all uncovered or covered assertion module instance names. Parameters: funit  Pointer to functional unit cov  Specifies if uncovered (0) or covered (1) assertions should be looked for inst_names  Pointer to array of uncovered instance names found within the specified functional unit excludes  Pointer to array of integers that contain the exclude information for the given instance names inst_size  Number of valid elements in the uncov_inst_names array { PROFILE(ASSERTION_COLLECT); /* Initialize outputs */ *inst_names = NULL; *excludes = NULL; *inst_size = 0; /* If OVL assertion coverage is needed, get this information */ if( info_suppl.part.assert_ovl == 1 ) { ovl_collect( funit, cov, inst_names, excludes, inst_size ); } PROFILE_END; }

bool assertion_display_funit_summary (  FILE *  ofile, const char *  name, const char *  fname, int  hits, int  total )  [static]

Returns: Returns TRUE if at least one assertion was found to be not hit; otherwise, returns FALSE. Displays the assertion summary information for a given instance to the specified output stream. Parameters: ofile  Pointer to file handle to output instance summary results to name  Name of functional unit being reported fname  Name of file containing the given functional unit hits  Total number of assertions hit in the given functional unit total  Total number of assertions in the given functional unit { PROFILE(ASSERTION_DISPLAY_FUNIT_SUMMARY); float percent; /* Percentage of assertions hit */ int miss; /* Number of assertions missed */ calc_miss_percent( hits, total, &miss, &percent ); fprintf( ofile, " %-20.20s %-20.20s %5d/%5d/%5d %3.0f%%\n", name, fname, hits, miss, total, percent ); PROFILE_END; return( miss > 0 ); }

bool assertion_display_instance_summary (  FILE *  ofile, const char *  name, int  hits, int  total )  [static]

Returns: Returns TRUE if at least one assertion was found to be not hit; otherwise, returns FALSE. Displays the assertion summary information for a given instance to the specified output stream. Parameters: ofile  Pointer to file handle to output instance summary results to name  Name of instance being reported hits  Total number of assertions hit in the given instance total  Total number of assertions in the given instance { PROFILE(ASSERTION_DISPLAY_INSTANCE_SUMMARY); float percent; /* Percentage of assertions hit */ int miss; /* Number of assertions missed */ calc_miss_percent( hits, total, &miss, &percent ); fprintf( ofile, " %-43.43s %5d/%5d/%5d %3.0f%%\n", name, hits, miss, total, percent ); PROFILE_END; return( miss > 0 ); }

void assertion_display_verbose (  FILE *  ofile, const func_unit *  funit, rpt_type  rtype )  [static]

Displays the verbose hit/miss assertion information for the given functional unit. Parameters: ofile  Pointer to the file to output the verbose information to funit  Pointer to the functional unit to display rtype  Type of report output to generate { PROFILE(ASSERTION_DISPLAY_VERBOSE); switch( rtype ) { case RPT_TYPE_HIT : fprintf( ofile, " Hit Assertions\n\n" ); break; case RPT_TYPE_MISS : fprintf( ofile, " Missed Assertions\n\n" ); break; case RPT_TYPE_EXCL : fprintf( ofile, " Excluded Assertions\n\n" ); break; } /* If OVL assertion coverage is needed, output it in the OVL style */ if( info_suppl.part.assert_ovl == 1 ) { ovl_display_verbose( ofile, funit, rtype ); } fprintf( ofile, "\n" ); PROFILE_END; }

bool assertion_funit_summary (  FILE *  ofile, const funit_link *  head, int *  hits, int *  total )  [static]

Returns: Returns TRUE if at least one assertion was found to not be covered in this functional unit; otherwise, returns FALSE. Outputs the functional unit summary assertion coverage information for the given functional unit to the given output file. Parameters: ofile  Pointer to output file to display summary information to head  Pointer to the current functional unit link to evaluate hits  Pointer to the number of assertions hit in all functional units total  Pointer to the total number of assertions found in all functional units { PROFILE(ASSERTION_FUNIT_SUMMARY); bool miss_found = FALSE; /* Set to TRUE if assertion was found to be missed */ while( head != NULL ) { /* If this is an assertion module, don't output any further */ if( head->funit->stat->show && !funit_is_unnamed( head->funit ) && ((info_suppl.part.assert_ovl == 0) || !ovl_is_assertion_module( head->funit )) ) { /* Get printable version of functional unit name */ /*@only@*/ char* pname = scope_gen_printable( funit_flatten_name( head->funit ) ); miss_found |= assertion_display_funit_summary( ofile, pname, get_basename( obf_file( head->funit->filename ) ), head->funit->stat->assert_hit, head->funit->stat->assert_total ); /* Update accumulated information */ *hits += head->funit->stat->assert_hit; *total += head->funit->stat->assert_total; free_safe( pname, (strlen( pname ) + 1) ); } head = head->next; } PROFILE_END; return( miss_found ); }

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

Outputs the functional unit verbose assertion coverage information for the given functional unit to the given output file. Parameters: ofile  Pointer to the file to output the functional unit verbose information to head  Pointer to the current functional unit link to look at { PROFILE(ASSERTION_FUNIT_VERBOSE); char* pname; /* Printable version of functional unit name */ while( head != NULL ) { if( !funit_is_unnamed( head->funit ) && (((head->funit->stat->assert_hit < head->funit->stat->assert_total) && !report_covered) || ((head->funit->stat->assert_hit > 0) && report_covered) || ((head->funit->stat->assert_excluded > 0) && report_exclusions)) ) { /* Get printable version of functional unit name */ pname = scope_gen_printable( funit_flatten_name( head->funit ) ); 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", pname, obf_file( head->funit->filename ) ); fprintf( ofile, " -------------------------------------------------------------------------------------------------------------\n" ); free_safe( pname, (strlen( pname ) + 1) ); if( ((head->funit->stat->assert_hit < head->funit->stat->assert_total) && !report_covered) || ((head->funit->stat->assert_hit > 0) && report_covered && (!report_exclusions || (head->funit->stat->assert_hit > head->funit->stat->assert_excluded))) ) { assertion_display_verbose( ofile, head->funit, (report_covered ? RPT_TYPE_HIT : RPT_TYPE_MISS) ); } if( report_exclusions && (head->funit->stat->assert_excluded > 0) ) { assertion_display_verbose( ofile, head->funit, RPT_TYPE_EXCL ); } } head = head->next; } PROFILE_END; }

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

Gets missed coverage point descriptions for the given assertion module. Finds all of the coverage points for the given assertion instance and stores their string descriptions and execution counts in the cp list. Parameters: funit  Pointer to functional unit inst_name  Name of assertion module instance to retrieve assert_mod  Pointer to assertion module name and filename being retrieved cp_head  Pointer to head of list of strings/integers containing coverage point information cp_tail  Pointer to tail of list of strings/integers containing coverage point information { PROFILE(ASSERTION_GET_COVERAGE); /* Find functional unit */ *cp_head = *cp_tail = NULL; /* If OVL assertion coverage is needed, get this information */ if( info_suppl.part.assert_ovl == 1 ) { ovl_get_coverage( funit, inst_name, assert_mod, cp_head, cp_tail ); } PROFILE_END; }

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

Retrieves the total and hit counts of assertions for the specified functional unit. Counts the total number and number of hit assertions for the specified functional unit. Parameters: funit  Pointer to functional unit hit  Pointer to the number of hit assertions in the specified functional unit excluded  Pointer to the number of excluded assertions total  Pointer to the total number of assertions in the specified functional unit { PROFILE(ASSERTION_GET_FUNIT_SUMMARY); /* Initialize total and hit counts */ *hit = 0; *excluded = 0; *total = 0; if( info_suppl.part.assert_ovl == 1 ) { ovl_get_funit_stats( funit, hit, excluded, total ); } PROFILE_END; }

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

Gather statistics for assertion coverage. Gets total and hit assertion coverage statistics for the given functional unit. Parameters: funit  Pointer to current functional unit hit  Pointer to the total number of hit assertions in this functional unit excluded  Pointer to the number of excluded assertions total  Pointer to the total number of assertions found in this functional unit { PROFILE(ASSERTION_GET_STATS); assert( funit != NULL ); /* Initialize total and hit values */ *hit = 0; *excluded = 0; *total = 0; /* If OVL assertion coverage is needed, check this functional unit */ if( info_suppl.part.assert_ovl == 1 ) { ovl_get_funit_stats( funit, hit, excluded, total ); } PROFILE_END; }

bool assertion_instance_summary (  FILE *  ofile, const funit_inst *  root, const char *  parent_inst, int *  hits, int *  total )  [static]

Returns: Returns TRUE if at least one assertion was found to not be covered in this function unit instance; otherwise, returns FALSE. Outputs the instance summary assertion coverage information for the given functional unit instance to the given output file. Parameters: ofile  Pointer to the file to output the instance summary information to root  Pointer to the current functional unit instance to look at parent_inst  Scope of parent instance of this instance hits  Pointer to number of assertions hit in given instance tree total  Pointer to total number of assertions found in given instance tree { PROFILE(ASSERTION_INSTANCE_SUMMARY); funit_inst* curr; /* Pointer to current child functional unit instance of this node */ char tmpname[4096]; /* Temporary holder of instance name */ char* pname; /* Printable version of instance name */ bool miss_found = FALSE; /* Set to TRUE if assertion was missed */ assert( root != NULL ); assert( root->stat != NULL ); /* Get printable version of the instance name */ pname = scope_gen_printable( root->name ); /* Calculate instance name */ if( db_is_unnamed_scope( pname ) || root->suppl.name_diff ) { strcpy( tmpname, parent_inst ); } else if( strcmp( parent_inst, "*" ) == 0 ) { strcpy( tmpname, pname ); } else { /*@-retvalint@*/snprintf( tmpname, 4096, "%s.%s", parent_inst, pname ); } free_safe( pname, (strlen( pname ) + 1) ); if( (root->funit != NULL) && root->stat->show && !funit_is_unnamed( root->funit ) && ((info_suppl.part.assert_ovl == 0) || !ovl_is_assertion_module( root->funit )) ) { miss_found |= assertion_display_instance_summary( ofile, tmpname, root->stat->assert_hit, root->stat->assert_total ); /* Update accumulated information */ *hits += root->stat->assert_hit; *total += root->stat->assert_total; } /* If this is an assertion module, don't output any further */ if( (info_suppl.part.assert_ovl == 0) || !ovl_is_assertion_module( root->funit ) ) { curr = root->child_head; while( curr != NULL ) { miss_found |= assertion_instance_summary( ofile, curr, tmpname, hits, total ); curr = curr->next; } } PROFILE_END; return( miss_found ); }

void assertion_instance_verbose (  FILE *  ofile, funit_inst *  root, char *  parent_inst )  [static]

Outputs the instance verbose assertion coverage information for the given functional unit instance to the given output file. Parameters: ofile  Pointer to the file to output the instance verbose information to root  Pointer to the current functional unit instance to look at parent_inst  Scope of parent of this functional unit instance { PROFILE(ASSERTION_INSTANCE_VERBOSE); funit_inst* curr_inst; /* Pointer to current instance being evaluated */ char tmpname[4096]; /* Temporary name holder for instance */ char* pname; /* Printable version of functional unit name */ assert( root != NULL ); /* Get printable version of instance name */ pname = scope_gen_printable( root->name ); if( db_is_unnamed_scope( pname ) || root->suppl.name_diff ) { strcpy( tmpname, parent_inst ); } else if( strcmp( parent_inst, "*" ) == 0 ) { strcpy( tmpname, pname ); } else { snprintf( tmpname, 4096, "%s.%s", parent_inst, pname ); } free_safe( pname, (strlen( pname ) + 1) ); if( !funit_is_unnamed( root->funit ) && (((root->stat->assert_hit < root->stat->assert_total) && !report_covered) || ((root->stat->assert_hit > 0) && report_covered) || ((root->stat->assert_excluded > 0) && report_exclusions)) ) { /* Get printable version of functional unit name */ pname = scope_gen_printable( funit_flatten_name( root->funit ) ); fprintf( ofile, "\n" ); switch( root->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, Instance: %s\n", pname, obf_file( root->funit->filename ), tmpname ); fprintf( ofile, " -------------------------------------------------------------------------------------------------------------\n" ); free_safe( pname, (strlen( pname ) + 1) ); if( ((root->stat->assert_hit < root->stat->assert_total) && !report_covered) || ((root->stat->assert_hit > 0) && report_covered && (!report_exclusions || (root->stat->assert_hit > root->stat->assert_excluded))) ) { assertion_display_verbose( ofile, root->funit, (report_covered ? RPT_TYPE_HIT : RPT_TYPE_MISS) ); } if( report_exclusions && (root->stat->assert_excluded > 0) ) { assertion_display_verbose( ofile, root->funit, RPT_TYPE_EXCL ); } } curr_inst = root->child_head; while( curr_inst != NULL ) { assertion_instance_verbose( ofile, curr_inst, tmpname ); curr_inst = curr_inst->next; } PROFILE_END; }

void assertion_parse (  const char *  arg  )

Parses -A command-line option to score command. Parameters: arg  Command-line argument specified in -A option to score command to parse Parses the specified command-line argument as an assertion to consider for coverage. { PROFILE(ASSERTION_PARSE); PROFILE_END; }

void assertion_parse_attr (  attr_param *  ap, const func_unit *  funit, bool  exclude )

Parses an in-line attribute for assertion coverage information. Parses the specified assertion attribute for assertion coverage details. Parameters: ap  Pointer to attribute to parse funit  Pointer to current functional unit containing this attribute exclude  If TRUE, excludes this assertion from coverage consideration { PROFILE(ASSERTION_PARSE_ATTR); PROFILE_END; }

void assertion_report (  FILE *  ofile, bool  verbose )

Generates report output for assertion coverage. Outputs assertion coverage report information to the given file handle. Parameters: ofile  File to output report contents to verbose  Specifies if verbose report output needs to be generated { PROFILE(ASSERTION_REPORT); bool missed_found = FALSE; /* If set to TRUE, lines were found to be missed */ inst_link* instl; /* Pointer to current instance link */ int acc_hits = 0; /* Total number of assertions hit */ int acc_total = 0; /* Total number of assertions in design */ fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" ); fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ASSERTION COVERAGE RESULTS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" ); fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" ); if( report_instance ) { fprintf( ofile, "Instance Hit/ Miss/Total Percent hit\n" ); fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); instl = db_list[curr_db]->inst_head; while( instl != NULL ) { missed_found |= assertion_instance_summary( ofile, instl->inst, (instl->inst->suppl.name_diff ? "<NA>" : "*"), &acc_hits, &acc_total ); instl = instl->next; } fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); (void)assertion_display_instance_summary( ofile, "Accumulated", acc_hits, acc_total ); if( verbose && (missed_found || report_covered) ) { fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); instl = db_list[curr_db]->inst_head; while( instl != NULL ) { assertion_instance_verbose( ofile, instl->inst, (instl->inst->suppl.name_diff ? "<NA>" : "*") ); instl = instl->next; } } } else { fprintf( ofile, "Module/Task/Function Filename Hit/ Miss/Total Percent hit\n" ); fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); missed_found = assertion_funit_summary( ofile, db_list[curr_db]->funit_head, &acc_hits, &acc_total ); fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); (void)assertion_display_funit_summary( ofile, "Accumulated", "", acc_hits, acc_total ); if( verbose && (missed_found || report_covered) ) { fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); assertion_funit_verbose( ofile, db_list[curr_db]->funit_head ); } } fprintf( ofile, "\n\n" ); PROFILE_END; }

---

Variable Documentation

unsigned int curr_db

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

db** db_list

Array of database pointers storing all currently loaded databases.

isuppl info_suppl

Informational line for the CDD file.

bool report_covered

If set to a boolean value of TRUE, displays covered logic for a particular CDD file. By default, Covered will display uncovered logic. Must be used in conjunction with the -d v|d (verbose output) option.

bool report_exclusions

If set to a boolean value of TRUE, displays excluded coverage points for a particular CDD file. By default, Covered will not display excluded coverage points. This can be useful when used in conjunction with the -x option for including excluded coverage points. Must be used in conjunction with the -d v|d (verbose output) option.

bool report_instance

If set to a boolean value of TRUE, provides a coverage information for individual functional unit instances. If set to a value of FALSE, reports coverage information on a functional unit basis, merging results from all instances of same functional unit.

---