Multiplication #

When a processor does multiplication, it doesn’t quite do multiplication in the way you can do it in your head. It uses a process you probably wouldn’t think about. In fact, with the ARM processors, every multiply operation takes at least ~4-6 cycles.

MUL operation #

The MUL operation is the “basic” multiplication operation. It takes the format mul Rd, Rn, Rm where Rd is the destination and Rn and Rm are input registers.

This opcode, as well as all of the other multiply opcodes, only take registers as inputs: there is no possibility to use the flexible operand2.

MLA operation #

MLA stands for multiply and accumulate. As it sounds, this operation multiples two registers and then adds the value to another register. The format is mla Rd, Rm, Rs, Rn where Rd = (Rm * Rs) + Rn.

You may have (or many not have) realized something. If you take two 32-bit numbers, multiply them together, you will possibly get a number that takes up more than 32-bits. The above operations (MUL, MLA) will only return the 32 least significant bits. The 32 most significant bits are discarded. For that reason, there are the following operations.

MULL and MLAL operations #

These are the “multiply long” and “multiply long and accumulate” operations. However, to complicate things a little more, they never exist in this form. They are always prefixed with a ‘U’ and a ‘S’ to indicate unsigned or signed multiplication.

    umull       r1, r2, r3, r4      @ r3 * r4, store high bits in r2, low in r1 
    smull       r1, r2, r3, r4      @ same as above, but for signed numbers 
    umlal       r1, r2, r3, r4      @ (r3 * r4) + (r2,r1) 
                                    @ high bits in r2, low bits in r1 
    smlal       r1, r2, r3, r4      @ same as above, but for signed numbers        

SMULxy and SMLAxy operations #

Only because your head isn’t spinning enough, you can add letters to the end of the signed multiplication opcode to multiply two 16-bit integers and store them in a 32-bit register. The x and y can either be a t or a b to indicate the top or bottom half of the registers.

    smultb      r1, r2, r3      @ multiply the top 16 bits of r2 and the 
                                @ bottom 16 bits of r3 and store in r1 
    smulbb      r1, r2, r3      @ multiply the bottom 16 bits of r2 and the
                                @ bottom 16 bits of r3 and store in r1