I have a possible ridiculous query. Is it possible to use stand alone assembly code to print stdout, and get stdin?

Or will I have to use C functions in the FASM framework?

I have a possible ridiculous query. Is it possible to use stand alone assembly code to print stdout, and get stdin?

Or will I have to use C functions in the FASM framework?

proc printf_stdoutput c string,args
        locals
                buff    rb 1028
        endl
        invoke  wvsprintf,addr buff,[string],addr args
        stdcall write_stdoutput,addr buff,eax
        ret
endp

proc write_stdoutput source,bytes
        local   bytes_written:DWORD
        invoke  GetStdHandle,STD_OUTPUT_HANDLE
        invoke  WriteFile,eax,[source],[bytes],addr bytes_written,0
        test    eax,eax
        jz      .done
        mov     eax,[bytes_written]
    .done:
        ret
endp    

        .file   "test1.c"
        .comm   number, 4, 2
        .def    __main; .scl    2;      .type   32;     .endef
        .section .rdata,"dr"
.LC0:
        .ascii "Enter a number:\11\0"
.LC1:
        .ascii "%d\0"
.LC2:
        .ascii "\12The number is %d!\12\0"
        .text
        .globl  main
        .def    main;   .scl    2;      .type   32;     .endef
        .seh_proc       main
main:
        pushq   %rbp
        .seh_pushreg    %rbp
        movq    %rsp, %rbp
        .seh_setframe   %rbp, 0
        subq    $32, %rsp
        .seh_stackalloc 32
        .seh_endprologue
        call    __main
        leaq    .LC0(%rip), %rcx
        call    printf
        leaq    number(%rip), %rax
        movq    %rax, %rdx
        leaq    .LC1(%rip), %rcx
        call    scanf
        leaq    number(%rip), %rax
        movl    (%rax), %eax
        movl    %eax, %edx
        leaq    .LC2(%rip), %rcx
        call    printf
        movl    $0, %eax
        addq    $32, %rsp
        popq    %rbp
        ret
        .seh_endproc
        .ident  "GCC: (tdm64-2) 4.8.1"
        .def    printf; .scl    2;      .type   32;     .endef
        .def    scanf;  .scl    2;      .type   32;     .endef
    

#include <stdio.h>

int number;

int main()
{
        printf("Enter a number:\t");
        scanf("%d",&number);
        printf("\nThe number is %d!\n",number);
        return 0;
}
    

format PE console
entry start

include 'win32a.inc'
include 'dota.inc' ;holds my imports


section '.data' readable  writeable

prompt db "Enter a number:",9,9,0
result db 10,"The number is %d!",1010b,0

number db "%d",0

num dd 3

section '.main' code readable
start:
        push    ebp
        mov     esp, ebp
        sub     esp, 32
        lea     ecx, [prompt]
        call    [printf]
        lea     eax, [num]
        mov     eax, edx
        lea     ecx, [number]
        call    [scanf]
        lea     eax, [number]
        mov     eax,eax
        mov     eax, edx
        lea     ecx, [result]
        call    [printf]
        mov     eax, 0
        add     esp, 32
        pop     ebp
        ret  
    

        .file   "test1.c"
        .intel_syntax noprefix
        .comm   number, 4, 2
        .def    __main; .scl    2;      .type   32;     .endef
        .section .rdata,"dr"
.LC0:
        .ascii "Enter a number:\11\0"
.LC1:
        .ascii "%d\0"
.LC2:
        .ascii "\12The number is %d!\12\0"
        .text
        .globl  main
        .def    main;   .scl    2;      .type   32;     .endef
        .seh_proc       main
main:
        push    rbp
        .seh_pushreg    rbp
        mov     rbp, rsp
        .seh_setframe   rbp, 0
        sub     rsp, 32
        .seh_stackalloc 32
        .seh_endprologue
        call    __main
        lea     rcx, .LC0[rip]
        call    printf
        lea     rax, number[rip]
        mov     rdx, rax
        lea     rcx, .LC1[rip]
        call    scanf
        lea     rax, number[rip]
        mov     eax, DWORD PTR [rax]
        mov     edx, eax
        lea     rcx, .LC2[rip]
        call    printf
        mov     eax, 0
        add     rsp, 32
        pop     rbp
        ret
        .seh_endproc
        .ident  "GCC: (tdm64-2) 4.8.1"
        .def    printf; .scl    2;      .type   32;     .endef
        .def    scanf;  .scl    2;      .type   32;     .endef
    

format PE console
entry start

include 'win32a.inc'
include 'dota.inc'    ; imports


section '.data' readable  writeable

prompt db "Enter a number:",9,9,0        ;LC0
result db 10,"The number is %d!",1010b,0 ;LC2

number db "%d",0                         ;LC1

num dd 3

section '.main' code readable
start:
        push    ebp
        mov     ebp, esp

        sub     esp, 32



        lea     ecx, [prompt]
        call    printf
        lea     eax, [num]
        mov     edx, eax
        lea     ecx, [number]
        call    scanf
        lea     eax, [num]
        mov     eax, [eax]
        mov     edx, eax
        lea     ecx, [result]
        call    printf
        mov     eax, 0
        add     esp, 32
        pop     ebp
        ret
    

push ebp
mov ebp, esp
sub esp, 32
; ...
add esp, 32
pop ebp    

push Hello
call [printf]
add esp, 4 ; <-- only for variable-parameter functions like printf    

