assign fixed slots (vregs) to the symbols.

Use cpythons lock implementation

This switches the thread lock implementation to use a semaphore instead of a mutex.
I hope this gets rid of the threading_local.py error on travis-ci.

This removes a bottleneck of the interpreter/bjit:
most var accesses introduced a DenseMap lookup, with this change we use a fixed offset per var.
The bjit stores the pointer to the vregs array inside r14 for fast accesses.

Not having the ASTInterpreter GC allocated improves performance.
I had to add a small asm function in order to produce a special stack frame where we can easily retrieve the ASTInterpreter*,
to replace s_interpreterMaps job. This also make sure that this function really does not get inlined.
The s_interpreterMap was hard to understand and produced several times problems (duplicate entries,...)

This patch contains a hack which limits the number of variables inside a function to 512.
Because we have to make sure the are all on the stack and can't dynamically add more space.
An upcoming patch will remove this limitation and replace it with a stack alloca of the size of the actual number of variables the function uses.

This switches the thread lock implementation to use a semaphore instead of a mutex.
I hope this gets rid of the threading_local.py error on travis-ci.

Allow passing NULL for empty kwargs

This is a convention that cpython uses that is a good
performance improvement -- unlike tuples, dicts are mutable,
so we currently have to create a new dict for every call
into a kwargs-taking function even if there are no keywords
to pass.

Have to modify the receiving ends to allow NULL kwargs.  This
includes the ast interpreter (which I think will automatically get
the bjit), the llvm irgenerator, and as many runtime functions as
I can find.

Pow

Gcc 4.9 gmp fix

Improve __getattr__ handling

Reduce number of optimization passes we run

bjit: inline trivial helper functions

Release leftover chunk in the TraceStack.

The previous set was based on trying to get the absolute
best results on microbenchmarks; go back to the small set.

Fix gc visiting code for running generators

This is not quite the same as checking whether tp_getattro
has been updated, since setting a __getattr__ will change
tp_getattro.

Usually this isn't that important since we will still need
to do some special getattr handling, but in a couple specific
cases we can optimize based on it.  In particular, this commit
optimizes calls to isinstance(inst, cls) on instances which have
a __getattr__ set: in the common case (no __getattribute__,
no custom __class__) we can know that the __getattr__ will not
get called and we can stay on the isinstance fastpath.

- rewriting a runtimeCall of an instancemethod was broken (this is
  a separate code path from the much-more-common callattr form).
- we don't need to guard on the this->cls as often in Box::getattr, specifically
  in cases that are coming from typeLookup.  Not because the classes are fixed
  (I think they can change), but because they are not allowed to change in a way
  that would change what Box::getattr has the guard for (guarding on attrs_offset
  and tp_dictoffset).
- slightly change the place we guard on tp_getattro and tp_getattr to a place I think
  is a bit more correct (or at least easier to understand as being correct).

ie the way that __getattr__ ends up getting called.  Two main optimizations:
- switch the initial attribute access (ie checking to see the attribute exists
  before calling __getattr__) to use a non-throwing api.  For the typical case,
  even though the throwing would be a C API throw, the construction of the
  AttributeError is relatively expensive, and the object would be immediately
  discarded anyway.
- add rewriting to the function

They both roughly cut out half the overhead of accessing attributes on
classes with __getattr__.

I verified with gdb that this now really visits all entries of the return context struct

Improve isinstance speed

Make sure to intern attribute string in PyObject_SetAttr.

Handle the extensive edge cases related to sequence slicing

bjit: omit frame pointer + use R12 for ASTInterpreter*

isinstance(obj, cls) needs to do a bunch of dynamic checking: it needs to
check cls's class to see if it defines __instancecheck__, and it needs
to fetch __class__ on obj.  Most of those time those aren't overridden,
so __instancecheck__ gets skipped and __class__ returns the type of the object.

So use the same "type slot" machinery to cache whether an __instancecheck__
or custom __class__ attribute have gotten added.  These are a bit different
than the other slots since they are not "wrappers", they are simply bools
that say whether or not the attribute exists.  This makes the slot handling
code a bit messier / more divergent from CPython, but I think it still makes
sense to put this here since we get the hooking-on-attribute-updating and
update-all-subclasses-as-well automatically.