How to output an integer to screen risc-v assembly

Question

The following is the assembly I have used in an attempt to print to console:

global _start

_start:
  addi   a0, x0, 1
  addi   a1, x0, 42
  addi   a7, x0, 63
  ecall

  addi   a0, x0, 0
  addi   a7, x0, 93
  ecall

.data
num:
  .byte 6  

I compiled with

riscv64-unknown-elf-as  -o example.o  example.S
riscv64-unknown-elf-ld  -o example  example.o

and run using spike and proxy kernel

spike pk example

No output is generated.

This works on https://www.kvakil.me/venus/ with

  addi   a0, x0, 1
  addi   a1, x0, 42
  ecall

and prints 42.

Also, if I wanted to print the contents of num in the data segment, how would I go about it?

Answer 1

I managed a solution from Peter Cordes' answer. I am posting the implementation here in case someone needs it and for my own reference.

UPDATE:

Steps:

1. Given a signed number, get its absolute value, if the number is negative, make a note of it through a variable.
2. Choose an end address position justified by the next point.
3. Perform repeated division and store the reminder in the appropriate memory location.
4. If the number is negative add '-' at the beginning.
5. Get length by subtracting first address from the end. Then call appropriate system call.

System calls can be found here.

C code logically mirrors the assembly

#include <unistd.h>

void num_print(long num){
    unsigned int base = 10;
    int sign_bit = 0;

    char string[20];
    char* end = string + 19;
    char* p   = end;
    *p = '\n';
    
    if (num < 0){
        num = 0 - num;
        sign_bit = 1;
    }

    do {
        *(--p) = (num % base) + '0';
        num /= base;
    } while (num);

    if (sign_bit)
        *(--p) = '-';
    
    size_t len = end - p;
    write(1, p, len + 1);
}

int main(){
    int arr[3] = {1234567, -1234567, 0};
    for (int i=0; i < 3; i++){
        num_print(arr[i]);
    }
    return 0;
}

Risc-v Assembly

.global _start

.text
_start:
    la           s1, arr          # s1: load arr address
    addi         s2, zero, 3      # s2: arr length

    addi         sp, sp, -8       # push 1 item to stack 
    sd           ra, 0(sp)        # save return address
    mv           s3, zero         # s3: i loop counter  
    j            compare_ipos

L1:
    slli         s4, s3, 3        # s4: i * 8
    add          s5, s1, s4       # s5: address of a[i]
    ld           a0, 0(s5)        # a0: arr[i]
    jal          ra, num_print    # call num_print
    addi         s3, s3, 1        # increment i

compare_ipos:
    blt          s3, s2, L1       # loop if i < 3
    j            exit
 
num_print:
    addi         sp, sp, -40      # create stack space
    sd           s0, 32(sp)       # store frame pointer
    addi         s0, sp, 40       # new frame pointer
  
    addi         t0, zero, 0      # initialize sign_bit
    addi         t1, zero, 10     # divisor and new-line char
    addi         t2, s0, -16      # t2: string[n] 
    add          a1, zero, t2     # a1: string[0] currently string[n]
  
    addi         t3, zero, '\n'   # '\n' char
    sb           t3, 0(a1)        # store '\n'
  
    bge          a0, zero, PVE    # if num >= 0 go to L1 else get absolute
    xori         a0, a0, -1       # (num ^ -1)
    addi         a0, a0, 1        # num + 1
    addi         t0, zero, 1      # set sign-bit to 1

PVE:
    remu         t3, a0, t1       # num % 10
    addi         t3, t3, 48       # convert to ascii
    addi         a1, a1, -1       # decrement start pointer
    sb           t3, 0(a1)        # store value
    divu         a0, a0, t1       # num /= 10
    blt          zero, a0, PVE    # if num > 0 loop

    beq          t0, zero, print  # if sign_bit = 0 go to print else, add '-' char
    addi         t3, zero, '-'    # ascii '-'
    addi         a1, a1, -1       # decrement start pointer
    sb           t3, 0(a1)        # store '-'

print:
    sub          t4, t2, a1       # t4: len -- string[n] - string[0]
    addi         a2, t4, 1        # len + 1
    addi         a0, zero, 1      # file descriptor to write to
    addi         a7, zero, 64     #  pk SYS_write
    ecall                         # transfer control to os

    ld           s0, 32(sp)       # restore frame pointer
    addi         sp, sp, 40       # restore stack pointer

    ret                           # return from function        
 
exit:
    ld           ra, 0(sp)        # restore ra
    addi         sp, sp, 8        # pop stack

    addi         a0, zero, 0      # return value
    addi         a7, zero, 93     # syscall exit code
    ecall

.data
arr:
  .dword  12345670, -12345670, 0

Answer 2

System calls depend on the environment. "Toy" systems like Venus or RARS have their own set of toy system calls that do things like print an integer.

In a real-world system like GNU/Linux, true system calls that you can access with ecall can only copy bytes to a file descriptor. If you want to output text, you need to create text in memory in user-space and pass a pointer to a write system call.

Spike + pk is apparently more like Linux, with a POSIX write(2) system call, not like those toy system-call environments where you could pass an integer directly to a print-int ecall. https://www.reddit.com/r/RISCV/comments/dagvzr/where_do_i_find_the_list_of_stdio_system_etc/ has some examples and links. Notably https://github.com/riscv/riscv-pk/blob/master/pk/syscall.h where we find #define SYS_write 64 as the call number (goes in a7) for a write system call.

A write system-call takes args: write(int fd, const void *buf, size_t count).

Formatting a binary integer into an ASCII string is something that library functions like printf will do. Toy systems don't have a library, so they just put a few useful functions as system calls. And if you want control over stuff like leading zeros or padding to a fixed width, you have to write it yourself. But on a system like Spike-pk, you only have simple Unix-like system calls and (perhaps?) no library at all, so you have to always do it yourself.

With just Linux / Unix / Spike-pk system-calls, you'll want to do repeated division by 10 to get the decimal digits of a binary integer. like in How do I print an integer in Assembly Level Programming without printf from the c library? which shows C and x86-64 assembly for Linux:

char *itoa_end(unsigned long val, char *p_end) {
  const unsigned base = 10;
  char *p = p_end;
  do {
    *--p = (val % base) + '0';
    val /= base;
  } while(val);                  // runs at least once to print '0' for val=0.

  // write(1, p,  p_end-p);
  return p;  // let the caller know where the leading digit is
}

Translate to RISC-V assembly (or compile with gcc or clang, e.g. via https://godbolt.org/). Reserving a small buffer on the stack is convenient.

Also, if I wanted to print the contents of num in the data segment, how would I go about it?

lw the number into a register, then do the same thing as above.