累加器（AC0—AC3）

CPU包括4个40位的累加器：AC0—AC3

每个累加器分为低字ACxL、高字ACxL和8个保护位AcxG

1、ADD [src,] dst

两个寄存器的内容相加

dst = dst + src

【例】 ADD AC1，AC2

2、ADD k4,dst

4位无符号立即数加到寄存器

dst = dst + k4

【例】 ADD #15，AC0

AC0的内容加上一个4位无符号立即数（15）结果放到寄存器AC0中

3、 ADD K16,[src,]dst

16位有符号立即数和源寄存器的内容相加

dst = src + K16

【例】 ADD #2E00h，AC0，AC1

16位有符号立即数（2E00h）加上AC0的内容，结果放入累加器AC1

4、ADD Smem,[src,]dst 

操作数和源寄存器的内容相加 

dst = src + Smem 

【例】ADD *AR3+, T0, T1 ；

AR3间接寻址得到的内容与T0的内;容相加，结果装入T1，并将AR3增1 

AR3             0302                 0303

T0                3300                 3300

T1                   0                2200

CARRY          0                    0

数据存储器

0302            EF00                EF00

3300+EF00=1 2200

5、ADD ACx<累加器ACx根据Tx中的内容移位后，再和累加器ACy相加 

ACy = ACy + (ACx<【例】ADD AC1<6、ADD ACx<<#SHIFTW, ACy       ; SHIFTW 6位立即数移位值（-32~31）

累加器ACx移位后与累加器ACy相加 

ACy = ACy + (ACx<<#SHIFTW)

【例】ADD AC1<<#31,AC0

7、ADD K16<<#16,[ACx,]ACy

ACy = ACx + (K16<<#16)

16位有符号立即数左移16位后加到累加器

【例】ADD #FFFFh<<#16,AC1,AC0

8、ADD K16<<#SHFT,[ACx,]Acy      ；SHFT  4位立即数移位值（0~15）

16位有符号立即数移位后加到累加器 (根据4位数SHFT的值对16位有符号立即数左移后的值的相加。

ACy = ACx + (K16<<#SHFT)

【例】ADD #FFFFh<<#15,AC1,AC0

9、ADD Smem<操作数根据Tx中的内容移位后，再和累加器ACx相加

ACy = ACx + (Smem<【例】ADD *AR1<AC0            00 0000 0000                00 2330 0000

AC1            00 2300 0000                00 2300 0000

T0                        000C                        000C

AR1                    0200                        0200

SXMD                        0                            0

M40                        0                            0

ACOV0                        0                            0

CARRY                    0                            0

0200                    0300                        0300

0300<<12=0000 0011 0000 0000 0000 0000 0000=030 0000 

030 0000+2300 0000=2330 0000

10、ADD Smem<<#16,[ACx,]ACy

操作数左移16位后，再和累加器ACx相加

ACy = ACx + (Smem<<#16)

【例】ADD *AR3<<#16,AC1,AC0

11、ADD [uns(]smem[)],CARRY,[ACx,] ACy        uns 操作数位无符号数。

操作数带进位加到累加器

ACy = ACx + uns(Smem) + CARRY

【例】ADD [uns]（*AR3），CARRY，AC1，AC2

CARRY状态位和AR3寻址的无符号内容加上AC1的内容，结果存入AC0

12、ADD [uns( ]Smem[)],[ACx,]ACy

执行累加器内容ACx和存储器（Smem）位置的内容的相加到累加器

ACy = ACx + uns(Smem) 

【例】ADD [uns]（*AR3），AC1，AC0

AC1和AR3寻址的无符号内容相加，存到累加器AC0

13、ADD [uns(]smem[)]<<#SHIFTW,[ACx,]ACy

操作数移位后加到累加器

ACy = ACx + (uns(Smem) <<#SHIFTW)

该指令执行累加器内容ACx和根据6位数SHIFTW的值对存储器（Smem）位置移位后的内容的加法。

【例】ADD uns(*AR3)<<#31,AC1,AC0

14、ADD dbl(Lmem),[ACx,]ACy

32位操作数加到累加器

ACy = ACx + dbl(Lmem)

【例】ADD dbl(*AR3+),AC1,AC0

AR3和 AR3+1寻址的内容（长字）加上AC1的内容，结果存入AC0

15、ADD Xmem, Ymem, ACx 

两操作数均左移16位后加到累加器

ACx = (Xmem<<#16) + (Ymem<<#16)

【例】ADD *AR3,*AR4，AC0

16、ADD K16, Smem

操作数和16位有符号立即数相加

Smem = Smem + K16

【例】ADD #FFFFh，*AR3

AR3寻址的内容加上16位带符号数，结果存回AR3寻址的位置。

17、ADD[R]V [ACx,] Acy     V：

计算累加器ACx的绝对值，结果与ACy相加

ACy = rnd(ACy + |ACx|)

【例】ADDV AC1，AC0

二、减法指令

1、SUB[src,]dst

dst = dst – src

两个寄存器的内容相减

【例】SUB  AC1，AC0

2、SUB k4,dst

dst = dst – k4

寄存器的内容减去4位无符号立即数

【例】SUB #15，AC0

3、SUB K16, [src,] dst

dst = dst – K16

寄存器的内容减去16位有符号立即数

【例】SUB #FFFFh，AC1，AC0

AC0= AC1– K16

4、SUB Smem, [src,] dst

dst = dst – Smem

寄存器的内容减去操作数

【例】SUB *AR3，AC1，AC0

AC0=AC1-AR3

5、SUB src, Smem, dst

dst = Smem – src

操作数减去源寄存器的内容

【例】SUB  AC1，*AR3，AC0

AC0=*AR3-AC1

6、SUB ACx << Tx, ACy

ACy = ACy – (ACx << Tx)

累加器ACx根据Tx中的内容移位后，作为减数和累加器ACy相减

【例】SUB AC1<7、SUB  ACx << #SHIFTW, ACy

ACy = ACy – (ACx << #SHIFTW)

累加器ACx移位后，作为减数和累加器ACy相减

【例】SUB AC1<<#31,AC0

AC0=AC0-(AC1<<#31)

8、SUB K16 << #16, [ACx,] ACy

ACy = ACx – (K16 << #16)

16位有符号立即数左移16位后，作为减数和累加器ACx相减

【例】SUB #FFFFh<<#16,AC1,AC0

AC0=AC1-#FFFFh<<#16

9、SUB K16 << #SHFT, [ACx,] ACy

ACy = ACx – (K16 << # SHFT)

16位有符号立即数移位后，作为减数和累加器ACx相减

【例】SUB  #9800h<<#5,AC0,AC1

AC1=AC0- #9800h<<#5

10、SUB Smem << Tx, [ACx,] ACy

ACy = ACx – (Smem << Tx)

操作数根据Tx中的内容移位后，作为减数和累加器ACx相减

【例】SUB *AR3<AC2=AC1-*AR3<11、SUB Smem << #16, [ACx,] ACy

ACy = ACx – (Smem << #16)

操作数左移16位后，作为减数和累加器ACx相减

【例】SUB *AR3<<#16,AC1,AC0

12、SUB ACx, Smem << #16, ACy

ACy = (Smem << #16) – ACx

操作数左移16位后，作为被减数和累加器ACx相减

【例】SUB AC1,*AR3<<#16, AC0

AC0=*AR3<<#16-AC1

13、SUB [uns(]Smem[)], BORROW, [ACx,] ACy

ACy = ACx – uns(Smem) – BORROW

从累加器中减去带借位的操作数

【例】SUB uns(*AR3),BORROW,AC0,AC1

从AC0的内容中减去AR1寻址的无符号内容（F000h）和CARRY位的反码（1），结果存入AC1

AC0                00 EC00 0000                00 EC00 0000

AC1                00 0000 0000                00 EBFF 0FFF

AR1                        0302                        0302

0302                        F000                        F000

CARRY                        0                            1

uns(*AR3)=F000

00 EC00 0000 –F000=EBFF 1000

EBFF 1000-1=EBFF 0FFF

14、SUB [uns(]Smem[)], [ACx,] ACy

ACy = ACx – uns(Smem)

从累加器中减去操作数

【例】SUB (*AR3), AC1,AC0

AC0=AC1-(*AR3)

15、SUB [uns(]Smem[)] << #SHIFTW, [ACx,] ACy

ACy = ACx – (uns(Smem) << #SHIFTW)

从累加器中减去移位后的操作数

【例】SUB uns(*AR3)<<#31，AC1,AC0

16、SUB dbl(Lmem), [ACx,] ACy

ACy = ACx – dbl(Lmem)

从累加器中减去32位操作数

【例】SUB dbl(*AR3+), AC1, AC0

从AC1的内容中减去AR3和AR3+1寻址的内容（长字），结果存入AC0。由于该指令为长操作数指令，执行后AR3递增2

17、SUB ACx, dbl(Lmem), ACy

ACy = dbl(Lmem) – Acx

32位操作数减去累加器

【例】SUB AC1，dbl（*AR3），AC0

从AR3和AR3+1寻址的内容（长字）中减去AC1的内容，结果存入AC0

18 SUB Xmem, Ymem, ACx

ACx = (Xmem << #16) – (Ymem << #16)

两操作数均左移16位后相减

【例】SUB *AR3，*AR4，AC0

三、条件减法

SUBC Smem, [ACx,] ACy 

if ((ACx – (Smem << #15)) >= 0)

ACy = (ACx – (Smem << #15)) << #1 + 1

Else

ACy = ACx << #1

【例】SUBC *AR1, AC0, AC1  ;

如果 (AC0 – (*AR1)<< #15) >= 0，则

AC1 = (AC0 – (*AR1) << #15)<< #1 + 1

否则AC1 = AC0 << #1

AC0            23 4300 0000            23 4300 0000

AC1            00 0000 0000            46 84 00 0001

AR1                    0300                    0300

SXMD                        0                        0

ACOV0                        0                        1

CARRY                    0                        1

0300                    0200                    0200

(*AR1)<< #15=(0000 00010 0000 0000)<<#15

=0000 0001 0000 0000 0000 0000 0000 0000=0100 0000

AC0 –(*AR1)<< #15= 23 4300 0000-0100 0000=23 4200 0000

(AC0 – (*AR1) << #15)<< #1=

0010 0011   0100 0010 0000 0000   0000 0000 0000 0000 

0100 0110   1000 0100 0000 0000   0000 0000 0000 0000

46 84 00 0000

四、条件加减法

TCx 测试控制标志（TC1、TC2）ST0_55.13(12)

1、ADDSUBCC Smem, ACx, TCx, Acy   

ACy = adsc(Smem, ACx, TCx)

If TCx = 1 ACy = ACx+(Smem<<#16)

else          ACy = ACx－(Smem<<#16) 

【例1】ADDSUBCC *AR3,AC1,TC1,AC0

如果TC1=1，AR3寻址的内容左移16位后加上AC1的内容，结果存入AC0

如果TC1=0，从AC1的内容中减去AR3寻址的内容左移16位的值，结果存入AC0

【例2】ADDSUBCC *AR1,  AC0,  TC2,  AC1

AC0            00 EC00 0000                00 EC00 0000

AC1            00 0000 0000                01 1F00 0000

AR1                    0200                        0200

200                        3300                        3300

TC2                        1                            1

SXMD                    0                                0

M40                    0                                0

ACOV1                    0                                1

CARRY                0                                1

TC2=1 

*AR1<<16=0011 0011 0000 0000<<#16=3300 0000

00 EC00 0000+3300 0000=01 1F00 0000

2、ADDSUBCC Smem, ACx, TC1, TC2,ACy

ACy = adsc(Smem, ACx, TC1, TC2)

If TC2=1 ACy=ACx

If TC2=0 and TC1=1

ACy=ACx+( Smem<<#16)

If TC2=0 and TC1=0

ACy=ACx–( Smem<<#16)

【例】ADDSUBCC *AR3， AC1, TC1, TC2,AC0

如果 TC2=1，            AC1的内容存入AC0

如果 TC2=0，and TC1=1：AC0=AC1+( *AR3<<#16)

如果 TC2=0  and TC1=0：AC0=AC1–(*AR 3<<#16) 

3、ADDSUB2CC Smem, ACx, Tx, TC1, TC2,ACy

ACy = ads2c(Smem, ACx, Tx, TC1, TC2)

If TC2=1 and TC1=1

ACy=ACx+( Smem<<#16)

If TC2=0 and TC1=1

ACy=ACx+( Smem<If TC2=1 and TC1=0

ACy=ACx–( Smem<<#16)

If TC2=0 and TC1=0

ACy=ACx–( Smem<ADDSUBCC *AR1, AC0, TC2, AC1 ;

如果 TC2 = 1 ，

则AC1= AC0+(*AR1)<<#16

否则AC1= AC0－(*AR1）<<#16

【例1】ADDSUB2CC *AR2,  AC0, T1,  TC1,  TC2，AC2

TC1=1且TC2=0 

AC0            00 EC00 0000

AC2            00 0000 0000                00 EC00 CC00

AR2                  0201

T1                         0002

TC1                        1

TC2                        0

201                        3300

*AR2<=00 1100 1100 0000 0000=00 CC00

AC0+( *AR2<五、乘法指令

1、 SQR[R] [ACx,] ACy

计算累加器ACx高位部分（32～16位）的平方值，结果舍入后放入累加器ACy

ACy = rnd(ACx * ACx)

【例】 SQR AC1，AC0

2、 MPY[R] [ACx,] ACy 

计算累加器ACx和ACy高位部分（32～16位）的乘积，结果舍入后放入累加器Acy

该指令在D单元MAC中执行乘法运算

ACy = rnd(ACy * ACx)

【例】MPY AC1，AC0  ，AC1=AC1×AC0

AC0         02 6000 3400        02 6000 3400

AC1            00 C000 0000           00 4800 0000

M40                   1                      1

FRCT                 0                      0

ACOV1                0                  0

6000×C000=4800 0000

R或ran 若关键字R或ran用于指令中，则该指令执行舍入操作。

3、 MPY[R] Tx, [ACx,] ACy 

计算累加器ACx高位部分（32～16位）和Tx中内容的乘积，结果舍入后放入累加器Acy

ACy = rnd(ACx * Tx)

【例】MPY T0，AC1，AC0  ；AC1的内容和T0的内容相乘，结果存入AC0。

4、 MPYK[R] K8, [ACx,] ACy

计算累加器ACx高位部分（32～16位）和8位有符号立即数的乘积，结果舍入后放入累加器ACy

【例】MPYK #-2,  AC1，AC0

AC1的内容和8位带符号数（-2）相乘，结果存入AC0

5、 MPYK[R] K16, [ACx,] ACy 

ACy = rnd(ACx * K16)

计算累加器ACx高位部分（32～16位）和16位有符号立即数的乘积，结果舍入后放入累加器ACy

（6）MPYM[R][T3 = ]Smem,Cmem, ACx 

ACx=rnd(Smem*coef(Cmem))[,T3=Smem]

两个操作数相乘，结果舍入后放入累加器ACx

（7）SQRM[R] [T3 = ]Smem, ACx 

操作数的平方，结果舍入后放入累加器ACx

ACx=rnd(Smem*Smem) [,T3=Smem]

（8）MPYM[R] [T3 = ]Smem,[ACx,] ACy 

操作数和累加器ACx相乘，结果舍入后放入累加器ACy

ACy=rnd(Smem*ACx)[,T3= Smem]

（9）MPYMK[R] [T3 = ]Smem, K8, ACx 

操作数和8位有符号立即数相乘，结果舍入后放入累加器ACx

ACx=rnd(Smem * K8) [,T3 = Smem]

（10）MPYM[R][40][T3 ][uns(]Xmem[)], [uns()Ymem[]],Acx

两数据存储器操作数相乘，结果舍入后放入累加器ACx

ACx = M40(rnd(uns(Xmem) * uns(Ymem))) [,T3 = Xmem]

(11)MPYM[R][U][T3 = ]Smem, Tx, ACx 

Tx的内容和操作数相乘，结果舍入后放入累加器ACx

ACx=rnd(uns(Tx*Smem))[,T3=Smem]

六、乘加指令

1、 SQA[R] [ACx,] ACy 

累加器ACy和累加器ACx的乘方相加，结果舍入后放入累加器ACy

ACy = rnd(ACy + (ACx * ACx))

2、 MAC[R] ACx, Tx, ACy[, Acy

累加器ACx和Tx的内容相乘后，再与累加器ACy相加，结果舍入后放入累加器ACy

ACy = rnd(ACy + (ACx * Tx))

3、 MAC[R] ACy, Tx, ACx, ACy

累加器ACy和Tx的内容相乘后，再与累加器ACx相加，结果舍入后放入累加器ACy

ACy = rnd((ACy * Tx) + ACx)

4、 MACK[R] Tx, K8, [ACx,] ACy 

Tx的内容和8位有符号立即数相乘后，再与累加器ACx相加，结果舍入后放入累加器ACy

ACy = rnd(ACx + (Tx * K8))

5、 MACK[R] Tx, K16, [ACx,] ACy 

Tx的内容和16位有符号立即数相乘后，再与累加器ACx相加，结果舍入后放入累加器ACy

ACy = rnd(ACx + (Tx * K16))

6、 MACM[R][T3= ]Smem, Cmem, ACx 

双操作数相乘后加到累加器ACx并作舍入

ACx = rnd(ACx + (Smem * Cmem)) [,T3 = Smem]

7、 MACM[R]Z [T3 = ]Smem, Cmem, ACx 

同上一条指令，并且与delay指令并行执行

ACx = rnd(ACx + (Smem * Cmem)) [,T3 = Smem],delay(Smem)

8、 SQAM[R] [T3 = ]Smem, [ACx,] ACy    

累加器ACx和操作数的乘方相加，结果舍入后放入累加器ACy

Acy = rnd(ACy + (Smem * ACx)) [,T3 = Smem] 

9、 MACM[R] [T3 = ]Smem, [ACx,] ACy     

操作数和累加器ACx相乘后，结果加到累加器ACy并作舍入

Acy = rnd(ACy + (Smem * ACx)) [,T3 = Smem]

10、 MACM[R] [T3 = ]Smem, Tx, [ACx,] ACy     

Tx的内容和操作数相乘，再与累加器ACx相加，结果舍入后放入累加器ACy

ACy = rnd(ACx + (Tx * Smem)) [,T3 = Smem] 

11、 MACMK[R] [T3 = ]Smem, K8, [ACx,] ACy      

操作数和8位有符号立即数相乘，再与累加器ACx相加，结果舍入后放入累加器ACy

12、 MACM[R][40][T3=][uns()Xmem[]], [uns() Ymem[]],[ACx,] Acy

两数据存储器操作数相乘，再与累加器ACx相加，结果舍入后放入累加器ACy

(Ymem)))) [,T3 = Xmem]

13、 MACM[R][40][T3=][uns()Xmem[]],[uns() Ymem[]],ACx >> #16[, ACy]

两数据存储器操作数相乘，再与累加器ACx右移16位后的值相加，结果舍入后放入累加器ACy

(Xmem) *uns(Ymem)))) [,T3 = Xmem]

七、乘减指令

1、 SQS[R] [ACx,] ACy 

累加器ACy减去累加器ACx的平方，结果舍入后放入累加器ACy

ACy = rnd(ACy – (ACx * ACx))

2、 MAS[R] Tx, [ACx,] ACy 

累加器ACy减去累加器ACx和Tx内容的乘积，结果舍入后放入累加器ACy

ACy = rnd(ACy – (ACx * Tx))

3、 MASM[R] [T3 = ]Smem, Cmem, ACx 

累加器ACx减去两个操作数的乘积，结果舍入后放入累加器ACx

ACx = rnd(ACx – (Smem * Cmem)) [,T3 = Smem]

4、 MASM[R] [T3 = ]Smem, [ACx,] ACy 

累加器ACy减去操作数和累加器ACx的乘积，结果舍入后放入累加器ACy

ACy = rnd(ACy – (Smem * ACx)) [,T3 = Smem]

5、 MASM[R] [T3 = ]Smem, Tx, [ACx,] ACy 

累加器ACx减去Tx的内容和操作数的乘积，结果舍入后放入累加器ACy

ACy = rnd(ACx – (Tx * Smem)) [,T3 = Smem]

6、 MASM[R][40][T3 =][uns()Xmem[]], [uns(]Ymem[)],[ACx,] ACy

累加器ACx减去两数据存储器操作数的乘积，结果舍入后放入累加器ACy

ACy = M40(rnd(ACx – (uns(Xmem) * uns(Ymem))))[,T3 = Xmem]

八、双乘加/双乘减指令

双乘加/双乘减指令利用D单元的两个MAC在一个周期内同时执行两个乘法或双乘加/双乘减运算

1、 MPY[R][40][uns(]Xmem[)], uns(]Cmem[)], ACx

::MPY[R][40] [uns(]Ymem[)], [uns()Cmem[]], ACy 

在一个周期内同时完成下列算术运算：两个操作数Xmem和Cmem、Ymem和Cmem相乘：ACx=Xmem*Cmem::ACy=Ymem*Cmem

ACx = M40(rnd(uns(Xmem) * uns(coef(Cmem)))),

ACy=M40(rnd(uns(Ymem)*  uns(coef(Cmem)))) 

2、 MAC[R][40] [uns(]Xmem[)], [uns(]Cmem[)], ACx

::MPY[R][40] [uns(]Ymem[)], [uns()Cmem[]], ACy 

在一个周期内同时完成下列算术运算：累加器ACx与两个操作数的乘积相加，结果舍入后放入累加器ACx ；两个操作数相乘，结果舍入后放入累加器ACy

ACx = M40(rnd(ACx + (uns(Xmem) *uns(coef(Cmem))))),

ACy = M40(rnd(uns(Ymem) * uns(coef(Cmem))))) 

3、 MAS[R][40] [uns(]Xmem[)], [uns(]Cmem[)], ACx

::MPY[R][40] [uns(]Ymem[)], [uns(]Cmem[)], ACy 

在一个指令周期内同时完成下列算术运算：累加器ACx减去两个操作数的乘积，结果舍入后放入累加器ACx ；两个操作数相乘，结果舍入后放入累加器ACy

ACx = M40(rnd(ACx – (uns(Xmem) * uns(coef(Cmem))))),

ACy = M40(rnd(uns(Ymem) * uns(coef(Cmem)))) 

4、 AMAR Xmem

::MPY[R][40] [uns(]Ymem[)], [uns()Cmem[]], ACx 

在一个指令周期内同时完成下列算术运算：修改操作数的值；两个操作数的乘法运算 

mar(Xmem),

ACx = M40(rnd(uns(Ymem) * uns(coef(Cmem)))) 

5、 MAC[R][40] [uns(]Xmem[)], [uns(]Cmem[)], ACx

::MAC[R][40] [uns(]Ymem[)], [uns(]Cmem[)], ACy 

在一个指令周期内同时完成下列算术运算：累加器和两个操作数的乘积相加 

ACx = M40(rnd(ACx + (uns(Xmem) *uns(Cmem)))),

ACy = M40(rnd(ACy + (uns(Ymem) * uns(Cmem)))) 

6、 MAS[R][40] [uns(]Xmem[)], [uns(]Cmem[)], ACx

::MAC[R][40] [uns(]Ymem[)], [uns(]Cmem[)], ACy 

在一个指令周期内同时完成下列算术运算：累加器和两个操作数的乘积相减；累加器和两个操作数的乘积相加 

ACx = M40(rnd(ACx – (uns(Xmem) * uns(Cmem)))),

ACy = M40(rnd(ACy + (uns(Ymem) * uns(Cmem))))

7、 AMAR Xmem

::MAC[R][40] [uns(]Ymem[)], [uns(]Cmem[)], ACx 

在一个指令周期内同时完成下列算术运算：修改操作数的值；累加器和两个操作数的乘积相加

mar(Xmem),

ACx = M40(rnd(ACx + (uns(Ymem) * uns(Cmem)))) 

8、MAS[R][40] [uns(]Xmem[)], [uns(]Cmem[)], Acx

::MAS[R][40] [uns(]Ymem[)], [uns(]Cmem[)], ACy

在一个指令周期内同时完成下列算术运算：累加器和两个操作数的乘积相减

ACx = M40(rnd(ACx – (uns(Xmem) * uns(Cmem)))),

ACy = M40(rnd(ACy – (uns(Ymem) * uns(Cmem)))) 

9、 AMAR Xmem

::MAS[R][40] [uns(]Ymem[)], [uns(]Cmem[)], ACx 

在一个指令周期内同时完成下列算术运算：修改操作数的值；累加器和两个操作数的乘积相减

mar(Xmem),

ACx = M40(rnd(ACx – (uns(Ymem) * uns(Cmem)))) 

10、 MAC[R][40] [uns(]Xmem[)], [uns(]Cmem[)], ACx >>#16

::MAC[R][40] [uns(]Ymem[)], [uns(]Cmem[)], ACy 

在一个指令周期内同时完成下列算术运算：累加器右移16位后和两个操作数的乘积相加；累加器和两个操作数的乘积相加

ACx = M40(rnd((ACx >> #16) + (uns(Xmem) *uns(Cmem)))),

ACy = M40(rnd(ACy + (uns(Ymem) * uns(Cmem)))) 

11、 MPY[R][40] [uns()Xmem[]], [uns(]Cmem[)], ACx

::MAC[R][40] [uns()Ymem[]], [uns()Cmem[]], ACy >> #16

在一个指令周期内并行完成两次下列算术运算：两个操作数相乘，累加器右移16位后和两个操作数的乘积相加 

ACx = M40(rnd(uns(Xmem) * uns(coef(Cmem))),

ACy = M40(rnd((ACy >> #16) + (uns(Ymem) *uns(coef(Cmem)))))

12、 MAC[R][40] [uns()Xmem[]], [uns()Cmem[]], ACx >>#16

::MAC[R][40] [uns()Ymem[]], [uns()Cmem[]], ACy >>#16

在一个指令周期内同时完成下列算术运算：累加器右移16位后和两个操作数的乘积相加

ACx = M40(rnd((ACx >> #16) + (uns(Xmem) *uns(Cmem)))),

ACy = M40(rnd((ACy >> #16) + (uns(Ymem) *uns(Cmem))))

13、 MAS[R][40] [uns()Xmem[]], [uns()Cmem[]], ACx

::MAC[R][40] [uns()Ymem[]], [uns()Cmem[]], ACy >>#16

14、 AMAR Xmem

::MAC[R][40] [uns()Ymem[]], [uns(]Cmem[)], ACx >>#16

在一个指令周期内同时完成下列算术运算：修改操作数的值；累加器右移16位后和两个操作数的乘积相加

mar(Xmem),

ACx = M40(rnd((ACx >> #16) + (uns(Ymem) *uns(Cmem)))) 

15、 AMAR Xmem, Ymem, Cmem

在一个指令周期内同时完成下列算术运算：修改操作数的值

mar(Xmem), mar(Ymem), mar(Cmem)

九、双16位算术指令

1、 ADDSUB Tx,Smem,ACx (双16位加和减)

该指令在一个周期内执行两条并行的算术操作：加和减

HI（ACx）=Smem+Tx

::LO(Acx)=Smem-Tx

[例]：ADDSUB  T1,*AR1,AC1

两条指令并行执行。AR1寻址的内容加上T1的内容，结果存入AC1（39~16）。从AR1的内容中减去T1的内容，结果存入AC（15~0）

执行前                    执行后

AC1        00 2300 0000        00 2330 A300

T1               4000              4000

AR1               0201              0201

0201               E300               E300

SXMD               1                1

M40                   1                1

ACOV0              0              0

CARRY            0              1

E300+4000=1 2300 

E300-4000=A300

2、 SUBADD Tx, Smem, ACx 

在一个指令周期内，在D-ALU中的高低位并行执行两个16位算术运算，在ACx的高16位保存两个操作数相减结果，在ACx的低16位保存两个操作数相加结果

HI(ACx) = Smem – Tx,

::LO(ACx) = Smem + Tx 

3、 ADD dual(Lmem), [ACx,] ACy 

在一个指令周期内，在D-ALU中的高低位并行执行两个16位算术运算，在ACx的高16位保存32位操作数和累加器高16位的相加结果，在ACx的低16位保存32位操作数和累加器低16位的相加结果

HI(ACy) = HI(Lmem) + HI(ACx),

::LO(ACy) = LO(Lmem) + LO(ACx

4、 SUB dual(Lmem), [ACx,] ACy 

在一个指令周期内，在D-ALU中的高低位并行执行两个16位算术运算，在ACx的高16位保存累加器和32位操作数高16位的相减结果，在ACx的低16位保存累加器和32位操作数低16位的相减结果

HI(ACy) = HI(Lmem) + HI(ACx),

::LO(ACy) = LO(Lmem) + LO(ACx) 

5、 SUB dual(Lmem), Tx, ACx 

在一个指令周期内，在D-ALU中的高低位并行执行两个16位算术运算，在ACx的高16位保存Tx的内容和32位操作数高16位的相减、相加结果，在ACx的低16位保存Tx的内容和32位操作数低16位的相减、相加结果

HI(ACx) = Tx – HI(Lmem),

::LO(ACx) = Tx – LO(Lmem) 

6、 ADD dual(Lmem), Tx, ACx 

HI(ACx) = HI(Lmem) + Tx,

::LO(ACx) = LO(Lmem) + Tx 

7、 SUB Tx, dual(Lmem), ACx 

HI(ACx) = HI(Lmem) – Tx,

::LO(ACx) = LO(Lmem) – Tx 

8、 ADDSUB Tx, dual(Lmem), ACx 

HI(ACx) = HI(Lmem) + Tx,

::LO(ACx) = LO(Lmem) – Tx 

9、 SUBADD Tx, dual(Lmem), ACx 

HI(ACx) = HI(Lmem) – Tx,

::LO(ACx) = LO(Lmem) + Tx 

十、比较和选择极值指令 

比较和选择极值指令可以在D单元的ALU中完成两个并行16位极值选择操作和一个40位极值选择操作 .

--------------------------------------------------------------------------------------------------------------------

MAXDIFF  ACx, ACy, ACz, ACw 

max_diff(ACx, ACy, ACz, ACw)

TRNx = TRNx >> #1

ACw(39–16)=ACy(39–16)–ACx(39–16)

ACw(15–0) = ACy(15–0) – ACx(15–0)

If (ACx(31–16) > ACy(31–16))

{bit(TRN0,15)=#0;ACz(39–16)=ACx(39–16) }

else

{bit(TRN0,15)=#1;ACz(39–16)=ACy(39–16) }

If (ACx(15–0) > ACy(15–0))

{bit(TRN1,15)=#0 ; ACz(15–0) = ACx(15–0) }

else

{bit(TRN1,15)=#1 ; ACz(15–0) = ACy(15–0) } 

【例】

MAXDIFF AC0, AC1, AC2, AC1 ; 

AC0                10 2400 2222                10 2400 2222

AC1                90 0000 0000                FF 8000 DDDE

AC2                00 0000 0000                10 2400 2222

SATD                            1                            1

TRN0                        1000                        0800

TRN1                        0100                        0080

ACOV1                            0                            1

CARRY                            1                            0

0000 1000 0000 0000

--------------------------------------------------------------------------------------------------------------------

DMAXDIFF ACx,ACy,ACz,ACw,TRNx

max_diff_dbl(ACx, ACy, ACz, ACw, TRNx)

If M40 = 0:

TRNx = TRNx >> #1

ACw(39–0) = ACy(39–0) – ACx(39–0)

If (ACx(31–0) > ACy(31–0))

{bit(TRNx,15)=#0 ; ACz(39–0) = ACx(39–0) }

else

{bit(TRNx,15)=#1 ; ACz(39–0) = ACy(39–0) }

If M40 = 1:

TRNx = TRNx >> #1

ACw(39–0) = ACy(39–0) – ACx(39–0)

If (ACx(39–0) > ACy(39–0))

{bit(TRNx,15)=#0 ; ACz(39–0) = ACx(39–0) }

else

{bit(TRNx,15)=#1 ; ACz(39–0) = ACy(39–0) } 

--------------------------------------------------------------------------------------------------------------------

MINDIFF ACx,ACy,ACz,ACw

min_diff(ACx, ACy, ACz, ACw) 

TRNx = TRNx >> #1

ACw(39–16) = ACy(39–16) – ACx(39–16)

ACw(15–0) = ACy(15–0) – ACx(15–0)

If (ACx(31–16) < ACy(31–16))

{bit(TRN0,15)=#0;ACz(39–16)=ACx(39–16) }

else

{bit(TRN0,15)=#1;ACz(39–16)=ACy(39–16) }

If (ACx(15–0) < ACy(15–0))

{bit(TRN1,15)=#0 ; ACz(15–0) = ACx(15–0) }

else

{bit(TRN1,15)=#1 ; ACz(15–0) = ACy(15–0) } 

--------------------------------------------------------------------------------------------------------------------

DMINDIFF ACx,ACy,ACz,ACw,TRNx

min_diff_dbl(ACx, ACy, ACz, ACw, TRNx)

If M40 = 0:

TRNx = TRNx >> #1

ACw(39–0) = ACy(39–0) – ACx(39–0)

If (ACx(31–0) < ACy(31–0))

{bit(TRNx,15)=#0 ; ACz(39–0) = ACx(39–0) }

else

{bit(TRNx,15)=#1 ; ACz(39–0) = ACy(39–0) }

If M40 = 1:

TRNx = TRNx >> #1

ACw(39–0) = ACy(39–0) – ACx(39–0)

If (ACx(39–0) < ACy(39–0))

{bit(TRNx,15)=#0 ; ACz(39–0) = ACx(39–0) }

else

{bit(TRNx,15)=#1 ; ACz(39–0) = ACy(39–0) } 

十一、最大/最小值指令 

十二、存储器比较指令 

十三、寄存器比较指令 

十四、条件移位指令

十五、带符号移位指令

十六、修改辅助寄存器（MAR）指令

十七、修改堆栈指针指令

十八、隐含并行指令 

十九、绝对距离指令

二十、绝对值指令

二十一、FIR滤波指令 

二十二、最小均方（LMS）指令

二十三、补码指令

二十四、归一化指令

二十五、饱和和舍入指令 

二十六、平方差指令 

 1．位操作指令下载本文