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.

I recently needed a complete list of ARM cores used in Apple’s iOS kit. We were trying to track down a bug which initially appeared to be something processor-dependent. The bug turned out to be something else, but I’d already compiled much of this table anyway. So, here it is for your reference:

The 64-bit A7 chips are still a bit too new to find out about in much detail.

See that the ‘S5L’ code name digits are the ‘APL’ product name but with its digits reversed. So a hypothetical Apple APL5678 would be a S5L8765.

Data from Wikipedia and PDAdb. E&OE.

And what do you know… I compile all that then I find this.