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

---

Detailed Description

Contains functions for determining/reporting combinational logic coverage.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

3/31/2002

#include <stdio.h>
#include "defines.h"

Go to the source code of this file.

Functions
void	combination_reset_counted_expr_tree (expression *exp)
	Resets combination counted bits in expression tree.
void	combination_get_tree_stats (expression *exp, int *ulid, unsigned int curr_depth, bool excluded, unsigned int *hit, unsigned int *excludes, unsigned int *total)
	Calculates combination logic statistics for a single expression tree.
void	combination_get_stats (func_unit *funit, unsigned int *hit, unsigned int *excluded, unsigned int *total)
	Calculates combination logic statistics for summary output.
void	combination_collect (func_unit *funit, int cov, expression ***exprs, unsigned int *exp_cnt, int **excludes)
	Collects all toggle expressions that match the specified coverage indication.
void	combination_get_funit_summary (func_unit *funit, unsigned int *hit, unsigned int *excluded, unsigned int *total)
	Gets combinational logic summary statistics for specified functional unit.
void	combination_get_inst_summary (funit_inst *inst, unsigned int *hit, unsigned int *excluded, unsigned int *total)
	Gets combinational logic summary statistics for specified functional unit instance.
void	combination_get_expression (int expr_id, char ***code, int **uline_groups, unsigned int *code_size, char ***ulines, unsigned int *uline_size, int **excludes, char ***reasons, unsigned int *exclude_size)
	Gets output for specified expression including underlines and code.
void	combination_get_coverage (int exp_id, int uline_id, char ***info, int *info_size)
	Gets output for specified expression including coverage information.
void	combination_report (FILE *ofile, bool verbose)
	Generates report output for combinational logic coverage.

---

Function Documentation

void combination_collect (  func_unit *  funit, int  cov, expression ***  exprs, unsigned int *  exp_cnt, int **  excludes )

Collects all toggle expressions that match the specified coverage indication. Gathers the covered or uncovered combinational logic information, storing their expressions in the exprs expression arrays. Used by the GUI for verbose combinational logic output. Parameters: funit  Pointer to functional unit cov  Specifies the coverage type to find exprs  Pointer to an array of expression pointers that contain all fully covered/uncovered expressions exp_cnt  Pointer to a value that will be set to indicate the number of expressions in covs array excludes  Pointer to an array of integers indicating exclusion property of each uncovered expression { PROFILE(COMBINATION_COLLECT); func_iter fi; /* Functional unit iterator */ statement* stmt; /* Pointer to current statement */ /* Reset combination counted bits */ combination_reset_counted_exprs( funit ); /* Create an array that will hold the number of uncovered combinations */ *exp_cnt = 0; *exprs = NULL; *excludes = NULL; func_iter_init( &fi, funit, TRUE, FALSE ); stmt = func_iter_get_next_statement( &fi ); while( stmt != NULL ) { int any_missed = 0; int any_measurable = 0; int any_excluded = 0; int all_excluded = 0; combination_output_expr( stmt->exp, 0, &any_missed, &any_measurable, &any_excluded, &all_excluded ); /* Check for uncovered statements */ if( ((cov == 0) && (any_missed == 1)) || ((cov == 1) && (any_missed == 0) && (any_measurable == 1)) ) { if( stmt->exp->line != 0 ) { *exprs = (expression**)realloc_safe( *exprs, (sizeof( expression* ) * (*exp_cnt)), (sizeof( expression* ) * (*exp_cnt + 1)) ); *excludes = (int*)realloc_safe( *excludes, (sizeof( int* ) * (*exp_cnt)), (sizeof( int* ) * (*exp_cnt + 1)) ); (*exprs)[(*exp_cnt)] = stmt->exp; (*excludes)[(*exp_cnt)] = all_excluded ? 1 : 0; (*exp_cnt)++; } stmt->exp->suppl.part.comb_cntd = 0; } stmt = func_iter_get_next_statement( &fi ); } func_iter_dealloc( &fi ); PROFILE_END; }

