ARM Assembly: Printing Integer Numbers Instead of ASCII Representation

ARM Assembly Integer-to-ASCII Conversion for System Output

The core issue revolves around the inability to directly print integer values to the screen in ARM assembly. Instead of displaying the numeric value, the system outputs the ASCII representation of the integer, which is not the desired behavior. For example, when attempting to print the integer 99, the output is the ASCII character 'c', as the value 99 corresponds to the ASCII code for 'c'. This problem arises because the system call used for printing (sys_write) interprets the data as a string of characters rather than a numeric value. To resolve this, a conversion mechanism must be implemented to transform the integer into its ASCII string representation before passing it to the system call.

The challenge lies in the fact that ARM assembly does not provide built-in functions for integer-to-ASCII conversion, unlike higher-level languages such as C. This requires the programmer to manually implement the conversion logic, which involves breaking down the integer into its individual digits, converting each digit to its corresponding ASCII value, and then constructing a string that can be passed to the system call. This process must be efficient and handle edge cases such as negative numbers and leading zeros.

Misuse of System Calls and Lack of Integer-to-String Conversion Logic

The primary cause of the issue is the misuse of the sys_write system call, which is designed to output strings rather than raw integers. When the integer 99 is stored in memory and passed directly to sys_write, the system interprets the binary representation of 99 as an ASCII character, resulting in the output 'c'. This behavior is expected because sys_write does not perform any conversion on the data; it simply outputs the bytes as they are.

Another contributing factor is the absence of integer-to-string conversion logic in the provided code. In higher-level languages, functions like printf or itoa handle this conversion automatically, but in ARM assembly, this functionality must be implemented manually. The conversion process involves dividing the integer by 10 repeatedly to extract each digit, converting each digit to its ASCII equivalent by adding 48 (the ASCII value of '0'), and storing the resulting characters in a buffer. This buffer can then be passed to sys_write for output.

Additionally, the code does not account for the endianness of the system, which can affect how multi-byte integers are stored in memory. While this is not directly related to the conversion issue, it is an important consideration when working with low-level programming languages like assembly. Ensuring that the integer is stored correctly in memory is crucial for accurate conversion and output.

Implementing Integer-to-ASCII Conversion and Correct System Call Usage

To resolve the issue, the following steps must be taken:

1. Implement Integer-to-ASCII Conversion Logic:

   • Create a function that takes an integer as input and converts it to its ASCII string representation. This function should handle both positive and negative integers.
   • Use a loop to divide the integer by 10 repeatedly, extracting each digit and converting it to its ASCII equivalent.
   • Store the resulting characters in a buffer in reverse order, as the digits are extracted from least significant to most significant.
   • Add a null terminator to the buffer to create a valid C-style string.

2. Modify the System Call to Output the Converted String:

   • Pass the address of the buffer containing the ASCII string to the sys_write system call.
   • Ensure that the length parameter passed to sys_write corresponds to the number of characters in the converted string, excluding the null terminator.

3. Handle Edge Cases:

   • Account for the case where the integer is zero, as this requires special handling to avoid an empty output.
   • Ensure that negative integers are correctly represented by adding a '-' character at the beginning of the string.
   • Remove any leading zeros from the output to maintain readability.

Below is an example implementation of the integer-to-ASCII conversion function in ARM assembly:

.global _start
.text
_start:
    mov r8, #99              @ Load the integer to be printed into r8
    ldr r9, =buffer          @ Load the address of the buffer into r9
    bl int_to_ascii          @ Call the conversion function
    bl print_string          @ Call the function to print the string
    b _end                   @ Jump to the end of the program

int_to_ascii:
    mov r1, #10              @ Load the divisor (10) into r1
    mov r2, r9               @ Copy the buffer address to r2
    cmp r8, #0               @ Check if the integer is zero
    beq handle_zero          @ Handle the zero case
    cmp r8, #0               @ Check if the integer is negative
    blt handle_negative      @ Handle the negative case

convert_loop:
    udiv r3, r8, r1          @ Divide the integer by 10
    mls r4, r3, r1, r8       @ Calculate the remainder
    add r4, r4, #48          @ Convert the remainder to ASCII
    strb r4, [r2], #1        @ Store the ASCII character in the buffer
    mov r8, r3               @ Update the integer to the quotient
    cmp r8, #0               @ Check if the quotient is zero
    bne convert_loop         @ Repeat until the quotient is zero
    b reverse_buffer         @ Jump to reverse the buffer

handle_zero:
    mov r4, #48              @ Convert zero to ASCII
    strb r4, [r2], #1        @ Store the ASCII character in the buffer
    b reverse_buffer         @ Jump to reverse the buffer

handle_negative:
    mov r4, #45              @ Load the ASCII value of '-'
    strb r4, [r2], #1        @ Store the '-' character in the buffer
    rsb r8, r8, #0           @ Convert the integer to positive

reverse_buffer:
    sub r2, r2, #1           @ Move the buffer pointer back to the last character
    mov r3, r9               @ Copy the buffer address to r3
reverse_loop:
    cmp r2, r3               @ Check if the pointers have crossed
    bge swap_chars           @ Swap the characters if they haven't
    b done_reversing         @ Exit the loop if they have
swap_chars:
    ldrb r4, [r2]            @ Load the character from the end
    ldrb r5, [r3]            @ Load the character from the start
    strb r5, [r2], #-1       @ Store the start character at the end
    strb r4, [r3], #1        @ Store the end character at the start
    b reverse_loop           @ Repeat the loop

done_reversing:
    mov r4, #0               @ Load the null terminator
    strb r4, [r2]            @ Store the null terminator in the buffer
    bx lr                    @ Return from the function

print_string:
    mov r7, #4               @ Load the syscall number for write
    mov r0, #1               @ Load the file descriptor for stdout
    mov r1, r9               @ Load the address of the buffer
    mov r2, #12              @ Load the length of the string
    swi 0                    @ Execute the syscall
    bx lr                    @ Return from the function

_end:
    mov r7, #1               @ Load the syscall number for exit
    swi 0                    @ Execute the syscall

.data
buffer: .space 12            @ Allocate space for the buffer

This implementation includes a function int_to_ascii that converts an integer to its ASCII string representation and stores it in a buffer. The print_string function then outputs the buffer to the screen using the sys_write system call. The code handles both positive and negative integers, as well as the special case of zero. The buffer is reversed after conversion to ensure the digits are in the correct order.

By following these steps and using the provided code as a reference, the issue of printing integers instead of their ASCII representation can be effectively resolved in ARM assembly.