disable jal in sv

rv_xxx convert c_xxx

rv_add in lh/sh

rv_add in store

blt and use of rv_add

add rv_ge

add rv_eq and rv_ne

add rv_eq and rv_ne

add rv_gt headers

add rv_sr

add shiftright

add shiftleft and lessthan

missed a mul

replace % operator with rv_rem

replace ^ operator with rv_xor

replace | operator with rv_or

replace & operator with rv_and

replace operator * with rv_mul

add rv_div (signed and unsigned) to replace operator /

redirect subtract through rv_sub

redirect add to rv_add

redirect add to rv_add

bit of a mess: attempted to create a complete arithmetic overload

had to back most of it out, and left in a change to the amo* functions
passing in a 2nd parameter to the higher-order-function

rename _zext_xlen

add sv_reg_t

redirect WRITE_FRD including different types (128/64/32)

add WRITE_FRD macro redirect

changed style, can revert changes to amomin/max

add frs2 redirect

add RS3 replacement

simplify sv_proc_t redirection of RS1-3 / FRS1 macrhos

redirect RS2 to sv_proc_t class

proof-of-concept, redirect RS1 to class sv_proc_t

combination of redirection through a "property" class overloads WRITE_RD

WRITE_RD, formerly a macro, now replaced with a function.
also required a redirector function rd

redirect instructions through a class called sv_proc_t

preparing the groundwork for a total over-ride of macros such as
WRITE_RD, and so on, so that element width can be implemented

more explicit testing, duplicating header file algorithms for div, rem and shift

whoops run from 0-255 not 0-254, and other test corrections

add some operator tests for int8_t being typecast to uint16_t

add more experimenting on operators

add operators test class

