Assembly

.section .text

.globl _start

_start:

mov $60, %rax      # 60 is the syscall number for 64-bits assembly
mov $3, %rdi       # the status code for the exit systemcall should be in %rdi
syscall             #invoke the system call

#!/bin/bash

as --gstabs+ ./$1.s -o $1.o
ld ./$1.o
./a.out
echo $?

./64bit.sh exit
3

.section .text

.globl _start

_start:

movl $1, %eax                           # now the eax register contains 1 which is the systemcall number for the exit syscall
movl $5, %ebx                           #the status code for the exit systemcall should be in %ebx
int $0x80                               #invoke the system call

#!/bin/bash

as --32 --gstabs+ $1.s -o $1.o
ld -m elf_i386 $1.o
./a.out
echo $?

./32bit.sh exit
5

.section .text

.global _start

_start:
        # write(1, message, 13)
        mov     $1, %rax                # system call 1 is write
        mov     $1, %rdi                # file handle 1 is stdout
        mov     $message, %rsi          # address of string to output
        mov     $13, %rdx               # number of bytes
        syscall                         # invoke operating system to do the write

        # exit(0)
        mov     $60, %rax               # system call 60 is exit
        xor     %rdi, %rdi              # we want return code 0
        syscall                         # invoke operating system to exit
message:
        .asciz  "Hello, world\n"

#!/bin/bash

as --gstabs+ ./$1.s -o $1.o
ld ./$1.o
./a.out
echo $?

./64bit.sh hello
=> Hello, world
=> 0

.section .data

.section .text

.global _start

_start:
        push $77

        format:
                .asciz  "%d\n"          # this format may also be below or above in .section .data but needed

        # 1 (pop - version)
        mov     $format, %rdi           # set 1st parameter (format)
        pop     %rsi                    # set 2nd parameter (current_number)
        xor     %rax, %rax              # mov $0, %rax using xor (faster) and because printf is varargs
        call    printf                  # printf(format, current_number)

        # 2 (move the content of %rsp to %rsi - version)
        mov     $format, %rdi           # set 1st parameter (format)
        mov     (%rsp), %rsi            # set 2nd parameter (current_number)
        xor     %rax, %rax              # because printf is varargs
        call    printf                  # printf(format, current_number)

exit:
        mov     $60, %rax               # system call 60 is exit
        xor     %rdi, %rdi              # we want return code 0
        syscall                         # invoke operating system to exit

#!/bin/bash


#-e main -s eventueel toevoegen als het startsymbol anders heet dan _start (rloman dit nog weg of uitzoeken)
as --gstabs+ -o $1.o ./$1.s
ld  -dynamic-linker /lib64/ld-linux-x86-64.so.2 -lc -melf_x86_64 ./$1.o
./a.out

./do_with_link.sh print_local_stack_var
=> 77

.section .data
    message: .asciz	"Hello World!\n"       # message and newline
    strend:  length = strend - message      # this is the length of the string (dynamic)
    file:	 .string	"./hello.out"	    # File to write

.section .text

.global _start

_start:

open_file:
                                        ## sys_open(file, permissions)
    mov	$2, %rax	                    # sys_open
    mov	$file, %rdi	                    # file
    mov	$0644, %rsi		                # Read/Write permissions
    syscall

check_if_exists:
                                        ## File exists?
    mov	$0, %rdx
    cmp	%rax, %rdx
    jle	write

create:
                                        ## sys_create(file, permissions)
	mov	$85, %rax		                # sys_create
	mov	$file, %rdi	                    # file
	mov	$0644, %rsi		                #  Read/Write permissions
	syscall

test_creation:
                                        ## File created sucessfully?
    mov	$0, %rdx
    cmp	%rdx, %rax                      # the %rax now contains the file descriptor and test for value <= 0
    jle	exit

write:

	mov	%rax, %rbx                      # File descriptor copy

	                                    ## sys_write(stream, message, length)
	mov	$1, %rax        	            # sys_write is syscallnr. 1
	mov	%rbx, %rdi                      # the fd
	mov	$message, %rsi                  # message address
	mov	$length, %rdx    	            # message string length
	syscall

                                        # close the file
                                        # rdi still contains the fd
	mov	$3, %rax                        # syscallnr. 3 is close
	syscall

exit:
    	                                ## sys_exit(return_code)
    	mov	$60, %rax      	            # sys_exit
    	mov	$0, %rdi        	        # return 0 (success)
    	syscall

