Add parsing support for register aliases.

Lots more opcodes; better eviction behaviour; better register moves. Lots more
PowerPC stuff (some working).

Floating point promotion is less buggy.

Promote values accessed via NOP.

'!' tracing is now always emitted; tracing goes to stderr.

Add support for floating point constants.

Lots more opcodes.

Add li and mr pseudoinstructions.

Bolt mcg into the PowerPC backend. It doesn't build yet, but it is generating
*some* code.

Merge in the unfinished PowerPC branch.

Implement saving of dirty registers onto the stack.

Add missing header that was causing builds to fail on Travis.

Merge from trunk.

Various bits of cleanup; we should almost be ready to try sending this to the
assembler soon...

Oops, forgot to add the output option spec to the string!

References to the stack frame are now rendered properly.

Stop passing proc around, and use a global instead --- much cleaner.

Register spilling to the stack frame works, more or less.

Fix yet another bug to do with IR register outputs.

Function termination gets routed through an exit block; we now have prologues
and epilogues. mcgg now exports some useful data as headers. Start factoring
out some of the architecture-specific bits into an architecture-specific file.

Add a pile of new instructions used by Pascal; I'm going to need to think about
how locals and the local base are handled.

Bytes were sometimes failing to be sign extended correctly.

Allow asm names for registers which are different from the friendly names shown
in the tracing (because PowerPC register names are just numbers).

Some more opcodes.

You can now mark a register as corrupting a certain register class; calls work,
or at least look like they work. The bad news is that the register allocator
has a rare talent for putting things in the wrong register.

Log empty hops.

Reworked loads and stores; it's now *different*, maybe not better.

Factor out the register allocation routines to make them easier to deal with.

Fix stupid issue where hop output registers were being overwritten, leading to
invalid SSA form.

Output register equality constraints work.

Make loads and stores in the table nicer; fix a place where it looked like it
was working but only accidentally.

Keep track of register types as well as attributes --- the type being how we
find new registers when evicting values. Input constraints work (they were
being ignored before). Various bug fixing so they actually work.

Add code to remove unused phis, converting to pruned SSA form, to avoid
confusing the register allocator later.

Don't allow the same IR to be added to the sequence list more than once
(sometimes happens because op_dup, but makes no sense).

Clean up the allocator a bit, in preparation for making it lots more
complicated; no semantic changes.

A few more opcodes.

A little fiddling with store instructions. The PowerPC is not friendly to
iburg.

Refactored the way hops are rendered; add support for emitting code (although
with no prologue or epilogue yet).

Register allocator now gets all the way through all of my test file without
crashing (albeit with register moves and swaps stubbed out). Correct code? Who
knows.

D'oh, need multiple passes over the edge splitter in order to properly find all
cases.

Calculate phi congruency groups; use them to solve the
importing-hreg-from-the-future problem (probably poorly).

Add pmap_remove().

The register allocator now makes a spirited attempt to honour register
attributes when allocating. Unfortunately, backward edges don't work (because
the limited def-use chain stuff doesn't work across basic blocks). Needs more
thought.

Floating point promotion was broken since the IR float change. Fix.

Add some more opcodes; rearrange the registers to be more PowerPC-friendly.