void combination_get_coverage (  int  exp_id, int  uline_id, char ***  info, int *  info_size )

Gets output for specified expression including coverage information. Returns: Returns TRUE if we were successful in obtaining coverage detail for the specified information; otherwise, returns FALSE to indicate an error. Calculates the coverage detail for the specified subexpression and stores this in string format in the info and info_size arguments. The coverage detail created matches the coverage detail output format that is used in the ASCII reports. Parameters: exp_id  Expression ID of statement containing subexpression to get coverage detail for uline_id  Underline ID of subexpression to get coverage detail for info  Pointer to string array that will be populated with the coverage detail info_size  Number of entries in info array { PROFILE(COMBINATION_GET_COVERAGE); func_unit* funit; /* Pointer to found functional unit */ exp_link* expl; /* Pointer to current expression link */ expression* exp; /* Pointer to found expression */ /* Find the functional unit that contains this expression */ funit = funit_find_by_id( exp_id ); assert( funit != NULL ); /* Find statement containing this expression */ expl = exp_link_find( exp_id, funit->exp_head ); assert( expl != NULL ); /* Now find the subexpression that matches the given underline ID */ exp = expression_find_uline_id( expl->exp, uline_id ); assert( exp != NULL ); combination_get_missed_expr( info, info_size, exp, 0, TRUE ); PROFILE_END; }

void combination_get_expression (  int  expr_id, char ***  code, int **  uline_groups, unsigned int *  code_size, char ***  ulines, unsigned int *  uline_size, int **  excludes, char ***  reasons, unsigned int *  exclude_size )

Gets output for specified expression including underlines and code. Exceptions: anonymous  Throw combination_underline_tree Gets the combinational logic coverage information for the specified expression ID, storing the output in the code and ulines arrays. Used by the GUI for displaying an expression's coverage information. Parameters: expr_id  Expression ID to retrieve information for code  Pointer to an array of strings containing generated code for this expression uline_groups  Pointer to an array of integers used for underlined missed subexpressions in this expression code_size  Pointer to value that will be set to indicate the number of elements in the code array ulines  Pointer to an array of strings that contain underlines of missed subexpressions uline_size  Pointer to value that will be set to indicate the number of elements in the ulines array excludes  Pointer to an array of values that determine if the associated subexpression is currently excluded or not from coverage reasons  Pointer to an array of strings that specify the reason for exclusion exclude_size  Pointer to value that will be set to indicate the number of elements in excludes { PROFILE(COMBINATION_GET_EXPRESSION); exp_link* expl; /* Pointer to found signal link */ unsigned int tmp; /* Temporary integer (unused) */ unsigned int i, j; /* Loop iterators */ char** tmp_ulines; unsigned int tmp_uline_size; int start = 0; unsigned int uline_max = 20; func_unit* funit; /* Find functional unit that contains this expression */ funit = funit_find_by_id( expr_id ); assert( funit != NULL ); /* Find the expression itself */ expl = exp_link_find( expr_id, funit->exp_head ); assert( expl != NULL ); /* Generate line of code that missed combinational coverage */ codegen_gen_expr( expl->exp, expl->exp->op, code, code_size, funit ); *uline_groups = (int*)malloc_safe( sizeof( int ) * (*code_size) ); /* Generate exclude information */ *excludes = NULL; *reasons = NULL; *exclude_size = 0; combination_get_exclude_list( expl->exp, funit_get_curr_module( funit ), excludes, reasons, exclude_size ); Try { /* Output underlining feature for missed expressions */ combination_underline_tree( expl->exp, 0, &tmp_ulines, &tmp_uline_size, &tmp, expl->exp->op, (*code_size == 1), funit ); } Catch_anonymous { unsigned int i; free_safe( *uline_groups, (sizeof( int ) * (*code_size)) ); *uline_groups = NULL; for( i=0; i<*code_size; i++ ) { free_safe( (*code)[i], (strlen( (*code)[i] ) + 1) ); } free_safe( *code, (sizeof( char* ) * *code_size) ); *code = NULL; *code_size = 0; free_safe( *excludes, (sizeof( int* ) * *exclude_size) ); *excludes = NULL; *exclude_size = 0; Throw 0; } *ulines = (char**)malloc_safe( sizeof( char* ) * uline_max ); *uline_size = 0; for( i=0; i<*code_size; i++ ) { assert( (*code)[i] != NULL ); (*uline_groups)[i] = 0; if( *code_size == 1 ) { *ulines = tmp_ulines; *uline_size = tmp_uline_size; (*uline_groups)[0] = tmp_uline_size; tmp_uline_size = 0; } else { for( j=0; j<tmp_uline_size; j++ ) { if( ((*ulines)[*uline_size] = combination_prep_line( tmp_ulines[j], start, strlen( (*code)[i] ) )) != NULL ) { ((*uline_groups)[i])++; (*uline_size)++; if( *uline_size == uline_max ) { uline_max += 20; *ulines = (char**)realloc_safe( *ulines, (sizeof( char* ) * (uline_max - 20)), (sizeof( char* ) * uline_max) ); } } } } start += strlen( (*code)[i] ); } for( i=0; i<tmp_uline_size; i++ ) { free_safe( tmp_ulines[i], (strlen( tmp_ulines[i] ) + 1) ); } if( tmp_uline_size > 0 ) { free_safe( tmp_ulines, (sizeof( char* ) * tmp_uline_size) ); } PROFILE_END; }

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