#!/bin/bash

as --gstabs+ ./$1.s -o $1.o
ld ./$1.o
./a.out
echo $?

./64bit.sh write_to_file
=> 0
$ cat ./hello.out
=> Hello World!

.global _start

.section .text

        .set sys_write, 1
        .set stdout, 1
        .set sys_exit, 60
_start:
        mov     $sys_write, %rax        # system call 1 is write
        mov     $stdout, %rdi           # file handle 1 is stdout
        mov     $message, %rsi          # address of string to output
        mov     $14, %rdx               # number of bytes
        syscall                         # invoke operating system to do the write

        # exit(0)
        mov     $sys_exit, %rax         # system call 60 is exit
        mov     $0, %rdi                # we want return code 0
        syscall                         # invoke operating system to exit

message:
        .asciz  "Hello, world\n"

#!/bin/bash

as --gstabs+ ./$1.s -o $1.o
ld ./$1.o
./a.out
echo $?

./64bit.sh hello_world_using_set_directive_64_bit
=> Hello, world

.section .data:

.section .text
.globl _start

_start:

mov $5, %rax
add $3, %rax

mov %rax, %rdi #the status code should be in %rdi
mov $60, %rax # exit system call number
syscall #invoke the system call

#!/bin/bash

as simple_add.s -o simple_add.o
ld simple_add.o
./a.out
echo $?

./simple_add.sh
13

# this file is even created by the src/main/scripts/assapp script
.section .text

.globl _start

_start:

push $5
push $3
call add

	# set back the stack to before the call (e.g. remove the pars)
add $16, %rsp

mov %rax, %rdi #the status code for the exit systemcall should be in %rdi, in this case the result of the add function
mov $60, %rax # now the rax register contains 60 which is the systemcall number for the exit syscall
syscall #invoke the system call

add:
		# save the base pointer
	push %rbp
		# make the stack pointer the base pointer
	mov %rsp, %rbp
		# move the first parameter, again parameter to %rax, be aware that the top of the %rbp, points to the saved base pointer, hence 8+2*8
	mov 24(%rbp), %rax
		# add the second parameter to %rax, see above for explaination
	add 16(%rbp), %rax

		 # restore the stack pointer
	mov %rbp, %rsp
		# restore the old (pushed) base pointer, to be able to recursive calls
	pop %rbp

	ret

#!/bin/bash

as --gstabs+ ./$1.s -o $1.o
ld ./$1.o
./a.out
echo $?

./64bit.sh function-and-call
=> 8

#PURPOSE:Program to illustrate how functions work. This program will compute 8+5
.section .data

.section .text

.globl _start

_start:
pushl $8                           # place 8 on the top of the stack
pushl $5                            # place 5 on the top of the stack hence the stack is now: [8,5] (top is right in the example)
call add                            # invoke the add function
addl $8, %esp                       # when done, the %esp (stack pointer) is incremented by 8, hence pointing back to before the first pushed value above

movl %eax, %ebx                     # set the content of the accumulator in the the %ebx register (the resulting statuscode)

movl $1, %eax                       # (and %ebx is the status code (the result))
int $0x80                           # And exit

# This function adds to numbers
# variables:
## %eax - holds the first number (a)
## %ebx - holds the second number (b)
## -4(%ebp) - holds the current result
## %eax - used for temporary storage
.type add, @function
add:
    pushl %ebp                      # save old base pointer
    movl %esp, %ebp                 # make stack pointer the base pointer
    #subl $8, %esp                   # get room for our local storage # not perse neede here

    movl 8(%ebp), %eax              # put second (pushed) argument in %ecx which is the FIRST parameter!!! (a)
    movl 12(%ebp), %ebx             # put first (pushed) argument in %ebx which is the SECOND parameter!!! (b)


    addl %ebx, %eax

    # kind a local var this
    movl %eax, -4(%ebp)             # store current result not perse neede here

    # this is a small one, but for later calculation using the local var (1) is handy
    movl -4(%ebp), %eax             # return value goes in %eax # not perse needed here since already in accumulator.

    movl %ebp, %esp                 # restore the stack pointer
    popl %ebp                       # restore the base pointer

    ret                             # return from function

#!/bin/bash

as --32 --gstabs+ add.s -o add.o
ld -m elf_i386 add.o
./a.out
echo $?

./add.sh
13

