Skip to content
DenseChip
Learn
PracticeCode labInterview

DenseChip

Navigate

Menu

LearnPracticeCode labInterview

Tools

All toolsSV editorCode repoResume
DenseChip

Practice, courses, and chip-design tools in one focused workspace.

LearnPracticeCode labInterviewToolsLearning paths

© 2026 DenseChip

AboutContactPrivacyTerms
Skip to lesson

Course contents

  • How to Use This Course
  • Reading Path
  • CDC/RDC Glossary
  • CDC/RDC Metrics Reference
  • CDC/RDC Interview Prep
  • CDC/RDC Signoff Cheatsheet
  • Clock Domains and Failure Modes8
  • Metastability and Synchronizers16
  • CDC Protocols and Handshakes16
  • Reconvergence and Gray Coding16
  • Reset Domain Crossing16
  • Architecture and Design Rules16
  • CDC Signoff Methodology24
    • CDC Tool Flow
    • CDC Constraints and STA
    • CDC Waiver Policy
    • CDC Review Gate
    • CDC Signoff Dashboard
    • Formal and Simulation CDC Verification
      • Formal CDC Checks
      • Metastability Injection
      • Gate Level and ECO Checks
      • Regression Strategy
  • RDC Signoff16
  • Debug and Case Studies11
  • CDC and RDC Interview Prep30
  • Capstone: Sign Off a Multi-clock Peripheral4
Loading lesson

‹Formal and Simulation CDC Verification
  1. Topics
  2. CDC & RDC
  3. CDC Signoff Methodology
  4. Formal and Simulation CDC Verification
  5. Gate Level and ECO Checks

Part 7 · CDC Signoff Methodology · Advanced

Gate Level and ECO Checks

Why CDC must be re-checked after synthesis and ECOs: merged flops, retiming, inserted logic, and clocking changes.

On this page

    RTL signoff proves the design as written; silicon is built from the netlist as implemented. Synthesis, optimisation, clock-tree work, and ECOs all rewrite the structures CDC depends on — silently, legally, and with the best intentions. The gate-level re-check exists because the implementation flow is allowed to break CDC while improving everything else.

    What can change

    Change

    How it breaks CDC

    What re-check catches it

    Flops merged or replicated

    Synchroniser stages collapse into one, or fanout alters settling

    Structural re-run on the netlist: stage count and no-logic-between-flops

    Retiming across the synchroniser

    Logic moves between the flops, spending settling time

    Structural re-run plus no-logic auditing on synchroniser modules

    Logic inserted before the synchroniser

    Optimisation folds a gate into the source path; glitches return

    Source-path auditing: registered source with no combinational prefix

    Clock tree and gating changes

    Skew and insertion delay move; gated domains shift phase

    Bound re-verification in timing plus clock-intent review

    Scan stitching through synchronisers

    Test structures reorder or bypass the flops

    DFT-aware structural run covering test mode as well as functional mode

    When to re-check

    • After synthesis and every major optimisation step: the first netlist structural run is a gate in its own right.

    • After every ECO, however small: ECOs edit precisely the logic under signoff, and their blast radius is always estimated, never known.

    • After scan insertion and clock-tree changes: both rewrite exactly the paths and flops CDC relies on.

    • Before tape-out on the final netlist with final constraints: the last word belongs to what is actually built.

    The handoff package from the review-gate topic is what makes these re-checks possible: PD needs the synchroniser inventory, the bounds, and the exceptions to preserve them — and to know when a change must come back for re-review.

    Common pitfall

    Re-running only timing on the netlist and calling CDC “carried forward from RTL” misses every row in the table above. Timing checks the numbers; only a structural re-run checks the structures still exist.

    Check yourself An ECO touches unrelated control logic far from any crossing. Must CDC be re-checked? Why?

    Yes — structurally, at least on the affected region and its boundary crossings. ECO blast radius is estimated, and optimisation around the edit can touch synchroniser context. The cost of a re-run is trivial next to the cost of being wrong.

    Check yourself Synthesis reports a synchroniser module “optimised”: two flops became one plus a buffer. Which checks catch this, and at which stage?

    The netlist structural re-run catches the collapsed stage count; timing may even look better. Caught at the post-synthesis gate — which is why that gate exists separately from RTL signoff.

    Related topics

    • Regression Strategy

    • Handoff to Physical Design and DFT

    • Pre-Tapeout Gates

    Previous

    117 / 179

    Next: Regression Strategy

    Up next

    Up nextRegression Strategy

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Formal CDC Checks