Most involved was the recursion checking stuff: switch to
providing the C API thread state rather than our internal
one, since they are mostly the same.

The recursion checking code doesn't mean much while most stuff
doesn't use it, but hey at least it's supported now.

Supposed to call type->tp_alloc(type) instead of PyObject_New

Adding Py_TPFLAGS_BASETYPE and checking it

And some install instructions on how to get a pre-built debug build,
and to put the sources where the Pyston make system expects them.

Add a hook to tell us what functions are taking a long time to JIT (spoiler: still sre_parse.py::_parse)

Special case {int,float,long}.__new__({int,float,str}) for
rewriting.

float.__new__(cls) can return something that is not an instance of cls

Disable rewriting of float.__new__ and int.__new__ in this changeset

If cls is int, and the argument has an __int__ method that returns
a subclass of int (that is not an int), then int.__new__ will return
that.

Will need to make the typeCall rewriting criteria tighter.

I thought it was just an implementation detail, but it has
observable effects from Python.

Was tricky to find a way to do this while still allowing rewriting.
Right now we only attempt rewriting for a whitelisted set of __new__
functions where __new__(cls) always returns an instance of cls.

It's more efficient since __new__ ends up being harder for the
JIT to handle than __init__.

It's also more correct, though hopefully no one relies on this.

Changes here due to the Metadata/Value split.

Had some issues with intermediate commits due to leak
detecting; not seeing them on this later commit.  Hopefully
everything is ok...

Also, set "AlignOperands: true" to continue getting that behavior.

Primary challenge is rebasing past the JITEventListener changes.

Some API changes, but also some considerable functionality changes,
since we no longer get the loaded version of the object file.

They added a feature to get the load address of a section, but not of
a symbol; I think that makes sense so I'll submit a patch for that.

Generators

Previously, we just included a char[] buffer in the generator object,
and used that as the stack.

Now, mmap() a dedicated stack segment for it.  Use MAP_GROWSDOWN so that
the stack is automatically expandable, but add a redzone 4MB down to
limit the maximum stack size.

Turning off frame introspection can make things easier to
debug, but will break features like tracebacks.

If we turn it off, instead of trying to collect a traceback and
crashing, just print out a warning and return an empty traceback.

Previously it was pretty implicit where we rely on the fact that the generator
object will exist on the previous stack, and once we notice the generator
its GC handler will crawl the generator stack.

I think we also missed the generator's registers, but only the top generator
and only if it wasn't the current thread (was unable to reproduce this).

Now, keep explicit track of all the previous stacks that a thread had been on.
This cleans that up, and since things are explicit now, we can also track
where we stopped executing on each stack.  We were doing this hackily for the main
stack before, but now we can do that for generator stacks, which will let
us make those auto-growing as well.

My confidence in this change: low.