Subtractor design in Verilog - Deep Dive

Overview - Subtractor design

What is it?

A subtractor is a digital circuit that calculates the difference between two binary numbers. It outputs the result of subtracting one number from another, often producing a borrow signal if the subtraction requires borrowing. In Verilog, subtractors are designed using logic gates or arithmetic operators to perform this operation on bits or multi-bit numbers. This design is fundamental in digital electronics and computer arithmetic.

Why it matters

Subtraction is a core arithmetic operation used in countless digital systems, from simple calculators to complex processors. Without subtractors, computers couldn't perform tasks like comparing numbers, calculating differences, or executing algorithms that rely on subtraction. Designing efficient subtractors ensures faster and more reliable hardware performance, impacting everything from embedded devices to high-speed computing.

Where it fits

Before learning subtractor design, you should understand basic binary numbers, logic gates, and Verilog syntax. After mastering subtractors, you can explore more complex arithmetic circuits like adders, multipliers, and arithmetic logic units (ALUs). This topic builds foundational skills for digital system design and hardware description languages.

Mental Model

Core Idea

A subtractor circuit takes two binary inputs and produces their difference along with a borrow signal if needed, just like borrowing in decimal subtraction.

Think of it like...

Imagine subtracting apples: if you don't have enough apples in one basket, you borrow from a neighbor's basket to complete the subtraction. The borrow signal in a subtractor is like asking for apples from your neighbor to finish the calculation.

  ┌─────────────┐       ┌─────────────┐
  │  Input A    │       │  Input B    │
  └─────┬───────┘       └─────┬───────┘
        │                     │
        │                     │
        │      ┌──────────────┴─────────────┐
        └─────▶│      Subtractor Circuit     │
               └──────────────┬─────────────┘
                              │
                ┌─────────────┴─────────────┐
                │  Difference (A - B) Output │
                └─────────────┬─────────────┘
                              │
                ┌─────────────┴─────────────┐
                │ Borrow Output (if needed)  │
                └────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Binary Subtraction Basics

Concept: Learn how subtraction works with binary digits and the role of borrow.

Binary subtraction works like decimal subtraction but with only two digits: 0 and 1. When subtracting 1 from 0, you need to borrow 1 from the next higher bit, turning the 0 into 2 (binary 10) before subtracting. This borrow process is essential to get the correct result.

Result

You understand how borrowing works in binary subtraction and why it is necessary.

Understanding borrowing in binary is crucial because it directly affects how subtractor circuits handle bit differences and borrow signals.

2

Foundation

Verilog Syntax for Basic Subtraction

Concept: Learn how to write simple subtraction expressions in Verilog.

In Verilog, you can subtract two numbers using the '-' operator. For example, 'assign diff = a - b;' subtracts b from a. This works for multi-bit vectors and automatically handles borrow internally at the hardware level.

Result

You can write a simple subtractor in Verilog using arithmetic operators.

Knowing Verilog's built-in subtraction operator helps you quickly implement subtractors before diving into gate-level design.

3

Intermediate

Designing a 1-bit Full Subtractor

🤔Before reading on: do you think a 1-bit subtractor needs to consider previous borrows? Commit to your answer.

Concept: A 1-bit full subtractor takes two bits and a borrow-in to produce a difference and borrow-out.

A 1-bit full subtractor has three inputs: minuend bit (A), subtrahend bit (B), and borrow-in (Bin). It outputs the difference bit and borrow-out (Bout). The difference is A XOR B XOR Bin. The borrow-out is (NOT A AND B) OR (Bin AND (NOT A XOR B)). This logic ensures correct subtraction with borrow chaining.

Result

You can build a 1-bit full subtractor circuit that handles borrow-in and borrow-out correctly.

Understanding the borrow-in and borrow-out logic is key to chaining subtractors for multi-bit subtraction.

4

Intermediate

Building Multi-bit Subtractors by Chaining

🤔Before reading on: do you think multi-bit subtractors can subtract all bits independently? Commit to your answer.

Concept: Multi-bit subtractors are built by connecting multiple 1-bit full subtractors in series, passing borrow signals between them.

To subtract multi-bit numbers, chain 1-bit full subtractors from least significant bit (LSB) to most significant bit (MSB). The borrow-out of one bit becomes the borrow-in of the next. This ripple borrow approach ensures correct subtraction across all bits.

Result

You understand how to design multi-bit subtractors by connecting 1-bit subtractors with borrow signals.

