Remove redundant folded_enum function

Handle static expressions with deferred constants that are not folded

Bump OSVVM to 2023.05

Enable make -j by default with GNU Make

Avoid repeatedly re-evaluating array bounds

Use wrapped arrays consistently when bounds are non-constant

Fix incorrect result bounds in lower_narrow

Fix copy/paste typo in 702a234

Fix pointer aliasing warning

Link with Mold if installed

Remove redundant lower_array_scalar_sub_elements

Refactor calculation in lower_array_stride

Missing bounds checks for record ports with unconstrained elements

Error rather than crash with external name in package. Issue #709

vhpi: Add basic float support

Add basic support for floating point types. Getting/putting them is not
supported, but this allows using VHPI on designs which contain floats.

vhpi: Simplify cast_* functions

Simplify some cast_* functions by calling their corresponding is_*
functions instead of reimplementing the same logic.

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")

vhpi: Check that we have enough space for values

Add a bounds check for vhpi_put_values to ensure we have enough space in
the signal for the value.

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")

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.

Add -f analysis option to analyse a list of files

Add selected signal and variable assignments

Implement "ordering on any scalar array type" VHDL-2019 feature

Set relaxed mode when running JIT benchmarks

Adding VHDL-2019 to OSVVM installation. (#622)

Fix visibility bug with VHDL-2019 interface lists. Fixes #708

Optimise memory allocation for access-to-array

Update THANKS.md

Add a --no-collapse option to inhibit port collapsing. Issue #704

Add a textio WRITE benchmark

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.

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.

vhpi: Trace the object name in more cases

Print the object's name when tracing in more cases, adding support for
names and signals.

vhpi: Support BaseIndex

This property is not used by cocotb, but it makes testing easier.

vhpi: Support staticness

Support querying the staticness of expressions. I'm not sure how this
would work for ranges, so I've left them out.

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.

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.

vhpi: Support NumDimensions

Support NumDimensions for arrays.

vhpi: Support LeftBound and RightBound

Support LeftBound and RightBound for IntRanges.

vhpi: Support IsUnconstrained

Support the IsUnconstrained property for ranges and types.

vhpi: Support constraints

Add support for range constraints on arrays and subtypes. I think the
from/to on unconstrained ranges should reflect the from/to of the
underlying type, but I have left that out for now. Currently no
properties are supported, but that will change soon.

vhpi: Support ElemType

Support the ElemType property of Arrays.

vhpi: Add support for subtypes

Add very basic support for subtypes. This is just enough to place them
in the type hierarchy, and not much else. Array subtypes are always
created as arrayTypeDecls, since this will let us expose the element
subtype properly.

vhpi: Pass type directly to init_typeDecl

Anonymous types can't be looked up by their ident, so the decl is for
their base type instead. Pass the type directly instead of using
tree_type to ensure the type matches what it represents.

vhpi: Support iterators in vhpi_handle_by_index

Refactor vhpi_handle_by_index to work with iterators, allowing it to
work with anything that vhpi_iterator does (and vice versa).

vhpi: Support single-element iterators

Instead of creating a list with one element for relations with only one
target, support single-element iterators directly.

vhpi: Move iterator initialization to init_iterator

In preparation for merging the logic in vhpi_iterator with
vhpi_handle_for_index, split off iterator initialization into its own
function. This replaces new_iterator so we can avoid a memory
allocation if possible in vhpi_handle_for_index.

vhpi: Don't scan non-iterators

If we get a non-iterator in vhpi_scan, just return NULL.

Fixes: fb8e5f51 ("vhpi: Support iterators")

vhpi: Move BaseType to c_typeDecl

Each Type has a BaseType. Except for subtypes, the BaseType is the Type
itself. In preparation for adding subTypeDecls, move BaseType to
typeDecl. This allows us to calculate the BaseType when necessary,
removing the need to have a redundant BaseType reference.

vhpi: Extend is_typeDecl to work on all typeDecls

Make is_typeDecl work on all sub-classes of c_typeDecl, instead of just
intTypeDecls.

Fix GMT offset calculation in GMTIME

Make sure $GALLOC opcode never returns a null pointer

Simplify logic in lower_incomplete_access

Change default exit severity to FAILURE

Implement remaining VHDL-2019 date/time functions

Return a non-empty string for TOOL_EDITION

Avoid crash when exiting concurrently with LLVM code generation

Optimise predefined attribute parsing

Attribute 'ASCENDING has a dimension parameter

Implement 'INDEX attribute from VHDL-2019 (LCS-2016-018a)

Skip unnecessary static bounds check during elaboration. Fixes #707

Add support for 'designated_subtype attribute (LCS2016_018d)

Add more tests for VHDL AST dumper

Create FST aliases for collapsed signals. Issue #704

Start adding a unit test for dumper

Rework representation of VHDL-2008 element constraints

Improve test case for issue #705

Add support for matching select? statements. Fixes #705

Add support for array mode view indication

Add support for inout in mode view indication

Simplify handling of 'CONVERSE attribute

Add vhdl-extras to regression tests

Adjust GTKW save file format. Issue #703

The GETENV function should also return conditional analysis identifiers

More efficient handling of ANSI escapes in diagnostics

Fix typos introduced by earlier commit

From @bpadalino

Allow VHDL-2008 rules for static expressions in relaxed mode

Handle aliases of operators

Prevent some cases of cascading errors

Do not translate ANSI escapes to UTF-8

Handle leading NUL characters in report message. Fixes #700

Rework handling of VHDL-2008 nested constraints. Fixes #701

Improve checking for mode view indication

Initial elaboration support for interfaces

Improve checking for interfaces

Add a performance test for unsigned "+"

Parsing for mode view indication

Parsing for 'CONVERSE attribute

Fix coverage generation for unary operators

Unary functions (such as reductions) cause an assertion failure in
lower_logic_expr_coverage. As they operate on arrays, and arrays are
skipped anyway, modify this function to skip such operators. Also remove
a debug print while we're here.

Add a test case to ensure such functions are excluded from coverage.

Closes: #698

Compile Synopsys STD_LOGIC_MISC package for 2008. Issue #696

More checking for view declarations

Fully qualify subtype names

Introduce type_designated to replace type_file and type_access

vhpi: Add some additional callback tests

Add some more tests for callback disabling/removal.

vhpi: Support filling in time for object callbacks

When cb_data->p is non-NULL for object callbacks, it is filled in with
the time of the callback when the callback triggers. Support this use
case.

vhpi: Don't support values for object callbacks

If cb_data_p->value is non-NULL for object callbacks, it must be filled
in with the value of the trigger. We don't support this, so error out
early.

vhpi: Calculate callback timeout at registration

Callback timeouts must be calculated at registration, not at enabling:

> Disabling a callback simply determines whether or not the callback will
> be triggered when its trigger event occurs. For example, disabling a
> callback that is registered to trigger after a given delay and
> subsequently enabling before expiry of the delay does not postpone the
> time at which the trigger event occurs.

Additionally, any data in cb_data_p that we do not save (such as time)
may not be accessed after we return from registration.

vhpi: Fix use-after-free when removing callbacks

Callbacks can generally be in a few states:

- Disabled or mature
- Actively executing
- Waiting to execute

For all callbacks except for AfterDelay, when the callback is waiting to
execute then clearing it will prevent further execution. However,
AfterDelay callbacks can be absent from the eventq_heap in the driverq
workqueue awaiting execution. Clearing these callbacks will not prevent
them from executing.

To work around this, make model_clear_timeout_cb return a boolean
indicating whether a callback was actually cleared. If no callback was
cleared and the callback is not currently executing, then the callback
is in a workqueue. In this case, just free the callback later.
Otherwise, we have actually removed a callback and we can be sure that
it will not execute, so free it now.

Fixes: d6e523a4 ("vhpi: Free callbacks in remove")

vhpi: Allow disabling ValueChange callbacks

Allow disabling ValueChange callbacks by clearing the individual
wakeables. This function could take rt_signal_t and user data, but the
signal is calculated for VHPI callbacks, and it is easier to just store
the watch instead.

model: Correct timing of RT_LAST_KNOWN_DELTA_CYCLE

According to the spec, vhpiCbLastKnownDeltaCycle callbacks can create
further delta cycles:

> h) If the next simulation cycle will be a delta cycle, the remainder of
> step h) is skipped. Otherwise, the following actions occur in the
> indicated order:
>
>   1. Each registered and enabled `vhpiCbLastKnownDeltaCycle` and
>      `vhpiCbRepLastKnownDeltaCycle` callback is executed. T_n is
>      recalculated according to the rules of 14.7.5.1.
>   2. If the next simulation cycle will be a delta cycle, the remainder
>      of step h) is skipped.
>   3. ...

Fire RT_LAST_KNOWN_DELTA_CYCLE before disabling delta cycles to allow
this to happen.