No emitted bytecode relies on Continuation being stored in local 0
anymore. Stop using local 0 for this purpose and compute offset
to the Continuation at JIT time. 16 bytes of memory freed.
At this point all locals of Continuation construction wrapper share the
same indices with their respective locals of Continuation body, which
should allow further optimizations.
The the code is being translated, we statically know offset of
Continuaton from its ActRec. Use this knowledge to emit data fetches
relative to ActRec rather than relative to Continuation loaded from
local 0.
This is an incremental step towards moving it all the way
to hphp/server. This flattens base but doesn't untangle
the server files from lib_hphp_runtime
Right now (on trunk, not release), a function with a ?int
typehint tells the reflection API its typehint is just "int". For
now, just turn this off. (If we want this later we'll probably have
to add a new API or something?)
Update the connect usage log message to include details of the client that is connecting to a proxy, or to state if it's a connection due to script debugging.
Added two simple functions to determine if a debugger is attached, and to provide info about where the debugger is connected from. Also fixed a minor bug in ext_socket where the name for an unbound AF_UNIX socket would come back from getsocketname()/getpeername() as garbage.
In HHVM (and HPHPc before it) we've been piggybacking resources on the
KindOfObject machinery. At the language level, resource is considered to
be a different type than object, and there are a number of differences
in behavior between objects and resources (ex. resources don't allow for
dynamic properties, resources don't work with the clone operator, the
"(object)" cast behaves differently for resources vs. objects, etc).
Piggybacking resources on the KindOfObject machinery has some downsides.
Code that deals with KindOfObject values often needs to check if the value
is a resource and go down a different code path. This makes things harder
to maintain and harder to keep parity with Zend. Also, these extra branches
hurt performance a little, and they make it harder for the JIT to do a good
job in some cases when its generating machine code that operates on objects.
This diff prepares the code base for a new KindOfResource type by adding a
new "Resource" smart pointer type (currently a typedef for the Object smart
pointer type) and it updates the C++ code and the idl files appropriately.
This diff is essentially a cosmetic change and should not impact run time
behavior. In the next diff (part 2) we'll actually add a new KindOfResource
type, detach ResourceData from the ObjectData inheritence hierarchy, and
provide a real implementation for the Resource smart pointer type (instead
of just aliasing the Object smart pointer type).
When the same header is passed in, Apache/PHP will comma delimit
all header values for the returned values in apache_request_headers
and $_SERVER['HTTP_*'].
For PhpFiles, there was a mixed management system, where references from
translated code were held until the code was made unreachable, while
references from interpreted code were held for the duration of the
current request. Under the new scheme, PhpFiles are always treadmilled.
They are owned by the FileRepository, and so need to be ref-counted
because the FileRepository can have the same PhpFile under multiple
paths. But we don't ref-count the *uses* of PhpFiles anymore.
Classes still need to be ref-counted, but as soon as their Unit
goes away, most of their internals can be freed. We just need to
hold onto them if derived classes are referencing them. Even in
that case, the next time we try to instantiate the derived class,
we can kill any that reference this Class.
There were also lots of holes where references were not dropped,
or owned data structures were not destroyed. eg a Class's methods
were not destroyed when the Class was destroyed; there were
several paths where an entry was erased from the file map, but the
corresponding PhpFile was not decRef'd - or worse, a null entry
was left in the map (something we had asserts to check for).
This tries to make the handling more consistent.
When object support was first added to HHVM, a class named "Instance"
was introduced (deriving from ObjectData) to represent instances of user
defined classes. Since then, things have evolved and HPHPc and HPHPi have
been retired, and now there really is no needed to have ObjectData and
Instance be separate classes anymore.
This diff moves all of the functionality from the Instance class to the
ObjectData and removes the Instance class. In the process, I got rid of
a bunch of dead methods and fixed some indentation and other style issues.
If no timeout was specified in fsockopen, we passed in 0.0,
which was then used as the actual timeout, meaning that while the
socket opened, it almost always failed to open in ssl mode due to
timeout, and then read garbage data from the socket.
We also failed to pass in the specified timeout for non-ssl sockets,
but there we did use the default timeout rather than 0.0. I've changed
that to use the passed in timeout instead.
We force users to use the create() methods of StaticResultWaitHandle and StaticExceptionWaitHandle, which properly set m_resultOrException. However, deserialization will use the normal constructor which was failing to initialize the field. The destructor, then, would operate on random data. This broke hphpd when a stack trace had one of these objects on it somewhere. The 'where' command would succeed, but the next command (which deletes the stack trace), would segfault in the wait handle's destructor.
I think it's fair to not serialize this member. It's not exposed thru PHP except via joining with the wait handle, and I think an argument can be made that it's just plain wrong to join with a deserialized copy of a wait handle. So I've just initialized it to a reasonable default.
While these fixes are mainly for clang, they should (for the most part) prevent possible bugs.
The implicit conversion function has been deleted. The explicit conversion function should be used
~~~hphp/runtime/ext/ext_apc.h
~~~hphp/runtime/ext/ext_domdocument.h
~~~hphp/runtime/ext/ext_hash.h
~~~hphp/runtime/ext/ext_icu_ucnv.h
~~~hphp/runtime/ext/ext_image.h
Char is not standardized to be unsigned, this should be explicit
~~~hphp/runtime/ext/filter/sanitizing_filters.cpp
The C++ Standard does not allow for default arguments in lambdas
~~~hphp/runtime/vm/jit/hhbctranslator.cpp
Turns out I need to use tvSet with temporaries. Also removes
unused tvSetObject*, and replaces some tvSetNull* callsites with using
make_tv temporaries.
Since TypedValue::operator= is dangerous, something like
tvTeleport is usually what you want to use, but it doesn't work with
temporary TypedValues (e.g. return values of things like make_tv or
cellAdd), because it took the arguments by pointer. This also means
we can change it to take parameters by value later without updating
callsites. This diff does the tvDup family and changes tvTeleport to
tvCopy. I'll gradually get the other ones done, but I just need these
for now to work with temporaries for changing SetOp to not use Variant
arithmetic.
Updates continuations to allow yielding of a key-value
pair from a generator. Adds bytecode instructions (PackContK,
ContKey) for using the new feature, and adds IR instructions
(ContUpdateIdx, ContIncKey) to help get it down to the metal
(in particular, ContIncKey attempts to keep the current use-cases
as fast as possible).
I keep reintroducing these by hand. My workflow is usually:
1. Have an idea to optimize X.
2. Realize I don't even know if X is important or not.
3. Instrument X to slow it down, to see if it makes a difference in
perflab.
After this diff, 3 is a simple matter of inserting a call to
cycleDelay(1000) (or what have you) in the path of interest.
Some simple changes for HPHP to help make it clang friendly
---hphp/compiler/package.cpp
---hphp/compiler/package.h
---hphp/runtime/ext/ext_curl.cpp
---hphp/runtime/ext/pdo_mysql.cpp
---hphp/tools/tc-print/offline-x86-code.h
---hphp/util/async_func.cpp
---hphp/util/async_func.h
---hphp/util/compression.cpp
---hphp/util/compression.h
---hphp/util/db_conn.cpp
---hphp/util/db_conn.h
Deleted unused private fields
~~~hphp/compiler/analysis/symbol_table.h
Static assert had to be outside the union
+++hphp/runtime/TARGETS
Added clang specific flag to supress unneded declaration warning
~~~hphp/runtime/base/datatype.h
Use of logical '&&' with constant operand. Added !=0 to remove warning,
~~~hphp/runtime/base/string_data.h
Static fields cannot be declared in an anonymous struct/union
~~~hphp/runtime/ext/bcmath/TARGETS
Moved gcc specific flag from preprocessor_flags to compiler_specific_flags
~---hphp/runtime/ext/pdo_mysql.cpp
Removed unnecessary self asignment for row_count
~~~hphp/runtime/vm/bytecode.h
Added default return statement
~---hphp/runtime/vm/jit/codegen.cpp
spillSlotsToSize was unused
~~~hphp/runtime/vm/jit/irtranslator.cpp
~~~hphp/runtime/vm/jit/linearscan.cpp
The c++ standard states default arguments shall not be specified in the
parameter-declaration-clause of a lambda-declarator.
~~~hphp/runtime/vm/jit/vectortranslator-internal.h
Clang had some issues determining the correct cast when these macros were used
A simple '!= 0' check was added to make things explicit for clang.
~~~hphp/tools/tc-print/perf-events.h
Added parens to make clang happy
+++hphp/util/asm-x64.h
The constexpr needed to be initialized
+++hphp/util/base.h
Clang also supports tr1 libraries
~~~hphp/util/bits.h
Again, clang had issues with implicit casting to bool.
added != 0 check
~~~hphp/util/malloc_size_class.h
Ambiguous operator precedence. Added parentheses.
~~~hphp/util/thread_local.h
Misspelled function
It only matters for reflection, but hhas parameters with
default values need to specify the text of the string.
In addition, change reflection to report parameters with no
default value string as not having a default value, to avoid
crashing when trying to access it.
Update the "func" parameter of array_filter to have a valid
default. The other uses of defaults in array_map and array_filter
are just to get the proper behavior on too few/too many args,
and don't really correspond to default values.
Continuation's m_received field is used to transfer values and
exceptions to the Continuation by send() and raise() methods. It has a
valid value only for a short duration of time, between
ContNext/ContSend/ContRaise and UnpackCont opcodes, when no other
operations could possibly occur. Let's free these 16 bytes of memory and
pass the value thru the VM stack.
To achieve this goal, ContEnter was modified to accept a value to be
transferred on the stack. The existence of the value on the stack is
then acknowledged by the UnpackCont opcode, which is the first opcode
executed after ContEnter enters the continuation body.
ContNext then becomes a trivial Null and is thus removed, ContSend just
teleports the value from local 0 to the stack (I will experiment in a
follow up diff with replacing ContSent by CGetL+UnsetL). ContRaise has
to update the label, but the eventual plan is to enter into unwinder
directly from the raise() method.
In trying to get the CakePHP Blog Tutorial to run on HHVM, a subtle bug was found where the table name was not being returned, and, instead, an numeric index was being used. The bug was in PDOMySqlStatement::getColumnMeta (pdo_mysql.cpp). Applying this fix, the flock/fwrite fix (D855470) and the Reflection::SetAccessible (D851647) fix makes the CakePHP tutorial run like a champ.
Adds support for checking ?Foo type hints in VerifyParamType.
The parameter must have type Foo or null. Failing to pass the hint is
reported as a warning instead of a recoverable error for now for
migration reasons---we'll want to convert it to be the same as normal
type hints later.
C++11 cleanup (clean up easy enums)
This is for runtime/base/... and ended up touching a lot of files
because it turns out we have a lot of reasonably behaved enums.
Sara Golemon