Add snoop port
DCache: Coherency

This adds coherency via the snoop port.

The cache have a duplicate tag memory for snooping,
which significantly improve performance over the other
alternative where the normal tag memory is used.

Note by Stefan Kristiansson:
This commit message is an excerpt of the original message
and the commit itself is squashed together from a couple
of trial and errors, but I think it should be
pretty representive of the gist of the original patch.
cappuccino: check atomic_reserve at end of storebuffer

Since there might be a snooped access while the atomic store
(l.swa) is in the storebuffer, the atomic_reserve flag has to
be checked right when the l.swa is coming out from the
store buffer and let out on the bus.

This achieves this by stalling the pipeline while the
l.swa is in the store buffer.

There are a couple of reasons why the atomic goes through
the store buffer and not bypass it.
1) It simplifies some of the logic (less special cases)
2) The store buffer should have knowledge about atomic stores
   going through it, since it place restrictions on what kind
   of re-ordering can be done.
   The current simple store buffer does no such things,
   but this way we are a little more future-proof.
squash to coherency
cappuccino/lsu: break atomic link when snoop occurs at the same time as load

This fixes a corner case where the snoop occurs at the exact
time as the load.
cappuccino/lsu: abort cache refill on snoop hit

Even though the assumption that the bus accesses from the refill
and the snoop are excelusive, there is a possibility that a
refill have been initiated at the same time as the snoop bus
access is going on.
This doesn't cause problems as long as the refill happens
to to the way that is being snooped, but if the snoop occurs to
an opposite way, the refill logic has saved the the old
tag data for that way and will write it back once the refill
has finished.

This avoids the issue by aborting refills when there's
a snoop hit, and prevents refills to be started at the
same instant as the snoop access and the snoop hit is handled.

This can be improved upon in several ways, either by only
aborting/preventing the accesses that are related to the
refill or as an even cleaner solution by splitting the tags
into seperate memories, so the tag saving mechanism can be
removed.

The overhead of aborting all refills on snoop-hits is however
rather small, since the refill would anyway be stalling waiting
for the snooped access to finish, so for now it will suffice as
a solution.

Conflicts:
	rtl/verilog/mor1kx_lsu_cappuccino.v
Debug: Execution traceport

The execution traceport traces all executed program counters, the
respective instruction and accesses to the register file with this
instruction. A rudimentary set of trace actions can be implemented in
a synthesizable way.

Set FEATURE_TRACEPORT_EXEC="ENABLED" to enable this trace port.

Add monitor for simulation.
propagate OPTION_DCACHE_SNOOP to top