.section .text
        .set sys_write, 1
        .set stdout, 1
        .set sys_exit, 60


.global _start

_start:

    #push the first argument on the stack
push $21
    # push the second argument on the stack
push $34
    # call the function
call add_plus_one
    # add 8 bytesx2 (one 64 bit var) to remove the arguments from the stackframe
add $16, %rsp

    # perform exit(%rdi);
mov %rax, %rdi
mov $sys_exit, %rax
syscall

.type add_plus_one, @function
add_plus_one:

        # save %rbp and move %rsp to %rbp
        ## this is to save the %rbp for recursive calling
     push %rbp
     mov %rsp, %rbp

        # create room for a (one) local variable
        #move the stack pointer 8 (x8)=64 bits down for one 64bit local variable
        ## and that will be used below to store our intermediate
     sub $8, %rsp

        # add the first(24(%rsbp)) and second(16(%rbp)) parameterto the %rax register
     mov 24(%rbp), %rax
     add 16(%rbp), %rax
        # increment with one
     inc %rax

        # set the content of the %rax to the local variable, just for demo purposes
     mov %rax, -8(%rbp)

        # set the (final) result in the accumulator (%rax), since that will be returned using the ret instruction below
     mov -8(%rbp), %rax

        #restore the stack pointer
     mov %rbp, %rsp

        # restore the (saved) basepointer
     pop %rbp

        # and return from function, which returns the content of the %rax register, after popping to the %rip, so it returns to the
        # next instructions after the caller
     ret

#!/bin/bash

as --gstabs+ ./$1.s -o $1.o
ld ./$1.o
./a.out
echo $?

./64bit.sh add_plus_one
56

.section .text

.globl _start

_start:
    xor %ecx, %ecx                  # clear dividend

    movl $8003, %eax                # argument 1
    movl $100, %ecx                 # argument 2
    div %ecx                        # arg1/arg2 => %ecx

    movl %edx, %ebx                 # move the remainder (in %edx) to %ebx (for status code)

exit:
    movl $1, %eax                   # exit
    int $0x80                       # invoke the system call

#!/bin/bash

as --32 --gstabs+ $1.s -o $1.o
ld -m elf_i386 $1.o
./a.out
echo $?

./32bit.sh remainder
=> 3

.section .data
    var1: .int 40
    var2: .int 20
    var3: .int 30

.section .text
.globl _start

_start:
    # move the contents of variables
    movl (var1), %ecx
    cmpl (var2), %ecx
    jg check_third_var
    movl (var2), %ecx

check_third_var:
    cmpl (var3), %ecx
    jg _exit

    movl (var3), %ecx


_exit:
    movl $1, %eax
    movl %ecx, %ebx
    int $0x80

#!/bin/bash

as --32 --gstabs+ $1.s -o $1.o
ld -m elf_i386 $1.o
./a.out
echo $?

./32bit.sh max_of_three_global_vars
=> 40

#PURPOSE:This program finds the maximum number of a set of data items.

# Credits Book Programming from the Ground up (see Resources)

#VARIABLES: The registers have the following uses:
# %edi - Holds the index of the data item being examined
# %ebx - Largest data item found
# %eax - Current data item

## WARNING: Since the statuscode of a C program < 255, the max number in the list
## below should be 255

# The following memory locations are used:
# data_items - contains the item data. A 0 is used to terminate the data

.section .data

#These are the data items
data_items:
   .long 3,67,34,222,45,75,54,34,44,33,22,11,66,0

.section .text

.globl _start

_start:
movl $0, %edi                           # move 0 into the index register
movl data_items(,%edi,4), %eax          # load the first byte of data from data_items[%edi] into %eax upto and not including the 4(th) byte (long!)
movl %eax, %ebx                         # since this is the first item, %eax is the biggest

start_loop:
    cmpl $0, %eax                       # check to see if we’ve hit the end
    je loop_exit                        # exit the loop if they are equal
    incl %edi                           # else load next value
    movl data_items(,%edi,4), %eax
    cmpl %ebx, %eax                     # compare values => jle means below compare the content of %eax with %ebx and if eax < ebx do nothing, jump if eax le ebx so other way
    jle start_loop                      # if less or equal go to start loop (the new one is not bigger, e.g. the new one is le )
    movl %eax, %ebx                     # else, move the value as the largest
    jmp start_loop                      # uncondition jump to start of the loop

