我为一个街机重制版写了一个long到ascii的整数转换器。
实际上，您可以使用高达(1<<16*10)-1的DIVU，因为655359/10仍然适合16位（并且是65535）
更进一步，将一个长数除以10000，6553590000 > 1<<32也不能大于655359，所以结果将适合16位。
然后继续进行你刚才得到的除法的余数，对下半部分做同样的操作。
如果num = (1<<32)-1（最大无符号值，又称$ffffffff），num除以10000等于429496，小于65536*10-1，所以可以处理，余数也可以用同样的方法处理。
这是我从我的游戏改编并测试过的一些代码。零填充看起来有点过，但你可能不需要它。

; main test code
main:
    move.l  #$12345678,d0
    lea     outbuf(pc),a1
    move.w  #0,d1
    bsr     write_decimal_number
    ; A1 contains "305419896"
    move.l  #2000001,d0
    lea     outbuf(pc),a1
    move.w  #0,d1
    bsr     write_decimal_number
    ; A1 contains "2000001"

    rts
    
outbuf
    ds.b    100,0
    
; the conversion routine
; < A1: buffer to write into
; < D0: 32 bit unsigned number
; < D1: number of padding zeroes
    
write_decimal_number:
    movem.l A0-A1/D2-d5,-(a7)
    move.l  d1,d3   ; quickly adapted, old code needed D0 and D1 for coordinates
    move.l  d0,d2
    cmp.w   #18,d3
    bcs.b   .padok
    move.w  #18,d3
.padok
    cmp.l   #655360,d2
    bcs.b   .one
    sub.l   #4,d3
    move.w  d0,d5
    ; first write high part    
    divu    #10000,d2
    swap    d2
    moveq.l #0,d4
    move.w   d2,d4
    clr.w   d2
    swap    d2
    bsr     .write_num
    subq.w  #1,a1   ; cancel last zero
    move.l  d4,d2
    moveq   #4,d3   ; pad to 4
.one
    bsr     .write_num
    clr.b   (a1)
    movem.l (a7)+,A0-A1/D2-d5
    rts
.write_num
    lea .buf+20(pc),a0
    tst.w   d2
    beq.b   .zero
.loop
    divu    #10,d2
    swap    d2
    add.b   #'0',d2
    subq    #1,d3
    move.b  d2,-(a0)
    clr.w   d2
    swap    d2
    tst.w   d2          ; probably unnecessary, swap sets Z flag already
    beq.b   .write
    bra.b   .loop
.zero
    subq    #1,d3
    move.b  #'0',-(a0)
.write
    tst.b   d3
    beq.b   .w
    bmi.b   .w
    subq    #1,d3
.pad
    move.b  #'0',-(a0)
    dbf d3,.pad
.w
    move.b  (a0)+,(a1)+
    bne.b   .w
    rts
.buf
    ds.b    20
    dc.b    0
    even

您所展示的算法向前提取数字，例如，从高阶十进制数字开始，然后到低阶。
DIVU指令将32位被除数除以16位除数，得到16位商与16位余数。
所以，关键是要使用这个特性，在某种程度上，这意味着首先提取低位数字，这可以在标准的itoa中看到。
与从最左到最右使用更小的10的幂不同，这对从右到左的每个数字使用10的除法和模数。
由于数字是按逆序生成的，因此有几种方法可以反转字符串，例如：

• 在产生数字后反转数字（如上面的例子所示）;
• 从缓冲区的末尾开始，并将它们反向相加（例如，使用-(a0)代替(a0)+）。
• 然后可以用ascii 0（零）数字填充缓冲区的剩余部分，或者，
• 执行movmem的等效操作以将其滑动到缓冲区的开头，或者，
• 如果你能忍受的话：返回缓冲区中放置最后一个数字的指针给调用者，这样他们就有了字符串的开头。

这种方法的一个优点是，当商为0时，您可以提前停止，因为所有剩余的数字都将为零。
当然，DIVU的问题是，由于只捕获16位结果，因此大数在除以10时会产生溢出。在溢出情况下，由于目标寄存器保持不变，因此既得不到商也得不到余数。
因此，这里有一个技巧，涉及到两个除法运算。x86版本见这里：Trying to Display a 32bit number in Assembly 8086 32bit
算法是这样的：

#include <stdio.h>

// using simple global variable to hold the resulting string
// but of course this can be edited to be parameterized instead
static char buf[20];

char *div2(unsigned long dividend) {
    unsigned short dvUpper16 = dividend >> 16;
    unsigned short dvLower16 = (unsigned short) dividend;
    char *bufPtr = buf + sizeof(buf);
    *--bufPtr = 0;

    for (;;) {
        unsigned long 
        dvTemp32  = dvUpper16;       // zero extending upper16 to 32 bits
        dvUpper16 = dvTemp32 / 10;   // first DIVU
        unsigned short 
        remainOne = dvTemp32 % 10;   // get mod from first DIVU
        
        dvTemp32 = (remainOne << 16) + dvLower16;
        dvLower16 = dvTemp32 / 10;  // second DIVU
        unsigned short 
        remainTwo = dvTemp32 % 10;  // get mod from second DIVU

        // print or capture remainTwo
        printf("%d\n", remainTwo);
        *--bufPtr = remainTwo + '0';
        
        if ( (dvUpper16 | dvLower16) == 0 )
            break;
    }
    
    return bufPtr;
}

int main()
{
    char *ptr = div2(543217689);
    printf("%s\n", ptr);
}

这种双除法安排适用于32位被除数和16位除数，并且永远不会溢出16位结果。
这将很容易地转换为68 k，因为所有需要的操作符都在那里。
由于DIVU同时产生商和余数，并且两者都需要，在68 k中这总共只需要两个DIVU。