算术逻辑部件设计
算 术 逻 辑 部 件
设 计
蒋 小 龙
2001.7.5
声 明
作此资料为本人个人行为，此资料版权为本人所有。
你可以任意使用，但你非经本人允许不得对此资料内容作任何修改。
你因使用此资料所带来任何收益，本人均不染指；因使用此资料所引起的任何不良后果，本人不承担任何形式的责任。
出版物引用，但请注明！
蒋 小 龙
2001.7.5
目 录
声明……………………………………………………………………………………
0、 约定……………………………………………………………………………………
1、 一位加法器……………………………………………………………………………
2、 4位加法器……………………………………………………………………………
3、 4位超前进位链………………………………………………………………………
4、 16位超前进位链………………………………………………………………………
5、 更多位超前进位链……………………………………………………………………
6、 算术运算设计…………………………………………………………………………
7、 逻辑操作设计…………………………………………………………………………
8、 标识位…………………………………………………………………………………
9、 设计示例1 —— 16位7功能算术逻辑部件 …………………………………………
10、设计示例2 —— 4位16功能算术逻辑部件 …………………………………………
后记……………………………………………………………………………………
个人介绍………………………………………………………………………………[***********]21
0、约定
运算数据：
A：操作数、位串；
B：操作数、位串；
D：结果数据、位串，与操作数位宽同；
Ci：进位、一位，以前操作所产生，本次操作视情况考虑；
Co：进位、一位，本次操作产生；
C：进位、位串，由操作数生成的进位，不会比操作数位宽小；
G：进位生成、位串，与操作数位宽同，具体意义见文中；
P：进位传输、位串, 与操作数位宽同，具体意义见文中。
运算符：
+：对其两边的数据作加法操作：A + B；
-：用左边的数据减去右边的数据作；A - B
-：对跟在其后的数据作取补操作，即用0减去跟在其后的数据；- B
&：对其两边的数据按位作与操作；A & B
#：对其两边的数据按位作或操作；A # B
@：对其两边的数据按位作异或操作；A @ B
~：对跟在其后的数据作按位取反操作；~ B
对运算符的约定只在文中论述的时候有效。
设计示例用VerilogHDL 语言实现，所有的东西符合VerilogHDL 语法。如有疑问，请参阅VerilogHDL 资料。
1、一位加法器
考虑一位全加器。如右图示真值表，D 、Co 逻辑表达式为：
D = A @ B @ Ci
Co = A & B # A & Ci # B & Ci
= A & B # (A # B) & Ci
不难作出其逻辑图，此处省略。
一位全加器又称“保留进位加法器”。
因其简单，是研究其它高性能、高速加法器的
基础。因其简单、快速，是构成其它高速处理
部件的基本元件。其符号如右。
由真值表可知，若将各位取反，并无影响。(1-1) (1-2) (1-3)
2、4位加法器
四位加法器可以采用四个一位全加器级连成串行进位加法器。如上图示：
对于这种方式，因高位运算必须等低位进位来到后才能进行。因此，它的延迟非常可观。高速运算肯定无法胜任。
对串行进位加法器研究可得：运算的延迟是由于进位的延迟。基于此，减小进位的延迟非常有效。下面讨论的超前进位链能有效减少进位的延迟，它由进位门产生进位，各进位彼此独立，不依赖于进位传播。因此，它的延迟非常小、速度非常高。
既然进位已经解决，则加法器值
D = A @ B @ C(2-1) 不存在问题。
由此可见，进位的解决是核心
。
3、4位超前进位链
研究式(1-3)
Co = A & B # (A # B) & Ci(3-1)
可以看出：若A 、B 均为1，则产生进位输出；若A 、B 存在1，则进位输出依赖于低位进位Ci 。换一种说法：若A 、B 均为1，则产生进位；若A 、B 存在1，则传输(低位) 进位(Ci)。
A 、B 、Ci 在本位运算，产生本位值D ，向高位进位Co 。更一般的：
Dn = An @ Bn @ Cn(3-2) Cn+1 = An & Bn # (An # Bn) & Cn(3-3)令：
Gn = An & Bn(3-4) Pn = An # Bn(3-5)则式(3.-3)为：
Cn+1 = Gn # Pn & Cn(3-6)
这样，就引入了进位产生函数(G)、进位传输函数(P)。其意义为：若Gn 为1，必定产生进位；若Pn 为1，则向高位传输(低位) 进位(Cn), 可认为低位进位越过本位直接向高位进位。此处是否说明仍存在进位传播，使进位延迟无法减小？
以4位超前进位链为例：
C0 = Ci
C1 = G0 # P0 & C0
= G0 # P0 & Ci(3-7) C2 = G1 # P1 & C1
= G1 # P1 & G0 # P1 & P0 & Ci(3-8) C3 = G2 # P2 & C2
= G2 # P2 & G1 # P2 & P1 & G0 # P2 & P1 & P0 & Ci(3-9) C4 = G3 # P3 & C3
= G3 # P3 & G2 # P3 & P2 & G1 # P3 & P2 & P1 & G0 #
P3 & P2 & P1 & P0 & Ci(3-10) Co = C4
其逻辑图如下
：
可见，将迭代关系去掉，则各位彼此独立，进位传播不复存在。因此，总的延迟是两级门的延迟。其高速也就自不待言。
对式(2-1)
D = A @ B @ C(3-11) = ((~ A) & B # A & (~ B)) @ C
= ((~ A) & B # A & (~ B) # (~ A) & A # (~ B) & B # A & (~ A) & B & (~ B) # (~ A) & A # (~ B) & B # A & (~ A) & B & (~ B)) @ C # (~ A) & A # (~ B) & B # A & (~ A) & B & (~ B)
= ((~ A) & (A # B) # (~ B) & (A # B) # A & B & (~ A) & (~ B)) @ C
= (((~ A) # (~ B)) & (A # B) # A & B & (~ (A # B))) @ C
= ((~ (A & B)) & (A # B) # A & B & (~ (A # B))) @ C
= (A & B) @ (A # B) @ C(3-12)
= G @ P @ C(3-13) 可见：
D = A @ B @ C = G @ P @ C = (A & B) @ (A # B) @ C(3-14) 此特性对算术逻辑部件的设计非常有用！
4、16位超前进位链
对4位超前进位加法器：二输入数据A 、B ，进位输入Ci ，生成数据D ，进位Co 。因此，可以用4个4位超前进位进位链单元串接形成16位进位链。这存在问题，就是单元内虽是超前进位，但单元间却是串行，存在进位传播问题，延迟不会短，速度也就高不了！
从4位超前进位链得到启示，能否在单元间实行超前进位？
考察第4、8、12、16位的进位，会得到：
C4 = G3 # P3 & C3
= (G3 # P3 & G2 # P3 & P2 & G1 # P3 & P2 & P1 & G0) #
(P3 & P2 & P1 & P0) & Ci(4-1)
C8 = G7 # P7 & C7
= (G7 # P7 & G6 # P7 & P6 & G5 # P7 & P6 & P5 & G4) #
(P7 & P6 & P5 & P4) & (G3 # P3 & G2 # P3 & P2 & G1 # P3 & P2 & P1 & G0) #
(P7 & P6 & P5 & P4) & (P3 & P2 & P1 & P0) & Ci(4-2)
C12 = G11 # P11 & C11
= (G11 # P11 & G10 # P11 & P10 & G9 # P11 & P10 & P9 & G8) #
(P11 & P10 & P9 & P8) & (G7 # P7 & G6 # P7 & P6 & G5 # P7 & P6 & P5 & G4) #
(P11 & P10 & P9 & P8) & (P7 & P6 & P5 & P4) &
(G3 # P3 & G2 # P3 & P2 & G1 # P3 & P2 & P1 & G0) #
(P11 & P10 & P9 & P8) &
(4-3) (P7 & P6 & P5 & P4) & (P3 & P2 & P1 & P0) & Ci
C16 = G15 # P15 & C15
= (G15 # P15 & G14 # P15 & P14 & G13 # P15 & P14 & P13 & G12) #
(P15 & P14 & P13 & P12) &
(G11 # P11 & G10 # P11 & P10 & G9 # P11 & P10 & P9 & G8) #
(P15 & P14 & P13 & P12) & (P11 & P10 & P9 & P8) &
(G7 # P7 & G6 # P7 & P6 & G5 # P7 & P6 & P5 & G4) #
(P15 & P14 & P13 & P12) & (P11 & P10 & P9 & P8) &
(P7 & P6 & P5 & P4) & (G3 # P3 & G2 # P3 & P2 & G1 # P3 & P2 & P1 & G0) # (P15 & P14 & P13 & P12) & (P11 & P10 & P9 & P8) &
(4-4) (P7 & P6 & P5 & P4) & (P3 & P2 & P1 & P0) & Ci
令：
(4-5) GX4 = G15 # P15 & G14 # P15 & P14 & G13 # P15 & P14 & P13 & G12
GX3 = G11 # P11 & G10 # P11 & P10 & G9 # P11 & P10 & P9 & G8(4-6)
(4-7) GX2 = G7 # P7 & G6 # P7 & P6 & G5 # P7 & P6 & P5 & G4
GX1 = G3 # P3 & G2 # P3 & P2 & G1 # P3 & P2 & P1 & G0(4-8)
(4-9) PX4 = P15 & P14 & P13 & P12
PX3 = P11 & P10 & P9 & P8(4-10)
(4-11) PX2 = P7 & P6 & P5 & P4
PX1 = P3 & P2 & P1 & P0(4-12) 可得：
(4-13) C4 = GX0 # PX0 & Ci
(4-14) C8 = GX1 # PX1 & GX0 # PX1 & PX0 & Ci
C12 = GX2 # PX2 & GX1 # PX2 & PX1 & GX0 # PX2 & PX1 & PX0 & Ci(4-15) C16 = GX3 # PX3 & GX2 # PX3 & PX2 & GX1 #
PX3 & PX2 & PX1 & GX0 # PX3 & PX2 & PX1 & PX0 & Ci(4-16) 比较式((4-13)~(4-16)) 与式((3-7)~(3-10)) ，可看出：单元间进位也可用超前进位链完成。
16位超前进位链如下
：
4位超前进位链如下：
实际应用中，最高位进位一般不直接使用，对其要求可降低。本图中，此位需四级门延迟。
综合考察式(4-5)~(4-16) 及上两幅图，可发现由G 、P 生成GX 、PX 有两级门延迟，由GX 、PX 生成单元间进位有两级门延迟，再需两级两级门延迟生成最终的进位。因此，总共需六级门延迟。
至此，问题已得到解决。
5、更多位超前进位链
对更多位超前进位链可参照上节，形成多级超前进位链树。
以64位超前进位链为例。
可用4位的超前进位链单元构成。第一级用16个单元，输出直接的进位；第二级用4个单元，用以形成第一级单元间进位；第三级用1个单元，为第二级提供单元间进位。这样，形成进位需10级门延迟：一、二级间需2，二、三级间需2，三、二级间需2，二、一级间需2，第一级输出需2。
也可用8位超前进位链单元构成。第一级用8个单元，输出直接的进位；第二级用1个单元，为第一级提供单元间进位。这样，形成进位需6级门延迟。
实际上，每增加一级，就需要增加形成GX 、PX 的时间2，再形成进位需时2，总共增加4。
这是否说明后一种方案就一定快！这不一定。需考虑电路中连线延迟、逻辑门的扇入扇出能力、逻辑门的延迟等多方面的因素。
再考虑32位、128位超前进位链，应如何实现。
在实际应用中，拟制多种方案，考虑多方面因素，得到最优结果。
至此，作为高速加法器的核心——超前进位链——的讨论已完
成。
6、算术运算设计
减法的数学表达式如下：
D = A - B - Ci(6-1) 按代数运算法则以及补码的定义可得：
D = A - B - Ci(6-2) = A + (- B) - Ci(6-3) = A + (~ B + 1) - Ci(6-4) = A + (~ B) + 1 - Ci(6-5) = A + (~ B) + (1 – Ci)(6-6) = A + (~ B) + (~ Ci)(6-7)由此得出的结论：
从被减数A 减去减数B 以及借位Ci ，可以将A 加上将B 的按位取反的值以及将借位Ci 取反的值！加法的数学表达式：
D = A + B + Ci(6-8)比照式(6-7)、(6-8)，作出如下结论：
作加法时将A 、B 、Ci 相加，作减法时将B 、Ci 取反与A 相加！
引入一控制信号：as 。当其为0时作加法操作；当其为1时作减法操作。见下式：
D = A + (as ? B : (~ B)) + (as @ Ci)(6-9)
D = A + (asv @ B) + (as @ Ci)(6-10) 在式(6-9)中，有一运算操作符：? : ；其表达式为：
条件 ? 条件为真选项 : 条件为假选项
用之，因其为一位信号，不能与位串信号B 直接操作。
在式(6-10) 中，有一信号asv, 它与信号B 位宽相同，它由信号as 填充。
超前进位链的输入值为G 、P 。作加法运算时，G 、P 为：
G = A & B(6-11) P = A # B(6-12) 作减法运算时，G 、P 为：
G = A & (~ B)(6-13) P = A # (~ B)(6-14) 对于可控加减法运算
G = A & (asv @ B)(6-15) P = A # (asv @ B)(6-16) 至此，算术运算已得到解决！
7、逻辑操作设计
逻辑操作是按位操作，不需要考虑位间进位。逻辑操作也就：与、或、异或（同或）三种操作。
也很容易地想到：二操作数A 、B 直接进行逻辑操作得到结果D 。还有一种方法：用G 、P 间接进行逻辑操作。参照式(3-14)
D = A @ B @ C = G @ P @ C = (A & B) @ (A # B) @ C(7-1) 逻辑操作表达式
D = A @ B = G @ P = (A & B) @ (A # B)(7-2)对于与操作：
D = A & B = G(7-3)对于或操作：
D = A # B = P(7-4)对于异或操作：
D = A @ B = G @ P(7-5)
引入一二位控制信号：lc 。当其为00时，作与操作；当其为01时，作或操作；当其为1X 时，作异或操作。
G = (~ (lc = 01)) ? (A & B) : 0(7-6) P = (~ (lc = 00)) ? (A # B) : 0(7-7) D = G @ P(7-8)
对这两种方法，我现在无从评测。我倾向于采用后一种。当然这样一来，多了一道环节，延迟不会没有。
8、标识位
任何一步算术逻辑操作都会产生各种各样的标识位。最主要的有：零标识、进位标识、符号标识、溢出标识。
若结果为零置零标识，或者说若待检测数据为零则置零标识。检测也不一定在此，可以在数据通路上检测。
符号标识的设置有两种：一是跟踪结果的符号位，即结果的最高位；二是使用扩展符号位，即：将二操作数作符号扩展一位，此时结果的最高位即用于设置符号标识。
在此讨论进位标识的设置，首先说明一下几个名词：进位、借位、进位标识、原进位。进位、借位是我们通常意义上的东西；进位标识跟踪进位、借位。原进位是指进位链上最高位。
加法操作时，可能会产生进位，因为结果可能会超出了表数范围，这在原进位上会表现出来。加法时，标识位的设置，只需要跟踪原进位即行。
我们知道，0减去任何不为0的数，都会借位；0减去0，不会借位。遗憾的是，进位链上并不是如此表现。
0减去一不为0的数B ，G 为0。B 不为0，则其位串中必定有1，将B 取反，此时位串中必定有0，P 位串中也必定有0。因此，原进位必定为0。
0减去0，即为0加上B 取反的值及1，实际上，1是作为进位引入的。此时G 为0。B 取反，此时位串全为1，P 位串也全为1，原进位跟踪最初输入的进位，其正为1。因此，原进位必定为1。
可以看到，原进位上的表现与实际的借位正好相反。现在的讨论是：被减数为0，非常特殊。见下式：
D = A - B(8-1) = (0 + A) + (0 - B)(8-2)(0 + A)原进位必会为0。所以：
作减法时，进位标识的设置是将原进位取反。溢出标识位的设置：作加法时，若二操作数符号相同，而结果符号相反，则置；作减法时，若减数、结果符号相同，而被减数符号相反，则置。
加法时
G = A & B(8-3) P = A # B(8-4) D = G @ P @ C(8-5)以A msb 表示数据A 的最高位，以A msb+1表示数据A 的扩展最高位。
(8-6) OV = Amsb & Bmsb & (~ Dmsb ) # (~ Amsb ) & (~ Bmsb ) & Dmsb
= Gmsb & (~ (Gmsb @ Pmsb @ Cmsb )) # (~ Pmsb ) & (Gmsb @ Pms b @ Cmsb ) (8-7)
(8-8) = Gmsb & (~ Cmsb ) # (~ Pmsb ) & Cmsb
参见式(3-6)
(8-9) Cmsb+1 @ Cmsb = (Gmsb # Pmsb & Cmsb ) @ Cmsb
= Gmsb & (~ Cmsb ) # (~ Gmsb ) & (~ Pmsb ) & Cmsb = Gmsb & (~ Cmsb ) # (~ (Gmsb # Pmsb )) & Cmsb (8-10) = Gmsb & (~ Cmsb ) # (~ ((Amsb & Bmsb ) # (Amsb # Bmsb ))) & Cmsb = Gmsb & (~ Cmsb ) # (~ (Amsb # Bmsb )) & Cmsb = Gmsb & (~ Cmsb ) # (~ Pmsb ) & Cmsb (8-11) 可以看到：式(8-8)、(8-11) 相等。可知：加法时：
(8-12) OV = Cmsb+1 @ Cmsb
减法时
G = A & (~ B)(8-13) P = A # (~ B)(8-14) D = G @ P @ C(8-15)
(8-16) OV = Amsb & (~ Bmsb ) & (~ Dmsb ) # (~ Amsb ) & Bmsb & Dmsb
= Gmsb & (~ (Gmsb @ Pmsb @ Cmsb)) # (~ Pmsb ) & (Gmsb @ Pmsb @ Cmsb ) (8-17)
(8-18) = Gmsb & (~ Cmsb ) # (~ Pmsb ) & Cmsb
参见式(3-6)
(8-19) Cmsb+1 @ Cmsb = (Gmsb # Pmsb & Cmsb ) @ Cmsb
= Gmsb & (~ Cmsb ) # (~ Gmsb ) & (~ Pmsb ) & Cmsb = Gmsb & (~ Cmsb ) # (~ (Gmsb # Pmsb )) & Cmsb (8-20) = Gmsb & (~ Cmsb ) # (~ ((Amsb & (~ Bmsb )) # (Amsb # (~ Bmsb )))) & Cmsb = Gmsb & (~ Cmsb ) # (~ (Amsb # (~ Bmsb ))) & Cmsb = Gmsb & (~ Cmsb ) # (~ Pmsb ) & Cmsb 可以看到：式(8-18) 、(8-21) 相等。可知：减法时：
OV = Cmsb+1 @ Cmsb
所以：
OV = Cmsb+1 @ Cmsb
至此，算术逻辑部件设计，理论上的东西已全部解决！
9、设计示例1 —— 16位7功能算术逻辑部件
在上面的讨论中，我们注意到一个热点：G 、P 。
其实，超前进位链是标准的，算术逻辑部件设计最主要的工作是设计G 、P 函数！这里用两节篇幅示例算术逻辑部件的设计。本节示例：设计一16位7功能算术逻辑部件。 输入：二数据：A 、B ，进位；Ci ；
输出：结果：D ，标识位：进位CF 、零标识ZF 、扩展符号SF 、溢出OF 。 功能控制：Fc ：000：A + B； 001：A – B；
010：A + B + Ci； 011：A - B - Ci； 100：A & B； 101：A # B； 110：A @ B； 111：A @ B；要求尽量高速。
尽量高速，用超前进位链；数据宽度为16位，用4位超前进位链搭建。
(8-21) (8-22)(8-23)
module ALU_Demo_1 ( A,B,Ci,// D,// Fc,//
cf,zf,sf,of// );
input [15:0] A,B;input Ci;output[15:0] D;input [ 2:0] Fc;
output cf,zf,sf,of;
reg [15:0] G,P;wire [16:0] C;
// Fc G P Cp Descript// 000 A & B A | B 0 A + B// 001 A & (~ B) A | (~ B) // 010 A & B A | B Ci A + B + Ci// 011 A & (~ B) A | (~ B) (~ Ci) A - B - Ci// 100 A & B 0 X A & B// 101 0 A | B X A | B// 110 A & B A | B X A ^ B// 111 A & B A | B X A ^ B
//----generat the Galways @(Fc or A or B) casex(Fc)
3'b000: G = A & B; 3'b001: G = A & (~ B); 3'b010: G = A & B; 3'b011: G = A & (~ B); 3'b100: G = A & B;
3'b101: G = {16{1'b0}}; 3'b110: G = A & B; 3'b111: G = A & B; default: G = A & B; endcase
1 A - B
//----generat the Palways @(Fc or A or B) casex(Fc)
3'b000: P = A | B; 3'b001: P = A | (~ B); 3'b010: P = A | B; 3'b011: P = A | (~ B); 3'b100: P = {16{1'b0}}; 3'b101: P = A | B; 3'b110: P = A | B; 3'b111: P = A | B; default: P = A | B; endcase
//----generat the C in leading carry linkwire Cp;wire [ 3:0] Gl,Pl;wire [ 4:1] Cx;wire [16:1] Ct;
assign Cp = ((Ci & Fc[1]) ^ Fc[0]);
Carry_Leading_4 CL0 (G[ 3: 0],P[ 3: 0],Cp ,Ct[ 4: 1],Gl[0],Pl[0]);Carry_Leading_4 CL1 (G[ 7: 4],P[ 7: 4],Cx[1],Ct[ 8: 5],Gl[1],Pl[1]);Carry_Leading_4 CL2 (G[11: 8],P[11: 8],Cx[2],Ct[12: 9],Gl[2],Pl[2]);Carry_Leading_4 CL3 (G[15:12],P[15:12],Cx[3],Ct[16:13],Gl[3],Pl[3]);Carry_Leading_4 CLX (Gl[ 3:0],Pl[ 3:0],Cp,Cx[ 4:1],,);
//assign C = {Ct,Cp};
assign C = {Cx[4],Ct[15:13],Cx[3],Ct[11:9],Cx[2],Ct[7:5],Cx[1],Ct[3:1],Cp};
//----generate the result
assign D = G ^ P ^ ((~ Fc[2]) ? C[15:0] : {16{1'b0}});assign cf = (C[16] ^ Fc[0]) & (~ Fc[2]);assign zf = ! D;
assign sf = G[15] ^ P[15] ^ ((~ Fc[2]) & C[16]);assign of = (C[15] ^ C[16]) & (~ Fc[2]);
endmodule
module Carry_Leading_4 (G,P,Ci,C,Gl,Pl);input [ 3:0] G,P;output [ 4:1] C;input Ci;output Gl,Pl;wire [ 3:0] G,P;wire [ 4:1] C;wire Ci;wire Gl,Pl;
assign C[1] = G[0] | P[0] & Ci;
assign C[2] = G[1] | P[1] & G[0] | P[1] & P[0] & Ci;
assign C[3] = G[2] | P[2] & G[1] | P[2] & P[1] & G[0] | P[2] & P[1] & P[0] & Ci;assign C[4] = Gl | Pl & Ci;
assign Gl = G[3] | P[3] & G[2] | P[3] & P[2] & G[1] | P[3] & P[2] & P[1] & G[0];assign Pl = P[3] & P[2] & P[1] & P[0];endmodule
10、设计示例2 —— 4位16功能算术逻辑部件
本节示例：设计一4位16功能算术逻辑部件。 输入：二数据：A 、B ，进位；Ci ；
输出：结果：D ，标识位：进位CF 、零标识ZF 、扩展符号SF 、溢出OF 。 功能控制：Fc ：0000：B ； 0001：B + 1；
0010：A + B + Ci； 0011：A + B； 0100：~ B； 0101：- B；
0110：A - B + Ci - 1； 0111：A - B；
1000：B - 1； 1001：B – A；
1010：B – A + Ci - 1； 1011：~ A； 1100：A & B； 1101：A # B； 1110：A @ B； 1111：abs A；要求尽量高速。
出现在功能表中有一如下操作： D = A - B + Ci – 1 = A + (- B) + Ci – 1 = A + (~ B) + 1 + Ci – 1 = A + (~ B) + Ci
module ALU_Demo_2 ( A,B,Ci,// D,// Fc,//
cf,zf,sf,of// );
input [ 3:0] A,B;input Ci;output[ 3:0] D;input [ 3:0] Fc;
output cf,zf,sf,of;
reg [ 3:0] G,P;reg [ 4:0] C;
wire ol;//logic operate if it is '1'
wire so;//subtract operate when it is '1' // D = A - B + Ci - 1// = A + (- B) + Ci - 1// = A + (~ B) + 1 + Ci - 1// = A + (~ B) + Ci
//Function table & it descript in other word
// Fc Descript ow T
// 0000 B 0 + B + 0 0 + B + 0// 0001 B + 1 0 + B + 1 0 + B + 1// 0010 A + B + Ci A + B + Ci A + B + Ci// 0011 A + B A + B A + B// 0100 ~ B 0 - B - 1 0 + (~ B)// 0101 - B 0 - B 0 + (~ B) + 1// 0110 A - B + Ci - 1 A - B + Ci - // 0111 A - B A - B A + (~ B) + // 1000 B - 1 B - 0 - // 1001 B - A B - A (~ A) + B + // 1010 B - A + Ci - 1 B - A + Ci - // 1011 ~ A 0 - A - // 1100 A & B A & B A & B// 1101 A | B A | B A | B// 1110 A ^ B A ^ B A ^ B
// 1111 abs A (0 - A) / (0 + A) (A[3] ? (~ A) : A) + 0 + (A[3])
//----generat the G// G = oa & ob
always @(Fc or A or B) casex(Fc)
4'b0000: G = 4'b0000; //oa = 0; ob = B; cp = 0; 4'b0001: G = 4'b0000; //oa = 0; ob = B; cp = 4'b0010: G = A & B; //oa = A; ob = B; cp = Ci; 4'b0011: G = A & B; //oa = A; ob = B; cp = 0; 4'b0100: G = 4'b0000; //oa = 0; ob = (~ B); cp = 0; 4'b0101: G = 4'b0000; //oa = 0; ob = (~ B); cp = 4'b0110: G = A & (~ B); //oa = A; ob = (~ B); cp = Ci 4'b0111: G = A & (~ B); //oa = A; ob = (~ B); cp = 4'b1000: G = B; //oa = (~ 0); ob = B; cp = 0; 4'b1001: G = (~ A) & B; //oa = (~ A); ob = B; cp = 4'b1010: G = (~ A) & B; //oa = (~ A); ob = B; cp = Ci; 4'b1011: G = 0; //oa = (~ A); ob = 0; cp = 0; 4'b1100: G = A & B; //oa = A; ob = B; cp = x; 4'b1101: G = 4'b0000; //oa = A; ob = B; cp = x; 4'b1110: G = A & B; //oa = A; ob = B; cp = x; 4'b1111: G = 4'b0000; //oa = (A[3] ? (~ A) : A); ob = 0; cp = A[3]; default: G = 4'bxxxx; //oa = X; ob = X; cp = x; endcase
1 A + (~ B) + Ci11 (~ 0) + B11 (~ A) + B + Ci1 (~ A) + 01; 1; 1; 1;
//----generat the P// P = oa | ob
always @(Fc or A or B) casex(Fc)
4'b0000: P = B; //oa = 0; ob = B; cp = 0; 4'b0001: P = B; //oa = 0; ob = B; cp = 1; 4'b0010: P = A | B; //oa = A; ob = B; cp = Ci; 4'b0011: P = A | B; //oa = A; ob = B; cp = 0; 4'b0100: P = (~ B); //oa = 0; ob = (~ B); cp = 0; 4'b0101: P = (~ B); //oa = 0; ob = (~ B); cp = 1; 4'b0110: P = A | (~ B); //oa = A; ob = (~ B); cp = Ci; 4'b0111: P = A | (~ B); //oa = A; ob = (~ B); cp = 1; 4'b1000: P = 4'b1111; //oa = (~ 0); ob = B; cp = 0; 4'b1001: P = (~ A) | B; //oa = (~ A); ob = B; cp = 1; 4'b1010: P = (~ A) | B; //oa = (~ A); ob = B; cp = Ci; 4'b1011: P = (~ A); //oa = (~ A); ob = 0; cp = 0; 4'b1100: P = 4'b0000; //oa = A; ob = B; cp = x; 4'b1101: P = A | B; //oa = A; ob = B; cp = x; 4'b1110: P = A | B; //oa = A; ob = B; cp = x; 4'b1111: P = (A[3] ? (~ A) : A); //oa = (A[3] ? (~ A) : A); ob = 0; cp = A[3]; default: P = 4'bxxxx; //oa = X; ob = X; cp = x; endcase
//----generat the Ci// P = oa | ob
always @(Fc or A or B) casex(Fc)
4'b0000: C[0] = 1'b0; //oa = 0; ob = B; cp = 0; 4'b0001: C[0] = 1'b 1; //oa = 0; ob = B; cp = 1; 4'b0010: C[0] = Ci; //oa = A; ob = B; cp = Ci; 4'b0011: C[0] = 1'b0; //oa = A; ob = B; cp = 0; 4'b0100: C[0] = 1'b0; //oa = 0; ob = (~ B); cp = 0; 4'b0101: C[0] = 1'b 1; //oa = 0; ob = (~ B); cp = 1; 4'b0110: C[0] = Ci; //oa = A; ob = (~ B); cp = Ci; 4'b0111: C[0] = 1'b 1; //oa = A; ob = (~ B); cp = 1; 4'b1000: C[0] = 1'b0; //oa = (~ 0); ob = B; cp = 0; 4'b1001: C[0] = 1'b 1; //oa = (~ A); ob = B; cp = 1; 4'b1010: C[0] = Ci; //oa = (~ A); ob = B; cp = Ci; 4'b1011: C[0] = 1'b0; //oa = (~ A); ob = 0; cp = 0; 4'b1100: C[0] = 1'bx; //oa = A; ob = B; cp = x; 4'b1101: C[0] = 1'bx; //oa = A; ob = B; cp = x; 4'b1110: C[0] = 1'bx; //oa = A; ob = B; cp = x; 4'b1111: C[0] = A[3]; //oa = (A[3] ? (~ A) : A); ob = 0; cp = A[3]; default: C[0] = 1'bx; //oa = X; ob = X; cp = x; endcase
assign ol = (Fc == 4'b1100) | (Fc == 4'b1101) | (Fc == 4'b1110);
assign so = (Fc == 4'b0101) | (Fc == 4'b0110) | (Fc == 4'b0111) | (Fc == 4'b1000) | (Fc == 4'b1001) | (Fc == 4'b1010) | ((Fc == 4'b1111) & A[3]);
//----generat the C in leading carry linkCarry_Leading_4 CL4 (G,P,C[0],C[ 4:1],,);
//----generate the result
assign D = G ^ P ^ ((~ ol) ? C[ 3:0] : 4'b0000);assign cf = (C[4] ^ so) & (~ ol);assign zf = ! D;
assign sf = G[3] ^ P[3] ^ C[4];assign of = (C[4] ^ C[3]) & (~ ol);
endmodule
module Carry_Leading_4 (G,P,Ci,C,Gl,Pl);input [ 3:0] G,P;output [ 4:1] C;input Ci;output Gl,Pl;wire [ 3:0] G,P;wire [ 4:1] C;wire Ci;wire Gl,Pl;
assign C[1] = G[0] | P[0] & Ci;
assign C[2] = G[1] | P[1] & G[0] | P[1] & P[0] & Ci;
assign C[3] = G[2] | P[2] & G[1] | P[2] & P[1] & G[0] | P[2] & P[1] & P[0] & Ci;assign C[4] = Gl | Pl & Ci;
assign Gl = G[3] | P[3] & G[2] | P[3] & P[2] & G[1] | P[3] & P[2] & P[1] & G[0];assign Pl = P[3] & P[2] & P[1] & P[0];endmodule
后 记
本人从事集成电路设计以来，所见过有关算术逻辑部件的设计，无一例外属于系统级描述。在和有关从业人员的交谈中，甚至于超前进位不知道的也大有人在。
我于早期作作过《超前进位链》一文，希望（目睹者）能于算术逻辑部件设计有所帮助。但后来发现：效果为零。一气之下，作此资料。
应该说，以寄存器传输级描述算术逻辑部件设计应是此行业从业人员基本能力要求。
如果将设计能力分为三个层次：艺术级、匠级、学徒级。系统级描述只需学徒级水平就行。
在微处理器设计中，在走到FPGA 功能验证这一步时，算术逻辑部件设计需要匠级水平，译码控制需艺术级水平——我所见到的算术逻辑部件设计是系统级描述。
作此文，希望能于各位工作带来帮助。
此资料“超前进位链”部分直接取材我以前（为公司）所作《超前进位链》（只有极微改动），因此涉及版权问题。但超前进位链技术不涉及版权问题，各位不用担心，本资料所提供技术可放心使用、流转。本人学历不高、学问不深、实践不足、更兼一气之作，难免谬误，望各位不吝指正。
蒋 小 龙
2001.7.5
个 人 介 绍
蒋小龙乃身份证名，亦用名：蒋维隆
集成电路逻辑设计。设计过16位、32位微处理器，现考虑超标量微处理器实现联系：[email protected]