Category: Uncategorized

I purchased volume 1, and I was blown away by how much information on the basics of hardware, registers, memory, and number systems was contained. In this review, I will explain how this book helped me and what I used it for.

I am a hobbyist Assembly programmer who has mostly done Intel/8086 Assembly on Linux and DOS operating systems. However, I have started trying to learn about other types of CPUs and their Assembly languages.

I learn Assembly because I believe learning Assembly can make someone a better programmer in other languages as well. But beyond that, I like learning about all the different machines there are and their differences. Most importantly, which are easier to learn than others? This book series by ChibiAkumas / Keith ‘Akuyou’ mentions the exact information I need so that I can decide which CPU I want to learn next and what tools to start with.

I was very pleased with the Kindle edition of volume 1, and so I purchased paperbacks of volumes 1 and 2. My ONLY disappointment with the Kindle edition specifically was that I cannot read it on the Kindle cloud reader, https://read.amazon.com/, on my PC. Because I use Linux, installing a Kindle app on a PC is not an option. I would advise the author to see if there is a way to make it readable in a web browser, like every other Kindle book in my library is. However, at least I will have the paperback soon for an easier reading experience. Reading on a tiny iPhone screen is hard on the eyes.

https://www.amazon.com/Learn-Multiplatform-Assembly-Programming-ChibiAkumas-ebook/dp/B0BLM31GX1

#hexdump for MIPS emulator: mars
.data
title: .asciiz "hexdump program in MIPS assembly language\n\n"

# test string of integer for input
test_int: .asciiz "10011101001110011110011"
hex_message: .asciiz "Hex Dump of File: "
file_message_yes: .asciiz "The file is open.\n"
file_message_no: .asciiz "The file could not be opened.\n"
file_data: .byte '?':16
           .byte 0
space_three: .asciiz "   "

#this is the location in memory where digits are written to by the putint function
int_string: .byte '?':32
int_newline: .byte 10,0
radix: .byte 2
int_width: .byte 4

argc: .word 0
argv: .word 0

.text
main:

# at the beginning of the program a0 has the number of arguments
# so we will save it in the argc variable
la $t1,argc
sw $a0,0($t1)

# at the beginning of the program a1 has a pointer to the argument strings
# so we save it because we may need a1 for system calls
la $t1,argv
sw $a1,0($t1)

#Now that the argument data is stored away, we can access it even if it is overwritten.
#For example, the putstring function uses a0 for system call number 4, which prints a string

la $s0,title
jal putstring

li $t0,16    #change radix
la $t1,radix
sb $t0,0($t1)

li $t0,1    #change width
la $t1,int_width
sb $t0,0($t1)


# next, we load argc from the memory so we can display the number of arguments
la $t1,argc
lw $s0,0($t1)
#jal putint

beq $s0,$zero,exit # if the number of arguments is zero, exit the program because nothing else to print

# this section processes the filename and opens the file from the first argument

jal next_argument
#jal putstring
move $s7,$s0 #save the filename in register s7 so we can use it any time

li $v0,13 # open file call number
move $a0,$s7  # copy filename for the open call
li $a1,0    # read only access for the file we will open (rars does not support read+write mode)
syscall

move $s0,$v0
#jal putspace
#jal putint

blt $s0,$zero,file_error # branch if argc is not equal to zero

move $s6,$s0 # save the file handle in register s6
la $s0,file_message_yes
#jal putstring

jal hexdump

j exit

file_error:

la $s0,file_message_no
jal putstring


j exit

exit:
li $v0, 10     # exit syscall
syscall








# this is the hexdump function

hexdump:
addi $sp,$sp,-4
sw $ra,0($sp)

la $s0,hex_message
jal putstring
move $s0,$s7
jal putstring
jal putline


li $t0,0    #disable automatic newlines after putint
la $t1,int_newline
sb $t0,0($t1)

li, $s5,0 # we will use s5 register as current offset



