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

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

create function core conect_satellite_decoders
just moving code from elaborate to make it clearer

add cancel in to alu_ok / alu_valid in LDSTCompUnit

rename LDSTCompUnit cancel to canceln (because it is active low)

whoops must remember to do rdmaskn on LDSTCompUnit as well

remove unit test that is unfinished

shorter way of getting FU busy signals

MultiCompUnit fixed to not need rdmask to be sustained indefinitely
only needs to be set on input (when issue is raised)

in MultiCompUnit, put rdmaskn into src latch rather than OR in src release
this allows rdmaskn to be set just once rather than left permanently
on.  but, it does mean that the internal src register latches end up
having the wrong (previous) output, which then bleed through into
ALUs.

to stop that, the src data latches are all set to zero if the CompUnit
is not busy

mmu unit test working again

remove unused variable

code comments

comments

remove issue_i from core, use i_valid instead to decide when to issue
converting core to Pipeline API

move "exception happened" detection from TestIssuer to Core

use p.i_valid in core instead of explicit signal ivalid_i
converting core to Pipeline API

use Pipeline API o_ready instead of explicit core busy_o signal
converting core.py to Pipeline API

convert core.py to Pipeline API, deriving from ControlBase

remove unneeded imports

move simple core input and output data to in/out data structures

make FSMDivCoreStage properly conform to Stage API
added ispec and ospec functions, no need to explicitly set
self.p_i_data and self.n.o_data because that is the job of the Stage API

add hazard vectors to Regfiles
the reason for adding it to Regfiles is because both In-Order and OoO
need global hazard vectors.

in the case of In-Order the hazard vector bits are set directly by the
Issue Engine.

in the case of Out-of-Order the vector bits are set by way of an
amalgamation (Great Big Or Gate) of the columns from the DMs

in either case the vectors are needed, so might as well be added to Regfiles

add quick test of regfiles to output rtlil

switch over to single-entry (num_rows=1) ReservationStation2 based
MultiCompUnit

this is effectively identical to FunctionUnitBaseSingle behaviour except
that now there is the possibility of increasing the number of rows
(number of "fronts" to the ALU) to 2 or greater

DIV FSM, Trap and SPR as well as LDST have been left alone

for some reason mul test cases had not been added to test_issuer

adding an FSM-based MultiCompUnit test (does not work yet)

remove some of the uses of wrmask (redundant)
https://bugs.libre-soc.org/show_bug.cgi?id=742

in MultiCompUnit, wrmask is the amalgamation of the incoming "data ok"
signals from an ALU.  ALUs are given the *option* to write to registers:
they are not told, "you absolutely have to write to this register"
but of course for Hazard purposes, the MultiCompUnit has to be told
to "hold" off the write until such time as the ALU can determine whether
it has anything to write

it _should_ now be possible for the ReservationStation version of
FunctionUnit to use combinatorial-setting of write data+ok

update test_issuer_mmu.py testcase, add needed debug outputs

tlbie, mtspr and mfspr test cases

add mmu/dcache unit test

use ReservationStations2 (disabled for now)

write-ok is expected to stay valid *after* being set,
working out what is going on here

add name to write pick on core

fix missing naming ready_i -> i_ready

cleanup fsm

loadstore.py: add Display statement on SPR change

add first tlbie test case