Programming 64-bit applications

The 64-bit Windows operating systems use the fastcall calling convention, that is, when calling a function the first four parameters are passed in the Rcx, Rdx, R8 and R9 registers, respectively, and all parameters are expected to be 8-byte values (QWORD). When writng a 64-bit window procedure, you have to save the four mentioned registers in the corresponding arguments (except for the GoAsm assembler), that is, Rcx in 1st argument, Rdx in 2nd argument, R8 in 3rd argument and R9 in 4th argument. The rest of arguments, if more than four, are passed on the stack.

wndMainProcedure Proc hWnd:QWORD, uMsg:QWORD, wParam:QWORD, lParam:QWORD
    Mov hWnd, Rcx  ;Not needed for GoAsm
    Mov uMsg, Rdx  ;Not needed for GoAsm
    Mov wParam, R8 ;Not needed for GoAsm
    Mov lParam, R9 ;Not needed for GoAsm

    Ret
wndMainProcedure EndP


REMARKS: Note that the lines above are written in MASM syntax. Please take into account to make the necessary syntax conversion when programming with other assemblers.

You have to mostly use the 64-bit registers in applications (Rax, Rbx, Rcx, Rdx, etc.), and the Rsp register (the stack pointer) has to be always 16-byte aligned when calling an API function, otherwise the application will probably crash. The best you can do in order to get into 64-bit programming, is to have a deep look at the various Easy Code 64-bit examples, located at the \EasyCode\Examples folder.

There are some important considerations that you should take into account when writing code inside a 64-bit procedure (or a frame in GOASM syntax):

• GOASM copies the Rcx, Rdx, R8 and R9 registers to the corresponding arguments (shadow space), so you do not need to do this. ASMC, JWASM and UASM64 also copy the registers to the shadow space, but ONLY if the Option win64:1 is activated. To do so, please see Configuring Option win64:n. For all other assemblers you have to copy the registers manually.


• POASM uses the Rsp register to address local variables instead of Rbp. As a result the Push and Pop instructions should not be used if there are local variables in the procedure, as the Rsp register would change its value and it could not address the variables properly. One solution is to declare more local variables in order to save and restore the necessary registers.


• Pushing any value before calling a function or a procedure, may disalign the Rsp register and, if so, the application will probably crash. If you Push something, make sure Rsp is properly 16-byte aligned, or Pop whatever you pushed before calling an API function or a procedure (please see the REMARKS).
  
  REMARKS: This consideration can be ignored when working with GoAsm and/or when the call is made with ECInvoke.
  


• The Rbx, Rbp, Rdi, Rsi, R12, R13, R14 and R15 registers have to be preserved if they are used. API functions always preserve them.


• When calling any of the Easy Code methods, you can be sure that all registers will be preserved, EXCEPT Rax, commonly used as the return value, and those used by the fastcall calling convention (Rcx, Rdx, R8 and R9).


• Microsoft Windows 64-bit operating systems use digitally signed drivers. If you need to test a 64-bit driver without a digital signature (i.e. a 64-bit driver you are programming, or the ECDrv64 64-bit driver example coming with Easy Code), press the F8 key when the system boots and in the boot menu choose the Disable driver signature enforcement option. Otherwise the non-signed drivers will not work. However, pressing F8 at boot NOT ALWAYS works on Windows 10.