hex_read_row:
li $v0,14        # read system call
move $a0,$s6        # file handle
la $a1,file_data # where to store data
li $a2,16        # how many bytes to read
syscall           # a0 will have number of bytes read after this call

move $s3,$v0 #save v0 to s3 to keep count of how many bytes read
move $s2,$v0 #save v0 to s2 to keep count of how many bytes read

beq $v0,$zero,hexdump_end

li $s0,8    #change width
la $s1,int_width
sb $s0,0($s1)

move $s0,$s5
add $s5,$s5,$s3
jal putint
jal putspace

li $s0,2    #change width to 2 for the bytes printed this row
la $s1,int_width
sb $s0,0($s1)

la $s1,file_data
hex_row_print:
lb $s0,0($s1)
jal putint
jal putspace
addi $s1,$s1,1

addi $s2,$s2,-1
bne $s2,$zero,hex_row_print

#pad the row with extra spaces

move $t2,$s3
li $t3,16
extra_row_space:
beq $t2,$t3,extra_row_space_complete
la $s0,space_three
jal putstring
addi $t2,$t2,1
j extra_row_space
extra_row_space_complete:

#now the hex form of the bytes are printed
#we will filter the text form and also print it

li $s2,0
la $s1,file_data
char_filter:
lb $s0,0($s1)

#if char is below 0x20 or above 0x7E, it is outside the range of printable characters

li $t5,0x20
blt $s0,$t5,not_printable
li $t5,0x7E
bgt $s0,$t5,not_printable

j next_char_index

not_printable:
li $s0,'.'
sb $s0,0($s1)

next_char_index:
addi $s1,$s1,1
addi $s2,$s2,1
blt $s2,$s3,char_filter

li $s0,0
sb $s0,0($s1)   #terminate string with a zero

la $s0,file_data
jal putstring


jal putline

j hex_read_row

hexdump_end:
lw $ra,0($sp)
addi $sp,$sp,4
jr $ra








# this function gets the next command line argument and returns it in s0
# it also decrements the argc variable so that it can be checked for 0 to exit the program if needed by the main program

next_argument:

la $t1,argv
lw $t0,0($t1) #load the string pointer located in argv into t0 register
lw $s0,0($t0) #load the data being pointed to by t0 into s0 for displaying the string
addi $t0,$t0,4 #add 4 to the pointer
sw $t0,0($t1)  #store the pointer so it will be loaded at the next string if the loop continues

# load the number of arguments from memory, subtract 1, store back to memory
# then use to compare and loop if nonzero
la $t1,argc
lw $t0,0($t1)

addi $t0,$t0,-1
sw $t0,0($t1)

jr $ra



putline:
li $v0,11
li $a0,10
syscall
jr $ra

putspace:
li $v0,11
li $a0,' '
syscall
jr $ra





putstring:
li $v0,4      # load immediate, v0 = 4 (4 is print string system call)
move $a0,$s0  # load address of string to print into a0
syscall
jr $ra


#this is the intstr function, the ultimate integer to string conversion function
#just like the Intel Assembly version, it can convert an integer into a string
#radixes 2 to 36 are supported. Digits higher than 9 will be capital letters

intstr:

la $t1,int_newline # load target index address of lowest digit
addi $t1,$t1,-1

lb $t2,radix     # load value of radix into $t2
lb $t4,int_width # load value of int_width into $t4
li $t3,1         # load current number of digits, always 1

digits_start:

divu $s0,$s0,$t2 # $s0=$s0/$t2 (divide s0 by the radix value in $t2)
mfhi $t0        # $t0=remainder of the previous division
blt $t0,10,decimal_digit
bge $t0,10,hexadecimal_digit

decimal_digit: # we go here if it is only a digit 0 to 9
addi $t0,$t0,'0'
j save_digit

hexadecimal_digit:
addi $t0,$t0,-10
addi $t0,$t0,'A'

save_digit:
sb $t0,($t1) # store byte from $t0 at address $t1
beq $s0,$0,intstr_end
addi $t1,$t1,-1
addi $t3,$t3,1
j digits_start

