alu.v

使用verilog作为CPU设计语言实现单数据通路五级流水线的CPU。具有32个通用寄存器、一个程序计数器PC、一个标志寄存器FLAG

module alu(A,B,OP,Y,OV,CY,Zero,Signal);
input [31:0]A,B;
output [31:0]Y;
output OV,CY,Zero,Signal;
input [3:0]OP;

wire [31:0]Logic_out,Adder_out,Shift_out,M1_out,M2_out,Mul_out,nMul_out,Mul_out1,Div_out,nDiv_out,Div_out1,MulDiv;
wire Mul_control;

assign SIGNAL=Y[31];
assign Div_out[31:16]=Div_out[15];
assign nDiv_out[31:16]=0;
nor no1(ZERO,Y[0],Y[1],Y[2],Y[3],Y[4],Y[5],Y[6],Y[7],Y[8],Y[9],Y[10],Y[11],Y[12],Y[13],Y[14],Y[15],Y[16],Y[17],Y[18],Y[19],Y[20],Y[21],Y[22],Y[23],Y[24],Y[25],Y[26],Y[27],Y[28],Y[29],Y[30],Y[31]);

/*//Multiplier(A[15:0],B[15:0],Mul_out[31:0]);
n//Multiplier(A[15:0],B[15:0],nMul_out[31:0]);
//Divider(A[31:0],B[15:0],Div_out[15:0]);
//nDivider(A[31:0],B[15:0],nDiv_out[15:0]);*/
Shift Sh(Shift_out,A,B,OP[1:0]);
alu_logic LOGIC(Logic_out,A,B,OP[1:0]);
AddSub1 (Adder_out,CY,OV,A,B,OP[1:0]);
mux32x2_1(Div_out1,Div_out,nDiv_out,OP[1]);
mux32x2_1(Mul_out1,Mul_out,nMul_out,OP[1]);
mux32x2_1(MulDiv,Mul_out1,Div_out1,OP[0]);
mux32x2_1(M1_out,Adder_out,MulDiv,OP[2]);
mux32x2_1(M2_out,Logic_out,Shift_out,OP[2]);
mux32x2_1(Y,M1_out,M2_out,OP[3]);

endmodule

module alu_logic(C,A,B,op); 
input [31:0]A,B;
output [31:0]C;
input [1:0]op;
logic_1(C[0],A[0],B[0],op);
logic_1(C[1],A[1],B[1],op);
logic_1(C[2],A[2],B[2],op);
logic_1(C[3],A[3],B[3],op);
logic_1(C[4],A[4],B[4],op);
logic_1(C[5],A[5],B[5],op);
logic_1(C[6],A[6],B[6],op);
logic_1(C[7],A[7],B[7],op);
logic_1(C[8],A[8],B[8],op);
logic_1(C[9],A[9],B[9],op);
logic_1(C[10],A[10],B[10],op);
logic_1(C[11],A[11],B[11],op);
logic_1(C[12],A[12],B[12],op);
logic_1(C[13],A[13],B[13],op);
logic_1(C[14],A[14],B[14],op);
logic_1(C[15],A[15],B[15],op);
logic_1(C[16],A[16],B[16],op);
logic_1(C[17],A[17],B[17],op);
logic_1(C[18],A[18],B[18],op);
logic_1(C[19],A[19],B[19],op);
logic_1(C[20],A[20],B[20],op);
logic_1(C[21],A[21],B[21],op);
logic_1(C[22],A[22],B[22],op);
logic_1(C[23],A[23],B[23],op);
logic_1(C[24],A[24],B[24],op);
logic_1(C[25],A[25],B[25],op);
logic_1(C[26],A[26],B[26],op);
logic_1(C[27],A[27],B[27],op);
logic_1(C[28],A[28],B[28],op);
logic_1(C[29],A[29],B[29],op);
logic_1(C[30],A[30],B[30],op);
logic_1(C[31],A[31],B[31],op);
endmodule

