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

revert addition of svsetvl as an actual opcode, add mvl CSR instead

this is less than ideal but better than having to add new opcodes

Revert "sv setvl as a csr not going to work, add getvl only"

This reverts commit 996e0246aa614231a560f3e3e84793745470ca6f.

Revert "manually add svsetvl instruction"

This reverts commit b3e60c2c6e722bc181369d48642834422fa1082c.

manually add svsetvl instruction

sv setvl as a csr not going to work, add getvl only

adding sv vector length CSR to processor state, and csr get/set

32 CSRs are used up, here, as SETVL requires not only an immediate
but also a target integer register in which the SETVL value is
stored.

add sv predication function

save some cpu cycles by |ing the checks for vectorop together

whoops vectorop has to be |= not &= to accumulate "true"

cache the sv redirected register values on each loop

if an emulated opcode ever calls insn.rd() or rs1-3 more than once
sv_inst_t::remap would accidentally increment the loop offset before
it was time to do so.

therefore put in a cacheing system and clear it only at the end
of each loop

remembered that the use of sv registers have to be loop-incremented separately

the SV parallelism loop has to respect whether each *individual* register
is a vector or a scalar.

clarify comments on (key strategic) sv_insn_t::remap function

actually implement sv register re-mapping

the algorithm here checks the (required) table (int or fp), checks if
the entry is "active", does a redirect, then checks if the entry is
scalar or vector.  if vector, the loop-offset (passed by value) is
added

ok this is tricky: an extra parameter has to be passed into sv_insn_t::remap

