9

I'm working in 16 bit NASM assembly having an issue where my code won't build. The error happens on all the MOV lines here:

  section .bss
  x_coord   RESB 8 ; [x_coord] is the head, [x_coord+2] is the next cell, etc.
  y_coord   RESB 8 ; Same here
  pixel_x  RESB 2  ; Storage for calculations
  pixel_y  RESB 2  ; Storage for calculations

   ...


  MOV [pixel_x], [x_coord]
  MOV [pixel_y], [y_coord]
  CALL DrawPixel

  MOV [pixel_x], [x_coord+2]
  MOV [pixel_y], [y_coord+2]
  CALL DrawPixel

  MOV [pixel_x], [x_coord+4]
  MOV [pixel_y], [y_coord+4]
  CALL DrawPixel

  MOV [pixel_x], [x_coord+6]
  MOV [pixel_y], [y_coord+6]
  CALL DrawPixel

I've read that this happens because the assembler doesn't know what size the variables are. I tried MOV [pixel_x], byte [x_coord] suggested by some online post but that gives the same error. I just want to copy the first two bytes of x_coord and y_coord into pixel_x/pixel_y, then the next two, then the next two, then the next two. How can I make this work?

Stephen Ostermiller
  • 23,933
  • 14
  • 88
  • 109
Nat
  • 890
  • 3
  • 11
  • 23
  • Related: [MOVing between two memory addresses](https://stackoverflow.com/q/1299077) / [Why isn't movl from memory to memory allowed?](https://stackoverflow.com/q/33794169) / [What x86 instructions take two (or more) memory operands?](https://stackoverflow.com/a/52574955) – Peter Cordes May 20 '23 at 21:22

1 Answers1

11

The processor does not have a simple memory-to-memory move instruction, so the right thing to do, if you want to move two bytes at a time, is to use a register as an intermediary:

MOV ax, word [x_coord]
MOV word [pixel_x], ax
MOV ax, word [y_coord]
MOV word [pixel_y], ax
CALL DrawPixel

Since your variables are contiguous in memory, you might also be able to do this:

MOV eax, dword [x_coord]  ; move BOTH x_coord AND y_coord into the register
MOV dword [pixel_x], eax  ; populates BOTH pixel_x AND pixel_y
CALL DrawPixel

If you are only drawing four pixels, you can do the calls one after the other:

MOV eax, dword [x_coord]
MOV dword [pixel_x], eax
CALL DrawPixel
MOV eax, dword [x_coord+2]
MOV dword [pixel_x], eax
CALL DrawPixel
MOV eax, dword [x_coord+4]
MOV dword [pixel_x], eax
CALL DrawPixel
MOV eax, dword [x_coord+6]
MOV dword [pixel_x], eax
CALL DrawPixel

If you had more pixels do draw, you might consider writing a loop.

(Aside: also consider implementing DrawPixel to use values from a register.)

Ray Toal
  • 86,166
  • 18
  • 182
  • 232
  • This looks perfect, thanks! About your last comment, I used memory because I'm not 100% sure what registers I'm safe to use for temp values like this. Which are best for this? – Nat Jul 11 '16 at 00:51
  • 2
    @Nathan: It depends on the ABI of the function. If you wrote both functions, you get to make up your own calling convention. Have a look at some existing ABIs / calling conventions in the [x86 tag wiki](http://stackoverflow.com/tags/x86/info). Microsoft's 32bit __vectorcall is probably a good starting point for 16bit code, where the first two integer args are passed in registers. (edx and ecx, IIRC). 32bit SysV (Linux) passes args on the stack exclusively. Even that would be a better choice than passing args in globals. (`push` works with a memory operand). – Peter Cordes Jul 11 '16 at 01:08
  • @Nathan: If you are using nasm in 64-bit mode, the integer valued parameters are passed in this order: `rdi`, `rsi`, `rdx`, `rcx`, `r8`, `r9`, so you would be likely to write your `drawPixel` function by packing your two coordinates into the low order 32 bits of `rdi`, namely `edi`. Within a function, should preserve `rbp`, `rbx`, `r12`, `r13`, `r14`, and `r15`. But there is much more to function calling conventions (including alignment, floating point registers, return values, etc.) so see http://www.nasm.us/doc/nasmdo11.html and http://x86-64.org/documentation/abi.pdf. – Ray Toal Jul 11 '16 at 02:28
  • `movs` instruction? – Frank C. Jul 11 '16 at 08:51
  • 1
    `movs` would be great for moving large blocks of memory, but the OP was talking about moving 32 bits from one memory location to another, so I would avoid `movs` for sure. I did mention in my answer there was no _simple_ memory-to-memory move instruction. I don't consider `movs` to be "simple" because of the implicit use of index registers. :-) – Ray Toal Jul 11 '16 at 18:55