Question

我正在为6502 cpu编写汇编语言程序，发现我需要一种尽可能快的除以7例程，特别是可能需要16位除法的例程。

我对here中找到的例程很熟悉，但是对找到的除以7的例程进行概括非常复杂，并且粗略地检查了通用算法（使用整数除法）

x / 7〜=（x + x / 8 + x / 64 ...）/ 8

表示要处理16位范围，由于6502的单个累加器寄存器和6502上单个存储器位移位的相对较慢，可能需要100个周期才能完成。

我认为查找表可能会有所帮助，但是在6502上，我当然仅限于256字节或更少的查找表。为此，可以假设存在两个256字节查找表xdiv7和xmod7，当使用无符号的一字节值作为表的索引时，它们可以快速获得字节除以7或取模的结果。 7，分别。我不确定如何利用这些来找到整个16位范围的值。

并行地，我还需要7模运算法则，尽管理想情况下，可以用除法解决的任何解决方案也会产生mod7结果。如果需要其他预计算表，只要所有表的总内存需求不超过3k，我都可以添加这些表。

尽管我最终需要一种带符号的除法算法，但无符号的算法就足够了，因为我可以根据需要将其推广到带符号的例程中。

任何帮助将不胜感激。

Answer 1

注意：正如@Damien_The_Unbeliever在注释中指出的，upperHigh和lowerLow表是相同的。因此，它们可以组合成一个表。但是，这种优化将使代码更难阅读，解释也更难编写，因此将表的合并留给读者练习。

下面的代码显示将16位无符号值除以7时如何生成商和余数。解释代码（IMO）的最简单方法是一个示例，因此让我们考虑将0xa732除以7.预期结果是：

quotient = 0x17e2
remainder = 4

我们首先将输入视为两个8位值，即upper字节和lower字节。 upper字节为0xa7，lower字节为0x32。

我们从upper字节计算商和余数：

0xa700 / 7 = 0x17db
0xa700 % 7 = 3

所以我们需要三个表：

upperHigh存储商的高字节：upperHigh[0xa7] = 0x17
upperLow存储商的低字节：upperLow[0xa7] = 0xdb
upperRem存储其余：upperRem[0xa7] = 3

我们从lower字节计算商和余数：

0x32 / 7 = 0x07
0x32 % 7 = 1

所以我们需要两个表：

lowerLow存储商的低字节：lowerLow[0x32] = 0x07
lowerRem存储其余：lowerRem[0x32] = 1

现在，我们需要汇总最终答案。余数是两个余数的总和。由于每个余数都在[0,6]范围内，所以总和在[0,12]范围内。因此，我们可以使用两个13字节的查询将总和转换为最后的余数和进位。

商的低字节是进位与lowerLow和upperLow表中的值之和。请注意，总和可能会在高字节中产生一个进位。

商的高字节是进位与upperHigh表中的值之和。

因此，要完成示例：

remainder = 1 + 3 = 4              // simple add (no carry in)
lowResult = 0x07 + 0xdb = 0xe2     // add with carry from remainder
highResult = 0x17                  // add with carry from lowResult

实现此目的的汇编代码由7个表查找，一条带进位携带指令和两条带进位指令组成。

#include <stdio.h>
#include <stdint.h>

uint8_t upperHigh[256];  // index:(upper 8 bits of the number)  value:(high 8 bits of the quotient)
uint8_t upperLow[256];   // index:(upper 8 bits of the number)  value:(low  8 bits of the quotient)
uint8_t upperRem[256];   // index:(upper 8 bits of the number)  value:(remainder when dividing the upper bits by 7)
uint8_t lowerLow[256];   // index:(lower 8 bits of the number)  value:(low  8 bits of the quotient)
uint8_t lowerRem[256];   // index:(lower 8 bits of the number)  value:(remainder when dividing the lower bits by 7)
uint8_t carryRem[13]    = { 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1 };
uint8_t combinedRem[13] = { 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5 };

void populateLookupTables(void)
{
    for (uint16_t i = 0; i < 256; i++)
    {
        uint16_t upper = i << 8;
        upperHigh[i] = (upper / 7) >> 8;
        upperLow[i] = (upper / 7) & 0xff;
        upperRem[i] = upper % 7;

        uint16_t lower = i;
        lowerLow[i] = lower / 7;
        lowerRem[i] = lower % 7;
    }
}

