Hack Developer Day 2014: Keep Hacking

Posted on April 10, 2014 by

A few weeks ago, the Hack language was launched to the world. Yesterday, we held the first Hack Developer Day in Menlo Park, California. 150+ Members of the PHP and developer community came to Facebook headquarters and joined over 2000 people online for presentations by the engineers of Hack and HHVM. Afterwards we held a five hour hackathon, where the attendees worked with those engineers to write Hack code, either by converting current codebases or writing new code from scratch. By the way, bonus points to anyone who can decrypt the commit message used when Josh originally pushed Hack to open source.

For those who couldn’t attend, here are the videos of all the presentations…

… and click here for the PDFs of the slides.

There is an official recap of the event on the Facebook Engineering blog, but let me try to provide you a few points that really resonated with me, and I hope many of the attendees:

  • We really strived to make Hack as unobtrusive as possible by providing a lot statically typed functionality without negatively impacting your fast workflow.
  • Hack features like Collections and async/await were received very well and I believe will end up being an integral part of a Hack developer’s toolbox.
  • Tools such as the Hackificator, while not a panacea, can really help you with code conversions.
  • We are working super hard to make HHVM a really great runtime for PHP. Just check out our frameworks compatibility page to understand how serious we are.
  • Our community is awesome. Plain and simple. And we want to make working with Hack and HHVM awesome for them. So we are doing all we can to be even more open (e.g., we are implementing an open review process; bye-bye pull requests).
  • Let it not be forgotten that we are always trying to make HHVM more efficient and run your code faster.
  • FBIDE is really nice, and can make learning and using Hack so much easier. I am really looking forward to its release. What is FBIDE, you might ask? See the video or recap to learn more about this nugget of information.

Simply put, the day was good times all around. And, as one attendee put it, “Keep Hacking!”

Posted in FYI | Leave a reply

Debug Packages

Posted on April 7, 2014 by

We try our best to be a stable dependable runtime, but if you are reaching into the deep dark abyss of the PHP language, you might stumble upon a dark corner where we segfault or assert. First of all, we are sorry. Secondly, we would love you to report the issue, and if you can put together a small test case that is best. If it only reproduces under the full moon when you hold your head to the side and hop on one leg, then a stacktrace would be next best.

Before today, you had to compile the code by hand to get a useful stack trace. No longer! Using the same repo you normally use, add -dbg to the name of your package.

sudo apt-get install hhvm-dbg  # old faithful
sudo apt-get install hhvm-nightly-dbg  # the new hotness

The package is much larger, slower and has a bajillion asserts in it, so please don’t use it in production. Please DO use it for reporting stack traces and for diving into HHVM with gdb. Happy debugging.

Posted in Uncategorized | Leave a reply

HHVM 3.0.0

Posted on March 28, 2014 by

This is a fun one! :)

At our last major version bump (2.0.0), we basically became a whole new project. We switched from a “PHP -> C++” translator to a virtual machine. This version bump (3.0.0) is a much less dramatic code shift (we’re still a VM, don’t worry), but this time the big announcement is that we support a new language, Hack.

I’d like to take some time to reflect on how far we’ve come since version 2.0.0. Back then we had a small semblance of a blog with just 8 posts from Sara and Owen. We didn’t have any type of release process; it was just whenever Sara wanted to cut one. We had a single package, for ubuntu 12.04; now we’re up to 6. We had a bajillion tasks that largely didn’t apply to the VM, so I closed them all. We’re back up to a bajillion (well ~300), but they all are real issues that we are plowing through. We took almost 0 pull requests, now we’re over 400 with 150 different contributors. We didn’t really know how well we run all PHP code, and now we have a cool framework tracking page and a community created one for composer modules. We didn’t hang out with our closest 200 friends on IRC. You couldn’t write extensions nearly as easily. You had to use our own webserver that spawned no end of questions for how to make rewrite rules for it, instead of the standard fastcgi. Oh and there wasn’t even a thought about running it on Heroku or testing on Travis. It has been a big year and I can’t wait to see what comes next.