module logic_1(C,A,B,op);
input A,B;
input [1:0]op;
output C;
wire [3:0]N;
and(N[0],A,B);
or(N[1],A,B);
xor(N[2],A,B);
not(N[3],A);
mux4_1(C,N[0],N[1],N[2],N[3],op[1],op[0]);
endmodule

module Shift(Y,A,B,op);
output [31:0]Y;
input [31:0]A,B;
input [1:0]op;
wire [31:0]S,Z;
wire [31:0]con1,con2,con3,con4,con5,temp1,temp2,temp3,temp4;
assign Z=32'b0;
assign S={32{A[31]}};
mux32x4_1 mux4_1(con1,{A[15:0],Z[31:16]},{Z[15:0],A[31:16]},{S[15:0],A[31:16]},{A[15:0],A[31:16]},op[1],op[0]);
mux32x2_1 mux2_1(temp1,A[31:0],con1,B[4]);
mux32x4_1 mux4_2(con2,{temp1[23:0],Z[31:24]},{Z[7:0],temp1[31:8]},{S[7:0],temp1[31:8]},{temp1[7:0],temp1[31:8]},op[1],op[0]);
mux32x2_1 mux2_2(temp2,temp1,con2,B[3]);
mux32x4_1 mux4_3(con3,{temp2[27:0],Z[31:28]},{Z[3:0],temp2[31:4]},{S[3:0],temp2[31:4]},{temp2[3:0],temp2[31:4]},op[1],op[0]);
mux32x2_1 mux2_3(temp3,temp2,con3,B[2]);
mux32x4_1 mux4_4(con4,{temp3[29:0],Z[31:30]},{Z[1:0],temp3[31:2]},{S[1:0],temp3[31:2]},{temp3[1:0],temp3[31:2]},op[1],op[0]);
mux32x2_1 mux2_4(temp4,temp3,con4,B[1]);
mux32x4_1 mux4_5(con5,{temp4[30:0],Z[31]},{Z[0],temp4[31:1]},{S[0],temp4[31:1]},{temp4[0],temp4[31:1]},op[1],op[0]);
mux32x2_1 mux2_5(Y,temp4,con5,B[0]);
endmodule

module AddSub1(Y,CY,OV,A,B,op);
output [31:0]Y;
output CY,OV;
input [31:0]A,B;
input [1:0]op;
wire [31:0] AddTempB;
xor_32_1 xor1(AddTempB,B,op[0]);
Adder32 Adder1(Y,CY,OV,A,AddTempB,op[0],op[1]);
endmodule

module xor_32_1(xorout,xorin,Sub);
output [31:0] xorout;
input [31:0] xorin;
input Sub;
wire [31:0] temp;
assign temp = {32{Sub}};
assign xorout = xorin^temp;
endmodule

module Adder32(Y,CY,OV,A,B,Cin,Flag);
output [31:0]Y;
output CY,OV;
input [31:0]A,B;
input Cin;
input Flag;
wire [3:0]C,G,P;
assign C[0]=Cin;
Adder8 Adder0(Y[7:0],G[0],P[0],A[7:0],B[7:0],C[0]);
assign C[1] = G[0]|P[0]&C[0];
Adder8 Adder1(Y[15:8],G[1],P[1],A[15:8],B[15:8],C[1]);
assign C[2]=G[1]|P[1]&G[0]|P[1]&P[0]&C[0];
Adder8 Adder2(Y[23:16],G[2],P[2],A[23:16],B[23:16],C[2]);
assign C[3]=G[2]|P[2]&G[1]|P[2]&P[1]&G[0]|P[2]&P[1]&P[0]&C[0];
Adder8 Adder3(Y[31:24],G[3],P[3],A[31:24],B[31:24],C[3]);
assign CY = G[3]|P[3]&G[2]|P[3]&P[2]&G[1]|P[3]&P[2]&P[1]&G[0]|P[3]&P[2]&P[1]&P[0]&C[0];
assign OV = (CY^C[3])&(~Flag);
endmodule