Gets combinational logic summary statistics for specified functional unit. Retrieves the combinational logic summary information for the specified functional unit Parameters: funit  Pointer to functional unit hit  Pointer to location to store the number of hit combinations for the specified functional unit excluded  Pointer to number of excluded logical combinations total  Pointer to location to store the total number of combinations for the specified functional unit { PROFILE(COMBINATION_GET_FUNIT_SUMMARY); *hit = funit->stat->comb_hit; *excluded = funit->stat->comb_excluded; *total = funit->stat->comb_total; PROFILE_END; }

void combination_get_inst_summary (  funit_inst *  inst, unsigned int *  hit, unsigned int *  excluded, unsigned int *  total )

Gets combinational logic summary statistics for specified functional unit instance. Retrieves the combinational logic summary information for the specified functional unit instance Parameters: inst  Pointer to functional unit instance hit  Pointer to location to store the number of hit combinations for the specified functional unit instance excluded  Pointer to number of excluded logical combinations total  Pointer to location to store the total number of combinations for the specified functional unit instance { PROFILE(COMBINATION_GET_INST_SUMMARY); *hit = inst->stat->comb_hit; *excluded = inst->stat->comb_excluded; *total = inst->stat->comb_total; PROFILE_END; }

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

Calculates combination logic statistics for summary output. Iterates through specified expression list and finds all root expressions. For each root expression, the combination_get_tree_stats function is called to generate the coverage numbers for the specified expression tree. Called by report function. Parameters: funit  Pointer to functional unit to search hit  Pointer to number of logical combinations hit during simulation excluded  Pointer to number of excluded logical combinations total  Pointer to total number of logical combinations { PROFILE(COMBINATION_GET_STATS); func_iter fi; /* Functional unit iterator */ statement* stmt; /* Pointer to current statement being examined */ int ulid; /* Current underline ID for this expression */ /* If the given functional unit is not an unnamed scope, traverse it now */ if( !funit_is_unnamed( funit ) ) { /* Initialize functional unit iterator */ func_iter_init( &fi, funit, TRUE, FALSE ); /* Traverse statements in the given functional unit */ while( (stmt = func_iter_get_next_statement( &fi )) != NULL ) { ulid = 1; combination_get_tree_stats( stmt->exp, &ulid, 0, stmt->suppl.part.excluded, hit, excluded, total ); } /* Deallocate functional unit iterator */ func_iter_dealloc( &fi ); } PROFILE_END; }

void combination_get_tree_stats (  expression *  exp, int *  ulid, unsigned int  curr_depth, bool  excluded, unsigned int *  hit, unsigned int *  excludes, unsigned int *  total )

