To understand what subexpressions of a statement caused it to not achieve 100% coverage, the viewer window allows the user to traverse uncovered subexpressions, displaying the coverage information for each subexpression in the lower frame. To see an uncovered subexpression in the lower frame, simply click the left mouse on the underlined subexpression. If the subexpression has one or more children subexpressions, these will be individually underlined and numbered. If the subexpression is a leaf subexpression of the statement, only its coverage information will be displayed in the lower pane. To traverse upward in a subexpression, simply click the right mouse button on the underlined subexpression. This will cause the parent subexpression to be underlined and its parent (if one exists) will have its coverage information displayed in the lower frame.

To exit this window, simply click on Close button. To see this help page for the combinational logic window, click on the help (?) button.

The coverage information for a selected subexpression can be one of four different types:

Event Subexpression

These subexpressions do not have any children expressions. Their coverage is in terms of:

• Did this event occur?

The following operators are considered events:

• At-event operators:

    @(posedge expression)
    @(negedge expression)
    @(expression)
    @*
                

• Event trigger operator:

    -> event_variable
                

Figure 21.2. Example Coverage Output for an Uncovered Event Subexpression

In this diagram, we see that a certain @(posedge clock) expression never occured.

Unary Subexpression

These subexpressions do not have any children expressions. Their coverage is in terms of:

• Did this expression evaluate to a value of 0?

• Did this expression evaluate to a non-zero value?

The following operators are considered unary subexpressions:

• Signal/Bit Selectors:

    signal_value
    signal_value[expression]
    signal_value[value:value]
    signal_value[expression+:value]
    signal_value[expression-:value]
                

• Function call:

    function_name( ... )
                

• Relational operators:

    !expression
    expression  <    expression
    expression  >    expression
    expression  <=   expression
    expression  >=   expression
    expression  ==   expression
    expression  !=   expression
    expression  ===  expression
    expression  !==  expression
                

• Shift operators:

    expression <<  value
    expression >>  value
    expression <<< value
    expression >>> value
                

• Conditional operator:

    expression ? expression : expression
                

• Unary operators:

    expression
    &expression
    |expression
    ^expression
    ~&expression
    ~|expression
    ~^expression
                

• Concatenation operators:

    {value{expression} }
    {expression, expression, ... }
                

• Case equality

Figure 21.3. Example Coverage Output for an Uncovered Unary Subexpression

Simple Combinational Subexpression

These subexpressions have two child expressions (L=left and R=right). There are three flavors of simple combinational subexpressions: AND-type, OR-type and other. The differences are explained below.

Simple AND-type Combinational Subexpressions

These subexpressions have three possible combinational outcomes:

• Did the left expression evaluate to 0?

• Did the right expression evaluate to 0?

• Did the left expression evaluate to 1 when the right expression evaluated to 1?

The following operators are considered simple AND-like combinational subexpressions:

• Logical operators:

    expression  &   expression
    expression  ~&  expression
    expression  &&  expression
                  

Figure 21.4. Example Coverage Output for an Uncovered Simple AND-type Combinational Subexpression

Simple OR-type Combinational Subexpressions

These subexpressions have three possible combinational outcomes:

• Did the left expression evaluate to 1?

  Did the right expression evaluate to 1?

  Did the left expression evaluate to 0 when the right expression evaluated to 0?

The following operators are considered simple OR-like combinational subexpressions:

• Logical operators

•   expression  |   expression
    expression  ~|  expression
    expression  ||  expression
                  

Figure 21.5. Example Coverage Output for an Uncovered Simple OR-type Combinational Subexpression

Simple Other-type Combinational Subexpressions

These subexpressions have four possible combinational outcomes:

• Did the left expression evaluate to 0 when the right expression evaluated to 0?

• Did the left expression evaluate to 0 when the right expression evaluated to 1?

• Did the left expression evaluate to 1 when the right expression evaluated to 0?

• Did the left expression evaluate to 1 when the right expression evaluated to 1?

The following operators are considered simple combinational subexpressions:

• Mathematical operators:

    expression + expression
    expression - expression
                  

• Logical operators:

    expression ^  expression
    expression ~^ expression
                  

