x86 assembly

[smolloy]

Greetings all! Long time no see, and all that....

Lately, I've decided to teach myself some assembly language. I know assembly is a little useless these days, given the optimising power of a good C compiler, but I think it will help teach me about exactly what goes on inside my computer when programming in higher level languages.

I have just successfully compiled my first program, and I thought I'd share it. When assembled, it simply echos back the first argument given to the executable. Useless, but I thought it was a good start!

Let me hear your comment and criticisms. How could I make it better? Shorter? More efficient?

(By the way, it's written to be assembled by nasm on x86 linux.)

global _start

section .data
        term    db      " ", 10    ; a newline character to terminate the string
        length  equ     $-term

section .text

_start:
        pop     edi             ; argc
        pop     edi             ; argv[0]
        pop     edi             ; the first real arg, the string to be echoed 
        push    edi            ; push it back onto the stack for later use

        xor     ecx, ecx      ; zero ecx
        not     ecx             ; all ones
        xor     al, al           ; zero al
        cld                        ; The following lines find the length of the string help
        repne   scasb         ; in edi (i.e. the input)
        not     ecx
        mov     edx,ecx

        mov eax, 4              ; write to file
        mov ebx, 1              ; STDOUT handle
        pop     ecx                ; pop the input back off the stack
        int 80h                 ; execute the syscall

        mov eax, 4              ; write to file
        mov ebx, 1              ; STDOUT handle
        mov ecx, term          ; the newline
        mov edx, length
        int 80h                    ; syscall

        xor ebx, ebx            ; send 0 as 'exit code'
        mov eax, 1              ; terminate process
        int 80h                 ; execute the syscall

[gerard4143]

Good work. A simpler way to accomplish this is to get the value directly off the stack like:

	movl	8(%esp), %edi

[smolloy]

Cheers Gerard. Here's an updated version of the asm file. Incredibly, the executable fits into less than 200 bytes!

I have to admit that even though I can't think of a single good reason to use assembly, I am having an awful lot of fun learning it!

global _start

section .data
        term    db      " ", 10
        length  equ     $-term

section .text

_start:
        mov     edi, [esp+8]    ; Grab the input string off the stack

        xor     ecx, ecx        ; ECX = 0
        not     ecx             ; ECX = -1 (signed)
        xor     al, al          ; AL = 0
        cld                     ; Set direction of scan
        repne   scasb           ; Find string location that equals AL
        not     ecx             ; ECX = abs(ECX) -1
        dec     ecx             ; ECX -= 1

        mov     edx,ecx         ; string length
        mov     eax, 4          ; write to file
        mov     ebx, 1          ; STDOUT handle
        mov     ecx, [esp+8]    ; the string
        int     80h             ; execute the syscall

        mov     eax, 4          ; write to file
        mov     ebx, 1          ; STDOUT handle
        mov     ecx, term
        mov     edx, length
        int     80h

        mov     eax, 1          ; terminate process
        xor     ebx, ebx        ; send 0 as 'exit code'
        int     80h             ; execute the syscall

[Bemk]

I am trying to learn assembler as well, just to get to know the insides of the PC.

I'm not even close to where you are, for I'm still trying to figure out what the basic keywords are. I do like what you've done. It helps me getting to know assembler a bit better.

[egan]

Do you have any tutorials to recommend. I have tried learning assembly before, but I have had a hard time finding anything from which to learn.

[gerard4143]

Here's some links

PC Assembly Language

Programming from the Ground
Up

GCC-Inline-Assembly-HOWTO

[Bemk]

This is what I'm reading:

The Art of Assembly Language Programming

[elija]

Oh man that brings back memories. I used to program my Atari STe in Assembly.

I'm off to wallow in a nice warm pool of 80's nostalgia.

[smolloy]

Here is the one I have found most useful.

PC Assembly Language

I'm slowly working my way through it, and have found that my understanding has come on in leaps and bounds since I started. He provides a zip file of all the code discussed, which is very useful for using as a starting point for your own code.

[smolloy]

Here is the latest version of my code. Now it returns multiple input arguments, and is starting to look very much like an assembly version of bash "echo".

global _start

section .data
        space   db      " "
        term    db      " ", 10
        tlength equ     $-term

section .text

%define EXIT_OK 0
%define FWRITE 4
%define STDOUT 1
%define ENDPROC 1

_start:
        pop     edi             ; Number of input args
        pop     edi             ; The name of the executable.  Not used.

while:
        pop     edi             ; Get the string off the stack
        test    edi, edi        ; edi AND edi.  edi=NULL is the only state resulting in 0
        jz      endwhile        ; Test for the end
        push edi                ; Store it back on the stack to prevent corruption

        xor     ecx, ecx        ; ECX = 0
        not     ecx             ; ECX = -1 (signed)
        xor     al, al          ; AL = 0
        cld                     ; Set direction of scan
        repne   scasb           ; Find string location that equals AL
        not     ecx             ; ECX = abs(ECX) -1
        dec     ecx             ; ECX -= 1

        mov     edx,ecx         ; string length
        mov     eax, FWRITE     ; write to file
        mov     ebx, STDOUT     ; STDOUT handle
        mov     ecx, [esp]      ; the string
        int     80h             ; execute the syscall

        mov     edx, 1          ; Now print a space to separate input args
        mov     eax, FWRITE     ; write to file
        mov     ebx, STDOUT     ; STDOUT handle
        mov     ecx, space
        int     80h

        pop edi                 ; Dump the data

        jmp     while           ; Loop
endwhile:

        mov     eax, FWRITE     ; write to file
        mov     ebx, STDOUT     ; STDOUT handle
        mov     ecx, term
        mov     edx, tlength
        int     80h

        mov     eax, ENDPROC    ; terminate process
        xor     ebx, ebx        ; send 0 as 'exit code'
        int     80h             ; execute the syscall