Display contents of register

Question

hi i need help displaying contents of a register.my code is below.i have been able to display values of the data register but i want to display flag states. eg 1 or 0. and it would be helpful if to display also the contents of other registers like esi,ebp.

my code is not printing the states of the flags ..what am i missing

section .text
global _start       ;must be declared for using gcc
_start :                     ;tell linker entry point

mov eax,msg         ; moves message "rubi" to eax register
mov [reg],eax       ; moves message from eax to reg variable


mov edx, 8   ;message length
mov ecx, [reg];message to write
mov ebx, 1      ;file descriptor (stdout)
mov eax, 4      ;system call number (sys_write)
int 0x80        ;call kernel

mov eax, 100
mov ebx, 100
cmp ebx,eax

pushf
pop dword eax

mov [save_flags],eax

mov edx, 8        ;message length
mov ecx,[save_flags]         ;message to write
mov ebx, 1          ;file descriptor (stdout)
mov eax, 4          ;system call number (sys_write)
int 0x80     


mov eax, 1      ;system call number (sys_exit)
int 0x80        ;call kernel

section .data

msg db "rubi",10

section .bss

reg resb 100

save_flags resw 100

Answer 1

I'm not going for anything fancy here since this appears to be a homework assignment (two people have asked the same question today). This code should be made as a function, and it can have its performance enhanced. Since I don't get an honorary degree or an A in the class it doesn't make sense to me to offer the best solution, but one you can work from:

    BITS_TO_DISPLAY equ 32       ; Number of least significant bits to display (1-32)

section .text
global _start                    ; must be declared for using gcc
_start :                         ;    tell linker entry point

    mov edx, msg_len             ; message length
    mov ecx, msg                 ; message to write
    mov ebx, 1                   ; file descriptor (stdout)
    mov eax, 4                   ; system call number (sys_write)
    int 0x80                     ; call kernel

    mov eax, 100
    mov ebx, 100
    cmp ebx,eax

    pushf
    pop dword eax

    ; Convert binary to string by shifting the right most bit off EAX into
    ; the carry flag (CF) and convert the bit into a '0' or '1' and place
    ; in the save_flags buffer in reverse order. Nul terminate the string
    ; in the event you ever wish to use printf to print it

    mov ecx, BITS_TO_DISPLAY     ; Number of bits of EAX register to display
    mov byte [save_flags+ecx], 0 ; Nul terminate binary string in case we use printf
bin2ascii:
    xor bl, bl                   ; BL = 0
    shr eax, 1                   ; Shift right most bit into carry flag
    adc bl, '0'                  ; bl = bl + '0' + Carry Flag
    mov [save_flags-1+ecx], bl   ; Place '0'/'1' into string buffer in reverse order
    dec ecx
    jnz bin2ascii                ; Loop until all bits processed

    mov edx, BITS_TO_DISPLAY     ; message length
    mov ecx, save_flags          ; address of binary string to write
    mov ebx, 1                   ; file descriptor (stdout)
    mov eax, 4                   ; system call number (sys_write)
    int 0x80

    mov eax, 1                   ;system call number (sys_exit)
    int 0x80                     ;call kernel

section .data
msg db "rubi",10
msg_len equ $ - msg

section .bss
save_flags resb BITS_TO_DISPLAY+1 ; Add one byte for nul terminator in case we use printf

The idea behind this code is that we continually shift the bits (using the SHR instruction) in the EAX register to the right one bit at a time. The bit that gets shifted out of the register gets placed in the carry flag (CF). We can use ADC to add the value of the carry flag (0/1) to ASCII '0' to get an ASCII value of '0` and '1'. We place these bytes into destination buffer in reverse order since we are moving from right to left through the bits.

BITS_TO_DISPLAY can be set between 1 and 32 (since this is 32-bit code). If you are interested in the bottom 8 bits of a register set it to 8. If you want to display all the bits of a 32-bit register, specify 32.

Answer 2

Note that you can pop directly into memory.

And if you want to binary dump register and flag data with write(2), your system call needs to pass a pointer to the buffer, not the data itself. Use a mov-immediate to get the address into the register, rather than doing a load. Or lea to use a RIP-relative addressing mode. Or pass a pointer to where it's sitting on the stack, instead of copying it to a global!

mov edx, 8        ;message length
mov ecx,[save_flags]         ;message to write    ;;;;;;; <<<--- problem
mov ebx, 1          ;file descriptor (stdout)
mov eax, 4          ;system call number (sys_write)
int 0x80     

Passing a bad address to write(2) won't cause your program to receive a SIGSEGV, like it would if you used that address in user-space. Instead, write will return EFAULT. And you're not checking the return status from your system calls, so your code doesn't notice.

---

mov eax,msg         ; moves message "rubi" to eax register
mov [reg],eax       ; moves message from eax to reg variable

mov ecx, [reg];

This is silly. You should just mov ecx, msg to get the address of msg into ecx, rather than bouncing it through memory.

---

Are you building for 64bit? I see you're using 8 bytes for a message length. If so, you should be using the 64bit function call ABI (with syscall, not int 0x80). The system-call numbers are different. See the table in one of the links at x86. The 32bit ABI can only accept 32bit pointers. You will have a problem if you try to pass a pointer that has any of the high32 bits set.

---

You're probably also going to want to format the number into a string, unless you want to pipe your program's output into hexdump.