The code was already in but it was turned off due to the
compile time regressions.  The addition af kill flags seems
to have fixed it.

We now have the locals() method working and can start to implement
other similar features.

When emitting frame information, we pass all currently-live
variable names.  We clear dead register names at the end of
every basic block, but for long basic blocks we can end up
accumulating many temporary names (one per sub expression).
This ends up hugely increasing the LLVM compilation times since
we will pass hundreds of arguments to many different callsites.

Now, we remove dead variable names as soon as they die.  (Note:
user-visible names are always live since they can always be seen
by the locals() function.)  This means that we pass many fewer values
as frame arguments.

A better solution will be to have a real bytecode language which
encodes such liveness information, instead of mostly-having it and
then discarding it.

We currently specify execution state by the AST node that
represents it, which means that we have to not reuse AST nodes.
Previous to this patch, we were doing that, so this patch
fixes those up.

This patch isn't the cleanest since I think this whole approach
will go away when we transition to a proper bytecode system.

The approach in this changeset is to attach frame args
to every call site via stackmap args.  We make sure that
every callsite is a patchpoint, and serialize the symbol
table into its arguments.

In this patch, that is just used for supporting the locals()
method.

It's currently disabled since it has a hugely negative impact
on performance (LLVM takes much longer to JIT with all the extra
function arguments).

Will make it easier to initialize non-ic patchpoints that
are coming up.

Turned off for now; will need this for a later patch.

Most code wants to have access to the basic types (INT, STR, etc)
but doesn't need to know anything about what methods they support.

Move the commonly-accessed parts of compvars.h into the always-included
core/types.h, and remove almost all of the includes of compvars.h

Allow 64-bit constants.  not sure how we didn't run into this before

With the LLVM patch, it seems like this works.

Fix isAllocCall check

If we allocate a callee-save register that the parent function had
not also allocated, change its value, and then call a function
that then unwinds, the unwinder would pass the new (incorrect)
value of the callee save register to the next frame.

We either need to
- make sure callee-save registers are restored before any potentially-throwing
  callsite, or
- make the unwinder able to restore these registers for us, potentially
  by writing our own exception unwinder.

For now, the easiest thing to do is to disallow allocation of those registers.
(I'm not even sure how much we allocate them at all at the moment.)

Closes PR #188

Will get rid of it once it's merged upstream

Just let the rewrite continue but stop emitting any assembly,
and then at the end abort the rewrite.

fixes #169 - allow a negative step in xrange

Previously it would always link against the system libstdc++; not sure how
that was working.

Also, put that in its own included makefile so that we can track the dependence
on the configuration parameters (otherwise you would have to run a configuration
manually to get this change).

Make some things owned by the cf rather than using global registries,
so that 1) we can eventually free the right things when we start freeing
cf's, and 2) we can have a single ip->cf mapping instead of lots of
ip->other things mappings.

Also added some helper classes for making stack crawling easier.