Alright, enough reminiscing; there is a lot of real business in this release.

  1. The old webserver is gone. If you get something like Uncaught exception: no factory for server type "libevent", you need to switch to fastcgi. Trust me, it is better for you. The package should automatically configure nginx or apache for you if it was installed before HHVM. Read our rationale behind this decision.
  2. We are moving from .hdf config files to .ini. The default one lives in /etc/hhvm/php.ini. We don’t support all the old options yet, so you can still use config.hdf for now, but be ready for it to die in the next release. All of your favorite options will go from Foo { BarBaz = True } to hhvm.foo.bar_baz = true.
  3. Hack is of course supported. Keep in mind that one of the major features of Hack is immediate feedback from the type system. This is enforced by a separate tool from HHVM itself, called hh_server and hh_client. These tools are included in the HHVM binary packages, but need to be explicitly set up and started. Also, if you have been running Hack code in the recent nightly packages, we’ve fixed a couple of bugs that may expose additional type errors in your code. In the future, we’ll be careful to ease the transition between stable releases so projects can fix these type errors at their own pace. However, we did not do this for the transition from nightly to stable 3.0.
  4. Our most requested extension, mysqli is now in. Enjoy. Update: This extension was broken in 3.0.0 and is fixed in 3.0.1. Make sure to upgrade if you were having problems, and to remove the Eval.CheckReturnTypeHints workaround if you were using it.
  5. Error messages now match PHP5. We no longer have the HipHop prefix, so you don’t have to bust out a rap when you miss an Exception.

Our next 4 alphabetical hiphop artists are here for your enjoyment in the full Changelog:

Donald Glover Eminem 50 Cent Ghostface Killah

“Ghostface Killah” 17-Mar-2014
  - Add Hack
  – Remove “HipHop” from error messages
  - Add __IsFoldable user attribute for const-foldable functions
  - Add __Native("NoFCallBuiltin") UA for builtins which need an actrec
  - Add support for testing different outputs in repo mode
  - Implement remaining functionality from intl extension
  - Implement XSL extension
  - Implement Stream Filters
  - Improve php.ini support and get ready to kill HDF files
  - Parse config files as ini files, unless filename contains ‘.hdf
  - Various fixes to Redis, JSON, SPL, DateTime, MySQLi, and others
  - Remove C<T>Ref typedefs (use const T& now)
  - JIT default on in command line mode
  - gethostname() just returns what the syscall returns (Zend compat)
  - HHBBC turned on in the build for facebook.com
“Fifty Cent” 3-Mar-2014
  - Array parameter type constraints implicitly cast collections to arrays
  - Fix issues with feof and fwrite
  - Fix issues with sleep and inaccessible properties
  - Dump a jemalloc pprod dump when a request hits OOM
  - Make method_exists work with interface inheritance
  - Fix crash in preg_replace with /e
  - Support filename and content type in Curl uploads
  - MySQLi fixes
  - Handle relative paths in is_dir
  - Add string conversion for array_fill_keys
  - Implement various Imagick functionality
  - Implement PHP 5.6 __debugInfo() magic method
  - Raise warnings when return type annotations mismatch
  - Fix nested ArrayObject assignment
  - Switch many ini settings to thread-time binding
  - Clean up memory stat tracking
  - Immutable collections are now prefixed with Imm instead of Fixed/Frozen
  - Clean up type parameter for CheckType-related IR opcodes
  - Remove legacy linear-scan register allocator and Eval.HHIRXls option
“Eminem” 18-Feb-2014
  - reenabled jemalloc tcache flush for idle threads
  - array_combine now performs __toString conversion on objects in $keys
  - Allow streams in move_uploaded_file
  - Fix a bug double closing a UserFile
  - Warn when first arg to call_user_func is an object with no __invoke
  - kill userland hdf functions
  - Final method reports itself as final
  - Implement IntlCalendar
  - Disallow create_function in RepoAuthoritative mode
  - Case-insensitive check for Accept-Encoding: gzip
“Donald Glover” 3-Feb-2014
  - Support for “::class
  - Enable FCallBuiltin for HNI functions
  - json_decode parity with PHP 5.4
  - Fix race condition with profiling vs. non-profiling functions prologues
  - Implement ini_get_all()
  - Begin conversion of runtime options to INI
  - Fix potential PGO-mode crash
  - Fixes and enhancement in IR printing
  - Vector and Set now supported by: array_{shift,unshift,fill_keys,reverse,flip,size,chunk}, min, and max
  - StableMap is now an alias for Map, which retains insertion order
  - Map moved to HH namespace
  - Fixes in XLS spilling of SIMD registers
  - Support SCRIPT_FILENAME in FastCGI
  - Implement stream_context_{get,set}_default
  - Support for Intel VTune Amplifier XE
  - Rewrite of SimpleXML
  - Several HNI conversions, and a helper script
  - Move Pair to HH namespace
  - Fix get_included_files ordering
  - Fix $_SERVER and $_ENV in FastCGI
  - Update timelib to php 5.5.8
  - Some dead code removal

