comb.h File Reference

Contains functions for determining/reporting combinational logic coverage. More...

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

---

Detailed Description

Contains functions for determining/reporting combinational logic coverage.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

3/31/2002

---

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

References esuppl_u::comb_cntd, combination_output_expr(), combination_reset_counted_exprs(), statement_s::exp, FALSE, func_iter_dealloc(), func_iter_get_next_statement(), func_iter_init(), expression_s::line, esuppl_u::part, PROFILE, PROFILE_END, realloc_safe, expression_s::suppl, and TRUE.

  { 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

References combination_get_missed_expr(), exp_link_s::exp, func_unit_s::exp_head, exp_link_find(), expression_find_uline_id(), funit_find_by_id(), PROFILE, PROFILE_END, and TRUE.

  { 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

References Catch_anonymous, codegen_gen_expr(), combination_get_exclude_list(), combination_prep_line(), combination_underline_tree(), exp_link_s::exp, func_unit_s::exp_head, exp_link_find(), free_safe, funit_find_by_id(), funit_get_curr_module(), malloc_safe, expression_s::op, PROFILE, PROFILE_END, realloc_safe, Throw, and Try.

  { 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

References statistic_s::comb_excluded, statistic_s::comb_hit, statistic_s::comb_total, PROFILE, PROFILE_END, and func_unit_s::stat.

  { 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

References statistic_s::comb_excluded, statistic_s::comb_hit, statistic_s::comb_total, PROFILE, PROFILE_END, and funit_inst_s::stat.

  { 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

References combination_get_tree_stats(), statement_s::exp, FALSE, func_iter_dealloc(), func_iter_get_next_statement(), func_iter_init(), funit_is_unnamed(), statement_s::part, PROFILE, PROFILE_END, statement_s::suppl, and TRUE.

Referenced by report_gather_funit_stats(), and report_gather_instance_stats().

  { 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

References allow_multi_expr, AND_COMB, esuppl_u::comb_cntd, combination_calc_depth(), combination_get_tree_stats(), combination_is_expr_multi_node(), combination_multi_expr_calc(), ESUPPL_EXCLUDED, ESUPPL_IS_ROOT, ESUPPL_WAS_COMB_COUNTED, ESUPPL_WAS_FALSE, ESUPPL_WAS_TRUE, esuppl_u::eval_00, esuppl_u::eval_01, esuppl_u::eval_10, esuppl_u::eval_11, EXP_OP_AND, EXP_OP_EXPAND, EXP_OP_LAND, EXP_OP_LOR, EXP_OP_OR, expr_stmt_u::expr, EXPR_IS_COMB, EXPR_IS_EVENT, EXPR_IS_MEASURABLE, expression_is_static_only(), FALSE, exp_info_s::is_comb, expression_s::left, expression_s::op, OR_COMB, expression_s::parent, esuppl_u::part, PROFILE, PROFILE_END, report_bitwise, report_comb_depth, REPORT_DETAILED, REPORT_SUMMARY, REPORT_VERBOSE, expression_s::right, exp_info_s::suppl, expression_s::suppl, TRUE, expression_s::ulid, expression_s::value, vector_get_eval_ab_count(), vector_get_eval_abc_count(), vector_get_eval_abcd_count(), and vector_s::width.

Referenced by combination_get_stats(), combination_get_tree_stats(), and exclude_expr_assign_and_recalc().

  { 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( (exp->op != EXP_OP_EXPAND) || (exp->value->width > 0) ) {
                  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

References combination_display_funit_summary(), combination_display_instance_summary(), combination_funit_summary(), combination_funit_verbose(), combination_instance_summary(), combination_instance_verbose(), curr_db, FALSE, funit_head, inst_link_s::inst, db_s::inst_head, funit_inst_s::name_diff, inst_link_s::next, PROFILE, PROFILE_END, report_covered, report_exclusions, report_instance, and funit_inst_s::suppl.

Referenced by report_generate().

  { 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

References esuppl_u::comb_cntd, combination_reset_counted_expr_tree(), expression_s::left, esuppl_u::part, PROFILE, PROFILE_END, expression_s::right, and expression_s::suppl.

Referenced by combination_reset_counted_expr_tree(), exclude_expr_assign_and_recalc(), and rank_gather_comp_cdd_cov().

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

}