Hardware FP mul, sub, and add.

Use the hardware FPU for double operations. Instead of teaching
the register allocator about FPU regs, we just commandeer xmm0 and xmm1
temporarily to evaluate a single term. Doubles continue to live in GPRs
at instruction boundaries. E.g., to subtract two temporaries in $rax
and $rcx:

  mov %rax, %xmm0     ;; inout
  mov %rcx, %xmm1     ;; in
  subsd %xmm0, %xmm1
  mov %xmm1, %rax     ;; out
Fix missing pseudoMain

There was one place where we didnt check
canUseDummyPseudoMain(), resulting in a
possibility of compilation errors. It was
pretty unlikely, because usually, such
requires have already been removed.
Use isVolatile() for persistent classes

This mimics the hphpc behavior, which we're
already relying on. Gets similar perf improvements
and so far no correctness issues.
Translate Double.

I noticed an interpOneDouble in the emitted code for
evaluate_logistic_regression. No excuse for that.
Don't enregister variant keys in the vector translator

Their types can change because of reentry during intermediate
operations.
Remove unused call* functions in asm-x64.h

Probably predate EMIT_CALL.
Refactor TV_DUP_FLATTEN_VARS as an inline function.

As a macro, this one has teeth; it can mutate the 'fr' parameter,
so I rewrote it as an inline function.  Also cleaned up a hack in
instance.cpp that was committed before we removed the _count = 0
from TV_DUP_FLATTEN_VARS.
Make HPHPc no longer default, require exprot USE_HPHPC=1

As part of the migration to making HHVM the default, all
builds must now explicitly state which version of HipHop
they would like to use.

For HHVM:  export USE_HHVM=1
For HPHPc: export USE_HPHPC=1

Setting both (or neither) will result in an error message
from cmake.
Predict Int for %, Double for /.

These operators produce unpredictable results. However, in the
vast majority of correct programs they produce a numeric type.
There's some uncertainty for /, so favor Double. We could
ultimately profile-drive this if we want more precision.
Fix bug, increase coverage for binary arithmetic.

Our attempts to handle reffy left-hand-sides for *= and friends
have always been broken. I noticed this while debugging an assertion
failure caused by misparenthesizing a check in analyzeSetOpL.
Separate "yield break" from "yield" parsing

"yield" and "yield break" are fundamentally different statements. Separate
their parsing paths and don't generate unused goto labels for "yield
break".

Parser's m_generators logic was updated to cope with zero labels case
that is now possible. A test case was added to cover this case.
Transform only foreaches with yield statements inside

Use the FunctionContext parser abstraction to keep track of
open foreach statements and presence of yields.
Move the inline vs. generic RetC cases into subroutines

Cut down a tad on function growth hormone imbalance syndrome.
Improve generic dtor stubs and support frame-less shared TC stubs

By allowing avoiding frames and using a custom calling
convention, combines the two generic dtor stubs and fits them on one
cache line.  Also inlines the call-table lookup for release helpers
instead of jumping to a C++ stub that does it.
Improve the generic freeLocalsHelper

Removes more branches from common cases in the
frameFreeLocals helper by calling to different offsets in a
generic-decref slide.  Also inlines the decref and destructor calls
instead of calling out to tvDecRefHelper.  To support this it also
always emits the varenv check (for AttrMayUseVV) and decrefs
ActRec::m_this in translateRetC translation.  For now this removes the
limit on total number of locals to do a specialized return (it leaves
the limit on number of reference counted locals).
Don't guard on nonrefcounted locals at RetC

If a local is known not to be reference counted at a given
RetC site, we don't need to guard on it when doing an inline return.
Use in-memory SQLite journaling for hphpc.

Use in-memory SQLite journaling for hphpc, since any hphpc failure by
definition results in an unusable repo anyway.
Nop out trivial CastDouble's.

I noticed this in je's command-line script and in histograms
of interp'ed instructions from www. A lot of the time (double) is just
to make sure on something that was already a double.
Sorting for collections

This diff adds support for Vectors to sort and usort, and adds support for
StableMaps to asort, ksort, uasort, and uksort.
enterTC code tweaks

A few minor tweaks.  Changes things so the compiler will
inline the fast path of getTranslation, only stores service request
args when there is a non-REQ_EXIT request, and removes the resume()
virtual since we're using TranslatorX64* in bytecode.cpp anyway.