tc_max_abs_dif_add15.v 12.5 KB
////////////////////////////////////////////////////////////////////////
//
// Project Reality
//
// module:	tc_max_abs_dif_add15
// description:	15 bit carry-propagating adder for use in tc lod,
//		with assumed carry in and carry out (for abs dif).
//		Assumes n = ~b (for speed).
//		Conditional sum adder.
//
// designer:	Phil Gossett
// date:	6/4/95
//
////////////////////////////////////////////////////////////////////////

// $Id: tc_max_abs_dif_add15.v,v 1.1 2002/03/28 00:26:13 berndt Exp $

module tc_max_abs_dif_add15 (a, b, n, s, co) ;

input [14:0] a;
input [14:0] b;
input [14:0] n;	// n = ~b

output [14:0] s;
output co;

wire [14:0] s0;	// sum out assuming carry in 0
wire [14:0] s1;	// sum out assuming carry in 1
wire [14:0] c0;	// carry out assuming carry in 0
wire [14:0] c1;	// carry out assuming carry in 1

// conditional cells:

xo02d1h s10  (.a1(a[0]), .a2(n[0]), .z(s1[0])); // assume carry in
assign s0[0] = s1[0];
or02d2  c10  (.a1(a[0]), .a2(b[0]), .z(c1[0]));	// assume carry in
assign c0[0] = c1[0];

xo02d1h s01  (.a1(a[1]), .a2(b[1]), .z(s0[1]));
xo02d1h s11  (.a1(a[1]), .a2(n[1]), .z(s1[1]));
an02d1h c01  (.a1(a[1]), .a2(b[1]), .z(c0[1]));
or02d2  c11  (.a1(a[1]), .a2(b[1]), .z(c1[1]));

xo02d1h s02  (.a1(a[2]), .a2(b[2]), .z(s0[2]));
xo02d1h s12  (.a1(a[2]), .a2(n[2]), .z(s1[2]));
an02d1h c02  (.a1(a[2]), .a2(b[2]), .z(c0[2]));
or02d2  c12  (.a1(a[2]), .a2(b[2]), .z(c1[2]));

xo02d1h s03  (.a1(a[3]), .a2(b[3]), .z(s0[3]));
xo02d1h s13  (.a1(a[3]), .a2(n[3]), .z(s1[3]));
an02d1h c03  (.a1(a[3]), .a2(b[3]), .z(c0[3]));
or02d2  c13  (.a1(a[3]), .a2(b[3]), .z(c1[3]));

xo02d1h s04  (.a1(a[4]), .a2(b[4]), .z(s0[4]));
xo02d1h s14  (.a1(a[4]), .a2(n[4]), .z(s1[4]));
an02d1h c04  (.a1(a[4]), .a2(b[4]), .z(c0[4]));
or02d2  c14  (.a1(a[4]), .a2(b[4]), .z(c1[4]));

xo02d1h s05  (.a1(a[5]), .a2(b[5]), .z(s0[5]));
xo02d1h s15  (.a1(a[5]), .a2(n[5]), .z(s1[5]));
an02d1h c05  (.a1(a[5]), .a2(b[5]), .z(c0[5]));
or02d2  c15  (.a1(a[5]), .a2(b[5]), .z(c1[5]));

xo02d1h s06  (.a1(a[6]), .a2(b[6]), .z(s0[6]));
xo02d1h s16  (.a1(a[6]), .a2(n[6]), .z(s1[6]));
an02d1h c06  (.a1(a[6]), .a2(b[6]), .z(c0[6]));
or02d2  c16  (.a1(a[6]), .a2(b[6]), .z(c1[6]));

xo02d1h s07  (.a1(a[7]), .a2(b[7]), .z(s0[7]));
xo02d1h s17  (.a1(a[7]), .a2(n[7]), .z(s1[7]));
an02d1h c07  (.a1(a[7]), .a2(b[7]), .z(c0[7]));
or02d2  c17  (.a1(a[7]), .a2(b[7]), .z(c1[7]));

xo02d1h s08  (.a1(a[8]), .a2(b[8]), .z(s0[8]));
xo02d1h s18  (.a1(a[8]), .a2(n[8]), .z(s1[8]));
an02d1h c08  (.a1(a[8]), .a2(b[8]), .z(c0[8]));
or02d2  c18  (.a1(a[8]), .a2(b[8]), .z(c1[8]));

