David Schneider avatar David Schneider committed 8ed51ef

update the blog post about the ARM merge a bit

Comments (0)

Files changed (1)

blog/draft/arm-status-update.rst

 ARM Backend News Update
 =======================
 
-Starting with the good news, we finally merged the ``arm-backend-2`` branch
-into PyPy's main development line. As described in previous_ posts_ the main
-goal of this branch was to add support for ARM processors to PyPY's JIT.  As a
-general byproduct PyPy should now do a better job supporting non-x86
+As announced in the previous release notes for the PyPy 2.0 beta the ARM JIT
+compiler backend branch ``arm-backend-2`` has been merged into the main
+development line and is going to be part of the upcomming release.
+As a general byproduct PyPy should now do a better job supporting non-x86
 architectures such as ARM and the in-progress support for PPC64.
 
+In this post I want to describe a bit more in detail the current state of
+PyPy's ARM support.  Currently we provide two versions of PyPy for ARM, one
+with and one without the JIT compiler.  Currently both target the ARM
+soft-float ABI. And in this post I'm going to focus on the JIT version.
+
 On ARM, the JIT requires an ARMv7 processor or newer with a VFP unit targeting
 the ARM application profile. Although this sounds like a strong restriction,
 most of the ARM processors used in mobile devices and development boards are
 as *softfp*, *soft-float* and *hard-float*. The first two use the core
 registers to pass floating point arguments and do not make any assumptions
 about a floating point unit. The first uses a software based
-float-implementation, while the second can use a floating point unit. The
-latter and incompatible one requires a floating point unit and uses the
-coprocessor registers to pass floating arguments to calls. A detailed
-comparison can be found `here`_.
+float-implementation, while the second can use a floating point unit to
+actually perform the floating point operations while still copying the
+arguments to and from core registers to perform calls. The latter and
+incompatible one requires a floating point unit and uses the coprocessor
+registers to pass floating arguments to calls. A detailed comparison can be
+found `here`_.
 
 At the time we started implementing the float support in the ARM backend of the
 JIT, the soft-float calling conventions were the most commonly supported ones
 We also have some hardware to run the subset of the PyPy test-suite relevant to
 the ARM-JIT backend and to run the tests suite that tests the translated ARM
 binaries. The nightly tests are run on a Beagleboard-xM_ and an i.MX53_
-versatile board (kindly provided by Michael Foord), both boards run the ARM port `Ubuntu
+versatile board (kindly provided by Michael Foord), both boards run the ARM port of `Ubuntu
 12.04 Precise Pangolin`_. The current results for the different builders can be
 seen on the `PyPy buildbot`_. As can be seen there are still some issues to be
 fixed, but we are getting there.
   a regular basis. A fully emulated approach using QEMU might still be worth trying.*
 * Improve the tools, i.e. integrate with jitviewer_.
 
-Long term on open topics/projects for ARM:
+Long term or open topics/projects for ARM:
 
+* Fully support the hard-float calling convention and have nightly builds and tests.
 * Review of the generated machine code the JIT generates on ARM to see if the
   instruction selection makes sense for ARM.
 * Build a version that runs on Android.
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.