¿Cómo escribir hola mundo en ensamblador en Windows?

Quería escribir algo básico en ensamblaje en Windows, estoy usando NASM, pero no puedo hacer que nada funcione.

¿Cómo escribir y compilar hello world sin la ayuda de funciones C en Windows?

Ejemplos de NASM .

Llamar libc stdio printf, implementarint main(){ return printf(message); }

; ----------------------------------------------------------------------------
; helloworld.asm
;
; This is a Win32 console program that writes "Hello, World" on one line and
; then exits.  It needs to be linked with a C library.
; ----------------------------------------------------------------------------

    global  _main
    extern  _printf

    section .text
_main:
    push    message
    call    _printf
    add     esp, 4
    ret
message:
    db  'Hello, World', 10, 0

Entonces corre

nasm -fwin32 helloworld.asm
gcc helloworld.obj
a

También está la guía Clueless Newbies para Hello World en Nasm sin el uso de una biblioteca C. Entonces el código se vería así.

Código de 16 bits con llamadas al sistema MS-DOS: funciona en emuladores de DOS o en Windows de 32 bits con soporte NTVDM . No se puede ejecutar "directamente" (de forma transparente) en cualquier Windows de 64 bits, porque un kernel x86-64 no puede usar el modo vm86.

org 100h
mov dx,msg
mov ah,9
int 21h
mov ah,4Ch
int 21h
msg db 'Hello, World!',0Dh,0Ah,'$'

Construya esto en un .comejecutable para que se cargue cs:100hcon todos los registros de segmento iguales entre sí (modelo de memoria pequeña).

Buena suerte.

Este ejemplo muestra cómo ir directamente a la API de Windows y no vincular en la biblioteca estándar de C.

    global _main
    extern  _GetStdHandle@4
    extern  _WriteFile@20
    extern  _ExitProcess@4

    section .text
_main:
    ; DWORD  bytes;    
    mov     ebp, esp
    sub     esp, 4

    ; hStdOut = GetstdHandle( STD_OUTPUT_HANDLE)
    push    -11
    call    _GetStdHandle@4
    mov     ebx, eax    

    ; WriteFile( hstdOut, message, length(message), &bytes, 0);
    push    0
    lea     eax, [ebp-4]
    push    eax
    push    (message_end - message)
    push    message
    push    ebx
    call    _WriteFile@20

    ; ExitProcess(0)
    push    0
    call    _ExitProcess@4

    ; never here
    hlt
message:
    db      'Hello, World', 10
message_end:

Para compilar, necesitará NASM y LINK.EXE (de Visual Studio Standard Edition)

   nasm -fwin32 hello.asm
   enlace / subsistema: consola / nodefaultlib / entrada: principal hello.obj 

Estos son ejemplos de Win32 y Win64 que utilizan llamadas a la API de Windows. Son para MASM en lugar de NASM, pero échales un vistazo. Puede encontrar más detalles en este artículo.

Esto usa MessageBox en lugar de imprimir en stdout.

Win32 MASM

;---ASM Hello World Win32 MessageBox

.386
.model flat, stdcall
include kernel32.inc
includelib kernel32.lib
include user32.inc
includelib user32.lib

.data
title db 'Win32', 0
msg db 'Hello World', 0

.code

Main:
push 0            ; uType = MB_OK
push offset title ; LPCSTR lpCaption
push offset msg   ; LPCSTR lpText
push 0            ; hWnd = HWND_DESKTOP
call MessageBoxA
push eax          ; uExitCode = MessageBox(...)
call ExitProcess

End Main

Win64 MASM

;---ASM Hello World Win64 MessageBox

extrn MessageBoxA: PROC
extrn ExitProcess: PROC

.data
title db 'Win64', 0
msg db 'Hello World!', 0

.code
main proc
  sub rsp, 28h  
  mov rcx, 0       ; hWnd = HWND_DESKTOP
  lea rdx, msg     ; LPCSTR lpText
  lea r8,  title   ; LPCSTR lpCaption
  mov r9d, 0       ; uType = MB_OK
  call MessageBoxA
  add rsp, 28h  
  mov ecx, eax     ; uExitCode = MessageBox(...)
  call ExitProcess
main endp

End

Para ensamblar y vincular estos usando MASM, use esto para el ejecutable de 32 bits:

ml.exe [filename] /link /subsystem:windows 
/defaultlib:kernel32.lib /defaultlib:user32.lib /entry:Main

o esto para ejecutables de 64 bits:

ml64.exe [filename] /link /subsystem:windows 
/defaultlib:kernel32.lib /defaultlib:user32.lib /entry:main

¿Por qué Windows x64 necesita reservar 28h bytes de espacio de pila antes de un call? Eso es 32 bytes (0x20) de espacio de sombra, también conocido como espacio doméstico, como lo requiere la convención de llamadas. Y otros 8 bytes para realinear la pila en 16, porque la convención de llamada requiere que RSP esté alineado con 16 bytes antes de a call. (Nuestro mainllamador (en el código de inicio CRT) hizo eso. La dirección de retorno de 8 bytes significa que RSP está a 8 bytes de un límite de 16 bytes al ingresar a una función).

Espacio de sombraUna función puede usar el para volcar sus argumentos de registro junto a donde estaría cualquier argumento de pila (si lo hubiera). A system callrequiere 30 h (48 bytes) para reservar también espacio para r10 y r11 además de los 4 registros mencionados anteriormente. Pero las llamadas a DLL son solo llamadas a funciones, incluso si son envolturas de syscallinstrucciones.

Dato curioso: no Windows, es decir, la convención de llamadas de System V x86-64 (por ejemplo, en Linux) no usa espacio de sombra en absoluto, y usa hasta 6 argumentos de registro de enteros / punteros, y hasta 8 argumentos de FP en registros XMM .

Usando MASM's invoke directiva (que conoce la convención de llamada), puede usar un ifdef para hacer una versión de esto que se puede construir como 32 bits o 64 bits.

ifdef rax
    extrn MessageBoxA: PROC
    extrn ExitProcess: PROC
else
    .386
    .model flat, stdcall
    include kernel32.inc
    includelib kernel32.lib
    include user32.inc
    includelib user32.lib
endif
.data
caption db 'WinAPI', 0
text    db 'Hello World', 0
.code
main proc
    invoke MessageBoxA, 0, offset text, offset caption, 0
    invoke ExitProcess, eax
main endp
end

La variante macro es la misma para ambos, pero no aprenderá a ensamblar de esta manera. En su lugar, aprenderá ASM estilo C. invokees para stdcallo fastcallmientras cinvokees para cdeclo argumento variable fastcall. El ensamblador sabe cuál usar.

Puede desmontar la salida para ver cómo se invokeexpande.

Flat Assembler no necesita un enlazador adicional. Esto hace que la programación en ensamblador sea bastante sencilla. También está disponible para Linux.

Esto es hello.asmde los ejemplos de Fasm:

include 'win32ax.inc'

.code

  start:
    invoke  MessageBox,HWND_DESKTOP,"Hi! I'm the example program!",invoke GetCommandLine,MB_OK
    invoke  ExitProcess,0

.end start

Fasm crea un ejecutable:

> fasm hola.asm
ensamblador plano versión 1.70.03 (1048575 kilobytes de memoria)
4 pasadas, 1536 bytes.

Y este es el programa en IDA :

Se puede ver las tres llamadas: GetCommandLine, MessageBoxy ExitProcess.

Para obtener un .exe con NASM'compiler y el vinculador de Visual Studio, este código funciona bien:

global WinMain
extern ExitProcess  ; external functions in system libraries 
extern MessageBoxA

section .data 
title:  db 'Win64', 0
msg:    db 'Hello world!', 0

section .text
WinMain:
    sub rsp, 28h  
    mov rcx, 0       ; hWnd = HWND_DESKTOP
    lea rdx,[msg]    ; LPCSTR lpText
    lea r8,[title]   ; LPCSTR lpCaption
    mov r9d, 0       ; uType = MB_OK
    call MessageBoxA
    add rsp, 28h  

    mov  ecx,eax
    call ExitProcess

    hlt     ; never here

Si este código se guarda en, por ejemplo, "test64.asm", entonces para compilar:

nasm -f win64 test64.asm

Produce "test64.obj" Luego para vincular desde el símbolo del sistema:

path_to_link\link.exe test64.obj /subsystem:windows /entry:WinMain  /libpath:path_to_libs /nodefaultlib kernel32.lib user32.lib /largeaddressaware:no