loop_exit:                              # we are done now

    movl $1, %eax                       #1 is the exit() syscall
                                        # %ebx is the status code for the exit system call and it already has the maximum number
    int $0x80

#!/bin/bash

as --32 --gstabs+ $1.s -o $1.o
ld -m elf_i386 $1.o
./a.out
echo $?

./32bit.sh maximum_of_a_set
=> 222

#PURPOSE:This program finds the minimum number of a set of data items.

#VARIABLES: The registers have the following uses:
# %edi - Holds the index of the data item being examined
# %ebx - Largest data item found
# %eax - Current data item

# The following memory locations are used:
# data_items - contains the item data. A 0 is used to terminate the data

.section .data

#These are the data items
data_items:
   .long 67,34,3,222,45,75,54,34,44,33,22,11,66,255

.section .text

.globl _start

_start:
    movl $0, %edi                           # move 0 into the index register
    movl data_items(,%edi,4), %eax          # load the first byte of data from data_items[%edi] into %eax upto and not including the 4(th) byte (long!)
    movl %eax, %ebx                         # since this is the first item, %eax is the smallest

start_loop:
    cmpl $255, %eax                         # check to see if we’ve hit the end
    je loop_exit                            # exit the loop if they are equal
    incl %edi                               # else load next value
    movl data_items(,%edi,4), %eax
    cmpl %ebx, %eax                         # compare values
    jg start_loop                           # if less or equal go to start loop (the new one is not bigger, e.g. the new one is le )
    movl %eax, %ebx                         # else, move the value as the smallest
    jmp start_loop                          # uncondition jump to start of the loop

loop_exit:

movl $1, %eax                               # exit with the status code in the %ebx register
int $0x80

#!/bin/bash

as --32 --gstabs+ $1.s -o $1.o
ld -m elf_i386 $1.o
./a.out
echo $?

./32bit.sh minimum
=> 3

# -----------------------------------------------------------------------------
# A 64-bit Linux application that writes the first 90 Fibonacci numbers.  It
# needs to be linked with a C library.
#
# Assemble and Link:
#     gcc fib.s
# -----------------------------------------------------------------------------

        .global _start

        .text
_start:
        push    %rbx                    # we have to save this since we use it

        mov     $90, %rcx               # rcx will countdown to 0
        xor     %rax, %rax              # rax will hold the current number, now zero (xor is faster than mov $0, %rax)
        xor     %rbx, %rbx              # rbx will hold the next number, idem, now zero
        inc     %rbx                    # rbx is originally 1

.type print, @function
print:
        # We need to call printf, but we are using eax, ebx, and ecx.  printf
        # may destroy eax and ecx so we will save these (by pushing on the stack) before the call and
        # restore them afterwards.

        push    %rax                    # caller-save register
        push    %rcx                    # caller-save register

        mov     $format, %rdi           # set 1st parameter (format)
        mov     %rax, %rsi              # set 2nd parameter (current_number)
        xor     %rax, %rax              # because printf is varargs

            # Stack is already aligned because we pushed three 8 byte registers
            # printf(format, current_number) (calls the C-library function, not to be confused with a syscall)
        call    printf

        pop     %rcx                    # restore caller-save register
        pop     %rax                    # restore caller-save register

        mov     %rax, %rdx              # save the current number
        mov     %rbx, %rax              # next number is now current
        add     %rdx, %rbx              # get the new next number
        dec     %rcx                    # count down
        jnz     print                   # if not done counting, do some more print (comparing with %rcx)

        pop     %rbx                    # restore rbx before returning

            #exit
         mov $60, %rax
         mov $0, %rdi
         syscall
format:
        .asciz  "%20ld\n"

#!/bin/bash


#-e main -s eventueel toevoegen als het startsymbol anders heet dan _start (rloman dit nog weg of uitzoeken)
as --gstabs+ -o $1.o ./$1.s
ld  -dynamic-linker /lib64/ld-linux-x86-64.so.2 -lc -melf_x86_64 ./$1.o
./a.out

./do_with_link.sh fibon
                    0
                    1
                    1
                    2
                    3
                    5
                    8
                   13
                   21
    ...
  1779979416004714189

#PURPOSE:Program to illustrate how functions work. This program will compute the value of  2^3 + 5^2

# Credits Book Programming from the Ground up (see Resources)


.section .data

.section .text

.globl _start

_start:

