SMLAD, SMLADX
Signed Multiply Accumulate Dual
Signed Multiply Accumulate Dual performs two signed 16 x 16-bit
multiplications. It adds the products to a 32-bit accumulate operand.
Optionally, the instruction can exchange the halfwords of
the second operand before performing the arithmetic. This produces
top x bottom and bottom x top multiplication.
This instruction sets PSTATE.Q to 1 if the accumulate operation
overflows. Overflow cannot occur during the multiplications.
For more information about the CONSTRAINED UNPREDICTABLE behavior of this instruction, see Architectural Constraints on UNPREDICTABLE behaviors.
It has encodings from the following instruction sets:
A32 (
A1
)
and
T32 (
T1
)
.
!= 1111
0
1
1
1
0
0
0
0
!= 1111
0
0
1
0
SMLAD{<c>}{<q>} <Rd>, <Rn>, <Rm>, <Ra>
1
SMLADX{<c>}{<q>} <Rd>, <Rn>, <Rm>, <Ra>
if Ra == '1111' then See("SMUAD"); end;
let d : integer = UInt(Rd);
let n : integer = UInt(Rn);
let m : integer = UInt(Rm);
let a : integer = UInt(Ra);
let m_swap : boolean = (M == '1');
if d == 15 || n == 15 || m == 15 then UnpredictableProcedure(); end;
1
1
1
1
1
0
1
1
0
0
1
0
!= 1111
0
0
0
0
SMLAD{<c>}{<q>} <Rd>, <Rn>, <Rm>, <Ra>
1
SMLADX{<c>}{<q>} <Rd>, <Rn>, <Rm>, <Ra>
if Ra == '1111' then See("SMUAD"); end;
let d : integer = UInt(Rd);
let n : integer = UInt(Rn);
let m : integer = UInt(Rm);
let a : integer = UInt(Ra);
let m_swap : boolean = (M == '1');
// Armv8-A removes UNPREDICTABLE for R13
if d == 15 || n == 15 || m == 15 then UnpredictableProcedure(); end;
<c>
See Standard assembler syntax fields.
<q>
See Standard assembler syntax fields.
<Rd>
Is the general-purpose destination register, encoded in the "Rd" field.
<Rn>
Is the first general-purpose source register, encoded in the "Rn" field.
<Rm>
Is the second general-purpose source register, encoded in the "Rm" field.
<Ra>
Is the third general-purpose source register holding the addend, encoded in the "Ra" field.
if ConditionPassed() then
EncodingSpecificOperations();
let operand2 : bits(32) = if m_swap then ROR(R(m),16) else R(m);
let product1 : integer = SInt(R(n)[15:0]) * SInt(operand2[15:0]);
let product2 : integer = SInt(R(n)[31:16]) * SInt(operand2[31:16]);
let result : integer = product1 + product2 + SInt(R(a));
R(d) = result[31:0];
if result != SInt(result[31:0]) then // Signed overflow
PSTATE.Q = '1';
end;
end;
2026-03-26 20:27:25
2026-03_rel