jal | Personal finance tracking project

If your intent is to follow the proper calling convention, rather than create your own, your register analysis is off.  The calling convention defines parameter registers, return registers, call preserved registers, and call clobbered registers; also return value passing and some requirements on stack handling.

In the following I make some notes below:

Though you're working in MIPS, this is not really a MIPS problem, it is a general problem of recursion.

In recursion, let's say we have:

My guess is that this linker does not handle branch instructions (bne or beq) to external labels.

This will preclude using beq label where label is external (global and in another object file), but this is only really possible to do in assembly.

Compiler output, for example, will have both the branch instruction and target location all within a single function, which goes into a single code chunk. (modulo certain tail call optimization).

With that limitation, then all bne and beq instructions are already fixed up by the compiler or assembler, using pc-relative addressing — there would be no need for an entry in the relocation table for these.

Further, the range of the branch (beq/bne) instructions (+/-128k) is shorter than for j, so if the linker were really intending to support branching to external label, it might also have to provide the capability to introduce branch islands to handle the ones that are branching too far away.

To expand on your example:

First, 0x7FFFFFFF is not a reasonable address for a MIPS stack pointer, because it is odd.  A MIPS stack pointer points to words, so should be an even multiple of 4.

Second, QtSPIM sets up the simulation's initial stack in a similar manner to a UNIX process — it puts command line parameters and environment variables on the stack.

Suggest you take a look at the stack in the data section and you'll most likely see strings of the environment.  (Click on the Data tab, before running the first instruction of a simulation, then view the User Stack memory area.)

Running QtSPIM on windows, for example, I see the same strings in that I see when doing set command from the command line shell cmd (cmd.exe).

If you add "Command-line arguments to pass to program" using "Run Parameters" menu item (from QtSPIM menu: "Simulator"), any strings you type there will also appear on the stack in front of the environment strings.  That will also change the initial stack pointer value used by the simulation.

Partial answer, to the "is there a bug" part, not the name of the code-model in the MIPS64 ABI.

Turns out the [compiler-explorer] tag was relevant after all: It was hiding a

The answer is the innerLoop's first statement:

This seems like a calling convention error. You're saving $ra into the stack but not restoring it after you finish a function. Remember that jal will overwrite $ra. So when you do

how does the processor know which address to start fetching instructions from?

The actual CPU itself will have some hard-wired address that it fetches from on reset / power-on. Usually a system will be designed with ROM or flash at that phys address. (That ROM might have early-boot code for an ELF program loader which will respect the ELF entry-point metadata to set up an ELF kernel image from ROM, or you could just link a flat binary with the right code at the start of the binary.)

What is going on here? I thought I'd have a simple single line of hex, but there's a lot more going on.

Your objdump -D disassembles all ELF sections, not just .text. As you can see, there is only one instruction in the .text section, and if you used objdump -d that's what you'd see. (I normally use objdump -drwC, although -w no line-wrapping is probably irrelevant for RISC-V, unlike x86 where a single insn can be long.)

Would it be possible to pass the file I compiled above as is to my processor?

Not in the way you're probably thinking. Also note that you chose the wrong file name for the output. as produces an object file (normally .o), not an executable. You could link with ld into a flat binary, or link and objcopy the .text section out of it.

(You could in theory put a whole ELF executable or even object file into ROM such that the .text section happens to start where the CPU will fetch from, but nothing will look at the metadata bytes. So the ELF entry-point address metadata in an ELF executable would be irrelevant.)

Difference between a .o and an executable: a .o just has relocation metadata for the linker to fill in actual addresses, absolute for la pseudo-instructions, or relative for auipc in cases like multiple .o files where one references a symbol from the other. (Otherwise the relative displacement could be calculated at assemble time, not left for link time.)

So if you had code that used any labels for memory addresses, you'd need the linker to fill in those relocation entries in your code. Then you could objcopy some sections out of a linked ELF executable. Or use a linker script to set the layout for your flat binary.

For your simple case with only an add, no la or anything, there are no relocation entries so the text section in the .o is the same as in a linked executable.

Also tricky to get right with objcopy is static data, e.g. .data and .bss sections. If you copy just the .text section to a flat binary, you won't have data anywhere. (But in a ROM, you'd need a startup function that copies static initializers from ROM to RAM for .data, and zeros the .bss space. If you want to write the asm source to have a normal-looking .data section with non-zero values, you'd want your build scripts to figure out the size to copy so your startup function can use it, instead of having to manually do all that.)

I have a suggestion for making the image clear, removing the background.

You can use inRange thresholding.

To use inRange thresholding you need to convert the image to the "hsv" color-space, then you have to set the lower and upper boundaries of the inRange method. The boundary values can be set manually. The result of the inRange method will be the mask of the image, where you can use the mask to remove the background. For example:

After, you can use the tesseract page segmentation modes(psm). Each psm value will give a different output. For example, psm 6 will give the result: