Pyston will try use the gcc which found in system path to compile
itself. But llvm and clang will use the gcc in /usr/bin dir by
default. This different will cause inconsistency in some situation.
So add -DGCC_INSTALL_PREFIX to let clang use same version of gcc as
Pyston used.

reduce the size of CFGBlocks

More misc compatibility fixes

and disable a sqlalchemy test that was overspecific

We had a few places where we added BoxedBuiltinFunctionOrMethod, which don't
have bind-on-get behavior, causing issues with __call__

(a == b) != (b == a)

This is not quite right since type.__call__ isn't even a proper function in
CPython.  But our handling of it is complicated enough that I think it's
worth trying this workaround for now.

for things (our build tools) that look for "python" explicitly.

Add "log hashing" to see new failures

transform BST to gapless bytecode inplace

A common issue is that we see that a test goes from N failures to N+1,
but it's not clear at all which of the failures is new.

This adds a simple hashing mechanism to try to help us in these cases:
we hash each line in the log, and construct a small bloom filter of
which lines were seen.  We can then put this into the test file, and
when the test fails we can run the received output against the expected
bloom filter.

I tried testing it and it seems ok, but we'll have to see how well it
works in practice.

this simplifies the code and removes a lot of ugliness

Get dict ordering closer to CPython's

Typo fixes from PR #1389

- 64 bit hashes in a couple more places
- insert-then-grow, instead of previously doing grow-then-insert
  (changes the order of reinsertion during the grow)

Rather than switching to CPython's dict implementation, which would
be quite a bit of code changes (since we use our internal dict interface
a lot), change our current dict implementation to more-closely match CPython's.

In particular, change the growth strategy and probing strategy to match cpython's.

I'm not sure how I feel about this -- there are still a number of differences.
In theory this is still an improvement over the current status quo (fewer ordering
differences), but I don't know if we need to go all the way and make sure to have
zero ordering differences.

jemalloc: build with profiling support

I think we get one more failure because http://pythonpaste.org/ is down but I'm not totaly sure.
master runs into the same problem but did not 12 days go

cpython encounters the same error
I took the opportunity to switch to py.test from nose
now that we support it and this is how one should test this package.

Minus the ones to code that we inherited from CPython or LLVM,
in order to keep those diffs clean.

- all instructions of the CFG are directly emitted a single memory region
- all instructions are packed and follow each other directly
- the CFGBlock just stores the offset into the bytecode where the first instruction of the block is located
- invokes are only a bit in the opcode field which when set means that the pointers to the normal and exc CFGBlocks* directly follow the normal instruction