Knowing how borrow ripples through bits helps you design scalable subtractors for any bit width.

5

Intermediate

Implementing Subtractor Using Verilog Modules

Concept: Learn to write reusable Verilog modules for 1-bit and multi-bit subtractors.

Create a Verilog module for a 1-bit full subtractor with inputs A, B, Bin and outputs Diff, Bout. Then create a multi-bit subtractor module that instantiates multiple 1-bit subtractors, connecting borrow signals between them. This modular design improves code clarity and reuse.

Result

You can write clean, reusable Verilog code for subtractors of any size.

Modular design in Verilog mirrors hardware structure and makes complex circuits manageable.

6

Advanced

Optimizing Subtractor with Borrow Lookahead

🤔Before reading on: do you think borrow signals must ripple through all bits sequentially? Commit to your answer.

Concept: Borrow lookahead reduces delay by calculating borrow signals in advance instead of waiting for ripple propagation.

Borrow lookahead logic uses generate and propagate signals to compute borrow outputs faster. This reduces the time delay caused by waiting for borrow to ripple through each bit. Implementing borrow lookahead improves subtractor speed in high-performance circuits.

Result

You understand how to speed up subtractors by predicting borrow signals ahead of time.

Knowing borrow lookahead techniques is essential for designing fast arithmetic units in modern processors.

7

Expert

Exploring Subtractor Internals and Hardware Mapping

🤔Before reading on: do you think Verilog subtraction always maps to the same hardware? Commit to your answer.

Concept: Verilog subtraction can be synthesized into different hardware structures depending on the design and synthesis tool optimizations.

At the hardware level, subtractors can be implemented using adders with two's complement, dedicated subtractor circuits, or optimized arithmetic blocks in FPGAs/ASICs. Understanding how synthesis tools map Verilog code to hardware helps optimize performance and resource usage.

Result

You gain insight into how subtractors are realized physically and how code affects hardware.

Understanding synthesis and hardware mapping allows you to write Verilog that leads to efficient real-world circuits.

Under the Hood

Subtractor circuits operate by comparing bits of two numbers and managing borrow signals that indicate when a higher bit must lend value to a lower bit. Internally, a 1-bit full subtractor uses XOR gates for difference calculation and AND/OR gates for borrow logic. Multi-bit subtractors chain these units, passing borrow signals sequentially. At the hardware level, subtractors often use two's complement addition internally, converting subtraction into addition of a negated number, which simplifies circuit design.

Why designed this way?

Subtractor design evolved to reuse adder circuits by leveraging two's complement representation, reducing hardware complexity. Early designs used explicit borrow logic, but modern synthesis tools optimize subtraction by transforming it into addition, which is faster and uses fewer gates. This design choice balances simplicity, speed, and resource use, making subtractors efficient and scalable.

  Inputs: A[n:0], B[n:0]
       │          │
       ▼          ▼
  ┌───────────────┐
  │  Two's        │
  │  Complement   │
  │  Converter    │
  └──────┬────────┘
         │
         ▼
  ┌───────────────┐
  │  Adder Circuit│
  └──────┬────────┘
         │
         ▼
  Outputs: Difference[n:0], Borrow Out

Alternatively:

  ┌───────────────┐
  │  1-bit Full   │
  │  Subtractor   │
  ├───────────────┤
  │  Difference   │
  │  Borrow Out   │
  └──────┬────────┘
         │
  Borrow In passed to next bit subtractor
         ▼
  Repeat for all bits

Myth Busters - 3 Common Misconceptions

Quick: Does subtracting B from A always produce a positive result? Commit to yes or no.

Common Belief: Subtracting B from A always gives a positive or zero result.

Reality: If B is greater than A, the subtraction results in a negative number represented in two's complement form, often indicated by a borrow out or sign bit.

Why it matters: Assuming subtraction always yields positive results can cause errors in interpreting outputs, leading to incorrect calculations or logic failures.

Quick: Do you think the borrow signal in subtraction is the same as the carry signal in addition? Commit to yes or no.

Common Belief: Borrow and carry signals are the same and behave identically.

Reality: Borrow and carry signals represent different conditions; borrow indicates a need to borrow from a higher bit in subtraction, while carry indicates an overflow in addition. Their logic and propagation differ.

Why it matters: Confusing borrow with carry can cause incorrect circuit design and unexpected behavior in arithmetic operations.

Quick: Is it true that Verilog's '-' operator always creates a dedicated subtractor circuit? Commit to yes or no.

