ecal | enhanced Communication Abstraction Layer

Using ocalls to return information is not the way to go for this.

While I had failed previously with this Idea, the way to go is by adding a pointer and its size to a functions arguments in order to copy the results.

so Enclave EDL

The questioner is focusing on the problem of getting an actual image to look like material being moved with the wind.

The code presented to do this divides a canvas into small rectangular elements and moves each of those as required by the 'physics' given (value of gravity/wind for example).

The original just draws grid lines for each of these areas. What we need is for the equivalent rectangle in the original image to be copied to that point.

This snippet achieves this by adding a origx/y to the info kept about each point so that we know where to find the original rectangle.

It brings the image into an img element (it is important to wait until this is loaded before doing more with it) then copies it to an off-screen canvas that has the same dimensions as the one which will hold the material. This canvas is inspected when we need the 'mini image' to put at a given point.

WARNING: this code (even without the introduction of an image) is pretty processor intensive. On a farily powerful laptop with good GPU it was taking around 19% of CPU and not much less of GPU and the fan was whirring. This is even when there is no movement of the mouse. The code could do with a thorough look through, for example to stop the timer when user activity is completed, and perhaps putting the frame rate down (it's 60fps in the given code). I would not recommend it be put in a webpage and left there running - it will be a battery drainer.

It's not loading a0 with the buffer at sp.

Because you didn't ask for a pointer as an "r" input in a register. The one and only guaranteed/supported behaviour of T foo asm("a0") is to make an "r" constraint (including +r or =r) pick that register.

But you used "m" to let it pick an addressing mode for that buffer, not necessarily 0(a0), so it probably picked an SP-relative mode. If you add asm comments inside the template like "ecall # 0 = %0 1 = %1 2 = %2" you can look at the compiler's asm output and see what it picked. (With clang, use -no-integrated-as so asm comments in the template come through in the -S output.)

Wrapping a system call does need the pointer in a specific register, i.e. using "r" or +"r"

You can't convert random bytes (such as produced by encryption) into UTF-8 (or many multi-byte encodings, 8-bit single byte encodings are fine). The String will most likely become corrupted, as there are byte sequences describing illegal characters, they will be replaced with 0xFFFE or � i.e. he unicode replacement character.

So you will need to keep the byte[] around and not convert that to a String until you've decrypted the byte array, not a String.

Let's just talk about sleep. In one of your earlier questions, you posted a link to the user.h header file. That header file tells your C compiler what arguments the function takes and what the function returns, on this line:

The built-in rule for compiling .c files to .o files uses $(CFLAGS), not $(App_C_Flags).

Is it possible that the rule

You are correct that the hardware captures some information, such as the epc (if it didn't the interrupted pc would be lost during transfer of control to the exception handler).

However that's all the hardware does — the rest is up to software.  Here, RARS is providing the exception handler for ecall.

RARS documentation states (from the help section on syscalls, which is what these are called on MIPS (and RARS came from MARS)):

Register contents are not affected by a system call, except for result registers as specified in the table below.

And below this quote in the help is ecall function code table labeled "Table of Available Services", in which 1 is PrintInt.

Should any temporary (t) registers be saved to the stack before using ecall?

No, it is not necessary, the $t registers will be unaffected by an ecall.

This also means that we can add ecalls to do printf-style debugging without concern for preserving the $t registers, which is nice.  However, keeping that in mind, we might generally avoid $a0 and $a7 for our own variables, since putting in an ecall for debugging will need those registers.

In addition, you can write your own exception handler, and it would not have to follow any particular conventions for parameter passing or even register preservation.

Your code is incomplete:

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: