ADDHA

Add horizontally vector elements to ZA tile

This instruction adds each element of the source vector to the corresponding Active element of each horizontal slice of a ZA tile. The tile elements are predicated by a pair of governing predicates. An element of a horizontal slice is considered active if its corresponding element in the second governing predicate is TRUE and the element corresponding to its horizontal slice number in the first governing predicate is TRUE. Inactive elements in the destination tile remain unmodified.

ID_AA64SMFR0_EL1.I16I64 indicates whether the 64-bit integer variant is implemented.

It has encodings from 2 classes: 32-bit and 64-bit

32-bit
(FEAT_SME)

313029282726252423222120191817161514131211109876543210
1100000010010000PmPnZn000ZAda
opV

Encoding

ADDHA <ZAda>.S, <Pn>/M, <Pm>/M, <Zn>.S

Decode for this encoding

if !IsFeatureImplemented(FEAT_SME) then EndOfDecode(Decode_UNDEF); end; let esize : integer{} = 32; let a : integer = UInt(Pn); let b : integer = UInt(Pm); let n : integer = UInt(Zn); let da : integer = UInt(ZAda);

64-bit
(FEAT_SME_I16I64)

313029282726252423222120191817161514131211109876543210
1100000011010000PmPnZn00ZAda
opV

Encoding

ADDHA <ZAda>.D, <Pn>/M, <Pm>/M, <Zn>.D

Decode for this encoding

if !IsFeatureImplemented(FEAT_SME_I16I64) then EndOfDecode(Decode_UNDEF); end; let esize : integer{} = 64; let a : integer = UInt(Pn); let b : integer = UInt(Pm); let n : integer = UInt(Zn); let da : integer = UInt(ZAda);

Assembler Symbols

<ZAda>

For the "32-bit" variant: is the name of the ZA tile ZA0-ZA3, encoded in the "ZAda" field.

For the "64-bit" variant: is the name of the ZA tile ZA0-ZA7, encoded in the "ZAda" field.

<Pn>

Is the name of the first governing scalable predicate register P0-P7, encoded in the "Pn" field.

<Pm>

Is the name of the second governing scalable predicate register P0-P7, encoded in the "Pm" field.

<Zn>

Is the name of the source scalable vector register, encoded in the "Zn" field.

Operation

CheckStreamingSVEAndZAEnabled(); let VL : integer{} = CurrentVL(); let PL : integer{} = VL DIV 8; let dim : integer{} = VL DIV esize; let mask1 : bits(PL) = P{}(a); let mask2 : bits(PL) = P{}(b); let operand_src : bits(VL) = Z{}(n); let operand_acc : bits(dim*dim*esize) = ZAtile{}(da, esize); var result : bits(dim*dim*esize); for col = 0 to dim-1 do let element : bits(esize) = operand_src[col*:esize]; for row = 0 to dim-1 do var res : bits(esize) = operand_acc[(row*dim+col)*:esize]; if (ActivePredicateElement{PL}(mask1, row, esize) && ActivePredicateElement{PL}(mask2, col, esize)) then res = res + element; end; result[(row*dim+col)*:esize] = res; end; end; ZAtile{dim*dim*esize}(da, esize) = result;

Operational information

This instruction is a data-independent-time instruction as described in About PSTATE.DIT.


2026-03_rel 2026-03-26 20:48:11

Copyright © 2010-2026 Arm Limited or its affiliates. All rights reserved. This document is Non-Confidential.