module Adder8(Y,Gout,Pout,A,B,Cin);
output [7:0] Y;
output Gout,Pout;
input [7:0] A,B;
input Cin;
wire [7:0] P,G,C;
assign G = A&B;
assign P = A^B;
assign Gout = G[7]|P[7]&G[6]|P[7]&P[6]&G[5]|P[7]&P[6]&P[5]&G[4]|P[7]&P[6]&P[5]&P[4]&G[3]|P[7]&P[6]&P[5]&P[4]&P[3]&G[2]|P[7]&P[6]&P[5]&P[4]&P[3]&P[2]&G[1]|P[7]&P[6]&P[5]&P[4]&P[3]&P[2]&P[1]&G[0];
assign	Pout = P[7]&P[6]&P[5]&P[4]&P[3]&P[2]&P[1]&P[0];
assign  C[0] = Cin;
assign 	C[1] = G[0]|P[0]&C[0];
assign  C[2] = G[1]|P[1]&G[0]|P[1]&P[0]&C[0];
assign  C[3] = G[2]|P[2]&G[1]|P[2]&P[1]&G[0]|P[2]&P[1]&P[0]&C[0];
assign  C[4] = G[3]|P[3]&G[2]|P[3]&P[2]&G[1]|P[3]&P[2]&P[1]&G[0]|P[3]&P[2]&P[1]&P[0]&C[0];
assign  C[5] = G[4]|P[4]&G[3]|P[4]&P[3]&G[2]|P[4]&P[3]&P[2]&G[1]|P[4]&P[3]&P[2]&P[1]&G[0]|P[4]&P[3]&P[2]&P[1]&P[0]&C[0];
assign	C[6] = G[5]|P[5]&G[4]|P[5]&P[4]&G[3]|P[5]&P[4]&P[3]&G[2]|P[5]&P[4]&P[3]&P[2]&G[1]|P[5]&P[4]&P[3]&P[2]&P[1]&G[0]|P[5]&P[4]&P[3]&P[2]&P[1]&P[0]&C[0];
assign  C[7] = G[6]|P[6]&G[5]|P[6]&P[5]&G[4]|P[6]&P[5]&P[4]&G[3]|P[6]&P[5]&P[4]&P[3]&G[2]|P[6]&P[5]&P[4]&P[3]&P[2]&G[1]|P[6]&P[5]&P[4]&P[3]&P[2]&P[1]&G[0]|P[6]&P[5]&P[4]&P[3]&P[2]&P[1]&P[0]&C[0];
assign	Y = P^C;
endmodule

