利用Verilog32位ALU设计

    利用控制信号S选择逻辑功能，产生CLA进位链，可实现算术32位逻辑单元设计

         CLA进位链信号的产生：

  

本文有两种思路：

1、先产生1位ALU，再通过例化32次产生32位

2、先产生4位ALU，再通过例化8次产生32位

---

第一种：

//一位ALU设计
`timescale 1ns/1ns
module ALU_1bit 
(
input wire  a,
            b,
input wire [3:0] s,
input wire  m,
            ci,
output wire do,
output wire co
);
wire p , g;
assign do = p ^ ci;
assign co = g | ( p & ci );
assign p = ~( s[3] & a & b |
             s[2] & a & ~b |
             s[1] & ~a & b |
             s[0] & ~a & ~b );
assign g = s[3] & a & b |
s[2] & a & ~b |
(~m);
endmodule

//16位ALU设计
`timescale 1ns/1ns
module ALU_RPL32 
(
input wire [31 : 0] opA , //操作数A
                    opB , //操作数B
input wire [3 : 0] S , //工作模式
input wire M , //逻辑操作
           Cin , //进位输入
output wire [31 : 0] DO , //数据输出
output wire N ,
            Z ,
            V ,
            C
);
wire [32 : 0] c;
assign c[0] = Cin;
assign C = c[32];
assign V = c[32] ^ c[31];
assign N = DO[31];
assign Z = !(|DO);
generate        //generate语句进行模块例化
genvar i;
for (i = 0; i < 32; i = i + 1) begin : u
ALU_1bit uALU1bit(
.a ( opA[i] ) ,
.b ( opB[i] ) , 
.s ( S ) ,
.m ( M ) ,
.ci ( c[i] ), 
.co ( c[i + 1] ) , 
.do ( DO[i] )
);
end
endgenerate
endmodule

---

第二种：

//4位ALU设计
module ALU_CLA4_G(
input wire [3:0] a ,
b ,
input wire ci ,
input wire M ,
input wire [3:0] S , 
output wire [3:0] Do , 
output wire co ,
output wire V ,
Z
);
reg [3 : 0] g , p ;
wire [3 : 0] G , P ;
wire [4 : 0] c ;
integer i;
always @(*)
for( i = 0; i < 4; i = i + 1) begin
g[i] = ( S[3] & a[i] & b[i] ) ||
      ( S[2] & a[i] & !b[i] ) ||
        !M;
p[i] = !( ( S[3] & a[i] & b[i] ) ||
         ( S[2] & a[i] & !b[i] ) ||
         ( S[1] & !a[i] & b[i] ) ||
         ( S[0] & !a[i] & !b[i] ) );
                               end
assign G[0] = g[0] ;
assign G[1] = g[1] | ( p[1] & G[0] ) ;
assign G[2] = g[2] | ( p[2] & G[1] ) ;
assign G[3] = g[3] | ( p[3] & G[2] ) ; 
assign P[0] = p[0] ;
assign P[1] = p[1] & P[0] ;
assign P[2] = p[2] & P[1] ;
assign P[3] = p[3] & P[2] ; 
assign c[0] = ci ;
assign c[4 : 1] = G | ( P & {4{c[0]}} );
assign Do = p ^ c[3 : 0];
assign co = c[4];
assign V = c[4] ^ c[3];
assign Z = ! ( | Do);
endmodule

//16位ALU设计
`timescale 1ns/1ns
module ALU_CLA32 
(
input wire [31 : 0] opA , //操作数A
                    opB , //操作数B
input wire [3 : 0] S , //工作模式
input wire             M , //逻辑操作
           Cin , //进位输入
output wire [31 : 0] DO , //数据输出
output wire N ,
            Z ,
            V ,
            C
);
wire [8 : 0] Co;
wire [7 : 0] Zo, Vo;
assign Co[0] = Cin;
generate
genvar i;
for( i = 0; i < 8; i = i + 1 ) begin : u
ALU_CLA4_G uALU_CLA4_G(
.a ( opA[i*4 + 3 : i*4] ),
.b ( opB[i*4 + 3 : i*4] ),
.ci ( Co[i] ),
.M ( M ),
.S ( S ),
.Do ( DO[i*4 + 3 : i*4] ),
.co ( Co[ i+1 ] ),
.V ( Vo[ i ] ),
.Z ( Zo[ i ] )
);
end
endgenerate
assign V = Vo[ 7];
assign N = DO[31];
assign C = Co[ 8];
assign Z = & Zo;
endmodule

---

32位ALU测试程序

`timescale 1ns/1ns
module ALU_CLA32_tb();
reg [31 : 0] opA ,
opB ;
reg [3 : 0] S ;
reg M ,
Cin ;
wire [31 : 0] DO ;
wire N , Z ,
V , C ;
ALU_CLA32 uALU32(
.opA ( opA ), //操作数A
.opB ( opB ), //操作数B
.S ( S ), //工作模式选择信号
.M ( M ), //逻辑操作控制信号
.Cin ( Cin ), //进位输入信号
.DO ( DO ), //数据输出
.N ( N ),
.Z ( Z ),
.V ( V ),
.C ( C )
);
initial begin
opA = 32'hFFFF_FFFF;
opB = 32'h0000_0001;
S = 4'b1001;
M = 1'b1;
Cin = 1'b0;
#10 opA = 32'hFFFF_FFFF;
opB = 32'h0000_0000;
#10 opA = 32'hFFFF_FFFF;
opB = 32'hFFFF_FFFF;
#10 opA = 32'h7FFF_FFFF;
opB = 32'h0FFF_FFFF;
#10 opA = 32'h3FFF_FFFF;
opB = 32'h0FFF_FFFF;
#10 $finish;
end
endmodule