Posted in Announcement | Leave a reply

Hacking Hack on Heroku

Posted on March 21, 2014 by

Yesterday, after our Hack announcement, we sat down with the heroku team to get Hack working on Heroku. And success! Read all about it over on the heroku blog.

First make an index.php file:


echo "Hello from HHVM ".HHVM_VERSION;

Then create a git repo, add the file, create our Heroku app and deploy away:

$ git init .
Initialized empty Git repository in /tmp/myhackapp/.git/
$ git add index.php
$ git commit -m 'initial'
[master (root-commit) 024f2b1] initial
 1 file changed, 3 insertions(+)
 create mode 100644 index.php
$ heroku create --buildpack https://github.com/hhvm/heroku-buildpack-hhvm
Creating stormy-crag-8213... done, stack is cedar
http://stormy-crag-8213.herokuapp.com/ | git@heroku.com:stormy-crag-8213.git

And then we can check and see that it worked:

$ heroku open

Send any issues to us on our buildpack repo.

Posted in Announcement | Leave a reply

Introducing Hack – A Programming Language for HHVM

Posted on March 20, 2014 by

As you may have heard or seen already, the Hack programming language has been released for HHVM. Hack reconciles the fast development cycle of PHP with the discipline provided by static typing, while adding many features commonly found in other modern programming languages.

We have deployed Hack at Facebook and it has been a great success. Over the last year, we have migrated nearly our entire PHP codebase to Hack, thanks to both organic adoption and a number of homegrown refactoring tools.

We are proud to release an open source version of Hack to the public as part of our HHVM runtime platform, which will now support both Hack and PHP.

It is important to note that we have developed Hack to interoperate as seamlessly as possible with PHP. In fact, it is a stated goal of the HHVM team to continue to grow compatibility with the many existing PHP frameworks. The top 20 open source frameworks on Github run on HHVM. We currently pass 9 10 of the top 20 at 100% on their unit tests. Most of the others are passing at or above 90%. We, of course, are working hard to ensure every framework is at or near 100%.

You can view the complete Hack language announcement or go directly to http://hacklang.org to find out more. Enjoy!

Posted in Announcement | Leave a reply

HHVM 2.4.2

Posted on March 8, 2014 by

We haven’t done posts for point releases since our normal release schedule is so quick, but when there is a security fix we thought you should know as soon as possible.

We have a few fastcgi fixes, a few memory leak fixes and the security vulnerability fix for CVE-2014-2209. Previously an attacker could get around escapeshellarg() using a specially crafted input. It is hard to exploit, and facebook.com wasn’t vulnerable, but you should patch your servers up just incase.

The full commit log is available for this release. Remember the branch cut is in 11 days for the next release so get your pull requests in soon!

Posted in Announcement | Leave a reply

Tracking Parity

Posted on March 3, 2014 by

HHVM has a large suite of unit tests that must pass in several build configurations before a commit reaches master. Unfortunately, this test suite passing doesn’t tell you if HHVM can be used for anything useful – so we periodically run the test suites for popular, open source frameworks.

Test Results

The frameworks test page is now public, as is the JSON data backing it (which you’re welcome to use).

What’s tested

We aim to test the latest stable version of each framework, with a few exceptions:

  • if fixes are required, we use the earliest version of master or develop that includes them
  • if recent changes make it significantly easier to run the tests – e.g., a framework switching from a custom test runner to just ‘run phpunit

At the moment, the framework versions in our test runner are fairly consistent with our above philosophy, but we will continue to fine tune them as needed. You can see the exact versions we use in hphp/test/frameworks/frameworks.yaml.

How it works

The test runner and configuration is in hphp/test/frameworks/; once an hour, a script fetches the latest version of HHVM from GitHub, does a clean debug build, and runs the framework tests in --csv mode (with JIT, not RepoAuthoritative) . This data is then imported into a fairly standard MySQL+Memcached system, and made available via a JSON API. The results page is built on top of that API using HHVM, XHP, and the Google Charts API.

The runner runs all tests in parallel – including tests within a framework; this is needed for the tests to complete in a reasonable amount of time, but unfortunately leads to noisy data, as some tests have implicit interdependencies.


