How to write hello world in assembler under Windows

Question

I wanted to write something basic in assembly under Windows  I m using NASM  but I can t get anything working    How to write and compile hello world without the help of C functions on Windows

User · Answer

These are Win32 and Win64 examples using Windows API calls. They are for MASM rather than NASM, but have a look at them. You can find more details in this article.

This uses MessageBox instead of printing to 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

To assemble and link these using MASM, use this for 32-bit executable:

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

or this for 64-bit executable:

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

Why does x64 Windows need to reserve 28h bytes of stack space before a call? That's 32 bytes (0x20) of shadow space aka home space, as required by the calling convention. And another 8 bytes to re-align the stack by 16, because the calling convention requires RSP be 16-byte aligned before a call. (Our main's caller (in the CRT startup code) did that. The 8-byte return address means that RSP is 8 bytes away from a 16-byte boundary on entry to a function.)

Shadow space can be used by a function to dump its register args next to where any stack args (if any) would be. A system call requires 30h (48 bytes) to also reserve space for r10 and r11 in addition to the previously mentioned 4 registers. But DLL calls are just function calls, even if they're wrappers around syscall instructions.

Fun fact: non-Windows, i.e. the x86-64 System V calling convention (e.g. on Linux) doesn't use shadow space at all, and uses up to 6 integer/pointer register args, and up to 8 FP args in XMM registers.

Using MASM's invoke directive (which knows the calling convention), you can use one ifdef to make a version of this which can be built as 32-bit or 64-bit.

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

The macro variant is the same for both, but you won't learn assembly this way. You'll learn C-style asm instead. invoke is for stdcall or fastcall while cinvoke is for cdecl or variable argument fastcall. The assembler knows which to use.

You can disassemble the output to see how invoke expanded.

User · Answer

Unless you call some function this is not at all trivial   And  seriously  there s no real difference in complexity between calling printf and calling a win32 api function   Even DOS int 21h is really just a function call  even if its a different API  If you want to do it without help you need to talk to your video hardware directly  likely writing bitmaps of the letters of  quot Hello world quot  into a framebuffer  Even then the video card is doing the work of translating those memory values into DisplayPort HDMI DVI VGA signals  Note that  really  none of this stuff all the way down to the hardware is any more interesting in ASM than in C  A  quot hello world quot  program boils down to a function call  One nice thing about ASM is that you can use any ABI you want fairly easily  you just need to know what that ABI is

User · Answer

The best examples are those with fasm  because fasm doesn t use a linker  which hides the complexity of windows programming by another opaque layer of complexity  If you re content with a program that writes into a gui window  then there is an example for that in fasm s example directory  If you want a console program  that allows redirection of standard in and standard out that is also possible  There is a  helas highly non-trivial  example program available that doesn t use a gui  and works strictly with the console  that is fasm itself  This can be thinned out to the essentials   I ve written a forth compiler  which is another non-gui example  but it is also non-trivial   Such a program  has the following command to generate a proper header for 32-bit executable  normally done by a linker  FORMAT PE CONSOLE   A section called   idata  contains a table that helps windows during startup to couple names of functions to the runtimes addresses  It also contains a reference to KERNEL DLL which is the Windows Operating System   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  The table format is imposed by windows and contains names that are looked up in system files  when the program is started  FASM hides some of the complexity behind the rva keyword  So  ExitProcess 4 is a fasm label and  exitProcess is a string that is looked up by Windows  Your program is in section   text   If you declare that section readable writeable and executable  it is the only section you need to add      section   text  code executable readable writable  You can call all the facilities you declared in the  idata section  For a console program you need  GetStdHandle to find he filedescriptors for standard in and standardout  using symbolic names like STD INPUT HANDLE which fasm finds in the include file win32a inc   Once you have the file descriptors you can do WriteFile and ReadFile  All functions are described in the kernel32 documentation  You are probably aware of that or you wouldn t try assembler programming  In summary  There is a table with asci names that couple to the windows OS  During startup this is transformed into a table of callable addresses  which you use in your program

User · Answer

If you want to use NASM and Visual Studio s linker  link exe  with anderstornvig s Hello World example you will have to manually link with the C Runtime Libary that contains the printf   function   nasm -fwin32 helloworld asm link exe helloworld obj libcmt lib   Hope this helps someone

User · Answer

This example shows how to go directly to the Windows API and not link in the C Standard Library        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    amp 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    To compile  you ll need NASM and LINK EXE  from Visual studio Standard Edition        nasm -fwin32 hello asm    link  subsystem console  nodefaultlib  entry main hello obj

User · Answer

To get an  exe with NASM compiler and Visual Studio s linker this code works fine   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   If this code is saved on e g   test64 asm   then to compile   nasm -f win64 test64 asm   Produces  test64 obj  Then to link from command prompt   path to link link exe test64 obj  subsystem windows  entry WinMain   libpath path to libs  nodefaultlib kernel32 lib user32 lib  largeaddressaware no   where path to link could be C  Program Files  x86  Microsoft Visual Studio 10 0 VC bin or wherever is your link exe program in your machine  path to libs could be C  Program Files  x86  Windows Kits 8 1 Lib winv6 3 um x64 or wherever are your libraries  in this case both kernel32 lib and user32 lib are on the same place  otherwise use one option for each path you need  and the  largeaddressaware no option is necessary to avoid linker s complain about addresses to long  for user32 lib in this case   Also  as it is done here  if Visual s linker is invoked from command prompt  it is necessary to setup the environment previously  run once vcvarsall bat and or see MS C   2010 and mspdb100 dll

User · Answer

NASM examples   Calling libc stdio printf  implementing int 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   Then run  nasm -fwin32 helloworld asm gcc helloworld obj a     There s also The Clueless Newbies Guide to Hello World in Nasm without the use of a C library  Then the code would look like this   16-bit code with MS-DOS system calls  works in DOS emulators or in 32-bit Windows with NTVDM support   Can t be run  directly   transparently  under any 64-bit Windows  because an x86-64 kernel can t use vm86 mode   org 100h mov dx msg mov ah 9 int 21h mov ah 4Ch int 21h msg db  Hello  World   0Dh 0Ah       Build this into a  com executable so it will be loaded at cs 100h with all segment registers equal to each other  tiny memory model    Good luck

User · Answer

Flat Assembler does not need an extra linker  This makes assembler programming quite easy  It is also available for Linux   This is hello asm from the Fasm examples   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 creates an executable     fasm hello asm flat assembler  version 1 70 03   1048575 kilobytes memory  4 passes  1536 bytes    And this is the program in IDA     You can see the three calls  GetCommandLine  MessageBox and ExitProcess

[winapi] How to write hello world in assembler under Windows?

Win32 MASM

Win64 MASM

Examples related to winapi

Examples related to assembly

Examples related to x86

Examples related to nasm