C extensions (NumPy) might inherit classes in C code and expect to find
tp_number. This is just copied from CPython's PyType_Ready.

This requires assigning some of the runtime functions to thesq_ and mp_ slots
otherwise there are infinite loops from Pyston attributes.

NumPy is huge, bigger than our previous (arbitrary) number by an order
of magnitude.

rewrite float comparison base on CPython implementation

microoptimizations

rewrite additional nonzero() cases

- improve bool and str hash() speed
- optimize str.find(char)

Use profiling to know when to throw CAPI exceptions

Rewrite string hash and enable test_hash

if we OSR out of a function, make sure we use the same exception
style for the OSR'd version.

We could also have the OSR exit code deal with switching exception
styles, but for now it doesn't feel worth it.

Enable validation of printf-style format strings

I had added the ability but forgot to turn it on.

And fix some of the issues that this found.

Also, allow reraising using CAPI exceptions.

Clean up our exception handling

I use like to use test/tests/t.py and t2.py as temporary test files,
so that they can get hooked into the makefile helpers, but the tester
ignores them.  Do this for t3.py too.

It was pretty unwieldy and handled some disparate parts of the
exception-raising process.  I think things are a bit cleaner now:
- cxx_unwind.cpp handles C++ unwinding semantics
- unwinding.cpp converts C stacks to Python stacks
- exceptions.cpp takes Python stack frames and handles them appropriately

So for throwing a C++ exception, it starts out in cxx_unwind.cpp, which
then hands off the C frames to unwinding.cpp, which then hands off the
Python frames to exceptions.cpp.  When we get exceptions not via uncaught
C++ exceptions (ie explicitly handled C++ exceptions or CAPI exceptions),
those go directly into exceptions.cpp.  There are also non-exception cases
that we want to get the Python stack trace (ex sys._getframe), and those
are handled by unwinding.cpp

We have a couple different ways of walking the C stack
(C++ exception unwinding and non-destructing stack crawling),
and they both want to do this to reconstruct the Python stack.
Extract out the common code.

It had gotten pretty ad hoc.  There were two things it was doing
- some things dealing with unwinding; moved those to codegen/unwinding.cpp
- most of our exception-throwing logic; moved these to a new runtime/exceptions.cpp

Be able to jit functions that throw CAPI exceptions

In theory should help with pyxl which throws a decent number
of StopIterations from calling generator.next() directly, but
pretty few of those calls actually make it into the llvm JIT
to benefit from this.

(Not enabled yet)

Our IR doesn't explicitly represent the data transfer between an Invoke
statement and its corresponding LandingPad.  We use a couple different
techniques to pass it through: in the ast interpreter/bjit, we stash it
into an interpreter-local variable and then pull it back out.  Previous
to this change, in the LLVM tier we would pass it directly through
an exception, using either the C++ or CAPI exception-passing mechanism.

This works but is a pain, since it requires coordination between the invoke
and the landingpad.  These live in different basic blocks, so we ended up
having this other code that lives separate from the normal irgen that has
to decide which exception style to use, and it has to respect certain
restrictions within irgen (ie it has to be careful to not request CAPI
exceptions for cases that we haven't added support for yet).

This commit changes the approach so that the exception data is passed
directly as LLVM Values, and its up to the Invoke to figure out how
to get it into that form.  This adds a bit more complexity to the invoke,
but it should make the interface easier to extend (such as in the next commit).

Which piggy-back on the integration tests for getting their dependencies.

fix a few generator problems

this all showed up by running test/cpython/test_generators.py
sadly there are still a few until we can run the whole test

Rewrite unaryop and property get

more capi exceptions

I think we track the dependency correctly in cmake, but distutils
doesn't know that the system headers can change from underneath it,
so manually specify them as extra dependencies.