Figure 21.6. Example Coverage Output for an Uncovered Simple Combinational Subexpression

Complex Combinational Subexpression

These subexpression have three or more child expressions that all are connected by the same operator. For example, the statement a = (b & c & d) would contain the complex combinational subexpression of (b & c & d) where b, c and d are the three child expressions all combined using the bitwise AND operator.

The effect of each subexpression on the value of the entire subexpression as well as the combination of each child toward the parent is displayed. For example, if the combinational operator is a bitwise OR, each child is checked to see if it evaluated to TRUE (in an OR operation, only one subexpression needs to evaluate to TRUE for the entire subexpression to be TRUE). Additionally, all child subexpressions are checked to see if all evaluated to 0 simultaneously (this is the only way to get the whole subexpression to evaluate to 0).

The unique identifier below each subexpression is used in the displayed coverage information for these types of subexpressions for identifying which subexpression did not behave correctly.

All simple combinational subexpressions can be output as complex combinational subexpressions if there are three or more child subexpressions to the operation.

Figure 21.7. Example Coverage Output for an Uncovered Complex Combinational Subexpression

In this example, subexpression 1 never evaluated to a value of TRUE (which would have made the entire expression TRUE) and all three subexpressions 1, 2, and 3 were never a value of 0 simultaneously (which would have made the entire expression FALSE). However, subexpressions 2 and 3 both evaluated to TRUE at some point.

For any displayed subexpression within a statement, the user may choose to disregard the coverage information for that subexpression by clicking on the Excluded checkbutton on the right side of the window. If this option is checked, Covered will display a exclusion reason popup window to allow the user to specify a reason for excluding the subexpression. Once a reason has been entered, the combinational logic summary coverage information will be recalculated for the current module/instance by adding to the "Exclude" count the number of uncovered combinational logic values for the given subexpression (and all subexpressions below this expression within the expression tree). This new summary information will be redisplayed on the listbox. The subexpression background color in the top frame will also change from the uncovered background color to the covered background color. However, the subexpression will still contain an underline that may be clicked on at any time to view its coverage information or the coverage information for any subexpressions that are uncovered. To include a previously excluded subexpression, simply uncheck the Excluded checkbutton. This will automatically cause the summary information and background color to be updated for the given subexpression. Figure 21.8, “Example of an excluded subexpression” below shows an example of a subexpression that has been excluded from coverage consideration.

Figure 21.8. Example of an excluded subexpression

If an expression tree has been entirely excluded from coverage (all subexpressions have the Excluded checkbutton checked), the background color in the file viewer will change from an uncovered background color to the covered background color to indicate at the top-level that this entire statement has been excluded from coverage. However, the statement will still be underlined in the Main Coverage File Viewer to allow the user to view the statement, if necessary.

If the user excludes any subexpression in the design, the Save CDD... option in the file menu will be enabled. This allows the user to save the excluded property either back to the CDD file (or to a newly named CDD file). Doing so will allow the user to load the CDD file at a different time and retain the knowledge of which subexpressions have been excluded/included for coverage. Additionally, if a saved CDD file with coverage exclusion is merged with another CDD file, the excluded subexpression information is preserved for the resulting merged CDD file.

If a subexpression has been excluded from coverage and an exclusion reason was specified, you can view the reason for exclusion by selecting the subexpression in the top window (so that it is displayed in the lower window and right-click-and-holding on the Excluded checkbutton. This will cause a tooltip-style window to be displayed specifying the reason for exclusion. The background color of the tooltip will be the same color as the "covered" background color to help distinguish it from a normal tooltip. To cause the exclusion reason tooltip to disappear, simply release the button.

If the Verbose Combinational Logic Coverage window is currently displayed with a statement, the user may select a new statement in the file viewer of the Mainwindow. When a new statement is selected, its value immediately replaces the currently selected statement. This feature allows many different statements to be viewed one after the other without having to create/destroy a new window for each.

The user may also see the previous or next uncovered statement in the main viewer by clicking either the left arrow button (for previous signal viewing) or the right arrow button (for next signal viewing). Note that the left arrow button will be disabled if there is not a signal previous to the current signal in the given module and the right arrow button will be disabled if there is not a signal after the current signal in the given module.