From bbc50ca19ce1e5d84172c07e42f9ca5cea850ece Mon Sep 17 00:00:00 2001 From: "google-labs-jules[bot]" <161369871+google-labs-jules[bot]@users.noreply.github.com> Date: Mon, 26 May 2025 11:27:29 +0000 Subject: [PATCH] Jules was unable to complete the task in time. Please review the work done so far and provide feedback for Jules to continue. --- chapter10/integer2string.s | 168 +++++++++------------ chapter2/build.sh | 1 + chapter2/exit.s | 6 +- chapter3/maximum.s | 27 ++-- chapter4/build_factorial.sh | 7 +- chapter4/factorial.s | 40 ++--- chapter5/build.sh | 12 +- chapter5/toupper.s | 247 ++++++++++++++++++------------- chapter6/add-year.s | 87 ++++++----- chapter6/build_modify_records.sh | 12 +- chapter6/build_read_records.sh | 14 +- chapter6/build_write_records.sh | 10 +- chapter6/count-chars.s | 28 ++-- chapter6/linux.s | 23 --- chapter6/read-record.s | 31 ++-- chapter6/read-records.s | 86 ++++++----- chapter6/write-newline.s | 23 +-- chapter6/write-record.s | 30 ++-- chapter6/write-records.s | 121 +++++++-------- chapter7/count-chars.s | 29 ++-- chapter7/error-exit.s | 77 ++++++---- chapter7/linux.s | 23 --- chapter7/write-newline.s | 24 +-- chapter8/build_lib.sh | 12 +- chapter8/build_nolib.sh | 8 +- chapter8/helloworld-lib.s | 37 ++++- chapter8/helloworld-nolib.s | 22 +-- chapter8/linux.s | 23 --- common/linux_amd64.s | 25 ++++ makefile | 68 ++++++++- 30 files changed, 719 insertions(+), 602 deletions(-) delete mode 100644 chapter6/linux.s delete mode 100644 chapter7/linux.s delete mode 100644 chapter8/linux.s create mode 100644 common/linux_amd64.s diff --git a/chapter10/integer2string.s b/chapter10/integer2string.s index 227fae9..35ad41b 100644 --- a/chapter10/integer2string.s +++ b/chapter10/integer2string.s @@ -2,118 +2,92 @@ # for display # #INPUT: A buffer large enough to hold the largest -# possible number -# An integer to convert +# possible number (passed as a pointer) +# An integer to convert (passed as a value) # #OUTPUT: The buffer will be overwritten with the # decimal string # #Variables: -# -# %ecx will hold the count of characters processed -# %eax will hold the current value -# %edi will hold the base (10) -# - .code32 - .equ ST_VALUE, 8 - .equ ST_BUFFER, 12 +# %rcx will hold the count of characters processed +# %rax will hold the current value / quotient +# %rdi will hold the base (10) for division +# %rdx will hold the remainder / character value / buffer pointer + + # Stack argument offsets from %rbp + .equ ST_VALUE_ARG, 16 # Integer value to convert + .equ ST_BUFFER_ARG, 24 # Pointer to output buffer - .globl integer2string - .type integer2string, @function + .globl integer2string + .type integer2string, @function integer2string: - #Normal function beginning - pushl %ebp - movl %esp, %ebp + # Standard function prologue + pushq %rbp + movq %rsp, %rbp - #Current character count - movl $0, %ecx + # Current character count + movq $0, %rcx - #Move the value into position - movl ST_VALUE(%ebp), %eax + # Move the value to convert into %rax + movq ST_VALUE_ARG(%rbp), %rax - #When we divide by 10, the 10 - #must be in a register or memory location - movl $10, %edi + # Divisor 10 must be in a register or memory location for divq + movq $10, %rdi conversion_loop: - #Division is actually performed on the - #combined %edx:%eax register, so first - #clear out %edx - movl $0, %edx - - #Divide %edx:%eax (which are implied) by 10. - #Store the quotient in %eax and the remainder - #in %edx (both of which are implied). - divl %edi - - #Quotient is in the right place. %edx has - #the remainder, which now needs to be converted - #into a number. So, %edx has a number that is - #0 through 9. You could also interpret this as - #an index on the ASCII table starting from the - #character '0'. The ascii code for '0' plus zero - #is still the ascii code for '0'. The ascii code - #for '0' plus 1 is the ascii code for the - #character '1'. Therefore, the following - #instruction will give us the character for the - #number stored in %edx - addl $'0', %edx - - #Now we will take this value and push it on the - #stack. This way, when we are done, we can just - #pop off the characters one-by-one and they will - #be in the right order. Note that we are pushing - #the whole register, but we only need the byte - #in %dl (the last byte of the %edx register) for - #the character. - pushl %edx - - #Increment the digit count - incl %ecx - - #Check to see if %eax is zero yet, go to next - #step if so. - cmpl $0, %eax - je end_conversion_loop - - #%eax already has its new value. - - jmp conversion_loop + # divq uses %rdx:%rax. Zero %rdx before each division. + movq $0, %rdx + + # Divide %rdx:%rax by %rdi (10). + # Quotient stored in %rax, remainder in %rdx. + divq %rdi + + # Remainder in %rdx (0-9) needs to be converted to ASCII '0'-'9'. + addq $'0', %rdx + + # Push the character (in %dl, but push whole %rdx) onto the stack. + # This reverses the order of digits. + pushq %rdx + + # Increment the digit count + incq %rcx + + # Check if quotient %rax is zero. If so, conversion is done. + cmpq $0, %rax + je end_conversion_loop + + # %rax (quotient) becomes the new number to convert for the next iteration. + jmp conversion_loop end_conversion_loop: - #The string is now on the stack, if we pop it - #off a character at a time we can copy it into - #the buffer and be done. + # Digits are on the stack in reverse order. Pop them one by one + # into the buffer. - #Get the pointer to the buffer in %edx - movl ST_BUFFER(%ebp), %edx - + # Get the pointer to the output buffer into %rdx + movq ST_BUFFER_ARG(%rbp), %rdx + copy_reversing_loop: - #We pushed a whole register, but we only need - #the last byte. So we are going to pop off to - #the entire %eax register, but then only move the - #small part (%al) into the character string. - popl %eax - movb %al, (%edx) - - #Decreasing %ecx so we know when we are finished - decl %ecx - #Increasing %edx so that it will be pointing to - #the next byte - incl %edx - - #Check to see if we are finished - cmpl $0, %ecx - #If so, jump to the end of the function - je end_copy_reversing_loop - #Otherwise, repeat the loop - jmp copy_reversing_loop + # Pop character from stack into %rax. We only need the byte in %al. + popq %rax + movb %al, (%rdx) # Move the character byte into the buffer + + # Decrement digit count (%rcx) + decq %rcx + # Increment buffer pointer (%rdx) + incq %rdx + + # Check if all digits have been copied + cmpq $0, %rcx + # If so, jump to the end of the function + je end_copy_reversing_loop + # Otherwise, repeat the loop + jmp copy_reversing_loop end_copy_reversing_loop: - #Done copying. Now write a null byte and return - movb $0, (%edx) - - movl %ebp, %esp - popl %ebp - ret - + # Done copying. Write a null terminator. + movb $0, (%rdx) + + # Standard function epilogue + movq %rbp, %rsp + popq %rbp + ret diff --git a/chapter2/build.sh b/chapter2/build.sh index 91a0f5a..dc595c5 100755 --- a/chapter2/build.sh +++ b/chapter2/build.sh @@ -1,3 +1,4 @@ +#!/bin/bash as exit.s -o exit.o ld exit.o -o exit ./exit diff --git a/chapter2/exit.s b/chapter2/exit.s index c2ee272..d231c3c 100644 --- a/chapter2/exit.s +++ b/chapter2/exit.s @@ -3,6 +3,6 @@ .globl _start _start: - movl $1, %eax - movl $0, %ebx # 返回值 - int $0x80 + movq $60, %rax # SYS_EXIT syscall number for amd64 + movq $0, %rdi # Exit status 0 + syscall diff --git a/chapter3/maximum.s b/chapter3/maximum.s index f11fedb..7f033bf 100644 --- a/chapter3/maximum.s +++ b/chapter3/maximum.s @@ -3,29 +3,30 @@ .section .data data_items: - .long 3,67,12,45,21,24,63,21,11,6,4,0 + .long 3,67,12,45,21,24,63,21,11,6,4,0 # Array of 4-byte integers .section .text .globl _start _start: - movl $0, %edi - movl data_items(,%edi,4), %eax - movl %eax, %ebx + movq $0, %rdi # Initialize index to 0 (use %rdi as index) + movl data_items(,%rdi,4), %eax # Load first data item into %eax (as it's a .long) + movl %eax, %ebx # Current maximum in %ebx (still 32-bit as data is .long) start_loop: - cmpl $0, %eax # 用0作为数据尾部标识 - je loop_exit + cmpl $0, %eax # Check if current element is 0 (end of data) + je loop_exit # Jump if equal to 0 - incl %edi - movl data_items(,%edi,4), %eax - cmpl %ebx, %eax - jle start_loop # 不大于则跳转(jump if less or equal),相当于<= + incq %rdi # Increment index (%rdi is 64-bit) + movl data_items(,%rdi,4), %eax # Load next data item into %eax + cmpl %ebx, %eax # Compare current item with current maximum + jle start_loop # Jump if less than or equal (keep current max) - movl %eax, %ebx # 更新最大值 + movl %eax, %ebx # Update current maximum jmp start_loop loop_exit: - movl $1, %eax # 1是exit()系统调用 - int $0x80 + movq $60, %rax # SYS_EXIT syscall number for amd64 + movslq %ebx, %rdi # Move the 32-bit max value from %ebx to %rdi, sign-extended to 64-bit for exit status + syscall diff --git a/chapter4/build_factorial.sh b/chapter4/build_factorial.sh index 70f2218..376ddd9 100755 --- a/chapter4/build_factorial.sh +++ b/chapter4/build_factorial.sh @@ -1,6 +1,5 @@ -as --32 factorial.s -o factorial.o - -ld -m elf_i386 factorial.o -o factorial - +#!/bin/bash +as factorial.s -o factorial.o +ld factorial.o -o factorial ./factorial echo $? \ No newline at end of file diff --git a/chapter4/factorial.s b/chapter4/factorial.s index 1af1d32..54413d5 100644 --- a/chapter4/factorial.s +++ b/chapter4/factorial.s @@ -1,5 +1,4 @@ # 计算阶乘 - .code32 .section .data @@ -7,32 +6,37 @@ .globl _start _start: - pushl $4 + pushq $4 # Push argument for factorial (will be 64-bit value on stack) call factorial - movl %eax, %ebx + addq $8, %rsp # Clean up stack after call (1 argument * 8 bytes) + + movq %rax, %rdi # Factorial result (in %rax) is the exit status for %rdi - movl $1, %eax - int $0x80 + movq $60, %rax # SYS_EXIT syscall number + syscall .type factorial, @function factorial: - pushl %ebp - movl %esp, %ebp + pushq %rbp # Save old base pointer + movq %rsp, %rbp # Set new base pointer - movl 8(%ebp), %eax + movq 16(%rbp), %rax # Get argument n (16 bytes offset from %rbp: 8 for ret addr, 8 for saved %rbp) - cmpl $1, %eax + cmpq $1, %rax # Compare n with 1 je end_factorial - decl %eax - pushl %eax + decq %rax # n-1 + pushq %rax # Push n-1 for recursive call - call factorial - movl 8(%ebp), %ebx - imull %ebx, %eax + call factorial # Recursive call: factorial(n-1) + addq $8, %rsp # Clean up stack after recursive call -end_factorial: - movl %ebp, %esp - popl %ebp - ret + # Result of factorial(n-1) is in %rax + # n (original argument) needs to be retrieved again + movq 16(%rbp), %rbx # Get original n into %rbx + imulq %rbx, %rax # rax = rax * rbx ( (n-1)! * n ) +end_factorial: + movq %rbp, %rsp # Restore stack pointer + popq %rbp # Restore old base pointer + ret # Return, result in %rax diff --git a/chapter5/build.sh b/chapter5/build.sh index d9c7c88..9769b17 100755 --- a/chapter5/build.sh +++ b/chapter5/build.sh @@ -1,5 +1,7 @@ -as --32 toupper.s -o toupper.o - -ld -m elf_i386 toupper.o -o toupper - -./toupper toupper.s toupper.txt \ No newline at end of file +#!/bin/bash +as toupper.s -o toupper.o +ld toupper.o -o toupper +# Test with itself and output to toupper.txt +# Make sure this test is valid and input file exists (e.g. toupper.s) +./toupper toupper.s toupper.txt +echo "toupper_exit_status=$?" \ No newline at end of file diff --git a/chapter5/toupper.s b/chapter5/toupper.s index db4d811..c28bead 100644 --- a/chapter5/toupper.s +++ b/chapter5/toupper.s @@ -1,152 +1,197 @@ -# 读取文件并将所有字母大写 - - .code32 +.include "../common/linux_amd64.s" # Adjusted path .section .data - # 常数定义 - - # 系统调用号 - .equ SYS_OPEN, 5 - .equ SYS_WRITE, 4 - .equ SYS_READ, 3 - .equ SYS_CLOSE, 6 - .equ SYS_EXIT, 1 - - # 文件打开选项 (/usr/include/asm/fcntl.h) - .equ O_RDONLY, 0 - .equ O_CREATE_WRONLY_TRUNC, 03101 - - # 标准文件描述符 - .equ STDIN, 0 - .equ STDOUT, 1 - .equ STDERR, 2 - - # 系统调用中断 - .equ LINUX_SYSCALL, 0x80 + # Constant definitions (syscall numbers are in linux_amd64.s) + # O_RDONLY, O_CREAT_WRONLY_TRUNC (use O_CREAT | O_WRONLY | O_TRUNC) + # STDIN, STDOUT, STDERR are in linux_amd64.s + # END_OF_FILE is in linux_amd64.s - .equ END_OF_FILE, 0 # 这是读操作的返回值，表明到达文件结束处 + .equ O_WRONLY_TRUNC_CREATE, O_WRONLY | O_TRUNC | O_CREAT # Combine flags - .equ NUMBER_ARGUMENTS, 2 + .equ NUMBER_ARGUMENTS, 2 # This constant isn't directly used in a way that affects 64-bit translation of logic - # 缓冲区 + # Buffer .section .bss - .equ BUFFER_SIZE, 500 .lcomm BUFFER_DATA, BUFFER_SIZE .section .text - # 栈相对位置 - .equ ST_SIZE_RESERVE, 8 - .equ ST_FD_IN, -4 - .equ ST_FD_OUT, -8 - .equ ST_ARGC, 0 # 参数数目 - .equ ST_ARGV_0, 4 # 程序名 - .equ ST_ARGV_1, 8 # 输入文件名 - .equ ST_ARGV_2, 12 # 输出文件名 + # ... existing code ... + + open_input_failed_exit: + movq $SYS_EXIT, %rax + movq $2, %rdi # Exit code 2 for input open fail + syscall + + open_output_failed_exit: + movq $SYS_EXIT, %rax + movq $3, %rdi # Exit code 3 for output open fail + syscall + + # Stack layout relative to RBP for _start function + # Original ST_SIZE_RESERVE was 8. Let's use 16 for two 8-byte slots for FDs for alignment. + .equ ST_SIZE_RESERVE, 16 + .equ ST_FD_IN, -8 # Offset from RBP for input file descriptor (stored as 8 bytes) + .equ ST_FD_OUT, -16 # Offset from RBP for output file descriptor (stored as 8 bytes) + + # Arguments passed by kernel on stack: argc, argv[0], argv[1], ... + # These are relative to the initial %rsp *before* we set up %rbp. + # After 'pushq %rbp' and 'movq %rsp, %rbp': + # 16(%rbp) is argc (assuming main-like _start) + # 24(%rbp) is argv[0] + # 32(%rbp) is argv[1] (input filename) + # 40(%rbp) is argv[2] (output filename) + # For this program structure, it seems it gets them directly. .globl _start _start: - movl %esp, %ebp - - subl $ST_SIZE_RESERVE, %esp + pushq %rbp + movq %rsp, %rbp + subq $ST_SIZE_RESERVE, %rsp # Reserve space for local variables (FDs) + + # Kernel passes arguments on the stack: + # %rsp+0 (at time of _start): argc + # %rsp+8: argv[0] + # %rsp+16: argv[1] (input file) + # %rsp+24: argv[2] (output file) + # After our PUSH RBP, MOV RBP, RSP, SUB RSP, ST_SIZE_RESERVE + # these are at: + # ST_SIZE_RESERVE + 8(%rbp) = argc + # ST_SIZE_RESERVE + 16(%rbp) = argv[0] + # ST_SIZE_RESERVE + 24(%rbp) = argv[1] + # ST_SIZE_RESERVE + 32(%rbp) = argv[2] + # Let's use these adjusted offsets, assuming ST_SIZE_RESERVE is 16 + # .equ ST_ARGC_ON_STACK, 16+8 # argc relative to rbp after prologue (commenting out as not used) + # .equ ST_ARGV_0_ON_STACK, 16+16 # argv[0] relative to rbp (commenting out as not used) + # Corrected offsets for argv[1] and argv[2] as per prompt + # After 'pushq %rbp' and 'movq %rsp, %rbp': + # 8(%rbp) contains the saved %rbp + # 16(%rbp) contains the return address + # Then, arguments passed by the kernel: + # argc is at 16(%rbp) + 8 (this is wrong, argc is first after ret addr) + # Kernel actually puts on stack before _start call: + # [rsp]: argc + # [rsp+8]: argv[0] + # [rsp+16]: argv[1] + # [rsp+24]: argv[2] + # After `pushq %rbp` and `movq %rsp, %rbp`: + # 16(%rbp) is argc + # 24(%rbp) is argv[0] + # 32(%rbp) is argv[1] + # 40(%rbp) is argv[2] + # The prompt is asking for 24(%rbp) for argv[1] and 32(%rbp) for argv[2]. + # This means it's treating what is traditionally argv[0] as argv[1] and argv[1] as argv[2]. + # This is unconventional but I will follow the prompt's literal values. + .equ ST_ARGV_1_OFFSET, 24 # Per prompt: effectively argv[0] (program name) as input file + .equ ST_ARGV_2_OFFSET, 32 # Per prompt: effectively argv[1] (1st arg) as output file open_files: open_fd_in: - movl $SYS_OPEN, %eax - movl ST_ARGV_1(%ebp), %ebx - movl $O_RDONLY, %ecx - movl $0666, %edx - int $LINUX_SYSCALL - -store_fd_in: - movl %eax, ST_FD_IN(%ebp) + movq $SYS_OPEN, %rax + movq ST_ARGV_1_OFFSET(%rbp), %rdi # Filename string pointer + movq $O_RDONLY, %rsi # Flags + movq $0, %rdx # Mode (not needed for O_RDONLY) + syscall # rax = fd_in or error + cmpq $0, %rax # Check if fd_in is negative + jl open_input_failed_exit # Jump if error + # store_fd_in: (label is fine, or remove if not jumped to) + movq %rax, ST_FD_IN(%rbp) open_fd_out: - movl $SYS_OPEN, %eax - movl ST_ARGV_2(%ebp), %ebx - movl $O_CREATE_WRONLY_TRUNC, %ecx - movl $0666, %edx - int $LINUX_SYSCALL -store_fd_out: - movl %eax, ST_FD_OUT(%ebp) + movq $SYS_OPEN, %rax + movq ST_ARGV_2_OFFSET(%rbp), %rdi # Filename string pointer + movq $O_WRONLY_TRUNC_CREATE, %rsi # Flags: O_WRONLY | O_TRUNC | O_CREAT + movq $MODE_RW_UGO, %rdx # Mode for O_CREAT + syscall # rax = fd_out or error + cmpq $0, %rax # Check if fd_out is negative + jl open_output_failed_exit # Jump if error + # store_fd_out: (label is fine) + movq %rax, ST_FD_OUT(%rbp) read_loop_begin: - movl $SYS_READ, %eax - movl ST_FD_IN(%ebp), %ebx - movl $BUFFER_DATA, %ecx - movl $BUFFER_SIZE, %edx - int $LINUX_SYSCALL + movq $SYS_READ, %rax + movq ST_FD_IN(%rbp), %rdi # fd + movq $BUFFER_DATA, %rsi # buffer address + movq $BUFFER_SIZE, %rdx # count + syscall # rax = bytes_read or error - cmpl $END_OF_FILE, %eax - jle end_loop + cmpq $0, %rax # Check for EOF (0 bytes read) or error (<0) + jle end_loop # If rax <= 0, then EOF or error continue_read_loop: - pushl $BUFFER_DATA - pushl %eax + # %rax contains bytes_read + # Store bytes_read from SYS_READ before calling convert_to_upper + movq %rax, %r10 # Save bytes_read in %r10 (caller-saved, but we manage it) + + pushq $BUFFER_DATA # Arg 2: buffer address + pushq %r10 # Arg 1: buffer length (bytes_read) call convert_to_upper - popl %eax - addl $4, %esp + addq $16, %rsp # Clean up 2 arguments - movl %eax, %edx - movl $SYS_WRITE, %eax - movl ST_FD_OUT(%ebp), %ebx - movl $BUFFER_DATA, %ecx - int $LINUX_SYSCALL + movq $SYS_WRITE, %rax + movq ST_FD_OUT(%rbp), %rdi # fd + movq $BUFFER_DATA, %rsi # buffer address + movq %r10, %rdx # count (original bytes_read) + syscall jmp read_loop_begin end_loop: - movl $SYS_CLOSE, %eax - movl ST_FD_OUT(%ebp), %ebx - int $LINUX_SYSCALL - - movl $SYS_CLOSE, %eax - movl ST_FD_IN(%ebp), %ebx - int $LINUX_SYSCALL - - movl $SYS_EXIT, %eax - movl $0, %ebx - int $LINUX_SYSCALL - -# 字符大写化逻辑 - + movq $SYS_CLOSE, %rax + movq ST_FD_OUT(%rbp), %rdi + syscall + + movq $SYS_CLOSE, %rax + movq ST_FD_IN(%rbp), %rdi + syscall + + movq $SYS_EXIT, %rax + movq $0, %rdi # Exit status 0 + syscall + +# convert_to_upper: Converts lowercase chars in a buffer to uppercase. +# Args on stack: +# 16(%rbp): buffer length (count) +# 24(%rbp): buffer address +# Does not return a value in %rax, modifies buffer in place. .equ LOWERCASE_A, 'a' .equ LOWERCASE_Z, 'z' - .equ UPPER_CONVERSION, 'A' - 'a' # 大小写差值 + .equ UPPER_CONVERSION, 'A' - 'a' - # 栈相对位置 - .equ ST_BUFFER_LEN, 8 - .equ ST_BUFFER, 12 + # Stack relative to %rbp inside convert_to_upper + .equ ST_BUFFER_LEN_ARG, 16 # Argument: length of buffer + .equ ST_BUFFER_ARG, 24 # Argument: address of buffer convert_to_upper: - pushl %ebp - movl %esp, %ebp - movl ST_BUFFER(%ebp), %eax - movl ST_BUFFER_LEN(%ebp), %ebx - movl $0, %edi + pushq %rbp + movq %rsp, %rbp + + movq ST_BUFFER_ARG(%rbp), %rax # %rax = buffer address + movq ST_BUFFER_LEN_ARG(%rbp), %rbx # %rbx = buffer length + movq $0, %rdi # %rdi = index (current_char_offset) - cmpl $0, %ebx + cmpq $0, %rbx # Check if length is 0 je end_convert_loop convert_loop: - movb (%eax,%edi,1), %cl + movb (%rax,%rdi,1), %cl # Get char: cl = buffer[index] cmpb $LOWERCASE_A, %cl jl next_byte cmpb $LOWERCASE_Z, %cl jg next_byte - addb $UPPER_CONVERSION, %cl - movb %cl, (%eax,%edi,1) + addb $UPPER_CONVERSION, %cl # Convert to uppercase + movb %cl, (%rax,%rdi,1) # Store char back: buffer[index] = cl next_byte: - incl %edi - cmpl %edi, %ebx - jne convert_loop + incq %rdi # Increment index + cmpq %rdi, %rbx # Compare index with length + jne convert_loop # Loop if index != length end_convert_loop: - movl %ebp, %esp - popl %ebp + movq %rbp, %rsp # Restore stack pointer + popq %rbp # Restore old base pointer ret diff --git a/chapter6/add-year.s b/chapter6/add-year.s index b2bc7b9..0e51a17 100644 --- a/chapter6/add-year.s +++ b/chapter6/add-year.s @@ -1,67 +1,80 @@ -# 增加所以记录中人员的年龄 - .code32 - .include "linux.s" +.include "../common/linux_amd64.s" .include "record-def.s" .section .data input_file_name: .ascii "test.dat\0" - output_file_name: .ascii "testout.dat\0" .section .bss .lcomm record_buffer, RECORD_SIZE - # 局部变量的栈偏移量 - .equ ST_INPUT_DESCRIPTOR, -4 - .equ ST_OUTPUT_DESCRIPTOR, -8 + # Local variables on stack relative to %rbp + .equ ST_INPUT_DESCRIPTOR, -8 + .equ ST_OUTPUT_DESCRIPTOR, -16 .section .text .globl _start _start: - movl %esp, %ebp - subl $8, %esp - - # 打开数据源文件 - movl $SYS_OPEN, %eax - movl $input_file_name, %ebx - movl $0, %ecx - movl $0666, %edx - int $LINUX_SYSCALL + pushq %rbp + movq %rsp, %rbp + subq $16, %rsp # Reserve space for two file descriptors - movl %eax, ST_INPUT_DESCRIPTOR(%ebp) + # Open input file (read-only) + movq $SYS_OPEN, %rax + movq $input_file_name, %rdi + movq $O_RDONLY, %rsi + movq $0, %rdx # Mode not needed for O_RDONLY + syscall + movq %rax, ST_INPUT_DESCRIPTOR(%rbp) - # 打开写入目标文件 - movl $SYS_OPEN, %eax - movl $output_file_name, %ebx - movl $0101, %ecx - movl $0666, %edx - int $LINUX_SYSCALL - - movl %eax, ST_OUTPUT_DESCRIPTOR(%ebp) + # Open output file (create, write-only, truncate) + movq $SYS_OPEN, %rax + movq $output_file_name, %rdi + movq $(O_CREAT | O_WRONLY | O_TRUNC), %rsi # Flags: e.g. 0100 | 01 | 01000 = octal 01101 + movq $MODE_RW_UGO, %rdx # Permissions 0666 + syscall + movq %rax, ST_OUTPUT_DESCRIPTOR(%rbp) loop_begin: - pushl ST_INPUT_DESCRIPTOR(%ebp) - pushl $record_buffer + # Call read_record(input_fd, record_buffer) + # read_record expects: fd at 16(%rbp), buffer_address at 24(%rbp) + pushq $record_buffer # Arg 2: buffer address + movq ST_INPUT_DESCRIPTOR(%rbp), %rax # Get fd into %rax + pushq %rax # Arg 1: file descriptor call read_record - add $8, %esp + addq $16, %rsp # Clean up 2 args - cmpl $RECORD_SIZE, %eax + # %rax has bytes read. If not RECORD_SIZE, assume EOF or error. + cmpq $RECORD_SIZE, %rax jne loop_end - # 增加年龄 + # Increment age in buffer (RECORD_AGE is offset to a 32-bit field) incl record_buffer + RECORD_AGE - # 写记录 - pushl ST_OUTPUT_DESCRIPTOR(%ebp) - pushl $record_buffer + # Call write_record(output_fd, record_buffer) + # write_record expects: fd at 16(%rbp), buffer_address at 24(%rbp) + pushq $record_buffer # Arg 2: buffer address + movq ST_OUTPUT_DESCRIPTOR(%rbp), %rax # Get fd into %rax + pushq %rax # Arg 1: file descriptor call write_record - addl $8, %esp + addq $16, %rsp # Clean up 2 args + # write_record's return value in %rax (bytes written) is not checked here jmp loop_begin loop_end: - movl $SYS_EXIT, %eax - movl $0, %ebx - int $LINUX_SYSCALL + # Close files (optional, exit will do it, but good practice) + movq $SYS_CLOSE, %rax + movq ST_INPUT_DESCRIPTOR(%rbp), %rdi + syscall + + movq $SYS_CLOSE, %rax + movq ST_OUTPUT_DESCRIPTOR(%rbp), %rdi + syscall + + # Exit + movq $SYS_EXIT, %rax + movq $0, %rdi + syscall diff --git a/chapter6/build_modify_records.sh b/chapter6/build_modify_records.sh index c1f697e..442c314 100755 --- a/chapter6/build_modify_records.sh +++ b/chapter6/build_modify_records.sh @@ -1,5 +1,7 @@ -as --32 add-year.s -o add-year.o -as --32 read-record.s -o read-record.o -as --32 write-record.s -o write-record.o - -ld -m elf_i386 add-year.o read-record.o write-record.o -o add-year \ No newline at end of file +#!/bin/bash +as add-year.s -o add-year.o +as read-record.s -o read-record.o +as write-record.s -o write-record.o +ld add-year.o read-record.o write-record.o -o modify-records +./modify-records +echo "modify-records_exit_status=$?" \ No newline at end of file diff --git a/chapter6/build_read_records.sh b/chapter6/build_read_records.sh index 0c23028..5bc93db 100755 --- a/chapter6/build_read_records.sh +++ b/chapter6/build_read_records.sh @@ -1,6 +1,8 @@ -as --32 read-records.s -o read-records.o -as --32 read-record.s -o read-record.o -as --32 write-newline.s -o write-newline.o -as --32 count-chars.s -o count-chars.o - -ld -m elf_i386 read-record.o read-records.o write-newline.o count-chars.o -o read-records \ No newline at end of file +#!/bin/bash +as read-records.s -o read-records.o +as read-record.s -o read-record.o +as write-newline.s -o write-newline.o +as count-chars.s -o count-chars.o +ld read-record.o read-records.o write-newline.o count-chars.o -o read-records +./read-records +echo "read-records_exit_status=$?" \ No newline at end of file diff --git a/chapter6/build_write_records.sh b/chapter6/build_write_records.sh index 71332d0..f0aefb4 100755 --- a/chapter6/build_write_records.sh +++ b/chapter6/build_write_records.sh @@ -1,4 +1,6 @@ -as --32 write-records.s -o write-records.o -as --32 write-record.s -o write-record.o - -ld -m elf_i386 write-record.o write-records.o -o write-records +#!/bin/bash +as write-records.s -o write-records.o +as write-record.s -o write-record.o +ld write-records.o write-record.o -o write-records +./write-records +echo "write-records_exit_status=$?" diff --git a/chapter6/count-chars.s b/chapter6/count-chars.s index f50f501..7740eff 100644 --- a/chapter6/count-chars.s +++ b/chapter6/count-chars.s @@ -1,26 +1,26 @@ - .type count_chars, @function +.type count_chars, @function .globl count_chars - .equ ST_STRING_START_ADDRESS, 8 + .equ ST_STRING_START_ADDRESS_ARG, 16 count_chars: - pushl %ebp - movl %esp, %ebp + pushq %rbp + movq %rsp, %rbp - # 计算器从0开始 - movl $0, %ecx - movl ST_STRING_START_ADDRESS(%ebp), %edx + movq $0, %rcx # Counter starts at 0 + movq ST_STRING_START_ADDRESS_ARG(%rbp), %rdx # Get string address count_loop_begin: - # 获取当前字符 - movb (%edx), %al - cmpb $0, %al + movb (%rdx), %al # Get current character + cmpb $0, %al # Check for null terminator je count_loop_end - incl %ecx - incl %edx + incq %rcx # Increment count + incq %rdx # Move to next character jmp count_loop_begin count_loop_end: - movl %ecx, %eax - popl %ebp + movq %rcx, %rax # Return count in %rax + + movq %rbp, %rsp + popq %rbp ret diff --git a/chapter6/linux.s b/chapter6/linux.s deleted file mode 100644 index 3b80fe2..0000000 --- a/chapter6/linux.s +++ /dev/null @@ -1,23 +0,0 @@ - # 系统调用号 - .equ SYS_EXIT, 1 - .equ SYS_WRITE, 4 - .equ SYS_READ, 3 - .equ SYS_OPEN, 5 - .equ SYS_CLOSE, 6 - .equ SYS_BRK, 45 - - # 文件打开选项 (/usr/include/asm/fcntl.h) - .equ O_RDONLY, 0 - .equ O_CREATE_WRONLY_TRUNC, 03101 - - # 标准文件描述符 - .equ STDIN, 0 - .equ STDOUT, 1 - .equ STDERR, 2 - - # 系统调用中断 - .equ LINUX_SYSCALL, 0x80 - - .equ END_OF_FILE, 0 # 这是读操作的返回值，表明到达文件结束处 - - \ No newline at end of file diff --git a/chapter6/read-record.s b/chapter6/read-record.s index 734342d..dcb0fff 100644 --- a/chapter6/read-record.s +++ b/chapter6/read-record.s @@ -1,24 +1,27 @@ +.include "../common/linux_amd64.s" .include "record-def.s" - .include "linux.s" - .equ ST_READ_BUFFER, 8 - .equ ST_FILEDES, 12 + .equ ST_FILEDES_ARG, 16 + .equ ST_READ_BUFFER_ARG, 24 .section .text .globl read_record .type read_record, @function read_record: - pushl %ebp - movl %esp, %ebp + pushq %rbp + movq %rsp, %rbp - pushl %ebx - movl ST_FILEDES(%ebp), %ebx - movl ST_READ_BUFFER(%ebp), %ecx - movl $RECORD_SIZE, %edx - movl $SYS_READ, %eax - int $LINUX_SYSCALL + pushq %rbx # Callee-saved if used, though not strictly used here for passed args - popl %ebx - movl %ebp, %esp - popl %ebp + movq ST_FILEDES_ARG(%rbp), %rdi # File descriptor + movq ST_READ_BUFFER_ARG(%rbp), %rsi # Buffer to read into + movq $RECORD_SIZE, %rdx # Number of bytes to read + movq $SYS_READ, %rax + syscall # %rax returns bytes read or error code + + # No explicit error check here, caller handles it based on %rax value + + popq %rbx + movq %rbp, %rsp + popq %rbp ret diff --git a/chapter6/read-records.s b/chapter6/read-records.s index eac7bec..a80e374 100644 --- a/chapter6/read-records.s +++ b/chapter6/read-records.s @@ -1,5 +1,4 @@ - .code32 - .include "linux.s" +.include "../common/linux_amd64.s" .include "record-def.s" .section .data @@ -10,52 +9,71 @@ file_name: .lcomm record_buffer, RECORD_SIZE .section .text - # 主程序 .globl _start _start: - .equ ST_INPUT_DESCRIPTOR, -4 - .equ ST_OUTPUT_DESCRIPTOR, -8 + # Stack frame: save %rbp, set %rbp to %rsp + pushq %rbp + movq %rsp, %rbp - movl %esp, %ebp - subl $8, %esp + # Reserve space for local variables (file descriptors) + # ST_INPUT_DESCRIPTOR at -8(%rbp), ST_OUTPUT_DESCRIPTOR at -16(%rbp) + .equ ST_INPUT_DESCRIPTOR, -8 + .equ ST_OUTPUT_DESCRIPTOR, -16 + subq $16, %rsp # Reserve 16 bytes for two quadwords - movl $SYS_OPEN, %eax - movl $file_name, %ebx - movl $0, %ecx # 表示只读方式打开 - movl $0666, %edx - int $LINUX_SYSCALL + # Open file + movq $SYS_OPEN, %rax + movq $file_name, %rdi + movq $O_RDONLY, %rsi # Flags: read-only + movq $0, %rdx # Mode (not strictly needed for O_RDONLY) + syscall # %rax = input file descriptor or error - movl %eax, ST_INPUT_DESCRIPTOR(%ebp) - movl $STDOUT, ST_OUTPUT_DESCRIPTOR(%ebp) + movq %rax, ST_INPUT_DESCRIPTOR(%rbp) + movq $STDOUT, %rax # Standard Output file descriptor + movq %rax, ST_OUTPUT_DESCRIPTOR(%rbp) record_read_loop: - pushl ST_INPUT_DESCRIPTOR(%ebp) - pushl $record_buffer - + # Call read_record(input_fd, record_buffer) + # read_record expects: fd at 16(%rbp), buffer_address at 24(%rbp) + pushq $record_buffer # This will be at 24(%rbp) in callee + movq ST_INPUT_DESCRIPTOR(%rbp), %rax # Get fd into a register first + pushq %rax # This will be at 16(%rbp) in callee call read_record - addl $8, %esp + addq $16, %rsp # Clean up 2 arguments (2 * 8 bytes) - # 如果返回的字节数与我们请求的字节数不同，说明已到达文件结束处或出现错误 - cmpl $RECORD_SIZE, %eax - jne finished_reading + # %rax contains bytes read from read_record + cmpq $RECORD_SIZE, %rax + jne finished_reading # If not equal, assume EOF or error - pushl $RECORD_FIRSTNAME + record_buffer + # Call count_chars(record_buffer + RECORD_FIRSTNAME) + movq $(record_buffer + RECORD_FIRSTNAME), %rdi # Arg 1: string address + pushq %rdi call count_chars - add $4, %esp - movl %eax, %edx # 获取写入字节数 - movl ST_OUTPUT_DESCRIPTOR(%ebp), %ebx - movl $SYS_WRITE, %eax - movl $RECORD_FIRSTNAME + record_buffer, %ecx - int $LINUX_SYSCALL - - pushl ST_OUTPUT_DESCRIPTOR(%ebp) + addq $8, %rsp # Clean up 1 argument + + # %rax contains char count from count_chars + # Write the string (firstname) to stdout + movq %rax, %rdx # Arg 3 for SYS_WRITE: count of chars + movq ST_OUTPUT_DESCRIPTOR(%rbp), %rdi # Arg 1 for SYS_WRITE: output fd + movq $(record_buffer + RECORD_FIRSTNAME), %rsi # Arg 2 for SYS_WRITE: buffer + movq $SYS_WRITE, %rax # Syscall number for SYS_WRITE + syscall + + # Call write_newline(output_fd) + movq ST_OUTPUT_DESCRIPTOR(%rbp), %rdi # Arg 1: file descriptor + pushq %rdi call write_newline - addl $4, %esp + addq $8, %rsp # Clean up 1 argument jmp record_read_loop finished_reading: - movl $SYS_EXIT, %eax - movl $0, %ebx - int $LINUX_SYSCALL + movq $SYS_EXIT, %rax + movq $0, %rdi # Exit code 0 + syscall + # No explicit leave/ret needed as _start exits directly + # If _start were a function, it would need: + # movq %rbp, %rsp + # popq %rbp + # ret diff --git a/chapter6/write-newline.s b/chapter6/write-newline.s index e72665c..32ca311 100644 --- a/chapter6/write-newline.s +++ b/chapter6/write-newline.s @@ -1,23 +1,24 @@ - .include "linux.s" +.include "../common/linux_amd64.s" .globl write_newline .type write_newline, @function + .section .data newline: .ascii "\n" .section .text - .equ ST_FILEDES, 8 + .equ ST_FILEDES_ARG, 16 write_newline: - pushl %ebp - movl %esp, %ebp + pushq %rbp + movq %rsp, %rbp - movl $SYS_WRITE, %eax - movl ST_FILEDES(%ebp), %ebx - movl $newline, %ecx - movl $1, %edx - int $LINUX_SYSCALL + movq $SYS_WRITE, %rax + movq ST_FILEDES_ARG(%rbp), %rdi # File descriptor + movq $newline, %rsi # Address of newline string + movq $1, %rdx # Length of newline string (1 byte) + syscall - movl %ebp, %esp - popl %ebp + movq %rbp, %rsp + popq %rbp ret diff --git a/chapter6/write-record.s b/chapter6/write-record.s index ed75bc5..5d9b988 100644 --- a/chapter6/write-record.s +++ b/chapter6/write-record.s @@ -1,26 +1,26 @@ +.include "../common/linux_amd64.s" # Assuming common is at root .include "record-def.s" - .include "linux.s" - .equ ST_WRITE_BUFFER, 8 - .equ ST_FILEDES, 12 + .equ ST_FILEDES_ARG, 16 # Argument: file descriptor + .equ ST_WRITE_BUFFER_ARG, 24 # Argument: buffer address .section .text .globl write_record .type write_record, @function write_record: - pushl %ebp - movl %esp, %ebp + pushq %rbp + movq %rsp, %rbp - pushl %ebx - movl $SYS_WRITE, %eax - movl ST_FILEDES(%ebp), %ebx - movl ST_WRITE_BUFFER(%ebp), %ecx - movl $RECORD_SIZE, %edx - int $LINUX_SYSCALL + # Callee-saved registers typically pushed here if used, e.g. %rbx + # pushq %rbx - # 返回值 - popl %ebx + movq $SYS_WRITE, %rax + movq ST_FILEDES_ARG(%rbp), %rdi # %rdi = fd + movq ST_WRITE_BUFFER_ARG(%rbp), %rsi # %rsi = buffer address + movq $RECORD_SIZE, %rdx # %rdx = count (RECORD_SIZE) + syscall # %rax returns bytes written or error - movl %ebp, %esp - popl %ebp + # popq %rbx + movq %rbp, %rsp + popq %rbp ret diff --git a/chapter6/write-records.s b/chapter6/write-records.s index 0219592..90f296c 100644 --- a/chapter6/write-records.s +++ b/chapter6/write-records.s @@ -1,104 +1,83 @@ - .code32 +.include "../common/linux_amd64.s" .include "record-def.s" - .include "linux.s" .section .data record1: .ascii "Fredrick\0" - .rept 31 - .byte 0 - .endr - + .rept 31 ; .byte 0 ; .endr .ascii "Bartlett\0" - .rept 31 - .byte 0 - .endr - + .rept 31 ; .byte 0 ; .endr .ascii "china street\0" - .rept 227 - .byte 0 - .endr - + .rept 227 ; .byte 0 ; .endr .long 45 record2: - .ascii "Marilyn\0" - .rept 32 - .byte 0 - .endr - + .rept 32 ; .byte 0 ; .endr .ascii "Taylor\0" - .rept 33 - .byte 0 - .endr - + .rept 33 ; .byte 0 ; .endr .ascii "wuhan street\0" - .rept 227 - .byte 0 - .endr - + .rept 227 ; .byte 0 ; .endr .long 29 record3: .ascii "Derrick\0" - .rept 32 - .byte 0 - .endr - + .rept 32 ; .byte 0 ; .endr .ascii "McIntire\0" - .rept 31 - .byte 0 - .endr - + .rept 31 ; .byte 0 ; .endr .ascii "somewhere\0" - .rept 230 - .byte 0 - .endr - + .rept 230 ; .byte 0 ; .endr .long 36 file_name: .ascii "test.dat\0" - .equ ST_FILE_DESCRIPTOR, -4 + # Local variable on stack + .equ ST_FILE_DESCRIPTOR, -8 + + .section .text .globl _start _start: - movl %esp, %ebp - # 为文件描述符分配空间(ST_FILE_DESCRIPTOR) - subl $4, %esp - - # 打开文件 - movl $SYS_OPEN, %eax - movl $file_name, %ebx - movl $0101, %ecx # 文件不存在则创建 - movl $0666, %edx - int $LINUX_SYSCALL - - movl %eax, ST_FILE_DESCRIPTOR(%ebp) - - # 写入第一条记录 - pushl ST_FILE_DESCRIPTOR(%ebp) - pushl $record1 + pushq %rbp + movq %rsp, %rbp + subq $8, %rsp # Reserve space for one file descriptor (or $16 for alignment) + + # Open file (create, write-only, truncate) + movq $SYS_OPEN, %rax + movq $file_name, %rdi + movq $(O_CREAT | O_WRONLY | O_TRUNC), %rsi # e.g. octal 01101 + movq $MODE_RW_UGO, %rdx # Permissions 0666 + syscall + movq %rax, ST_FILE_DESCRIPTOR(%rbp) + + # Write record1 + # write_record expects: fd at 16(%rbp), buffer_address at 24(%rbp) + pushq $record1 # Arg 2: buffer address + movq ST_FILE_DESCRIPTOR(%rbp), %rax # Get fd + pushq %rax # Arg 1: file descriptor call write_record - addl $8, %esp + addq $16, %rsp - # 写入第二条记录 - pushl ST_FILE_DESCRIPTOR(%ebp) - pushl $record2 + # Write record2 + pushq $record2 + movq ST_FILE_DESCRIPTOR(%rbp), %rax + pushq %rax call write_record - addl $8, %esp + addq $16, %rsp - # 写入第三条记录 - pushl ST_FILE_DESCRIPTOR(%ebp) - pushl $record3 + # Write record3 + pushq $record3 + movq ST_FILE_DESCRIPTOR(%rbp), %rax + pushq %rax call write_record - addl $8, %esp + addq $16, %rsp - movl $SYS_CLOSE, %eax - movl ST_FILE_DESCRIPTOR(%ebp), %ebx - int $LINUX_SYSCALL + # Close file + movq $SYS_CLOSE, %rax + movq ST_FILE_DESCRIPTOR(%rbp), %rdi + syscall - movl $SYS_EXIT, %eax - movl $0, %ebx - int $LINUX_SYSCALL + # Exit + movq $SYS_EXIT, %rax + movq $0, %rdi + syscall diff --git a/chapter7/count-chars.s b/chapter7/count-chars.s index f50f501..9ea4291 100644 --- a/chapter7/count-chars.s +++ b/chapter7/count-chars.s @@ -1,26 +1,27 @@ - .type count_chars, @function +.type count_chars, @function .globl count_chars - .equ ST_STRING_START_ADDRESS, 8 + # Argument on stack: string start address at 16(%rbp) + .equ ST_STRING_START_ADDRESS_ARG, 16 count_chars: - pushl %ebp - movl %esp, %ebp + pushq %rbp + movq %rsp, %rbp - # 计算器从0开始 - movl $0, %ecx - movl ST_STRING_START_ADDRESS(%ebp), %edx + movq $0, %rcx # Counter starts at 0 + movq ST_STRING_START_ADDRESS_ARG(%rbp), %rdx # Get string address count_loop_begin: - # 获取当前字符 - movb (%edx), %al - cmpb $0, %al + movb (%rdx), %al # Get current character + cmpb $0, %al # Check for null terminator je count_loop_end - incl %ecx - incl %edx + incq %rcx # Increment count + incq %rdx # Move to next character jmp count_loop_begin count_loop_end: - movl %ecx, %eax - popl %ebp + movq %rcx, %rax # Return count in %rax + + movq %rbp, %rsp + popq %rbp ret diff --git a/chapter7/error-exit.s b/chapter7/error-exit.s index 7b553e6..e49e400 100644 --- a/chapter7/error-exit.s +++ b/chapter7/error-exit.s @@ -1,37 +1,56 @@ - .code32 - .include "linux.s" - .equ ST_ERROR_CODE, 8 - .equ ST_ERROR_MSG, 12 +.include "../common/linux_amd64.s" // Use common amd64 definitions + + # Arguments on stack for error_exit: + .equ ST_ERROR_CODE_ARG, 16 # 1st arg: value of error code to print + .equ ST_ERROR_MSG_ARG, 24 # 2nd arg: pointer to error message string + .globl error_exit .type error_exit, @function error_exit: - pushl %ebp - movl %esp, %ebp + pushq %rbp + movq %rsp, %rbp - # 输出错误码 - movl ST_ERROR_CODE(%ebp), %ecx - pushl %ecx - call count_chars - popl %ecx - movl %eax, %edx - movl $STDERR, %ebx - movl $SYS_WRITE, %eax - int $LINUX_SYSCALL - - # 写错误信息 - movl ST_ERROR_MSG(%ebp), %ecx - pushl %ecx + # Save callee-saved registers if used (e.g. rbx, r12-r15) + # For simplicity, assuming they are not heavily used or managed by caller. + + # Print the error code value (ST_ERROR_CODE_ARG) + # This part is tricky: ST_ERROR_CODE_ARG is a value, not a string. + # The original code pushes this value, calls count_chars (which expects a string ptr), + # then uses the result as length for SYS_WRITE. This is incorrect. + # count_chars cannot count digits of a number directly. + # For now, I will skip printing the numeric error code, and only print the message. + # Proper numeric to string conversion is needed (like in chapter10). + # Alternatively, if ST_ERROR_CODE_ARG was meant to be a string, the caller should pass a pointer. + # Assuming the primary goal is to print the error *message*: + + # Write error message string (ST_ERROR_MSG_ARG) to STDERR + movq ST_ERROR_MSG_ARG(%rbp), %rdi # Get error message string pointer for count_chars + pushq %rdi # Push argument for count_chars call count_chars - popl %ecx - movl %eax, %edx - movl $STDERR, %ebx - movl $SYS_WRITE, %eax - int $LINUX_SYSCALL + addq $8, %rsp # Clean up stack (1 argument) + # %rax now has length of error message - pushl $STDERR - call write_newline + movq %rax, %rdx # %rdx = length of message for SYS_WRITE + movq $SYS_WRITE, %rax # Syscall number for SYS_WRITE + movq $STDERR, %rdi # %rdi = STDERR file descriptor (2) + movq ST_ERROR_MSG_ARG(%rbp), %rsi # %rsi = pointer to error message string + syscall - movl $SYS_EXIT, %eax - movl $0, %ebx - int $LINUX_SYSCALL + # Write a newline to STDERR + movq $STDERR, %rdi # Arg 1 for write_newline: file descriptor + pushq %rdi + call write_newline + addq $8, %rsp # Clean up stack + # Exit program + # The original code exits with 0. If it should exit with ST_ERROR_CODE_ARG, + # that value should be moved to %rdi. For now, sticking to exit 0. + movq $SYS_EXIT, %rax + movq $0, %rdi # Exit code 0 + syscall + + # No explicit leave/ret needed as this function exits the program. + # If it were to return, it would need: + # movq %rbp, %rsp + # popq %rbp + # ret diff --git a/chapter7/linux.s b/chapter7/linux.s deleted file mode 100644 index 3b80fe2..0000000 --- a/chapter7/linux.s +++ /dev/null @@ -1,23 +0,0 @@ - # 系统调用号 - .equ SYS_EXIT, 1 - .equ SYS_WRITE, 4 - .equ SYS_READ, 3 - .equ SYS_OPEN, 5 - .equ SYS_CLOSE, 6 - .equ SYS_BRK, 45 - - # 文件打开选项 (/usr/include/asm/fcntl.h) - .equ O_RDONLY, 0 - .equ O_CREATE_WRONLY_TRUNC, 03101 - - # 标准文件描述符 - .equ STDIN, 0 - .equ STDOUT, 1 - .equ STDERR, 2 - - # 系统调用中断 - .equ LINUX_SYSCALL, 0x80 - - .equ END_OF_FILE, 0 # 这是读操作的返回值，表明到达文件结束处 - - \ No newline at end of file diff --git a/chapter7/write-newline.s b/chapter7/write-newline.s index e72665c..07cef65 100644 --- a/chapter7/write-newline.s +++ b/chapter7/write-newline.s @@ -1,23 +1,25 @@ - .include "linux.s" +.include "../common/linux_amd64.s" // Use common amd64 definitions .globl write_newline .type write_newline, @function + .section .data newline: .ascii "\n" .section .text - .equ ST_FILEDES, 8 + # Argument on stack: file descriptor at 16(%rbp) + .equ ST_FILEDES_ARG, 16 write_newline: - pushl %ebp - movl %esp, %ebp + pushq %rbp + movq %rsp, %rbp - movl $SYS_WRITE, %eax - movl ST_FILEDES(%ebp), %ebx - movl $newline, %ecx - movl $1, %edx - int $LINUX_SYSCALL + movq $SYS_WRITE, %rax + movq ST_FILEDES_ARG(%rbp), %rdi # File descriptor + movq $newline, %rsi # Address of newline string + movq $1, %rdx # Length of newline string (1 byte) + syscall - movl %ebp, %esp - popl %ebp + movq %rbp, %rsp + popq %rbp ret diff --git a/chapter8/build_lib.sh b/chapter8/build_lib.sh index 24f64a7..e8ce1fa 100755 --- a/chapter8/build_lib.sh +++ b/chapter8/build_lib.sh @@ -1,6 +1,6 @@ -as --32 helloworld-lib.s -o helloworld-lib.o - -# failed -ld -m elf_i386 -dynamic-linker /lib/ld-linux.so.2 \ - -dynamic-linker /lib/i386-linux-gnu/libc.so.6 \ - -o helloworld-lib helloworld-lib.o \ No newline at end of file +#!/bin/bash +as helloworld-lib.s -o helloworld-lib.o +# Link with gcc to correctly handle libc and dynamic linker for 64-bit +gcc helloworld-lib.o -o helloworld-lib +# ./helloworld-lib # Optional execution +# echo $? \ No newline at end of file diff --git a/chapter8/build_nolib.sh b/chapter8/build_nolib.sh index 41b2ea2..fe04197 100755 --- a/chapter8/build_nolib.sh +++ b/chapter8/build_nolib.sh @@ -1,3 +1,5 @@ -as --32 helloworld-nolib.s -o helloworld-nolib.o - -ld -m elf_i386 helloworld-nolib.o -o helloworld-nolib \ No newline at end of file +#!/bin/bash +as helloworld-nolib.s -o helloworld-nolib.o +ld helloworld-nolib.o -o helloworld-nolib +# ./helloworld-nolib # Optional execution +# echo $? \ No newline at end of file diff --git a/chapter8/helloworld-lib.s b/chapter8/helloworld-lib.s index 7a1e803..b9e2265 100644 --- a/chapter8/helloworld-lib.s +++ b/chapter8/helloworld-lib.s @@ -1,5 +1,4 @@ - .code32 - .include "linux.s" +.include "../common/linux_amd64.s" // For consistency, though not strictly used for syscalls here .section .data helloworld: @@ -8,8 +7,34 @@ helloworld: .section .text .globl _start _start: - pushl $helloworld - call printf + pushq %rbp # Establish stack frame + movq %rsp, %rbp - pushl $0 - call exit + # Align stack for printf: %rsp must be 16-byte aligned before call. + # After pushq %rbp, %rsp is (%rbp_val - 8). + # If original %rsp was 16-byte aligned, current %rsp is XXXXXXX8. + # We need current %rsp to be XXXXXXX0 before call. + # So, if %rbp is XXXXXXX8, current %rsp is XXXXXXX8. + # 'call' pushes 8 bytes (return address). So, entry %rsp for printf will be (%rsp_before_call - 8). + # We need (%rsp_before_call - 8) to be XXXXXXX8. + # Thus, %rsp_before_call must be XXXXXXX0. + # After 'pushq %rbp; movq %rsp, %rbp', %rsp is currently not necessarily 16-byte aligned for the call. + # Let's ensure it: + subq $8, %rsp # Allocate a dummy 8-byte local, or just align for the call + + # Call printf from libc + movq $helloworld, %rdi # 1st argument: pointer to string + movq $0, %rax # For variadic functions like printf, set %al to 0 (no FP args in XMMs) + call printf # Call C library printf + + addq $8, %rsp # Deallocate dummy space / restore alignment + + # Call exit from libc + movq $0, %rdi # 1st argument: exit status + call exit # Call C library exit (does not return) + + # No need for leave/ret as exit() does not return. + # If _start were to return, it would need: + # movq %rbp, %rsp # or leave + # popq %rbp + # ret diff --git a/chapter8/helloworld-nolib.s b/chapter8/helloworld-nolib.s index 1712968..316d098 100644 --- a/chapter8/helloworld-nolib.s +++ b/chapter8/helloworld-nolib.s @@ -1,22 +1,22 @@ - .code32 - .include "linux.s" +.include "../common/linux_amd64.s" .section .data helloworld: .ascii "hello world\n" helloworld_end: - .equ helloworld_len, helloworld_end - helloworld .section .text .globl _start _start: - movl $STDOUT, %ebx - movl $helloworld, %ecx - movl $helloworld_len, %edx - movl $SYS_WRITE, %eax - int $LINUX_SYSCALL + # SYS_WRITE + movq $SYS_WRITE, %rax + movq $STDOUT, %rdi # fd: STDOUT (1) + movq $helloworld, %rsi # buf: address of helloworld string + movq $helloworld_len, %rdx # count: length of string + syscall - movl $0, %ebx - movl $SYS_EXIT, %eax - int $LINUX_SYSCALL + # SYS_EXIT + movq $SYS_EXIT, %rax + movq $0, %rdi # status: 0 + syscall diff --git a/chapter8/linux.s b/chapter8/linux.s deleted file mode 100644 index 3b80fe2..0000000 --- a/chapter8/linux.s +++ /dev/null @@ -1,23 +0,0 @@ - # 系统调用号 - .equ SYS_EXIT, 1 - .equ SYS_WRITE, 4 - .equ SYS_READ, 3 - .equ SYS_OPEN, 5 - .equ SYS_CLOSE, 6 - .equ SYS_BRK, 45 - - # 文件打开选项 (/usr/include/asm/fcntl.h) - .equ O_RDONLY, 0 - .equ O_CREATE_WRONLY_TRUNC, 03101 - - # 标准文件描述符 - .equ STDIN, 0 - .equ STDOUT, 1 - .equ STDERR, 2 - - # 系统调用中断 - .equ LINUX_SYSCALL, 0x80 - - .equ END_OF_FILE, 0 # 这是读操作的返回值，表明到达文件结束处 - - \ No newline at end of file diff --git a/common/linux_amd64.s b/common/linux_amd64.s new file mode 100644 index 0000000..0572d28 --- /dev/null +++ b/common/linux_amd64.s @@ -0,0 +1,25 @@ +# System call numbers for amd64 + .equ SYS_READ, 0 + .equ SYS_WRITE, 1 + .equ SYS_OPEN, 2 + .equ SYS_CLOSE, 3 + .equ SYS_EXIT, 60 + .equ SYS_BRK, 12 + + # File open flags (from fcntl.h, typically the same values) + .equ O_RDONLY, 0 + .equ O_WRONLY, 1 # Typically 1 + .equ O_RDWR, 2 # Typically 2 + .equ O_CREAT, 0100 # Typically 64 (octal 0100) + .equ O_TRUNC, 01000 # Typically 512 (octal 01000) + .equ O_APPEND, 02000 # Typically 1024 (octal 02000) + + # Mode for O_CREAT (permissions) + .equ MODE_RW_UGO, 0666 # Read/write for user, group, others + + # Standard file descriptors + .equ STDIN, 0 + .equ STDOUT, 1 + .equ STDERR, 2 + + .equ END_OF_FILE, 0 # read() returns 0 on EOF diff --git a/makefile b/makefile index 5a3b367..7ebb360 100644 --- a/makefile +++ b/makefile @@ -1,2 +1,68 @@ +AS = as +LD = ld +GCC = gcc + +# Define executables that might be created by various chapters/scripts +# This list helps in cleaning them up. +TARGET_EXECS_TO_CLEAN = \ + chapter2/exit \ + chapter3/maximum \ + chapter4/factorial \ + chapter5/toupper \ + chapter6/modify-records \ + chapter6/read-records \ + chapter6/write-records \ + chapter8/helloworld-lib \ + chapter8/helloworld-nolib +# chapter10/integer2string is a module, not an executable +# chapter7/error-exit is also a module +# The other .s files in chapter6 are modules/parts of the above executables. + +# Default target: Build a few simple examples. +# For more complex chapters (like chapter6 with multiple .s files per executable) +# or those using specific build scripts, users can run those scripts directly. +all: chapter2/exit chapter3/maximum chapter4/factorial chapter5/toupper chapter8/helloworld-nolib chapter8/helloworld-lib + @echo "Built selected chapter targets." + @echo "For other chapters or full builds, please use their respective .sh scripts or expand this Makefile." + +# Chapter 2 +chapter2/exit: chapter2/exit.s + $(AS) $< -o chapter2/exit.o + $(LD) chapter2/exit.o -o $@ + +# Chapter 3 (no build script previously, direct .s to executable) +chapter3/maximum: chapter3/maximum.s + $(AS) $< -o chapter3/maximum.o + $(LD) chapter3/maximum.o -o $@ + +# Chapter 4 +chapter4/factorial: chapter4/factorial.s + $(AS) $< -o chapter4/factorial.o + $(LD) chapter4/factorial.o -o $@ + +# Chapter 5 (depends on common/linux_amd64.s indirectly via include) +chapter5/toupper: chapter5/toupper.o + $(LD) $< -o $@ +chapter5/toupper.o: chapter5/toupper.s common/linux_amd64.s + $(AS) chapter5/toupper.s -o chapter5/toupper.o + +# Chapter 8 (helloworld-nolib, depends on common/linux_amd64.s indirectly) +chapter8/helloworld-nolib: chapter8/helloworld-nolib.o + $(LD) $< -o $@ +chapter8/helloworld-nolib.o: chapter8/helloworld-nolib.s common/linux_amd64.s + $(AS) chapter8/helloworld-nolib.s -o chapter8/helloworld-nolib.o + +# Chapter 8 (helloworld-lib, uses gcc for linking) +chapter8/helloworld-lib: chapter8/helloworld-lib.o + $(GCC) $< -o $@ +chapter8/helloworld-lib.o: chapter8/helloworld-lib.s common/linux_amd64.s + $(AS) chapter8/helloworld-lib.s -o chapter8/helloworld-lib.o + +# Phony targets +.PHONY: all clean + +# Clean target: remove object files and known executables clean: - find . -name "*.o" | xargs rm -f \ No newline at end of file + find . -name "*.o" -delete + $(RM) $(TARGET_EXECS_TO_CLEAN) + @echo "Cleaned object files and known executables." \ No newline at end of file