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
    • Synthesis Flow Overview
    • Synthesizable RTL and Inference
      • Combinational Blocks Infer Logic
      • Priority Chains versus Parallel Selects
      • Latch Inference from Incomplete Assignment
      • Flops, Tri-States and Unrolled Loops
      • What Is Not Synthesizable
    • Reading Netlists and Reports
  • Logic Optimisation and Mapping20
  • Constraints and Timing15
  • Sequential, FSM and Memory19
  • Datapath Synthesis14
  • Area, Power and Test14
  • Verification, ECO and Handoff15
  • Flows and Debugging15
  • Interview and Judgment11
Loading lesson

←Synthesis Foundations
  1. Topics
  2. Logic Synthesis
  3. Synthesis Foundations
  4. Synthesizable RTL and Inference

Part 1 of 9Part 1 of 9/Synthesis FoundationsIntermediate

Synthesizable RTL and Inference

Which RTL constructs infer which hardware, and the latch and priority pitfalls.

  • 5topics
  • 5lessons

Every later topic assumes you can look at RTL and name the hardware: muxes for complete selects, latches for skipped paths, flops for clock edges. Without that reflex, every netlist is a surprise and every warning reads as noise.

After this lesson you can: map each common RTL construct to the generic cell it infers, and say which lesson proves each mapping with a recorded run.

Each RTL construct maps to specific hardware. Operators become word-level cells, complete selects become multiplexers, a skipped assignment in a combinational block becomes a latch, and clocked blocks become flip-flops. The five lessons below each prove one row of that mapping with a recorded tool run, so this hub is a map over evidence rather than a claim on its own.

Flowchart from six RTL shapes to their inferred hardware: complete combinational logic to gates and mux cells, skipped paths to latch cells, clocked blocks to flop cells, tri-states to pins, fixed loops to unrolled copies, and delays and testbench code to nothing.
Each RTL shape meets one inference rule that names its generic cell: complete combinational logic gives muxes, skipped paths give latches, clock edges give flops, tri-states stay at pins, fixed loops unroll, and delays and testbench code give nothing.

Read the chart left to right whenever you meet unfamiliar RTL. First ask which row the block belongs to: is it an operator, combinational and complete, combinational with a gap, clocked, a pin driver, a counted loop, or testbench code wearing an RTL costume. The row names the cell family before any report is opened, which turns the later lessons from surprises into confirmations.

Lesson

What it covers

Combinational Blocks Infer Logic

Operators to word cells ($add, $eq, $mux) and then to bit cells, proved with the tool.

Priority Chains versus Parallel Selects

If chains, one-hot case selects, and their depth and area.

Latch Inference from Incomplete Assignment

The missing-else latch, its fixes, and why always_comb refuses one.

Flops, Tri-States and Unrolled Loops

Clocked blocks, pin tri-states, bus fights, and unrolled loops.

What Is Not Synthesizable

Delays, initial blocks, and the real-type boundary.

One recorded number to set the tone: the latch lesson elaborates a bare 8-bit if without an else and records 1 $dlatch cell holding the bus whenever the enable drops, while each of the three fixed variants records zero. Every lesson below holds itself to the same bar: a number from a run, never an adjective.

The bare latch variant as recorded: one highlighted 8-bit $dlatch on the path to the output, with no select logic beside it.

What you can do after this topic

The topic is finished when each of these is a reflex rather than a lookup. Every item is proved by the lesson named beside it, with the recorded cell counts on the page.

  • Name the word cell each operator infers, then read the bit-level count after techmap (Combinational Blocks Infer Logic).

  • Write one select two ways, prove the forms equivalent, and read which cost the mapper actually paid (Priority Chains versus Parallel Selects).

  • Remove a latch three different ways and watch the recorded $dlatch count fall to zero (Latch Inference from Incomplete Assignment).

  • Price a sync reset against an async reset from mapped reports instead of rules of thumb (Flops, Tri-States and Unrolled Loops).

  • Reject delays, testbench blocks and unelaboratable types from RTL by naming what the tool kept and what it ignored (What Is Not Synthesizable).

Check yourself A combinational block skips its output on one branch. Which cell holds the old value?

A latch. The latch lesson proves one $dlatch with the tool and contrasts it with a mux.

Which RTL habit most often adds hardware the designer never drew?

Weak answer: bad coding style makes synthesis slow.

Strong answer: an uncovered path in a combinational block. The bare 8-bit variant records one 8-bit $dlatch (8 latch bits after mapping) where every fixed variant records zero, so one missing assignment is one 8-bit $dlatch (8 latch bits after mapping).

Follow-up: how do you find it in a big netlist. Answer: search the generic netlist for $dlatch cells and walk back to the combinational block that skips the output.

  • Complete combinational selects give muxes; a skipped path gives a latch.

  • Clock edges give flops; tri-states belong at pins; fixed-bound loops unroll.

  • Delays, testbench blocks and real types never reach the netlist.

Rule of thumb: name the cell before you read the report.

How this was checked

The hub shows one recorded figure: the bare 8-bit latch variant from the latch-inference run, a single highlighted $dlatch with no select cells beside it (Yosys 0.70+post through the course checker, COURSE=synth scripts/tools/run-rtl-testbenches.mjs). Each lesson below records its own run the same way; the flowcharts here only summarize those recordings. Library areas are teaching units from course.lib, so absolute values are illustrative and the cell families are the point.

  • Interview: run a mock interview on this topic

Related topics

  • Up: Synthesis Foundations

  • Previous: Synthesis Flow Overview

  • Next: Reading Netlists and Reports

PreviousNext: Combinational Blocks Infer Logic

Up next

Up nextCombinational Blocks Infer Logic

Sign in to save progress

Practice this lessonPrevious lessonReport an error

See also

  • Synthesis Flow Overview
  • Reading Netlists and Reports