/*module Multiplier(Aa,Bb,Cz);
input[15:0]Aa,Bb;
wire[14:0]B;
output[31:0]Cz;
wire Sign,Zero;
wire[15:0] W0,W1,W2,W3,W4,W5,W6,W7,W8,W9,W10,W11,W12,W13,W14,W15;
wire[15:0] C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15;
wire[15:0] S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15;
wire[29:0] C;
wire[14:0] A;
wire[15:1] inter;

assign Zero=0;
xor X(Sign,Aa[15],Bb[15]);

Inverter15 in1(Aa[15],Aa[14:0],A[14:0]);
Inverter15 in2(Bb[15],Bb[14:0],B[14:0]);
and
An0[14:0]({W0[14:1],C[0]},B[0],A[14:0]),
An1[14:0](W1[14:0],B[1],A[14:0]),
An2[14:0](W2[14:0],B[2],A[14:0]),
An3[14:0](W3[14:0],B[3],A[14:0]),
An4[14:0](W4[14:0],B[4],A[14:0]),
An5[14:0](W5[14:0],B[5],A[14:0]),
An6[14:0](W6[14:0],B[6],A[14:0]),
An7[14:0](W7[14:0],B[7],A[14:0]),
An8[14:0](W8[14:0],B[8],A[14:0]),
An9[14:0](W9[14:0],B[9],A[14:0]),
An10[14:0](W10[14:0],B[10],A[14:0]),
An11[14:0](W11[14:0],B[11],A[14:0]),
An12[14:0](W12[14:0],B[12],A[14:0]),
An13[14:0](W13[14:0],B[13],A[14:0]),
An14[14:0](W14[14:0],B[14],A[14:0]);
CSA csa2({W2[13:0],Zero},W1[14:0],{Zero,W0[14:1]},{S2[14:1],C[1]},C2[14:0]);
CSA csa3({W3[13:0],Zero},{W2[14],S2[14:1]},C2[14:0],{S3[14:1],C[2]},C3[14:0]);
CSA csa4({W4[13:0],Zero},{W3[14],S3[14:1]},C3[14:0],{S4[14:1],C[3]},C4[14:0]);
CSA csa5({W5[13:0],Zero},{W4[14],S4[14:1]},C4[14:0],{S5[14:1],C[4]},C5[14:0]);
CSA csa6({W6[13:0],Zero},{W5[14],S5[14:1]},C5[14:0],{S6[14:1],C[5]},C6[14:0]);
CSA csa7({W7[13:0],Zero},{W6[14],S6[14:1]},C6[14:0],{S7[14:1],C[6]},C7[14:0]);
CSA csa8({W8[13:0],Zero},{W7[14],S7[14:1]},C7[14:0],{S8[14:1],C[7]},C8[14:0]);
CSA csa9({W9[13:0],Zero},{W8[14],S8[14:1]},C8[14:0],{S9[14:1],C[8]},C9[14:0]);
CSA csa10({W10[13:0],Zero},{W9[14],S9[14:1]},C9[14:0],{S10[14:1],C[9]},C10[14:0]);
CSA csa11({W11[13:0],Zero},{W10[14],S10[14:1]},C10[14:0],{S11[14:1],C[10]},C11[14:0]);
CSA csa12({W12[13:0],Zero},{W11[14],S11[14:1]},C11[14:0],{S12[14:1],C[11]},C12[14:0]);
CSA csa13({W13[13:0],Zero},{W12[14],S12[14:1]},C12[14:0],{S13[14:1],C[12]},C13[14:0]);
CSA csa14({W14[13:0],Zero},{W13[14],S13[14:1]},C13[14:0],{S14[14:1],C[13]},C14[14:0]);
CSA cso({W14[14],S14[14:1]},C14[14:0],{inter[14:1],Zero},C[28:14],{C[29],inter[14:1]});
Inverter30 in3(Sign,C[29:0],Cz[29:0]);
assign Cz[30]=Sign;
assign Cz[31]=Sign;
endmodule

module CSA(A,B,Cin,Sum,Cout);
input[14:0] A,B,Cin;
output[14:0] Sum,Cout;
wire[14:0] Temp1,Temp2,Temp3;
xor
xr1[14:0](Temp1,A,B),
xr2[14:0](Sum,Temp1,Cin);
nand 
nd1[14:0](Temp2,Temp1,Cin),
nd2[14:0](Temp3,A,B),
nd3[14:0](Cout,Temp2,Temp3);
endmodule

module Inverter15(Flag,In,Out);
input[14:0] In;
input Flag;
output[14:0] Out;
wire[14:0] W;
xor
X[14:0](W[14:0],In[14:0],Flag);
wire[15:1] inter;
Halfadder15 H(W[14:0],{inter[14:1],Flag},Out[14:0],inter[15:1]);
endmodule

module Halfadder15(A,B,S,C);
input[14:0] A,B;
output[14:0] C,S;
and
a[14:0](C[14:0],A[14:0],B[14:0]);
xor
x[14:0](S[14:0],A[14:0],B[14:0]);
endmodule

module Inverter30(Flag,In,Out);
input[29:0] In;
input Flag;
output[29:0] Out;
wire[29:0] W;
xor
X[29:0](W[29:0],In[29:0],Flag);
wire[30:1] inter;
Halfadder30 H(W[29:0],{inter[29:1],Flag},Out[29:0],inter[30:1]);
endmodule

module Halfadder30(A,B,S,C);
input[29:0] A,B;
output[29:0] C,S;
and 
a[29:0](C[29:0],A[29:0],B[29:0]);
xor
x[29:0](S[29:0],A[29:0],B[29:0]);
endmodule

module nMultiplier(A,B,C);
input[15:0]A,B;
output[31:0]C;
wire[15:0] W0,W1,W2,W3,W4,W5,W6,W7,W8,W9,W10,W11,W12,W13,W14,W15;
wire[15:0] C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15;
wire[15:0] S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15;
wire[15:1] inter;
wire Zero;

assign Zero=0;

and
An0[15:0]({W0[15:1],C[0]},B[0],A[15:0]),
An1[15:0](W1[15:0],B[1],A[15:0]),
An2[15:0](W2[15:0],B[2],A[15:0]),
An3[15:0](W3[15:0],B[3],A[15:0]),
An4[15:0](W4[15:0],B[4],A[15:0]),
An5[15:0](W5[15:0],B[5],A[15:0]),
An6[15:0](W6[15:0],B[6],A[15:0]),
An7[15:0](W7[15:0],B[7],A[15:0]),
An8[15:0](W8[15:0],B[8],A[15:0]),
An9[15:0](W9[15:0],B[9],A[15:0]),
An10[15:0](W10[15:0],B[10],A[15:0]),
An11[15:0](W11[15:0],B[11],A[15:0]),
An12[15:0](W12[15:0],B[12],A[15:0]),
An13[15:0](W13[15:0],B[13],A[15:0]),
An14[15:0](W14[15:0],B[14],A[15:0]),
An15[15:0](W15[15:0],B[15],A[15:0]);
CSA15 csa2({W2[14:0],Zero},W1[15:0],{Zero,W0[15:1]},{S2[15:1],C[1]},C2[15:0]);
CSA15 csa3({W3[14:0],Zero},{W2[15],S2[15:1]},C2[15:0],{S3[15:1],C[2]},C3[15:0]);
CSA15 csa4({W4[14:0],Zero},{W3[15],S3[15:1]},C3[15:0],{S4[15:1],C[3]},C4[15:0]);
CSA15 csa5({W5[14:0],Zero},{W4[15],S4[15:1]},C4[15:0],{S5[15:1],C[4]},C5[15:0]);
CSA15 csa6({W6[14:0],Zero},{W5[15],S5[15:1]},C5[15:0],{S6[15:1],C[5]},C6[15:0]);
CSA15 csa7({W7[14:0],Zero},{W6[15],S6[15:1]},C6[15:0],{S7[15:1],C[6]},C7[15:0]);
CSA15 csa8({W8[14:0],Zero},{W7[15],S7[15:1]},C7[15:0],{S8[15:1],C[7]},C8[15:0]);
CSA15 csa9({W9[14:0],Zero},{W8[15],S8[15:1]},C8[15:0],{S9[15:1],C[8]},C9[15:0]);
CSA15 csa10({W10[14:0],Zero},{W9[15],S9[15:1]},C9[15:0],{S10[15:1],C[9]},C10[15:0]);
CSA15 csa11({W11[14:0],Zero},{W10[15],S10[15:1]},C10[15:0],{S11[15:1],C[10]},C11[15:0]);
CSA15 csa12({W12[14:0],Zero},{W11[15],S11[15:1]},C11[15:0],{S12[15:1],C[11]},C12[15:0]);
CSA15 csa13({W13[14:0],Zero},{W12[15],S12[15:1]},C12[15:0],{S13[15:1],C[12]},C13[15:0]);
CSA15 csa14({W14[14:0],Zero},{W13[15],S13[15:1]},C13[15:0],{S14[15:1],C[13]},C14[15:0]);
CSA15 csa15({W15[14:0],Zero},{W14[15],S14[15:1]},C14[15:0],{S15[15:1],C[14]},C15[15:0]);
CSA15 cso({W15[15],S15[15:1]},C15[15:0],{inter[15:1],Zero},C[30:15],{C[31],inter[15:1]});
endmodule

module CSA15(A,B,Cin,Sum,Cout);
input[15:0] A,B,Cin;
output[15:0] Sum,Cout;
wire[15:0] Temp1,Temp2,Temp3;
xor
xr1[15:0](Temp1,A,B),
xr2[15:0](Sum,Temp1,Cin);
nand 
nd1[15:0](Temp2,Temp1,Cin),
nd2[15:0](Temp3,A,B),
nd3[15:0](Cout,Temp2,Temp3);
endmodule*/