Common Belief: Using '-' in Verilog always synthesizes a dedicated subtractor hardware block.

Reality: Most synthesis tools implement subtraction by adding the two's complement of the subtrahend, reusing adder hardware instead of separate subtractor circuits.

Why it matters: Misunderstanding synthesis can lead to inefficient designs or incorrect assumptions about hardware resource usage.

Expert Zone

1

Borrow lookahead logic can be combined with carry lookahead adders to create unified fast arithmetic units.

2

In FPGA implementations, dedicated arithmetic blocks often optimize subtraction internally, making manual borrow logic less critical.

3

Signed and unsigned subtraction differ in interpretation of borrow and overflow, requiring careful design for correct results.

When NOT to use

Explicit borrow ripple subtractors are slow for wide bit widths; use borrow lookahead or two's complement addition instead. For very high-speed designs, consider specialized arithmetic IP cores or hardware multipliers with subtraction capabilities.

Production Patterns

In real-world designs, subtractors are often implemented as part of ALUs using two's complement addition. Designers use parameterized Verilog modules for flexible bit widths and rely on synthesis tool optimizations. Borrow lookahead is used in performance-critical processors, while simple ripple borrow subtractors appear in low-power or small-area designs.

Connections

Two's Complement Arithmetic

Subtraction is implemented using two's complement addition internally.

Understanding two's complement arithmetic clarifies why subtractors often reuse adder circuits, simplifying hardware design.

Ripple Carry Adder

Ripple borrow subtractors chain borrow signals like ripple carry adders chain carry signals.

Knowing ripple carry adders helps grasp how borrow signals propagate in subtractors and why lookahead improves speed.

Bank Loan System (Finance)

Borrow signals in subtraction are conceptually similar to borrowing money when funds are insufficient.

Recognizing borrow as a temporary loan helps understand why subtraction circuits must track and propagate borrow signals carefully.

Common Pitfalls

#1 Ignoring borrow-in when designing multi-bit subtractors.

Wrong approach:

module subtractor_4bit(input [3:0] A, B, output [3:0] Diff);
assign Diff = A - B;
endmodule

Correct approach:

module full_subtractor(input A, B, Bin, output Diff, Bout);
assign Diff = A ^ B ^ Bin;
assign Bout = (~A & B) | (Bin & (~A ^ B));
endmodule