donde ruta_a_vínculo podría ser C: \ Archivos de programa (x86) \ Microsoft Visual Studio 10.0 \ VC \ bin o donde esté su programa link.exe en su máquina, ruta_a_libs podría ser C: \ Archivos de programa (x86) \ Windows Kits \ 8.1 \ Lib \ winv6.3 \ um \ x64 o donde sea que estén sus bibliotecas (en este caso, tanto kernel32.lib como user32.lib están en el mismo lugar; de lo contrario, use una opción para cada ruta que necesite) y / largeaddressaware: no opción necesario para evitar que el vinculador se queje de direcciones demasiado largas (para user32.lib en este caso). Además, como se hace aquí, si se invoca el vinculador de Visual desde el símbolo del sistema, es necesario configurar el entorno previamente (ejecutar una vez vcvarsall.bat y / o ver MS C ++ 2010 y mspdb100.dll ).

A menos que llame a alguna función, esto no es en absoluto trivial. (Y, en serio, no hay una diferencia real en complejidad entre llamar a printf y llamar a una función api win32).

Incluso DOS int 21h es en realidad solo una llamada de función, incluso si es una API diferente.

Si desea hacerlo sin ayuda, debe hablar directamente con su hardware de video, probablemente escribiendo mapas de bits de las letras de "Hola mundo" en un framebuffer. Incluso entonces, la tarjeta de video está haciendo el trabajo de traducir esos valores de memoria en señales VGA / DVI.

Tenga en cuenta que, en realidad, nada de todo esto hasta el hardware es más interesante en ASM que en C. Un programa de "hola mundo" se reduce a una llamada de función. Una cosa buena de ASM es que puede usar cualquier ABI que desee con bastante facilidad; solo necesita saber qué es ese ABI.

Los mejores ejemplos son aquellos con fasm, porque fasm no usa un enlazador, lo que oculta la complejidad de la programación de Windows mediante otra capa opaca de complejidad. Si está satisfecho con un programa que escribe en una ventana de interfaz gráfica de usuario, entonces hay un ejemplo para eso en el directorio de ejemplo de fasm.

Si desea un programa de consola, que permita la redirección de entrada y salida estándar, también es posible. Hay un programa de ejemplo (helas muy no trivial) disponible que no usa una interfaz gráfica de usuario y funciona estrictamente con la consola, es decir, fasm. Esto se puede reducir a lo esencial. (Escribí un cuarto compilador que es otro ejemplo que no es de interfaz gráfica de usuario, pero tampoco es trivial).

Dicho programa tiene el siguiente comando para generar un encabezado adecuado para un ejecutable de 32 bits, normalmente realizado por un enlazador.

FORMAT PE CONSOLE 

Una sección llamada '.idata' contiene una tabla que ayuda a Windows durante el inicio a acoplar nombres de funciones a las direcciones de tiempo de ejecución. También contiene una referencia a KERNEL.DLL, que es el sistema operativo Windows.

 section '.idata' import data readable writeable
    dd 0,0,0,rva kernel_name,rva kernel_table
    dd 0,0,0,0,0

  kernel_table:
    _ExitProcess@4    DD rva _ExitProcess
    CreateFile        DD rva _CreateFileA
        ...
        ...
    _GetStdHandle@4   DD rva _GetStdHandle
                      DD 0

El formato de tabla lo imponen las ventanas y contiene nombres que se buscan en los archivos del sistema cuando se inicia el programa. FASM oculta parte de la complejidad detrás de la palabra clave rva. Entonces, _SalirProcess @ 4 es una etiqueta fasm y _exitProcess es una cadena que Windows busca.

Su programa está en la sección '.text'. Si declara que esa sección es legible, se puede escribir y ejecutar, es la única sección que necesita agregar.

    section '.text' code executable readable writable

Puedes llamar a todas las instalaciones que declaraste en la sección .idata. Para un programa de consola, necesita _GetStdHandle para encontrar los descriptores de archivo para la entrada y salida estándar (usando nombres simbólicos como STD_INPUT_HANDLE que fasm encuentra en el archivo de inclusión win32a.inc). Una vez que tenga los descriptores de archivo, puede hacer WriteFile y ReadFile. Todas las funciones se describen en la documentación de kernel32. Probablemente sea consciente de eso o no probaría la programación en ensamblador.

En resumen: hay una tabla con nombres asci que se acoplan al sistema operativo Windows. Durante el inicio, esto se transforma en una tabla de direcciones a las que se puede llamar, que utiliza en su programa.

Si desea utilizar NASM y el enlazador de Visual Studio (link.exe) con el ejemplo de Hello World de anderstornvig, tendrá que enlazar manualmente con la biblioteca de tiempo de ejecución de C que contiene la función printf ().

nasm -fwin32 helloworld.asm
link.exe helloworld.obj libcmt.lib

Espero que esto ayude a alguien.