如何在用于 Linux 的 nasm x86 程序集中复制数组，移植 16 位 DOS 代码？

Question

I have to write a program which copy an array in other array, using x86 assembler

The original code is written in MSDOS' TASM for 8086 processor, but I want port this to Linux NASM using i386 processor

The code in TASM is this:

.MODEL SMALL

.DATA

    TABLE_A DB 10, 5, 1
    TABLE_B DB 0, 0, 0

.CODE

    MOV AX, SEG TABLE_B
    MOV DS, AX

    MOV SI, 0

    LOOP:
        MOV AL, TABLE_A[SI]
        MOV TABLE_B[SI], AL

        INC SI
        CMP SI, 2
    JBE LOOP


    MOV AH, 4Ch
    INT 21h

END

I'm trying to rewrite this in nasm, but I don't get to sit in the correct array position, similar to TABLE_A[SI] instruction

How can I do it?

Answer 1

The final code in nasm is this

section .text
global _start
cpu 386

_start:

MOV ESI, TABLE_A
MOV EDI, TABLE_B
MOV CX, 3

COPY_LOOP:      
    MOV AL, [ESI]
    MOV [EDI], AL

    INC SI
    INC DI
LOOP COPY_LOOP

MOV AX,1
INT 80h

section .data
TABLE_A DB 10, 5, 1
TABLE_B DB 0, 0, 0

Answer 2

How could I do it?

(question from comments on self-answer)

Well, first you read Instruction reference guide to understand what the instruction does, and then you can use it, if it fits your purpose. This is the important step, keep re-reading instruction details every so often, to verify it does modify registers and flags in a way you expect it. Especially if in debugger you see the CPU state of change you didn't expect.

As you are in linux, the ds / es segment registers are very likely already set to reasonably values (covering .data section), so after setting eSi to S ource address, eDi to D estination address, and eCx to C ount, you write instead of COPY_LOOP: just rep movsb ... and then exit trough int 80h (eax=1) . (notice the emphasized letters in register names, Intel picked those intentionally to make it easy to recall)

BTW, just now I noticed, you wrote in your code sort of bugs:

1. inc si/di should be inc esi/edi , because you use esi/edi to address. If you would be copying array over 64k memory boundary, inc si would wrap around on it.

2. set ecx to 3, in 32b mode the loop instruction does use whole 32b ecx , not 16b part cx only. If the code ahead of copy would use some large number in ecx setting some of upper 16 bits, your loop would copy many more bytes than only 3.

3. ahead of calling int 80h again you must set whole eax with the function number, otherwise you risk to have some garbage in upper 16 bits of eax from previous code, requesting invalid function.

So after applying these your code may look like this:

section .text
global _start
cpu 386

_start:
    MOV ESI, TABLE_A
    MOV EDI, TABLE_B
    MOV ECX, 3
    REP MOVSB  ; copy ECX bytes from DS:ESI to ES:EDI

    MOV EAX,1  ; call sys_exit, again FIXED to EAX!
    INT 80h

section .data

TABLE_A DB 10, 5, 1
TABLE_B DB 0, 0, 0

If you did read the docs about registers, you should already understand what is difference between eax and ax . In Linux you are in 32b mode (when you link the binary as 32b elf, nowadays the 64b may be default on 64b system, which differs a bit from 32b mode), so by default use the 32b register variants. Unless you really want the 16b/8b variant for particular reason, and you make sure the code doesn't work later with 32b register while you set only less of it (like loop , rep movsb and int 80h do).

Also it makes the code usually faster, as using 16b ax in 32b mode requires additional opcode byte ahead of instruction, for example mov eax,ebx is 2 bytes opcode 89 D8 , mov ax,bx is 3 bytes opcode 66 89 D8 .

Answer 3

In response to marc

I tried this form, without successful result:

MOV SI, 0
MOV AX, 0

LOOP:       
    MOV AX, [TABLE_A + SI]
    MOV [TABLE_B + SI], AX

    INC SI
    CMP SI, 2
JBE LOOP

Answer 4

Use pointers ( SI , DI ) to the arrays and CX as counter :

MOV SI, Table_A     ;POINTER TO TABLE_A.
MOV DI, Table_B     ;POINTER TO TABLE_B.
MOV CX, 3           ;ARRAY LENGTH.
REPEAT:       
    MOV AL, [SI]
    MOV [DI], AL
    INC SI
    INC DI
    LOOP REPEAT     ;CX-1. IF CX>0 JUMP TO REPEAT.