LDRAA, LDRAB
Load register, with pointer authentication
This instruction authenticates an address from a base register using
a modifier of zero and the specified key, adds an immediate offset
to the authenticated address, and loads a 64-bit doubleword from
memory at this resulting address into a register.
Key A is used for LDRAA. Key B is used for LDRAB.
If the authentication passes, the PE behaves the same as for an LDR instruction.
For information on behavior if the authentication fails, see
Faulting on pointer authentication.
The authenticated address is not written back to the base register,
unless the pre-indexed variant of the instruction is used. In this
case, the address that is written back to the base register does not
include the pointer authentication code.
For information about addressing modes, see
Load/Store addressing modes.
This instruction is a data-independent-time instruction as described in About PSTATE.DIT.
1
1
1
1
1
0
0
0
1
1
0
0
LDRAA <Xt>, [<Xn|SP>{, #<simm>}]
0
1
LDRAA <Xt>, [<Xn|SP>{, #<simm>}]!
1
0
LDRAB <Xt>, [<Xn|SP>{, #<simm>}]
1
1
LDRAB <Xt>, [<Xn|SP>{, #<simm>}]!
if !IsFeatureImplemented(FEAT_PAuth) then EndOfDecode(Decode_UNDEF); end;
let t : integer = UInt(Rt);
let n : integer = UInt(Rn);
var wback : boolean = W == '1';
let use_key_a : boolean = M == '0';
let S10 : bits(10) = S::imm9;
let offset : bits(64) = LSL(SignExtend{64}(S10), 3);
let nontemporal : boolean = FALSE;
let tagchecked : boolean = wback || n != 31;
var wb_unknown : boolean = FALSE;
if wback && n == t && n != 31 then
let c : Constraint = ConstrainUnpredictable(Unpredictable_WBOVERLAPLD);
assert c IN {Constraint_WBSUPPRESS, Constraint_UNKNOWN, Constraint_UNDEF, Constraint_NOP};
case c of
when Constraint_WBSUPPRESS => wback = FALSE; // writeback is suppressed
when Constraint_UNKNOWN => wb_unknown = TRUE; // writeback is UNKNOWN
when Constraint_UNDEF => EndOfDecode(Decode_UNDEF);
when Constraint_NOP => EndOfDecode(Decode_NOP);
end;
end;
<Xt>
Is the 64-bit name of the general-purpose register to be transferred, encoded in the "Rt" field.
<Xn|SP>
Is the 64-bit name of the general-purpose base register or stack pointer, encoded in the "Rn" field.
<simm>
Is the optional signed immediate byte offset, a multiple of 8 in the range -4096 to 4088, defaulting to 0 and encoded in the "S:imm9" field as <simm>/8.
var address : bits(64);
let privileged : boolean = PSTATE.EL != EL0;
let auth_then_branch : boolean = TRUE;
let accdesc : AccessDescriptor = CreateAccDescGPR(MemOp_LOAD, nontemporal, privileged,
tagchecked, t);
if n == 31 then
address = SP{64}();
else
address = X{64}(n);
end;
if use_key_a then
address = AuthDA(address, X{64}(31), auth_then_branch);
else
address = AuthDB(address, X{64}(31), auth_then_branch);
end;
if n == 31 then
CheckSPAlignment();
end;
address = AddressAdd(address, offset, accdesc);
X{64}(t) = Mem{64}(address, accdesc);
if wback then
if wb_unknown then
address = ARBITRARY : bits(64);
end;
if n == 31 then
SP{64}() = address;
else
X{64}(n) = address;
end;
end;
2026-03-12 12:23:09
2025-09_rel_asl1