This makes it possible to refer to entities defined in the source file,
using the source names prefixed with $.
For example, $v20 refers to the value by that name in the sources, even
if it was renumbered to 'vx0' in the parsed file.
Often, an implementation of VariableMap can return references to
internal strings, and Cow::Borrow() allows that without making any
copies.
We still want to allow VariableMap implementations to return owned
strings in case they have to manufacture variable values on demand. The
Cow::Owned() variant does exactly that.
Switch the internal VariableMap implementations over to Cows. It turns
out they can simply store references to substrings of the input test,
completely avoiding string allocation for script-defined variables.
This trait serves as a shared interface for the different kinds of test
commands the 'cton-util test' understands.
Many tests produce output that is run through filecheck for validation.
Provide a simple run_filecheck() function to help with this.
Implement the 'test cat' sub-test which is probably the simplest
possible.
It is common to represent a function as a String, and previously that
required re-validating the UTF-8 in a Vec<u8>. The fmt::Write trait
writes UTF-8 directly into a String, so no extra checking is required.
This also means we can implement Display for Function which gives it a
to_string() method. This makes the function_to_string() method
redundant, so delete it.
The functions in the write module are no longer generally useful, so
make the module private. The Display trait on Function is all we need.
It's not super fast to clone a function, but it is faster than
re-parsing the test case file it came from.
Some tests want to mutate the function, and there may be other tests in
the same script that need the original function.
Use (Function, Details) in place of the aggregrate DetailedFunction.
It turns out that some tests want to clone and manipulate the function
while the details never change.
This code looks overly complicated because it is anticipating running
jobs in a thread pool.
The test files are loaded and parsed, but not actually executed yet.
Errors are reported back to the test runner.
This command accepts files and directories containing test cases to run.
Recursively searches for test files in any directory it is passed.
Actually running tests is not yet implemented.
The result from parsing a function is now a DetailedFunction which
includes all comments that can be associated with an entity.
Comments before the first function are ignored, everything else is
associated with the preceeding entity.
The parse_functions() function still returns plain functions.
Export a single function: parse_functions() which results a vector of
functions parsed from the source string.
Hide the parser and lexer modules. They are not useful to external
clients.
The -c flag to 'cton-util filecheck' will now print out a description of how
the directives are matching the input.
This explanation is also printed when a match fails.
Use the new ISA predicate numbering to emit ISA predicate instructions in the
encoding tables.
Properly decode the ISA predicate number in RISC-V and add tests for RV32M iwth
and without 'supports_m' enabled.
Three predicates affect each extension:
- supports_m determines whether the target CPU supports the instruction set.
- enable_m determines if the instructions should be used, assuming they're
available.
- use_m is the predicate used to actually use the instructions.
Define data types for the level 1 and level 2 hash tables. These data types are
generic over the offset integer type so they can be twice as compact for
typically small ISAs.
Use these new types when generating encoding hash tables.
Emit both level 1 and level 2 hash tables.
Define generic functions that perform lookups in the encoding tables.
Implement the TargetIsa::encode() method for RISC-V using these building
blocks.
We need to generate hash tables keyed by types, so the Python scripts need to
know the index used to represent types in Rust code.
To enforce this, add a new gen_types.py script which generates constant
definitions for the ir/types module.
Also generate constants for common SIMD vector sizes.
