ICs: variable size IC slots

Add type.__basicsize__, type.__itemsize__

Dictionary comparisons

bjit: fix failed OSR

OSR can fail in some cases and we have to continue with interpreting in this cases.

CPython has quite a bit more logic than just 'try __cmp__'

Get test/tests/dict_comparisons.py working.
change test timeout -t75 to -t90

before this change we had a fixed number of equal size slots inside an IC.
Because of the large difference in rewrite sizes a fixed slot size is not ideal.
We often ended up with too large slots which prevented us from emitting more slots.
(or very large ICs in general which are bad for memory usage and the instruction cache)

With this commit we will start with a single slot with the size of the whole IC and then decreasing its size to the actual bytes emitted
and creating a new slot which starts directly at the end of the previous slot.
We will repeat to to this until the space left is smaller than the number of bytes the last slot required.
This makes it a little bit less likely that we will be successful in overwritting an existing slot
but our benchmarks show that it is still a large win on all our benchmarks.

Some notable changes are:
- we pick the slot to rewrite much earlier now and prevent it from getting rewritten while we rewrite using num_inside = 1
  the reason is that we would otherwise not know how big the slot is
- when we resize a slot we have to patch the failing guard jumps to the address of the next slot

Some scipy related fixing.

Enable function.func_closure and function.__new__

In Pyston, has_getattribute got set if __getattribute__ is overridden,
but only tp_getattro is supposed to set __getattribute__ and tp_getattr
will not set it. So add a check to update_one_slot, if type->tp_getattr
is not NULL, don't set has_getattribute to False.

enable the clang travis CI build again

This reverts commit d1b799e5.

Fixes part of #1263

The function PyCFunction_GetFunction(func) check func type should be
exactly PyCFunction_Type. PyCFunction_GET_FUNCTION(func) does not check
func type. But assumes func layout starts with PyCFunctionObject. i.e.
for allowing func to be PyCFunction_Type subclass.

This way an extension which subclasses PyCFunctionObject will get
into trouble using PyCFunction_GET_FUNCTION() on Pyston

Add some helper API to Pyston.

rewriter+bjit: remove duplicate getattrs, misc codegen improvements

this saves a few bytes by replacing some movabs imm64, reg with smaller instructions

before when we allocated scratch space we always needed one more reg to store the address of the scratch space
this address is a constant stack offset so this was not needed because it can be recalculated like to a constant value

e.g. relative or absolute using a temp register

this transform some xdecrefs to decrefs
and removes some calls of assertNameDefinedHelper

problem was that the bumped the variable to late which caused an extra spill

I think we need a place to test new added C API. And Pyston missed
PySet_Size implementation(already declared it). Add and test it.

Add more line numbers

We've been a bit lazy about adding line numbers to all ast nodes.
This is an inconvenience when the tracebacks are bad/wrong, and it's
also causing issues for testing code that wants to look at the line
at which something failed.

So I added line numbers to a whole bunch more nodes.  There are still
quite a few that don't have line numbers, but many of them are harmless,
so I tried to identify the ones that matter.  I also added some assertions
to make sure that bad (non-positive) line numbers don't escape to the user.

This issue is that type analysis is stronger than irgen.
Specifically here, type analysis knows that the phi isn't required
and propagates the type across BB's, but irgen conservatively promotes
to UNKNOWN.

Fix some leaks related to signals

The IR we generated looked something like this:

1: i64 %a = doIC()
2: checkPendingCalls()
3: Box* %b = (Box*)%b

The problem is that the refcounter only knew about %b, starting on
line 3.  So for line 2, the refcounter didn't think it needed to decref
%a if an exception was thrown.

So the first thing this commit does is it adds check that when we refcount-track
a value, if it is a cast, then the cast must be right next to the thing it is casting.
This is stricter than we need but it should be easy enough to do and be sufficient.

Another approach would have been to have the refcount checker be able to track the
non-box-like values, ie track %a in the above example.  This would need some checking
to make sure that people didn't forget to track that.  In the end I thought this would
be simpler.

The second thing is it adds a helper function createAfter that inserts the cast in
the right location.  This could have worked by having createIC do the casting itself.
But this was a little bit tricky since some callers want to know the Instruction of the
call itself, and if createIC only returned the cast then those would get confused.  It
could have returned both, but that seemed complicated.

We would leak refs if an exception was thrown via the pending-calls handler.

Previously we would print out all leaked objects at program exit.
But this is problematic since it includes both directly leaked objects
(the ones we are interested in), and indirectly leaked objects
(which only got leaked by being referenced from another leaked object).

This uses the cycle collector infrastructure to figure out what objects
have non-heap, ie leaked, references remaining.  Hopefully this should
help us debug cases where there are hundreds of objects remaining.

perf: add a script which allows 'perf report' to disassemble JITed functions