xo02d1h s09  (.a1(a[9]), .a2(b[9]), .z(s0[9]));
xo02d1h s19  (.a1(a[9]), .a2(n[9]), .z(s1[9]));
an02d1h c09  (.a1(a[9]), .a2(b[9]), .z(c0[9]));
or02d2  c19  (.a1(a[9]), .a2(b[9]), .z(c1[9]));

xo02d1h s010 (.a1(a[10]), .a2(b[10]), .z(s0[10]));
xo02d1h s110 (.a1(a[10]), .a2(n[10]), .z(s1[10]));
an02d1h c010 (.a1(a[10]), .a2(b[10]), .z(c0[10]));
or02d2  c110 (.a1(a[10]), .a2(b[10]), .z(c1[10]));

xo02d1h s011 (.a1(a[11]), .a2(b[11]), .z(s0[11]));
xo02d1h s111 (.a1(a[11]), .a2(n[11]), .z(s1[11]));
an02d1h c011 (.a1(a[11]), .a2(b[11]), .z(c0[11]));
or02d2  c111 (.a1(a[11]), .a2(b[11]), .z(c1[11]));

xo02d1h s012 (.a1(a[12]), .a2(b[12]), .z(s0[12]));
xo02d1h s112 (.a1(a[12]), .a2(n[12]), .z(s1[12]));
an02d1h c012 (.a1(a[12]), .a2(b[12]), .z(c0[12]));
or02d2  c112 (.a1(a[12]), .a2(b[12]), .z(c1[12]));

xo02d1h s013 (.a1(a[13]), .a2(b[13]), .z(s0[13]));
xo02d1h s113 (.a1(a[13]), .a2(n[13]), .z(s1[13]));
an02d1h c013 (.a1(a[13]), .a2(b[13]), .z(c0[13]));
or02d2  c113 (.a1(a[13]), .a2(b[13]), .z(c1[13]));

xo02d1h s014 (.a1(a[14]), .a2(b[14]), .z(s0[14]));
xo02d1h s114 (.a1(a[14]), .a2(n[14]), .z(s1[14]));
an02d1h c014 (.a1(a[14]), .a2(b[14]), .z(c0[14]));
or02d2  c114 (.a1(a[14]), .a2(b[14]), .z(c1[14]));

// first rank of muxes (all muxes should be high performance):

wire m1c0b0;	// carry out from bit 0

wire m1s0b2;	// sum bit 2 assuming carry out bit 1 is 0
wire m1s1b2;	// sum bit 2 assuming carry out bit 1 is 1
wire m1c0b2;	// carry in to bit 3 assuming carry out bit 1 is 0
wire m1c1b2;	// carry in to bit 3 assuming carry out bit 1 is 1

wire m1s0b4;	// sum bit 4 assuming carry out bit 1 is 0
wire m1s1b4;	// sum bit 4 assuming carry out bit 1 is 1
wire m1c0b4;	// carry in to bit 5 assuming carry out bit 1 is 0
wire m1c1b4;	// carry in to bit 5 assuming carry out bit 1 is 1

wire m1s0b6;	// sum bit 6 assuming carry out bit 1 is 0
wire m1s1b6;	// sum bit 6 assuming carry out bit 1 is 1
wire m1c0b6;	// carry in to bit 7 assuming carry out bit 1 is 0
wire m1c1b6;	// carry in to bit 7 assuming carry out bit 1 is 1

wire m1s0b8;	// sum bit 8 assuming carry out bit 1 is 0
wire m1s1b8;	// sum bit 8 assuming carry out bit 1 is 1
wire m1c0b8;	// carry in to bit 9 assuming carry out bit 1 is 0
wire m1c1b8;	// carry in to bit 9 assuming carry out bit 1 is 1

wire m1s0b10;	// sum bit 10 assuming carry out bit 1 is 0
wire m1s1b10;	// sum bit 10 assuming carry out bit 1 is 1
wire m1c0b10;	// carry in to bit 11 assuming carry out bit 1 is 0
wire m1c1b10;	// carry in to bit 11 assuming carry out bit 1 is 1

wire m1s0b12;	// sum bit 12 assuming carry out bit 1 is 0
wire m1s1b12;	// sum bit 12 assuming carry out bit 1 is 1
wire m1c0b12;	// carry in to bit 13 assuming carry out bit 1 is 0
wire m1c1b12;	// carry in to bit 13 assuming carry out bit 1 is 1