format PE console
entry start

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


section '.data' readable  writeable

prompt db "Enter a number:",9,9,0
result db 10,"The number is %d!",1010b,0

number db "%d",0

num dd ? ; changed this to not have a set variable.

section '.main' code readable
start:
        push    prompt
        call    [printf]
        push    num
        mov     eax, edx
        push    number
        call    [scanf]
        push    number
        mov     eax,eax
        mov     eax, edx
        push    result
        call    [printf]
        mov     eax, 0
        ret
    

Enter a number:         5

The number is 4202534!
    

That's because you're extemely mad at me for giving you some schooling on 64-bit programming.

Alright, this is what my assembly looks like now:

Code:

format PE console
entry start

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


section '.data' readable  writeable

prompt db "Enter a number:",9,9,0
result db 10,"The number is %d!",1010b,0

number db "%d",0

num dd ? ; changed this to not have a set variable.

section '.main' code readable
start:
        push    prompt
        call    [printf]
        push    num
        mov     eax, edx
        push    number
        call    [scanf]
        push    number
        mov     eax,eax
        mov     eax, edx
        push    result
        call    [printf]
        mov     eax, 0
        ret
    

section '.main' code readable
start:
        push    prompt
        call    [printf]
        push    num         ; this is correct, this pushes the *address* of 'num' for scanf (which is what it expects)
        mov     eax, edx    ; this has no purpose at all (edx has unknown value to begin with)
        push    number
        call    [scanf]     ; this will put the number into 'num' (num as an address, a pointer, you pushed above)

;       push    number      ; this is the wrong part: you push 'number' which is the address (!) of the *string* "%d" above
        push    dword [num] ; instead, push this: this pushes the 32-bit (dword) *value* found at *num* (address); remember, we passed 'num' (address) to scanf, and it stored it there

        mov     eax,eax     ; useless instruction? I'm asking so I get to understand why you do this  it doesn't do anything
        mov     eax, edx    ; same as above, what is its purpose? 'edx' is unknown value after scanf, eax is scanf's return value before this
        push    result
        call    [printf]
        mov     eax, 0
        ret
    

Or maybe because in his opening post in this thread he said he is experienced with several languages and gave example in C, idiot. I didn't realize he was asking how to use C standard library functions like scanf because of that reason. Using that knowledge you must have given him such wonderful advice to do what he already knows from C, indeed. On the other hand, looks like he doesn't understand pointers in asm (see his latest attempt), so you can try to ridicule me all you want, at least I know I help him unlike you.

(btw about rax, shows how much of an airhead you are, most functions return a value in rax, and other functions use that value as first argument, plus rax is an extra register to use to pass parameters; this is what is called SUPERIOR DESIGN. I don't personally give a shit if YOU find it insignificant. It is objectively better as it avoids 1 mov instruction for many function calls and uses 1 more register as parameter, so go cry to your mommy for getting schooled -- on and lastly, optimizing the function CALL is much more important than the FUNCTION itself because 1 function is called at LEAST one time, but usually many MORE times than once; so placing the overhead into EACH call makes for more bloated code (callee cleans and other crap), less cache used, etc, dummy)

If varargs are your argument, those are a complete joke on x64 calling convention. The amount of extra bloat you have to do in your function is unimaginable to handle that properly. (and you cried for one 'and' instruction to align the stack pointer, LOL!!)

In any protected OS the zone below the stack is perfectly safe for user mode programs to use in regards to worrying about the OS clobbering it. The x86 CPU provides for 4 independent stack pointers, one for for each privilege level. But one does still need to be aware of certain things when using that stack zone, push and call will overwrite any data there.

It is also of note that you can use the stack pointer (ESP/RSP) as a general purpose computing register without causing any problem to the OS. Your stack pointer can even be 0x0000, or any other value you want, and the OS won't crash. But at some point you need to recover the original value before doing calls or pushes and that will usually require some global variable (and that often also precludes multi-threading).

The 128-byte area beyond the location pointed to by rsp is considered to be reserved and shall not be modified by signal or interrupt handlers. Therefore, functions may use this area for temporary data that is not needed across function calls. In particular, leaf functions may use this area for their entire stack frame, rather than adjusting the stack pointer in the prologue and epilogue. This area is known as the red zone.

It is also of note that you can use the stack pointer (ESP/RSP) as a general purpose computing register without causing any problem to the OS. Your stack pointer can even be 0x0000, or any other value you want, and the OS won't crash. But at some point you need to recover the original value before doing calls or pushes and that will usually require some global variable (and that often also precludes multi-threading).

section '.data' bla bla
here:
    _rcx dq 0
    _rdx dq 0
    ...
    _r9 dq 0
    rb 32

section '.code' bla bla
main:
    mov rsp,here     ;hijacking the RSP to point to static data
    sub rsp,0x20
    push $+8
    jmp [aWinAPI]
    add rsp,0x20    

There are problem with pointing ESP/ESP to data areas. Exception handlers might not be able to be entered because the OS checks if ESP/RSP is inside a valid stack area. Also you should make sure there is enough space on the stack for the API to do its work. It is not until the kernel is entered that a new stack is used

Furs: In a protected OS the stack use is at your leisure. Other non-protected OSes might not use different stacks for interrupts. So in those OSes you could get into trouble. Remember that AMD and Intel don't only support Windows and Linux, they also need to cover all situations.