The issue was that the types analysis was osr-aware, where
we would only type-analyze the sections of the function
accessible from the osr entry point.  The phi and definedness
analyses were not osr-aware, so they would think that phis
in certain places where the type analysis knew that they
were undefined.

So this change makes definedness and phi analysis osr-aware,
where they only analyze the appropriate section of the function.
I think this means that we will do these analyses more, since we
have to rerun them for each entry point, so hopefully analysis time
doesn't increase too much.

Speed-up analysis and irgen

this descreases the number of symbols / stackmap constants size slightly

because the time measurement takes more time than retrieving the cache entry

Take another pass over the CPython test suite

Jit cache misses

Speedup analysis by using llvms more cache friendly map/set algorithms

Iterate over the symbol table in sorted order.

I thought it would have been a problem with the -n optimization flag which we
would want to hunt down, but I think it might just be an issue with the parser.
Don't have a good idea why though.

Conflicts:
	CMakeLists.txt
	tools/tester.py

Increase test parallelism on pyston_old_parser

We were casting a 2-bit bitfield to a char using a union, which
gave us a nondeterministic result.  This works fine since we
don't care about those other bits, but it causes cache misses.

Add a cache for JITed object code

Should not change the generated output.

for test/integration/django_test.py
us_compiling_analysis_definedness: 130569 --> 29087
us_compiling_analysis_liveness: 132502 --> 102092
us_compiling_analysis_phis: 229944 --> 188633
us_compiling_analysis_types: 214522 --> 36165

We added a couple of features that the tests used to be running
into, such as exec and extslice.  Now a lot of things are blocking
on doctest, for which the main difficulty is compile().

with some minor changes to try to get it working

Switch travis-ci to docker infrastructure

Adds the LZ4 compression library and use it for compressing cached objects.
This saves alot of space (on my test it reduces the required space to about one-tenth),
and adds a checksum to the file in order to detect truncated cache files,
without reducing the speed.

When remapping generator expressions / set+dict comprehensions,
we create an explicit new function, which will later get run
through CFG again.  With the new changes, we can't use a nodeName()
that was generated in the parent scope, since that will end up clashing
when the generated scope generates its own names.

I think it's not too bad to fix since in these cases the arguments are only
ever used inside of the inner scope, so we just have to use names that aren't
used elsewhere.

We still need to generate the IR but if we can find,
a cache file created for the exact same IR we will load it and
skip instruction selection etc...

-stop manually downloading cmake

- increase the time limit here
- Have the tester print out the stderr when a test fails with the wrong exit code;
  this might make things spammy but I hope that it will be more helpful.
- Base EXTMODULE_DIR_PYSTON off the executable, not the tester
- modifying os.environ has no effect, even when spawning subprocesses...

Until I can figure out what the issue is that's making them fail.
(I don't feel great about removing tests, but I just added these a
few commits ago, so I think this makes the most sense for now.)

- generalize dynamic loading support
- copy include files to cmake build directory: we don't need it for our build,
  but we need them to be there for building extension modules
- some beginning hacks for supporting Cython

(increase the reopt and osr thresholds by 2x)

This helps django a ton.  will probably hurt our microbenchmarks
but I don't care much about those right now.