wire m1s0b14;	// sum bit 14 assuming carry out bit 1 is 0
wire m1s1b14;	// sum bit 14 assuming carry out bit 1 is 1
wire m1c0b14;	// carry in to bit 15 assuming carry out bit 1 is 0
wire m1c1b14;	// carry in to bit 15 assuming carry out bit 1 is 1

assign s[0]   = s1[0];	// assume carry in
assign m1c0b0 = c1[0];	// assume carry in

mx21d1h mx1s0b2  (.s(c0[1]), .i0(s0[2]), .i1(s1[2]), .z(m1s0b2));
mx21d1h mx1s1b2  (.s(c1[1]), .i0(s0[2]), .i1(s1[2]), .z(m1s1b2));
mx21d1h mx1c0b2  (.s(c0[1]), .i0(c0[2]), .i1(c1[2]), .z(m1c0b2));
mx21d1h mx1c1b2  (.s(c1[1]), .i0(c0[2]), .i1(c1[2]), .z(m1c1b2));

mx21d1h mx1s0b4  (.s(c0[3]), .i0(s0[4]), .i1(s1[4]), .z(m1s0b4));
mx21d1h mx1s1b4  (.s(c1[3]), .i0(s0[4]), .i1(s1[4]), .z(m1s1b4));
mx21d1h mx1c0b4  (.s(c0[3]), .i0(c0[4]), .i1(c1[4]), .z(m1c0b4));
mx21d1h mx1c1b4  (.s(c1[3]), .i0(c0[4]), .i1(c1[4]), .z(m1c1b4));

mx21d1h mx1s0b6  (.s(c0[5]), .i0(s0[6]), .i1(s1[6]), .z(m1s0b6));
mx21d1h mx1s1b6  (.s(c1[5]), .i0(s0[6]), .i1(s1[6]), .z(m1s1b6));
mx21d1h mx1c0b6  (.s(c0[5]), .i0(c0[6]), .i1(c1[6]), .z(m1c0b6));
mx21d1h mx1c1b6  (.s(c1[5]), .i0(c0[6]), .i1(c1[6]), .z(m1c1b6));

mx21d1h mx1s0b8  (.s(c0[7]), .i0(s0[8]), .i1(s1[8]), .z(m1s0b8));
mx21d1h mx1s1b8  (.s(c1[7]), .i0(s0[8]), .i1(s1[8]), .z(m1s1b8));
mx21d1h mx1c0b8  (.s(c0[7]), .i0(c0[8]), .i1(c1[8]), .z(m1c0b8));
mx21d1h mx1c1b8  (.s(c1[7]), .i0(c0[8]), .i1(c1[8]), .z(m1c1b8));

mx21d1h mx1s0b10 (.s(c0[9]), .i0(s0[10]), .i1(s1[10]), .z(m1s0b10));
mx21d1h mx1s1b10 (.s(c1[9]), .i0(s0[10]), .i1(s1[10]), .z(m1s1b10));
mx21d1h mx1c0b10 (.s(c0[9]), .i0(c0[10]), .i1(c1[10]), .z(m1c0b10));
mx21d1h mx1c1b10 (.s(c1[9]), .i0(c0[10]), .i1(c1[10]), .z(m1c1b10));

mx21d1h mx1s0b12 (.s(c0[11]), .i0(s0[12]), .i1(s1[12]), .z(m1s0b12));
mx21d1h mx1s1b12 (.s(c1[11]), .i0(s0[12]), .i1(s1[12]), .z(m1s1b12));
mx21d1h mx1c0b12 (.s(c0[11]), .i0(c0[12]), .i1(c1[12]), .z(m1c0b12));
mx21d1h mx1c1b12 (.s(c1[11]), .i0(c0[12]), .i1(c1[12]), .z(m1c1b12));

mx21d1h mx1s0b14 (.s(c0[13]), .i0(s0[14]), .i1(s1[14]), .z(m1s0b14));
mx21d1h mx1s1b14 (.s(c1[13]), .i0(s0[14]), .i1(s1[14]), .z(m1s1b14));
mx21d1h mx1c0b14 (.s(c0[13]), .i0(c0[14]), .i1(c1[14]), .z(m1c0b14));
mx21d1h mx1c1b14 (.s(c1[13]), .i0(c0[14]), .i1(c1[14]), .z(m1c1b14));

// second rank of muxes:

wire m2c0b2;	// carry out from bit 2