intstr_end:

li $t0,'0'
prefix_zeros:
bge $t3,$t4,end_zeros
addi $t1,$t1,-1
sb $t0,($t1) # store byte from $t0 at address $t1
addi $t3,$t3,1
j prefix_zeros
end_zeros:

move $s0,$t1

jr $ra

#this function calls intstr to convert the $s0 register into a string
#then it uses a system call to print the string
#it also uses the stack to save the value of $s0 and $ra (return address)

putint:
addi $sp,$sp,-8
sw $ra,0($sp)
sw $s0,4($sp)
jal intstr
#print string
li $v0,4      # load immediate, v0 = 4 (4 is print string system call)
move $a0,$s0  # load address of string to print into a0
syscall
lw $ra,0($sp)
lw $s0,4($sp)
addi $sp,$sp,8
jr $ra




strint:

move $t1,$s0 # copy string address from $s0 to $t1
li $s0,0

lb $t2,radix     # load value of radix into $t2

read_strint:
lb $t0,($t1)
addi $t1,$t1,1
beq $t0,0,strint_end

#if char is below '0' or above '9', it is outside the range of these and is not a digit
blt $t0,'0',not_digit
bgt $t0,'9',not_digit

#but if it is a digit, then correct and process the character
is_digit:
and $t0,$t0,0xF
j process_char

not_digit:
#it isn't a digit, but it could be perhaps and alphabet character
#which is a digit in a higher base

#if char is below 'A' or above 'Z', it is outside the range of these and is not capital letter
blt $t0,'A',not_upper
bgt $t0,'Z',not_upper

is_upper:

sub $t0,$t0,'A'
addi $t0,$t0,10
j process_char

not_upper:

#if char is below 'a' or above 'z', it is outside the range of these and is not lowercase letter
blt $t0,'a',not_lower
bgt $t0,'z',not_lower

is_lower:

sub $t0,$t0,'a'
addi $t0,$t0,10
j process_char

not_lower:

#if we have reached this point, result invalid and end function
#this is only reached if the byte was not a valid digit or alphabet character
j strint_end

process_char:

bgt $t0,$t2 strint_end #;if this value is above or equal to radix, it is too high despite being a valid digit/alpha

mul $s0,$s0,$t2 # multiply $s0 by the radix
add $s0,$s0,$t0     # add the correct value of this digit

j read_strint # jump back and continue the loop if nothing has exited it

strint_end:

jr $ra

I have been learning the Assembly language of MIPS recently, just for fun. I have been learning from this book:

I learned enough to translate my Intel functions into the language of MIPS. My code runs in both the spim and mars simulators.

Also, this reference was helpful for understanding the division instructions which were not covered by the book written by Robert Winkler:

I don’t expect to have much use for these functions, but theoretically, I could write nearly anything with them if I put enough time with them. Most of the time I will stick with the Intel Assembly because it runs natively on my computer. I am very glad these simulators exist and were so easy to use. Unfortunately I haven’t found the equivalent simulators I was hoping to for 6502.

# This is the source of the MIPS version of chastelib
# The four basic functions have been translated from Intel x86 Assembly
# They are as follows
#
# putstring (prints string pointed to by $s0 register)
# intstr (converts integer in $s0 register to a string)
# putint (prints integer in $s0 register by use of the previous two functions)
# strint (converts a string pointed to by $s0 register into an integer in $s0)
#
# Most importantly, the intstr and strint functions depend on a global variable (radix)
# In fact, these two functions are the foundation of everything.
# They can convert to and from any radix from 2 to 36

.data
title: .asciiz "A test of Chastity's integer and string conversion functions.\n"

# test string of integer for input
test_int: .asciiz "10011101001110011110011"

#this is the location in memory where digits are written to by the putint function
int_string: .byte '?':32
int_newline: .byte 10,0
radix: .byte 2
int_width: .byte 4

.text
main:

la $s0,title
jal putstring

li $s0,0 #we will load the $s0 register with the number we want to convert to string

