Conflicts:
	src/core/ast.h
	src/core/cfg.cpp
	test/tests/sys_test.py

This lets class & function definitions become ordinary assignments in
the CFG, which simplifies our invariants and fixes problems with the
interaction between definedness analysis and block-terminating
"invoke"s.

Add a simple 'code' type (ex f.func_code), and some related
things like f.func_defaults.

This implementation isn't super performant or consistent, but
I think these particular features are relatively rarely used?

Misc fixes for pip search part 2

print HASNEXT primitive properly

We were getting some gc issues with these, I think because there
could be GC pointers behind the GC-opaque shared_ptr pointers.

Just make impl be a conservatively-allocated object so that the
collector will find it while scanning.  We still need to explicitly
call BoxIterator::gcAlloc if we store a reference (ex for BoxedEnumerate),
but this should mean that we keep these alive when they are just on
the stack (ex when we do a for-each loop over pyElements).

I don't really like how this turned out, but I think the better option
is to get rid of the indirection.

Also fix str.rpartition, and add a signal handler for SIGUSR1 that
prints out a stack trace.  I wanted this because our stack unwinder
doesn't work when called from a gdb print command, so it was hard to
debug why we were in an infinite loop.

Also, fix the '-i' argument so that we get back to the repl if the
program throws an exception.

It's trickier than just setting all of the attributes, since any updates
to either the original dict or to the object's attributes will get
mirrored in the other object.  I don't know if anyone uses this,
but I don't think there's any good way for us to tell if this is
going to happen so we just have to be conservative.

So, add a new distinction between "types" of hidden classes, and add
a new "dict backed" type.  Instead of having an array of attributes,
has a single attribute which is a dict.

There are some pretty tricky corner cases that we don't support yet,
such as if you access and save __dict__, then set __dict__, and then
try to access the saved version.  At least we can detect that and fail.

cmake fix libunwind flags

- Inherit simple_destructor from base classes
- Handle unreachable code better
- Call reprICAsString instead of reprIC
- Fix self-assignment checking bug

-don't pass empty CFLAGS='' when buliding libunwind in release mode
-revert libunwind to older version that has per thread caching enabled
and match Makefile

- exceptions_test: exceptions_test now succeeds, unless we're JITting.
  It fails due to a bug in llvm codegen having to do with definedness
  analysis; see comment in emitBBs in irgen.cpp.

- with_{class,functiondef}, try_{class,def}: Expose the same JIT bug
  that occurs in exceptions_test.

- try_return_finally: We used to flip an internal assert in
  compareKeyset when JITting this test, but it's fixed now.

- file_closed: Files have a `closed' attribute in Python, but not yet in
  Pyston.

- finally_except: Our CFG pass had some corner case bugs when nesting a
  try/finally inside a try/except. This checks they're fixed.

- try_continue: The CFG pass has a bug in its syntax error reporting.

- with_continue, try_continue: Checks that `with'/`try'/`finally' handle
  syntax errors properly.

- with_ctxclass_instance_attrs: Checks that we're accessing
  context-manager attributes on the context-manager's class, not the
  instance, when we run a `with'. As it turns out, our AST interpreter
  has a bug in ClsAttribute (I think) which means that we don't. Our JIT
  works ok, though.

- with_ctxclass_order_of_access: Checks that we're accessing
  context-manager attributes in the right order when we run a `with',
  which we are.

- with_file: Our `file' object runtime previously didn't support `with'
  properly. This checks that files work with `with'.

(turning up the collection frequency helped with this a lot)

- register some memory as a static root
- use StlCompatAllocator in the ast_interpreter
- zero out memory in the (hopefully uncommon) cases we call PystonType_GenericAlloc
- when we realloc() a conservative block, update its recorded size

Make sure the GC sees the fields of BoxedClassobj and BoxedInstances

misc fixes for running 'pip search'

reduces the parse time for 'import pip' from 120ms to 80ms

Looks like allocating the BoxedSlice before the arguments caused a issue?!?

Add some stack frames before where all the exceptions happen.
This makes us take some obscenely large amount of time, particularly
since we currently generate a traceback for the entire stack when
an exception is thrown.

Idea from Marius.  This seems to improve exception performance quite a bit,
though interestingly also some of the other benchmarks as well.

like we had to do for getattrGeneric and setattrGeneric

I guess all the other slots will eventually follow as well.