bit32_4_2comp.v

hmac的verilog代码, 通过控制字选择进行sha1运算或hmac运算

//////////////////////////////////////////////////////////
//    module describe
// name: 		4-2 compressor(32 bit)
// function:	reduce the delay time for the add function
// writer:		zy
// data:		2006/04/01
// version:		1.0
// feature:		
//////////////////////////////////////////////////////////
 
 module bit32_4_2comp(a,b,c,d,sum1,sum2);
 
 input [31:0] a;
 input [31:0] b;
 input [31:0] c;
 input [31:0] d;
 
 output [31:0] sum1;
 output [31:0] sum2;
 
 wire [31:0] sum1;
 wire [31:0] carry;
 
 wire x0_out;
 wire x1_out;
 wire x2_out;
 wire x3_out;
 wire x4_out;
 wire x5_out;
 wire x6_out;
 wire x7_out;
 wire x8_out;
 wire x9_out;
 wire x10_out;
 wire x11_out;
 wire x12_out;
 wire x13_out;
 wire x14_out;
 wire x15_out;
 wire x16_out;
 wire x17_out;
 wire x18_out;
 wire x19_out;
 wire x20_out;
 wire x21_out;
 wire x22_out;
 wire x23_out;
 wire x24_out;
 wire x25_out;
 wire x26_out;
 wire x27_out;
 wire x28_out;
 wire x29_out;
 wire x30_out;
 wire x31_out;
 
 assign sum2[31:1]=carry[30:0];
 assign sum2[0]=0;
   
 bit4_2comp bit4_2comp0(a[0],b[0],c[0],d[0],1'b0,sum1[0],x0_out,carry[0]);
 bit4_2comp bit4_2comp1(a[1],b[1],c[1],d[1],x0_out,sum1[1],x1_out,carry[1]);
 bit4_2comp bit4_2comp2(a[2],b[2],c[2],d[2],x1_out,sum1[2],x2_out,carry[2]);
 bit4_2comp bit4_2comp3(a[3],b[3],c[3],d[3],x2_out,sum1[3],x3_out,carry[3]);
 bit4_2comp bit4_2comp4(a[4],b[4],c[4],d[4],x3_out,sum1[4],x4_out,carry[4]);
 bit4_2comp bit4_2comp5(a[5],b[5],c[5],d[5],x4_out,sum1[5],x5_out,carry[5]);
 bit4_2comp bit4_2comp6(a[6],b[6],c[6],d[6],x5_out,sum1[6],x6_out,carry[6]);
 bit4_2comp bit4_2comp7(a[7],b[7],c[7],d[7],x6_out,sum1[7],x7_out,carry[7]);
 bit4_2comp bit4_2comp8(a[8],b[8],c[8],d[8],x7_out,sum1[8],x8_out,carry[8]);
 bit4_2comp bit4_2comp9(a[9],b[9],c[9],d[9],x8_out,sum1[9],x9_out,carry[9]);
 bit4_2comp bit4_2comp10(a[10],b[10],c[10],d[10],x9_out,sum1[10],x10_out,carry[10]);
 bit4_2comp bit4_2comp11(a[11],b[11],c[11],d[11],x10_out,sum1[11],x11_out,carry[11]);
 bit4_2comp bit4_2comp12(a[12],b[12],c[12],d[12],x11_out,sum1[12],x12_out,carry[12]);
 bit4_2comp bit4_2comp13(a[13],b[13],c[13],d[13],x12_out,sum1[13],x13_out,carry[13]);
 bit4_2comp bit4_2comp14(a[14],b[14],c[14],d[14],x13_out,sum1[14],x14_out,carry[14]);
 bit4_2comp bit4_2comp15(a[15],b[15],c[15],d[15],x14_out,sum1[15],x15_out,carry[15]);
 bit4_2comp bit4_2comp16(a[16],b[16],c[16],d[16],x15_out,sum1[16],x16_out,carry[16]);
 bit4_2comp bit4_2comp17(a[17],b[17],c[17],d[17],x16_out,sum1[17],x17_out,carry[17]);
 bit4_2comp bit4_2comp18(a[18],b[18],c[18],d[18],x17_out,sum1[18],x18_out,carry[18]);
 bit4_2comp bit4_2comp19(a[19],b[19],c[19],d[19],x18_out,sum1[19],x19_out,carry[19]);
 bit4_2comp bit4_2comp20(a[20],b[20],c[20],d[20],x19_out,sum1[20],x20_out,carry[20]);
 bit4_2comp bit4_2comp21(a[21],b[21],c[21],d[21],x20_out,sum1[21],x21_out,carry[21]);
 bit4_2comp bit4_2comp22(a[22],b[22],c[22],d[22],x21_out,sum1[22],x22_out,carry[22]);
 bit4_2comp bit4_2comp23(a[23],b[23],c[23],d[23],x22_out,sum1[23],x23_out,carry[23]);
 bit4_2comp bit4_2comp24(a[24],b[24],c[24],d[24],x23_out,sum1[24],x24_out,carry[24]);
 bit4_2comp bit4_2comp25(a[25],b[25],c[25],d[25],x24_out,sum1[25],x25_out,carry[25]);
 bit4_2comp bit4_2comp26(a[26],b[26],c[26],d[26],x25_out,sum1[26],x26_out,carry[26]);
 bit4_2comp bit4_2comp27(a[27],b[27],c[27],d[27],x26_out,sum1[27],x27_out,carry[27]);
 bit4_2comp bit4_2comp28(a[28],b[28],c[28],d[28],x27_out,sum1[28],x28_out,carry[28]);
 bit4_2comp bit4_2comp29(a[29],b[29],c[29],d[29],x28_out,sum1[29],x29_out,carry[29]);
 bit4_2comp bit4_2comp30(a[30],b[30],c[30],d[30],x29_out,sum1[30],x30_out,carry[30]);
 bit4_2comp bit4_2comp31(a[31],b[31],c[31],d[31],x30_out,sum1[31],x31_out,carry[31]);

endmodule