难倒在 LC-3 组装的扩展乘法上
Stumped on Extended Multiplication for LC-3 Assembly
我正在尝试让扩展乘法在 LC-3 上运行。我的代码的相关摘录：
.ORIG x3000
; Calculate AB = A x B
LEA R6, ARGS
LD R0, B
STR R0, R6, #0 ; Store B into Multiplier address of ARGS
JSR PRINT
LD R0, A
STR R0, R6, #1 ; Store A into Multiplicand address of ARGS
JSR PRINT
LEA R0, AB ; R0 <- starting address of AB
STR R0, R6, #2 ; Store starting address of AB into Product word of ARGS
JSR XMULT
; DID WE LOAD THE PRODUCT PROPERLY?
; THIS SHOULD PRINT THE LEAST SIGNIFICANT BITS OF PRODUCT
LDR R0, R0, #0
JSR PRINT
; THIS SHOULD PRINT THE MOST SIGNIFICANT BITS OF PRODUCT
LEA R0, AB
ADD R0, R0, #1
LDR R0, R0, #0
JSR PRINT
; Calculate XY = X * Y
TRAP x25
; Test Data
A .FILL x0010
B .FILL x00AB
X .FILL x1234
Y .FILL xABCD
AB .BLKW 2
XY .BLKW 2
; Argument List
ARGS .BLKW 1 ;Multiplier (value)
.BLKW 1 ;Multiplicand (value)
.BLKW 1 ;Product (address)
;**********************************************************
XMULT ;Extended Multiplication
;Arguments located by R6
; multiplier (value)
; multiplicand (value)
; product (address)
ST R7, XMU7 ;Save Registers
ST R0, XMU0 ; TEMP register (for storing temp results and passing to RightShift subroutine)
ST R1, XMU1 ; Will store MPR (Multiplier)
ST R2, XMU2 ; Will store MND (Multiplicand)
ST R3, XMU3 ; Will store ACC (Accumulator)
ST R4, XMU4 ; Will serve as a COUNTER for loop
ST R5, XMU5 ; Will store BITMASK for testing
ST R6, XMU6 ; Argument list
LDR R1, R6, #0 ; Store MPR into R1 (Multiplier is first item in the argument list pointed to by R6)
LDR R2, R6, #1 ; Store MND into R2 (Multiplicand is second item)
AND R3, R3, #0 ; ACC <- 0
LD R4, COUNTER ; Set counter
LD R5, BITMASK ; Set R5 to 0000 0000 0000 0001, the bitmask needed to test MPR[0]
; Counter and operands ready - now we can start the loop
MULOOP ; MUltiplication LOOP
AND R0, R5, R1 ; Test MPR[0]
BRz ELSE ; Branch if MPR[0] isn't set
ADD R3, R3, R2 ; ACC <- ACC + MND
ELSE
AND R0, R0, #0 ; Clear R0
ADD R0, R3, #0 ; R0 <- ACC
JSR SHIFT ; ShiftRight(ACC)
ADD R3, R0, #0 ; R3 <- Right-shifted ACC
ADD R0, R1, #0 ; R0 <- MPR
JSR SHIFT ; ShiftRight(MPR)
ADD R1, R0, #0 ; R1 <- Right-shifted MPR
ADD R4, R4, #-1 ; Decrement Counter
BRp MULOOP ; If Counter > 0, branch to beginning of loop
MULOOPEND ; MUltiplication LOOP ends here
; Write results to memory addresses (OUT-parameter segment)
LDR R0, R6, #2 ; R0 <- Product(address), least significant digit
STR R1, R0, #0 ; Right-shifted MPR goes in the lower address word
STR R3, R0, #1 ; Right-shifted ACC goes in the higher address word
LD R7, XMU7 ; Restore Registers
LD R0, XMU0
LD R1, XMU1
LD R2, XMU2
LD R3, XMU3
LD R4, XMU4
LD R5, XMU5
LD R6, XMU6
RET
XMU0 .BLKW 1
XMU1 .BLKW 1
XMU2 .BLKW 1
XMU3 .BLKW 1
XMU4 .BLKW 1
XMU5 .BLKW 1
XMU6 .BLKW 1
XMU7 .BLKW 1
; Data
COUNTER .FILL x0010
BITMASK .FILL x0001
请注意，子程序PRINT 和SHIFT 只是将R0 的内容以位形式打印到控制台，并分别对R0 的内容执行右移。请假设它们正常工作（我已经多次测试它们并且它们是）。
因此，该代码应该计算两个 N 位无符号整数的双字乘积。当然，乘积存储在两个连续的字中，"least significant" 位存储在低地址字中。
在 XMULT 子程序中，我使用 R3（ACCumulator 的 ACC）和 R1（MultiPlieR 的 MPR）分别存储乘积的 "most significant" 和 "least significant" 部分。这些是使用标准通用乘法算法计算的
MPR <- Multiplier
MND <- Multiplicand
ACC <- 0
for (int k = 1; k <= N; k++)
{
if (MPR[0]) // Test MPR[0]
ACC <- ACC + MND
ShiftRight(ACC:MPR)
}
这样到循环结束时，双字乘积可用于 ACC:MPR。
ACC 似乎在循环终止时存储了正确的值，但 MPR 没有。例如，取值 X 和 Y，查询位乘计算器显示 x1234 * xABCD = xC374FA4
现在，如果我 运行 我的代码乘以 X 和 Y，一旦乘法循环终止，ACC（乘积的最重要部分）存储 b0000 1100 0011 0111 = x0C37，所以这部分看起来是正确的。但是，MPR 存储零 (b0000 0000 0000 0000 = x0000)。
在过去的几个小时里，我一直在我的 LC-3 模拟器上使用断点和 Step Into 函数来逐步检查我的代码，试图弄清楚为什么会发生这种情况，而我唯一要做的就是我注意到乘法循环期间发生的逻辑右移在循环终止之前将 MPR 减少到 0（尽管 ACC 获得了正确的值）。
正如我所说，所有子程序（逻辑右移的 SHIFT 是其中最重要的）都在正常工作，并且 MULOOP 之类的 SEEMS 正确实现了通用乘法算法，那么为什么 MPR 会被清零？
更令人困惑的是，我尝试将 x0100 和 x0200 相乘（只是为了尝试两个简单的数字），我得到了正确答案：x0002 存储在 ACC 中，x0000 存储在 MPR 中，使得乘积 x20000 (因为 ACC 是产品中最重要的部分，而 MPR 是最不重要的部分）。
我不知道怎么了。几个小时以来，我一直在转动轮子尝试各种事情：
我改变了操作数的顺序（交换了乘数和被乘数），这当然对乘法没有影响，但我很绝望
我尝试了一种完全不同的逻辑右 SHIFT 实现，它也是正确的。不出所料，结果和原来的一模一样
我已经更改了循环计数器的值，试图查看循环的较少迭代是否会导致 MPR 在循环终止之前不会被清零。答案：确实如此，但正如预期的那样，这会导致 ACC 不再在循环终止时存储正确的值。此外，MPR 也不会存储正确的值 - 它只是不会最终为零（如果我使用较小的计数器）。
我真的被难住了。是我的乘法循环的实现有问题，还是有其他问题？我什至不知道去哪里找错误了。
快速提问：
PRINT 过程是否保留 R6 ？如果不是，您需要使用额外的 LEA R6, ARGS 指令为第二个和第三个参数重新加载它。
你实际上并不ShiftRight(ACC:MPR)
你ShiftRight(ACC)ShiftRight(MPR)
ADD R0, R3, #0 ; R0 <- ACC
JSR SHIFT ; ShiftRight(ACC)
ADD R3, R0, #0 ; R3 <- Right-shifted ACC
ADD R0, R1, #0 ; R0 <- MPR
JSR SHIFT ; ShiftRight(MPR)
ADD R1, R0, #0 ; R1 <- Right-shifted MPR
在程序的这一部分中，您执行 2 个完全独立的操作。您将 R3 (ACC) 中的单词向右移动，并将 R1 (MPR) 中的单词向右移动。
但是，您忘记了 ACC:MPR 应该是 32 位的数量。 ACC 右侧移出 out 的位必须移至 MPR 左侧 in。由于这没有发生，您最终得到一个空的 MPR。
你应该做什么：
If Bit(ACC,0) = 0
ShiftRight(ACC)
ShiftRight(MPR)
Else
ShiftRight(ACC)
ShiftRight(MPR)
Add(MPR,32768)
Endif
我正在尝试让扩展乘法在 LC-3 上运行。我的代码的相关摘录：
.ORIG x3000
; Calculate AB = A x B
LEA R6, ARGS
LD R0, B
STR R0, R6, #0 ; Store B into Multiplier address of ARGS
JSR PRINT
LD R0, A
STR R0, R6, #1 ; Store A into Multiplicand address of ARGS
JSR PRINT
LEA R0, AB ; R0 <- starting address of AB
STR R0, R6, #2 ; Store starting address of AB into Product word of ARGS
JSR XMULT
; DID WE LOAD THE PRODUCT PROPERLY?
; THIS SHOULD PRINT THE LEAST SIGNIFICANT BITS OF PRODUCT
LDR R0, R0, #0
JSR PRINT
; THIS SHOULD PRINT THE MOST SIGNIFICANT BITS OF PRODUCT
LEA R0, AB
ADD R0, R0, #1
LDR R0, R0, #0
JSR PRINT
; Calculate XY = X * Y
TRAP x25
; Test Data
A .FILL x0010
B .FILL x00AB
X .FILL x1234
Y .FILL xABCD
AB .BLKW 2
XY .BLKW 2
; Argument List
ARGS .BLKW 1 ;Multiplier (value)
.BLKW 1 ;Multiplicand (value)
.BLKW 1 ;Product (address)
;**********************************************************
XMULT ;Extended Multiplication
;Arguments located by R6
; multiplier (value)
; multiplicand (value)
; product (address)
ST R7, XMU7 ;Save Registers
ST R0, XMU0 ; TEMP register (for storing temp results and passing to RightShift subroutine)
ST R1, XMU1 ; Will store MPR (Multiplier)
ST R2, XMU2 ; Will store MND (Multiplicand)
ST R3, XMU3 ; Will store ACC (Accumulator)
ST R4, XMU4 ; Will serve as a COUNTER for loop
ST R5, XMU5 ; Will store BITMASK for testing
ST R6, XMU6 ; Argument list
LDR R1, R6, #0 ; Store MPR into R1 (Multiplier is first item in the argument list pointed to by R6)
LDR R2, R6, #1 ; Store MND into R2 (Multiplicand is second item)
AND R3, R3, #0 ; ACC <- 0
LD R4, COUNTER ; Set counter
LD R5, BITMASK ; Set R5 to 0000 0000 0000 0001, the bitmask needed to test MPR[0]
; Counter and operands ready - now we can start the loop
MULOOP ; MUltiplication LOOP
AND R0, R5, R1 ; Test MPR[0]
BRz ELSE ; Branch if MPR[0] isn't set
ADD R3, R3, R2 ; ACC <- ACC + MND
ELSE
AND R0, R0, #0 ; Clear R0
ADD R0, R3, #0 ; R0 <- ACC
JSR SHIFT ; ShiftRight(ACC)
ADD R3, R0, #0 ; R3 <- Right-shifted ACC
ADD R0, R1, #0 ; R0 <- MPR
JSR SHIFT ; ShiftRight(MPR)
ADD R1, R0, #0 ; R1 <- Right-shifted MPR
ADD R4, R4, #-1 ; Decrement Counter
BRp MULOOP ; If Counter > 0, branch to beginning of loop
MULOOPEND ; MUltiplication LOOP ends here
; Write results to memory addresses (OUT-parameter segment)
LDR R0, R6, #2 ; R0 <- Product(address), least significant digit
STR R1, R0, #0 ; Right-shifted MPR goes in the lower address word
STR R3, R0, #1 ; Right-shifted ACC goes in the higher address word
LD R7, XMU7 ; Restore Registers
LD R0, XMU0
LD R1, XMU1
LD R2, XMU2
LD R3, XMU3
LD R4, XMU4
LD R5, XMU5
LD R6, XMU6
RET
XMU0 .BLKW 1
XMU1 .BLKW 1
XMU2 .BLKW 1
XMU3 .BLKW 1
XMU4 .BLKW 1
XMU5 .BLKW 1
XMU6 .BLKW 1
XMU7 .BLKW 1
; Data
COUNTER .FILL x0010
BITMASK .FILL x0001
请注意，子程序PRINT 和SHIFT 只是将R0 的内容以位形式打印到控制台，并分别对R0 的内容执行右移。请假设它们正常工作（我已经多次测试它们并且它们是）。
因此，该代码应该计算两个 N 位无符号整数的双字乘积。当然，乘积存储在两个连续的字中，"least significant" 位存储在低地址字中。
在 XMULT 子程序中，我使用 R3（ACCumulator 的 ACC）和 R1（MultiPlieR 的 MPR）分别存储乘积的 "most significant" 和 "least significant" 部分。这些是使用标准通用乘法算法计算的
MPR <- Multiplier
MND <- Multiplicand
ACC <- 0
for (int k = 1; k <= N; k++)
{
if (MPR[0]) // Test MPR[0]
ACC <- ACC + MND
ShiftRight(ACC:MPR)
}
这样到循环结束时，双字乘积可用于 ACC:MPR。
ACC 似乎在循环终止时存储了正确的值，但 MPR 没有。例如，取值 X 和 Y，查询位乘计算器显示 x1234 * xABCD = xC374FA4
现在，如果我 运行 我的代码乘以 X 和 Y，一旦乘法循环终止，ACC（乘积的最重要部分）存储 b0000 1100 0011 0111 = x0C37，所以这部分看起来是正确的。但是，MPR 存储零 (b0000 0000 0000 0000 = x0000)。
在过去的几个小时里，我一直在我的 LC-3 模拟器上使用断点和 Step Into 函数来逐步检查我的代码，试图弄清楚为什么会发生这种情况，而我唯一要做的就是我注意到乘法循环期间发生的逻辑右移在循环终止之前将 MPR 减少到 0（尽管 ACC 获得了正确的值）。
正如我所说，所有子程序（逻辑右移的 SHIFT 是其中最重要的）都在正常工作，并且 MULOOP 之类的 SEEMS 正确实现了通用乘法算法，那么为什么 MPR 会被清零？
更令人困惑的是，我尝试将 x0100 和 x0200 相乘（只是为了尝试两个简单的数字），我得到了正确答案：x0002 存储在 ACC 中，x0000 存储在 MPR 中，使得乘积 x20000 (因为 ACC 是产品中最重要的部分，而 MPR 是最不重要的部分）。
我不知道怎么了。几个小时以来，我一直在转动轮子尝试各种事情：
我改变了操作数的顺序（交换了乘数和被乘数），这当然对乘法没有影响，但我很绝望
我尝试了一种完全不同的逻辑右 SHIFT 实现，它也是正确的。不出所料，结果和原来的一模一样
我已经更改了循环计数器的值，试图查看循环的较少迭代是否会导致 MPR 在循环终止之前不会被清零。答案：确实如此，但正如预期的那样，这会导致 ACC 不再在循环终止时存储正确的值。此外，MPR 也不会存储正确的值 - 它只是不会最终为零（如果我使用较小的计数器）。
我真的被难住了。是我的乘法循环的实现有问题，还是有其他问题？我什至不知道去哪里找错误了。
快速提问：
PRINT 过程是否保留 R6 ？如果不是，您需要使用额外的 LEA R6, ARGS 指令为第二个和第三个参数重新加载它。
你实际上并不ShiftRight(ACC:MPR)
你ShiftRight(ACC)ShiftRight(MPR)
ADD R0, R3, #0 ; R0 <- ACC JSR SHIFT ; ShiftRight(ACC) ADD R3, R0, #0 ; R3 <- Right-shifted ACC ADD R0, R1, #0 ; R0 <- MPR JSR SHIFT ; ShiftRight(MPR) ADD R1, R0, #0 ; R1 <- Right-shifted MPR
在程序的这一部分中，您执行 2 个完全独立的操作。您将 R3 (ACC) 中的单词向右移动，并将 R1 (MPR) 中的单词向右移动。
但是，您忘记了 ACC:MPR 应该是 32 位的数量。 ACC 右侧移出 out 的位必须移至 MPR 左侧 in。由于这没有发生，您最终得到一个空的 MPR。
你应该做什么：
If Bit(ACC,0) = 0
ShiftRight(ACC)
ShiftRight(MPR)
Else
ShiftRight(ACC)
ShiftRight(MPR)
Add(MPR,32768)
Endif