当必须使用循环命令时，无论如何要增加循环命令的范围

Question

outerLoop:
    skipCarry:
        mov     eax, 2
        mov     inCompare, eax   ;Set our inCompare to 2
        mov     eax, outCompare 
        push    ecx ;Save status of these registers before entering the innerLoop
        push    eax
        mov     ecx, innerLoopCount

    isComposite:
        mov     eax, outCompare ;Value to be checked for composite
        mov     edx, 0  ;Make sure edx does not have a left over value
        div     inCompare   ;Divide outCompare by inCompare to see if we get a remainder of 0 in edx
        cmp     edx, 0
        jne     skipPrint   ;If the remainder is not 0, we have not proven that the number in question is composite, so do not print
        ;Print out a composite value if its been proven
        mov     eax, outCompare
        call    WriteDec
        mov     edx, OFFSET spaces
        call    WriteString     ;Write spaces between the composites
        mov     ebx, writeCounter
        inc     ebx     ;This will help to make sure we start a new line after writing 10 composites
        mov     writeCounter, ebx
        cmp     ebx, 10     ;If counter is at 10, we start a new line
        jne     exitInnerLoop   ;exit the inner loop because we found that the number in question is composite
        call    CrLf
        mov     writeCounter, 0
        jmp     exitInnerLoop       ;exit the inner loop because we found that the number in question is composite

        skipPrint:      ;Jumped to if the number in question was not confirmed to be composite

        ;This is to continue testing for composite of the number in question by incrementing the divisor
        mov     ebx, inCompare
        inc     ebx
        mov     eax, outCompare
        cmp     eax, ebx
        je      exitInnerLoop
        mov     inCompare, ebx

        skipIncrement:  ;Will be jumped to if there are no new divisors to be tested

        loop    isComposite     ;Retest with new divisior if there is a possibility
        exitInnerLoop:

    pop     eax     ;restore outer loop status
    pop     ecx
    inc     eax     ;Next number to check for being composite
    mov     outCompare, eax
    loop    outerLoop

我收到错误代码，指出跳转太长了 5 个字节，指的是外循环。我知道只使用 jmp 命令并自己跟踪计数器会更简单，但我的家庭作业要求使用循环来代替。有没有办法扩展循环的范围，或者有没有办法将循环中的内容缩小 5 个字节，而我没有看到？

循环应该检查一个数字是否是复合的，只是为了知道功能。

Answer 1

不，loop/loopne 每个只有一个编码，使用 SHORT（有符号 8 位 rel8）相对位移。

x86 因为 386 有 jcc rel32 aka NEAR conditional branches as well as jcc rel8。如果您需要跳得比rel8 更远，loop 是小代码大小的错误选择。 dec ecx / jnz 基本上是等效的，除了它破坏了一些标志。

代码大小是您应该使用loop 的唯一原因之一； it's slow on everything except recent AMD)。 （速度 ~= 8086 上的代码大小，所以它在那里很有用。后来的 CPU 故意让它变慢以兼容驱动程序中的（坏？）延迟循环。

---

如果你真的想用loop 跳得更远，你可以这样做：

    loop  .stay_in_loop

    jmp   .leave_loop
.stay_in_loop:
    jmp .far_away
.leave_loop:

.stay_in_loop 块可以在函数结束之后，或者在 127B 内从未到达的其他位置，这样您就可以省略 jmp .leave_loop。

---

你也可以“作弊”，把一些循环体放在外面。例如您可以将Print 块移动到函数结束之后（或开始之前），将jcc 移动到它，将jmp 移回循环内部。

---

使用两个嵌套的loop 指令只是脑残，但您似乎需要使用它。 push/pop 来保存/恢复外循环的ecx 不是必需的；您可以使用另一个寄存器和mov ecx, esi 或其他东西。无论哪种方式都很糟糕，因为 push 或 mov esi, ecx 必须位于循环的顶部。除非你自己做dec esi 来伪造它，而不是复制回loop 产生的值。这使代码更清晰，但可能被认为是作弊/违背了要求的目的。 :P

也许你的任务的真正目标是让你优化代码大小，以便短跳转可以达到。在您的情况下，这绝对是提高整体代码质量的正确方法。

初学者代码效率低下是正常的，因此这里有许多简单的局部优化。例如xor edx,edx is 2 bytes (and faster) than 5 byte mov edx, 0。使用test edx,edx 与零进行比较。 It's smaller and better, and sets flags identically to cmp edx,0

另外，将变量保存在寄存器中。 mov writeCounter, 0 之类的指令使用 disp32 寻址模式汇编为 mov r/m32, imm32。所以这是 8 个字节的地址和数据，加上 2 个字节的操作码 + ModR/M。每个绝对地址而不是寄存器操作数都需要 4 个字节。

如果您需要在循环中保存更多代码大小，您可以将内容复制到堆栈并使用[ebp+disp8] 寻址模式（ModR/M 之外的 1 个字节而不是 4 个字节）访问它们。

要释放更多寄存器以供循环使用，请在函数的开始/结束处推送/弹出它们。

---

问题中代码的清理版

外部loop 中的位移为0xc9，即-55。所以我的版本不到你版本的一半。 （在循环外ResetWriteCounter 中有 12 个字节的代码。）

    push   ebx
    push   ebp       ; we're NOT using it as a frame pointer
    push   edi
    push   esi


