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

AboutRoadmapCareersInternshipsFAQContactPrivacyTerms
Skip to lesson

Course contents

  • Logic Synthesis Glossary
  • Logic Synthesis Cheatsheet
  • Synthesis Foundations14
  • Logic Optimisation and Mapping20
  • Constraints and Timing15
  • Sequential, FSM and Memory19
    • Flops, Resets and Enables
      • D Flop Inference
      • Enables: Mux or Clock Enable
      • Synchronous and Asynchronous Reset
      • Reset-less Flops and Initial Values
      • Mapping Flops to Library Cells
    • FSM Synthesis
    • Memory and Macro Inference
    • Retiming and Pipelining
  • Datapath Synthesis14
  • Area, Power and Test14
  • Verification, ECO and Handoff15
  • Flows and Debugging15
  • Interview and Judgment11
Loading lesson

←Sequential, FSM and Memory
  1. Topics
  2. Logic Synthesis
  3. Sequential, FSM and Memory
  4. Flops, Resets and Enables
On this page

    Part 4 of 9Part 4 of 9/Sequential, FSM and MemoryIntermediate

    Flops, Resets and Enables

    D flops, enables, resets, and how each maps to library cells.

    • 5topics
    • 5lessons

    Every clocked bit in a design lives in one of four flop families, and each family prices differently depending on the library. Without that map, every reset or enable looks free until the area report arrives.

    After this lesson you can: name the generic flop family for any plain, enabled, or reset idiom, and say where each reset and enable cost sits after mapping.

    Every clocked bit in a design lives in one of four flop families: plain, enabled, synchronous reset, or asynchronous reset. Each RTL idiom infers its own generic cell, and the library decides whether that cell maps to a dedicated flop or to a plain flop plus glue logic. This topic runs all four families through inference and mapping against the teaching library, prices each one from the recorded stat reports, and shows where the reset and enable costs really sit.

    The headline result to carry through the topic: in this library a synchronous reset is a plain DFF with gates on D, while an asynchronous reset is a dedicated DFFR cell, and the two 10-bit registers report the same total chip area. The cost moves between the flop cell and the surrounding logic instead of changing the sum, which is why this topic always quotes the stat chip area and never the ABC summary line when flops are involved.

    From RTL idiom to generic flop cell to library cells, with a branch for extra mux logic when the library lacks the cell.
    Each RTL idiom infers one generic flop cell, which then maps to library cells plus logic.

    What you can do after this topic

    • Name the generic cell for any plain, enabled, sync-reset, or async-reset block, and prove it with a select assertion.

    • Read a mapped register as library cells plus glue, and explain which seat the reset or enable cost sits in.

    • Quote register area from the stat chip total, and say why the ABC summary line misprices any design with flops.

    • Decide which flops may skip reset, what an initial value guarantees, and what reading too early shows in simulation.

    • Predict what the legalize-then-exchange flow builds when the library has no matching flop, and what a combined reset-plus-enable costs.

    Lessons

    Lesson

    What it covers

    D Flop Inference

    The plain clocked block, one flop per bit, width scaling, and the chained-blocking break-it.

    Enables: Mux or Clock Enable

    $dffe becomes DFF plus feedback mux here, and the real clock-power saving comes from a gate.

    Synchronous and Asynchronous Reset

    $sdff against $adff with equal mapped totals, plus recovery, removal, and a safe release.

    Reset-less Flops and Initial Values

    Which flops may skip reset, what init records, and what early reads show in simulation.

    Mapping Flops to Library Cells

    From generic cells to DFF and DFFR via dfflegalize and dfflibmap, plus the no-match fallback.

    Check yourself A block loads q only when en is high and has no reset. Which generic cell does it infer?

    An enabled flop without reset: $dffe. The enable selects between the new data and the held value, which the next lesson records as a DFF plus feedback mux in this library.

    Carry one sentence per lesson: plain blocks give $dff at one flop per bit, enables give $dffe as DFF plus mux here, sync reset gives $sdff and async gives $adff at equal mapped totals, datapath flops usually skip reset, and dfflegalize limits the flop set before dfflibmap exchanges to DFF or DFFR, with glue where the library has no match.

    • Plain blocks give $dff, enables give $dffe, sync reset gives $sdff, async gives $adff.

    • A sync reset is a plain DFF plus gates on D here; an async reset is a dedicated DFFR cell.

    • Chip area comes from stat -liberty, which includes flops; the ABC summary line excludes them.

    Rule of thumb: name the generic family first, then read where the library put the reset or enable cost.

    How this was checked

    The hub runs nothing; its flowchart is a drawing of the lesson structure. The evidence for each claim sits on the five lesson pages, each recorded with Yosys 0.70 and ABC and listed in that page's frame.

    • Interview: run a mock interview on this topic

    Related topics

    • Up: Sequential, FSM and Memory

    • Foundations: Flops, Tri-States and Unrolled Loops

    • RTL: Flip-Flops and Registers

    PreviousNext: D Flop Inference

    Up next

    Up nextD Flop Inference

    Sign in to save progress

    Practice this lessonPrevious lessonReport an error

    See also

    • FSM Synthesis
    • Memory and Macro Inference
    • Retiming and Pipelining