Predicates can now take numeric arguments. The PowerPC predicates have been
turned into generic ones (as they'll be useful everywhere). Node arguments for
predicates require the '%' prefix for consistency. Hex numbers are permitted.

Basic register allocation works!

Replace pmap_get() with pmap_findleft() and pmap_findright(), to allow lookups
in both directions.

Only allocate an output vreg if the instruction actually wants one.

Instruction predicates work now.

Minor cleanup.

Fix bug where pushes were being placed in the wrong blocks.

Overhaul of everything phi related; critical edge splitting now happens before
anything SSA happens; liveness calculations now look like they might be
working.

Add array_{appendall,removeall,appendallu}.

Refactor the cfg and dominance stuff to make it a lot nicer.

We're not using 'allocates' any more; clean up.

The register allocator is really a pass, so arrange the code like one.

Warning fix.

No, dammit, for register allocation I need to walk the blocks in *dominance*
order. Since the dominance tree has changed when I fiddled with the graph, I
need to recompute it, so factor it out of the SSA pass. Code is uglier than I'd
like but at least the RET statement goes last in the generated code now.

Allowing an input filename on the command line makes debuggers happy. (Then we
don't need to redirect stdin.)

Better constraint syntax; mcgg now passes register usage information up to mcg;
mcg can track individual hop inputs and outputs (needed for live range
analysis!); the register allocator now puts the basic blocks into the right
order in preparation for live range analysis.

Made sure that all files end in vim magic.

Better management of register data. Add struct hreg.

Add a pass to do critical edge splitting.

Added support for the op_bXX conditional branch instructions.

Fix the horror of the startup code; now uses getopt and stuff and the debug
flags can be set as an option.

Remove unused variable (reduce memory usage by 1/10).

Bodge in enough phi support to let the instruction generator complete on basic
programs.

Oops --- hadn't updated the nts array for the new child order.

Don't allocate new vregs for REG and NOP --- a bit hacky, but suppresses stray
movs very effectively.

Massive rewrite of how emitters and the instruction selector works, after I
realised that the existing approach wasn't working. Now, hopefully, tracks the
instruction trees generated during selection properly.

Instruction selection now happens on a shadow tree, rather than on the IR tree
itself. Currently it's semantically the same but the implementation is cleaner.

Get quite a long way towards basic output-register equality constraints (needed
to make special nodes like NOP work properly). Realise that the way I'm dealing
with the instruction selector is all wrong; I need to physically copy chunks of
tree to give to burg (so I can terminate them correctly).

Come up with a syntax for register constraints.

Perform SSA conversion of locals. Much, *much* better code now, at least
inasmuch as it looks better before register allocation. Basic blocks now know
their own successors and predecessors (after a certain point in the IR
processing).

Add array push/pop; fix ghastly memory overrun bug.

Add zrl opcode. Keep track of local sizes as well as offsets.

Add inl and del opcodes.

Refactor mcg.h as it's getting a bit big; keep track of register variables.

Make betterer.

Fix edge case where leftover pushes would occasionally cause infinite loops in
the analysis.

Show expression trees correctly.

Deal with malformed mes instructions emitted by ego.

More rigorous dealing of IR groups; no need for is_generated and is_root any
more (but now passes are required to set IR roots properly when changing
instructions).

We're going to need some type inference after all, I think. Let's do a little
for now and see how it goes.

Predicates work; we now have prefers and requires clauses. Predicates must be
functions. Not convinced that semantic types are actually working --- there are
still problems with earlier statements leaving things in the wrong registers.

It doesn't really make a lot of sense to have BURG nonterminal names different
to register classes, so combine them. Refactor the map code.

Move fatal(), warning() and aprintf() into the new data module (because they're
really useful).

More properly keep track of register classes.

Error check fragment rules which don't emit anything.

Much better handling of fragments (no run-time code needed to distinguish them
from registers) and better handling of individual hops within a paragraph ---
no more ghastly hacks to try and distinguish the input from the output.

You know what, the type inference stuff is a complete red herring. What this
actually needs is a more intelligent register allocator. So, remove the type
inference.

You can tell whether an item already exists in the array when calling
array_appendu() now.

Actually, I don't need vregs: hops work just as well. Particularly if I
restructure things so that I don't need to walk the blasted ir / burg tree
every time I look at an instruction.

Fleshed out hops and vregs. The result is almost looking like code now ---
uncanny.

Move map into the data module.

Revamp the array module not to use nasty macros any more. Slightly more verbose
to use, but definitely cleaner.

Move the array library into the data module.

Keep more data around about ir instructions. Implement a half-baked type
inference routine to propagate information about floats up the tree, so we know
whether to put floats into special registers as early as possible.

Start factoring out the hardware op code.