void divideBy7(uint8_t upperValue, uint8_t lowerValue, uint8_t *highResult, uint8_t *lowResult, uint8_t *remainder)
{
    uint8_t temp = upperRem[upperValue] + lowerRem[lowerValue];
    *remainder = combinedRem[temp];
    *lowResult = upperLow[upperValue] + lowerLow[lowerValue] + carryRem[temp];
    uint8_t carry = (upperLow[upperValue] + lowerLow[lowerValue] + carryRem[temp]) >> 8;  // Note this is just the carry flag from the 'lowResult' calcaluation
    *highResult = upperHigh[upperValue] + carry;
}

int main(void)
{
    populateLookupTables();

    uint16_t n = 0;
    while (1)
    {
        uint8_t upper = n >> 8;
        uint8_t lower = n & 0xff;

        uint16_t quotient1  = n / 7;
        uint16_t remainder1 = n % 7;

        uint8_t high, low, rem;
        divideBy7(upper, lower, &high, &low, &rem);
        uint16_t quotient2 = (high << 8) | low;
        uint16_t remainder2 = rem;

        printf("n=%u q1=%u r1=%u q2=%u r2=%u", n, quotient1, remainder1, quotient2, remainder2);
        if (quotient1 != quotient2 || remainder1 != remainder2)
            printf(" **** failed ****");
        printf("\n");

        n++;
        if (n == 0)
            break;
    }
}

Answer 2

在Unsigned Integer Division Routines处进行8位除以7：

;Divide by 7 (From December '84 Apple Assembly Line)
;15 bytes, 27 cycles
  sta  temp
  lsr
  lsr
  lsr
  adc  temp
  ror
  lsr
  lsr
  adc  temp
  ror
  lsr
  lsr

大约有移位的100个周期的估计是非常准确的：到最后一个ror的104个周期，不包括rts的总共106个周期，整个函数的112个周期。注意：在为C64组装并为C64使用VICE仿真器后，我发现算法失败，例如65535给出了9343，正确答案是9362。

   ; for 16 bit division  by 7
   ; input:
  ;   register A is low byte
  ;   register X is high byte
  ; output 
  ;   register A is low byte
  ;   register X is high byte
  ;
  ; memory on page zero
  ; temp     is on page zero, 2 bytes
  ; aHigh    is on page zero, 1 byte
  --
  sta temp
  stx temp+1
  stx aHigh
  --
  lsr aHigh
  ror a
  lsr aHigh
  ror a
  lsr aHigh
  ror a
  ---
  adc temp
  tax
  lda aHigh
  adc temp+1
  sta aHigh
  txa
  --
  ror aHigh
  ror a
  lsr aHigh
  ror a
  lsr aHigh
  ror a
  --
  adc temp
  tax
  lda aHigh
  adc temp+1
  sta aHigh
  txa
  --
  ror aHigh
  ror a
  lsr aHigh
  ror a
  lsr aHigh
  ror a     -- 104 cycles
  ;-------
  ldx aHigh  ; -- 106
  rts        ; -- 112 cycles

Answer 3

执行此操作的另一种方法是将除法转换为乘法。

要计算乘积因子，我们对倒数感兴趣。本质上，我们这样做：

d = n*(1/7)

为了使事情更准确，我们将其乘以2的便捷乘方。2 ^ 16效果很好：

d = floor(n*floor(65536/7)/65536)

乘积因子为：floor（65536/7），即9362。结果的大小将是：

ceiling(log2(65535*9362)) = 30 bits (4 bytes rounded up)

然后我们可以舍弃较低的两个字节以除以65536，或者只是将较高的2个字节用作最终结果。

要计算出实际的旋转并添加所需的旋转，我们检查因子9362的二进制表示形式：

10010010010010

请注意位模式的重复。因此，一种有效的方案是计算：

((n*9*256/4 + n*9)*8 + n)*2 = 9362*n

计算n * 9只需要上限（log2（65535 * 9））= 20位（3字节）。

在伪汇编中，这是：

LDA number          ; lo byte
STA multiply_nine
LDA number+1        ; high byte
STA multiply_nine+1
LDA #0              
STA multiply_nine+2 ; 3 byte result

ASL multiply_nine   ; multiply by 2
ROL multiply_nine+1
ROL mulitply_nine+2
ASL multiply_nine   ; multiply by 2 (4)
ROL multiply_nine+1
ROL mulitply_nine+2
ASL multiply_nine   ; multiply by 2 (8)
ROL multiply_nine+1
ROL mulitply_nine+2

CLC                 ; not really needed as result is only 20 bits, carry always zero
LDA multiply_nine
ADC number
STA multiply_nine
LDA multiply_nine+1
ADC number+1
STA multiply_nine+1
LDA multiply_nine+2
ADC #0
STA multiply_nine+2 ; n*9

其余的练习我留给OP。请注意，不必乘以256，因为这只是将整个字节向上移位。

对于6502，{16快速除以7的16位除数

3 个答案: