;-------------------------------------------------
; DWORD stdcall uint32_add(DWORD a, DWORD b)
;-------------------------------------------------

uint32_add:

        push    ebp
        mov     ebp,esp

        sub     esp,8 ; adjust the stack for 2 local dwords

        mov     eax,[ebp+8]
        add     eax,[ebp+12]

        mov     esp,ebp
        pop     ebp

        retn    8
    

 
mov eax,1         ;X coordinate
mov ebx, 2        ;Y coordinate
mov ecx, 100      ;length
mov edx, 2000     ;color
call MyProcedure

    

uint32_add:
virtual at ebp-.local.size
 ; Using dot at the beginning of every symbol to make them local to the function
  .dummyByte db ?    ; [EBP-5]
  .dummy dd ?        ; [EBP-4]
.local.size = $ - $$
  .oldEBP dd ?       ; [EBP]
  .retAddr dd ?      ; [EBP+4]
  .a dd ?            ; [EBP+8]
  .b dd ?            ; [EBP+12]
end virtual

; Prologue
      push ebp
      mov  ebp, esp
      sub  esp, (.local.size + 3) and -4

; User code
      mov edx, [.dummy]
      mov cl, [.dummyByte]

      mov eax, [.a]
      add eax, [.b]

; Epilogue
      leave
      retn 8
uint32_add_end: ; Closing local scope    

uint32_add:
    mov eax,[esp+8]
    add eax,[esp+12]
    retn 8
    

uint32_add:
      sub     esp, 8 ; Reserving 7 bytes but aligned to 4

      mov     edx, [esp+4]
      mov     dx, [esp+2]
      mov     dl, [esp+1]


      mov     eax, [esp+4+8]
      add     eax, [esp+8+8]

      add     esp, 8
      retn    8    

      sub     esp, 64 ; 64 bytes of local variables (just an example)
      push    ebx

; ...

.loop:
      push    dword [esp+64+4+4*1] ; Caller's first argument; Callee's second argument
      push    dword [esp+4*2]      ; Caller's local variable; Callee's first argument
      call    stdcall_function

      lea     eax, [esp]
      push    eax
      call    another_function_that_modifies_local_var

      ; ...

      dec     ebx
      jnz     .loop

; ...

      pop     ebx
      add     esp, 64
      retn    

You mean not to use ebp for stack when stack not used inside function?
(I included a local variable in my example only for practice, it does nothing.)

Like this?

Code:

uint32_add:
    mov eax,[esp+8]
    add eax,[esp+12]
    retn 8
    

uint32_add:
    mov eax,[esp+4] ;+4 to skip the return address on the stack
    add eax,[esp+8] ;+4 (return address) +4 (to get to the second parameter)
    retn 8    

So the only difference between stdcall and ccall is the retn value?

stdcall: retn sizeof args

ccall: retn 0

;------------------------------------------------
; DWORD stdcall uint32_add(DWORD a, DWORD b)
;------------------------------------------------

uint32_add:

        ; esp     -> callers eip
        ; esp + 4 -> argument a
        ; esp + 8 -> argument b

        push ebp

        ; esp      -> saved ebp
        ; esp + 4  -> callers eip
        ; esp + 8  -> argument a
        ; esp + 12 -> argument b

        mov ebp,esp

        ; ebp      -> saved ebp
        ; ebp + 4  -> callers eip
        ; ebp + 8  -> argument a
        ; ebp + 12 -> argument b

        sub esp,8 ; make 2 local dwords

        ; esp      -> second local dword
        ; esp + 4  -> first local dword
        ; esp + 8  -> saved ebp
        ; esp + 12 -> callers eip
        ; esp + 16 -> argument a
        ; esp + 20 -> argument b

        ; ebp based access
        ;
        mov eax,[ebp+8]
        add eax,[ebp+12]

        ; esp based access
        ;
        ; mov eax,[esp+16]
        ; add eax,[esp+20]

        mov esp,ebp

        ; esp -> saved ebp

        pop ebp

        ; esp -> callers eip

        retn 8
    

Well on 64-bit world perhaps the choice is easy because you don't code for a 80486 or a Pentium old series processors, but on 32-bit land what happens on situations like this? ...