skip madd* tests since they're not implemented

MASK was moved into ISACallerHelper class

set parent pspec to class with XLEN = 64

set 'soc' filter to filter out v3.1 insns

fix ALU test by setting 'soc' filter to filter out addex

mark src/soc/experiment/test/test_compldst_multi.py as broken

mark test_pi2ls.py as broken

I tried to fix it, but a whole bunch needs changing so I gave up for now

add cocotb to gitlab-ci

add pytest-output-to-files's output dir to gitignore

make CI work

Makefile: Added rule for generating mw-compatible core with SVP64
issue_verilog.py: Added argument for mw+svp64.

It's intended to be an unintrusive change for testing. No default behaviour
has been changed.

Handle newer nMigen adding a "bench" hierarchy root in VCD files

Keep the valid signal from the formal engine ALU stable, until read

Check that exactly one ALU write is made, per instruction

Check cover and bmc in separate sub-tests

This allows generating a bmc trace even if cover failed.

Reset req_l latch on system reset

Even if the holding register of SRLatch is really reset-less, it is still
reset at startup, because the latch reset port has reset=1. But, this only
works if the latch reset port is driven by the sync domain. In case of
req_l, it's driven by the comb domain, so the latch is not reset on system
reset.

Generate a pulse on system reset, and combine it with the latch reset.

Reset src_l latch on issue_i

When the input operand is masked, there will be no go_i pulse to
reset the src_l latch, so we force it to reset on issue_i, as well.

only NLnet sponsor

Move test to expose bug in MultiCompUnit

A bug was discovered in MultiCompUnit, which occurs only when an
instruction with zero_a or imm_ok is immediately followed by one with
a masked input port. If we move one test out of the way, we get exactly
that.

Check invariant for instruction operands

For every instruction issued, at any point in time, each operand
was either:
1) Already read
2) Not read yet, but the read is pending (rel_o high)
3) Masked

If the ALU is idle, do not assert valid

Count zero_a and imm_data.ok as masked read transactions

Don't issue while busy

Otherwise, the formal engine, in some cases, will happily assert issue_i
while busy_o is high. MultiCompUnit can't handle that.

Add count of masked reads

Add ALU read transaction counter

Add ALU write transaction counter

Add write transaction counter

Fix duplicate line (copy & paste error)

Add counter for operand reads

Avoid toggling go_i when rel_o is low

This must be enforced on the scoreboard, in its proof.

Leave shadow / die proof for last

Start of formal proof of MultiCompUnit

Create a "random" ALU, controlled by the formal engine.
Add an "issue" transaction counter and ask the fomal engine to
give an example.

change goldschmidt_div_sqrt to use nmutil.plain_data rather than dataclasses

grr not a yield function

add get_fpregs stub function to HDLstate

update pinmux submodule, rename to "fabric"

add fabric compatibility mode

MulOutputData was only 64-bit output not 128-bit
meaning that mulhd is truncated (always zero)
https://bugs.libre-soc.org/show_bug.cgi?id=855

add signal for resetting trap internal state (kaivb cache)

set msr_o.data not msr_o Record in trap main_stage.py

adapt TRAP function in main state pipeline to put KAIVB
into top bits

store KAIVB SPR 850 in TRAP Pipeline
by redirecting OP_MTSPR and OP_MFSPR to it
https://bugs.libre-soc.org/show_bug.cgi?id=859

reduce icache/dcache TLB sizes

update trap test_pipe_caller.py to use up-to-date test method

missing module argument to TestRunner execute

convert trap test_pipe_caller.py to consistent format
(like alu test_pipe_caller.py)

Change usage of WB sel for individual control

split out front of div into separate stage, still too long combinatorial
blocks

add missing module

split off CR0/XER production in DIV Function Unit into separate stage
due to massive combinatorial chains

clear out DEC in core.cur_state.dec due to spurious interrupt.

this is slightly complicated.  the STATE regfile contains pc, msr, svstate,
dec, and tb, being a reflection of CoreState.  reading from STATE regfile
is on a one-clock delay. the DEC/TB FSM needs to decrement DEC and increment
TB, by reading from the STATE regfile and then writing a new value.

of course, the SPR pipeline has to get a word in edgeways as well.

but...

the complication comes in that it is the PowerDecoder2 which receives
a *cached* copy of DEC, and this cached copy is what has (up until now)
been out-of-date with what is in the STATE regfile.

the hack-job-solution is to zero-out the cached copy when the SPR pipeline
writes a new value to DEC.  the DEC/TB FSM will then rewrite a correct
value into it.