add operators library to contain operator-overloads of +/-/*/div/>/>= etc

for all types int8, uint8, float16_t, float32_t etc.

all to be template-ified

get predicated-vectorised branch working

save branch address and predication merged result, and test after branch

if the predication was all good, go ahead with the branch

still not tested for predicated / vectorised branch yet however
at least scalar branches work

add explanatory comment

add explanatory comment

start adding explicit twin-predicated branch identification (rs2)

extend sv register file from 64 to 128 after discussion.

evaluation of even embedded GPUs shows that they have really enormous
register files.  a fp16 x 4 to express quads, times four, takes up eight
consecutive registers just on its own.

override setpc macro so that sv can redirect it in branch

this is slightly complicated.  setpc is a global macro, intended for
use in the templates.  however for SV it needs to be conditional,
so needs to redirect to a function in sv_insn_t.

that in turn needs quite a few extra parameters: the current loop
element offset, the argument to set_pc just in case actually it is
detected that this really is to be a branch not a predication scenario
and so on.

have not tried out vectorisation yet, at least straight non-vectorised
branch operations (unit tests) pass.

swap #ifdef USING_NOREGS so that it is possible to redefine set_pc

to avoid having to modify the branch instructions the set_pc macro will
be #undefd and redefined to modify the predication target

add rd bit-setting function

add extra debug printing for c.lwsp

add rvc_swsp_imm sv overload, provides vector unit stride now

c.swsp and c.fswsp predication and offset enabling

allow x2 (sp) to be redirected in C.LWSP

temporary hack disabling SV in anything other than user mode

whoops inverted ldsp and lwsp immediates

create ldsp immediate offset overrides

this allows C.LWSP/C.LDSP to do predicated load/stores from contiguous
blocks of memory

add in predication for immediate, for C.LWSP

reorganise src and dest vector-element offsets

pass in pointer to offsets from processor_t->state.srcoffs and destoffs
into sv_insn_t so that the element state information about how many
parallel elements have been executed is recorded.

in this way it will be possible to restart a loop at the right place
if there is an exception (such as a memory cache miss on a LOAD/STORE)

add srcoffs and destoffs sv state, alter CSRs

remove SVREALVL, replace with SVSTATE

reorganise twin-predication

move the offset incrementing to outside of the sv_insn_t, and pass in
the src_offs and dest_offs by reference, mirroring and matching the
predication src and dest referencing

big reorganisation to support twin-predication

twin predication is on certain operations like LOAD, STORE, C.MV, FCVT
where the effect is similar to VSPLAT, VINSERT, and also bitmanip
scatter/gather.

add in twin-predication identification

pass in second predicate for twin-predication operands

decided not to change the behaviour of LOAD/STORE

start work on parallelsing LOAD, pass in parameter to reinterpret immed

debug print for floating-point regs

add comment explaining why invert isnt done in zeroing test
(already inverted basically)

add comment explaining use of insn._rd() in zeroing

whoops vloop continuation logic the wrong way round

the loop has to continue if there is one vectorised register left
rather than stop if there is *no* vectorised registers

skip parallelisation of complex LR/SC operations

identify type of instruction with additional #defines

add a #define to id_regs.py which indicates name of the instruction

the c preprocessor cannot cope with detecting what the name of the
instruction is (and when it does, if it is "and" that throws a
compile-error), so as a workaround have id_regs.py create a
#define INSN_ADD, #define INSN_ADD_I etc.

list of instructions to avoid parallelising

update template comment

lots of debugging of predication, found other errors

lots of stuff here:
* changed sv reg and pred entry layout to make them a bit more
  human-readable: put the key and idx on byte-boundaries
* bug in SV REG setting (getting int table instead of fp one, twice)
* bug(s) in SV PRED table setting (zeroing the reg tables, using idx not
  key and more)
* stop lookup of predication if the *REGISTER* entry is inactive
  (but not if it is a scalar, because scalar predication is ok)
  this was the final piece of the puzzle that got predication working
* added a useful macro for creating SV REG and PRED CAM table entries

predication now working including zeroing

add sv support for zeroing predication in dest register

bit of a major rework:

* access to the "unpredicated" (non-zero-hacked) register was needed
* therefore all rd/rs1-3/rvc_xxx functions had to have _ variants
* the underscored variants are not predicated
* this in turn meant that the offset for each register was wrong
  as it is incremented *after* being checked
* therefore a newoffs had to be added
* and the reset_cache function copies the newoffs values

bit of a mess but it works: this is a state machine after all...

add in predication to sv instruction execution

this relies on setting the value of the destination register
(and source registers) to zero.  a bad hack but it will do

start linking in predication into sv

use an alternative logic for detecting scalar / loop-end

instead of pre-checking do the check for "all-scalar" during the
first loop iteration i.e. when registers are first accessed

add compressed-identifying patterns to id_regs.py

also skip LUI (and C.LUI) as non-paralleliseable instructions

fix code template for when SPIKE_SIMPLEV is not defined

yuk. break id_regs.py being a generic tool by skipping csr ops

trying to use c preprocessor macros to skip CSRs in sv from being
parallelised is too painful, and is necessary to do.  a parallel CSR
read/write does not make sense

fix bug in sv template where FRS2 was checking rs3

add checks for RVC registers to sv template

add sv_insn_t overloads for rvc registers

also arrange for id_regs.py to identify compressed instruction usage

a LOT of debugging and fixing, sv loop actually working

move SV CSRs to user-read-write

add near-duplicate of SV CFG REG CSRs, for predication

add implementation of CSR SV CFG regs 0-7

this is a CAM table of key-value entries, 5-bits key (from instruction)
6-bits value (actual register table, now 64 entries)

TODO: obviously RV32E that would be reduced.
TODO: make it optional to have 32-32

assign SV REG CSRs (using new union ability)

make sv csr tables a union so they can be assigned to a ushort easily

add support for CSR_SVVL to CSRRWI as well

fix bug in CSR set SVVL: val has already been looked up

csrrw.h has been modified to invert the order of set/get, so the
call to processor_t::set_csr(SVVL, val) will do the right thing
and the subsequent (delayed) call to get_csr will return the
state.vl value in the chosen RD

all good

add stub for SV REG configs

stop a compiler warning

reorganise from moving sv_pred_* and sv_reg_* tables into processor_t

have to move SV CSRs into processor_t

add 8 CSRs for registers and predication each

each CSR contains 2 16-bit entries and is a CAM based on register as
key (5-bit) and target-register as value (6-bit) so that a 5-bit
RS1-3/RD can actually reach 64 actual registers, and *3-bit C instructions
can as well*

whoops dont need separate SVSETVL/SVGETVL CSRs

also add SVREALVL which is needed for state context save/restore