ecal | simple embeddable scripting language | Pub Sub library

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:

This is pretty good in that it works!  Comments:

• As it deals with the string in word sizes — chunks of 4 characters at a time — it is arguably more complicated than the other approach of doing it 1 byte at a time.

• Working with 4 bytes at a time, it ignores whether the string in question starts on a word aligned boundary — while that it does in this program's case, there is no such guarantee for arbitrary strings in general.  Unaligned word-sized loads & stores are subject to certain hazards, and somewhat depends on the underlying processor, ranging from performance issues to access faults.  Fixing the algorithm to accommodating arbitrary alignment, while still working 4 bytes at a time, will add considerable complexity.

• Working with 4 bytes at a time, it potentially reads past the end of the string, into another data structure.  While this is unlikely to cause any problems when a word aligned string is given, it is generally frowned upon reading past the end of a data structure, and if the processor supports unaligned loads, this have the undesired effect of reading into the next cache line or page not part of the string itself.

Yes, you have found the boundary of what signed 32-bit integers can hold.

• fib(47) = 2971215073 won't fit in 32-bit integers as signed, but will fit as unsigned — however, RARS does not have an "unsigned int" print function.

• fib(48) = 4807526976 won't fit in 32-bit form, even as unsigned.

List of fibonacci numbers: https://www.math.net/list-of-fibonacci-numbers

If you want to represent larger numbers, you will need a strategy.

• if precision is not important, you can switch to floating point, where the results with such large numbers will be inexact.

• use two integers together for 64-bit arithmetic — you'll be good up to fib(92) = 7540113804746346429.

• use variable length integers for precision limited only by computer memory and compute time

• a complex combination of the above

And finally, you can detect and issue an error on overflow of your chosen arithmetic data type.  Overflow detection on RISC V is somewhat simple but not really obvious.

Technically, addition of 2 arbitrary 32-bit numbers results in a 33 bit answer — but no more than 33 bits, so we can use that knowledge of math in detecting overflow.

First, in a 32-bit number the top bit is either the sign bit (when signed data type), or the magnitude bit (when unsigned data type).

If you add two positive numbers (as is the case with fib) and the sign bit is set, you have signed overflow — but a proper bit pattern, if interpreted as unsigned.  However, you won't be able to print the number properly using the ecall #1, because it will print the number as signed and interpret as negative.  You can write your own unsigned number print; you can also look for this case and simply stop the program from printing and issue an error instead.

Going beyond that you can check for overflow in 32-bit unsigned addition by seeing if the resulting value is less than one of the input operands.

The last approach is also used in multiword addition to make a carry from the lower word(s) to higher word(s).

addi is used for adding a register and an immediate (thus the "i" at the end), a constant value; such as addi t2, t0, 5 (t2 = t0 + 5). Use add instead; add t2, t0, t1

You are using v0 registers which are only available with vector extension. If you toolchain.

The compiler and the "standard" binutils of the gnu toolchain don't seem supporting it yet. There is a dedicated binutils branch https://github.com/riscv/riscv-binutils-gdb/tree/rvv-1.0.x.

LLVM also is not supporting it also. How do I use the RISC-V Vector (RVV) instructions in LLVM IR?

You are printing only posTotal and negTotal. You need to print also positiveSum and negativeSum after converting them to ascii format.

I don't known how your ecall works , but you need to add two calls to ecall when you put the ascii from of your Sums in a0 (this solution will always work), or if the ecall can take more than one argument place the Sum as the second argument by using a1.

You got Negative Integers Total: printed twice because you did not add \0 at the end of your strings, so the first time you print the first string but continue printing until you found an \0.

I recommend you add an alignment directive between your strings like .balign 4.

This program is supposed to take each element of an array of 5 word and multiply it with the first word after the array, then divide the result with the second element after the array. However there is some problems:
1- you need to add com between the words of the array.
2- you need to declare main as a global function, so that the linker can find it. Otherwise you will have an undefined reference error.
3- the lui s0, 0x10010 could be problematic. Are you sure the linker will put array at this address? Did you modified the linker script to force it? IF you are not sure of what the linker will do . It will be better to declare array as an object and use it directly with and lui + addi.

The code will be:

x0 is hard-wired to 0. It never makes sense to li into it. https://en.wikichip.org/wiki/risc-v/registers.

Whatever register the ecall handler looks in for a system-call number, it's not x0. Check the documentation for whatever you're using. (e.g. RARS system-calls use a7, the same way that MARS used the MIPS register $v0 (not MIPS $0, the zero register))

Also generally a bad idea to mix x1 and t0 / s0 register names. Easy to accidentally use 2 different names for the same register and have your code overwrite its own data.

In a previous version of the question you had:

Note: RISC-V multiply and divide instructions do not support immediates (constants). Therefore, all numeric values are to be defined in and loaded from memory

That's weird, the "therefore" doesn't really follow.

li reg, constant is still cheaper than lw, especially for a small integer. But if your assignment said you had to do it the stupid way, with data memory instead of foo = 5 or .equ assemble-time symbolic constants, then you have to. You can define your constants in one place, but then still use them as immediates, if your assembler doesn't suck.

I was able to get all of your testbench cases to pass in a RISC-V simulator with 3 changes:

(1) Your second test case has the wrong expected result. I'm assuming you're using 0-indexed Fibonacci numbers, since that's what most of your test cases do (e.g. test case 1 says Fibonacci number 1 is 1, test case 3 says Fibonacci number 7 is 13). In that case, Fibonacci number 3 should be 2, not 3.

(2) To get the correct number of iterations, in your loop, your "i" variable / register a4 should begin set to 1, not 2.

(3) You generally don't use ECALL to return from a function in RISC-V. As per the RISC-V spec, "the ECALL instruction is used to make a service request to the execution environment." It causes a precise trap and is used (for example) when implementing syscalls. Instead, there is the pseudoinstruction ret to return from a function call (similar notation to x86). ret is equivalent to jalr x0 0(ra). (That being said, maybe you've defined ecall behavior such that when a7 is 93, the equivalent of a ret is executed.)