How X Flows Through Muxes, Flops & Latches

Chapter 6 · Section 6.3 · X-Propagation

Project thread — the FSM's state X (5.5) reaches busy/done through the output logic. These mechanics are how you'll trace that path in 6.6.

1. Why Should I Learn This?

Root-causing an X means following it — backward to its source, forward to its symptom. That needs the flow rules.

• Muxes/flops/latches each have specific X rules.
• Controlling values (AND-0, OR-1) absorb X; non-controlling paths spread it.
• Knowing the rules tells you when an X should stop — and flags when it doesn't.

This is the mechanics layer between "where X comes from" (6.1) and root-causing the FSM X (6.6).

2. Real Silicon Story — the X that stopped where it shouldn't have

An engineer tracing an X expected it to reach a status output, but the output was a clean 0. They concluded the X had "gone away" and closed the investigation.

The X hadn't gone away — it hit an AND gate whose other input was 0, a controlling value that forced the output to 0 regardless (AND(X,0)=0), absorbing the X on that path. The X was still live on other paths. Mistaking absorption for resolution left a real upstream X un-fixed.

Lesson: X flow follows controlling values — an X can be absorbed by a dominating 0/1 on one path while still propagating on others. Trace by the rules, not by where the X happens to disappear.

3. Concept — the X-flow rules

Muxes:

• Unknown select + differing data → X.
• Unknown select + equal data → definite (both branches agree; less pessimistic).
• X on an unselected input → no effect (select routes around it).

Flip-flops:

• X on D → captured X at the clock edge.
• X on the clock → output X (can't tell if/when it triggered).
• X on async set/reset → output X (can't tell if it's asserted).

Latches:

• X on enable → X (can't tell open vs closed).

Ordinary gates — controlling values:

• Controlling value dominates and absorbs X: AND(X,0)=0, OR(X,1)=1, NAND(X,0)=1, NOR(X,1)=0.
• Non-controlling input passes X: AND(X,1)=X, OR(X,0)=X, XOR(X,anything)=X, NOT(X)=X.

Reading it:

• Controlling value on any input → X on the other input is absorbed.
• All non-controlling → X propagates.
• Some rules (mux equal-data) are less pessimistic; others may be conservative (6.2).

4. Mental Model — X is a rumour; controlling values are people who know the truth

Treat X as a rumour spreading through the logic.

• A gate with a controlling value is someone who knows the fact — they stop the rumour cold (AND-0 says "definitely 0", ignoring the rumour).
• A gate with only non-controlling inputs just passes the rumour on (AND-1 has nothing to counter it → X).
• A mux with an unknown select is at a fork with no directions — it can only shrug (X), unless both roads lead the same place (equal data).
• A flop writes the rumour down (captures X) and repeats it next cycle.

Follow the rumour: it dies where someone knows the truth (controlling value), spreads where nobody does.

5. Working Example — X absorbed vs propagated

The controlling-value truth table, and a flop capturing X:

# Gate X-flow — REPRESENTATIVE (controlling value in brackets)
AND(X, 0) = 0     # [0] controlling -> ABSORBS X
AND(X, 1) = X     #  1  non-controlling -> PASSES X
OR (X, 1) = 1     # [1] controlling -> ABSORBS X
OR (X, 0) = X     #  0  non-controlling -> PASSES X
XOR(X, 0) = X     # XOR has no controlling value -> always PASSES X
NOT(X)    = X

// Flop capturing X on D; and X on reset forcing X — REPRESENTATIVE
DFFRX1 u_q (.D(x_data), .CK(clk), .RN(rst_n), .Q(q));
//  D = X            -> q captures X at the edge
//  RN = X (bad reset) -> q = X (can't tell if reset is asserted)

Practical context (representative, tool-neutral):

# Tracing an X in a waveform (tool-neutral):
#   backward: follow the X to the first net that is X -> toward the SOURCE (6.1)
#   forward:  follow it until a CONTROLLING value (AND-0 / OR-1) ABSORBS it
#   a mux X?  check the SELECT (unknown select + differing data = X)
#   a flop X? check D, clock, and async reset for X

An X absorbed by a controlling value vs propagated, as a real waveform:

6. Debugging Session — an X that "disappeared" (was absorbed)

7. Common Mistakes

• Thinking an absorbed X is resolved. A controlling value hides it on one path; the source lives.
• Ignoring the mux equal-data case. Equal data can keep a definite output despite an unknown select.
• Forgetting X on clock/reset. A flop goes X from an X clock or async reset, not just X data.
• Overlooking XOR. XOR has no controlling value — it always passes X.
• Tracing forward only. The fix is at the source — trace backward (6.1).

8. Industry Best Practices

• Trace X both ways — backward to source, forward to symptom.
• Use controlling values to explain where an X stops (absorbed, not resolved).
• Check select/clock/reset first for mux/flop X.
• Fix the source, not the absorbed symptom.
• Flag conservative rules as possible pessimism (6.2) when relevant.

Senior Engineer Thinking

• Beginner: "The X turned into 0 at this gate — it's fixed."
• Senior: "That's an AND with a 0 — a controlling value absorbing the X on this path. The source X is still live. Let me trace backward and fix the source, not celebrate the absorption."

The senior reads X flow by controlling values and always traces to the source.

Silicon Impact

Understanding X flow is what makes root-causing reliable. Mistake absorption for resolution and you leave a real source X (uninitialized state, bad reset) in place — it keeps propagating on other paths and can reach silicon as a power-up/intermittent failure (0.3). Conversely, knowing that controlling values absorb X prevents chasing an X down a dead path. And recognising which flow rules are conservative (mux/UDP pessimism, 6.2) keeps you from waiving a real X or drowning in a false one. The flow rules turn X tracing from guesswork into a deterministic walk to the root cause.

Engineering Checklist

• Traced each X backward to source and forward to symptom.
• Explained where X stopped via a controlling value (absorbed ≠ resolved).
• Checked select (mux) and clock/reset (flop) for X.
• Fixed the source, not an absorbed symptom.
• Noted conservative rules as possible pessimism (6.2).

Try Yourself

1. Drive an X into an AND gate with the other input 0 — the output is 0 (absorbed).
2. Observe: change the other input to 1 — the output becomes X (passed).
3. Change: feed an unknown select into a mux with differing data (→ X), then make the data equal (→ definite).
4. Expect: you can now predict where an X stops (controlling values, equal-data muxes) and where it spreads — trace one end to end.

Any free Verilog simulator demonstrates all these X-flow rules. No paid tool required.

Interview Perspective

• Weak: "X just spreads everywhere."
• Good: "A mux with an unknown select outputs X; a flop captures X on D; controlling values like AND-0 block it."
• Senior: "X flows by rules: muxes propagate on unknown selects with differing data, flops capture X on D/clock/reset, and controlling values (AND-0, OR-1) absorb X while non-controlling inputs pass it. An absorbed X isn't resolved — the source is still live, so I trace backward to fix the source. Some rules are conservative (pessimism)."

9. Interview / Review Questions

10. Key Takeaways

• Muxes: unknown select + differing data → X; equal data can stay definite; an X on an unselected input has no effect.
• Flip-flops: X on D is captured; X on the clock or async reset drives the output X. Latches: X on enable → X.
• Ordinary gates flow X by controlling value: AND-0→0 and OR-1→1 absorb X; non-controlling inputs (AND-1, OR-0, any XOR) pass X.
• An absorbed X is not a resolved one — a controlling value hides it on one path while the source X lives and spreads on others; trace backward to the source (6.1).
• Some flow rules are conservative (pessimism, 6.2); X is a modelling value, and GLS stays dynamic (STA signs off, 0.3). Next: 6.4 — why RTL hides bugs the netlist exposes.

Quick Revision

X-flow rules: mux (unknown select + differing data → X; equal data → definite); flop (X on D/clock/reset → X); latch (X enable → X). Gates: controlling values absorb (AND-0→0, OR-1→1), non-controlling pass (AND-1, OR-0, XOR → X). Absorbed ≠ resolved — trace backward to the source (6.1). Some rules conservative (pessimism). Next: 6.4 — why RTL hides bugs the netlist exposes.