312 lines
10 KiB
NASM
312 lines
10 KiB
NASM
;*********************************************************************
|
|
; util.asm
|
|
; Version: 1.2
|
|
; Author: mjbrusso
|
|
; Contributors: AlessandroFonseca
|
|
; Licensed under the MIT license (see "license.txt").
|
|
;*********************************************************************
|
|
global exit, exit0, strlen, atoi, endl, printstr, printint, readstr, readint
|
|
|
|
SYS_READ: equ 0
|
|
SYS_WRITE: equ 1
|
|
SYS_EXIT: equ 60
|
|
|
|
STDIN: equ 0
|
|
STDOUT: equ 1
|
|
|
|
LINEFEED: equ 0x0A
|
|
|
|
section .text
|
|
|
|
;*********************************************************************
|
|
; void exit(int64 code)
|
|
;
|
|
; Description:
|
|
; Quit program
|
|
;
|
|
; Arguments:
|
|
; rdi: int64 code: Exit code (0=Success, >0=Error)
|
|
;
|
|
; Returns:
|
|
; This function does not return
|
|
;
|
|
;*********************************************************************
|
|
exit:
|
|
mov rax, SYS_EXIT ; rax: system call number
|
|
syscall
|
|
;*********************************************************************
|
|
|
|
;*********************************************************************
|
|
; void exit0()
|
|
;
|
|
; Description:
|
|
; Quit program with status code = 0
|
|
;
|
|
; Arguments:
|
|
; None
|
|
;
|
|
; Returns:
|
|
; This function does not return
|
|
;
|
|
;*********************************************************************
|
|
exit0:
|
|
xor rdi, rdi ; rdi = 0
|
|
jmp exit ; TCO: tail call optimization
|
|
;*********************************************************************
|
|
|
|
|
|
;*********************************************************************
|
|
; int64 strlen(char *s)
|
|
;
|
|
; Description:
|
|
; Calculates the length of string ( excluding the terminating null)
|
|
;
|
|
; Arguments:
|
|
; rdi: char *s: address of a null-terminated string (array of chars terminated by 0)
|
|
;
|
|
; Returns:
|
|
; rax: int64: string size
|
|
;
|
|
;*********************************************************************
|
|
strlen:
|
|
xor rax, rax ; rax=0; // reset counter
|
|
.loop: ; do{
|
|
cmp byte [rdi], 0 ; if (*s==0); // If zero, skip loop
|
|
je strlen.end ; break;
|
|
inc rax ; rax++; // increment counter
|
|
inc rdi ; s++; // advance to the next char
|
|
jmp strlen.loop ; }while(true);
|
|
.end:
|
|
ret ; return rax;
|
|
;*********************************************************************
|
|
|
|
|
|
;*********************************************************************
|
|
; void itoa(int64 value, char *s)
|
|
;
|
|
; Description:
|
|
; Converts an integer to a null-terminated string.
|
|
;
|
|
; Arguments:
|
|
; rdi: int64 value: Integer value to convert.
|
|
; rsi: char *s: Memory address where to store the resulting string.
|
|
;
|
|
; Returns:
|
|
; rax: int64: string size
|
|
;
|
|
;*********************************************************************
|
|
itoa:
|
|
test rdi, rdi ; value = rdi
|
|
jz itoa.iszero ; value==0 has a direct solution
|
|
jns itoa.notneg ; if(value <0 )
|
|
mov byte [rsi], '-' ; *s = '-'
|
|
neg rdi ; value = -value
|
|
inc rsi ; s++
|
|
.notneg:
|
|
mov r9b, 1 ; bool leftzero=true
|
|
mov r10, 10 ; base = 10
|
|
mov rcx, 1000000000000000000 ; divisor = 1000000000000000000
|
|
mov r8, 19 ; cont = 19 // Will repeat 19 times
|
|
.loop: ; do{
|
|
mov rax, rdi ; dividend[0..31] = value
|
|
xor rdx, rdx ; dividend[32..63] = 0
|
|
idiv rcx ; rax=(rdx:rax)/rcx ; rdx=(rdx:rax)%rcx
|
|
test al, al ; digit = rax[0..7]
|
|
jnz itoa.notdigit0 ; if(digit!=0)
|
|
test r9b, r9b ; if(leftzero)
|
|
jnz itoa.nextdigit ; continue
|
|
jmp itoa.digit0
|
|
.notdigit0:
|
|
xor r9b, r9b ; leftzero = false
|
|
.digit0:
|
|
add eax, 48 ; digit = '0' + digit
|
|
mov rdi, rdx ; value %= divisor
|
|
mov byte [rsi], al ; *p = digit
|
|
inc rsi ; p++
|
|
.nextdigit:
|
|
mov rax, rcx ; dividend[0..31] = value
|
|
xor rdx, rdx ; dividend[32..63] = 0
|
|
idiv r10 ; rax=(rdx:rax)/10 ; rdx=(rdx:rax)%10
|
|
mov rcx, rax ; divisor /= 10
|
|
dec r8 ; cont--
|
|
jne itoa.loop ; }while(cont!=0)
|
|
.end:
|
|
mov byte [rsi], 0 ; *p = '\0'
|
|
ret
|
|
.iszero:
|
|
mov word [rsi], 0x0030 ; *p = "0" (x86 is little endian)
|
|
ret
|
|
;*********************************************************************
|
|
|
|
|
|
;*********************************************************************
|
|
; int64 atoi(char *s)
|
|
;
|
|
; Description:
|
|
; Convert string to integer.
|
|
;
|
|
; Arguments:
|
|
; rdi: char *s: Address of a null-terminated string (array of chars terminated by 0)
|
|
;
|
|
; Returns:
|
|
; rax: int64: integer value
|
|
;*********************************************************************
|
|
atoi:
|
|
push r12 ; r12 is callee saved
|
|
mov r12, rdi ; rdi is caller saved
|
|
call strlen
|
|
lea rdi, [r12+rax-1] ; char *p = &s[strlen(string)]; //scans string backward
|
|
xor rax, rax ; result value
|
|
mov rdx, 1 ; multiplier
|
|
.beginloop:
|
|
cmp rdi, r12 ; while(p>=s){
|
|
jl atoi.end ;
|
|
xor rcx, rcx ;
|
|
mov cl, byte [rdi] ; cl = current char
|
|
cmp cl, '-' ; if(cl=='-')
|
|
jne atoi.notneg ;
|
|
neg rax ; rax=-rax
|
|
jmp atoi.end ;
|
|
.notneg:
|
|
cmp cl, '9' ; if(!isdigit(cl)) nextdigit
|
|
jg atoi.endloop ;
|
|
sub cl, '0' ;
|
|
jl atoi.endloop ;
|
|
imul rcx, rdx ; digit_value = current_char * multiplier
|
|
add rax, rcx ; result += digit_value
|
|
imul rdx, 10 ; multiplier *= 10
|
|
.endloop:
|
|
dec rdi ; previous char //scans string backward
|
|
jmp atoi.beginloop ; }
|
|
.end:
|
|
pop r12 ; restore r12
|
|
ret
|
|
;*********************************************************************
|
|
|
|
|
|
;*********************************************************************
|
|
; void endl()
|
|
;
|
|
; Description:
|
|
; Prints a newline (line break)
|
|
;
|
|
; Arguments:
|
|
; None
|
|
;
|
|
; Returns:
|
|
; Nothing
|
|
;
|
|
;*********************************************************************
|
|
endl:
|
|
lea rdi, [endl.str] ; print the string
|
|
call printstr
|
|
ret
|
|
|
|
;*********************************************************************
|
|
|
|
|
|
;*********************************************************************
|
|
; void printstr(char *s)
|
|
;
|
|
; Description:
|
|
; Print a string
|
|
;
|
|
; Arguments:
|
|
; rdi: char *s: address of a null-terminated string (array of chars terminated by 0)
|
|
;
|
|
; Returns:
|
|
; Nothing
|
|
;
|
|
;*********************************************************************
|
|
printstr:
|
|
push r15 ; r15 is callee saved
|
|
mov r15, rdi ; save copy (rdi should be caller saved)
|
|
call strlen
|
|
mov rdx, rax ; string size
|
|
mov rsi, r15 ; string
|
|
mov rax, SYS_WRITE ; system call number
|
|
mov rdi, STDOUT ; file descriptor
|
|
syscall ; system call
|
|
pop r15
|
|
ret
|
|
;*********************************************************************
|
|
|
|
|
|
;*********************************************************************
|
|
; void printint(int64 n)
|
|
;
|
|
; Description:
|
|
; Print integer number (decimal)
|
|
;
|
|
; Arguments:
|
|
; rdi: int64 n: Value to print
|
|
;
|
|
; Returns:
|
|
; Nothing
|
|
;
|
|
;*********************************************************************
|
|
printint:
|
|
sub rsp, 40 ; stack allocate a temp string
|
|
mov rsi, rsp ; rdi=value, rsi=&str[0]
|
|
call itoa
|
|
mov rdi, rsp ; rdi=&str[0]
|
|
call printstr ; print number
|
|
add rsp, 40 ; deallocate the string
|
|
ret
|
|
;*********************************************************************
|
|
|
|
|
|
;*********************************************************************
|
|
; int64 readstr(char *s, int64 maxsize)
|
|
;
|
|
; Description:
|
|
; Read up to *maxsize* chars from standard input into a string.
|
|
;
|
|
; Arguments:
|
|
; rdi: char *s: address of a string (array of chars)
|
|
; rsi: int64 maxsize: input size limit
|
|
;
|
|
; Returns:
|
|
; rax: int64: Number of characters read
|
|
;
|
|
;*********************************************************************
|
|
readstr:
|
|
mov r8, rdi ; copy of buffer address
|
|
mov rax, SYS_READ ; system call number
|
|
mov rdx, rsi ; pointer to buffer
|
|
mov rsi, rdi ; max size
|
|
mov rdi, STDIN ; file descriptor
|
|
syscall ; system call
|
|
dec rax ; removing trailing newline char
|
|
mov byte [r8+rax], 0 ; replace with '\0'
|
|
ret
|
|
;*********************************************************************
|
|
|
|
|
|
;*********************************************************************
|
|
; int64 readint()
|
|
;
|
|
; Description:
|
|
; Read int64 from standard input
|
|
;
|
|
; Arguments:
|
|
; None
|
|
;
|
|
; Returns:
|
|
; rax: int64: The value entered
|
|
;
|
|
;*********************************************************************
|
|
readint:
|
|
sub rsp, 40 ; char s[40]
|
|
mov rdi, rsp ; rdi = &s[0]
|
|
mov rsi, 21 ; max input size
|
|
call readstr ; read number as string
|
|
mov rdi, rsp ;
|
|
call atoi ; rax = atoi(s)
|
|
add rsp, 40 ; deallocate s from stack
|
|
ret
|
|
;*********************************************************************
|
|
|
|
section .data
|
|
endl.str: db LINEFEED, 0
|