The DFG keeps track of instruction definitions, values, and EBBs.
Store the primary definition of each instruction: Opcode and operands.
Track SSA values as either the result of an instruction or EBB arguments.
This supports the pattern of creating structs wrapping a u32 and using them as
indexes into a vector of entities. These entity references should implement the
EntityRef trait.
The EntityMap is a generic map from an EntityRef to some value type. It expects
densely indexed entities and uses a Vec to represent the mapping compactly.
The icmp and fmp instructions use different kinds of condition codes because
integers and floating point values behave differently.
Add a CondCode trait implementing shared behavior.
Add an external dependency to the docopt package and use it for a scaffold
command line interface for the cton-util command.
I am not too happy about taking external dependencies, and docopt pulls in 13
other packages. However, I really don't want to be writing command line parsers,
and as long as the external dependencies are confined to the tools crate, we
should be fine.
The core cretonne crate should stay free of external dependencies to avoid
trouble with embedding it.
Implement a basic 'cat' subcommand which currently behaves like unix 'cat'. It
will gain parser powers soon.
Avoid gathering too much code in repr.rs.
The `entities` module contains entity reference types, and the `instructions`
module contains instruction opcodes and formats.
A function owns instructions and extended basic blocks. References to these
entities are implemented as opaque structs indexing into the functions internal
tables. This avoids fighting Rust's ownership checking and it also makes
references 4 bytes on all platforms.
SSA values are identified similarly, but with an optimization for the first
value produced by an instruction. Very few instructions will produce more than
one value, and there is an extended value table for those.
