They were previously represented as strings, like in cpython,
but we want to treat them like names.

Maybe not the best place to start

rather than implicitly via being missing in the hashtable.

Track down an elusive reference leak

The pattern seems to be that we invalidate an IC (deregestering the decrefinfo),
but there is a stack frame in that IC and furthermore that stack frame will
get unwound via an exception.

The fix I did here is to not deregister the decrefinfo if num_inside>0.

capi: add the direct access macros back

deinitFrame: don't modify CAPI exception state

If a CAPI exception was set and we called deinitFrame in some rare cases calling the finalizers cleared the CAPI exception.
This would cause us to return NULL even though no exception is set #1273 (for LLVM functions compiled in capi mode)
Unfortunately I could not come up with a testcase which triggers it but I verified that it fixes the problem scipy triggered.

fix some scipy segfaults

rearrangeArguments added a extra ref to numpy array in when call numpy
resize function. fixes issue #1275

If rewriter encounter a situation which can't be handled. It will set
the `failed` to `true`. In this situation, just stop to emit code. And
also don't check some assert.

Optimize the llvm refcounter pass

Remove the "CPython executable parser"

Pyston call CPython executable to generate CPython AST. Remove this
"parser", use CPython Parser module by default. Pass "-x" to enable
libpypa parser.

- was accidentally inserting elements into the map when we didn't need to
- the maps are small so use a data structure optimized for that

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