An update to my RISC OS image viewer PrivateEye is now available with a couple of small but essential fixes for anyone using a Raspberry Pi 3, or using a version of RISC OS with zero page protection enabled:

• It avoids crashes on the Raspberry Pi 3 by fixing a previously undetected MOVS pc instruction. It appears that the Cortex-A53 faults these instructions; a change from earlier cores.
• There was a NULL dereference in the choices handling code when the user clicked on a pane containing hidden choices (those without a UI). This would cause a crash on zero page protected OSes.

Additionally it was rebuilt using the latest DDE27 tools from RISC OS Open Ltd.

There have been a couple of recent changes to the ARM courses. Here’s a summary (with reporter in brackets):

• Introduction to ARM > Barrel Shifter
  • The ‘ASR’ diagram was wrong: corrected. (Bruce Robertson)
• The Introduction to ARM diagrams have all had 2x and 3x scale versions added for the benefit of those using retina/HiDPI screens.

There have been a couple of recent fixes to the ARM courses. Here’s a summary (with reporter in brackets):

• Introduction to ARM > Registers
  • The ‘aliases’ diagram was wrong: corrected. (Felix Dreissig)
• Efficient C for ARM > Sentinels
  • The ‘pipelined’ Wikipedia link was broken. (Marek Niepiekło, Matt Godbolt)

In fact, while fixing the aliases diagram I re-drew all of the Introduction to ARM diagrams in Affinity Designer.

Sometimes when programming we need to tune a small portion of code which is critical to an implementation. For example an inner loop may involve a pixel bashing operation which dominates the program’s overall performance. If this operation uses a comparison, and that results in the compiled code branching, it can hurt performance on pipelined CPUs. It may be better to find a branch-free alternative even if it appears to make the code slightly more complex.

But how do we find these branch-free alternatives? Sufficiently small sequences can be discovered with a superoptimiser program. Superoptimisers are not as clever as the name might suggest: they are typically an exhaustive search through a (virtual) instruction set, trying every conceivable permutation of instructions until it finds one which—for the given input values—works.

Two examples of this are GNU superopt (1995) and Aha! - A Hacker’s Assistant (2008). In this article I’ll only discuss Aha.

There have been some recent fixes to the ARM course pages. Here’s a summary with (reporter in brackets):

• Introduction to ARM > Movement
  • MVN ought to be described as “move NOT” rather than “move negated”. (Dan Lewis)
• Introduction to ARM > Conditional Execution
  • The entry for the “LE” condition code showed the wrong binary encoding. Also, the flags were getting mangled due to Markdown coopting the | character. (Michael Vartan)
  • In the “set the flags, then use various condition codes” example, the less-than comparison ought to have been less-than-or-equal. (Justin Davinroy)
• Efficient C for ARM > Sentinels
  • The “replacing array indexing with pointers” link was broken. (Marek Niepiekło)
• Fixed broken links on Efficient C for ARM > Pointer Aliasing, Efficient C for ARM > Function Argument Types and both index pages.