wire m2s0b5;	// sum bit 5 assuming carry out bit 4 is 0
wire m2s1b5;	// sum bit 5 assuming carry out bit 4 is 1
wire m2s0b6;	// sum bit 6 assuming carry out bit 4 is 0
wire m2s1b6;	// sum bit 6 assuming carry out bit 4 is 1
wire m2c0b6;	// carry in to bit 6 assuming carry out bit 4 is 0
wire m2c1b6;	// carry in to bit 6 assuming carry out bit 4 is 1

wire m2s0b9;	// sum bit 9 assuming carry out bit 8 is 0
wire m2s1b9;	// sum bit 9 assuming carry out bit 8 is 1
wire m2s0b10;	// sum bit 10 assuming carry out bit 8 is 0
wire m2s1b10;	// sum bit 10 assuming carry out bit 8 is 1
wire m2c0b10;	// carry in to bit 10 assuming carry out bit 8 is 0
wire m2c1b10;	// carry in to bit 10 assuming carry out bit 8 is 1

wire m2s0b13;	// sum bit 13 assuming carry out bit 12 is 0
wire m2s1b13;	// sum bit 13 assuming carry out bit 12 is 1
wire m2s0b14;	// sum bit 14 assuming carry out bit 12 is 0
wire m2s1b14;	// sum bit 14 assuming carry out bit 12 is 1
wire m2c0b14;	// carry in to bit 14 assuming carry out bit 12 is 0
wire m2c1b14;	// carry in to bit 14 assuming carry out bit 12 is 1

mx21d1h mx2s0b1  (.s(m1c0b0), .i0(s0[1]), .i1(s1[1]), .z(s[1]));
mx21d1h mx2s0b2  (.s(m1c0b0), .i0(m1s0b2), .i1(m1s1b2), .z(s[2]));
mx21d1h mx2c0b2  (.s(m1c0b0), .i0(m1c0b2), .i1(m1c1b2), .z(m2c0b2));

mx21d1h mx2s0b5  (.s(m1c0b4), .i0(s0[5]), .i1(s1[5]), .z(m2s0b5));
mx21d1h mx2s1b5  (.s(m1c1b4), .i0(s0[5]), .i1(s1[5]), .z(m2s1b5));
mx21d1h mx2s0b6  (.s(m1c0b4), .i0(m1s0b6), .i1(m1s1b6), .z(m2s0b6));
mx21d1h mx2s1b6  (.s(m1c1b4), .i0(m1s0b6), .i1(m1s1b6), .z(m2s1b6));
mx21d1h mx2c0b6  (.s(m1c0b4), .i0(m1c0b6), .i1(m1c1b6), .z(m2c0b6));
mx21d1h mx2c1b6  (.s(m1c1b4), .i0(m1c0b6), .i1(m1c1b6), .z(m2c1b6));

mx21d1h mx2s0b9  (.s(m1c0b8), .i0(s0[9]), .i1(s1[9]), .z(m2s0b9));
mx21d1h mx2s1b9  (.s(m1c1b8), .i0(s0[9]), .i1(s1[9]), .z(m2s1b9));
mx21d1h mx2s0b10 (.s(m1c0b8), .i0(m1s0b10), .i1(m1s1b10), .z(m2s0b10));
mx21d1h mx2s1b10 (.s(m1c1b8), .i0(m1s0b10), .i1(m1s1b10), .z(m2s1b10));
mx21d1h mx2c0b10 (.s(m1c0b8), .i0(m1c0b10), .i1(m1c1b10), .z(m2c0b10));
mx21d1h mx2c1b10 (.s(m1c1b8), .i0(m1c0b10), .i1(m1c1b10), .z(m2c1b10));

mx21d1h mx2s0b13 (.s(m1c0b12), .i0(s0[13]), .i1(s1[13]), .z(m2s0b13));
mx21d1h mx2s1b13 (.s(m1c1b12), .i0(s0[13]), .i1(s1[13]), .z(m2s1b13));
mx21d1h mx2s0b14 (.s(m1c0b12), .i0(m1s0b14), .i1(m1s1b14), .z(m2s0b14));
mx21d1h mx2s1b14 (.s(m1c1b12), .i0(m1s0b14), .i1(m1s1b14), .z(m2s1b14));
mx21d1h mx2c0b14 (.s(m1c0b12), .i0(m1c0b14), .i1(m1c1b14), .z(m2c0b14));
mx21d1h mx2c1b14 (.s(m1c1b12), .i0(m1c0b14), .i1(m1c1b14), .z(m2c1b14));

// third rank of muxes:

wire m3c0b6;	// carry out from bit 6
wire m3c0b6b;	// carry out from bit 6, buffered version

