fix null check

add support for the _curses, bz2, and grp modules (mercurial needs them)

don't do isNonheapRoot first, since .so's loading at arbitrary accesses can put max/min on either side of our gc heap.

add long.__float__ attribute

Revert "Merge pull request #685 from undingen/interp_gc2"

This reverts commit 78493220, reversing
changes made to 194d51eb.

This was a merge conflict between #656 and #693

Fix lea

baseline jit: directly emit patchpoints instead of using runtime ICs

Don't guard types sometimes

I encountered this issue sometimes with the protobuf integration test.

this also adds support for calling 8 arg functions (=2 stack args)

rewrite some tp_call cases, and reduce calls to getTopPythonFrame

use inline functions instead of casting function pointers

Fewer mallocs

interpreter: Don't GC allocate ASTInterpreter instances.

Print out the last N lines of a failing test instead of first N

after adding these modules, virtualenv_test now tries to access file.mode, which we hadn't exposed before.

And also bump N from 200->500

Fix analysis_unittest after tiering changes

It was failing an assert that doesn't get checked on travis-ci,
which only tests release mode :/

GC allocating the huge number of large ASTInterpreter instances is slow,
instead add a small wrapper object which gets GC allocated and notifies the ASTInterpreter.

tiering refactoring

This was vistigial from the old llvm interpreter, where we it made a bit more
sense.  Now it's just weird, and caused the tiering logic to be spread into
weird places.  It was also the source of some bugs, since when we would deopt
there's not really any relevant CompiledFunction that represents the deopt
frame (this is why type speculation had to be temporarily disabled).

So instead, make it so that the interpreter (and by extension, the baseline
jit) work on the CLFunction directly, since the CompiledFunction didn't hold
any relevant information anyway.  This require a whole bunch of refactoring and
API changes.

This commit doesn't actually change any of the tiering decisions (I think), but
should just make them clearer; the actual behavioral changes will be done in
upcoming commits.

Module-level code used to return void, but this causes some
special-casing, so switch to having them return None.
Also, CPython has their module code objects return None, so
it's a small compatibility gain as well.

use SmallVectors for some of the rewriter vectors (with enough size to keep additional mallocs from happening.)

the type casts we were using were causing bad things to happen with gcc builds (still not exactly sure
why they aren't in clang builds), since we were casting from a function which expects arguments on the stack
to a function type that doesn't.

this manifests itself as rewrite_args changing from NULL to a small heap pointer on this line:

```
objmodel.cpp:4108    contained = callattrInternal1(rhs, contains_str, CLASS_ONLY, NULL, ArgPassSpec(1), lhs);
```

that is, the local variable rewrite_args is NULL before the call, and non-NULL after.  The actual line that causes
the pointer overwrite is in `bindObjIntoArgs`:

```
objmodel.cpp:3043    arg1 = bind_obj;
```

so I'm guessing that since we didn't push things onto the stack before the call to `callattrInternal`, we end up
trampling over values in `compareInternal`'s frame.