[WIP] Virtual interfaces support

[kozdra]

This is more of a call for comments for now, aiming to discuss the difficulties and design of virtual interfaces support, with a proof-of-concept patchset to talk about.

A virtual interface is emitted to C++ as a variable holding a pointer to an interface scope (initialized to a null pointer), which is the most straightforward thing I came up with.

The main concern is the duality of scopes and variables in Verilator. In this patchset I decided that in the easiest case this can be worked out with minimal alteration, by simply using variables where variables are normally used (e.g. viface = iface assignments), and scopes where scopes are normally used (e.g. iface.signal or viface.signal), as opposed to MemberSel, to name one.

This comes with several drawbacks:

• The scopes are tracked separately from their corresponding variables, and one of the two might get optimized away when still needed. I addressed this by checking for this case in V3Dead, but this might still be a potential footgun in the codebase.
• The scopes and variables have a different representation in the verilated code (vlSymsp->TOP_unique_absolute_path_to_interface vs some_scope.some_var.path.to.viface_field):
  1. Plain interfaces, when used as variables, are emitted as pointers to their inner scopes. This is done by assigning them their inner scopes instead of parent scopes during V3Scope, and it is even quite correct.
  2. Virtual interfaces, when used as scopes, are emitted as the variable names, with an extra null check added. This does not work for every case, and is hacky. This is the most important place in which I would appreciate some feedback and ideas.
• Variables accessed in scopes of virtual interfaces can no longer be tracked with scope identity checks (this would actually apply here anyway, even with a different implementation). This would ideally require keeping for each scope a set of scopes that it can be confused with, filled in during assignments parsing, but I solved it by setting every variable accessed through a virtual interface as public, which disables agressive optimizations on them (variable constification and assignment elimination), and works well for showcasing the proof-of-concept, as it does not impact optimizations of designs that do not use virtual interfaces. This can always be implemented separately as an optimization.

[kbieganski]

I think it's good, I don't know enough about Verilator's scopes to suggest anything better. Just the one comment, also look through the source and constify all pointers that don't change.

[kbieganski]

Is this unavoidable? Which optimization is this needed for?

[kozdra]

This could be avoided if we added special handling for scope overlaps with virtual interfaces in V3Dead and V3Const.

Without this deoptimization the provided regression test (v8 = p8; v8.grant = 1; $display(v8.grant, p8.grant)) shows the incorrect value for the actual interface (the value access to the virtual interface gets constified, and the assignment gets eliminated). The variables are reported as unused, because each variable is in a different scope.