Sean Anderson [Thu, 22 Jun 2023 01:10:26 +0000 (21:10 -0400)]
vhpi: Add support for getting record types by name
When cocotb tries to access an object with a name like `VHPI5.O.F`, it
doesn't know whether O is a signal or a record. This ambiguity could be
resolved by trying to look up the name like `:VHPI5:O.F` or
`:VHPI5:O:F`, but cocotb can't determine which to use ahead of time.
This is a limitation of cocotb, but probably not one which will ever get
resolved.
Add support for looking up record types by name, primarily to allow
cocotb to access them.
Sean Anderson [Thu, 22 Jun 2023 01:00:43 +0000 (21:00 -0400)]
vhpi: Add get/set support for selected names
Inhomogenous types are create scopes instead of signals. Additionally,
inhomogenous arrays have nested scopes for their elements. Add the
necessary machinery to determine the scope for a name/objDecl, and look
up the signal at the final level.
In the style of vhpi7, assign a value to each element of the test
records, and try to change them. To avoid needing to repeat the same
code while recursing through records, we just print out the values and
check them against the golden output. We cheat a bit for
multidimensional arrays because array properties are checked properly in
vhpi7.
Sean Anderson [Thu, 22 Jun 2023 00:42:18 +0000 (20:42 -0400)]
vhpi: Add support for selected names
The other major type of prefixed names is selected names. Add support
for them. In many ways they are simpler than indexed names, since we
don't have to keep track of multiple indices. Getting/setting is not
supported, but it will be addressed in the next commit.
Sean Anderson [Wed, 21 Jun 2023 23:32:14 +0000 (19:32 -0400)]
vhpi: Support record elements
Add support for record elements. Convert the vhpi5 test to gold to make
it easier to check recursive structures, and change the record
definition to something a little more interesting.
Sean Anderson [Sun, 18 Jun 2023 21:29:01 +0000 (17:29 -0400)]
vhpi: Pre-calculate names' offsets
We have all the information necessary to determine the offset of indexed
names when creating them. To simplify the process of determining the
offset by pre-calculating them.
Sean Anderson [Sun, 11 Jun 2023 19:01:05 +0000 (15:01 -0400)]
vhpi: Support EnumLiterals
Add support for the various *Literals properties of enums. Although
`EnumLiteral`s are generalizations of both `expr`s and `decl`s, we only
really support single-inheritance at the moment. Make c_enumLiteral a
subtype of c_abstractDecl, since there are more properties in `decl`s
than in `expr`s. This should be the only exception in this area we need
to make, since other literals aren't generalizations of decl.
Sean Anderson [Sun, 11 Jun 2023 15:02:42 +0000 (11:02 -0400)]
vhpi: Support char and string values
The native format for character types is vhpiCharVal. Similarly, the
native format for 1-d character arrays is vhpiStrVal. Use these formats
instead of the short enum formats. Note that vhpiStrVals are
nul-terminated, and the terminator is not included in the numElems (but
it is included in bufSize).
Nick Gasson [Sat, 17 Jun 2023 15:19:07 +0000 (16:19 +0100)]
Rework determination of most recently analysed architecture
Avoid using timestamps as well as loading every architecture and instead
establish a total order over all architectures in a library with a new
_sequence file.
Sean Anderson [Sun, 11 Jun 2023 03:54:26 +0000 (23:54 -0400)]
vhpi: Fix use-after-free when removing callbacks (part 2)
I made a first attempt at this back in commit a21a360e ("vhpi: Fix
use-after-free when removing callbacks"), but I didn't fix the global or
value callbacks. These can also have use-after-frees, which can be
triggered consistently with a pair of "mutually-removing" callbacks.
They are set up so that they trigger on the next cycle, and they try to
remove themselves. This fails without the fixes in this commit.
The main approach is to give rt_watch_t the same treatment that
c_callback got: adding a flag to free the watch after the callback
completes. Global callbacks are a bit simpler, and can mostly be treated
like timeout callbacks; if we don't find anything to remove, the
callback must be currently-enqueued, so we shouldn't free it.
Fixes: d6e523a4 ("vhpi: Free callbacks in remove")
Sean Anderson [Sat, 10 Jun 2023 23:04:30 +0000 (19:04 -0400)]
vhpi: Fix incorrect range calculation
Null ranges have zero length. Detect them properly by basing the
direvction of the range on IsUp instead of whether LeftBound >
RightBound. The comparison in init_indexedName can stay the same since
it is guarded by build_indexedNames.
Fixes: 2052a42f ("vhpi: Rework size calculation") Fixes: 9416eb6e ("vhpi: Add support for IndexedNames")
Sean Anderson [Sat, 10 Jun 2023 21:06:48 +0000 (17:06 -0400)]
vhpi: Fix NULL-pointer dereference in vhpi_get_by_name
strtok_r returns NULL when there are no more tokens in the string. When
passed a name matching scope's name, but without a colon or period, we
call strtok_r twice, getting NULL the second time. Because the name
matches the region, fix this by returning the region.
Sean Anderson [Mon, 29 May 2023 21:39:41 +0000 (17:39 -0400)]
vhpi: Add support for getting/putting IndexedNames
This allows getting/putting nested arrays, and individual elements of an
array. The final index calculation is done lazily, although this
could be done eagerly by moving it to init_indexedName.
The tests for indexednames and the various enum types are extended now
that it is easier to access them.
Sean Anderson [Mon, 29 May 2023 21:49:14 +0000 (17:49 -0400)]
vhpi: Fix vhpi_get_value with EnumVecVal format
The Logic, SmallEnum, and Enum formats were not treated consistently.
Sometimes the wrong value type was used to store signals, and the
variable signal size of Enum was not handled properly. The correct
relationships for these types may be seen in the following table:
Format Value type Signal size
================ ============== ===========
vhpiLogicVal vhpiEnumT 8
vhpiSmallEnumVal vhpiSmallEnumT 8
vhpiEnumVal vhpiEnumT variable
In order to handle the variable size of Enum, we need to use FOR_ALL_SIZES
from model.c. Move it to util.h, and rename a conflicting macro with a
similar purpose. This also adds support for getting SmallEnumVecs.
This adds a test for the Vec versions of these formats; the non-vec
versions will be tested when indexedName get/put support is added.
Sean Anderson [Mon, 29 May 2023 21:04:52 +0000 (17:04 -0400)]
vhpi: Add support for IndexedNames
IndexedNames (e.g. `a(0)` or `a(2, 3)`) are necessary to access elements
of nested or multidimensional arrays (which have too many dimensions for
vhpiLogicVecVal) or to set individual elements of single-dimensional
arrays. Add basic support for these objects.
Although objDecls are names too, they also include the decl properties
which we don't want. Therefore, we use a separate hierarchy for
exprs/names. For future work, it might be nice to use the object
framework (tree_t, type_t, etc) for VHPI as well.
IndexedNames are created lazily. This is useful for nested arrays. For
example, a signal like
type a is array(0 to 9) of std_logic_vector(31 downto 0);
signal b: a;
might only be accessed like `b(0)` and never like `b(2)(3)`.
The encoding of prefixedName varies slightly from the UML. To reuse the
above example, while the UML says that the prefix of `b(0)` is `b`,
we set prefix as NULL in this situation, using simpleName instead. This
makes it easier to walk nested prefixes, since we don't have to compare
prefix to simpleName.
To populate IndexedNames, we must iterate over all constraints on the
array, and create `c_indexedName`s for each. One option here would be to
pass BaseIndex to init_indexedName. However, this would require decoding
the BaseIndex into indices for each constraint. Indead, I chose to pass
the indices directly, and create BaseIndex from them. I think this is
easier, because it doesn't involve any division.
Sean Anderson [Mon, 29 May 2023 20:11:56 +0000 (16:11 -0400)]
vhpi: Rework size calculation
IndexedNames represent a subset of the elements in a signal. Their size
is dependent on their type. In preparation for adding IndexedName
support, rework the size calculation to be based on the type of the
object instead of the width of the backing signal.