early use of Array unnecessarily (all uses are static references
not dynamic indexing: no pmux created or needed)

get score6600_multi operational again
main thing was a "delay" on go_read_i due to regfile read results being
one clock cycle behind.

add debug prints in old simulator

add debug prints in old simulator

seperate invalid test case from other test cases

mmu: add debug output

add testcase for invalid pagetable

pimem: reset on exception

remove unuses dsisr signal

reset state to idle on exception

more sorting scoremulti

more sorting out scoremulti

add test pspec for scoremulti to work

convert hazard bitvectors to Reset-Priority SRLatch from nmutil

the read/write port were seriously getting in the way, by way of the
operand forwarding etc. etc. need instead to get either the immediate-latched
value (combinatorial) or the sync-delayed one, depending on circumstances.

fix exception handling in pi_ld

Merge branch 'master' of ssh://git.libre-riscv.org:922/soc

improve debug output in mmu.py

fix write-after-write hazard detection

when allow_overlap enabled do a manual wait until all FUs have
entirely finished befor going on to read the regfile state
this really should be done with the DMI interface, which needs updating

code-comments

add write-after-write hazard detection
stall if a WaW hazard is detected, continuing to assert the main decoder
so that the relevant bits of the write-vector can be read.  these
bits are read *one clock behind* which is perfectly fine

add 2nd hazard bitvector port for write-after-write
hazard detection

whoops merged the two write-ports for RT and RA-with-update

disable hazard vectors when overlap is not requested in core.py

update submodules

more comments

pimem changes for st exception handling

fix test_loadstore1.py

add FU write-after-write hazard detection Signal (dummy so far)

this has to be set up in the connect_write section but then
*used* in connect_rdport in order to stop reading from happening

strictly speaking it should actually stop issue, but we already
established that that way lies madness (combinatorial loops).

this may turn out to be a bit more complex than initially planned
due to some instructions potentially not having read at all
(only write)

add code-comments, link to in-order core

more use of namedtuples in core.py for clarity

start some use of namedtuples in core.py

use some namedtuples to make things clearer in core.py

use fascinating trick of defaultdict-of-defaultdicts

add store testcase

fix fast exception handling for pi_st

make FetchFSM take PC as an input in its ispec

local variable rename in FetchFSM

split out FetchFSM into separate module
there are DriverConflicts which result in the FetchFSM being merged
into TestIssuerInternal but that is actually ok for now

whoops accidentally committed commented-out test for overlap
in test_runner.py

reset execute back to ISSUE_START if at INSN_WAIT and
stopping was requested.

restrict (refine) hazard selection to the one being picked for this port

block picker hazard on input to PriorityPicker rather than output
reason: another register could be picked if the input is blocked
but if the output is masked out, the picker will sit there with the
highest priority port stopping all others

parse test_issuer args allow option "allow-overlap" to be optional

complex.  TestRunner now does not work properly unless recognising
that first, instructions can complete out-of-order from which they were
issued, and second, that just because the Function Unit has said it
accepted the instruction does not mean it has actually completed.

TestRunner therefore needed quite a bit of sorting out

fixed issue with hazard dependencies, read will nott
take place until write dependencies are clear.  currently extremely
draconian "ban" on entire FU progressing, actually probably all FUs
progressing, until write-hazards are clear.  can sort out later

add testcase for fast exceptions on store

fix pi_ld testcase

add both bitdict and selected args to connect_rd/wrport

sorting out issue hazard conflicts in core.

debug and cleanup

rename instruction_active to instr_active in core

read latch on regfile ports was fine, the combinatorial loop
is in the hazard detection on instruction issue

Merge branch 'master' of ssh://git.libre-riscv.org:922/soc

latch copy of read register numbers, not in use due to combinatorial loop
of some kind

use read spec in connect_rdport rather than list of reads

capture write regfile numbers into write latches in core

code tidyup / comments, and use defaultdict

create lists of latches in each FU, to record the read/write register
numbers required by the FU to read/write to regfiles.

previously, in the FSM-only version, these read/write regnums were
held (globally) by TestIssuer, and because only one instruction was
active, it did not matter.

now with the possibility of multiple instructions being run, it matters
(a lot)

for some reason DMI CTRL returns status of 0x6 not 0x0

missing argument, domain="sync" in JTAG instance

return None if data returned is empty

remove combinatorial loop in core instruction conflict detection

experimenting with overlapping instructions, bit of a mess

set up core processing FSM, which captures data if FU is not ready

set up a temporary copy of CoreInput
(and fix CoreInput.eq, sigh)

experiment allowing overlap (activated with --allow-overlap) in TestIssuer

remove unneeded import

more work on test_loadstore1

start adding bitmanip FU

PortInterfaceBase: fix fast exception handling

whitespace

Merge branch 'master' of ssh://git.libre-riscv.org:922/soc

fix mistake in test_pi2ls.py

reading of regfile bitvector added, which activates on a per-FU basis
at the regfile read port

this is somewhat complete overkill because strictly speaking the
read should be done at issue time.  fortunately, merging of lots of ORs
results in the exact same thing, just distributed

horribly inefficient though

core hazard bitvector regfiles need to be readable
immediately (combinatorial) not via sync.  allow synced option to
pass through from VirtualRegPort to RegFileArray

fixed busy waiting in pi_st

add option to test_issuer.py to allow for overlapping issue of
instructions.  this is for Core hazard detection prior to moving to
an in-order core

add ability to run hazard instruction for test purposes

detect the case in Core bitvector when the Function Unit says:
"actually, although you said i *could* write to this regfile
(and therefore have been reserving a write hazard protection for me)
actually i'm not going to write to it."

this situation occurs when:
* at issue time a wrflag (from PowerDecoder decode_regspec_write) was HI
* at ALU output time (alu.n.o_ready) the FU dest.data.ok flag is LOW

under these unusual but perfectly valid circumstances the write hazard
bitvector MUST still be cleared

add probe of whether CompUnit ALU is done or not.
this is used in core to detect whether the optional situation of
an ALU *maybe* writing to a regfile occurs or not

missing optional check on make_hazard_vecs

move core hazard set/clear to separate function, for clarity

whoops context-indentation by mistake (no harm done, just odd)

add a FetchOutput pipeline data structure

print out regfile unary status, bit of name-cleanup

use a virtual regfile port for the hazard bitvectors
this allows a full width of enables and full width of bits
(one per reg being written to)

pi_ld busy waiting fix

loadstore1 now reports exception reason

create set/get ports for bitvectors

capture write port (wrflag) in byregfiles_spec for use in
bitvector setting at issue time

rename regports for bitvectors so that
* read regfile can SET the bitvector
* write regfile can CLEAR the bitvector

starting to get write-clear of hazard vectors operating

whoops, hazard vectors were depth 1 width N
they need to be regwidth 1 (1 bit wide) depth N (one per register)

report dar on exception + test case

add test_loadstore1.py

add quick instructions on how to run pinouts.py to get some debug info

update submodule to make ngi pointer router pinouts

add new get_pinspec_resources function which creates nmigen
Resource/Subsignal/Pins suite from the JSON files generated by pinmux

code-comment for get_pinspecs()