Why can't I print out them both?

format PE console
entry start

include 'win32a.inc'
include 'dota.inc' ; this has my imports

section '.data' data readable

Hello db 'Hello World! The number is now %d.',0
String1 db "The number is %d",0

section '.main' data readable

subtract:
        mov eax,0    ; nop out eax
        sub ebx,1     ; subtract 1 from ebx (equals eax when we copied eax into ebx)
        mov eax,ebx  ; mov ebx into eax
        call multiply   ; call the multiply func


multiply:
        imul eax,2    ; multiply 2 by eax
        push eax      

        push Hello
        call [printf]
        add esp,4
        push 0
        call [ExitProcess]



start:
        mov eax, 4     ; eax = 4
        add eax,6      ;  add 6 to 4
        mov ebx,eax  ; copy eax into ebx (since printf will erase eax) 
        push eax       ; push eax to the stack
        push String1  
        call [printf]
        add esp, 4

        call subtract    ; call the subtract func
    

The number is 10.
Hello World! The number is now 18.
    

section '.data' data readable writeable
greet db 'Hello. My first program',0ah,0
fmt db 'Result: %d + %d = %d',0ah,0
inp1 dd 6
inp2 dd 4
ans dd ?

section '.code' code readable executable
main:
        push    greet           ;arg1
        call    [printf]        
        add     esp,4           ;cleanup for arg1 push. cdecl convention

        push    [inp2]          ;arg2
        push    [inp1]          ;arg1
        call    addTwo
        mov     [ans],eax       ;copy the return value in EAX to ans
        
        push    [ans]           ;arg4
        push    [inp2]          ;arg3
        push    [inp1]          ;arg2
        push    fmt             ;arg1
        call    [printf]
        add     esp,4*4         ;cdecl stack cleanup (calling convention)

        push    0
        call    [ExitProcess]

;add two integers
;Requires 2 arguments
;Returns to EAX
;Calling convention: stdcall (callee cleanup stack)
addTwo:
        push    ebp             ;function prologue
        mov     ebp,esp
        push    ebx             ;save EBX
        
        mov     ebx,[ebp+12]    ;arg2 from stack
        mov     eax,[ebp+8]     ;arg1 from stack
        add     eax,ebx         ;EAX stores the answer
        
        pop     ebx             ;restore EBX
        mov     esp,ebp         ;function epilogue
        pop     ebp
        ret     4*2             ;stdcall stack cleanup (calling convention)    

int main()
{
    int inp1=6, inp2=4;
    int ans;

    printf("Hello. My first program\n");
    ans = addTwo(inp1,inp2);
    printf("Result: %d + %d = %d\n",inp1,inp2,ans);
    return 0;
}

int addTwo(int x,int y)
{
    return x+y;
}    

format PE console
entry start

include 'win32a.inc'
include 'dota.inc'

section '.data' data readable

Hello db 'Hello World! The number is now %d.',13,10,0    ; add newline to the strings (windows uses CR LF)
String1 db "The number is %d",13,10,0

section '.main' data readable

subtract:
        dec ebx        ; subtract 1 with 'dec' instruction, smaller encoding
        mov eax,ebx    ; could have used here 'lea eax, [ebx-1]' and get rid of 'dec'
                       ; and the mov (the lea does the same thing), but let's keep it basic 
        ret            ; return from subtract!


multiply:
        shl eax, 1     ; multiply by 2 with left shift by 1 bit, same thing but faster
        ret            ; return from multiply with result in eax!


start:
        mov eax, 4
        add eax, 6
        mov ebx, eax
        push eax       ; push eax to the stack
        push String1  
        call [printf]
        add esp, 4

        call subtract  ; takes input in ebx, returns result in eax
        call multiply  ; multiply takes value in eax and returns in eax

        push eax
        push Hello
        call [printf]
        add esp,4
        push 0
        call [ExitProcess]
    

Alignment is a processor thingy. Not OS. 64-bit calling conventions is tailored to suit such CPU requirement.

PS. I would like to make two lines of text.
Example:

Code:

The number is 10.
Hello World! The number is now 18.    

I thank you all for being patient with me. I will study both of theses answers. I appreciate the efforts from you all.


- Sincerely, C0deHer3tic.

Huh? I was talking about requiring alignment on a function call -- the processor does not need that at all.

add     esp,4*4
    

ret     4*2             ;stdcall stack cleanup (calling convention)
    

shl eax, 1     ; multiply by 2 with left shift by 1 bit, same thing but faster 
    

shl shifts the destination operand left by the number of bits specified in the second operand. The destination operand can be byte, word, or double word general register or memory. The second operand can be an immediate value or the CL register. The processor shifts zeros in from the right (low order) side of the operand as bits exit from the left side. The last bit that exited is stored in CF. sal is a synonym for shl.

Hello db 'Hello World! The number is now %d.',13,10,0    ; add newline to the strings (windows uses CR LF) 
String1 db "The number is %d",13,10,0 
    

@Furs

Code:

shl eax, 1     ; multiply by 2 with left shift by 1 bit, same thing but faster 
    

What? I am not clear with this command. How does it multiply by 2?

Here is what I found on this command, and forgive my ignorance, but I still don't understand.

Quote:

shl shifts the destination operand left by the number of bits specified in the second operand. The destination operand can be byte, word, or double word general register or memory. The second operand can be an immediate value or the CL register. The processor shifts zeros in from the right (low order) side of the operand as bits exit from the left side. The last bit that exited is stored in CF. sal is a synonym for shl.

Also, why do you use 13,10,0 after each string?

Code:

Hello db 'Hello World! The number is now %d.',13,10,0    ; add newline to the strings (windows uses CR LF) 
String1 db "The number is %d",13,10,0 
    

Now is this because 13 is the carriage return, and would do the same if I did 0dh?
If so, why then is the newline used? Dec 10 (0ah) hex, or 1010b
Of course 0 is null. Just like "Hello World!\0" Right?

What do you mean the processor doesn't need aligned memory? stack is just an abstract view of the same memory in the same address space. IT IS MEMORY. So suggesting that SSE instructions require aligned memory but not aligned stack shows your fundamental understanding of how the 64-CPU works in bare metal is quite low.

push rbp
mov rbp, rsp
and rsp, -32    ; realigns the stupid stack, WOW magic!!!

[...]    

SSE/AVX instructions do exist / required inside many API functions. So where do you think they get aligned memory from if not from the aligned stack?

... for that tiny minority of functions which use SSE ...

Dude, a function can realign the stack with one instruction (and a frame pointer). Even if the stack is completely messed up and aligned to 1 byte only. This is REQUIRED for any functions using AVX regardless if you want performance.

sub rsp,8
mov [rsp],rcx    

Furs wrote:

... for that tiny minority of functions which use SSE ...

Did you miss my post above? In fact a large number of API functions use the SSE/AVX instructions for moving data around (without any arithmetic being done). It is not a tiny minority. I'm not saying it is good or bad, just that there are in fact many functions that require the alignment.

Anyhow, we have it now. It is what it is. If you want to write code that interfaces with the API then you have to comply or have your code crashing.

Thank you everyone. So much studying!

Example

push a
push b
push c
call D
add esp,4*3 ;or simply add esp, 12