use different way to pass instructions to test_issuer ISACaller

debugging test_issuer.py general test cases

get instructions immediately from assembly code

move test_sim.py unit tests to different class (split)

slightly hacky way to keep an eye on the PC

whoops generate core ilang not TestIssuer

use while / exception in test_compunit loop

investigating mtocrf/mtcrf issue

working on adding rest of stage classes for div pipeline

add bug reference to mtocrf/mtcrf name decoding

decoding assembly instruction name, move to separate function

getting sim instruction decoder to reproduce asm instruction disassembly

update submodule

add comment/assembly decode in power enums

update test_sim.py to do a simple execution loop: decode-execute-decode-execute

add loop example, required a bit of munging.

get fu compunit test to use ISACaller instruction-memory

got fed up of adding arguments to ISACaller / ISA, use *args and **kwargs

split execute and setup of ISACaller instruction execution
into two phases

comment ISACaller setup

start to add in independent execution into ISACaller

add a fake program counter to ISACaller

use an independent power decoder in ISACaller

add "respect_pc" boolean to ISACaller

add optional instruction memory

split out TestIssuer into separate module

remove unneeded yield

enable all tests again in test_core.py and test_issuer.py

got test_issuer FSM operating.  bit of a hack

debugging test_issuer, getting FSM working

output to issuer_simulator.vcd

add first version unit test for TestIssuer

reduce instruction depth to 6 bits in TestIssuer

move debug statements to check function

hack LD/ST ad/st together, allow PC to be set externally

move check regs in simple core to separate function

move test core reg set up into separate function

set up a TestIssuer class with a FSM for doing instruction issue to simple core

add ports to TestMemory

add beginnings of TestIssuer class, to issue instructions to simple core

weird: adding TestMemory with no port causes nmigen recursion-exceeded

refer to signals directly in Test Core

add test instruction memory SRAM

update popcount docstring

start trying to fill in some comments in Minerva L1 cache code

whitespace cleanup

imports and syntax errors fixed (found test_cache.py)

more whitespace

more whitespace on minerva (no unit tests, so cannot check it)

whitespace cleanup, remove minerva DataSelector class

have to set up addr/st rel-go link before setting up nmigen Simulator
LD/ST now works in test_core.py

add in memory setup/check but disable LDST Unit Tests in core.py
LDST is still busy after 2nd instruction, bug needs tracking down

move setup/check memory into helper functions for use in test_core.py

whoops LDSTCompUnit was identified as a Function.ALU not a Function.LDST

add in TstL0CacheBuffer but disable temporarily

add optional LDSTFunctionUnit to compunits

unit tests showing byte-reverse works

add sim-qemu test for byte-reversed LD/ST

add in byte-reverse from op PowerDecode2 field

error in address width (truncated) in setting up L0CacheBuffer

error in naming that ended up in gtkwave from a proxy

add another LD/ST example to qemu-sim test,
mirroring the one in ldst compunit test

add byte-reversal on LD and ST in L0CacheBuffer

reasonably certain that the careful and slow use of little-endian data read/write
and explicit endian-ness swapping is correct, when comparing the
simulator against qemu

Wait for all active rel signals to be high, and only then pulse go.

It's the best we can do without parallel processes.

first cut at qemu memory dump and compare

note possible BE/LE mode needed for memory reads/writes

update ld/st test to see what is going on

tracking down what looks like an error in the Simulator Mem ld/st

debug printout of sim and hardware memory, shows mismatch of depths

use ALUHelpers in LDSTCompUnit test

some ugly hacks that get LD/ST immediate working

even more complexity in CompALUMulti, to deal with an edge case where
go-write is requested immediately (same cycle as go-req).
the set and reset on "req_l" happen to come in on the same cycle.
the result: the latch *remains* set high.
solution: record the go signals for one extra cycle (sync) and push
them into the req-reset and wr_any signals

must distinguish between rd/write xer_ca sim helpers

fixing get_rd_sim_xer_ca, has to only read carry if available

yield needed for unit tests to work (has to go)

read and write version of get_sim_xer_ca are different

use ALUHelpers in shift_rot

add fast spr1/2 sim ALUHelpers

rename get_sim_cr_a to get_wr_sim_cr_a for now
add read-version of get_sim_cr_a

move Decode2ToExecute1Type to separate module

whitespace

modify qemu.py to set qemu's cr to 0

link ST.go directly to ST.rel

rename unit test function in ld/st compalu_multi

hmmm very confused about LD/ST CompUnit unit test

wrong data structure being imported, duplicate CompLDSTOpSubset

remove old code

set data_len in compldst_multi unit test

yield ports from data_o and addr_o

expand LenExpand to 4 bits in order to cover 1/2/4/8 (0b1000)

got L0CacheBuffer shift/mask working on a preliminary level

whitespace

add use of classes in L0Cache unit tests

start using unittest suite in l0_cache.py

creates an import error and stops unit tests from running

Revert "PortInterface refactoring"

This reverts commit 8e58e66142991e308985a463cfff396a36e3f816.

add in LenExpander to L0CacheBuffer, not used yet

make resetless for all signals in DataMergerRecord

PortInterface refactoring

exception if rolls in addr_split.py