Beginning Logic Design – Part 7

Hello and welcome to Part 7 of my Beginning Logic Design series. In this post I will continue to add functionality to the ALU I’ve been working on in the last couple posts.

Using Vivado Via Command Line

This ALU project is making decent progress and I’d like to start managing the code with Git and make my work flow a bit faster. When I talk to engineers that work with FPGAs for a living, it seems like most of them do not use the project flow that I’ve been working with. They favor the command line or batch mode approach.

I’ll first copy my alu.sv and top.sv to a new directory so that those files are all I have. To build and test on the command line there are 3 commands I’ll use, xvlog to parse my SystemVerilog, xelab to elaborate the design, and xsim to run the simulation.

  1. xvlog --sv alu.sv top.sv
  2. xelab top
  3. xsim -R top
xvlog --sv alu.sv top.sv
xelab top
xsim -R top

Armed with these commands, I can more easily write my code in whichever editor I choose!

I’ll use this Makefile to give me an easy way to test and clean up the built files and logs.

  1. XVLOG_FILES=xvlog.log xvlog.pb xsim.dir
  2. XELAB_FILES=webtalk*.log webtalk*.jou xelab.log xelab.pb .Xil/
  3. XSIM_FILES=xsim*.log xsim*.jou
  5. all:
  6. @echo "Parsing HDL"
  7. @xvlog --sv *.sv > build.log
  8. @echo "Elaborating design"
  9. @xelab top >> build.log
  10. @echo "Starting simulation"
  11. @xsim -R top
  13. clean:
  14. rm -rf $(XVLOG_FILES) $(XELAB_FILES) $(XSIM_FILES) build.log
XVLOG_FILES=xvlog.log xvlog.pb xsim.dir
XELAB_FILES=webtalk*.log webtalk*.jou xelab.log xelab.pb .Xil/
XSIM_FILES=xsim*.log xsim*.jou

all:
  @echo "Parsing HDL"
  @xvlog --sv *.sv > build.log
  @echo "Elaborating design"
  @xelab top >> build.log
  @echo "Starting simulation"
  @xsim -R top

clean:
  rm -rf $(XVLOG_FILES) $(XELAB_FILES) $(XSIM_FILES) build.log



Implementing Subtraction

Subtraction in binary is nearly identical to addition. In the case of subtraction, carry is looked at as a borrow value. Building a subtraction operation in SystemVerilog is the same as addition, but with - instead of +.

  1. // Subtract operation internals
  2. logic [7:0] subtract;
  3. logic [6:0] subtract_lower_bits;
  4. logic subtract_borrow_6;
  5. logic subtract_borrow_7;
  7. ...
  9. assign {subtract_borrow_6, subtract_lower_bits} = a[6:0] - b[6:0] - carry_in,
  10. {subtract_borrow_7, subtract} = a - b - carry_in;
  12. ...
  14. SUBTRACT: begin
  15. y <= subtract;
  16. carry_out <= subtract_borrow_7;
  17. sign <= subtract[7];
  18. overflow <= subtract_borrow_7 ^ subtract_borrow_6;
  19. if (subtract == 0)
  20. zero <= 1;
  21. else
  22. zero <= 0;
  23. end
// Subtract operation internals
logic [7:0] subtract;
logic [6:0] subtract_lower_bits;
logic subtract_borrow_6;
logic subtract_borrow_7;

...

assign {subtract_borrow_6, subtract_lower_bits} = a[6:0] - b[6:0] - carry_in,
    {subtract_borrow_7, subtract} = a - b - carry_in;

...

        SUBTRACT: begin
            y <= subtract;
            carry_out <= subtract_borrow_7;
            sign <= subtract[7];
            overflow <= subtract_borrow_7 ^ subtract_borrow_6;
            if (subtract == 0)
                zero <= 1;
            else
                zero <= 0;
        end

As with the addition, I’ll make some tests that validate I’m getting the results I expect from the operation.

  1. // Test 100 - 80
  2. operation = SUBTRACT;
  3. a = 100;
  4. b = 80;
  5. #2 assert(y == 20) else $error("Subtract assertion failed.");
  6. assert(zero == 0) else $error("Zero assertion failed.");
  7. assert(sign == 0) else $error("Sign assertion failed.");
  8. assert(carry_out == 0) else $error("Carry assertion failed.");
  9. assert(overflow == 0) else $error("Overflow assertion failed.");
  11. // Test 80 - 100
  12. a = 80;
  13. b = 100;
  14. #2 assert(y == 236) else $error("Subtract assertion failed.");
  15. assert(zero == 0) else $error("Zero assertion failed.");
  16. assert(sign == 1) else $error("Sign assertion failed.");
  17. assert(carry_out == 1) else $error("Carry assertion failed.");
  18. assert(overflow == 0) else $error("Overflow assertion failed.");
  20. // Test 80 - 176
  21. a = 80;
  22. b = 176;
  23. #2 assert(y == 160) else $error("Subtract assertion failed.");
  24. assert(zero == 0) else $error("Zero assertion failed.");
  25. assert(sign == 1) else $error("Sign assertion failed.");
  26. assert(carry_out == 1) else $error("Carry assertion failed.");
  27. assert(overflow == 1) else $error("Overflow assertion failed.");
  29. // Test 208 - 112
  30. a = 208;
  31. b = 112;
  32. #2 assert(y == 96) else $error("Subtract assertion failed.");
  33. assert(zero == 0) else $error("Zero assertion failed.");
  34. assert(sign == 0) else $error("Sign assertion failed.");
  35. assert(carry_out == 0) else $error("Carry assertion failed.");
  36. assert(overflow == 1) else $error("Overflow assertion failed.");
  38. // Test 208 - 208
  39. a = 208;
  40. b = 208;
  41. #2 assert(y == 0) else $error("Subtract assertion failed.");
  42. assert(zero == 1) else $error("Zero assertion failed.");
  43. assert(sign == 0) else $error("Sign assertion failed.");
  44. assert(carry_out == 0) else $error("Carry assertion failed.");
  45. assert(overflow == 0) else $error("Overflow assertion failed.");
// Test 100 - 80
operation = SUBTRACT;
a = 100;
b = 80;
#2 assert(y == 20) else $error("Subtract assertion failed.");
assert(zero == 0) else $error("Zero assertion failed.");
assert(sign == 0) else $error("Sign assertion failed.");
assert(carry_out == 0) else $error("Carry assertion failed.");
assert(overflow == 0) else $error("Overflow assertion failed.");