wire m3s0b11;	// sum bit 11 assuming carry out bit 10 is 0
wire m3s1b11;	// sum bit 11 assuming carry out bit 10 is 1
wire m3s0b12;	// sum bit 12 assuming carry out bit 10 is 0
wire m3s1b12;	// sum bit 12 assuming carry out bit 10 is 1
wire m3s0b13;	// sum bit 13 assuming carry out bit 10 is 0
wire m3s1b13;	// sum bit 13 assuming carry out bit 10 is 1
wire m3s0b14;	// sum bit 14 assuming carry out bit 10 is 0
wire m3s1b14;	// sum bit 14 assuming carry out bit 10 is 1
wire m3c0b14;	// carry out of bit 14 assuming carry out bit 10 is 0
wire m3c1b14;	// carry out of bit 14 assuming carry out bit 10 is 1

mx21d1h mx3s0b3  (.s(m2c0b2 ), .i0(s0[3]), .i1(s1[3]), .z(s[3]));
mx21d1h mx3s0b4  (.s(m2c0b2 ), .i0(m1s0b4), .i1(m1s1b4), .z(s[4]));
mx21d1h mx3s0b5  (.s(m2c0b2 ), .i0(m2s0b5), .i1(m2s1b5), .z(s[5]));
mx21d1h mx3s0b6  (.s(m2c0b2 ), .i0(m2s0b6), .i1(m2s1b6), .z(s[6]));
mx21d1h mx3c0b6  (.s(m2c0b2 ), .i0(m2c0b6), .i1(m2c1b6), .z(m3c0b6));
ni01d4  ni3c0b6  (.i(m3c0b6 ),                           .z(m3c0b6b));

mx21d1h mx3s0b11 (.s(m2c0b10), .i0(s0[11]), .i1(s1[11]), .z(m3s0b11));
mx21d1h mx3s1b11 (.s(m2c1b10), .i0(s0[11]), .i1(s1[11]), .z(m3s1b11));
mx21d1h mx3s0b12 (.s(m2c0b10), .i0(m1s0b12), .i1(m1s1b12), .z(m3s0b12));
mx21d1h mx3s1b12 (.s(m2c1b10), .i0(m1s0b12), .i1(m1s1b12), .z(m3s1b12));
mx21d1h mx3s0b13 (.s(m2c0b10), .i0(m2s0b13), .i1(m2s1b13), .z(m3s0b13));
mx21d1h mx3s1b13 (.s(m2c1b10), .i0(m2s0b13), .i1(m2s1b13), .z(m3s1b13));
mx21d1h mx3s0b14 (.s(m2c0b10), .i0(m2s0b14), .i1(m2s1b14), .z(m3s0b14));
mx21d1h mx3s1b14 (.s(m2c1b10), .i0(m2s0b14), .i1(m2s1b14), .z(m3s1b14));
mx21d1h mx3c0b14 (.s(m2c0b10), .i0(m2c0b14), .i1(m2c1b14), .z(m3c0b14));
mx21d1h mx3c1b14 (.s(m2c1b10), .i0(m2c0b14), .i1(m2c1b14), .z(m3c1b14));

// fourth rank of muxes:

mx21d1h mx4s0b7  (.s(m3c0b6b), .i0(s0[7]), .i1(s1[7]), .z(s[7]));
mx21d1h mx4s0b8  (.s(m3c0b6b), .i0(m1s0b8), .i1(m1s1b8), .z(s[8]));
mx21d1h mx4s0b9  (.s(m3c0b6b), .i0(m2s0b9), .i1(m2s1b9), .z(s[9]));
mx21d1h mx4s0b10 (.s(m3c0b6b), .i0(m2s0b10), .i1(m2s1b10), .z(s[10]));
mx21d1h mx4s0b11 (.s(m3c0b6b), .i0(m3s0b11), .i1(m3s1b11), .z(s[11]));
mx21d1h mx4s0b12 (.s(m3c0b6b), .i0(m3s0b12), .i1(m3s1b12), .z(s[12]));
mx21d1h mx4s0b13 (.s(m3c0b6b), .i0(m3s0b13), .i1(m3s1b13), .z(s[13]));
mx21d1h mx4s0b14 (.s(m3c0b6b), .i0(m3s0b14), .i1(m3s1b14), .z(s[14]));
mx21d1h mx4c0b14 (.s(m3c0b6 ), .i0(m3c0b14), .i1(m3c1b14), .z(co));

endmodule // tc_max_abs_dif_add15