Cannot Log Multiple Outputs with WriteConsoleA in Windows 10 (64-bit) Assembly Program

Question

I am learning assembly development on Windows 10 (64-bit) and using IntelliJ IDEA to write my assembly code. I'm trying to log multiple outputs using WriteConsoleA, but only the first log message appears. The second log message is ignored.

First I tried to implement arithmetic logic to get the sum of two numbers. It didn't work and I tried to hardcode the value and get a log result and then I realized this problem.

Here is my detailed setup and the code I am using.

Environment:

Operating System: Windows 10 (64-bit)
Assembler: NASM
Compiler/Linker: MinGW-Win64

Code:

section .data
    sum_msg db 'Sum: ', 0
    sum db '15', 0

section .bss
    num_bytes_written resq 1

section .text
    global _start

    extern GetStdHandle
    extern WriteConsoleA
    extern ExitProcess

_start:
    ; Get the handle for stdout
    mov ecx, -11           ; STD_OUTPUT_HANDLE
    call GetStdHandle

    ; Check if handle is valid
    cmp rax, -1
    je .exit

    ; Write the "Sum: " message to stdout
    mov rcx, rax           ; handle to stdout
    lea rdx, [rel sum_msg] ; pointer to message
    mov r8d, 5             ; message length
    lea r9, [rel num_bytes_written]  ; pointer to number of bytes written
    call WriteConsoleA

    ; Write the hardcoded sum to stdout
    mov rcx, rax           ; handle to stdout
    lea rdx, [rel sum]     ; pointer to sum string
    mov r8d, 2             ; sum string length (including null terminator)
    lea r9, [rel num_bytes_written]  ; pointer to number of bytes written
    call WriteConsoleA

    ; Infinite loop to prevent immediate exit
.loop:
    nop
    jmp .loop

.exit:
    ; Exit
    xor ecx, ecx           ; exit code 0
    call ExitProcess

Commands: Assemble code:

nasm -f win64 sum.asm -o sum.obj

Link code:

gcc -nostdlib -o sum.exe sum.obj -lkernel32

Expected Output: Sum: 15

Actual output: Sum:

Attempts to Fix:

Verified that the initial message ("Sum: ") logs correctly.
Added a loop to ensure the program doesn't exit immediately, confirming that the second log is ignored.
Tried changing the length of the second message.
Confirmed that the WriteConsoleA function is called, but it doesn't print the second message.
Tested with hardcoded values for the second log message.
Tried to compile the program by re-ordering the WriteConsoleA (top: "15", bottom: "Sum: ") and it logs the "15" result.

What exactly do I need to know

Why is the second call to WriteConsoleA not logging the message?
Is there a specific requirement or constraint for calling WriteConsoleA multiple times in a 64-bit Windows assembly program?

Any help or suggestions would be greatly appreciated.

It looks like you're only passing 4 params to WriteConsoleA, but the function takes 5. Also, WriteConsoleA returns a value in eax, which means it wipes out the value that was stored there by GetStdHandle. — David Wohlferd
– David Wohlferd, Commented Jul 28, 2024 at 2:24
You also called all the functions on a misaligned stack, and you didn't allocate shadow space or declare unwind codes — Raymond Chen
– Raymond Chen, Commented Jul 28, 2024 at 4:07
Thank you for pointing that out. I updated my code to ensure that all five parameters are passed to WriteConsoleA. Additionally, I saved the value of GetStdHandle to avoid it being overwritten by the return value of WriteConsoleA. This adjustment resolved the issue. — kavi castelo
– kavi castelo, Commented Jul 28, 2024 at 5:54

David Wohlferd · Accepted Answer · 2024-07-28 23:34:09Z

Turning the comments into an answer:

There are several problems here. Probably the most significant is that the return value from your first call to WriteConsoleA overwrites the value of eax, where you are storing the handle returned from GetStdHandle. As a result, the second call to WriteConsoleA is using the wrong handle.

Secondmost is that you are only passing 4 parameters to a routine that takes 5. While this may work since param 5 is reserved (and therefore probably completely unused), it's a risk since there's no way of knowing what the called function might be doing with it or the stack space where it's supposed to be stored.

Third is the fact that you are failing to allocate shadow space for the parameters (discussed here). Again, you might get away with it depending on how the called function is working. But if it fails, the failure might come hundreds of instructions later, making tracking it down very hard.

Similarly: The stack will always be maintained 16-byte aligned, except within the prolog (for example, after the return address is pushed). You are calling functions with the stack not aligned on 16 byte boundaries.

Raymond also makes reference to unwind codes. While I don't specify these myself, I don't usually use exception handling. Presumably terrible things happen if you omit them in code that does throw, or is even in the call stack when an exception is triggered.

Writing code that fails to properly follow the calling conventions is a terrible idea. It might seem to work, but is mucking things up that you can't easily see. Easier to do it right the first time than to spend time tracking it down later.

Collectives™ on Stack Overflow

Cannot Log Multiple Outputs with WriteConsoleA in Windows 10 (64-bit) Assembly Program

1 Answer 1

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related