We believe the current frameworks in the test runner are a nice representative sample of real world PHP (and we are adding more). We showed a static snapshot of our test parity to these frameworks late last year. As HHVM is continually developed, it is paramount that the community knows whether there is progression or regression in how HHVM can run code. Having a live snapshot of unit test pass percentage progress helps “keep us honest”.

Also, HHVM has a growing developer community, including passionate OpenAcademy students; snapshots of this data have been invaluable for finding and prioritizing issues (combined with data from GitHub and VersionEye). As such, moving from occasional framework unit test snapshots to continuous data was an obvious step in making it easy for new contributors to find effective ways to contribute.

Posted in Parity | Leave a reply

Implementing MySQLi

Posted on February 26, 2014 by

I joined the HHVM team right before Christmas for a hackamonth (or, in my case, a hack-a-two-months).

Getting My Feet Wet

To prepare for what was to be my big project, I rewrote the ini parser to better match Zend. This was released in HHVM 2.4.0. Interestingly, the parser was going to be shipped with HHVM 2.3.0; but when we tested the RC (release candidate), we noticed that we had a bunch of ini files at Facebook that the parser failed upon. So, I had to fix those files before we could release the new one.




After warming up with the parser, I was ready to start my big project: implement MySQLi. This has been a long requested feature for HHVM. And, this extension is required to help meet our compatibility goals.


MySQLi is not a trivial extension. As a PHP developer, I am so glad that SaraG has created HNI (HHVM Native Interface), which makes it possible to write extensions in PHP directly instead of writing them in C++. Also, SaraG created a tool called docskel.php, which uses the raw XML that forms the php.net documentation to stub out the appropriate HNI-based signatures for extensions. While the documentation can be wrong sometimes when it comes to return types and parameter types, the stub generation saves a ton of time. After the stub generation, essentially the only work left  is to implement all the required functions.


For many of the MySQLi methods, it was simply a matter of essentially passing through calls to the older MySQL equivalent implementations. For example, mysqli::real_escape_string() just calls the implementation for mysql_real_escape_string().

MySQLi has both a procedural and an object-oriented interface. However, because we can write part of the extension in PHP, I could implement almost all of the procedural interface in PHP by just having it call the object-oriented interface. For example, the procedurual function mysqli_real_escape_string() just calls the object-oriented function mysqli::real_escape_string().


To test the correctness of my implementation, I used the Zend test suite. There are about 300 tests in this test suite. However, these tests are not meant to be run in parallel. Many tests uses the same database table which, when running in parallel, will randomly make the test fail because some other test touched the same table at the same time. Running the tests in serial wasn’t a great option because that would make development of MySQLi a lot slower. So, instead, I updated our Zend import script to fix the tests to use different tables, thus avoiding the conflicts when running in parallel.

Another testing issue came with what we call ZendParamMode. ZendParamMode is our flag to indicate the calling convention that Zend uses. In short, when using ZendParamMode, if a function is called with a parameter of the wrong type, a warning is logged and the function returns null. The problem is that functions in HNI that are implemented in PHP do not currently support ZendParamMode. So even if the function was doing everything correct, except how it handled ZendParamMode, the test would fail. This made it very hard to see what was implemented correctly and what was incorrect or missing. But, since making the function actually have correct behavior is more important than supporting ZendParamMode, I just changed the import script to remove most of the cases where ZendParamMode was tested.

After fixing the above issues, I was able to perform the normal “where does the test fail and fix it” methodology. This often included reading Zend’s MySQLi source code to determine what the right behavior should be.

Overcoming Roadblocks

The most difficult part of the MySQLi implementation was mysqli_stmt::bind_param() and mysqli_stmt::bind_result(). These methods take a variable number of arguments that are passed by reference. And, at the time, HNI did not support either. First SaraG added support for variable number of arguments, and then I added support for variables as references.

mysqli_multi_query() (and its friends mysqli_more_results() and mysqli_next_result()) were initially going to be a bit tricky since they were not part of Zend. However, just the opposite occurred. The reason for that is that HHVM already had implementations for mysql_multi_query(), mysql_more_results() and mysql_next_result(), so all I had to do was essentially do a pass through call to those functions.

Current Status

We currently pass 182 of the Zend MySQLi tests. We fail 114. However, many of those 114 tests are failures are what I call “technicality” failures. For example, when we var_dump() a double, we print more digits which makes our output different from Zend.

For real-world compatibility, we pass 100% of doctrine/dbal unit tests and we pass 100% of the CodeIgniter unit tests when running on MySQL.

