Hey there! Let's break down why those first couple of mov instructions might be acting up as you transition from 16-bit real mode to 32-bit protected mode for your x86 bootloader. Since you're ditching BIOS calls and starting the protected mode setup, there are a few common pitfalls with early-stage real-mode code that could be causing the issue.

Common Causes & Fixes #

1. Mismatched Operand Sizes in Real Mode #

Real mode is inherently 16-bit, so the CPU expects 16-bit operands by default. If your initial mov instructions are targeting 32-bit registers (like eax, ebx) without explicitly telling the assembler to handle 32-bit operations in real mode, you'll get broken machine code. The CPU might truncate data or misinterpret the instruction entirely.

• Fix:
  • Stick to 16-bit registers (ax, bx, cx, etc.) for your real-mode setup code until you've fully switched to protected mode.
  • If you need to use 32-bit operations early on, make sure you've declared BITS 16 at the top of your assembly file—this tells assemblers like NASM to add the necessary 0x66 operand-size prefix to 32-bit instructions so the real-mode CPU understands them.

2. Incorrect Segment Register Initialization #

Your bootloader loads at physical address 0x7C00, but real-mode memory addressing uses segment:offset (where physical address = segment * 16 + offset). If you set your segment registers (ds, es, ss) to the wrong value, your mov instructions will point to the wrong memory locations, making it seem like they're not working.

• Example of Correct Initialization:

  BITS 16
  org 0x7C00  ; Tells assembler our code starts at 0x7C00
  
  boot_start:
      ; Set data, extra, and stack segments to match our load address
      mov ax, 0x0000  ; Since org=0x7C00, 0x0000*16 + 0x7C00 = 0x7C00
      mov ds, ax
      mov es, ax
      mov ss, ax
      mov sp, 0x7C00  ; Set stack pointer above our bootloader to avoid overwriting code
  

  • Note: If you omit org 0x7C00, you'd need to set ax to 0x07C0 instead, since 0x07C0*16 + 0x0000 = 0x7C00.

3. Missing BITS 16 Directive #

If your assembler defaults to 32-bit mode (some environments do), it will compile your initial mov instructions as 32-bit machine code. Real-mode CPUs don't parse 32-bit instructions correctly, so this will lead to unpredictable behavior right out the gate.

• Fix: Add BITS 16 as the very first line of your boot.asm file. This ensures all early code is compiled for 16-bit real mode, which is critical before you flip the protected mode bit in the CR0 register.

4. Uninitialized Stack #

If your mov instructions are interacting with the stack (or if subsequent code does), a missing stack setup can cause crashes that look like your initial mov instructions failed. The stack pointer (sp) needs a valid location in real mode to avoid overwriting your bootloader code.

• Fix: As shown in the segment initialization example, set ss to a valid segment and sp to a safe address (like 0x7C00, which is the start of your bootloader—growing downward from here won't overwrite your code).

Next Step #

If none of these fixes resolve the issue, share the exact first two lines of your boot.asm code! Seeing the specific instructions will let us pinpoint the problem more accurately.

内容的提问来源于stack exchange，提问作者Jacob Garby