将简单C程序改写为人工编写汇编代码遇阻求助

Hey there, I feel your frustration—handwriting assembly can be tricky when you're just getting started, especially when small mistakes lead to weird behavior like infinite loops or crashes. Let's break down the problems you're seeing and walk through some fixes.

Common Pitfalls & Fixes for Your Issues #

1. Variable Initialization Failures Causing Broken cmp/jmp (Infinite Output) #

The most likely culprit here is that your variables aren't being properly initialized, leaving them with garbage values that throw off your conditional checks. Here's what to watch for:

• Global variables: Make sure you're defining them in the .data (initialized) or .bss (uninitialized) section. For example, an integer count = 0 in C translates to:

  section .data
      count dd 0  ; dd = define doubleword (4 bytes for int)
  

• Local stack variables: When creating variables on the stack, you first need to reserve space and explicitly set their initial value. Skipping this step leaves the memory with random data:

  ; Set up stack frame
  push ebp
  mov ebp, esp
  sub esp, 4  ; Reserve 4 bytes for a local int
  
  mov dword [ebp-4], 0  ; Initialize local variable to 0
  

If your cmp is comparing a garbage value instead of your intended starting value, your jmp will never trigger the exit condition—leading to that infinite output loop.

2. Program Crashes Without Output #

Crashes usually boil down to memory access errors or stack imbalance. Here are the top fixes:

• Stack balance after function calls: If you're using standard library functions like printf, you need to clean up the stack after calling them (for cdecl calling convention, which most compilers use). For example:

  push msg  ; Push argument for printf
  call printf
  add esp, 4  ; Clean up the 4-byte argument from the stack
  

  Forgetting this leaves the stack in an invalid state, which will crash your program when you try to manipulate it later.
• Register preservation: If you're using callee-saved registers (like ebx, esi, edi in x86), you need to push them to the stack before modifying them, then pop them back before returning. Skipping this corrupts registers that other functions rely on.
• Valid memory addresses: Make sure any strings or pointers you're using are properly defined. For example, a string for printf needs a null terminator (0) at the end—without it, printf will read past the string into invalid memory and crash.

Example: Converting a Simple C Loop to Assembly #

To make this concrete, let's take a basic C program and convert it to working x86 32-bit NASM assembly. This should help you see the correct structure:

Original C Code #

#include <stdio.h>

int main() {
    int i = 0;
    while (i < 5) {
        printf("Hello!\n");
        i++;
    }
    return 0;
}

Corresponding Assembly #

section .data
    msg db 'Hello!', 0xA, 0  ; 0xA = newline, 0 = null terminator
    len equ $ - msg  ; Calculate length of the string (optional for printf)

section .text
    global main
    extern printf  ; Declare external function

main:
    ; Set up stack frame
    push ebp
    mov ebp, esp
    sub esp, 4  ; Reserve space for local variable i

    mov dword [ebp-4], 0  ; Initialize i = 0
loop_start:
    cmp dword [ebp-4], 5  ; Check if i >= 5
    jge loop_end          ; If yes, exit loop

    ; Call printf
    push msg
    call printf
    add esp, 4  ; Clean up stack after call

    inc dword [ebp-4]  ; i++
    jmp loop_start     ; Jump back to loop check

loop_end:
    mov eax, 0  ; Set return value to 0
    ; Tear down stack frame
    mov esp, ebp
    pop ebp
    ret

Notice how every step is explicit: stack frame setup, variable initialization, proper stack cleanup after printf, and clear conditional jumps.

If you can share your specific C program and the assembly code you've written so far, we can pinpoint exactly where things are going wrong.

内容的提问来源于stack exchange，提问作者Noi Knowles