LeadingDigitAnticipate constructor

LeadingDigitAnticipate(
  1. Logic a,
  2. Logic b, {
  3. String name = 'leading_digit_anticipate',
  4. String? definitionName,
})

Construct a leading-digit anticipate module that predicts the number of leading digits in the sum of a and b.

  • Outputs leadingDigit which is the position of the first digit change (leading 1 position for positive sum, leading 0 position for negative sum).

Implementation

LeadingDigitAnticipate(Logic a, Logic b,
    {super.name = 'leading_digit_anticipate', String? definitionName})
    : super(definitionName: definitionName ?? 'LeadingDigitAnticipate') {
  a = addInput('a', a, width: a.width);
  b = addInput('b', b, width: b.width);
  final pA = a.reversed.named('revA');
  final pB = b.reversed.named('revB');
  final g = (pA & pB).named('g');
  final t = (pA ^ pB).named('t');
  final z = (~pA & ~pB).named('z');

  final zBarShift = (~z >>> 1).named('zBarShift');
  final gBarShift = (~g >>> 1).named('gBarShift');
  final tShift = (t << 1).named('tShift');
  final tBarShift = (~t << 1).named('tBarShift');

  final findFromMSB = Logic(name: 'findFromMSB', width: t.width - 1);
  final lowBits = (tShift & ((g & zBarShift) | (z & gBarShift)) |
          tBarShift & ((z & zBarShift) | (g & gBarShift)))
      .named('lowBitsWide')
      .slice(t.width - 2, 1);

  findFromMSB <= [lowBits, ~t[0] & t[1]].swizzle();

  final leadingEncoder = RecursiveModulePriorityEncoder(findFromMSB,
      generateValid: true, name: 'leading-pos');
  final leadingPos = leadingEncoder.out;
  final validLead = leadingEncoder.valid!;

  addOutput('leadingDigit', width: log2Ceil(findFromMSB.width + 1)) <=
      leadingPos;
  addOutput('validLeadDigit') <= validLead;
}