Missing Pieces

The biggest missing pieces when it comes to passing all Zend tests are:

  • Bugs that comes from the interaction between MySQLi and php.ini. Reading default values from php.ini is currently missing (but is being developed).
  • Sometimes we output different error messages which confuses the test runner when it compares output.
  • Zend has two different MySQL drivers. One is the normal MySQL C API and one is their own MySQL Native Driver. Because HHVM uses the MySQL C API we, don’t support the functions that require the MySQL Native Driver. We may be able to work around this issue for some functions, but, for now, we don’t support any of the functions that require MySQL Native Driver.
  • What happens when something goes wrong may be different between HHVM and Zend.

What’s next?

  • Support ZendParamMode for PHP functions in HNI.
  • Make more of the 114 failing Zend tests pass.
  • The plan is to release MySQLi in HHVM 2.5.0. Please test the implementation as much as possible before the 2.5.0 release (you can use a nightly), so we can continue to fix bugs.

Posted in FYI, Parity | Leave a reply

HHVM: The Next Six Months

Posted on February 24, 2014 by

The HHVM team has just wrapped up its planning for the first half of 2014. We’d like to share our plans, providing you a bit of context.

2014 Themes:

  • Open Source
  • Increase Web Efficiency
  • Make HHVM Hackable

Open Source goals:

  • Increase community participation and adoption
  • Move to open development
    • Figure out a way to have all non-Facebook specific HHVM development done in the open.

We’ve been making steady progress on HHVM’s compatibility with PHP in the wild, but we still have a lot of work ahead of us. We’re using unit test pass rates as a proxy for success measurement, but you can help by adding HHVM to your Travis configuration, and reporting bugs and issues through GitHub. We are resourced to help support a couple of major HHVM deployments, which we hope has the side effect of exposing us to “non-Facebook” deployment and maintenance challenges.

We are also going to push for a more open development model, with the goal of increasing our community participation. We’ll have more to say on what this means later on. Stay tuned!

Increase Web Efficiency:

  • Further CPU time reduction
    • JIT improvements (including region compiler work)
    • HHBBC (HH bytecode-to-bytecode compiler)
    • Code and data layout optimizations
    • Lockdown improvements
  • Reduce Memory
    • Memory bandwidth reductions
    • Working set reductions
    • Ship a memory profiler
  • ARM64
    • 25% bytecode coverage on simulator
  • Prototype LLVM integration

We’ve set very aggressive efficiency goals for the half that we hope to achieve through a range of JIT compiler projects. We hope these translate into wins for a variety of PHP workloads. We’re shooting for wins via the region compiler project, which is a compilation strategy that stitches together multiple basic blocks into larger chunks of code. This means that the current optimization passes we have in place can do a better job at identifying and exploiting optimization opportunities.

HHBBC (HipHop Bytecode to Bytecode compiler) is essentially a redesign and reimplementation of something we already have: a type inference pass. Right now we do type inference during the AST (Abstract Syntax Tree) generation phase, but we think we can do a better job of this at the bytecode level while giving us option value to augment bytecode with richer type information through tooling and offline static analysis. Having more type information on hand means generating faster and more specific code — it’s like “peering in to a dynamic program, and pulling out its static equivalent”.

We’re also planning on really knuckling down on memory consumption: both total working set and memory bandwidth usage. Reducing both will inevitably give us CPU time wins (a lot of our CPU time is spent waiting for memory requests) and will allow us to deploy to servers with a smaller memory footprint. All requests start with a fresh heap, add and subtract to it over the lifetime of the request, and then throw it away. As we increase RPS (inevitable side-effect of better quality code generation) we also increase bandwidth pressure on the memory subsystem. We want to make sure that the memory bus does not become a bottleneck.

Hackable HHVM:

Hackable HHVM really means “move faster”. We want to ship better documentation to help you guys (and it really helps us too…) get hacking on HHVM. One significant part of the “Hackable HHVM” theme is moving all of our internal extensions over to the HNI interface which is a super fast lightweight way of building extensions for HHVM.

An Exciting Road:

The Road Ahead

Clearly it’s going to be a big half in terms of technical agenda, and probably our biggest in terms of open source engagement. We’ll be attending conferences, shipping code, getting faster and having fun this year.

Please continue your awesome effort of using and contributing to HHVM, and discussing all things HHVM on IRC at #hhvm. We looking forward to having you join us for the ride in 2014 and beyond.

