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()

start adding hazard vector setting in core (unfinished)

debug prints

fix regfile port names for "fast" port access (regreduce=False)

TODO, implement is_dcbz

code-comments

split out core input/output into separate file core_data.py

enable hazard vecs in core

add exact same number - and name - bitvector ports to regfiles
for hazard purposes, easier to just have the exact same names
g

code-morph regfile port specs to a dictionary format rather than hardcoded
this allows for Hazard Bit-vector regfiles to be created with exactly
the same regfile port names

invert numbering on CR HDLState.get_crregs

update store data reg 10 to 0xfe in virtmode mmu test

remove read of MSR, it is done by passing through PowerDecoder2

allow MSR to be set in StateRegs in test_core.py

add $Display of oper_r.msr in LDSTCompUnit

whitespace

morph regfiles to add hazard vector make_vecs function

add fetch of MSR in LD/ST pipe_data

add debug output for msr_pr

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

test testcase for exception

make core busy_o part of the CoreOutput data structure
the FSM TestIssuer can use this to detect not to send anything to it
and the InOrderIssuer can safely ignore it as long as it takes care
of RaW hazards

add a "fu_found" signal to core, which allows for an indicator that
no Function Unit (no Reservation Station) is currently available for this
instruction

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

test_issuer_mmu.py: add case_5_allsprs

add core instruction-issue PriorityPickers

this got more complicated than expected.  it should have been dead easy:
* identify each type of ALU (Logical, Shift, Mul)
* create a list per type of ALU of all Function Units providing that Function
* create a PriorityPicker for each type of ALU
* pick one
* shove that into the "issue" of the picked Function Unit.

where that went wrong was nothing to do with issue, it was to do with the
selection of the register files.

a return result from connect_instruction is a dictionary of "enabled"
bits, one per FU, giving permission for that FU to perform read/write
access to regfile ports.

however with the fu_bitdict changing from "continuously-enabled" over
to "single-pulse indicating issue", the read/write ports were no longer
requested.

to fix this, an *additional* dictionary was created: fu_selected, which
has the OR of the FU issue *and* the FU "busy" signal, which will be
HI for the whole time that the FU is active (even including the first
issue cycle: normally busy_o only goes active one cycle *after* issue
is blipped)

thus in theory, although in practice it will not happen, the read/write
ports could be requested immediately the instruction is issued.

comments

core.py: create a dictionary of lists of Function Units capable of
dealing with a particular instruction (by power_enums Function: ALU, MMU, DIV
LOGICAL etc.)