summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--smallbrain.s554
1 files changed, 277 insertions, 277 deletions
diff --git a/smallbrain.s b/smallbrain.s
index b293978..748fecc 100644
--- a/smallbrain.s
+++ b/smallbrain.s
@@ -2,7 +2,7 @@
.equ O_RDONLY, 0
.equ EXIT_FAILURE, 1
-# Opcodes
+// Opcodes
ENUM(OP_ADD)
ENUM(OP_SUB)
ENUM(OP_RIGHT)
@@ -32,114 +32,114 @@ bytecode: .quad 0
program: .quad 0
.text
-# ==================
-# Description:
-# The entry point of the program.
-#
-# Args:
-# %rdi: The number of command line arguments
-# %rsi: An array of command line arguments ((%rsi) is the program name)
-#
-# Return:
-# %rax: The programs exit code
-# ==================
+// ==================
+// Description:
+// The entry point of the program.
+//
+// Args:
+// %rdi: The number of command line arguments
+// %rsi: An array of command line arguments ((%rsi) is the program name)
+//
+// Return:
+// %rax: The programs exit code
+// ==================
main:
- # Make sure that the right number of arguments were passed
+ // Make sure that the right number of arguments were passed
cmpl $2, %edi
jne usage
- movq 8(%rsi), %rdi # Move the specified script filename into %rdi
- call read_file # Read the file
- call compile # Compile into bytecode
- call execute # Execute the program
+ movq 8(%rsi), %rdi // Move the specified script filename into %rdi
+ call read_file // Read the file
+ call compile // Compile into bytecode
+ call execute // Execute the program
- # Return successfully
+ // Return successfully
xorl %eax, %eax
ret
-# ==================
-# Description:
-# Read the specified file into a program buffer which the user must later free themselves.
-#
-# Args:
-# %rdi: The scripts filename
-# ==================
+// ==================
+// Description:
+// Read the specified file into a program buffer which the user must later free themselves.
+//
+// Args:
+// %rdi: The scripts filename
+// ==================
read_file:
pushq %rbp
movq %rsp, %rbp
- # Allocate space for local variables
- # 4 bytes for the file descriptor
- # 144 bytes for the struct stat (check `extras/sizeof_struct_stat.c` for numbers)
- # 12 bytes of padding to align %rsp on a 16 byte boundary
+ // Allocate space for local variables
+ // 4 bytes for the file descriptor
+ // 144 bytes for the struct stat (check `extras/sizeof_struct_stat.c` for numbers)
+ // 12 bytes of padding to align %rsp on a 16 byte boundary
subq $160, %rsp
- # Open the file in read-only mode with the open(2) syscall
+ // Open the file in read-only mode with the open(2) syscall
movl $O_RDONLY, %esi
call open
- cmpl $-1, %eax # Check if open(1) returned -1 (it failed)
- je open_die # If so, exit the program
- movl %eax, -4(%rbp) # If not store the file descriptor
+ cmpl $-1, %eax // Check if open(1) returned -1 (it failed)
+ je open_die // If so, exit the program
+ movl %eax, -4(%rbp) // If not store the file descriptor
- movl %eax, %edi # Set the first argument to the file descriptor
- leaq -160(%rbp), %rsi # Set the second argument to the address of the struct stat
- call fstat # Call fstat(2) to populate the struct stat
+ movl %eax, %edi // Set the first argument to the file descriptor
+ leaq -160(%rbp), %rsi // Set the second argument to the address of the struct stat
+ call fstat // Call fstat(2) to populate the struct stat
- # Error check fstat(2) just like open(2)
+ // Error check fstat(2) just like open(2)
cmpl $-1, %eax
je fstat_die
- # Allocate a buffer for the programs contents
- movq -112(%rbp), %rdi # Put st_size (the filesize) in %rdi
- incq %rdi # Make space for the NUL byte
- pushq %rdi # Store the value of %rdi for the next 2 malloc calls
- call malloc # Allocate the memory
- testq %rax, %rax # Check if %rax is NULL
- je malloc_die # If it is then malloc failed and we exit
- movq %rax, (program) # Store the address of the allocated memory in (program)
- addq -112(%rbp), %rax # Point to the last element of the program array
- movb $0, (%rax) # NULL terminate the program
-
- # Allocate a buffer for the bytecode
- popq %rdi # Retrieve %rdi from the stack
- shlq $4, %rdi # Multiply the size of the buffer by 16 to make space for opcodes
- call malloc # Allocate the memory
- movq %rax, (bytecode) # Store the address of the allocated memory in (bytecode)
- testq %rax, %rax # Check if %rax is NULL
- je malloc_die # If it is then malloc failed and we exit
-
- # Get a FILE* from the file descriptor with fdopen(3)
+ // Allocate a buffer for the programs contents
+ movq -112(%rbp), %rdi // Put st_size (the filesize) in %rdi
+ incq %rdi // Make space for the NUL byte
+ pushq %rdi // Store the value of %rdi for the next 2 malloc calls
+ call malloc // Allocate the memory
+ testq %rax, %rax // Check if %rax is NULL
+ je malloc_die // If it is then malloc failed and we exit
+ movq %rax, (program) // Store the address of the allocated memory in (program)
+ addq -112(%rbp), %rax // Point to the last element of the program array
+ movb $0, (%rax) // NULL terminate the program
+
+ // Allocate a buffer for the bytecode
+ popq %rdi // Retrieve %rdi from the stack
+ shlq $4, %rdi // Multiply the size of the buffer by 16 to make space for opcodes
+ call malloc // Allocate the memory
+ movq %rax, (bytecode) // Store the address of the allocated memory in (bytecode)
+ testq %rax, %rax // Check if %rax is NULL
+ je malloc_die // If it is then malloc failed and we exit
+
+ // Get a FILE* from the file descriptor with fdopen(3)
movl -4(%rbp), %edi
movq $read_mode, %rsi
call fdopen
- pushq %rax # Push the FILE* to the stack for the later call to fclose(3)
- movq (program), %r15 # Move the program buffer into %r15
+ pushq %rax // Push the FILE* to the stack for the later call to fclose(3)
+ movq (program), %r15 // Move the program buffer into %r15
-# cmpjeq - Compare Jump Equal Quadword
-# ====================================
-# Compare the value of 'val' to %rax and if they match jump to 'jump'.
+// cmpjeq - Compare Jump Equal Quadword
+// ====================================
+// Compare the value of 'val' to %rax and if they match jump to 'jump'.
.macro cmpjeq val, jump
cmpq \val, %rax
je \jump
.endm
-# cmpjeb - Compare Jump Equal Byte
-# ================================
-# Compare the value of 'val' to %al and if they match jump to 'jump'.
+// cmpjeb - Compare Jump Equal Byte
+// ================================
+// Compare the value of 'val' to %al and if they match jump to 'jump'.
.macro cmpjeb val, jump
cmpb \val, %al
je \jump
.endm
read_file_loop:
- movq -168(%rbp), %rdi # Move the FILE* into %rdi
- call fgetc # Read a character from the file
- cmpl $EOF, %eax # Check if we reached EOF
- je read_file_eof # If we did then end the loop
+ movq -168(%rbp), %rdi // Move the FILE* into %rdi
+ call fgetc // Read a character from the file
+ cmpl $EOF, %eax // Check if we reached EOF
+ je read_file_eof // If we did then end the loop
- # If we match any non-comment character jump to read_file_not_comment
+ // If we match any non-comment character jump to read_file_not_comment
cmpjeb $'+', read_file_not_comment
cmpjeb $'-', read_file_not_comment
cmpjeb $'>', read_file_not_comment
@@ -148,39 +148,39 @@ read_file_loop:
cmpjeb $']', read_file_not_comment
cmpjeb $',', read_file_not_comment
cmpjeb $'.', read_file_not_comment
- # DEFAULT CASE (its a comment we can ignore)
+ // DEFAULT CASE (its a comment we can ignore)
jmp read_file_loop
read_file_not_comment:
- movb %al, (%r15) # Read the character into the program buffer
- incq %r15 # Point to the next empty slot in the buffer
- jmp read_file_loop # Loop again
+ movb %al, (%r15) // Read the character into the program buffer
+ incq %r15 // Point to the next empty slot in the buffer
+ jmp read_file_loop // Loop again
read_file_eof:
- # NUL terminate the buffer
+ // NUL terminate the buffer
movb $0, (%r15)
- # Close the file, don't error check this
+ // Close the file, don't error check this
movq -168(%rbp), %rdi
call fclose
leave
ret
-# ==================
-# Description:
-# Compile the program into a bytecode which is an optimized version of the raw program. Each
-# opcode is a "struct" where the higher 8 bytes are an opcode and the lower 8 are data for
-# the instruction.
-# ==================
+// ==================
+// Description:
+// Compile the program into a bytecode which is an optimized version of the raw program. Each
+// opcode is a "struct" where the higher 8 bytes are an opcode and the lower 8 are data for
+// the instruction.
+// ==================
compile:
- movq (program), %r15 # Store the address of the program pointer into %r15
- movq (bytecode), %r14 # Store the address of the bytecode pointer into %r14
+ movq (program), %r15 // Store the address of the program pointer into %r15
+ movq (bytecode), %r14 // Store the address of the bytecode pointer into %r14
compile_loop:
- # Load the current command into %rax
+ // Load the current command into %rax
movq (%r15), %rax
- # Jump to a different label depending on which instruction we hit
+ // Jump to a different label depending on which instruction we hit
cmpjeb $'+', compile_add
cmpjeb $'-', compile_sub
cmpjeb $'>', compile_right
@@ -191,165 +191,165 @@ compile_loop:
cmpjeb $'.', compile_write
compile_add:
- movq $OP_ADD, (%r14) # Specify the ADD opcode
- movq $1, 8(%r14) # Write the count of '+'s to the data portion
+ movq $OP_ADD, (%r14) // Specify the ADD opcode
+ movq $1, 8(%r14) // Write the count of '+'s to the data portion
compile_add_loop:
- incq %r15 # Move to the next instruction
- cmpb $'+', (%r15) # Check if there is another +
- jne compile_out # If not, exit this loop
- incq 8(%r14) # Increment the accumulator
- jmp compile_add_loop # Loop again
+ incq %r15 // Move to the next instruction
+ cmpb $'+', (%r15) // Check if there is another +
+ jne compile_out // If not, exit this loop
+ incq 8(%r14) // Increment the accumulator
+ jmp compile_add_loop // Loop again
compile_sub:
- movq $OP_SUB, (%r14) # Specify the SUB opcode
- movq $1, 8(%r14) # Write the count of '-'s to the data portion
+ movq $OP_SUB, (%r14) // Specify the SUB opcode
+ movq $1, 8(%r14) // Write the count of '-'s to the data portion
compile_sub_loop:
- incq %r15 # Move to the next instruction
- cmpb $'-', (%r15) # Check if there is another -
- jne compile_out # If not, exit this loop
- incq 8(%r14) # Increment the accumulator
- jmp compile_sub_loop # Loop again
+ incq %r15 // Move to the next instruction
+ cmpb $'-', (%r15) // Check if there is another -
+ jne compile_out // If not, exit this loop
+ incq 8(%r14) // Increment the accumulator
+ jmp compile_sub_loop // Loop again
compile_right:
- movq $OP_RIGHT, (%r14) # Specify the RIGHT opcode
- movq $1, 8(%r14) # Write the count of '>'s to the data portion
+ movq $OP_RIGHT, (%r14) // Specify the RIGHT opcode
+ movq $1, 8(%r14) // Write the count of '>'s to the data portion
compile_right_loop:
- incq %r15 # Move to the next instruction
- cmpb $'>', (%r15) # Check if there is another >
- jne compile_out # If not, exit this loop
- incq 8(%r14) # Increment the accumulator
- jmp compile_right_loop # Loop again
+ incq %r15 // Move to the next instruction
+ cmpb $'>', (%r15) // Check if there is another >
+ jne compile_out // If not, exit this loop
+ incq 8(%r14) // Increment the accumulator
+ jmp compile_right_loop // Loop again
compile_left:
- movq $OP_LEFT, (%r14) # Specify the LEFT opcode
- movq $1, 8(%r14) # Write the count of '<'s to the data portion
+ movq $OP_LEFT, (%r14) // Specify the LEFT opcode
+ movq $1, 8(%r14) // Write the count of '<'s to the data portion
compile_left_loop:
- incq %r15 # Move to the next instruction
- cmpb $'<', (%r15) # Check if there is another <
- jne compile_out # If not, exit this loop
- incq 8(%r14) # Increment the accumulator
- jmp compile_left_loop # Loop again
+ incq %r15 // Move to the next instruction
+ cmpb $'<', (%r15) // Check if there is another <
+ jne compile_out // If not, exit this loop
+ incq 8(%r14) // Increment the accumulator
+ jmp compile_left_loop // Loop again
compile_loop_start:
- # When we reach a '[' the first thing we want to do is check to see if it matches the
- # pattern '[-]'. This pattern is one that sets a memory cell to 0, so we can optimize that.
- movq %r15, %rdi # Compare the current position in the program string
- movq $zero_pattern, %rsi # Compare it against the zero pattern '[-]'
- movl $4, %ecx # We want to compare 3 bytes (the instruction requires +1)
- repe cmpsb # Keep looping CMPSB while bytes match
- jrcxz compile_zero # Jump to compile_zero if the strings matched
-
- movq %r15, %rdi # Move the current instruction pointer into %rdi
- call copy_loop_checker # Call the copy loop checker
- testq %rax, %rax # Check to see if we hit a copy loop
- jz compile_loop_start_normal # If we didn't, this is a regular loop
- movq %rax, %r15 # Otherwise, set %r15 to the new location
- incq %r15 # Then point to the next instruction
+ // When we reach a '[' the first thing we want to do is check to see if it matches the
+ // pattern '[-]'. This pattern is one that sets a memory cell to 0, so we can optimize that.
+ movq %r15, %rdi // Compare the current position in the program string
+ movq $zero_pattern, %rsi // Compare it against the zero pattern '[-]'
+ movl $4, %ecx // We want to compare 3 bytes (the instruction requires +1)
+ repe cmpsb // Keep looping CMPSB while bytes match
+ jrcxz compile_zero // Jump to compile_zero if the strings matched
+
+ movq %r15, %rdi // Move the current instruction pointer into %rdi
+ call copy_loop_checker // Call the copy loop checker
+ testq %rax, %rax // Check to see if we hit a copy loop
+ jz compile_loop_start_normal // If we didn't, this is a regular loop
+ movq %rax, %r15 // Otherwise, set %r15 to the new location
+ incq %r15 // Then point to the next instruction
jmp compile_out
compile_loop_start_normal:
- # Push the address of the loop start to the stack for the next ']'
+ // Push the address of the loop start to the stack for the next ']'
pushq %r14
- movq $OP_LOOP_START, (%r14) # Specify the LOOP_START opcode
- movq $0, 8(%r14) # Zero the data section
- incq %r15 # Increment the instruction pointer
+ movq $OP_LOOP_START, (%r14) // Specify the LOOP_START opcode
+ movq $0, 8(%r14) // Zero the data section
+ incq %r15 // Increment the instruction pointer
jmp compile_out
compile_loop_end:
- popq 8(%r14) # Pop the address of the previous loop start to the data section
- movq $OP_LOOP_END, (%r14) # Push the address of the loop end to the stack
- incq %r15 # Increment the instruction pointer
+ popq 8(%r14) // Pop the address of the previous loop start to the data section
+ movq $OP_LOOP_END, (%r14) // Push the address of the loop end to the stack
+ incq %r15 // Increment the instruction pointer
jmp compile_out
compile_read:
- movq $OP_READ, (%r14) # Specify the READ opcode
- movq $0, 8(%r14) # Zero the data section
- incq %r15 # Increment the instruction pointer
+ movq $OP_READ, (%r14) // Specify the READ opcode
+ movq $0, 8(%r14) // Zero the data section
+ incq %r15 // Increment the instruction pointer
jmp compile_out
compile_write:
- movq $OP_WRITE, (%r14) # Specify the WRITE opcode
- movq $0, 8(%r14) # Zero the data section
- incq %r15 # Increment the instruction pointer
+ movq $OP_WRITE, (%r14) // Specify the WRITE opcode
+ movq $0, 8(%r14) // Zero the data section
+ incq %r15 // Increment the instruction pointer
jmp compile_out
compile_zero:
- movq $OP_ZERO, (%r14) # Specify the ZERO opcode
- movq $0, 8(%r14) # Zero the data section
- addq $3, %r15 # '[-]' is a 3 byte instruction
- # FALLTHROUGH
+ movq $OP_ZERO, (%r14) // Specify the ZERO opcode
+ movq $0, 8(%r14) // Zero the data section
+ addq $3, %r15 // '[-]' is a 3 byte instruction
+ // FALLTHROUGH
compile_out:
- addq $16, %r14 # Move to the next opcode
- movb (%r15), %al # Move the current instruction into %al
- testb %al, %al # Check if we have reached the NUL byte
- jne compile_loop # If we haven't, loop
- movq $0, (%r14) # Otherwise, NUL terminate the bytecode
-
- # Now that we have traversed the entire program, we do a 2nd pass backwards so that we can
- # set the jump addresses for the '[' commands now that the ']' commands have the addresses
- # set.
+ addq $16, %r14 // Move to the next opcode
+ movb (%r15), %al // Move the current instruction into %al
+ testb %al, %al // Check if we have reached the NUL byte
+ jne compile_loop // If we haven't, loop
+ movq $0, (%r14) // Otherwise, NUL terminate the bytecode
+
+ // Now that we have traversed the entire program, we do a 2nd pass backwards so that we can
+ // set the jump addresses for the '[' commands now that the ']' commands have the addresses
+ // set.
compile_backwards:
- # We are at the NUL terminator, so move backwards
+ // We are at the NUL terminator, so move backwards
subq $16, %r14
- cmpq $OP_LOOP_END, (%r14) # Check if we hit a ']'
- jne compile_backwards_next # If we didn't move to the next check
- pushq %r14 # Otherwise push the address of the opcode to the stack
+ cmpq $OP_LOOP_END, (%r14) // Check if we hit a ']'
+ jne compile_backwards_next // If we didn't move to the next check
+ pushq %r14 // Otherwise push the address of the opcode to the stack
jmp compile_backwards_out
compile_backwards_next:
- cmpq $OP_LOOP_START, (%r14) # Check if we hit a '['
- jne compile_backwards_out # If we didn't just keep looping
- popq 8(%r14) # If we did then pop the corresponding ']' address
+ cmpq $OP_LOOP_START, (%r14) // Check if we hit a '['
+ jne compile_backwards_out // If we didn't just keep looping
+ popq 8(%r14) // If we did then pop the corresponding ']' address
compile_backwards_out:
- cmpq %r14, (bytecode) # Check if we've seen every opcode
- jne compile_backwards # If not keep looping
- movq (program), %rdi # Otherwise, move the program buffer to %rdi
- call free # Free it
- ret # And return
-
-# ==================
-# Description:
-# Try to figure out if we are at a copy loop and optimize it. A copy loop follows the pattern
-# of a loop ([]) beginning with a '-' followed by N occurances of '>' followed by a '+' and N
-# occurances of '<'. This sequence copies the current cell to the cell at offset N and clears
-# the current cell afterwards.
-#
-# Args:
-# %rdi: A pointer to the first '[' of the potential copy loop
-#
-# Return:
-# 0 if not a copy loop, otherwise the new position of the instruction pointer.
-# ==================
+ cmpq %r14, (bytecode) // Check if we've seen every opcode
+ jne compile_backwards // If not keep looping
+ movq (program), %rdi // Otherwise, move the program buffer to %rdi
+ call free // Free it
+ ret // And return
+
+// ==================
+// Description:
+// Try to figure out if we are at a copy loop and optimize it. A copy loop follows the pattern
+// of a loop ([]) beginning with a '-' followed by N occurances of '>' followed by a '+' and N
+// occurances of '<'. This sequence copies the current cell to the cell at offset N and clears
+// the current cell afterwards.
+//
+// Args:
+// %rdi: A pointer to the first '[' of the potential copy loop
+//
+// Return:
+// 0 if not a copy loop, otherwise the new position of the instruction pointer.
+// ==================
copy_loop_checker:
- # Skip '['
+ // Skip '['
incq %rdi
- # All copy loops must begin with a '-'
+ // All copy loops must begin with a '-'
cmpb $'-', (%rdi)
jne copy_loop_fail
incq %rdi
- # Zero %rax so we can use it to count the copy offset
+ // Zero %rax so we can use it to count the copy offset
xorl %eax, %eax
copy_loop_count_offset:
- cmpb $'>', (%rdi) # Check for '>'
- jne copy_loop_next # If we don't match anymore then move to the next step
- incq %rax # Increment the offset counter
- incq %rdi # Increment the instruction pointer
- jmp copy_loop_count_offset # Loop again
+ cmpb $'>', (%rdi) // Check for '>'
+ jne copy_loop_next // If we don't match anymore then move to the next step
+ incq %rax // Increment the offset counter
+ incq %rdi // Increment the instruction pointer
+ jmp copy_loop_count_offset // Loop again
copy_loop_next:
- cmpb $'+', (%rdi) # Check if we see the mandatory '+'
- jne copy_loop_fail # If we don't then fail
- incq %rdi # Otherwise move to the next instruction
+ cmpb $'+', (%rdi) // Check if we see the mandatory '+'
+ jne copy_loop_fail // If we don't then fail
+ incq %rdi // Otherwise move to the next instruction
- # The following code is the exact same as what we just did to count the offset but we are
- # now using %rcx and decrementing for each '<'. This is so we can make sure that the copy
- # loop is a working one.
+ // The following code is the exact same as what we just did to count the offset but we are
+ // now using %rcx and decrementing for each '<'. This is so we can make sure that the copy
+ // loop is a working one.
cmpb $'<', (%rdi)
jne copy_loop_fail
movq %rax, %rcx
@@ -360,36 +360,36 @@ copy_loop_verify_offset:
incq %rdi
copy_loop_next_2:
- cmpb $']', (%rdi) # Ensure this is the end of the loop
- jne copy_loop_fail # If its not then fail
- testq %rcx, %rcx # Otherwise make sure that our offsets line up
- jnz copy_loop_fail # If they don't then fail
-
- movq $OP_COPY, (%r14) # Create an OP_COPY opcode
- movq %rax, 8(%r14) # Set the offset to copy to
- movq $OP_ZERO, 16(%r14) # Create an OP_ZERO opcode
- movq $0, 24(%r14) # Set an empty data section
- addq $16, %r14 # Increment the opcode pointer
-
- # Return the address of the instruction pointer
+ cmpb $']', (%rdi) // Ensure this is the end of the loop
+ jne copy_loop_fail // If its not then fail
+ testq %rcx, %rcx // Otherwise make sure that our offsets line up
+ jnz copy_loop_fail // If they don't then fail
+
+ movq $OP_COPY, (%r14) // Create an OP_COPY opcode
+ movq %rax, 8(%r14) // Set the offset to copy to
+ movq $OP_ZERO, 16(%r14) // Create an OP_ZERO opcode
+ movq $0, 24(%r14) // Set an empty data section
+ addq $16, %r14 // Increment the opcode pointer
+
+ // Return the address of the instruction pointer
movq %rdi, %rax
ret
copy_loop_fail:
xorl %eax, %eax
ret
-# ==================
-# Description:
-# Execute the brainfuck bytecode.
-# ==================
+// ==================
+// Description:
+// Execute the brainfuck bytecode.
+// ==================
execute:
- movq (bytecode), %r15 # Store the address of the program pointer into %r15
- movq $memory, %r14 # Store the address of the first memory cell into %r14 # TODO make sure this handles overflows normally
+ movq (bytecode), %r15 // Store the address of the program pointer into %r15
+ movq $memory, %r14 // Store the address of the first memory cell into %r14 # TODO make sure this handles overflows normally
execute_loop:
- # Load the current command into %rax
+ // Load the current command into %rax
movq (%r15), %rax
- # Jump to a different label depending on which instruction we hit
+ // Jump to a different label depending on which instruction we hit
cmpjeq $OP_ADD, execute_add
cmpjeq $OP_SUB, execute_sub
cmpjeq $OP_RIGHT, execute_right
@@ -399,87 +399,87 @@ execute_loop:
cmpjeq $OP_READ, execute_read
cmpjeq $OP_WRITE, execute_write
cmpjeq $OP_ZERO, execute_zero
- # OP_COPY
+ // OP_COPY
jmp execute_copy
execute_add:
- # Increment the current memory cell
+ // Increment the current memory cell
movq 8(%r15), %rax
addb %al, (%r14)
jmp execute_out
execute_sub:
- # Decrement the current memory cell
+ // Decrement the current memory cell
movq 8(%r15), %rax
subb %al, (%r14)
jmp execute_out
execute_right:
- # Move the memory pointer right
+ // Move the memory pointer right
addq 8(%r15), %r14
jmp execute_out
execute_left:
- # Move the memory pointer left
+ // Move the memory pointer left
subq 8(%r15), %r14
jmp execute_out
execute_loop_start:
- # If the current memory cell is 0 move to the next ']'
+ // If the current memory cell is 0 move to the next ']'
cmpb $0, (%r14)
cmovzq 8(%r15), %r15
jmp execute_out
execute_loop_end:
- # If the current memory cell is not 0 move to the last '['
+ // If the current memory cell is not 0 move to the last '['
cmpb $0, (%r14)
cmovnzq 8(%r15), %r15
jmp execute_out
execute_read:
- # Set the current cell to the character read from stdin
- call getchar # Read a character with getchar(3)
- cmpb $EOF, %al # Check if the EOF was read
- je execute_read_eof # If EOF was read, jump to a special handler for that
- movb %al, (%r14) # Otherwise move the read character into the current memory cell
+ // Set the current cell to the character read from stdin
+ call getchar // Read a character with getchar(3)
+ cmpb $EOF, %al // Check if the EOF was read
+ je execute_read_eof // If EOF was read, jump to a special handler for that
+ movb %al, (%r14) // Otherwise move the read character into the current memory cell
jmp execute_out
execute_read_eof:
- # If EOF was read, set the current cell to 0
+ // If EOF was read, set the current cell to 0
movb $0, (%r14)
jmp execute_out
execute_write:
- # Print the character at the current memory cell
- movl (%r14), %edi # Move the current memory cell into %edi
- call putchar # Print it with putchar(3)
+ // Print the character at the current memory cell
+ movl (%r14), %edi // Move the current memory cell into %edi
+ call putchar // Print it with putchar(3)
jmp execute_out
execute_zero:
- # Zero the current cell
+ // Zero the current cell
movb $0, (%r14)
jmp execute_out
execute_copy:
- # Copy the current memory cells contents elsewhere
+ // Copy the current memory cells contents elsewhere
movq 8(%r15), %rax
movb (%r14), %cl
movb %cl, (%rax, %r14, 1)
- # FALLTHROUGH
+ // FALLTHROUGH
execute_out:
- addq $16 , %r15 # Increment the instruction pointer
- movq (%r15), %rax # Move the current instruction into %rax
- testq %rax, %rax # Check if we have reached the NUL byte
- jne execute_loop # If we haven't, loop
- ret # Otherwise, return
-
-# ==================
-# Description:
-# The following die functions all work the same. They simply take the name of the
-# corresponding function and store it in %rdi. Then the die function is called to print a
-# message to stderr and terminate the program.
-# ==================
+ addq $16 , %r15 // Increment the instruction pointer
+ movq (%r15), %rax // Move the current instruction into %rax
+ testq %rax, %rax // Check if we have reached the NUL byte
+ jne execute_loop // If we haven't, loop
+ ret // Otherwise, return
+
+// ==================
+// Description:
+// The following die functions all work the same. They simply take the name of the
+// corresponding function and store it in %rdi. Then the die function is called to print a
+// message to stderr and terminate the program.
+// ==================
.macro fdie s
movq \s, %rdi
@@ -492,46 +492,46 @@ read_die: fdie $func_read
malloc_die: fdie $func_malloc
-# ==================
-# Description:
-# Print out an error message in the format "<func name>: <err msg>" then exit via `_exit`
-#
-# Args:
-# %rdi: The function name
-# ==================
+// ==================
+// Description:
+// Print out an error message in the format "<func name>: <err msg>" then exit via `_exit`
+//
+// Args:
+// %rdi: The function name
+// ==================
die:
- # Store the function name temporarily in %r15
+ // Store the function name temporarily in %r15
movq %rdi, %r15
- call __errno_location # Call __errno_location to get a pointer to errno
- movq (%rax), %rdi # Move errno into %rdi
- call strerror # Get the error string with strerror(3)
+ call __errno_location // Call __errno_location to get a pointer to errno
+ movq (%rax), %rdi // Move errno into %rdi
+ call strerror // Get the error string with strerror(3)
- movq %rax, %rcx # Set the error string
- xorl %eax, %eax # Zero %rax
- movq %r15, %rdx # Set the function name
- movq $die_fmt, %rsi # Set the format string
- movq stderr, %rdi # Get stderr
- call fprintf # Print the message to stderr
+ movq %rax, %rcx // Set the error string
+ xorl %eax, %eax // Zero %rax
+ movq %r15, %rdx // Set the function name
+ movq $die_fmt, %rsi // Set the format string
+ movq stderr, %rdi // Get stderr
+ call fprintf // Print the message to stderr
jmp _exit
-# ==================
-# Description:
-# Print a usage message to standard error and exit the program via `_exit`
-# ==================
+// ==================
+// Description:
+// Print a usage message to standard error and exit the program via `_exit`
+// ==================
usage:
- xorl %eax, %eax # Set rax to 0
- movq (%rsi), %rdx # Get argv[0]
- movq $usage_fmt, %rsi # Set the format string
- movq stderr, %rdi # Get stderr
- call fprintf # Print the error
- # FALLTHROUGH
-
-# ==================
-# Description:
-# Exit the program with the return code EXIT_FAILURE
-# ==================
+ xorl %eax, %eax // Set rax to 0
+ movq (%rsi), %rdx // Get argv[0]
+ movq $usage_fmt, %rsi // Set the format string
+ movq stderr, %rdi // Get stderr
+ call fprintf // Print the error
+ // FALLTHROUGH
+
+// ==================
+// Description:
+// Exit the program with the return code EXIT_FAILURE
+// ==================
_exit:
movl $EXIT_FAILURE, %eax
call exit