Calculates combination logic statistics for a single expression tree. Recursively traverses the specified expression tree, recording the total number of logical combinations in the expression list and the number of combinations hit during the course of simulation. An expression can be considered for combinational coverage if the "measured" bit is set in the expression. Parameters: exp  Pointer to expression tree to traverse ulid  Pointer to current underline ID curr_depth  Current search depth in given expression tree excluded  Specifies that this expression should be excluded for hit information because one or more of its parent expressions have been excluded hit  Pointer to number of logical combinations hit during simulation excludes  Pointer to number of excluded logical combinations total  Pointer to total number of logical combinations { PROFILE(COMBINATION_GET_TREE_STATS); int num_hit = 0; /* Number of expression value hits for the current expression */ int tot_num; /* Total number of combinations for the current expression */ if( exp != NULL ) { /* Calculate excluded value for this expression */ excluded |= ESUPPL_EXCLUDED( exp->suppl ); /* Calculate children */ combination_get_tree_stats( exp->left, ulid, combination_calc_depth( exp, curr_depth, TRUE ), excluded, hit, excludes, total ); combination_get_tree_stats( exp->right, ulid, combination_calc_depth( exp, curr_depth, FALSE ), excluded, hit, excludes, total ); if( ((report_comb_depth == REPORT_DETAILED) && (curr_depth <= report_comb_depth)) || (report_comb_depth == REPORT_VERBOSE) || (report_comb_depth == REPORT_SUMMARY) ) { if( (EXPR_IS_MEASURABLE( exp ) == 1) && (ESUPPL_WAS_COMB_COUNTED( exp->suppl ) == 0) ) { if( (ESUPPL_IS_ROOT( exp->suppl ) == 1) || (exp->op != exp->parent->expr->op) || ((exp->op != EXP_OP_AND) && (exp->op != EXP_OP_LAND) && (exp->op != EXP_OP_OR) && (exp->op != EXP_OP_LOR)) || !allow_multi_expr ) { /* Calculate current expression combination coverage */ if( (((exp->left != NULL) && (exp->op == exp->left->op)) || ((exp->right != NULL) && (exp->op == exp->right->op))) && ((exp->op == EXP_OP_AND) || (exp->op == EXP_OP_OR) || (exp->op == EXP_OP_LAND) || (exp->op == EXP_OP_LOR)) && allow_multi_expr ) { combination_multi_expr_calc( exp, ulid, FALSE, excluded, hit, excludes, total ); } else { if( !expression_is_static_only( exp ) ) { if( EXPR_IS_COMB( exp ) == 1 ) { if( exp_op_info[exp->op].suppl.is_comb == AND_COMB ) { if( report_bitwise ) { tot_num = 3 * exp->value->width; num_hit = vector_get_eval_abc_count( exp->value ); } else { tot_num = 3; num_hit = ESUPPL_WAS_FALSE( exp->left->suppl ) + ESUPPL_WAS_FALSE( exp->right->suppl ) + exp->suppl.part.eval_11; } } else if( exp_op_info[exp->op].suppl.is_comb == OR_COMB ) { if( report_bitwise ) { tot_num = 3 * exp->value->width; num_hit = vector_get_eval_abc_count( exp->value ); } else { tot_num = 3; num_hit = ESUPPL_WAS_TRUE( exp->left->suppl ) + ESUPPL_WAS_TRUE( exp->right->suppl ) + exp->suppl.part.eval_00; } } else { if( report_bitwise ) { tot_num = 4 * exp->value->width; num_hit = vector_get_eval_abcd_count( exp->value ); } else { tot_num = 4; num_hit = exp->suppl.part.eval_00 + exp->suppl.part.eval_01 + exp->suppl.part.eval_10 + exp->suppl.part.eval_11; } } *total += tot_num; if( excluded ) { *hit += tot_num; *excludes += tot_num; } else { *hit += num_hit; } if( (num_hit != tot_num) && (exp->ulid == -1) && !combination_is_expr_multi_node( exp ) ) { exp->ulid = *ulid; (*ulid)++; } } else if( EXPR_IS_EVENT( exp ) == 1 ) { (*total)++; num_hit = ESUPPL_WAS_TRUE( exp->suppl ); if( excluded ) { (*hit)++; (*excludes)++; } else { *hit += num_hit; } if( (num_hit != 1) && (exp->ulid == -1) && !combination_is_expr_multi_node( exp ) ) { exp->ulid = *ulid; (*ulid)++; } } else { if( report_bitwise ) { *total = *total + (2 * exp->value->width); num_hit = vector_get_eval_ab_count( exp->value ); } else { *total = *total + 2; num_hit = ESUPPL_WAS_TRUE( exp->suppl ) + ESUPPL_WAS_FALSE( exp->suppl ); } if( excluded ) { *hit += 2; *excludes += 2; } else { *hit += num_hit; } if( (num_hit != 2) && (exp->ulid == -1) && !combination_is_expr_multi_node( exp ) ) { exp->ulid = *ulid; (*ulid)++; } } } } } } } /* Consider this expression to be counted */ exp->suppl.part.comb_cntd = 1; } PROFILE_END; }