given that PowerDecoder2 only uses the MSB of DEC (and the EE bit of MSR)
to determine whether to fire an interrupt, this should be perfectly fine.

Implement transparent read port option on the XOR wrapper SRAM

Add a bypass path when simultaneously reading and writing to the same
address.
There needs to be an independent Mux for each write lane, since we may not be
writing on all lanes, necessarily.

fix waay-too-precise error requirements

reduces 128x64->64-bit divider to 220k cells rather than 700k cells

add option to set small cache sizes in
issuer_verilog.py

add comment

fix so HDL works for 5, 8, 16, 32, and 64-bits.

HDL works for io_width=5

Test simultaneous transparent reads and partial writes

Should catch some corner cases.

add docs for clz

add WIP HDL version of goldschmidt division -- it's currently broken

notes added to setup.py - absolute paranoia is needed on
what dependencies the HDL has.  dropping USD 16 million on 7nm Mask Charges
you absolutely cannot have arbitrary software downloaded off the internet
from external sources.

move GoldschmidtDivState

add FIXME comments

add the goldschmidt sqrt/rsqrt algorithm, still need code to calculate good parameters

switch cached-property dependency to using libre-soc's git repo

improved goldschmidt division algorithm parameter optimization algorithm

split out non-derived params into separate class without all the accuracy checking stuff.

split out n_hat as separate property

add default_cost_fn

move GoldschmidtDivParams.get to bottom of class

rename _goldschmidt_div_ops to GoldschmidtDivState.__make_ops

goldschmidt division works! still needs better parameter selection tho...

fix goofed __init__.py file name

working on goldschmidt_div_sqrt.py

add cached_property dependency

working on goldschmidt division algorithm

whitespace

add WIP goldschmidt division algorithm

Implement a 1W/1R register file, XOR style

Test case seems to be working.
Total 6x 1RW SRAMs were used, but no DFF RAM was needed.
Still needs a bypass for a transparent read option.

Formal proof of pseudo 1W/2R SRAM

Mostly taken from the proof of the 1W/1R SRAM. Sorry for all the
duplication, they are all variations of the same theme.

Add transparent option for the full read port

Implement a pseudo 1W/2R memory

This is intended for a XOR-based 6x1RW implementation of a 1R/1W
register file.
It costs 3 x 1RW memory blocks.

reduce dcache/icache number of ways, to fit into ECP5 45k resource

part two of issuer_fix: read pspec.microwatt_old and pspec.microwatt_debug

Check non-transparent 1W/1R SRAM wrapper

Add special case for the non-transparent case, where a simultaneous write
returns the old value of the holding register.
This completes the proof for this 1W/1R SRAM wrapper

Enable read port for non-transparent memories

For some reason, the reset value (=1) of the port enable is not recognized
by the formal engine, even if the simulation is fine with it.

Merge ssh://git.libre-riscv.org:922/soc

part one of issuer_fix: add parameter to issuer_verilog.py

Add port declarations to the SRAM wrappers

Change write lane signal from one-hot to binary

It's simpler to write, and actually runs faster, somehow...

whoops, WBASyncBridge ack signal not wired up!

select width is data_width // data granularity.
(common mistake to make, confused the hell out of me too)

Synchronize LVT state, completing the induction proof

Sync proof state with downstream memories

put the old microwatt compatibility back
PLEASE DO NOT CHANGE THIS WITHOUT CONSULTATION

blegh.
* add in a new PRE_IDLE state into issue FSM (to allow pc_at_reset to
  get a word in edgeways)
* set nia to pc_at_reset on core_rst (not 0x0)
* add in a terrible hack where the STATE regfile entry for PC is
  shifted down by one.

absolutely no frickin idea why that is needed

Complete moving the induction support into the DUT

That way, we pass the state down, to be checked by single code at
the lowest level, instead of having to check all variations of the
lower level states, at the top level.
Had to increment the proof depth, for some reason.

Fix incorrect signal widths

dbg_data is the width of a write lane (granularity) and dbg_wrote is a
single bit.

Move part of formal proof to the implementation

For induction, some state has to be synchronized with the
device under test. Make the device itself responsible for checking
this, to avoid exposing its internal workings, and making the proof
more generic.
This is done for PhasedDualPortRegfile, the rest will follow.

add option Spec to XICS ICP/ICS to be able to activate (in a horrible
hack way) make_wb_layout to add stall
this is done by spotting "spec.microwatt_compat" adds stall
blegh