the reason is that the remap has to know if the register being
remapped is an int or a float.  the place where that is known
is at *decode* time... and that means that id_regs.py has to
look that up and pass it on (in a #define REGS_PATTERN).
the reason it is passed in as a pattern is so that svn_insn_t rd/rs1-3
have access to the information that is needed

move sv remap function to sv.cc (not inline)

check if register redirection is active, and if vectorisation enabled

check each register (if used) - this is what the #define USING_RD etc.
macros are for, to disable checks that are not needed

comment why sv_insn_t is set up the way it is; add vector loop stub

easier to #define USING_NOREGS if the opcode does not use any registers

include auto-generated identification of use of registers per op

modified id_regs.py to take a single argument (file in riscv/insns to parse)
added call to id_regs.py in riscv.mk.in
included the auto-generated file in the insn_template.cc

now each instruction has a way - BEFORE the emulated instruction is called -
to identify which registers (RD, RS1-3, FRD, FRS1-3) are going to be used.

shuffle things around a bit for sv, put rv32/64_name back to like they were

decided to move sv to its own template file, and make a bit more use
of macro pre-processing

skip id_reg.py parsing its own output; stop outputting "0" on empty

change to instruction template parsing, create one file per instruction

id_regs.py looks for patterns in riscv/insns/*.h to find the use of
registers

add decode.h header to sv.h

rename sv vlen to sv voffs, add csr and reg tables

add reference to vector length in sv

use sv_insn_t class in instruction template

add sv_insn_t class (inherits from insn_t)

argh cant virtualise rd/rs1-3, due to union usage with rocc_insn_union_t

sv: rd, rs1/2/3 become virtual so that sv_insn_t can override them

clarify sv cam table

define CSR and register tables for SV

remove unneeded use of AM_CONDITIONAL

add #define for SPIKE_SIMPLEV, re-run autoreconf

create #defines from identified registers, per opcode

clarify docstring on id_regs.py

add function identifying the registers in each emulated instruction

identify instructions, plan: extract registers

Update README

Merge pull request #235 from riscv/sba

Fix cut-and-paste bug in 64-bit SBA loads.

Fix cut-and-paste bug in 64-bit SBA loads.

Fixes #234.

Handle spike-dasm inputs with leading 0x correctly

Add dummy custom debug registers, to test OpenOCD. (#233)

Fix several disassembler bugs

h/t Shane Lardinois

Add --disable-dtb option to suppress writing the DTB to memory

Make IRQ_COP read-only/undelegable unless coprocessor is present

Instantiate disassembler after max_xlen is known

This fixes RVC disassembly.

It's done in a way that doesn't break 2cd60b277e909a5599ca48e4561cbfbc61460186

Don't increment instret immediately after it is written (#231)

This brings Spike into compliance with this clause in the spec:
https://github.com/riscv/riscv-isa-manual/blob/master/src/csr.tex#L96

Fix 2 trigger corner cases. (#229)

1. When hitting a trigger during a single step, dcsr.cause must reflect
the trigger not the step.
2. Also check for triggers on accesses that require a slow path fetch.

Make sstatus.MXR readable

h/t @taoliug

Fix using the uninitialized disassemble object. (#220)

This fixes runtime crash when custom extension registers its
disassembly.

Refactor and fix LR/SC implementation (#217)

- Use physical addresses to avoid homonym ambiguity (closes #215)

- Yield reservation on store-conditional (https://github.com/riscv/riscv-isa-manual/commit/03a5e722fc0fe7b94dd0a49f550ff7b41a63f612)

- Don't yield reservation on exceptions (it's no longer required).

Merge pull request #212 from riscv/hartsel

Update debug_defines.h

Update debug_defines.h

Add support for hartselhi parsing, but other parts of the debug code
still don't support more than 1024 harts.

Put simif_t declaration in its own file. (#209)

By separating the simif_t declaration from the sim_t declaration, the
simif_t declaration no longer depends on fesvr header files. This
simplifies compilation of custom sim class implementations that don't
depend on fesvr.

Fix install of missed header. (#207)

Extract out device-tree generation and compilation into an exported api. (#197)

Revert "C.LWSP and C.LDSP with rd=0 are legal instructions"

See https://github.com/riscv/riscv-isa-manual/commit/01190b6ebeb29cfac6783a3e7ce30cd529bf6c59

C.LWSP and C.LDSP with rd=0 are legal instructions

This mistake derives from an ambiguity in the specification that has since been corrected: https://github.com/riscv/riscv-isa-manual/commit/272d038abebe7f006ed7960b522f1e51890bb982

Fix commit log for serializing instructions

Resolves #199

Only break out of the simulator loop on WFI, not on CSR writes

Breaking out of the loop on WFI was intended to let other threads run
when the current thread has no work to do.  There's no advantage to doing
so on CSR writes, and the unintentional change in thread interleaving
broke some test programs that relied on short timer periods.

When no arguments are passed, print spike help, not fesvr help

Allow querying the mmu configuration chosen during the build. (#191)

Revert "Fix for issue #183: No illegal instruction exception for c.sxxi instructions encoded with zero shift amount"

This reverts commit be0555d585b332fd0496affe559c0a5a4e7e5644.

See #190

Merge pull request #189 from pmundkur/pm-csr-name-api

Add an api to get the name for a CSR.

Add an api to get the name for a CSR.

Implement Hauser misa.C misalignment proposal (#187)

See https://github.com/riscv/riscv-isa-manual/commit/0472bcdd166f45712492829a250e228bb45fa5e7

- Reads of xEPC[1] are masked when RVC is disabled
- Writes to MISA are suppressed if they would cause a misaligned fetch
- Misaligned PCs no longer need to be checked upon fetch

Fix the access exception during page-table walks to match the original access type, as specified in the manual. (#185)

Fix spike-dasm. (#184)

It had been broken by 90bafe660b323250338fd564bb9ab4316576d59b.

Merge pull request #182 from riscv/reset_bits

Implement debug havereset bits

Implement debug havereset bits

Merge branch 'deepsrc-b_fix_issue183'

Fix for issue #183: No illegal instruction exception for c.sxxi instructions encoded with zero shift amount

Fix a bug caused by moving misa into state_t. (#180)

* Fix misa losing its value in processor constructor due to state:reset() following state.misa initialization.
Make state:reset() preserve misa.

* Set state.misa to max_isa on reset().

* Idiomatic fix for earlier commit.

Move processor.isa to state.misa, since it really belongs there.

Fix single stepping csrrw instructions (#178)

This code is still a bit voodoo to me, but now we pass all the tests
again. (Stepping was broken by
4299874ad4b07ef457776513a64e5b2397a6a75e.)

Merge pull request #177 from riscv/debug_auth

Add debug module authentication.

Narrow the interface used by the processors and memory to the top-level simulator/htif.
This allows the implementation of an alternative top-level simulator class.

Fix install of a missed header from debug_rom.

The installed header files from the riscv subproject were incomplete, since
processor.h includes debug_rom_defines.h, and the latter was not installed.
Fix by moving it into riscv/, add it to the riscv subproject header list, which
ensures it will get installed.  While here, also add a missed dependency of debug_rom
on riscv/encoding.h to debug_rom/Makefile.

Fix a missed header file in the softfloat include install.

Implement clearing-misa.C-while-PC-is-misaligned proposal

See https://github.com/riscv/riscv-isa-manual/pull/139

Not adopted yet, but I'm putting the implementation here for reference.