MIP | MIP – macOS Injection Platform | Cybersecurity library

Use syscall function code 3 to print doubles (not function code 2 — that's for single float).

Use mov.d to copy one register to another, e.g. into $f12 for sycalls (then no need to load 0.0 into $f0).

(Also, use l.d instead of ldc1.)

The loop: loop isn't a loop (there is no backward branch for it).

As @Peter says, your scaling/offsets are not properly accounting for the size of double, which is 8.  Scaling needs to multiply by 8 (shift by 3, not 2), and offsets need to be multiples of 8.

Your first loop, when its done, should not EXIT the program but rather continue with the next statement (i.e. the printing loop).

For this statement numbers[i+2] = numbers[i+1] + numbers[i]; there are two loads and one store as array references, whereas the assembly code is doing 3 loads and no store.

You use $s5, but never put anything in it.

The comparison of numbers[i+1] < 150 has to be done in (double) floating point, whereas the assembly code is attempting this in integer registers.

Floating point comparison is done using c.eq.d, c.lt.d, or c.le.d.  Like with integer compares, constants need to be in registers before the compare instruction.  150.0 would best come directly from memory (as a double constant) before the loop and remain there for the loop duration (or you can move integer 150 into a floating point register and convert that to double (cvt.w.d)).

Conditional branches on floating point compare conditions use either bc1t or bc1f (depending on the sense you want).

The C-like pseudo code probably doesn't run properly.  The exit condition for the first loop is suspect — it will probably run off the end of the array (depending on its initial data values).

Translating non-working C code into assembly is a recipe for frustration.  Suggest getting it working in C first; run it to make sure it works.

You may use for example ori combined with sll to load a 32 bit constant in 3 instructions without using lui:

With code that triggers undefined behavior, the compiler can just about do anything - well, that's why it's undefined - asking for a safe definition of undefined code doesn't make any sense. Theoretical evaluations or observing the compiler translating similar code or assumptions on what "common practice" might be won't really give you an answer.

Evaluating what a compiler really has translated your UB code to would probably be your only safe bet. If you want to be really sure what happens in the corner cases, have a look at the generated (assembly or machine) code. Modern debuggers give you the toolset to catch those corner cases and tell you what actually happens (the generated machine code is, after all, very well defined). This will be much simpler and much safer than to speculate on what code the compiler might probably emit.

First, let's state that this question applies to a pipelined processor, rather than a single cycle processor.

Second, let's assume that WB (write back) executes instantly at the beginning of the cycle — this is realistic b/c WB doesn't have to compute anything and the value for it to store into the register file is available at the very beginning of the cycle.

And that then the ID from a later instruction can capture the value written by WB from an earlier instruction, via overlap in the same cycle.

We must start with $s1's contents -- the value held there.  From the 32-bit value held by that register, we can do:

1. $s1 + 200 (simple addition), or,
2. Mem[$s1 + 200] (displacement addressing), or
3. Mem[$s1] + 200 (there's some name for this but it is not a common addressing mode).

In your case, as you want to do PC = 200($s1), my guess would be (1) or (2).

Because assignment to the PC (PC=...) already implies another memory fetch that will occur for the very next instruction — to fetch the machine code instruction to execute — we need to question whether a memory fetch (in the new J instruction) is desired or not.  The syntax J 200($s1) is ambiguous here (b/c of the implied indirection of the execution cycle: IR=Mem[PC] that naturally occurs during instruction execution), so, you'll have to ask whether the 200($s1) is the simple address of machine code to fetch and execute next (very likely), or, the address of a data pointer that tells where the machine code is.

The former, (1), would be reasonable as the next operation the processor performs is IR = Mem[PC], so across two instructions (this J and the next instruction), that says execute the instruction at Mem[PC] (where PC=$s1+200) so equivalent to saying to execute the instruction at Mem[$s1+200]: a single level of indirection, which says to use the location, $s1+200, to assign to the PC=$s1+200, and use subsequently as a the location of program/machine code instructions.

IR is the instruction register, used internally to describe the processor's fetch of the machine code instruction and holding of it for decode and further execution.

The latter, (2), would also be reasonable, and it says execute the instruction at Mem[Mem[$s1+200]], an extra level of indirection, appropriate if the intent is to use the memory location, $s1+200, as a data word, as a pointer to the next PC/machine code instruction, to be assigned to the PC so that the next instruction is sourced from that data pointer value.

The problem is you are running your loop using the address of N and not the value of N. The first line of main loads the address of N into $a0 which becomes $t0 in your max function. However, you then use that address as if its the value of N (ie, 8) in your loop with beq $t2 $t0 maxEnd.

Either just load the value directly into $a0 at the beginning:

The push operation should pre-decrement the stack pointer. That is, instead of:

The number of solutions is very likely not the reason for the out-of-memory error. It's the size of the branch-and-bound tree and the number of nodes that need to be stored and processed. You should try limiting the number of threads that are used to reduce the memory footprint.

Furthermore, there aren't that many proper solutions found. For every new incumbent you see a marker (* or H) at the beginning of the respective line, e.g.,

I'm currently looking on import and export and the webassembly specification (as for now) does not cover how the wasm/js api actually works.

That's the beauty of a specification, it can have various different implementations!

For example when importing something like JS console.log function or another function does the JS engine just search the import section and looks for the names encoded and match it with a function?

That would seem like a reasonable implementation. When you create a WebAssembly module you supply named import functions, these must match the names in the WebAssembly module's import section.

webassemblyjs is a JavaScript-based WebAssembly interpreter. You can see how it matches externally provided imports with the module's expected imports here:

https://github.com/xtuc/webassemblyjs/blob/master/packages/webassemblyjs/src/interpreter/index.js#L57