The Negative Number That Was Not Smaller

Where the interviewer goes next. Open a node to practise that follow-up.

WhyWhat IfProve ItBreak ItCompare

1. The Negative Number That Was Not Smaller
2. WhyWhy the Operands Decide SignednessL1 JuniorL2 Mid-Level

   Why did the language designers make signedness depend only on the operands, not on where the result goes?

   Reveal the Model Answer

   The standard evaluates an expression in two steps. First, the operands fix the width and signedness of each part. Then the operands are extended to that size. Keeping the result target out of the first pass means one expression has one meaning wherever it appears. The price is the trap you just saw, so the rule is to make operands agree.

   Self-Check

   Tick each key point you covered in your answer.

   Key point 1 The standard evaluates an expression in two steps. Key point 2 First, the operands fix the width and signedness of each part. Key point 3 Then the operands are extended to that size. Key point 4 Keeping the result target out of the first pass means one expression has one meaning wherever it appears. Key point 5 The price is the trap you just saw, so the rule is to make operands agree.

   Half-Truth

   "Signed arithmetic only matters for division."

   It also changes comparisons, right shifts with >>> and sign extension when a narrow value is widened.

   Source IEEE 1800-2017 §11.4.10

   • Lesson 1.4Enums, Typedef and Casting
3. What IfA Negative Literal Next to an Unsigned VectorL1 JuniorL2 Mid-Level

   What if you write a < -1 with a declared logic [7:0]?

   Reveal the Model Answer

   One unsigned operand makes the whole comparison unsigned. Both sides are sized to 32 bits, the width of the literal. So -1 becomes 32'hFFFF_FFFF, and a < -1 is true for every 8-bit a. Make the unsigned side signed and wide enough, as in int'(a) < -1.

   Self-Check

   Tick each key point you covered in your answer.

   Key point 1 One unsigned operand makes the whole comparison unsigned. Key point 2 Both sides are sized to 32 bits, the width of the literal. Key point 3 So -1 becomes 32'hFFFF_FFFF, and a < -1 is true for every 8-bit a. Key point 4 Make the unsigned side signed and wide enough, as in int'(a) < -1.

   Misconception

   "A negative literal keeps the comparison signed."

   Signed arithmetic needs every operand to be signed. One unsigned vector turns the whole comparison unsigned.

   Source IEEE 1800-2017 §11.8.1

   • Lesson 1.4Enums, Typedef and Casting
   • Problem 1.4.1Safe Opcode Decoder
4. CompareSigned Cast vs Widening FirstL1 JuniorL2 Mid-Level

   Compare fixing the comparison with $signed(u) and with $signed({1'b0, u}). When do they differ?

   Reveal the Model Answer

   $signed(u) reinterprets the same 8 bits, so any value of 128 or more becomes negative: 200 turns into -56. $signed({1'b0, u}) first adds a zero sign bit, so 200 stays 200 as a 9-bit signed value. They agree for small values, which is why the plain cast passes a quick test and fails in the field.

   Expression	Bits	Value	s < it, with s = -1
   $signed(u)	1100_1000	-56	0
   $signed({1'b0, u})	0_1100_1000	200	1

   The values are the output of the run on this question.

   RUNIcarus Verilog · in your browser

   Edit the code, then run it

   OutputWaves

   RunReset codeExpected: $signed(u) = -56, so s < $signed(u) is 0 $signed({1'b0,u}) = 200, so s < it is 1

   Self-Check

   Tick each key point you covered in your answer.

   Key point 1 $signed(u) reinterprets the same 8 bits, so any value of 128 or more becomes negative: 200 turns into -56. Key point 2 $signed({1'b0, u}) first adds a zero sign bit, so 200 stays 200 as a 9-bit signed value. Key point 3 They agree for small values, which is why the plain cast passes a quick test and fails in the field.

   Misconception

   "$signed makes the value signed without changing it."

   It keeps the bits, not the value. For the top half of the unsigned range those bits mean a negative number.

   Source IEEE 1800-2017 §11.7

   • Lesson 1.4Enums, Typedef and Casting
5. Break ItThe Down-Counter That Never StoppedL1 Junior

   A test hangs in this loop. What is wrong?

   for (bit [3:0] i = 3; i >= 0; i--) begin
     drive_lane(i);
   end

   Reveal the Model Answer

   An unsigned counter is never below zero, so i >= 0 is always true; after 0 it wraps to 15 and keeps going. Use a signed loop variable such as int, or count up.

   Self-Check

   Tick each key point you covered in your answer.

   Key point 1 An unsigned counter is never below zero, so i >= 0 is always true; after 0 it wraps to 15 and keeps going. Key point 2 Use a signed loop variable such as int, or count up.

   Misconception

   "The loop runs four times and stops at 0."

   The twin guards the loop at 20 passes; it hits the guard with the 4-bit counter and runs exactly four times with int.

   Run It

   A 4-bit unsigned down-counter with a guard so the run ends.

   RUNVerilator · simulator service

   Edit the code, then run it

   OutputWaves

   RunReset codeExpected: iterations=21 FAIL: an unsigned counter is never below 0, so i >= 0 is always true

   See the Fix

   module tb;
     int iters = 0;
     initial begin
       // Visit 3, 2, 1, 0 with a 4-bit counter.
       for (int i = 3; i >= 0; i--) begin
         iters++;
         if (iters > 20) break;  // guard, so the run ends
       end
       $display("iterations=%0d", iters);
       if (iters > 4) $display("FAIL: an unsigned counter is never below 0, so i >= 0 is always true");
       else $display("PASS: the loop ran four times");
     end
   endmodule
   

   Prints: iterations=4 PASS: the loop ran four times

   • Lesson 1.4Enums, Typedef and Casting
6. Prove ItSolve 1.4.1: Safe Opcode DecoderSimulator-graded

   Show it, don't just say it: this Silicon Lab problem is graded by the simulator.

   Open Problem 1.4.1