void combination_report (  FILE *  ofile, bool  verbose )

Generates report output for combinational logic coverage. Exceptions: anonymous  combination_funit_verbose combination_instance_verbose After the design is read into the functional unit hierarchy, parses the hierarchy by functional unit, reporting the combinational logic coverage for each functional unit encountered. The parent functional unit will specify its own combinational logic coverage along with a total combinational logic coverage including its children. Parameters: ofile  Pointer to file to output results to verbose  Specifies whether or not to provide verbose information { PROFILE(COMBINATION_REPORT); bool missed_found = FALSE; /* If set to TRUE, indicates combinations were missed */ inst_link* instl; /* Pointer to current instance link */ int acc_hits = 0; /* Accumulated number of combinations hit */ int acc_total = 0; /* Accumulated number of combinations in design */ fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" ); fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ COMBINATIONAL LOGIC COVERAGE RESULTS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" ); fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" ); if( report_instance ) { fprintf( ofile, " Logic Combinations\n" ); fprintf( ofile, "Instance Hit/Miss/Total Percent hit\n" ); fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); instl = db_list[curr_db]->inst_head; while( instl != NULL ) { missed_found |= combination_instance_summary( ofile, instl->inst, (instl->inst->suppl.name_diff ? "<NA>" : "*"), &acc_hits, &acc_total ); instl = instl->next; } fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); (void)combination_display_instance_summary( ofile, "Accumulated", acc_hits, acc_total ); if( verbose && (missed_found || report_covered || report_exclusions) ) { fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); instl = db_list[curr_db]->inst_head; while( instl != NULL ) { combination_instance_verbose( ofile, instl->inst, (instl->inst->suppl.name_diff ? "<NA>" : "*") ); instl = instl->next; } } } else { fprintf( ofile, " Logic Combinations\n" ); fprintf( ofile, "Module/Task/Function Filename Hit/Miss/Total Percent hit\n" ); fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); missed_found = combination_funit_summary( ofile, db_list[curr_db]->funit_head, &acc_hits, &acc_total ); fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); (void)combination_display_funit_summary( ofile, "Accumulated", "", acc_hits, acc_total ); if( verbose && (missed_found || report_covered || report_exclusions) ) { fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); combination_funit_verbose( ofile, db_list[curr_db]->funit_head ); } } fprintf( ofile, "\n\n" ); PROFILE_END; }

void combination_reset_counted_expr_tree (  expression *  exp  )

Resets combination counted bits in expression tree. Recursively iterates through specified expression tree, clearing the combination counted bit in the supplemental field of each child expression. This functions needs to get called whenever the excluded bit of an expression is changed. Parameters: exp  Pointer to expression tree to reset { PROFILE(COMBINATION_RESET_COUNTED_EXPR_TREE); if( exp != NULL ) { exp->suppl.part.comb_cntd = 0; combination_reset_counted_expr_tree( exp->left ); combination_reset_counted_expr_tree( exp->right ); } PROFILE_END; }

---