X-Handling & X-Bounding in LBIST

Chapter 9 · Section 9.4 · Logic BIST (LBIST)

Project thread — the mini-SoC is X-bounded for LBIST (memory bypassed as in 8.6, flops initialized) so its MISR signature is valid; 9.5 deploys the in-field self-test.

1. Why Should I Learn This?

In LBIST, X-handling is make-or-break — because a single X corrupts the entire signature and invalidates the whole run.

• The MISR accumulates via feedback → one X propagates into every subsequent bit → whole signature corrupt.
• Far stricter than compression (7.4): compression masks per-pattern; LBIST's single signature tolerates ~no X.
• X-bounding: make every X-source deterministic in LBIST mode — tie/initialize/scan/bypass (memories → MBIST, Ch8).
• X-masking is a fallback (costs coverage) — the emphasis is eliminating X at the source.

2. Real Silicon Story — the signature that changed every run

An LBIST bring-up hit a baffling symptom: on a known-good part, the signature was different every run — sometimes matching golden, sometimes not, non-deterministically. It wasn't a fault (the part was good), and it wasn't aliasing (9.3, which is deterministic). The signature was simply unstable.

The cause was an unbounded X-source: an uninitialized flop (and a memory that wasn't bypassed, 8.6) fed unknown (X) values into the logic, and those X's reached the MISR. Because the MISR accumulates through feedback, one X contaminated the entire signature — and since the X resolved differently each run (uninitialized state is non-deterministic), the signature changed run-to-run. The signature was meaningless — you can't compare an X-contaminated signature to golden.

The fix was X-bounding: initialize the flop and bypass the memory in LBIST mode so their outputs were known. The signature became stable and valid, matching golden on good parts. Lesson: an unstable / X signature means an unbounded X-source reaching the MISR — because the MISR accumulates, one X ruins the whole run, so X must be eliminated at the source before LBIST means anything.

3. Factory Perspective — X-handling through each lens

• What the DFT engineer sees: the X-source list and the X-bounding applied (tie/init/scan/bypass) — and that any residual X reaching the MISR makes the signature invalid.
• What the RTL/DV engineer sees: that X-source elimination is a design requirement for LBIST — initialize state, avoid uninitialized/non-scan logic, bypass memories — stricter than for ATPG.
• What the memory engineer sees: that memories must be bypassed/initialized in LBIST mode (as in MBIST scan-bypass, 8.6) — a memory is a major X-source.
• What management cares about: that a valid LBIST signature (and thus the in-field/safety capability, 9.5) depends on X-bounding — a design-discipline requirement, not a tool setting.

4. Concept — why LBIST is X-intolerant, and how to bound it

Why one X ruins the whole signature (the MISR's feedback):

• The MISR accumulates each response into a running signature via XOR feedback (9.2).
• When an X enters, the XOR of anything with X is X, and the feedback carries that X forward into every subsequent signature bit — so the final signature is X / meaningless.
• You cannot compare an X-contaminated signature to a golden value → the entire LBIST run is invalid.

Why LBIST is stricter than compression (7.4):

• Compression: an X corrupts one pattern's compacted output; you can mask per-pattern and keep the rest.
• LBIST: the signature is a single accumulated value over all patterns → one X anywhere ruins everything → LBIST's X-tolerance is essentially zero.

The X-sources (same as 7.4):

• Uninitialized flops (non-deterministic reset state), non-scan logic, memories (X outputs — bypass/init; test via MBIST, Chapter 8), analog blocks, uncontrolled multi-cycle paths, bus contention.

X-bounding — the primary technique (eliminate X at the source):

• Make each X-source deterministic in LBIST mode so it produces known values:
  • Tie / initialize uninitialized logic to a known value.
  • Scan non-scan flops (put them under control).
  • Bypass / initialize memories in LBIST mode (as in the MBIST scan-bypass, 8.6).
  • Control multi-cycle paths; resolve bus contention.
• Goal: the design is 'X-free in LBIST mode' — no X reaches the MISR.

X-masking — a fallback (used sparingly):

• Gate X-carrying paths before the MISR — but this costs coverage (7.4), and since LBIST can't afford any X in the signature, X-bounding at the source is strongly preferred over masking.

5. Mental Model — one drop of ink in a running total

The MISR is like keeping a single running total by mixing every new number into a shared beaker — and an X is a drop of ink.

• Each response is a splash of clear water added to the beaker (the signature); you keep stirring (the feedback mixes everything together).
• An X is a drop of black ink. The moment one drop goes in, the stirring spreads it through the entire beaker — and every future splash mixes into ink-stained water. The final color (the signature) is ruined, and you can't compare it to the 'known-good color' (golden).
• Contrast a compression compactor, which is more like separate cups per pattern: an inked cup can be set aside (masked) and the others are fine. LBIST's one beaker has no such luxury — one drop ruins the whole thing.
• Worse, if the ink source is a flaky dropper (an uninitialized flop — non-deterministic), the beaker is a different shade every time (the unstable signature).
• The only real fix is to stop the ink at the source — cap the dropper (initialize/tie), remove it (scan/bypass) — so no ink ever enters the beaker.

One beaker, one running total — one drop of ink (X) ruins it all. Stop the ink at the source (X-bound), don't try to fish it out.

6. Working Example — X-bounding for a valid signature

Bound the X-sources so the signature is valid:

# LBIST X-bounding - REPRESENTATIVE, SIMPLIFIED, tool-neutral:
  X-source                         WHY it's X in LBIST                 X-BOUNDING (make deterministic in LBIST mode)
  uninitialized flop               no reset -> unknown state           add reset/init to a KNOWN value (or scan it)
  non-scan sub-block               not controlled/initialized          SCAN it, or initialize/tie its outputs
  on-chip MEMORY                   sense-amp outputs unknown            BYPASS/INITIALIZE in LBIST mode (MBIST tests it, Ch8)
  analog / mixed-signal IF         non-digital output                  tie/gate to a known value in LBIST mode
  uncontrolled multi-cycle path    settles late -> X at capture        control/hold it; ensure known at capture
  bus contention / floating        multiple/no driver                  ensure ONE defined driver in LBIST mode
  RESULT: NO X reaches the MISR -> the signature is DETERMINISTIC + VALID -> comparable to golden.

# Why LBIST is stricter than compression (7.4) - REPRESENTATIVE:
  COMPRESSION: X corrupts ONE pattern's compacted output -> MASK that pattern's chains -> rest of coverage survives
  LBIST:       the MISR ACCUMULATES all patterns -> ONE X anywhere -> WHOLE signature = X -> ENTIRE run invalid
  -> compression tolerates/masks SOME X per-pattern ; LBIST tolerates essentially NONE -> X-BOUND at the source.
# Unstable signature (varies run-to-run on a good part) = an UNBOUNDED X-source reaching the MISR (not aliasing, 9.3).

7. Industry Flow — X-bounding makes the signature valid

X-bounding is a prerequisite for a meaningful LBIST signature:

8. Debugging Session — an unstable (X) signature

9. Common Mistakes

• Underestimating LBIST's X-intolerance. One X ruins the whole signature — far stricter than compression (7.4).
• Relying on X-masking. It costs coverage and can't save a signature from all X — X-bound at the source.
• Leaving memories live in LBIST. A memory is a major X-source — bypass/initialize it (8.6).
• Confusing an unstable signature with aliasing. Unstable/run-to-run = X; aliasing (9.3) is deterministic.
• Forgetting to recompute golden on the X-free design. Golden must reflect the bounded design (9.2).

10. Industry Best Practices

• Eliminate X-sources at the source (tie/init/scan/bypass) — the primary LBIST X strategy.
• Bypass/initialize memories in LBIST mode (MBIST tests them, Chapter 8).
• Verify X-free in LBIST mode by simulation — no X reaches the MISR.
• Use X-masking sparingly (fallback; costs coverage) — never as the main strategy.
• Recompute golden on the X-free design; treat an unstable signature as an X-source bug.

11. Senior Engineer Thinking

• Beginner: "The LBIST signature changes every run — the tool or the part is flaky."
• Senior: "An unstable signature on a good part is an unbounded X-source reaching the MISR — and because the MISR accumulates via feedback, one X ruins the whole signature; an uninitialized flop makes it non-deterministic run-to-run. I X-bound the source — initialize/scan/bypass — so no X hits the MISR, verify X-free in LBIST mode, and recompute golden. Masking is a last resort — LBIST can't tolerate X."

The senior reads an unstable signature as an X-source (not aliasing) and eliminates X at the source.

12. Silicon Impact

X-handling is the make-or-break discipline in LBIST, because the MISR's accumulating feedback makes LBIST categorically less X-tolerant than any other structural test: where compression (7.4) suffers an X in one pattern and can mask it, LBIST's single accumulated signature is destroyed by one X anywhere — the X propagates through the feedback into every subsequent bit, so the whole run is invalid and cannot be compared to golden. That severity flips the strategy: in compression, X-masking is a workable per-pattern tool; in LBIST, the emphasis must be on X-bounding at the source — making every X-source deterministic (tie, initialize, scan, or bypass — memories bypassed exactly as in MBIST, 8.6) so the design is X-free in LBIST mode and no X ever reaches the MISR. The diagnostic fingerprint is worth memorizing: an unstable, run-to-run-varying signature on a known-good part is not a fault and not aliasing (which is deterministic, 9.3) — it is the signature of an unbounded X-source, most often an uninitialized flop or an un-bypassed memory, and it means the LBIST run is meaningless until the X is bounded. For the RTL/DV engineer, this elevates X-source elimination to a first-class design requirement — initialize your state, avoid uninitialized/non-scan logic, bypass memories in LBIST mode — stricter than what ATPG demands, and owned by the design, not a tool setting. And the stakes are high because LBIST's whole reason for existing is in-field/safety self-test (9.5): a safety part relies on the LBIST signature to declare itself healthy at power-on and periodically, so a valid, stable, X-free signature is a safety requirement, not merely a bring-up nicety. Get X-bounding right and the mini-SoC's LBIST produces a trustworthy signature; get it wrong and the self-test is worse than useless — it can look like it passed on a run whose signature was never valid.

13. Engineering Checklist

• Enumerated all X-sources (uninit flops, non-scan, memories, analog, multi-cycle, bus contention).
• X-bounded each in LBIST mode (tie/init/scan/bypass; memories per 8.6) → deterministic.
• Verified X-free in LBIST mode (no X reaches the MISR) by simulation.
• Used X-masking only as a sparing fallback (costs coverage).
• Recomputed golden on the X-free design; treated an unstable signature as an X-source bug (not aliasing).

14. Try Yourself

1. Explain, using the MISR's feedback, why one X corrupts the entire signature.
2. Contrast LBIST (one X ruins all) with compression (7.4: one X corrupts one maskable pattern).
3. For an uninitialized flop and an un-bypassed memory, apply X-bounding (init/scan/bypass).
4. Distinguish an unstable/X signature (X-source) from aliasing (deterministic, 9.3).
5. Verify the design is X-free in LBIST mode and explain why the golden must be recomputed.

The reasoning is tool-neutral. Real X-analysis comes from the LBIST/DFT flow. No paid tool required to reason about X-bounding.

15. Interview Perspective

• Weak: "You mask X values in LBIST like in compression."
• Good: "The MISR accumulates, so an X spreads through the signature; you have to bound X-sources so none reaches it."
• Senior: "LBIST is far stricter on X than compression. The MISR accumulates via feedback, so XOR(·, X) = X propagates into every subsequent signature bit — one X anywhere ruins the whole signature and invalidates the run (you can't compare to golden). Compression (7.4) only loses one maskable pattern; LBIST loses everything. So the strategy is X-bounding — make every X-source deterministic in LBIST mode: initialize/tie uninitialized logic, scan non-scan flops, bypass/initialize memories (as in MBIST, 8.6), control multi-cycle paths, resolve bus contention — so no X reaches the MISR. X-masking is a sparing fallback (it costs coverage). And the tell: an unstable, run-to-run-varying signature on a good part is an unbounded X-source (an uninitialized flop's random power-up), not aliasing (which is deterministic). Fix it at the source."

16. Interview / Review Questions

17. Key Takeaways

• The MISR accumulates responses through feedback, so a single X entering it corrupts the entire signature (XOR with X propagates into every subsequent bit) — the whole LBIST run is invalid (can't compare to golden).
• This makes LBIST far stricter on X than compression (7.4): compression loses one maskable pattern, LBIST loses everything — LBIST's X-tolerance is essentially zero.
• The remedy is X-bounding — make every X-source deterministic in LBIST mode: tie/initialize uninitialized logic, scan non-scan flops, bypass/initialize memories (as in MBIST, 8.6), control multi-cycle paths, resolve bus contention — so no X reaches the MISR (X-free in LBIST mode).
• X-masking is a sparing fallback (it costs coverage, 7.4) — LBIST can't afford any X, so the emphasis is elimination at the source, not masking after the fact.
• An unstable, run-to-run-varying signature on a known-good part is the fingerprint of an unbounded X-source (e.g. an uninitialized flop) — not aliasing (which is deterministic, 9.3) — and a valid, X-free signature is a safety requirement for the in-field self-test of 9.5. Next: 9.5 — LBIST for in-field & safety test.

18. Quick Revision

X-handling & X-bounding in LBIST. The MISR ACCUMULATES via feedback → XOR(·, X) = X propagates into EVERY subsequent bit → ONE X corrupts the WHOLE signature → entire run INVALID (can't compare to golden). Far stricter than compression (7.4: one X = one maskable pattern; LBIST: one X = everything). Fix = X-BOUNDING: make EVERY X-source (uninit flops, non-scan, MEMORIES→bypass/init 8.6, analog, multi-cycle, bus contention) deterministic in LBIST mode (tie/init/scan/bypass) → no X reaches the MISR → design is X-free in LBIST mode. X-masking = sparing fallback (costs coverage). Unstable signature (varies run-to-run on a good part) = unbounded X-source (NOT aliasing, which is deterministic 9.3) → fix at the source, recompute golden. Valid signature = a SAFETY requirement (9.5). Next: 9.5 — LBIST for in-field & safety test.