3264_Template.asm

Go to the documentation of this file.

;
; Template for 32/64 bit dual mode assembly source files.
; This file will contain both 32 and 64 bit versions of the functions.
; Author: B.O. Love Nystrom.
;
; Public License: BSD - No usage restrictions.
;
TITLE 32/64 bit assembly routines.

IFDEF RAX
    _WIN64 = 1
ELSE
    _WIN64 = 0
   .686P
   .XMM
   .MODEL FLAT
ENDIF

;==============================================================================
;  Common x86/x64 - Constants and parameterless functions
;==============================================================================

_TEXT SEGMENT
; Your common code goes here..
_TEXT ENDS

;==============================================================================
IF (_WIN64 eq 0) ; 32 bit version
;==============================================================================
ECHO === 32-BIT ASSEMBLY (ML) ===

; __cdecl
;   Argument passing: Right to left
;   Stack-maintenance: Calling function pops the stack
;   Name-decoration: Underscore character (_) is prefixed to names,
;   except when exporting __cdecl functions that use C linkage.
;
; __stdcall
;   Argument-passing: Right to left. By value, unless pointer or reference.
;   Stack-maintenance: Called function pops the stack.
;   Name-decoration: An underscore (_) is prefixed to the name. The name is 
;   followed by the at sign (@) followed by the number of bytes (in decimal)
;   in the argument list. In other words, a function declared as 
;   int func( int a, double b ); is decorated as: _func@12
;
; __fastcall
;   Argument-passing: The first two DWORD or smaller arguments are passed in 
;   ECX and EDX registers; all other arguments are passed right to left.
;   Stack-maintenance: Called function pops the stack.
;   Name-decoration: At sign (@) is prefixed to names; an at sign followed by 
;   the number of bytes (in decimal) in the parameter list is suffixed to names.

_TEXT SEGMENT

PUBLIC _foo_c
;
; UINT32 __cdecl foo_c( UINT32 bar );
;
_foo_c PROC
   enter   0,0
    mov     eax, [epb+8]    ; first argument
    add     eax, eax
    leave
    ret     ; Caller unstacks the args
_foo_c ENDP

PUBLIC _foo_s@4
;
; UINT32 __stdcall foo_s( UINT32 bar );
;
_foo_s@4 PROC
   enter   0,0
    mov     eax, [epb+8]    ; first argument
    add     eax, eax
    leave
    ret     4 ; Unstack the args
_foo_s@4 ENDP

PUBLIC @foo_f@4
;
; UINT32 __fastcall foo_f( UINT32 bar );
;
@foo_f@4 PROC
   ;enter   0,0
    mov     eax, ecx    ; first argument
    add     eax, eax
    ;leave
    ret     ; For 3 or more args, unstack all except the first two
@foo_f@4 ENDP

_TEXT ENDS

;==============================================================================
ELSE ; 64 bit version
;==============================================================================
ECHO === 64-BIT ASSEMBLY (ML64) ===

; Extern C assembly routines does NOT get an added underscore with MSVC + ML64.
; Hence the x64 assembly routines must be named _exactly_as_the_C_prototypes_,
; or, in case of C++ class members, the mangled C++ identifiers.
;
; Fastcall is used regardless of prototype declaration!
; Arguments -> RCX, RDX, R8, R9, then stack.
;
; The four register args are backed by unused stack cells.
; Ergo, after std prologue the fifth argument is at [RBP+48].
;
; Normal fastcall stack cleanup convention (function pop args) is *not used*.
; Functions end with 'ret 0' even if they had stack args.
;
; RAX, RCX, RDX, R8, R9, R10, R11 are considered volatile.
; RBX, RBP, RDI, RSI, RSP, R12, R13, R14, and R15 are nonvolatile
; and must be saved and restored by a function that use them.
;
; frame$ = 10h ; Offset from rbp to first shadow arg after 'enter 0,0'
; x64 fastcall arguments:
;   rcx = arg1 (rbp+10h)
;   rdx = arg2 (rbp+18h)
;   r8  = arg3 (rbp+20h)
;   r9  = arg4 (rbp+28h)
;   [rbp+30h] = arg5

_TEXT SEGMENT

PUBLIC foo
;
; UINT64 foo( UINT64 bar );
;
foo PROC
   ;enter   0,0        ;<< not needed if <= 4 args
    mov     rax, rcx    ; first argument
    add     rax, rax
    ;leave              ;>> not needed if <= 4 args
    ret                 ; Caller balances the stack
foo ENDP

_TEXT ENDS

ENDIF ; _WIN64
END