module subtractor_4bit(input [3:0] A, B, output [3:0] Diff);
wire b1, b2, b3;
full_subtractor fs0(A[0], B[0], 1'b0, Diff[0], b1);
full_subtractor fs1(A[1], B[1], b1, Diff[1], b2);
full_subtractor fs2(A[2], B[2], b2, Diff[2], b3);
full_subtractor fs3(A[3], B[3], b3, Diff[3], );
endmodule

Root cause:

Misunderstanding that borrow-in affects each bit's subtraction leads to incorrect multi-bit subtractor design.

#2 Confusing borrow output with difference bit in 1-bit subtractor.

Wrong approach:

assign Diff = (~A & B); // Incorrect difference calculation

Correct approach:

assign Diff = A ^ B ^ Bin; // Correct difference calculation

Root cause:

Mixing borrow logic with difference logic causes wrong output values.

Key Takeaways

Subtractor circuits compute the difference between binary numbers and manage borrow signals similar to borrowing in decimal subtraction.

A 1-bit full subtractor handles inputs and borrow-in to produce difference and borrow-out, enabling multi-bit subtraction by chaining.

Verilog allows simple subtraction using the '-' operator, but understanding underlying borrow logic is essential for custom designs.

Borrow lookahead techniques improve subtractor speed by reducing sequential borrow propagation delays.

Subtraction is often implemented using two's complement addition internally, which simplifies hardware and leverages existing adder circuits.

Practice

1.

What is the main function of a subtractor in digital circuits?

easy

A. To multiply two binary numbers

B. To add two binary numbers

C. To find the difference between two binary numbers

D. To store binary data

Solution

1. Step 1: Understand the subtractor's purpose

   A subtractor is designed to calculate the difference between two binary inputs.

2. Step 2: Compare with other operations

   Adders add, multipliers multiply, and storage units store data, so these are not subtractors.

3. Final Answer:

   To find the difference between two binary numbers -> Option C

4. Quick Check:

   Subtractor = Difference finder [OK]

Hint: Subtractor always calculates difference, not sum or product [OK]

Common Mistakes:

• Confusing subtractor with adder
• Thinking subtractor stores data
• Mixing subtractor with multiplier

2.

Which of the following is the correct Verilog module header for a 1-bit subtractor?

module subtractor(

easy

A. module subtractor(input a, input b, output diff, output borrow);

B. module subtractor(input a, b, output diff, borrow);

C. module subtractor(a, b, diff, borrow);

D. module subtractor(input a, input b, input diff, output borrow);

Solution

1. Step 1: Check correct input/output declaration

   Inputs must be declared with 'input' keyword and outputs with 'output'.

2. Step 2: Verify syntax correctness

   module subtractor(input a, input b, output diff, output borrow); correctly declares inputs and outputs with proper keywords and commas.

3. Final Answer:

   module subtractor(input a, input b, output diff, output borrow); -> Option A

4. Quick Check:

   Correct input/output syntax = module subtractor(input a, input b, output diff, output borrow); [OK]

Hint: Always declare inputs and outputs explicitly with keywords [OK]

Common Mistakes:

• Omitting input/output keywords
• Listing inputs and outputs without keywords
• Declaring outputs as inputs

3.

What is the output difference and borrow when inputs a=1 and b=0 are applied to this 1-bit subtractor module?

assign diff = a ^ b ^ borrow_in;
assign borrow_out = (~a & b) | (borrow_in & (~a ^ b));

Assume borrow_in = 0.

medium

A. diff = 0, borrow_out = 0

B. diff = 0, borrow_out = 1

C. diff = 1, borrow_out = 1

D. diff = 1, borrow_out = 0

Solution

1. Step 1: Calculate diff with given inputs

   diff = a ^ b ^ borrow_in = 1 ^ 0 ^ 0 = 1

2. Step 2: Calculate borrow_out with given inputs

   borrow_out = (~a & b) | (borrow_in & (~a ^ b)) = (0 & 0) | (0 & (0 ^ 0)) = 0

3. Final Answer:

   diff = 1, borrow_out = 0 -> Option D

4. Quick Check:

   1 - 0 = 1, no borrow needed [OK]

Hint: XOR inputs and borrow_in for diff; borrow if a < b [OK]

Common Mistakes:

• Forgetting borrow_in in diff calculation
• Misapplying borrow logic
• Mixing up a and b in borrow expression

4.

Identify the error in this Verilog code for a 1-bit subtractor:

module subtractor(input a, input b, output diff, output borrow);
  assign diff = a - b;
  assign borrow = (b > a);
endmodule

medium

A. Using '-' operator for bitwise subtraction is incorrect in Verilog

B. 'borrow' should be declared as 'output reg' instead of 'output'

C. The module lacks a clock input for synchronous operation

D. The borrow calculation logic is incorrect

Solution

1. Step 1: Check arithmetic operator usage

   Verilog '-' operator performs arithmetic subtraction but does not produce borrow output directly.

2. Step 2: Understand borrow signal generation

   Borrow must be calculated using logic expressions, not by comparing b and a with '>' operator.

3. Final Answer:

   Using '-' operator for bitwise subtraction is incorrect in Verilog -> Option A

4. Quick Check:

   Subtractor needs logic for borrow, not '-' operator [OK]

Hint: Use logic expressions for borrow, not '-' operator [OK]

Common Mistakes:

• Using arithmetic '-' expecting borrow output
• Ignoring borrow logic
• Assuming '>' operator works for borrow

5.

Design a 2-bit subtractor using two 1-bit subtractor modules connected in series. Which of the following correctly describes the borrow connection?

hard

A. The borrow input of the least significant bit subtractor connects to the borrow output of the most significant bit subtractor

B. The borrow output of the least significant bit subtractor connects to the borrow input of the most significant bit subtractor

C. The borrow outputs of both subtractors are connected together to form a single borrow output

D. The borrow inputs of both subtractors are tied to 0

Solution

1. Step 1: Understand borrow chaining in multi-bit subtractors

   Borrow from the lower bit subtractor must feed into the higher bit subtractor's borrow input.

2. Step 2: Verify connection direction

   The least significant bit's borrow output connects to the most significant bit's borrow input to propagate borrow correctly.

3. Final Answer:

   The borrow output of the least significant bit subtractor connects to the borrow input of the most significant bit subtractor -> Option B

4. Quick Check:

   Borrow chains from LSB to MSB [OK]

Hint: Borrow flows from lower to higher bits in subtractors [OK]

Common Mistakes:

• Connecting borrow inputs to zero for all bits
• Connecting borrow outputs together incorrectly
• Reversing borrow input/output connections