Remove read from freed memory
Fix read of uninitialized variable
Currently many places in the codebase create AST_Jump objects but do not initalice the line ,col numbers. Set them to -1, in order to not call SetCurrentDebugLocation with random locations.
Update chr to be compatible with CPython
Merge pull request #83 from kkszysiu/chr_fixes

Update chr to be compatible with CPython
Ok good, the args were already guarded
Merge pull request #81 from undingen/iterator_invalid

Remove read from freed memory
Initial, very broken, implementation of threads

Well, the thread-creating should work, but nothing is threadsafe.
This one crashes Pyston reliably
Add a gil

Don't worry, a non-gil version is coming.
Use a gil for now so we can start working on the other threading
requirements, such as GC.
Use signals to get the registers of other threads
Need to set up the threading environment for the unittests
Crawl the stacks of all threads for GC roots

I think threading now "works" ie doesn't crash Pyston,
though we don't release the GIL until the thread exits.
Change stack crawling to not be based on unwinding

We always want to crawl the entire stack, and it's
possible to determine the extents of the stack, so just
do a scan over the entire memory range.

Also, change the way the interpreter keeps track of its roots;
we don't really need to associate the roots with a specific
interpreter frame.

This should hopefully clear up the weirdness about libunwind
trying to unwind through the pthreads assembly code, and potentially
also make stack crawling faster.
Add safepoints, which for now are for GIL checking

Once the GRWL is added, will also be for GC safepoints.
make format
Proactively save the thread registers when calling AllowThreads

And then use that register info rather than sending a signal to the
thread; this lets the thread that called AllowThreads avoid receiving
signals ex during a syscall.

I'm not sure if this is valid though; are we really guaranteed that
the thread can't invalidate the saved state?
Start working on the GRWL (aka gil-rwlock)
Add enough locking to make the GRWL somewhat safe

Add some basic locking to:
- code generation (one lock for all of it)
- garbage collection (spin lock for allocations, global serialization for collections)
- lists (mutex per list object)

Can run the GRWL on some simple tests (microbenchmarks/thread_contention.py and thread_uncontended.py)
Performance is not great yet
Makefile cleanup

Make rules more general, and generate rules that can't be patterns
Made it easy to add a pyston_grwl target
more grwl experiments