This will be used for converting function return types soon, so
generalize it a bit.

- abi.cton is for testing the actual RISC-V ABI.
- legalize-abi.cton is for testing the legalize...

These low-level functions allow us to build up a list of instruction
results incrementally. They...

This makes it possible to compute the first result of an instruction in
a different way without ...

Instead, just return the first of the detached values, and provide a
next_secondary_result() met...

This better matches the detach_secondary_results cousin.

Also rename the converse put_ebb_arg -...

The type signatures of functions can change when they are legalized for
a specific ABI. This mea...

This method returns an object that can display an instruction in the
standard textual format, bu...

When the CRETONNE_DBG environment variable is set, send debug messages
to a file named cretonne....

The Python code computing this property had a bug. The property has only
been used for optimizin...

Now that some instruction formats put all of their value arguments in a
value list, we need to k...

Lots of changes this time.

Worked around what looks like a rustfmt bug in parse_inst_operands w...

This method opens up a hole in the middle of a list where new elements
can be written.

Any code that needs to manipulate a variable argument list on an
instruction will need to remove...

The value_list flag can be inferred from the presence of VARIABLE_ARGS
in the operand list.

The...

Allow some flexibility in the signature matching for instruction
formats. In particular, look fo...

No instruction sets actually have single instructions for materializing
vector constants. You al...

Instruction formats are now identified by a signature that doesn't
include the ordering of value...

Part of the refactoring of instruction formats. This list is now stored
in the instruction itsel...

An instruction format is now seen as having two separate operand lists:
immediates and values. C...

This field is no longer needed. We can use imm_members to get the names
of immediate fields, and...

Use the new Instruction fields instead.

The per-instruction format low-level constructors in InstBuilder should
be independent of the re...

These two tuples contain operand indexes of the explicit value operands
and immediate operands r...

No functional change.

Now that variable arguments are always stored in a value list with the
fixed arguments, we no lo...

Make some changes that will make it easier to get rid of the
'value_operands' and 'members' fiel...

Now that all variable_args formats use has_value_list, we can remove
some workarounds that allow...

With the Return and ReturnReg formats converted to using value lists for
storing their arguments...

The Branch format also stores its fixed argument in the value list. This
requires the value pool...

Add a new kind of instruction format that keeps all of its value
arguments in a value list. Thes...

Read the Docs is now using the latest version of Sphinx, so upgrade our
recommended version too....

If func.locations has not been properly resized to have an entry for all
values, we should just ...

Add a Function::display() method which can include ISA-specific
information when printing the fu...

This was particularly confusing when reading a file with Windows line
endings. The CR would beco...

Translate the small integer arguments to i32 or i64 with the appropriate
extend and ireduce inst...

Add support for two new type variable functions: half_vector() and
double_vector().

Use these t...

Insert conversion code that reconstructs the original function argument
types from the legalized...

These two methods can be use to rewrite the argument values to an EBB.
In particular, we need to...

Add an abi module with code that is probably useful to all ISAs when
implementing this function....

This entry point will be used for controlling ABI conventions when
legalizing.

Provide an empty...

The argument locations contains register unit references that we want to
display with their corr...

These functions return an object containing the necessary ISA info to
print a ValueLoc or Argume...

The List and Dict types are no longer implicitly available. They must be
imported from typing.

...

Rust 1.12 did work at one point, but Travis is testing against the
current stable and beta relea...

Fixes #46

Specify the location of arguments as well as the size of stack argument
array needed. The ABI an...

This will be used to amend function signatures with ABI lowering
information.

Fix a few other minor issues with the documentation.

Collect the data structures that hang around between function
compilations.

Provide a main entr...

This is a bare-bones outline of the SSA coloring pass. Many features are
missing, including:

- ...

The value locations appear after the encodings:

> [R#0c,%x2] v0 = iadd vx0, vx1
> ...

Run functions through the register allocator, and then filecheck.

Some polymorphic instructions don't return the controlling type
variable, so it has to be comput...

Register-style return is used by all RISC architectures, so it is
natural to have a shared instr...

When the liveness pass implements dead code elimination, missing live
ranges can be used to indi...

Add a compute() method which can recompute a dominator tree for
different functions.

Add a domi...

Move the flow graph computation into a compute method which can be
called with multiple function...

We Don't need to expose the internal control flow graph representation.

This will provide main entry points for compiling functions, and it
serves as a place for keepin...

This is just for better error messages etc.

Most of the register allocator algorithms will only have to look at the
currently live values as...

The coloring algorithm needs to process these two types of live values
differently, so we may as...

The struct is just a pair of static references, and we don't need the
double indirection.

This lets us iterate over the blocks in a function without holding a
reference to the layout.

Keep track of which values are live and dead as we move through the
instructions in an EBB.

Partition the elements in a mutable slice according to a predicate.