core tidyup

add Regspecs get_io_spec function

start allocating more FUs (more ReservationStations)

random loadstore1 test: readback written data

reenable dcbz test case

return correct data from microwatt

cleanup test_loadstore1.py

loadstore: add done_delay

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

add LogicalTestCases back in to test_core.py (pass)

let PowerDecode2 decide which operand class to use in test_core.py
this gets it to pick *all* fields

use latched readflag (recspec_decode_read "ok") instead of global one

tidyup on read-flag latches

fix read-decode information by latching not just the read reg number
but *whether it is valid or not*.
not only the register *number* from regspec_decode_read() needs to
be captured but its ok (valid) flag as well

this error only showed up when a mul (2-operand) was followed by addi
(1-operand).  the mul had its 2nd operand dropped on the floor because
the *addi* only has one operand.

fix write-after-write hazard checking

allow busy to settle before checking state in test_core.py

only check regs right at the end in test_core.py overlap mode

move sim call before core run in test_core.py
to give PC a chance to settle in regfile

getting formerly unused test_core.py operational

whoops missed make_hazard_vec test

whoops do the set/get of the write-vector at a single access point
for example: INT o, INT o2 is *two* write ports.  therefore,
previously, there was a comb += wvint bitvector for o, which was
then OVERWRITTEN by a second comb += wvint bitvector for o2

instead, return the wvset/wvclr requests to connect_wrport, which
collates by regfile name and performs an additional or-tree-reduce
on the requests to set/get

always set fwd_bus_mode=False on regfiles

add MMU and SPR to list of FUs that must report "busy" i.e. block

disallow overlap in core on LDST, Branch, and Trap.
these are all the ones that could cause exceptions or mess with ordering

use dict style not setattr on submodules

update loadstore1 testcase

code-comments

fix instructions of the type "read-reg-is-same-as-write"
this then caused write-after-write detection to go into a combinatorial
loop, which was fixed by not checking fu.issue_i but instead using
fu_enable (fu_bitdict[FU])

loadstore testcase: read at random addresses

FU-Regs matrix tidyup and comments

minor tidyup on FU-Regs Matrix

update FURegDepMatrix to multi-dest

update naming on Reg_Rsv signals

add copyright and attribution notices
update Reg_Rsv to multi-dest

update FU_RW_Pending vectors to multi-dest
update Copyright and Attribution notices

convert DependencyRow to multiple destination latches

add copyright and attribution notices to dependence_cell.py

update license and attribution in fu_reg_matrix.py

convert score6600_multi over to using RegSpecs (in a fake way)
which by slow code-morphing the entire score6600_multi code can be
converted to be like core.py

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

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