As instruções de múltiplicação são utilizadas para realizar as operações aritméticas multiplicação acumulada, não-acumulada, sinalizada e não-sinalizada com os tamanho de dados 32 e 64-bits.

Nessas instruções, apenas as flags de status N e Z são afetadas enquanto as flags restantes são inalteradas ou têm seu valor imprevisível.

As instruções são executadas de acordo com a condição <cond> utilizada. As flags de status N, Z, C, e V são alteradas quando o sufixo S é utilizado.

Mais informações sobre registradores, flags e condições podem ser vistas em Registradores e CPSR e Formato: Condições.

Notação utilizada

Essa instrução MLA, multiplica dois operandos/valores sinalizados ou não-sinalizados gerando um resultado em 32-Bits. Esse resultado é adicionado a um outro operando gerando um valor final acumulado que é armazenado no registrador destino.

Sintaxe

MLA{<cond>}{<S>} Rd, Rm, Rs, Rn

Operação

temp <- (Rm * Rs + Rn)
Rd <- temp[Bit 31-0]

Endereçamento:

Rm, Rs, Rn

CPSR

N: a
Z: a 
C: ?
V: -

Exemplo:

MOV R0, #00
MOV R3, #01
MOV R2, #02
MOV R1, #03
MLA R0, R1, R2, R3 ; R0 <- 3*2 + 1
MOV R3, R0

A instrução MLA, multiplica dois operandos/valores sinalizados ou não-sinalizados gerando um resultado em 32-Bits. Esse resultado é armazenado em um destino sem acumulação.

Sintaxe

MUL{<cond>}{<S>} Rd, Rm, Rs

Operação

temp <- (Rm * Rs)
Rd <- temp[Bit 31-0]

Endereçamento:

Rm, Rs

CPSR

N: a
Z: a 
C: ?
V: -

Exemplo:

MOV R0, #00
MOV R2, #02
MOV R1, #03
MLA R0, R1, R2, R3 ; R0 <- 3*2

Essa instrução SMLAL, multiplica dois operandos sinalizados gerando um resultado em 64-Bits. E esse resultado é adicionado a um valor 64-bits contido em outros dois registradores gerando um valor final acumulado e armazenado nos registradores de destino. Nessa instrução, a sinalização do operandos é estendida no resultado.

Sintaxe

SMLAL{<cond>}{<S>} RdLo, RdHi, Rm, Rs

Operação

temp64 <- (Rm * Rs)
RdLo, C <- (temp64 + RdLo)[Bit 31-0]
RdHi <- (temp64 >> 32) + RdHi + C

Endereçamento:

RdLo, RdHi, Rm, Rs

CPSR

N: a
Z: a 
C: ?
V: -

Exemplo:

MOV R0, #02
MOV R1, #00
MOV R3, #02
MOV R2, #FFFFFFFF ; 
MLA R0, R1, R2, R3 
;temp64 = Rm*Rs = 1FFFFFFFE
;(word)temp64 : FFFFFFFE
;R1: 02
;R1 <-  R1 + FFFFFFFE =  200000000
;C = 1
;R0: 0
;R0 <- R0 + (temp64 >> 32) + C

Essa instrução SMLUL, multiplica dois operandos/valores sinalizados gerando um resultado em 64-Bits. Esse resultado gerado é armazenado nos registradores de destino sem acumulação. Nessa instrução, a sinalização do operandos é mantida/estendida no resultado.

Sintaxe

SMLUL{<cond>}{<S>} RdLo, RdHi, Rm, Rs

Operação

temp64 <- (Rm * Rs)
RdLo <- temp64[bit31-0]
RdHi <- temp64 >> 32

Endereçamento:

RdLo, RdHi, Rm, Rs

CPSR

N: a
Z: a 
C: ?
V: -

Exemplo:

MOV R0, #02
MOV R1, #00
MOV R3, #02
MOV R2, #FFFFFFFF ; 
MLA R0, R1, R2, R3

A instrução UMLAL, multiplica dois operandos/valores não-sinalizados gerando um resultado em 64-Bits. E esse resultado é adicionado a um valor 64-bits contido em outros dois registradores gerando um valor final acumulado e armazenado nos registradores de destino. Nessa instrução, a sinalização do operandos não é mantida/estendida no resultado.

Sintaxe

SMLAL{<cond>}{<S>} RdLo, RdHi, Rm, Rs

Operação

temp64 <- (Rm * Rs)
RdLo, C <- (temp64 + RdLo)[Bit31 - 0]
RdHi <- (temp64 >> 32) + RdHi + C

Endereçamento:

RdLo, RdHi, Rm, Rs

CPSR

N: a
Z: a 
C: ?
V: -

Exemplo:

MOV R0, #02
MOV R1, #00
MOV R3, #02
MOV R2, #FFFFFFFF ; 
MLA R0, R1, R2, R3 

Essa instrução SMLAL, multiplica dois operandos/valores sinalizados gerando um resultado em 64-Bits. Esse resultado gerado é armazenado nos registradores de destino sem acumulação. Nessa instrução, a sinalização do operandos não é mantida/estendida no resultado.

Sintaxe

UMULL{<cond>}{<S>} RdLo, RdHi, Rm, Rs

Operação

temp64 <- (Rm * Rs)
RdLo <- temp64[Bit31 - 0]
RdHi <- temp64 >> 32

Endereçamento:

RdLo, RdHi, Rm, Rs

CPSR

N: a
Z: a 
C: ?
V: -

Exemplo:

MOV R0, #02
MOV R1, #00
MOV R3, #02
MOV R2, #FFFFFFFF ; 
MLA R0, R1, R2, R3