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

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.

Specify older 'mock' version to unbreak sqlalchemy

Small fixes for the baseline JIT

Fix irgen bug for instancemethods

We would try to statically-resolve their getattrs, but there's some
special casing in the getattr logic for them.  Which should be handled
by moving the special-case to a proper tp_getattr, but for now just
add the special-casing to "hasGenericGetattr" as well.

Refactor offset macros to use the C++ built-in instead.

This causes us to do some unwinding which ends up showing up
in the stats.  We have the globals dict available, so just use
that.

Things are a bit complicated because we use "globals==NULL" to
signify certain things, but the asserts seem to be panning out so
I think it's ok.

More small improvements

This probably doesn't matter that much since I don't
think the function names get used during execution,
but they get seen by tools/annotate.py

ie instead of generating the call to compare(AST_TYPE::Is), just
directly do the pointer comparison in LLVM IR.

For c extension classes that define it.  This makes
unicode-subscripting much faster.

An assortment of misc small perf changes

Put the common-case (where we don't do any work) in an
inline-able function, and keep the slow stuff hidden.