// Test 80 - 100
a = 80;
b = 100;
#2 assert(y == 236) else $error("Subtract assertion failed.");
assert(zero == 0) else $error("Zero assertion failed.");
assert(sign == 1) else $error("Sign assertion failed.");
assert(carry_out == 1) else $error("Carry assertion failed.");
assert(overflow == 0) else $error("Overflow assertion failed.");

// Test 80 - 176
a = 80;
b = 176;
#2 assert(y == 160) else $error("Subtract assertion failed.");
assert(zero == 0) else $error("Zero assertion failed.");
assert(sign == 1) else $error("Sign assertion failed.");
assert(carry_out == 1) else $error("Carry assertion failed.");
assert(overflow == 1) else $error("Overflow assertion failed.");

// Test 208 - 112
a = 208;
b = 112;
#2 assert(y == 96) else $error("Subtract assertion failed.");
assert(zero == 0) else $error("Zero assertion failed.");
assert(sign == 0) else $error("Sign assertion failed.");
assert(carry_out == 0) else $error("Carry assertion failed.");
assert(overflow == 1) else $error("Overflow assertion failed.");

// Test 208 - 208
a = 208;
b = 208;
#2 assert(y == 0) else $error("Subtract assertion failed.");
assert(zero == 1) else $error("Zero assertion failed.");
assert(sign == 0) else $error("Sign assertion failed.");
assert(carry_out == 0) else $error("Carry assertion failed.");
assert(overflow == 0) else $error("Overflow assertion failed.");

Implementing Remaining Operations

Addition and Subtraction are the trickiest operations to implement of the operations planned for this ALU. With two instructions down there are 10 to go,

  • Arithmetic Operations
    • Add with Carry
    • Subtract with Carry
    • Increment
    • Decrement
  • Logic Operations
    • AND
    • OR
    • XOR
    • NOT/Negate (not in 6502, but I want my ALU to have it!)
  • Shifting Operations
    • Arithmetic Shift Left
    • Logical Shift Right
    • Rotate Left
    • Rotate Right

Increment & Decrement

Increment and decrement only affect the sign and zero flags, and adds or subtracts 1 from a single operand. To implement them I’ll use assign again to give me a reference to an incremented and decremented value.

  1. // Increment/Decrement
  2. logic [7:0] incremented;
  3. logic [7:0] decremented;
  6. assign incremented = a + 1,
  7. decremented = a - 1;
// Increment/Decrement
logic [7:0] incremented;
logic [7:0] decremented;


assign incremented = a + 1,
  decremented = a - 1;

Then in my case statement on operation, I’ll add the INCREMENT and DECREMENT cases.

  1. INCREMENT: begin
  2. y <= incremented;
  3. sign <= incremented[7];
  4. if (incremented == 0)
  5. zero <= 1;
  6. else
  7. zero <= 0;
  8. end
  9. DECREMENT: begin
  10. y <= decremented;
  11. sign <= decremented[7];
  12. if (decremented == 0)
  13. zero <= 1;
  14. else
  15. zero <= 0;
  16. end
INCREMENT: begin
  y <= incremented;
  sign <= incremented[7];
  if (incremented == 0) 
    zero <= 1;
  else
    zero <= 0;
end
DECREMENT: begin
  y <= decremented;
  sign <= decremented[7];
  if (decremented == 0) 
    zero <= 1;
  else
    zero <= 0;
end