loop:
jal putint
addi $s0,$s0,1
blt $s0,16,loop

la $s0,test_int # convert string to integer
jal strint

li $t0,10    #change radix
sb $t0,radix

li $t0,8    #change width
sb $t0,int_width

jal putint

li   $v0, 10     # exit syscall
syscall


putstring:
li $v0,4      # load immediate, v0 = 4 (4 is print string system call)
move $a0,$s0  # load address of string to print into a0
syscall
jr $ra


#this is the intstr function, the ultimate integer to string conversion function
#just like the Intel Assembly version, it can convert an integer into a string
#radixes 2 to 36 are supported. Digits higher than 9 will be capital letters

intstr:

la $t1,int_newline # load target index address of lowest digit
addi $t1,$t1,-1

lb $t2,radix     # load value of radix into $t2
lb $t4,int_width # load value of int_width into $t4
li $t3,1         # load current number of digits, always 1

digits_start:

divu $s0,$s0,$t2 # $s0=$s0/$t2 (divide s0 by the radix value in $t2)
mfhi $t0        # $t0=remainder of the previous division
blt $t0,10,decimal_digit
bge $t0,10,hexadecimal_digit

decimal_digit: # we go here if it is only a digit 0 to 9
addi $t0,$t0,'0'
j save_digit

hexadecimal_digit:
addi $t0,$t0,-10
addi $t0,$t0,'A'

save_digit:
sb $t0,($t1) # store byte from $t0 at address $t1
beq $s0,$0,intstr_end
addi $t1,$t1,-1
addi $t3,$t3,1
j digits_start

intstr_end:

li $t0,'0'
prefix_zeros:
bge $t3,$t4,end_zeros
addi $t1,$t1,-1
sb $t0,($t1) # store byte from $t0 at address $t1
addi $t3,$t3,1
j prefix_zeros
end_zeros:

move $s0,$t1

jr $ra

#this function calls intstr to convert the $s0 register into a string
#then it uses a system call to print the string
#it also uses the stack to save the value of $s0 and $ra (return address)

putint:
sw $ra,0($sp)
sw $s0,4($sp)
jal intstr
#print string
li $v0,4      # load immediate, v0 = 4 (4 is print string system call)
move $a0,$s0  # load address of string to print into a0
syscall
lw $ra,0($sp)
lw $s0,4($sp)
jr $ra











strint:

move $t1,$s0 # copy string address from $s0 to $t1
li $s0,0

lb $t2,radix     # load value of radix into $t2

read_strint:
lb $t0,($t1)
addi $t1,$t1,1
beq $t0,0,strint_end

#if char is below '0' or above '9', it is outside the range of these and is not a digit
blt $t0,'0',not_digit
bgt $t0,'9',not_digit

#but if it is a digit, then correct and process the character
is_digit:
and $t0,$t0,0xF
j process_char

not_digit:
#it isn't a digit, but it could be perhaps and alphabet character
#which is a digit in a higher base

#if char is below 'A' or above 'Z', it is outside the range of these and is not capital letter
blt $t0,'A',not_upper
bgt $t0,'Z',not_upper

is_upper:

sub $t0,$t0,'A'
addi $t0,$t0,10
j process_char

not_upper:

#if char is below 'a' or above 'z', it is outside the range of these and is not lowercase letter
blt $t0,'a',not_lower
bgt $t0,'z',not_lower

is_lower:

sub $t0,$t0,'a'
addi $t0,$t0,10
j process_char

not_lower:

#if we have reached this point, result invalid and end function
#this is only reached if the byte was not a valid digit or alphabet character
j strint_end

process_char:

bgt $t0,$t2 strint_end #;if this value is above or equal to radix, it is too high despite being a valid digit/alpha

mul $s0,$s0,$t2 # multiply $s0 by the radix
add $s0,$s0,$t0     # add the correct value of this digit

j read_strint # jump back and continue the loop if nothing has exited it

strint_end:

jr $ra