Posted in Announcement | Leave a reply

HHVM 2.4.0

Posted on February 1, 2014 by

It is that wonderful time again for an HHVM release. We’re sticking to our 8 week release cadence to keep everything fresh and in your hands. Also, remember you can run the nightly packages if you want a bleeding edge feature.



This release has many exciting points. First of all, 4 more large frameworks now pass 100% of their unit tests (using phpunit 3.9) – Laravel, Mockery, PHPUnit and CodeIgniter. Remember to put HHVM in your travis config and we just might do a drive-by and make them all pass.

Big fixes:

  • A full rewrite of the ini parser
  • Support for the same recursive __get() and __set() semantics as php-src
  • Implemented try {} finally {}
  • Various reflection bugs
  • Turned on the Region JIT,  which makes the blocks of code that we translate larger giving more opportunity for speedups


You might notice our new naming scheme for our 2 week releases. Since we are the HipHop team, we thought it would be fitting to use hiphop themed names. If you have suggestions for release names feel free to comment. Also, we noticed that there are 52 weeks in the year and with a release every 2 weeks, we can name them alphabetically and just perfectly fit. So far we’ve had Appleseed, Beastie Boys and Coolio.

Security Fixes:

CVE-2014-1439Fix libxml_disable_entity_loader(). This was also part of the 2.3.3 release.

Full Changelog:

  • Turn on Region JIT
  • FastCGI fixes, perf improvements
  • ext_zend_compat fixes
  • Turn on XLS Register Allocator by default
  • Fix server stats reporting
  • num‘ scalar typehint that accepts both ints and floats
  • fix support for typedef’d namespaces
  • don’t swallow fatals when autoloading
  • Map collections learned the in-place retain() and retainWithKey()
  • rename Set::difference() to Set::removeAll()
  • Update Set to retain element insertion order
  • remove APC stats
  • Fixes for ARM mode
  • FrozenMap collection
  • Deprecated Vector|Set|Map::put() method removed
  • == between Frozen{Vector|Set|Map} and {Vector|Set|Map} now can return true
  • Support lex-time binary constants (eg. 0b10111)
  • StreamWrappers now support rmdir, mkdir, rename and unlink
  • Miscellaneous Zend PHP compatibility fixes
  • Default StatCache to off
  • Miscellaneous FastCGI fixes
  • Miscellaneous region compiler fixes
  • Map and StableMap collections use the same underlying implementation
  • Trait requirements enforced
  • hhprof performance improvements
  • Add array to string conversion notice
  • Add RaiseNotice IR opcode
  • Fix VirtualHost.<name>.Pattern matching
  • Fix various memory leaks (pdo_parse_params, Gen*WaitHandle)
  • Import a lot more Zend tests that used to crash or hang
  • Clean up base.h
  • XLS register allocation cleanup
  • Enable region compiler by default for JIT functions in ahot
  • Fatal on eval() in RepoAuthoritative mode
  • Enable Link Time Optimization (LTO) for HHVM
  • Fix a few SPL compatibility issues
  • Fix issues with DOCUMENT_ROOT in fastcgi
  • Better type inference for collections and builtins in repo mode
  • Shorter syntax for lambda expressions w/ automatic captures
  • Parser support for trait require clauses
  • Move FrozenVector and Set to the HH namespace
  • Fix resource to array conversion
  • Fix a request local memory leak in foreach of apc arrays
  • Initial php_odbc API implementation
  • Implement PHP’s hash_copy() function
  • Experimental tool: Memoization Opportunity Profiler
  • Various small parity/behavior fixes (in phar, proc_open, filter_var)
  • A Eval.DumpHhas=1 option to dump hhas for a php file
  • Better warnings in Set::toArray
  • Fix the behavior of foreach loops in finally blocks
  • chmod -x runtime/vm/jit/*.{cpp,h}
  • Changes to make hhvm build clean with clang-3.4
  • Fix array_product to not be bug-compatible with PHP 5.2
  • Change the Map datastructure—preserves order and does faster foreach
  • FrozenSet collection
  • Generate pid.map when we unmap text section, for the perf tool
  • Implemented GlobIterator
  • Implemented Reflection::export and Reflection::getModifierNames
  • support date.timezone in ini files
  • implement fileinfo
  • special comparisons for DateTime
  • delete unimplemented functions
  • support for the finally clause in try blocks

Posted in Announcement | Leave a reply