multibooth.v

verilog 写的两种方式的乘法器 不错!

fulladder fa7(b0[9],b1[7],b2[5],k[7],j[7]);
fulladder fa8(b0[10],b1[8],b2[6],k[8],j[8]);
fulladder fa9(b0[11],b1[9],b2[7],k[9],j[9]);
fulladder fa10(b0[12],b1[10],b2[8],k[10],j[10]);
fulladder fa11(b0[13],b1[11],b2[9],k[11],j[11]);
fulladder fa12(b0[14],b1[12],b2[10],k[12],j[12]);
fulladder fa13(b0[15],b1[13],b2[11],k[13],j[13]);
fulladder fa14(b0[16],b1[14],b2[12],k[14],j[14]);
fulladder fa15(b0[17],b1[15],b2[13],k[15],j[15]);
fulladder fa16(b0[18],b1[16],b2[14],k[16],j[16]);
fulladder fa17(b0[19],b1[17],b2[15],k[17],j[17]);
fulladder fa18(b1[18],b2[16],b3[14],k[18],j[18]);
fulladder fa19(b2[17],b3[15],b4[13],k[19],j[19]);
fulladder fa20(b2[18],b3[16],b4[14],k[20],j[20]);
fulladder fa21(b3[17],b4[15],b5[13],k[21],j[21]);
fulladder fa22(b3[18],b4[16],b5[14],k[22],j[22]);
fulladder fa23(b4[17],b5[15],b6[13],k[23],j[23]);
fulladder fa24(b4[18],b5[16],b6[14],k[24],j[24]);
fulladder fa25(b5[17],b6[15],b7[13],k[25],j[25]);
fulladder fa26(b5[18],b6[16],b7[14],k[26],j[26]);
fulladder fa27(b6[17],b7[15],b8[13],k[27],j[27]);
fulladder fa28(b6[18],b7[16],b8[14],k[28],j[28]);
fulladder fa29(b3[2],b4[0],s[4],k[29],j[29]);
fulladder fa30(b3[4],b4[2],b5[0],k[30],j[30]);
fulladder fa31(b3[5],b4[3],b5[1],k[31],j[31]);
fulladder fa32(b3[6],b4[4],b5[2],k[32],j[32]);
fulladder fa33(b3[7],b4[5],b5[3],k[33],j[33]);
fulladder fa34(b3[8],b4[6],b5[4],k[34],j[34]);
fulladder fa35(b3[9],b4[7],b5[5],k[35],j[35]);
fulladder fa36(b3[10],b4[8],b5[6],k[36],j[36]);
fulladder fa37(b3[11],b4[9],b5[7],k[37],j[37]);
fulladder fa38(b3[12],b4[10],b5[8],k[38],j[38]);
fulladder fa39(b3[13],b4[11],b5[9],k[39],j[39]);
fulladder fa40(b4[12],b5[10],b6[8],k[40],j[40]);
fulladder fa41(b5[11],b6[9],b7[7],k[41],j[41]);
fulladder fa42(b5[12],b6[10],b7[8],k[42],j[42]);
fulladder fa43(b6[11],b7[9],b8[7],k[43],j[43]);
fulladder fa44(b6[12],b7[10],b8[8],k[44],j[44]);
fulladder fa45(b6[2],b7[0],s[7],k[45],j[45]);
fulladder fa46(b6[4],b7[2],b8[0],k[46],j[46]);
fulladder fa47(b6[5],b7[3],b8[1],k[47],j[47]);
fulladder fa48(b6[6],b7[4],b8[2],k[48],j[48]);
fulladder fa49(b6[7],b7[5],b8[3],k[49],j[49]);
halfadder ha50(b0[1],j[0],k[50],j[50]);
fulladder fa51(b0[3],b1[1],j[1],k[51],j[51]);
fulladder fa52(k[4],j[3],b3[0],k[52],j[52]);
fulladder fa53(k[5],j[4],b3[1],k[53],j[53]);
fulladder fa54(k[6],j[5],k[29],k[54],j[54]);
fulladder fa55(k[7],j[6],b3[3],k[55],j[55]);
fulladder fa56(k[8],j[8],k[30],k[56],j[56]);
fulladder fa57(k[9],j[7],k[31],k[57],j[57]);
fulladder fa58(k[10],j[9],k[32],k[58],j[58]);
fulladder fa59(k[11],j[10],k[33],k[59],j[59]);
fulladder fa60(k[12],j[11],k[34],k[60],j[60]);
fulladder fa61(k[13],j[12],k[35],k[61],j[61]);
fulladder fa62(k[14],j[13],k[36],k[62],j[62]);
fulladder fa63(k[15],j[14],k[37],k[63],j[63]);
fulladder fa64(k[16],j[15],k[38],k[64],j[64]);
fulladder fa65(k[17],j[16],k[39],k[65],j[65]);
fulladder fa66(k[18],j[17],k[40],k[66],j[66]);
fulladder fa67(k[19],j[18],k[41],k[67],j[67]);
fulladder fa68(k[20],j[19],k[42],k[68],j[68]);
fulladder fa69(k[21],j[20],k[43],k[69],j[69]);
fulladder fa70(k[22],j[21],k[44],k[70],j[70]);
fulladder fa71(k[23],j[22],j[44],k[71],j[71]);
fulladder fa72(k[24],j[23],b7[12],k[72],j[72]);
fulladder fa73(k[25],j[24],b8[11],k[73],j[73]);
fulladder fa74(k[26],j[25],b8[12],k[74],j[74]);
fulladder fa75(b7[17],b8[15],j[28],k[75],j[75]);
fulladder fa76(j[31],b6[0],s[6],k[76],j[76]);
fulladder fa77(j[34],j[45],b6[3],k[77],j[77]);
fulladder fa78(j[36],k[47],j[46],k[78],j[78]);
fulladder fa79(j[37],k[48],j[47],k[79],j[79]);
fulladder fa80(j[38],k[49],j[48],k[80],j[80]);
fulladder fa81(j[39],j[49],b7[6],k[81],j[81]);
halfadder ha82(k[1],j[50],k[82],j[82]);
fulladder fa83(k[2],s[2],j[51],k[83],j[83]);
fulladder fa84(k[55],j[54],b4[1],k[84],j[84]);
fulladder fa85(k[56],j[55],s[5],k[85],j[85]);
fulladder fa86(k[57],j[56],j[30],k[86],j[86]);
fulladder fa87(k[58],j[57],k[76],k[87],j[87]);
fulladder fa88(k[59],j[58],j[76],k[88],j[88]);
fulladder fa89(k[60],j[59],j[33],k[89],j[89]);
fulladder fa90(k[61],j[60],k[77],k[90],j[90]);
fulladder fa91(k[62],j[61],j[77],k[91],j[91]);
fulladder fa92(k[63],j[62],k[78],k[92],j[92]);
fulladder fa93(k[64],j[63],k[79],k[93],j[93]);
fulladder fa94(k[65],j[64],k[80],k[94],j[94]);
fulladder fa95(k[66],j[65],k[81],k[95],j[95]);
fulladder fa96(k[67],j[66],j[81],k[96],j[96]);
fulladder fa97(k[68],j[67],j[41],k[97],j[97]);
fulladder fa98(k[69],j[68],j[42],k[98],j[98]);
fulladder fa99(k[70],j[69],j[43],k[99],j[99]);
fulladder fa100(k[71],j[70],b7[11],k[100],j[100]);
fulladder fa101(k[72],j[71],b8[10],k[101],j[101]);
fulladder fa102(k[27],j[26],j[74],k[102],j[102]);
halfadder ha103(k[28],j[27],k[103],j[103]);
halfadder ha104(k[51],j[82],k[104],j[104]);
fulladder fa105(k[3],j[2],j[83],k[105],j[105]);
fulladder fa106(k[88],j[87],j[32],k[106],j[106]);
fulladder fa107(k[89],j[88],k[45],k[107],j[107]);
fulladder fa108(k[90],j[89],b7[1],k[108],j[108]);
fulladder fa109(k[91],j[90],j[35],k[109],j[109]);
fulladder fa110(k[93],j[92],j[78],k[110],j[110]);
fulladder fa111(k[94],j[93],j[79],k[111],j[111]);
fulladder fa112(k[95],j[94],j[80],k[112],j[112]);
fulladder fa113(k[96],j[95],j[40],k[113],j[113]);
fulladder fa114(k[97],j[96],b8[6],k[114],j[114]);
fulladder fa115(k[100],j[99],b8[9],k[115],j[115]);
halfadder ha116(k[101],j[100],k[116],j[116]);
fulladder fa117(j[101],k[73],j[72],k[117],j[117]);
halfadder ha118(k[74],j[73],k[118],j[118]);
halfadder ha119(k[83],j[104],k[119],j[119]);
halfadder ha120(k[52],s[3],j[105],j[120]);
halfadder ha121(k[53],j[52],k[121],j[121]);
halfadder ha122(k[54],j[53],k[122],j[122]);
halfadder ha123(k[84],j[29],k[123],j[123]);
halfadder ha124(k[85],j[84],k[124],j[124]);
halfadder ha125(k[86],j[85],k[125],j[125]);
halfadder ha126(k[87],j[86],k[126],j[126]);
halfadder ha127(k[106],b6[1],k[127],j[127]);
halfadder ha128(k[107],j[106],k[128],j[128]);
halfadder ha129(k[108],j[107],k[129],j[129]);
fulladder fa130(k[109],k[46],j[108],k[130],j[130]);
fulladder fa131(k[92],j[91],j[109],k[131],j[131]);
halfadder ha132(k[112],j[111],k[132],j[132]);
fulladder fa133(k[113],k[112],b8[5],k[133],j[133]);
halfadder ha134(k[114],j[113],k[134],j[134]);
fulladder fa135(k[98],j[97],j[114],k[135],j[135]);
halfadder ha136(k[99],j[98],k[136],j[136]);
cla32      cla (m,n,1'b1,sum,co);
endmodule
module fulladder(a,b,cin,sum,co);
input a,b,cin;
output sum,co;
assign sum=a^b^cin;
assign co=(a&b)|(a&cin)|(b&cin);
endmodule

module halfadder(a,b,sum,co);
input a,b;
output sum,co;
assign sum=a^b;
assign co=a&b;
endmodule

module booth(x1,x2,x3,y1,y2,p);
input x1,x2,x3,y1,y2;
output p;
wire one,double,m;
wire temp1,temp2,temp3,temp4,temp5;
assign one=x1^x2;
assign temp1=x1&x2&(~x3);
assign temp2=(~x1)&(~x2)&x3;
assign double=temp1|temp2;
assign m=x3;
assign temp3=y2&one;
assign temp4=y1&double;
assign temp5=~(temp3|temp4);
assign p=~(temp5^m);
endmodule

module cla32 (a,b,cin,sum,co);
input [31:0] a,b;
input cin;
output [31:0] sum;
output co;
reg [31:0] G1,P1,G2,P2,G3,P3,G4,P4,G5,P5;
reg [31:0] cout;
wire[31:0] sum,G0,P0;
assign P0=a^b;
assign G0=a&b;
assign sum=P0^{cout[30:0],cin};
assign co=cout[31];
always @(P0 or G0 or P1 or G1 or P2 or G2 or P3 or G3 or P4 or G4 or P5 or G5 )
begin 
  P1[31:1]=P0[31:1]&P0[30:0];
  G1[31:1]=G0[31:1]|P0[31:1]&G0[30:0];
  G1[0]=G0[0];
  P1[0]=P0[0];
  P2[31:2]=P1[31:2]&P1[29:0];
  G2[31:2]=G1[31:2]|P1[31:2]&G1[29:0]; 
  G2[1:0]=G1[1:0];
  P2[1:0]=P1[1:0];
  P3[31:4]=P2[31:4]&P2[27:0];
  G3[31:4]=G2[31:4]|P2[31:4]&G2[27:0]; 
  G3[3:0]=G2[3:0];
  P3[3:0]=P2[3:0];
  P4[31:8]=P3[31:8]&P3[23:0];
  G4[31:8]=G3[31:8]|P3[31:8]&G3[23:0]; 
  G4[7:0]=G3[7:0];
  P4[7:0]=P3[7:0];
  P5[31:16]=P4[31:16]&P4[15:0];
  G5[31:16]=G4[31:16]|P4[31:16]&G4[15:0];
  G5[15:0]=G4[15:0];
  P5[15:0]=P4[15:0];
  cout=G5|P5&cin;  
end
endmodule