pushl $3                            # place 3 on the top of the stack
pushl $2                            # place 2 on the top of the stack hence the stack is now: [3,2] (top is right in the example)
call power                          # invoke the power function

addl $8, %esp                       # move the stack pointer back (4bytes per argument)

pushl %eax                          # push the (sub) result (the content of the accumulator) on the stack

###### now the second power invocation
pushl $2                            # push second argument
pushl $5                            # push first argument
call power                          # again, call power
addl $8, %esp                       # move the stack pointer back

popl %ebx                           # since we saved it before 'push %eax' (line 15) we can now pop that old result in %ebx register
                                    #eax now contains the result of the 2^5 call

addl %eax, %ebx                     # add them to the %ebx register

movl $1, %eax                       # (and %ebx is the status code (the result))
int $0x80                           # And exit

# This function raises number to a power
# variables:
## %ebx - holds the base number
## %ecx - holds the power to raise to
## -4(%ebp) - holds the current result
## %eax - used for temporary storage
.type power, @function
power:
    pushl %ebp                      # save old base pointer
    movl %esp, %ebp                 # make stack pointer the base pointer
    subl $4, %esp                   # get room for our local storage

    movl 8(%ebp), %ebx              # put first argument in %ebx
    movl 12(%ebp), %ecx             # put second argument in %ecx

    movl %ebx, -4(%ebp)             # store current result to local var 1

    power_loop_start:
        cmpl $1, %ecx               # if the power is 1, we are done
        je end_power
        movl -4(%ebp), %eax         # move the current result into %eax
        imull %ebx, %eax            # multiply the current result by the base number
        movl %eax, -4(%ebp)         # store the current result
        decl %ecx                   # decrease the power
        jmp power_loop_start        # run for the next power

    end_power:
        movl -4(%ebp), %eax         # return value goes in %eax
        movl %ebp, %esp             # restore the stack pointer
        pop (%ebp)                  # restore the base pointer
        ret                         # return from function

#!/bin/bash

as --32 --gstabs+ $1.s -o $1.o
ld -m elf_i386 $1.o
./a.out
echo $?

./32bit.sh power
=> 33 # since 2^3 +5^2 = 33

SYS_WRITE = 1
STDOUT    = 1

.section .data
    newline: .ascii "\n"
    newline_end: NEWLINE_LEN = newline_end-newline

.section .text

.globl _start

_start:

    mov (%rsp), %r8             # 0(%rsp) = # args. This code doesn't use it. Only save it to R8 as an example.
    lea 16(%rsp), %rbx          # 8(%rsp)=pointer to prog name, # 16(%rsp)=pointer to 1st parameter

.argloop:
    mov (%rbx), %rsi            # Get current cmd line parameter pointer
    test %rsi, %rsi
    jz .exit                    # If it's zero we are finished

    # Compute length of current cmd line parameter
    # Starting at the address in RSI (current parameter) search until
    # we find a NUL(0) terminating character.
    # rdx = length not including terminating NUL character

    xor %rdx, %rdx              # RDX = character index = 0
    mov %rdx, %rax              # RAX = terminating character NUL(0) to look for
.strlenloop:
    inc %rdx               # advance to next character index
    cmpb %al, -1(%rsi,%rdx)# Is character at previous char index
                             #     a NUL(0) character?
    jne .strlenloop        # If it isn't a NUL(0) char then loop again
    dec %rdx                    # We don't want strlen to include NUL(0)

    # Display the cmd line argument
    # sys_write requires:
    #    rdi = output device number
    #    rsi = pointer to string (command line argument)
    #    rdx = length
    #
    mov $STDOUT, %rdi
    mov $SYS_WRITE, %rax
    syscall

    # display a new line
    mov $NEWLINE_LEN, %rdx
    lea newline(%rip), %rsi     # We use RIP addressing for the
                                #     string address
    mov $SYS_WRITE, %rax
    syscall

    add $8, %rbx                # Go to next cmd line argument pointer
                                #     In 64-bit pointers are 8 bytes
    # lea 8(%rbx), %rbx         # This LEA instruction can replace the
                                #     ADD since we don't care about the flags
                                #     rbx = 8 + rbx (flags unaltered)
    jmp .argloop

.exit:
    xor %rdi, %rdi
    mov $60, %rax
    syscall

#!/bin/bash

as --gstabs+ ./$1.s -o $1.o
ld ./$1.o
./a.out
echo $?

./a.out aap noot mies
=> aap
=> noot
=> mies