main:
        push    rbp
        mov     rbp, rsp
        mov     eax, 0
        pop     rbp
        ret
    

start:

        invoke  GetModuleHandle,0
        invoke  DialogBoxParam, eax, 37, HWND_DESKTOP, DialogProc,0
        or      eax,eax
        jz      exit
        invoke  MessageBox, HWND_DESKTOP, message, caption, [flags]
        ...
    

(Re)Hello!
I was wondering what was the best way to write the beginning of a program. Let me explain,
in the assembler code given by my compiler, the main function (and any other function for that matter) gives this :

Code:

main:
        push    rbp
        mov     rbp, rsp
        mov     eax, 0
        pop     rbp
        ret
    

Except that in the examples given in the FASM file, the entry point does not define any "good manners", and goes directly into the heart of the program. Example from "DIALOG.ASM" :

Code:

start:

        invoke  GetModuleHandle,0
        invoke  DialogBoxParam, eax, 37, HWND_DESKTOP, DialogProc,0
        or      eax,eax
        jz      exit
        invoke  MessageBox, HWND_DESKTOP, message, caption, [flags]
        ...
    

1) What is the main difference between relative and absolute addressing?

2) What registers should I use as a stack pointer? I always used the general registers (eax, ecx, ...), except one person told me they weren't made for it (he doesn't know FASM), your opinion?

GetModuleHandle always returns 0x400000. Actually it returns the address of where the exe is loaded to, and I guess it's somewhere in the pe header.

You don't need ExitProcess at the end if you have only one thread, you can just use "ret".

vivik wrote:

You don't need ExitProcess at the end if you have only one thread, you can just use "ret".

This is also not guaranteed to work. It costs practically nothing to call the proper function.

MessageBox is actually either MessageBoxA or MessageBoxW. First is ascii text, second is widechar text. In ascii, one char takes 1 byte, in widechar - 2. Widechar is something like unicode.

While those two things above might be true for the current versions of Windows, there is nothing that says MS won't change the implementation in a future version.

While you are generally right here, I would still argue (as I did in the past) that since all threads are equal with regards to Windows API, and since it is documented that returning from a thread "function" is a valid way of terminating it, the return from the "main function" (that is the main thread) may be considered an officially documented and therefore reliable method.

But the “main” thread might not be the only one in the process. I remember having problems with RET from WinMain even on WinXP for programs that called GetOpenFileName() function. In Win10 even a simple two-liner fails to terminate this way. Antivirus software, UI customizers and whatever the hell they put into the new Windows release might and does create threads in pretty much every process out there.

revolution, you have a tendency of warning about "oh no it's scary" without bringing any facts about it.

But the “main” thread might not be the only one in the process. I remember having problems with RET from WinMain even on WinXP for programs that called GetOpenFileName() function. In Win10 even a simple two-liner fails to terminate this way. Antivirus software, UI customizers and whatever the hell they put into the new Windows release might and does create threads in pretty much every process out there.

Well, if there is another thread that still has some work to do, it would be nicer to let it finish first, wouldn't it?

You don't need ExitProcess at the end if you have only one thread, you can just use "ret". My program stopped exiting properly once I added directdraw in it, so there were 2 threads. Better have it just in case.

(Re)Hello!
I was wondering what was the best way to write the beginning of a program. Let me explain,
in the assembler code given by my compiler, the main function (and any other function for that matter) gives this :

Code:

main:
        push    rbp
        mov     rbp, rsp
        mov     eax, 0
        pop     rbp
        ret
    

Except that in the examples given in the FASM file, the entry point does not define any "good manners", and goes directly into the heart of the program. Example from "DIALOG.ASM" :

Code:

start:

        invoke  GetModuleHandle,0
        invoke  DialogBoxParam, eax, 37, HWND_DESKTOP, DialogProc,0
        or      eax,eax
        jz      exit
        invoke  MessageBox, HWND_DESKTOP, message, caption, [flags]
        ...
    

The first program is adhering to standard C structure. In C, almost everything is a function, even main function itself. The basic idea behind it -- a function, whatever that is, returns with a RET instruction. This is guaranteed by C, to ensure portability of C's binaries across multiple platforms. C has its own way dealing with program's exit. The return address found at C's TOS points to an area where C hosts its own exit sequence, at least along the MingW toolchain.

If you debugged a C program both on Win64 and Linux64, you'll see that they both would produce similar "main" structure at the binary level. You won't see ExitProcess or syscall coming out from main because according to C's design philosophy, main is a function, and a function should use RET, just like any other functions.

;-----------------------------------
; fasm this.asm
; gcc -m32 this.obj sbase3.dll -o this.exe
;-----------------------------------
        format MS COFF
        public _WinMain@16
        extrn _stackview
        extrn _memview

        section '.data' writeable
msg     db 'Hello World',0ah,0

        section '.text' executable
_WinMain@16:
        push    ebp             ;C standard prologue
        mov     ebp,esp

        push    5               ;view main's stack
        call    _stackview

        mov     eax,[esp+4]
        push    eax             
        push    100
        call    _memview        ;what C is hiding at that return address

        pop     ebp
        ret                     ; C's standard return    

00562954 |0022FEA8
00000000 |0022FEA4
00400000 |0022FEA0
00401D6B |0022FE9C  ==> C's return address
0022FF18 |0022FE98
5B59F4658D10EC83 |00401D6B| 0|0  ==> C's return sequence at that address
B48DC3FC618D5D5E |00401D73| 8|8
74223C0000000026 |00401D7B| 10|16
8403B60F01C3830A |00401D83| 18|24
C0940F223CF275C0 |00401D8B| 20|32
3C86EBC301C0B60F |00401D93| 28|40
E5895595EB897409 |00401D9B| 30|48
FFFFF535E818EC83 |00401DA3| 38|56
E8004013702404C7 |00401DAB| 40|64
9090C3C9FFFFF509 |00401DB3| 48|72
FFFFFF9090909090 |00401DBB| 50|80
00000000401DA0FF |00401DC3| 58|88
        FFFFFF00 |00401DCB| 60|96