The Zero-Waiver Coverage Loop
Closing the Specification Contract Before Tapeout
Near tapeout, design and verification teams often stop arguing about RTL and start arguing about what is still open.
Was the behavior required? Was it checked for this configuration? Was the test written? Can the logic run? Did the checker bite? Did the tool reach its limit? Does another test need to be added?
These questions cost more near tapeout because the project has little room left for doubt. A coverage hole becomes a schedule problem. A missing test becomes an ownership problem. An unclear requirement becomes another meeting. A waiver can become the quickest way to stop the discussion.
WIOWIZ uses a different method. We call it the Zero-Waiver Coverage Loop.

The loop starts with the specification contract, generates verification work from coverage intent and keeps each open item moving through correction, proof or replay.
Start with the specification contract
Verification should not start with a loose collection of tests. It should start with the product configuration and a fixed statement of what that product must do. Together, they form the specification contract.
The contract is built from architecture, block and IP specifications, registers, address maps, interrupts, clocks, resets, power states, security rules, safety rules, boot behavior, error handling, performance limits and the configuration files used to build the product.
From this contract, the project creates verification obligations. An obligation can cover a function, an error path, a register rule, an interrupt, a clock or reset relation, a power transition, a security rule, a safety condition or a performance limit.
Each obligation must keep its link to the clause or configuration item that created it. The link tells the project why the test, assertion, coverpoint or analysis exists.
Zero unsupported waivers is the result of this loop. It is not a rule placed on top of a coverage report.
A coverage hole is an open question
A coverage hole means one thing: an obligation has not reached a conclusion that the project can check.
The next question should not be, “Can we waive it?” The next question should be, “Why is it still open?”
The last state matters. The loop does not need every tool to report PASS. It needs every unresolved item to remain visible until the next operation is known.
Zero waiver does not mean zero exclusions
A product configuration can remove a feature before verification starts. A formal run can prove that a coverage point cannot execute. Both can be valid reasons to remove an item from the active target.
The difference is that the reason can be checked without relying on a note written during signoff.
A green dashboard should follow these states. It should not be created by moving an open item into a waiver file.

The coverage dashboard keeps uncovered and unknown points in the count. A proof can change the target. A note cannot.
Formal closes the question left by simulation
Simulation shows what happened during the tests that ran. When an obligation remains uncovered, one question is still open: was it not stimulated, or can it never happen?
This is where formal verification fits. It is not a separate mathematical exercise. It handles a gap that simulation cannot settle by observation alone.
If formal can neither find a path nor complete the proof, the obligation stays open. The tool result does not disappear and it does not become a waiver.

The formal coverage view separates points hit by simulation from points removed by proof. The two routes do not share the same closing rule.
Every tool must refer to the same design
Results from different tools can be joined only when they refer to the same design state.
A waveform from an older RTL revision cannot close a failure in the current revision. A proof made with one set of assumptions cannot close an item in another configuration. A coverage database from another build cannot be counted for the current run. A CDC result made with different clock definitions is a different analysis.
Each closing record must identify:
- the design revision and product configuration,
- the tool build and command,
- the constraints, assumptions and power intent,
- the property, check or coverage point,
- the result and the change made after it,
- and the replay that confirmed the change.
Without this identity, a project can collect many reports while still lacking one verification record for the design it plans to tape out.
The WIOWIZ EDA Platform closes the loop
Individual tools remain important because each one answers a different question. FSiMX runs the design. Wave shows the signal and state sequence. Asesha records coverage. Hetu handles proof and counterexamples. Truti checks clock and reset crossings. Vajra-LP checks power intent.
EDA Studio gives these tools a common work area. The Zero-Waiver Coverage Loop defines how their results should move one obligation forward.

WIOWIZ EDA Studio places simulation, Wave, Asesha, Truti, Hetu, Vajra-LP and the project terminal in one verification desktop.
The project question is not whether each program finished. The project question is what remains open and what operation comes next.
RVP turns the contract into runnable verification
RVP starts from a configured SoC and its verification inputs. It builds the runnable environment around the RTL and links specification items to tests, checks, models, coverpoints, constraints and run inputs.
When an item remains open, RVP helps identify the next required step. That step may be new stimulus, a checker, a model, a formal question, a design correction or a rerun.
Replace the tapeout argument with a next operation
Late conflict is often blamed on design or verification teams. The deeper problem is usually a missing shared record.
Design says verification is adding tests. Verification says behavior keeps changing. Architecture says the requirement was read incorrectly. Program management asks why coverage is still open. Someone proposes a waiver.
The loop replaces that discussion with six fields:
- the contract clause,
- the product configuration,
- the current result,
- the reason the item is blocked,
- the owner,
- and the next operation.
The tapeout review can then inspect closed obligations and named open items. It does not need to reconstruct the project from disconnected reports.
The objective is contract closure
Formal is not the objective. A coverage percentage is not the objective. Simulation completion is not the objective. Zero waiver is not the direct objective.
The objective is to close the specification contract.
When every applicable obligation reaches a checked terminal state, unsupported waivers reach zero.
A coverage hole should never be treated as a request to hide uncertainty. It should name the next engineering operation required to remove that uncertainty.
See how a project is opened, run and inspected on the WIOWIZ EDA Platform.
Read the platform guide