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.

Sort of keep track of registers and register classes. Start walking the
generated instruction tree --- holy cow, they look like instructions!

Collapse several rule arrays into one; actually generate the array properly.

Rename struct insn to struct em (throughout).

Stupid stringlist is stupid. Use a proper data structure, properly abstracted
out (so other things can use it).

Rethink the way patterns are mapped to rules; generate emitters (probably
badly).

We now record the code fragments to be emitted by each rule.

Instruction selection is so important the file needs a longer name.

Some instruction selection is now happening.

More grammar changes.

IR codes are now owned by mcgg; ir terminals are inserted into the table during
compilation (so you can refer to them).

Crudely bolt on mcgg to mcg itself.

Parameters are parsed with getopt. Simplify, constify.

Change the predicate stuff to use costs instead; now you can use when clauses
on leaves. Remove an iburg premature optimisation (required for above).

Lots of exploratory new grammar for instruction definitions and string and
fragment emission (none of which is hooked up to anything yet).

Add support for labelled tree nodes.

Fix some late-night typo bugs.

Procedure compilation now happens after the entire EM file has been read in (so
that we can look inside data blocks which might be defined in the future...
sigh, csa and csb). csa and csb no longer generate invalid IR.

Replaced the block splicer with a trivial block eliminator (which rewrites
jumps to blocks which contain only a jump). Don't bother storing the bb graph
in the ir nodes; we can find it on demand by walking the tree instead ---
slower, but much easier to understand and more robust. Added a terrible map
library.

Each pass now lives in its own source file; much cleaner.

Add a bodged in algorithm for converting basic block communication from stacked
variables to SSA. Also add dead block removal and block splicing. IR code is
much better now.

Tracing cleanup. Simplified the IR code. Some more opcodes.

Massive grammar overhaul and refactor. Hacked in support for predicates, where
instructions can be turned on and off based on their parameters. New lexer
using a lexer. Now quite a lot of the way towards being a real instruction
selector.

Run through clang-format.

Strip out surplus files. Rewrite README.

Import iburg.

Import iburg.

Create hacky fake basic blocks for data fragments, used to track which
instruction labels descriptor blocks refer to; this allows csa and csb to know
where they're going.

Treebuilder now gets to the bottom of my test file, merrily generating
(probably horribly broken) IR.

Store the EM code up front and build the basic block graph *before*
generating the IR code. Lots more IR code.

Archival checking of the half-written IR treebuilder.

ANSIise to fix warnings.

Abstract out the EM reader; skeleton of the tree builder.

Basic skeleton of em parser.

Merge pull request #3 from kernigh/ego-fix

Fix bugs with memory allocation in ego.

Fix bugs with memory allocation in ego.

cf/cf_loop.c and share/put.c tried to read the next pointer in an
element of a linked list after freeing the element.  ud/ud_copy.c
tried to read beyond the end of the _defs_ array: it only has
_nrexpldefs_ elements, not _nrdefs_ elements.

These bugs caused core dumps on OpenBSD.  Its malloc() put _defs_ near
the end of a page, so reading beyond the end crossed into an unmapped
page.  Its free() wrote junk bytes and changed the next pointer to
0xdfdfdfdfdfdfdfdf.

Add unlink system call.

Cleanup some stray files.

Add modeline, fix formatting.

Updated.

More documentation.

First half of the ackbuilder documentation.

Makefiles are now slightly less inaccurate. Does actually seem to do sensible
incremental builds now. I loathe make.

Add an install target.

Distributions are a pain --- let's not bother any more. Instead, we just tag
the repository and download a complete snapshot, old and ancient stuff and all.

Remove the old make-based build system, plus some big chunks of horribly
obsolete protomake build system.

Clean up the top level makefile.

Fix a fun bug where, every now again, ego would get its temporary files mangled
and generate invalid calls to the optimisers.

Previously ego would generate a temporary file template that looked like
/tmp/ego.A.BB.XXXXXX, call mktemp() on it to randomise the XXXXXX, and then
replace A and BB with data.

However, it used strrchr to find the A and B. Which would fine, except when
mktemp produced an A or a B in the randomised part...

This code was written on 4 March 1991. I was 16.

Forgot to check a file in.

ego now builds and is used.

This needed lots of refactoring to ego --- not all platforms have ego descr
files, and ego will just crash if you invoke it without one. I think originally
it was never intended that these platforms would be used at -O2 or above.

Plats now only specify the ego descr file if they have one.

filenamesof() an installable now returns all installed files, not just the ones
at the top level (necessary to make a lot of the dependency stuff work when
using tools which depend on installables).

Fix linking bug where em_decode would generate binary data instead of text.

Run through clang-format.

Run through clang-format.

Run through clang-format.

Run through clang-format.

Run through clang-format.

Push through clang-format.

Run through clang-format.

Push em_ego.c through clang-format before working on it.

Build the examples when doing a normal build; this exercises the compiler as a
whole and is one step further towards a proper test suite.

aal doesn't build the ranlib table if you don't set -DAAL.

Add files which got missed in the initial build pass.

liblinux is no more; its files are now in libsys.

rpi has a time() function; don't try to call gettimeofday().

Print hex numbers actually properly this time.

Raspberry Pi backend now builds.

Wildcards are allowed to match no files now.

Filename variables now get passed into ackbuilder on the command line.

Fix dependency error (only shows up with make, not ninja. Odd).