Modos de direccionamiento en lenguaje ensamblador (IA-32 NASM)

Como los recursos web en este campo son escasos, comenzaré por listar los modos de dirección para el lenguaje de ensamblaje IA-32 (NASM) y, a continuación, haré un seguimiento con una pregunta rápida.

  1. Registro de direcciones
    • mov eax, ebx: copia lo que está en ebx en eax
    • mov esi, var: copia la dirección de var (digamos 0x0040120e) en esi
  2. Direccionamiento inmediato (el segundo operando es una constante inmediata)
    • mov bx, el registro bx de 20: 16 bits obtiene el valor real 20
  3. Direccionamiento directo de memoria (carga directamente desde la memoria a través de una dirección especificada)
    • mov ax, [1000h]: carga un objeto de 2 bytes desde el byte en la dirección 4096 (0x1000 en hexadecimal) en un registro de 16 bits llamado ‘ax’
    • mov [1000h], ax: memoria en la dirección 1000h obtiene el valor de hacha
  4. Direccionamiento de desplazamiento directo (igual que 3, simplemente usando aritméticos para modificar la dirección)
    • mov al, [byte_tbl + 2]
  5. Registro indirecto (acceso a la memoria mediante el uso de direcciones almacenadas en registros)
    • mov ax, [di]: copia el valor en la dirección de memoria especificada por di, en hacha
    • mov dword [eax], var1: copia el valor en var1 en la ranura de memoria especificada por eax

Tenga en cuenta que lo anterior es para NASM. Para MASM / TASM usaría “mov esi, OFFSET foo” para obtener la dirección, mientras que “mov esi, foo” y “mov esi, [foo]” obtendrían el valor (creds to @Michael).

Por lo tanto, en mi pregunta. Está en relación con un ejemplo al final de la página 29 del siguiente tutorial: http://www.tutorialspoint.com/assembly_programming/assembly_tutorial.pdf

Básicamente enumera el código siguiente como un ejemplo de direccionamiento de memoria indirecta.

MY_TABLE TIMES 10 DW 0 ; Allocates 10 words (2 bytes) each initialized to 0 MOV EBX, [MY_TABLE] ; Effective Address of MY_TABLE in EBX MOV [EBX], 110 ; MY_TABLE[0] = 110 ADD EBX, 2 ; EBX = EBX +2 MOV [EBX], 123 ; MY_TABLE[1] = 123 

Mis preguntas:

  1. ¿No debería “MOV EBX, [MY_TABLE]” de hecho ser “MOV EBX, MY_TABLE”, ya que queremos poner la dirección de la tabla en EBX, no el valor en sí?
  2. Seguramente es MY_TABLE [2] que es igual a 123 al final, no MY_TABLE [1]?

  1. En la syntax de NASM, esa instrucción debe ser MOV EBX, MY_TABLE . Lo que MOV EBX, [MY_TABLE] haría es cargar los primeros 4 bytes ubicados en MY_TABLE en EBX . Otra alternativa sería usar LEA , como en LEA EBX, [MY_TABLE] .

  2. En este caso, el tutorial es correcto. MY_TABLE se define como una matriz de palabras. Una palabra en el x86 es de 2 bytes, por lo que el segundo elemento de MY_TABLE está ubicado en MY_TABLE + 2 .

Ese tutorial ni siquiera es un código NASM válido. Para ver enlaces a guías / recursos / manuales de x86 que no son de mal gusto, consulte la wiki de tags x86 aquí en SO.

MOV [EBX], 110 no se ensamblará porque ninguno de los operandos implica un tamaño de operando . (Creo que incluso MASM no lo ensamblará, pero algunos ensambladores malos como emu8086 tienen un tamaño de operando predeterminado para instrucciones como esta). mov word [ebx], 110 haría una tienda de 16 bits.

MOV EBX, [MY_TABLE] se ensamblará pero carga las primeras 2 palabras de la tabla. mov ebx, MY_TABLE pondrá la dirección en un registro.

    Intereting Posts