Targets

All targets at a glance

Windows: PE files for Intel and ARM, 32 and 64 bit

With .format pe the assembler writes a finished Windows file: DOS stub, PE header, sections and import table. The source holds only code (.code), data (.data) and the functions it needs from DLLs (.import). No linker is needed.

.format pe console
.arch i386
.import msvcrt.dll printf, exit

.code
start:
    push dword msg      ; the argument on the stack
    call [printf]       ; through the import table
    add esp, 4          ; printf does not clean up
    push 0
    call [exit]

.data
msg db 'Hello, World!', 10, 0

.format pe console
.arch x64
.import msvcrt.dll printf, exit

.code
start:
    sub rsp, 40         ; shadow space, stack aligned
    lea rcx, [msg]      ; first argument in rcx
    call [printf]
    xor ecx, ecx
    call [exit]

.data
msg db 'Hello, World!', 10, 0

The same for ARM, with an explanation, is on the page Windows on ARM. .format pe gui makes a window program instead of a console program (messagebox_*.asm, window_*.asm).

Debugging. Asmonite debugs a 32-bit Intel program itself, on this computer. An x64 program runs under the helper process asmodbgx64, because Asmonite itself is a 32-bit program; this too happens on this computer (or on another one with the same debug server). ARM programs run on a Windows on ARM computer with the debug server asmodbg or asmodbg64, connected over ssh or directly on the network; on the ARM computer itself also locally. Before each start Asmonite checks the file it made: header, sections, entry point and whether the imported DLLs and functions really exist.

DOS: .COM and .EXE in QEMU

With .format binary and .arch x86_real Asmonite writes 16-bit code for real mode, byte by byte as it stands in the source.

Debugging. F9 puts the program on a hard disk image and starts QEMU with FreeDOS; the helper dbgload.com loads it there, and the debugger stops at the first line. Breakpoints, steps, registers and memory work as for Windows programs; a second run needs no new boot. qemu\run_freedos.bat gets the FreeDOS floppy once, QEMU itself is set up with qemu\install_qemu.bat. Dismonite opens finished DOS programs (MZ), finds code, data, jump tables and the end of the program and lets you mark regions by hand.

ARM Linux: ELF programs in QEMU

This target belongs to Dismonite: it reads ELF files for 32-bit ARM, as GCC or another compiler makes them on Linux, and debugs them in a Raspberry Pi OS that runs in QEMU.

• Look at it: Dismonite disassembles the code from the entry point, with the names from the symbol table, and shows ARM and Thumb instructions.
• Run and debug: qemu\run_buster.bat starts the guest system; the debugger reaches it over ssh and gdbserver, copies the program into it and stops at the entry point. If the guest is not running, Dismonite asks whether to start it.
• Limit: Asmonite does not write ELF files (yet). A Linux program of your own is made with the tools of Linux; Asmonite and Dismonite help to read and debug it.

Raspberry Pi Pico and Pico 2

With .target pico (RP2040, Cortex-M0+) or .target pico2 (RP2350, Cortex-M33 or RISC-V Hazard3) Asmonite writes the bytes for the board and checks them: the allowed instructions, RAM and flash, the boot2 block on the Pico, the IMAGE_DEF block on the Pico 2. F7 puts the program into the RAM or the flash over a CMSIS-DAP debug probe and stops at _start, without OpenOCD and without an SDK. Without a probe it goes onto the BOOTSEL drive as a UF2 file.

The page of the Raspberry Pi Pico →

Next