;;; Important to keep in registers
; edi = inCompare = trial divisor
; ebx = outCompare = prime/composite candidate

;; nice to keep in registers
; ebp = WriteCounter  (but done as a down-counter with dec instead of inc/cmp)
; esi = outer loop counter

;; these variable names are kinda bad, IMO.
;; candidate / divisor would be better names.

; ecx = inner loop counter
; eax,edx = scratch for DIV


    mov    ebx, outCompare    ; first composite candidate

    mov    ebp, 10            ; down-counter to trigger newlines
    push   '  '          ; two spaces followed by 2 zero bytes (i.e. null-terminated string)
   ; Use mov edx, esp instead of mov edx, OFFSET spaces in the print block

   ;;; note that code before this isn't part of the size that LOOP has to jump over.

outerLoop:
        test    bl, 1
        jz      Print    ;; multiple of 2
        ;; inner loop now only has to check the odd divisors

        mov     edi, 3    ; first trial divisor = first odd prime (other than 1)
        mov     ecx, innerLoopCount     ; ideally set to sqrt(ebx), e.g. cvtsi2ss xmm0, ebx / sqrtss xmm0,xmm0 / cvtss2si xmm0, ecx might be correct :P
                   ; could instead use ecx = ebx directly if you don't care about speed, so try divisors all the way up to the candidate.

    ;; inner loop
    isComposite:
        mov     eax, ebx         ; edx:eax = dividend = candidate
        xor     edx, edx
        div     edi              ; trial division

        add     edi, 2           ; next trial divisor = next odd number
        test    edx, edx         ; equivalent to cmp edx,0 to check remainder
        jz      Print            ; you could maybe fold this into a LOOPNZ and check ZF after the loop
   ;If the remainder is not 0, we have not proven that the number in question is composite, so do not print

        ;;cmp     edi, ebx        ;  divisor, candidate
        ;;jae     exitInnerLoop   ; what's the point of this?  isn't ecx set so that loop falls through after this many iterations?

        loop   isComposite     ;Retest with new divisor if there is a possibility

        jmp     NoPrint        ; else it was prime

;;; I put this outside the inner loop in the first place instead of needing to multiple jumps out of this to exitInnerLoop
    Print:   ;Print out a composite value if its been proven
        mov     eax, ebx
        call    WriteDec

        dec     ebp              ; new line when the down-counter reaches zero
        jz      ResetWriteCounter

        ; print spaces only if not printing a newline
        mov     edx, esp        ; OFFSET spaces;  Use stack memory we pushed earlier
        call    WriteString     ;Write spaces between the composites

    ;; tail of outer loop.  Prime numbers jump here without printing.
    exitInnerLoop:
    NoPrint:
        inc     ebx         ;Next number to check for being composite
                            ; TODO: increment by 2 and don't even check the even numbers, just print them after every odd prime/composite

        mov     ecx, esi    ; ecx = outer loop counter for the LOOP insn
        dec     esi         ; update outer counter instead of having  mov esi, ecx at the top of the loop
        loop    outerLoop

    add    esp, 4    ; clear the '  ' we pushed earlier.  pop esi  is smaller and about as efficiently

    pop    esi
    pop    edi
    pop    ebp
    pop    ebx
    ret

  ; after the end of the function is a good place for infrequently-use blocks that you jump to and then jump back.
 ResetWriteCounter:
        mov     ebp, 10         ; reset counter
        ; start a new line after writing 10 composites
        call    CrLf
        ; could have done this branchlessly by selecting a string of '  ',0 or 13,10,0 based on ebp being zero
        ; but doing the ebp update branchlessly too is worse than this highly predictable branch.  Maybe if the count was a power of 2, DEC/AND

        jmp  NoPrint          ; back where we came from, skipping the write spaces
       ; alternative: duplicate inc / mov / dec / loop block here

您可以在分支结构方面做更多事情。例如我想在退出循环后消除jmp NoPrint。这似乎很笨拙。将 Print 块放在其他地方可以解决问题，但 Print 必须跳跃而不是跌落。

TODO：使用ecx 作为试验除数。不过，倒数可能比倒数慢得多，因为小的素数更常见。还需要避开1。

---

我打算只应用一些本地优化，但是当我完成对您的分支结构的理解时，我已经很开心地在代码大小上打了高尔夫球。高尔夫代码中的高尔夫 = 最少的字节获胜。

请参阅我的一些 x86 machine code golf answers 以了解代码大小的技巧（包括以牺牲速度为代价，有时会牺牲很多）：

• GCD in an 8 byte loop
• Chroma-key blend two images (arrays) in 13 bytes。
• 极值斐波那契：Fib(10^9)in 105 bytes of x86 32-bit code (with Linux system calls) 的前 1000 位数字，使用 10 次幂的小数肢体进行扩展精度 adc，以便于截断以仅保留最重要的数字。这个很简洁，因为还有性能要求，所以内部循环针对速度进行了优化。 （在我的 i7-6700k 上，整个过程大约需要 70 秒。）
• 对数刻度适用于戒烟者：strlen and memset with rep strings to replace strings of N chars with base^N filler chars; in 21 bytes。
• n 和 n^3 具有相同的十进制数字集，40 bytes of machine code。 （使用bts 在寄存器中构建位图。）