Vectors: one instruction, many numbers

One register, many views

The scalar names read one value, not a row of them, from the low bits of a v register:

Written as v0 with an arrangement after a dot, the same 128 bits become lanes:

v0.8b, v0.4h and v0.2s use only the low 64 bits. One lane is named by its number in square brackets, counting from 0 at the low end: v0.s[2] is the third 32-bit lane.

Loading, adding, and copying lanes out

• ld1 {v0.4s}, [x9] loads 16 bytes from the address in x9caller-saved temporary (x9-x15): a called routine may overwrite it. into the four lanes, the word at the lowest address into lane 0. st1 {v0.4s}, [x9] stores the lanes back the same way.
• add v2.4s, v0.4s, v1.4s adds lane 0 to lane 0, lane 1 to lane 1, and so on: four separate adds in one instruction. mulRd = Rn * Rm. Low bits only. works lane by lane in the same way. All three operands use the same arrangement.
• dup v3.4s, w9 copies w9caller-saved temporary (x9-x15): a called routine may overwrite it. into every lane, and movi v1.8b, 40 puts the constant 40 in every lane.
• addv s5, v2.4s adds the lanes of one register together and leaves the total in lane 0 of v5, which is s5.
• printf reads only general registers for %d, so mov w1, v2.s[0] copies one lane out to w1argument and return register (x0-x7): carries the first eight arguments and the return value. first.

Each of these has a reference entry with an example to run, such as ld1, dup and addv, and the reference's Calling convention tab covers the jobs of the v registers.

The program below adds two lists of four ints, multiplies the four sums by 3, and totals the sums. It prints:

Vectors and calls

The rule that a function must hand d8 to d15 back unchanged covers only the low 64 bits of v8 to v15. A function you call may change their upper 64 bits, and every bit of v0 to v7 and v16 to v31. So no v register is sure to keep a whole 128-bit value across bl printf.

That is why the program copies the total into w19callee-saved register (x19-x28): a routine must restore it before it returns. and stores the products in memory with st1The contiguous store. before its first printf, then loads them back with ld1Contiguous load, no interleaving. afterward. .align 4 before saved puts it on a 16-byte boundary, the size of one v register.

Each lane stands alone

A carry never crosses from one lane into the next. Add 40 to a byte lane that holds 250, and the true answer, 290, does not fit in 8 bits, so the lane keeps 290 - 256 = 34, while the lane beside it never sees the carry. For the brightness of a pixel that wraparound is wrong: a bright pixel turns nearly black. uqaddUnsigned saturating add. (unsigned saturating add) stops at the largest value instead, so 250 + 40 gives 255.

The program below brightens eight pixels both ways and prints each row through a small subroutine. It prints:

The pixel that held 215 lands on 255 exactly, so both rows agree there. Only the last two went past 255, and only those two differ between the rows.

Check yourself

1. How many lanes does v7.8h have, and how many bits is each one?
2. v0.4s holds 1, 2, 3 and 4, and v1.4s holds 10 in every lane. What does v2.4s hold after add v2.4s, v0.4s, v1.4s, and what does addv s3, v2.4s then leave in s3?
3. A byte lane holds 200. What does it hold after an addRd = Rn + Rm/imm. No flags. of 100, and what after a uqaddUnsigned saturating add. of 100?
4. A function keeps a 128-bit value in v9 and calls printf. Which part of v9 can it count on afterward?

Practice

• Basic quiz: floating point: the register file that the vectors share.
• Four lanes, one add: add one bonus to four scores with ld1Contiguous load, no interleaving., dupOne value into every lane, from a general register or from one lane. and a vector addRd = Rn + Rm/imm. No flags., and total them with addvSum of every lane, truncated to the lane's own width..
• Basic quiz: vectors: lanes and arrangements, uqaddUnsigned saturating add., dupOne value into every lane, from a general register or from one lane., copying a lane out, and which v registers a call may change.
• Predict: vectors (challenge): what lane-by-lane adds, a saturating subtract and addvSum of every lane, truncated to the lane's own width. leave in a register.