Allow select threads to bypass the usual thread initialization

Parallel query jobs dont need to do any of the normal thread
initialization, so skip it.
Fix an issue with over-agressive type annotations

This could cause a local with a type assertion to be
inferred non-null at places where thats not the case.

In the new test, the $a in "return $a" was inferred to
to be an object, resulting in a crash when $a was
pushed onto the stack, and its refcount incremented.
Fix file_put_contents to work with php://{stdout,stderr}

file_put_contents' implementation was manually opening the
passed in filename. If we use our File class instead, the magic php://
paths just work.
In finish_thread_locals, use isNull instead of getNoCheck

The getNoCheck function will assert that it's not null, which
this code is apparently trying to check.  (Somehow hit this loading a
sandbox page, but not sure how to repro.)
Strengthen is_refcount_realistic assertions

All valid refcounts should be less than or equal to the
static value.
fb_compact_serialize: add a VECTOR code

We need a concept of Vector since it will be supported in PHP in the future and C++ code should have a way to represent vectors.
Remove legacy UnsetM translation code.

Remove legacy UnsetM translation code; generic *M translation obsoletes it.
Remove incorrect assertion

The assertion assumes we're dealing with a
utf8_string - in which case it will have been
checked for correctness. But preg also works with
non-utf8 strings.
Initialize m_allocMode in VectorArray non-smart-copy constructor

Non-smart-allocated VectorArray wasn't initializing this field,
which surely can't be good.  This would most likely impact HPHPC
but only when creating static arrays; and its not clear when/if
we create static VectorArrays.  But it's still a bug.
Fixed get_class_vars.
Correct some use of smart allocated data in DebuggerClient

The DebuggerClient destructor could try to invoke ~Array
after the smart allocator shut down from a static dtor.  In the case
of the hphpd_get_client API, it also could try to assign null_array to
an Array at sweep time---I think this could be wrong if these Array's
have references to other Object's with custom sweeps.
Fix injected bug: check m_strongIterators on the copy

This was injected when I converted the strong iterator
list to a linked list.  Only affects HphpArray when
COW occurs on the array being mutated in a mutable foreach
loop.  Starting a strong iteration causes a private copy
to be made anyway, but the bug should be fixed either way.
Don't pass empty strings to PlainFile::writeImpl

This function asserts length is not zero, so I was hitting
this in a debug www load.
Enable C++11

Moving forward, these compiler features will be required for
IR and other features in the pipeline.  Compilers which do not
support C++11 features will be incompatable.
Initial IR work

Initial merge of IR (Intermediate Representation) tree.
Fix leak in safe_free()

safe_free() was so safe, it was a no-op.
Move the siPastEnd flag into a spare bit in m_strongIterators

Each subclass of ArrayData needs a flag to track whether there's
a strong iterator past the end of the array; use a spare bit in
m_strongIterators to store the flag, and consolidate more strong
iterator code in class ArrayData.

This will also aid in packing fields in subclasses.
Fix bug in DebuggerClient's use of Sweepable Socket objects

DebuggerClient attempted to avoid problems with destructing
Socket objects by calling incPersistent so they would not be swept.
However, the semantics of incPersistent apparently require that the
object only is persistent in some sort of thread-local cache (it is
re-added to the sweepable list for the same thread immediately).  When
we disconnect the debugger, the DebuggerClient is deleted and the
socket object is also destructed---the Sweepable destructor tries to
remove it from the current thread's list, so if this is a different
thread, the next sweep loop on the original creating thread will make
function calls on a deleted object.