.global printregs
.extern u64hex

.option rvc
.option norelax # don't depend on gp being set correctly

.data

regmsg:
.ascii " x1/ra=0x................   x5/t0=0x................   x8/s0=0x................\n"
.ascii " x2/sp=0x................   x6/t1=0x................   x9/s1=0x................\n"
.ascii " x3/gp=0x................   x7/t2=0x................\n"
.ascii " x4/tp=0x................                             x18/s2=0x................\n"
.ascii "                           x14/a4=0x................  x19/s3=0x................\n"
.ascii "x10/a0=0x................  x15/a5=0x................  x20/s4=0x................\n"
.ascii "x11/a1=0x................  x16/a6=0x................  x21/s5=0x................\n"
.ascii "x12/a2=0x................  x17/a7=0x................\n"
.ascii "x13/a3=0x................                             x28/t3=0x................\n"
.ascii "                          x25/ s9=0x................  x29/t4=0x................\n"
.ascii "x22/s6=0x................ x26/s10=0x................  x30/t5=0x................\n"
.ascii "x23/s7=0x................ x27/s11=0x................  x31/t6=0x................\n"
.ascii "x24/s8=0x................\n"
.equ regmsg_size, (.) - regmsg

#  x1 ra      x5 t0    x8 s0/fp
#  x2 sp      x6 t1    x9 s1
#  x3 gp      x7 t2
#  x4 tp               x18 s2
#             x14 a4   x19 s3
#  x10 a0     x15 a5   x20 s4
#  x11 a1     x16 a6   x21 s5
#  x12 a2     x17 a7
#  x13 a3              x28 t3
#            x25 s9    x29 t4
#  x22 s6    x26 s10   x30 t5
#  x23 s7    x27 s11   x31 t6
#  x24 s8
#


#  x1 ra     
#  x2 sp      x5 t0    
#  x3 gp      x6 t1    x8 s0/fp
#  x4 tp      x7 t2    x9 s1
#                               
#  x10 a0     x14 a4   x18 s2
#  x11 a1     x15 a5   x19 s3
#  x12 a2     x16 a6   x20 s4
#  x13 a3     x17 a7   
#                      x28 t3
#  x21 s5    x25 s9    x29 t4
#  x22 s6    x26 s10   x30 t5
#  x23 s7    x27 s11   x31 t6
#  x24 s8    

.text

printregs:
    # this routine is meant for debugging,
    # so we treat all registers as callee-save

    # TODO: consider saving to globals instead of the stack

    # huh. it seems impossible to do anything useful
    # with atomics without using registers
    #
    #    li           t0, 1        # Initialize swap value.
    #  0:lw           t1, (a0)     # Check if lock is held.
    #    bnez         t1, again    # Retry if held.
    #    amoswap.w.aq t1, t0, (a0) # Attempt to acquire lock.
    #    bnez         t1, 0b       # Retry if held.

    # save regs to stack
    sd sp, -8(sp)
    addi sp, sp, -8*7
    sd a0, 0(sp)
    sd a1, 8(sp)
    sd t1, 16(sp)
    sd t2, 24(sp)
    sd t5, 32(sp)
    sd ra, 40(sp)

    # copy string to stack?

    # write registers to string
    la a0, regmsg+9
    ld a1, 40(sp) # x1 / ra
    call u64hex
    addi a0, a0, 16+11
    mv a1, x5 # t0
    call u64hex
    addi a0, a0, 16+11
    mv a1, x8 # s0
    call u64hex

    addi a0, a0, 16+10
    ld a1, 48(sp) # x2/sp
    call u64hex
    addi a0, a0, 16+11
    ld a1, 16(sp) # x6/t1
    call u64hex
    addi a0, a0, 16+11
    mv a1, x9 # s1
    call u64hex

    addi a0, a0, 16+10
    mv a1, x3 # gp
    call u64hex
    addi a0, a0, 16+11
    ld a1, 24(sp) # x7/t2
    call u64hex

    addi a0, a0, 16+10
    mv a1, x4 # tp
    call u64hex
    addi a0, a0, 16+11 + 16+11
    mv a1, x18 # s2
    call u64hex

    addi a0, a0, 16+10 + 16+11
    mv a1, x14 # a4
    call u64hex
    addi a0, a0, 16+11
    mv a1, x19 # s3
    call u64hex

    addi a0, a0, 16+10
    ld a1, 0(sp) # x10/a0
    call u64hex
    addi a0, a0, 16+11
    mv a1, x15 # a5
    call u64hex
    addi a0, a0, 16+11
    mv a1, x20 # s4
    call u64hex

    addi a0, a0, 16+10
    ld a1, 8(sp) # a1
    call u64hex
    addi a0, a0, 16+11
    mv a1, x16 # a6
    call u64hex
    addi a0, a0, 16+11
    mv a1, x21 # s5
    call u64hex

    addi a0, a0, 16+10
    mv a1, x12 # a2
    call u64hex
    addi a0, a0, 16+11
    mv a1, x17 # a7
    call u64hex

    addi a0, a0, 16+10
    mv a1, x13 # a3
    call u64hex
    addi a0, a0, 16+11 + 16+11
    mv a1, x28 # t3
    call u64hex

    addi a0, a0, 16+10 + 16+11
    mv a1, x25 # s9
    call u64hex
    addi a0, a0, 16+11
    mv a1, x29 # t4
    call u64hex

    addi a0, a0, 16+10
    mv a1, x22 # s6
    call u64hex
    addi a0, a0, 16+11
    mv a1, x26 # s10
    call u64hex
    addi a0, a0, 16+11
    ld a1, 32(sp) # x30 / t5
    call u64hex

    addi a0, a0, 16+10
    mv a1, x23 # s7
    call u64hex
    addi a0, a0, 16+11
    mv a1, x27 # s11
    call u64hex
    addi a0, a0, 16+11
    mv a1, x31 # t6
    call u64hex

    addi a0, a0, 16+10
    mv a1, x24 # s8
    call u64hex

    # print string
    li a7, 64 # sys_write
    li a0, 1 # stdout
    la a1, regmsg
    li a2, regmsg_size
    ecall
    
    # restore saved registers
    ld a0, 0(sp)
    ld a1, 8(sp)
    ld t1, 16(sp)
    ld t2, 24(sp)
    ld t5, 32(sp)
    ld ra, 40(sp)
    ld sp, 48(sp)
    ret