Overview of x64 ABI conventions
…
Conflicts with the x86 compiler
Data types that are larger than 4 bytes aren't automatically aligned on the stack when you use the x86 compiler to compile an application. Because the architecture for the x86 compiler is a 4 byte aligned stack, anything larger than 4 bytes, for example, a 64-bit integer, can't be automatically aligned to an 8-byte address.
Working with unaligned data has two implications.
• It may take longer to access unaligned locations than it takes to access aligned locations.
• Unaligned locations can't be used in interlocked operations.
If you require more strict alignment, use __declspec(align(N)) on your variable declarations. This causes the compiler to dynamically align the stack to meet your specifications. However, dynamically adjusting the stack at run time may cause slower execution of your application.
…

AND RSP,0FFFFFFFFFFFFFFF0

However, I still don't understand the alignment method that involves subtracting 8 from the RSP register (or the `push rbp` suggested by revolution). Personally, I would have preferred an instruction like:

AND RSP,0FFFFFFFFFFFFFFF0
By doing so, we would truly align RSP to a QWord.

; Inside the OS loader, that puts the program in memory
; here RSP is always aligned to 0 mod 16, as per the FASTCALL convention

    call [program_entry_point] ; address is in the PE header
; here RSP is now 8 mod 16, the return address was pushed onto the stack

; --------------------------------------------------------

; now inside the program, the first instruction
entry:
    push rbp                        ; (or sub rsp, 8 if preferred)
; here RSP is now 0 mod 16 again, proper alignment is guaranteed

; program does its thing here    

; Viewing the contents of the RSP register at
; the entry point of a Windows 64-bit program.

format PE64 GUI 5.0
entry start

include 'win64a.inc'

section '.text' code readable executable

  start:

        sub     rsp,8                   ; alignment of the RSP register
        mov     rax,rsp
        add     rax,8                   ; actual value of RSP at program entry
        cld
        mov     rdi,_RegContent
        mov     rcx,16

;==== Converting 64-bit binary value to asciiz string ====
Loop4:
        rol     rax,4
        push    rax
        and     al,0Fh
        cmp     al,10
        jb      @F
        add     al,7

@@:     add     al,30h
        stosb
        cmp     rcx,9
        jne     @F
        mov     al,'-'
        stosb

@@:     pop     rax
        loop    Loop4

;===== Dispalying in a Message Box and Exit
        invoke  MessageBox,NULL,_RegContent,_title,MB_ICONERROR+MB_OK

        invoke  ExitProcess,NULL

section '.data' data readable writeable

  _RegContent  DB  32 dup(0)
  _title       DB 'ESP register content when starting',0

section '.idata' import data readable writeable
  library kernel32,'KERNEL32.DLL',\
          user32,'USER32.DLL'

  include 'api\kernel32.inc'
  include 'api\user32.inc'                       

I infer—perhaps incorrectly—that it is the Windows functions that do not support this misalignment. What do you think?