Then I’ll add some more tests to top to verify it.

  1. // Test 0++
  2. operation = INCREMENT;
  3. a = 0;
  4. #2 assert(y == 1) else $error("Increment assertion failed.");
  5. assert(zero == 0) else $error("Zero assertion failed.");
  6. assert(sign == 0) else $error("Sign assertion failed.");
  8. // Test 200++
  9. a = 200;
  10. #2 assert(y == 201) else $error("Increment assertion failed.");
  11. assert(zero == 0) else $error("Zero assertion failed.");
  12. assert(sign == 1) else $error("Sign assertion failed.");
  14. // Test 255++
  15. a = 255;
  16. #2 assert(y == 0) else $error("Increment assertion failed.");
  17. assert(zero == 1) else $error("Zero assertion failed.");
  18. assert(sign == 0) else $error("Sign assertion failed.");
  20. // Test 0--
  21. operation = DECREMENT;
  22. a = 0;
  23. #2 assert(y == 255) else $error("Decrement assertion failed.");
  24. assert(zero == 0) else $error("Zero assertion failed.");
  25. assert(sign == 1) else $error("Sign assertion failed.");
  27. // Test 200--
  28. a = 200;
  29. #2 assert(y == 199) else $error("Decrement assertion failed.");
  30. assert(zero == 0) else $error("Zero assertion failed.");
  31. assert(sign == 1) else $error("Sign assertion failed.");
  33. // Test 1--
  34. a = 1;
  35. #2 assert(y == 0) else $error("Decrement assertion failed.");
  36. assert(zero == 1) else $error("Zero assertion failed.");
  37. assert(sign == 0) else $error("Sign a
// Test 0++
operation = INCREMENT;
a = 0;
#2 assert(y == 1) else $error("Increment assertion failed.");
assert(zero == 0) else $error("Zero assertion failed.");
assert(sign == 0) else $error("Sign assertion failed.");

// Test 200++
a = 200;
#2 assert(y == 201) else $error("Increment assertion failed.");
assert(zero == 0) else $error("Zero assertion failed.");
assert(sign == 1) else $error("Sign assertion failed.");

// Test 255++
a = 255;
#2 assert(y == 0) else $error("Increment assertion failed.");
assert(zero == 1) else $error("Zero assertion failed.");
assert(sign == 0) else $error("Sign assertion failed.");

// Test 0--
operation = DECREMENT;
a = 0;
#2 assert(y == 255) else $error("Decrement assertion failed.");
assert(zero == 0) else $error("Zero assertion failed.");
assert(sign == 1) else $error("Sign assertion failed.");

// Test 200--
a = 200;
#2 assert(y == 199) else $error("Decrement assertion failed.");
assert(zero == 0) else $error("Zero assertion failed.");
assert(sign == 1) else $error("Sign assertion failed.");

// Test 1--
a = 1;
#2 assert(y == 0) else $error("Decrement assertion failed.");
assert(zero == 1) else $error("Zero assertion failed.");
assert(sign == 0) else $error("Sign a

Logic Operations

The logic operations AND, OR, XOR, and NOT are the easiest operations to implement. Very similar to what I did for increment and decrement, I’ll name some new variables and keep them assigned to the results for each operation. Then they are added to the case statement.

  1. // Logic operations
  2. logic [7:0] and_result;
  3. logic [7:0] or_result;
  4. logic [7:0] xor_result;
  5. logic [7:0] not_result;
  7. // Logic assignments
  8. assign and_result = a & b,
  9. or_result = a | b,
  10. xor_result = a ^ b,
  11. not_result = ~a;
  13. ...
  15. BIT_AND: begin
  16. y <= and_result;
  17. sign <= and_result[7];
  18. if (and_result == 0)
  19. zero <= 1;
  20. else
  21. zero <= 0;
  22. end
  23. BIT_OR: begin
  24. y <= or_result;
  25. sign <= or_result[7];
  26. if (or_result == 0)
  27. zero <= 1;
  28. else
  29. zero <= 0;
  30. end
  31. BIT_XOR: begin
  32. y <= xor_result;
  33. sign <= xor_result[7];
  34. if (xor_result == 0)
  35. zero <= 1;
  36. else
  37. zero <= 0;
  38. end
  39. BIT_NOT: begin
  40. y <= not_result;
  41. sign <= not_result[7];
  42. if (not_result == 0)
  43. zero <= 1;
  44. else
  45. zero <= 0;
  46. end
// Logic operations
logic [7:0] and_result;
logic [7:0] or_result;
logic [7:0] xor_result;
logic [7:0] not_result;

// Logic assignments
assign and_result = a & b,
  or_result = a | b,
  xor_result = a ^ b,
  not_result = ~a;

...

    BIT_AND: begin
      y <= and_result;
      sign <= and_result[7];
      if (and_result == 0)
        zero <= 1;
      else
        zero <= 0;
    end
    BIT_OR: begin
      y <= or_result;
      sign <= or_result[7];
      if (or_result == 0)
        zero <= 1;
      else
        zero <= 0;
    end
    BIT_XOR: begin
      y <= xor_result;
      sign <= xor_result[7];
      if (xor_result == 0)
        zero <= 1;
      else
        zero <= 0;
    end
    BIT_NOT: begin
      y <= not_result;
      sign <= not_result[7];
      if (not_result == 0)
        zero <= 1;
      else
        zero <= 0;
    end

Then some tests to verify.

  1. // Test 12 & 10
  2. operation = BIT_AND;
  3. a = 12;
  4. b = 10;
  5. #2 assert(y == 8) else $error("AND assertion failed.");
  6. assert(zero == 0) else $error("Zero assertion failed.");
  7. assert(sign == 0) else $error("Sign assertion failed.");
  9. // Test 13 | 15
  10. operation = BIT_OR;
  11. a = 13;
  12. b = 15;
  13. #2 assert(y == 15) else $error("OR assertion failed.");
  14. assert(zero == 0) else $error("Zero assertion failed.");
  15. assert(sign == 0) else $error("Sign assertion failed.");
  17. // Test 13 ^ 15
  18. operation = BIT_XOR;
  19. a = 13;
  20. b = 15;
  21. #2 assert(y == 2) else $error("XOR assertion failed.");
  22. assert(zero == 0) else $error("Zero assertion failed.");
  23. assert(sign == 0) else $error("Sign assertion failed.");
  25. // Test 13 & 15
  26. operation = BIT_NOT;
  27. a = 13;
  28. #2 assert(y == 242) else $error("NOT assertion failed.");
  29. assert(zero == 0) else $error("Zero assertion failed.");
  30. assert(sign == 1) else $error("Sign assertion failed.");
// Test 12 & 10
operation = BIT_AND;
a = 12;
b = 10;
#2 assert(y == 8) else $error("AND assertion failed.");
assert(zero == 0) else $error("Zero assertion failed.");
assert(sign == 0) else $error("Sign assertion failed.");

// Test 13 | 15
operation = BIT_OR;
a = 13;
b = 15;
#2 assert(y == 15) else $error("OR assertion failed.");
assert(zero == 0) else $error("Zero assertion failed.");
assert(sign == 0) else $error("Sign assertion failed.");

// Test 13 ^ 15
operation = BIT_XOR;
a = 13;
b = 15;
#2 assert(y == 2) else $error("XOR assertion failed.");
assert(zero == 0) else $error("Zero assertion failed.");
assert(sign == 0) else $error("Sign assertion failed.");

// Test 13 & 15
operation = BIT_NOT;
a = 13;
#2 assert(y == 242) else $error("NOT assertion failed.");
assert(zero == 0) else $error("Zero assertion failed.");
assert(sign == 1) else $error("Sign assertion failed.");

Shifting Operations

The last few operations to add are the shifters. Rotate left and rotate right shift all the bits left or right by one position. In the case of a right shift, the leftmost bit will change to the carry in bit, and the rightmost bit will become the new carry out. In the arithmetic and logical shift operations the bit being pushed in will be 0 regardless of the carry in value.

  1. // Shifting operations
  2. logic [7:0] rotated_left;
  3. logic [7:0] rotated_right;
  4. logic [7:0] shifted_left;
  5. logic [7:0] shifted_right;
  7. // Shifting assignments
  8. assign rotated_left = {a[6:0], carry_in},
  9. rotated_right = {carry_in, a[7:1]},
  10. shifted_left = {a[6:0], 1'b0},
  11. shifted_right = {1'b0, a[7:1]};
  13. ...
  15. ROTATE_LEFT: begin
  16. y <= rotated_left;
  17. carry_out <= a[7];
  18. sign <= rotated_left[7];
  19. if (rotated_left == 0)
  20. zero <= 1;
  21. else
  22. zero <= 0;
  23. end
  24. ROTATE_RIGHT: begin
  25. y <= rotated_right;
  26. carry_out <= a[0];
  27. sign <= rotated_right[7];
  28. if (rotated_right == 0)
  29. zero <= 1;
  30. else
  31. zero <= 0;
  32. end
  33. SHIFT_LEFT: begin
  34. y <= shifted_left;
  35. carry_out <= a[7];
  36. sign <= shifted_left[7];
  37. if (shifted_left == 0)
  38. zero <= 1;
  39. else
  40. zero <= 0;
  41. end
  42. SHIFT_RIGHT: begin
  43. y <= shifted_right;
  44. carry_out <= a[0];
  45. sign <= shifted_right[7];
  46. if (shifted_right == 0)
  47. zero <= 1;
  48. else
  49. zero <= 0;
// Shifting operations
logic [7:0] rotated_left;
logic [7:0] rotated_right;
logic [7:0] shifted_left;
logic [7:0] shifted_right;

// Shifting assignments
assign rotated_left = {a[6:0], carry_in},
  rotated_right = {carry_in, a[7:1]},
  shifted_left = {a[6:0], 1'b0},
  shifted_right = {1'b0, a[7:1]};

...

    ROTATE_LEFT: begin
      y <= rotated_left;
      carry_out <= a[7];
      sign <= rotated_left[7];
      if (rotated_left == 0)
        zero <= 1;
      else
        zero <= 0;
    end
    ROTATE_RIGHT: begin
      y <= rotated_right;
      carry_out <= a[0];
      sign <= rotated_right[7];
      if (rotated_right == 0)
        zero <= 1;
      else
        zero <= 0;
    end
    SHIFT_LEFT: begin
      y <= shifted_left;
      carry_out <= a[7];
      sign <= shifted_left[7];
      if (shifted_left == 0)
        zero <= 1;
      else
        zero <= 0;
    end
    SHIFT_RIGHT: begin
      y <= shifted_right;
      carry_out <= a[0];
      sign <= shifted_right[7];
      if (shifted_right == 0)
        zero <= 1;
      else
        zero <= 0;

For the shift assignments I use 1'b0 to specify a 1 bit binary with the value 0 in the concatenation. As always some tests to validate we’re getting the right behavior.

  1. // Test shift left
  2. operation = SHIFT_LEFT;
  3. carry_in = 1;
  4. a = 136;
  5. #2 assert(y == 16) else $error("Shift left assertion failed.");
  6. assert(carry_out == 1) else $error("carry assertion failed.");
  7. assert(zero == 0) else $error("Zero assertion failed.");
  8. assert(sign == 0) else $error("Sign assertion failed.");
  10. // Test shift right
  11. operation = SHIFT_RIGHT;
  12. a = 8;
  13. #2 assert(y == 4) else $error("Shift right assertion failed.");
  14. assert(carry_out == 0) else $error("carry assertion failed.");
  15. assert(zero == 0) else $error("Zero assertion failed.");
  16. assert(sign == 0) else $error("Sign assertion failed.");
  18. // Test rotate left
  19. operation = ROTATE_LEFT;
  20. a = 8;
  21. #2 assert(y == 17) else $error("Rotate left assertion failed.");
  22. assert(carry_out == 0) else $error("carry assertion failed.");
  23. assert(zero == 0) else $error("Zero assertion failed.");
  24. assert(sign == 0) else $error("Sign assertion failed.");
  26. // Test rotate right
  27. operation = ROTATE_RIGHT;
  28. a = 9;
  29. #2 assert(y == 132) else $error("Rotate right assertion failed.");
  30. assert(carry_out == 1) else $error("carry assertion failed.");
  31. assert(zero == 0) else $error("Zero assertion failed.");
  32. assert(sign == 1) else $error("Sign assertion failed.");
// Test shift left
operation = SHIFT_LEFT;
carry_in = 1;
a = 136;
#2 assert(y == 16) else $error("Shift left assertion failed.");
assert(carry_out == 1) else $error("carry assertion failed.");
assert(zero == 0) else $error("Zero assertion failed.");
assert(sign == 0) else $error("Sign assertion failed.");

// Test shift right
operation = SHIFT_RIGHT;
a = 8;
#2 assert(y == 4) else $error("Shift right assertion failed.");
assert(carry_out == 0) else $error("carry assertion failed.");
assert(zero == 0) else $error("Zero assertion failed.");
assert(sign == 0) else $error("Sign assertion failed.");

// Test rotate left
operation = ROTATE_LEFT;
a = 8;
#2 assert(y == 17) else $error("Rotate left assertion failed.");
assert(carry_out == 0) else $error("carry assertion failed.");
assert(zero == 0) else $error("Zero assertion failed.");
assert(sign == 0) else $error("Sign assertion failed.");

// Test rotate right
operation = ROTATE_RIGHT;
a = 9;
#2 assert(y == 132) else $error("Rotate right assertion failed.");
assert(carry_out == 1) else $error("carry assertion failed.");
assert(zero == 0) else $error("Zero assertion failed.");
assert(sign == 1) else $error("Sign assertion failed.");

It Works!

There it is! An ALU implementation that can handle 12 different 8-bit operations. It took 3 posts to get here, but this is a decently large design. Here’s the final alu.sv file

  1. `timescale 1ns / 1ps
  3. package ALU;
  4. typedef enum logic [3:0] {
  5. ADD,
  6. SUBTRACT,
  7. INCREMENT,
  8. DECREMENT,
  9. BIT_AND,
  10. BIT_OR,
  11. BIT_XOR,
  12. BIT_NOT,
  13. SHIFT_LEFT,
  14. SHIFT_RIGHT,
  15. ROTATE_LEFT,
  16. ROTATE_RIGHT
  17. } opcode;
  18. endpackage
  20. import ALU::*;
  22. module alu (
  23. input logic clock,
  24. input opcode operation,
  25. input logic [7:0] a,
  26. input logic [7:0] b,
  27. input logic carry_in,
  28. output logic [7:0] y,
  29. output logic zero,
  30. output logic sign,
  31. output logic carry_out,
  32. output logic overflow
  33. );
  35. // Add operation internals
  36. logic [7:0] add;
  37. logic [6:0] add_lower_bits;
  38. logic add_carry_6;
  39. logic add_carry_7;
  41. // Subtract operation internals
  42. logic [7:0] subtract;
  43. logic [6:0] subtract_lower_bits;
  44. logic subtract_borrow_6;
  45. logic subtract_borrow_7;
  47. // Increment/Decrement
  48. logic [7:0] incremented;
  49. logic [7:0] decremented;
  51. // Logic operations
  52. logic [7:0] and_result;
  53. logic [7:0] or_result;
  54. logic [7:0] xor_result;
  55. logic [7:0] not_result;
  57. // Shifting operations
  58. logic [7:0] rotated_left;
  59. logic [7:0] rotated_right;
  60. logic [7:0] shifted_left;
  61. logic [7:0] shifted_right;
  63. // Add assignments
  64. assign {add_carry_6, add_lower_bits} = a[6:0] + b[6:0] + carry_in,
  65. {add_carry_7, add} = a + b + carry_in;
  67. // Subtract assignments
  68. assign {subtract_borrow_6, subtract_lower_bits} = a[6:0] - b[6:0] - carry_in,
  69. {subtract_borrow_7, subtract} = a - b - carry_in;
  71. // Increment/decrement assignments
  72. assign incremented = a + 1,
  73. decremented = a - 1;
  75. // Logic assignments
  76. assign and_result = a & b,
  77. or_result = a | b,
  78. xor_result = a ^ b,
  79. not_result = ~a;
  81. // Shifting assignments
  82. assign rotated_left = {a[6:0], carry_in},
  83. rotated_right = {carry_in, a[7:1]},
  84. shifted_left = {a[6:0], 1'b0},
  85. shifted_right = {1'b0, a[7:1]};
  87. always_ff @ (posedge clock) begin
  88. case (operation)
  89. ADD: begin
  90. y <= add;
  91. carry_out <= add_carry_7;
  92. sign <= add[7];
  93. overflow <= add_carry_7 ^ add_carry_6;
  94. if (add == 0)
  95. zero <= 1;
  96. else
  97. zero <= 0;
  98. end
  99. SUBTRACT: begin
  100. y <= subtract;
  101. carry_out <= subtract_borrow_7;
  102. sign <= subtract[7];
  103. overflow <= subtract_borrow_7 ^ subtract_borrow_6;
  104. if (subtract == 0)
  105. zero <= 1;
  106. else
  107. zero <= 0;
  108. end
  109. INCREMENT: begin
  110. y <= incremented;
  111. sign <= incremented[7];
  112. if (incremented == 0)
  113. zero <= 1;
  114. else
  115. zero <= 0;
  116. end
  117. DECREMENT: begin
  118. y <= decremented;
  119. sign <= decremented[7];
  120. if (decremented == 0)
  121. zero <= 1;
  122. else
  123. zero <= 0;
  124. end
  125. BIT_AND: begin
  126. y <= and_result;
  127. sign <= and_result[7];
  128. if (and_result == 0)
  129. zero <= 1;
  130. else
  131. zero <= 0;
  132. end
  133. BIT_OR: begin
  134. y <= or_result;
  135. sign <= or_result[7];
  136. if (or_result == 0)
  137. zero <= 1;
  138. else
  139. zero <= 0;
  140. end
  141. BIT_XOR: begin
  142. y <= xor_result;
  143. sign <= xor_result[7];
  144. if (xor_result == 0)
  145. zero <= 1;
  146. else
  147. zero <= 0;
  148. end
  149. BIT_NOT: begin
  150. y <= not_result;
  151. sign <= not_result[7];
  152. if (not_result == 0)
  153. zero <= 1;
  154. else
  155. zero <= 0;
  156. end
  157. ROTATE_LEFT: begin
  158. y <= rotated_left;
  159. carry_out <= a[7];
  160. sign <= rotated_left[7];
  161. if (rotated_left == 0)
  162. zero <= 1;
  163. else
  164. zero <= 0;
  165. end
  166. ROTATE_RIGHT: begin
  167. y <= rotated_right;
  168. carry_out <= a[0];
  169. sign <= rotated_right[7];
  170. if (rotated_right == 0)
  171. zero <= 1;
  172. else
  173. zero <= 0;
  174. end
  175. SHIFT_LEFT: begin
  176. y <= shifted_left;
  177. carry_out <= a[7];
  178. sign <= shifted_left[7];
  179. if (shifted_left == 0)
  180. zero <= 1;
  181. else
  182. zero <= 0;
  183. end
  184. SHIFT_RIGHT: begin
  185. y <= shifted_right;
  186. carry_out <= a[0];
  187. sign <= shifted_right[7];
  188. if (shifted_right == 0)
  189. zero <= 1;
  190. else
  191. zero <= 0;
  192. end
  193. endcase
  194. end
  196. endmodule
`timescale 1ns / 1ps

package ALU;
  typedef enum logic [3:0] {
    ADD,
    SUBTRACT,
    INCREMENT,
    DECREMENT,
    BIT_AND,
    BIT_OR,
    BIT_XOR,
    BIT_NOT,
    SHIFT_LEFT,
    SHIFT_RIGHT,
    ROTATE_LEFT,
    ROTATE_RIGHT
  } opcode;
endpackage

import ALU::*;

module alu (
  input logic clock,
  input opcode operation,
  input logic [7:0] a,
  input logic [7:0] b,
  input logic carry_in,
  output logic [7:0] y,
  output logic zero,
  output logic sign,
  output logic carry_out,
  output logic overflow
);

  // Add operation internals
  logic [7:0] add;
  logic [6:0] add_lower_bits;
  logic add_carry_6;
  logic add_carry_7;

  // Subtract operation internals
  logic [7:0] subtract;
  logic [6:0] subtract_lower_bits;
  logic subtract_borrow_6;
  logic subtract_borrow_7;

  // Increment/Decrement
  logic [7:0] incremented;
  logic [7:0] decremented;

  // Logic operations
  logic [7:0] and_result;
  logic [7:0] or_result;
  logic [7:0] xor_result;
  logic [7:0] not_result;

  // Shifting operations
  logic [7:0] rotated_left;
  logic [7:0] rotated_right;
  logic [7:0] shifted_left;
  logic [7:0] shifted_right;

  // Add assignments
  assign {add_carry_6, add_lower_bits} = a[6:0] + b[6:0] + carry_in,
    {add_carry_7, add} = a + b + carry_in;

  // Subtract assignments
  assign {subtract_borrow_6, subtract_lower_bits} = a[6:0] - b[6:0] - carry_in,
    {subtract_borrow_7, subtract} = a - b - carry_in;

  // Increment/decrement assignments
  assign incremented = a + 1,
    decremented = a - 1;

  // Logic assignments
  assign and_result = a & b,
    or_result = a | b,
    xor_result = a ^ b,
    not_result = ~a;

  // Shifting assignments
  assign rotated_left = {a[6:0], carry_in},
    rotated_right = {carry_in, a[7:1]},
    shifted_left = {a[6:0], 1'b0},
    shifted_right = {1'b0, a[7:1]};

  always_ff @ (posedge clock) begin
    case (operation)
      ADD: begin
        y <= add;
        carry_out <= add_carry_7;
        sign <= add[7];
        overflow <= add_carry_7 ^ add_carry_6;
        if (add == 0)
          zero <= 1;
        else
          zero <= 0;
      end
      SUBTRACT: begin
        y <= subtract;
        carry_out <= subtract_borrow_7;
        sign <= subtract[7];
        overflow <= subtract_borrow_7 ^ subtract_borrow_6;
        if (subtract == 0)
          zero <= 1;
        else
          zero <= 0;
      end
      INCREMENT: begin
        y <= incremented;
        sign <= incremented[7];
        if (incremented == 0) 
          zero <= 1;
        else
          zero <= 0;
      end
      DECREMENT: begin
        y <= decremented;
        sign <= decremented[7];
        if (decremented == 0) 
          zero <= 1;
        else
          zero <= 0;
      end
      BIT_AND: begin
        y <= and_result;
        sign <= and_result[7];
        if (and_result == 0)
          zero <= 1;
        else
          zero <= 0;
      end
      BIT_OR: begin
        y <= or_result;
        sign <= or_result[7];
        if (or_result == 0)
          zero <= 1;
        else
          zero <= 0;
      end
      BIT_XOR: begin
        y <= xor_result;
        sign <= xor_result[7];
        if (xor_result == 0)
          zero <= 1;
        else
          zero <= 0;
      end
      BIT_NOT: begin
        y <= not_result;
        sign <= not_result[7];
        if (not_result == 0)
          zero <= 1;
        else
          zero <= 0;
      end
      ROTATE_LEFT: begin
        y <= rotated_left;
        carry_out <= a[7];
        sign <= rotated_left[7];
        if (rotated_left == 0)
          zero <= 1;
        else
          zero <= 0;
      end
      ROTATE_RIGHT: begin
        y <= rotated_right;
        carry_out <= a[0];
        sign <= rotated_right[7];
        if (rotated_right == 0)
          zero <= 1;
        else
          zero <= 0;
      end
      SHIFT_LEFT: begin
        y <= shifted_left;
        carry_out <= a[7];
        sign <= shifted_left[7];
        if (shifted_left == 0)
          zero <= 1;
        else
          zero <= 0;
      end
      SHIFT_RIGHT: begin
        y <= shifted_right;
        carry_out <= a[0];
        sign <= shifted_right[7];
        if (shifted_right == 0)
          zero <= 1;
        else
          zero <= 0;
      end
    endcase
  end

  endmodule

And the final top.sv

  1. `timescale 1ns / 1ps
  3. import ALU::*;
  5. module top ();
  6. logic clock;
  7. opcode operation;
  8. logic [7:0] a;
  9. logic [7:0] b;
  10. logic carry_in;
  11. logic [7:0] y;
  12. logic zero;
  13. logic sign;
  14. logic carry_out;
  15. logic overflow;
  17. alu myALU (
  18. clock,
  19. operation,
  20. a,
  21. b,
  22. carry_in,
  23. y,
  24. zero,
  25. sign,
  26. carry_out,
  27. overflow
  28. );
  30. initial begin
  31. clock = 0;
  32. operation = ADD;
  33. carry_in = 0;
  35. // Test 208 + 144
  36. a = 208;
  37. b = 144;
  38. #2 assert(y == 96) else $error("Sum assertion failed.");
  39. assert(zero == 0) else $error("Zero assertion failed.");
  40. assert(sign == 0) else $error("Sign assertion failed.");
  41. assert(carry_out == 1) else $error("Carry assertion failed.");
  42. assert(overflow == 1) else $error("Overflow assertion failed.");
  44. // Test 208 + 48 (signed -48 + 48)
  45. a = 208;
  46. b = 48;
  47. #2 assert(y == 0) else $error("Sum assertion failed.");
  48. assert(zero == 1) else $error("Zero assertion failed.");
  49. assert(sign == 0) else $error("Sign assertion failed.");
  50. assert(carry_out == 1) else $error("Carry assertion failed.");
  51. assert(overflow == 0) else $error("Overflow assertion failed.");
  53. // Test 80 + 80
  54. a = 80;
  55. b = 80;
  56. #2 assert(y == 160) else $error("Sum assertion failed.");
  57. assert(zero == 0) else $error("Zero assertion failed.");
  58. assert(sign == 1) else $error("Sign assertion failed.");
  59. assert(carry_out == 0) else $error("Carry assertion failed.");
  60. assert(overflow == 1) else $error("Overflow assertion failed.");
  62. // Test 100 - 80
  63. operation = SUBTRACT;
  64. a = 100;
  65. b = 80;
  66. #2 assert(y == 20) else $error("Subtract assertion failed.");
  67. assert(zero == 0) else $error("Zero assertion failed.");
  68. assert(sign == 0) else $error("Sign assertion failed.");
  69. assert(carry_out == 0) else $error("Carry assertion failed.");
  70. assert(overflow == 0) else $error("Overflow assertion failed.");
  72. // Test 80 - 100
  73. a = 80;
  74. b = 100;
  75. #2 assert(y == 236) else $error("Subtract assertion failed.");
  76. assert(zero == 0) else $error("Zero assertion failed.");
  77. assert(sign == 1) else $error("Sign assertion failed.");
  78. assert(carry_out == 1) else $error("Carry assertion failed.");
  79. assert(overflow == 0) else $error("Overflow assertion failed.");
  81. // Test 80 - 176
  82. a = 80;
  83. b = 176;
  84. #2 assert(y == 160) else $error("Subtract assertion failed.");
  85. assert(zero == 0) else $error("Zero assertion failed.");
  86. assert(sign == 1) else $error("Sign assertion failed.");
  87. assert(carry_out == 1) else $error("Carry assertion failed.");
  88. assert(overflow == 1) else $error("Overflow assertion failed.");
  90. // Test 208 - 112
  91. a = 208;
  92. b = 112;
  93. #2 assert(y == 96) else $error("Subtract assertion failed.");
  94. assert(zero == 0) else $error("Zero assertion failed.");
  95. assert(sign == 0) else $error("Sign assertion failed.");
  96. assert(carry_out == 0) else $error("Carry assertion failed.");
  97. assert(overflow == 1) else $error("Overflow assertion failed.");
  99. // Test 208 - 208
  100. a = 208;
  101. b = 208;
  102. #2 assert(y == 0) else $error("Subtract assertion failed.");
  103. assert(zero == 1) else $error("Zero assertion failed.");
  104. assert(sign == 0) else $error("Sign assertion failed.");
  105. assert(carry_out == 0) else $error("Carry assertion failed.");
  106. assert(overflow == 0) else $error("Overflow assertion failed.");
  108. // Test 0++
  109. operation = INCREMENT;
  110. a = 0;
  111. #2 assert(y == 1) else $error("Increment assertion failed.");
  112. assert(zero == 0) else $error("Zero assertion failed.");
  113. assert(sign == 0) else $error("Sign assertion failed.");
  115. // Test 200++
  116. a = 200;
  117. #2 assert(y == 201) else $error("Increment assertion failed.");
  118. assert(zero == 0) else $error("Zero assertion failed.");
  119. assert(sign == 1) else $error("Sign assertion failed.");
  121. // Test 255++
  122. a = 255;
  123. #2 assert(y == 0) else $error("Increment assertion failed.");
  124. assert(zero == 1) else $error("Zero assertion failed.");
  125. assert(sign == 0) else $error("Sign assertion failed.");
  127. // Test 0--
  128. operation = DECREMENT;
  129. a = 0;
  130. #2 assert(y == 255) else $error("Decrement assertion failed.");
  131. assert(zero == 0) else $error("Zero assertion failed.");
  132. assert(sign == 1) else $error("Sign assertion failed.");
  134. // Test 200--
  135. a = 200;
  136. #2 assert(y == 199) else $error("Decrement assertion failed.");
  137. assert(zero == 0) else $error("Zero assertion failed.");
  138. assert(sign == 1) else $error("Sign assertion failed.");
  140. // Test 1--
  141. a = 1;
  142. #2 assert(y == 0) else $error("Decrement assertion failed.");
  143. assert(zero == 1) else $error("Zero assertion failed.");
  144. assert(sign == 0) else $error("Sign assertion failed.");
  146. // Test 12 & 10
  147. operation = BIT_AND;
  148. a = 12;
  149. b = 10;
  150. #2 assert(y == 8) else $error("AND assertion failed.");
  151. assert(zero == 0) else $error("Zero assertion failed.");
  152. assert(sign == 0) else $error("Sign assertion failed.");
  154. // Test 13 | 15
  155. operation = BIT_OR;
  156. a = 13;
  157. b = 15;
  158. #2 assert(y == 15) else $error("OR assertion failed.");
  159. assert(zero == 0) else $error("Zero assertion failed.");
  160. assert(sign == 0) else $error("Sign assertion failed.");
  162. // Test 13 ^ 15
  163. operation = BIT_XOR;
  164. a = 13;
  165. b = 15;
  166. #2 assert(y == 2) else $error("XOR assertion failed.");
  167. assert(zero == 0) else $error("Zero assertion failed.");
  168. assert(sign == 0) else $error("Sign assertion failed.");
  170. // Test 13 & 15
  171. operation = BIT_NOT;
  172. a = 13;
  173. #2 assert(y == 242) else $error("NOT assertion failed.");
  174. assert(zero == 0) else $error("Zero assertion failed.");
  175. assert(sign == 1) else $error("Sign assertion failed.");
  177. // Test shift left
  178. operation = SHIFT_LEFT;
  179. carry_in = 1;
  180. a = 136;
  181. #2 assert(y == 16) else $error("Shift left assertion failed.");
  182. assert(carry_out == 1) else $error("carry assertion failed.");
  183. assert(zero == 0) else $error("Zero assertion failed.");
  184. assert(sign == 0) else $error("Sign assertion failed.");
  186. // Test shift right
  187. operation = SHIFT_RIGHT;
  188. a = 8;
  189. #2 assert(y == 4) else $error("Shift right assertion failed.");
  190. assert(carry_out == 0) else $error("carry assertion failed.");
  191. assert(zero == 0) else $error("Zero assertion failed.");
  192. assert(sign == 0) else $error("Sign assertion failed.");
  194. // Test rotate left
  195. operation = ROTATE_LEFT;
  196. a = 8;
  197. #2 assert(y == 17) else $error("Rotate left assertion failed.");
  198. assert(carry_out == 0) else $error("carry assertion failed.");
  199. assert(zero == 0) else $error("Zero assertion failed.");
  200. assert(sign == 0) else $error("Sign assertion failed.");
  202. // Test rotate right
  203. operation = ROTATE_RIGHT;
  204. a = 9;
  205. #2 assert(y == 132) else $error("Rotate right assertion failed.");
  206. assert(carry_out == 1) else $error("carry assertion failed.");
  207. assert(zero == 0) else $error("Zero assertion failed.");
  208. assert(sign == 1) else $error("Sign assertion failed.");
  210. #1 $finish();
  211. end
  213. always begin
  214. #1 clock = ~clock;
  215. end
  217. endmodule
`timescale 1ns / 1ps

import ALU::*;

module top ();
  logic clock;
  opcode operation;
  logic [7:0] a;
  logic [7:0] b;
  logic carry_in;
  logic [7:0] y;
  logic zero;
  logic sign;
  logic carry_out;
  logic overflow;

  alu myALU (
    clock,
    operation,
    a,
    b,
    carry_in,
    y,
    zero,
    sign,
    carry_out,
    overflow
  );

  initial begin
    clock = 0;
    operation = ADD;
    carry_in = 0;

    // Test 208 + 144
    a = 208;
    b = 144;
    #2 assert(y == 96) else $error("Sum assertion failed.");
    assert(zero == 0) else $error("Zero assertion failed.");
    assert(sign == 0) else $error("Sign assertion failed.");
    assert(carry_out == 1) else $error("Carry assertion failed.");
    assert(overflow == 1) else $error("Overflow assertion failed.");

    // Test 208 + 48 (signed -48 + 48)
    a = 208;
    b = 48;
    #2 assert(y == 0) else $error("Sum assertion failed.");
    assert(zero == 1) else $error("Zero assertion failed.");
    assert(sign == 0) else $error("Sign assertion failed.");
    assert(carry_out == 1) else $error("Carry assertion failed.");
    assert(overflow == 0) else $error("Overflow assertion failed.");

    // Test 80 + 80
    a = 80;
    b = 80;
    #2 assert(y == 160) else $error("Sum assertion failed.");
    assert(zero == 0) else $error("Zero assertion failed.");
    assert(sign == 1) else $error("Sign assertion failed.");
    assert(carry_out == 0) else $error("Carry assertion failed.");
    assert(overflow == 1) else $error("Overflow assertion failed.");

    // Test 100 - 80
    operation = SUBTRACT;
    a = 100;
    b = 80;
    #2 assert(y == 20) else $error("Subtract assertion failed.");
    assert(zero == 0) else $error("Zero assertion failed.");
    assert(sign == 0) else $error("Sign assertion failed.");
    assert(carry_out == 0) else $error("Carry assertion failed.");
    assert(overflow == 0) else $error("Overflow assertion failed.");

    // Test 80 - 100
    a = 80;
    b = 100;
    #2 assert(y == 236) else $error("Subtract assertion failed.");
    assert(zero == 0) else $error("Zero assertion failed.");
    assert(sign == 1) else $error("Sign assertion failed.");
    assert(carry_out == 1) else $error("Carry assertion failed.");
    assert(overflow == 0) else $error("Overflow assertion failed.");

    // Test 80 - 176
    a = 80;
    b = 176;
    #2 assert(y == 160) else $error("Subtract assertion failed.");
    assert(zero == 0) else $error("Zero assertion failed.");
    assert(sign == 1) else $error("Sign assertion failed.");
    assert(carry_out == 1) else $error("Carry assertion failed.");
    assert(overflow == 1) else $error("Overflow assertion failed.");

    // Test 208 - 112
    a = 208;
    b = 112;
    #2 assert(y == 96) else $error("Subtract assertion failed.");
    assert(zero == 0) else $error("Zero assertion failed.");
    assert(sign == 0) else $error("Sign assertion failed.");
    assert(carry_out == 0) else $error("Carry assertion failed.");
    assert(overflow == 1) else $error("Overflow assertion failed.");

    // Test 208 - 208
    a = 208;
    b = 208;
    #2 assert(y == 0) else $error("Subtract assertion failed.");
    assert(zero == 1) else $error("Zero assertion failed.");
    assert(sign == 0) else $error("Sign assertion failed.");
    assert(carry_out == 0) else $error("Carry assertion failed.");
    assert(overflow == 0) else $error("Overflow assertion failed.");

    // Test 0++
    operation = INCREMENT;
    a = 0;
    #2 assert(y == 1) else $error("Increment assertion failed.");
    assert(zero == 0) else $error("Zero assertion failed.");
    assert(sign == 0) else $error("Sign assertion failed.");

    // Test 200++
    a = 200;
    #2 assert(y == 201) else $error("Increment assertion failed.");
    assert(zero == 0) else $error("Zero assertion failed.");
    assert(sign == 1) else $error("Sign assertion failed.");

    // Test 255++
    a = 255;
    #2 assert(y == 0) else $error("Increment assertion failed.");
    assert(zero == 1) else $error("Zero assertion failed.");
    assert(sign == 0) else $error("Sign assertion failed.");

    // Test 0--
    operation = DECREMENT;
    a = 0;
    #2 assert(y == 255) else $error("Decrement assertion failed.");
    assert(zero == 0) else $error("Zero assertion failed.");
    assert(sign == 1) else $error("Sign assertion failed.");

    // Test 200--
    a = 200;
    #2 assert(y == 199) else $error("Decrement assertion failed.");
    assert(zero == 0) else $error("Zero assertion failed.");
    assert(sign == 1) else $error("Sign assertion failed.");

    // Test 1--
    a = 1;
    #2 assert(y == 0) else $error("Decrement assertion failed.");
    assert(zero == 1) else $error("Zero assertion failed.");
    assert(sign == 0) else $error("Sign assertion failed.");

    // Test 12 & 10
    operation = BIT_AND;
    a = 12;
    b = 10;
    #2 assert(y == 8) else $error("AND assertion failed.");
    assert(zero == 0) else $error("Zero assertion failed.");
    assert(sign == 0) else $error("Sign assertion failed.");

    // Test 13 | 15
    operation = BIT_OR;
    a = 13;
    b = 15;
    #2 assert(y == 15) else $error("OR assertion failed.");
    assert(zero == 0) else $error("Zero assertion failed.");
    assert(sign == 0) else $error("Sign assertion failed.");

    // Test 13 ^ 15
    operation = BIT_XOR;
    a = 13;
    b = 15;
    #2 assert(y == 2) else $error("XOR assertion failed.");
    assert(zero == 0) else $error("Zero assertion failed.");
    assert(sign == 0) else $error("Sign assertion failed.");

    // Test 13 & 15
    operation = BIT_NOT;
    a = 13;
    #2 assert(y == 242) else $error("NOT assertion failed.");
    assert(zero == 0) else $error("Zero assertion failed.");
    assert(sign == 1) else $error("Sign assertion failed.");

    // Test shift left
    operation = SHIFT_LEFT;
    carry_in = 1;
    a = 136;
    #2 assert(y == 16) else $error("Shift left assertion failed.");
    assert(carry_out == 1) else $error("carry assertion failed.");
    assert(zero == 0) else $error("Zero assertion failed.");
    assert(sign == 0) else $error("Sign assertion failed.");

    // Test shift right
    operation = SHIFT_RIGHT;
    a = 8;
    #2 assert(y == 4) else $error("Shift right assertion failed.");
    assert(carry_out == 0) else $error("carry assertion failed.");
    assert(zero == 0) else $error("Zero assertion failed.");
    assert(sign == 0) else $error("Sign assertion failed.");

    // Test rotate left
    operation = ROTATE_LEFT;
    a = 8;
    #2 assert(y == 17) else $error("Rotate left assertion failed.");
    assert(carry_out == 0) else $error("carry assertion failed.");
    assert(zero == 0) else $error("Zero assertion failed.");
    assert(sign == 0) else $error("Sign assertion failed.");

    // Test rotate right
    operation = ROTATE_RIGHT;
    a = 9;
    #2 assert(y == 132) else $error("Rotate right assertion failed.");
    assert(carry_out == 1) else $error("carry assertion failed.");
    assert(zero == 0) else $error("Zero assertion failed.");
    assert(sign == 1) else $error("Sign assertion failed.");

    #1 $finish();
  end

  always begin
    #1 clock = ~clock;
  end

endmodule

With the ALU working I’ll call it a wrap for this post. If you have any questions or feedback be sure to leave a comment. Keep tinkering!

Leave a Reply