use llvm::SmallVector to reduce allocations

tester.py: canonicalize_stderr: add substitution for object.__new__() error

Implement str.replace maxreplaces

There were a lot of std::vectors in the rewriter and in the invoke
machinery (callFunc and friends), and every std::vector usage involves
a call to malloc (and free when is destroyed.)  we should be using
llvm::SmallVector wherever we can in performance sensitive code, since it
allows a configurable stack allocated buffer.  It reverts to malloc/free
if you blow the buffer's capacity, but as long as things are tuned well,
we can get a pretty significant speedup.

There is more work to be done, but this change gets us ~3% on geomean.

I don't like making extension modules call a function (here called PyGC_AddRoot),
but I think this is something that we can eventually automate (look for stores
to static locations) so I don't mind going with a temporary solution.

Add sys.getdefaultencoding and sys.getfilesystemencoding

The file.py test looked at the README.md file, but the tester caches
the CPython output and when I changed the README it didn't invalidate the
cache.

The tester knows to invalidate the cache if the test file itself changes, so
instead of using README as the test target, use itself since that dependency
is already tracked.

I don't think this has been touched in quite a while and some parts were
getting out of date.

Implement delattr()

add small unicode encoding test

unicode strings are allowed to be used as attribute names, but
only if they convert cleanly to ascii.

unicode and str need to compare equal to each other and have the same
hash value if the unicode is ascii-compatible and has the same value
as the str.

Well, fix one of them and work around another.  They both come from having
an extension class subclass from a builtin class, since in CPython they can
expect the tp_* slots to be set, but in Pyston those are just wrappers around
the Python functions and then things can get in infinite recursion.

Add compvars and rewriting support for GET_ITER nodes 

Implement str.translate() with delete chars

This commit set adds the unicode type, as well as the ability to
parse unicode literals such as u"\u0180".

There's still a lot more that needs to be added; for instance,
we don't currently support printing unicode values to stdout.

Currently storing + passing unicode strings around as UTF-encoded bytestrings
in std::string; maybe it'd be nice to have the type system show that these are
actually unicode strings, or to use the CPython internal representation (UCS4?)
to reduce the number of encodings/decodings.

and with the fixes to get that working, all the tests pass!

If the type analysis successfully determines that the __iter__() and __hasnext__()
methods we can now replace them with direct calls to the destination.
Else we create a patchpoint and do a rewrite.

This also forced us to make our exception handling more compatible in
a couple places, as well as fix some bugs that weren't getting exposed.

There might be some benefit to implementing the exceptions ourselves
(get to use faster Pyston interfaces, make them GC-aware) but maybe
we can get these benefits but still use the 2kloc exceptions.c file.

These are the unmodified versions to try to make it easier to see our Pyston
modifications.

Implement long.__int__()

We already have getset support, but it takes function pointers
to Pyston-style functions.  CAPI types can specify tp_getset which
is almost the same thing, but the function pointers are to CAPI-style
functions.

Add the ability to do either, try to make it more explicit about
which one is being chosen, and change the existing getters/setters to be
more consistent with being Pyston-style functions.

- Apparently you can manually create instancemethod objects
- set __doc__ on more things

"import socket" does not quite work yet

Rebase llvm to r230300