LDM (exception return) Load Multiple (exception return) Load Multiple (exception return) loads multiple registers from consecutive memory locations using an address from a base register. The SPSR of the current mode is copied to the CPSR. An address adjusted by the size of the data loaded can optionally be written back to the base register. The registers loaded include the PC. The word loaded for the PC is treated as an address and a branch occurs to that address. The PE checks the encoding that is copied to the CPSR for an illegal return event. See Illegal return events from AArch32 state. Load Multiple (exception return) is: UNDEFINED in Hyp mode. UNPREDICTABLE in debug state, and in User mode and System mode. For more information about the CONSTRAINED UNPREDICTABLE behavior of this instruction, see Architectural Constraints on UNPREDICTABLE behaviors. Instructions with similar syntax but without the PC included in the registers list are described in LDM (User registers). This instruction is a data-independent-time instruction as described in About the DIT bit. != 1111 1 0 0 1 1 1 LDM{<amode>}{<c>}{<q>} <Rn>{!}, <registers_with_pc>^ let n : integer = UInt(Rn); let registers : bits(15) = register_list; let wback : boolean = (W == '1'); let increment : boolean = (U == '1'); let wordhigher : boolean = (P == U); if n == 15 then UnpredictableProcedure(); end; if wback && registers[n] == '1' then UnpredictableProcedure(); end; wback && registers<n> == '1' The instruction performs all the loads using the specified addressing mode and the content of the register being written back is UNKNOWN. In addition, if an exception occurs during the execution of this instruction, the base address might be corrupted so that the instruction cannot be repeated. <amode> is one of: DA Decrement After. The consecutive memory addresses end at the address in the base register. Encoded as P = 0, U = 0. FA Full Ascending. For this instruction, a synonym for DA. DB Decrement Before. The consecutive memory addresses end one word below the address in the base register. Encoded as P = 1, U = 0. EA Empty Ascending. For this instruction, a synonym for DB. IA Increment After. The consecutive memory addresses start at the address in the base register. This is the default. Encoded as P = 0, U = 1. FD Full Descending. For this instruction, a synonym for IA. IB Increment Before. The consecutive memory addresses start one word above the address in the base register. Encoded as P = 1, U = 1. ED Empty Descending. For this instruction, a synonym for IB. <c> See Standard assembler syntax fields. <q> See Standard assembler syntax fields. <Rn> Is the general-purpose base register, encoded in the "Rn" field. ! The address adjusted by the size of the data loaded is written back to the base register. If specified, it is encoded in the "W" field as 1, otherwise this field defaults to 0. <registers_with_pc> Is a list of one or more registers, separated by commas and surrounded by { and }. It specifies the set of registers to be loaded. The registers are loaded with the lowest-numbered register from the lowest memory address, through to the highest-numbered register from the highest memory address. The PC must be specified in the register list, and the instruction causes a branch to the address (data) loaded into the PC. See also Encoding of lists of general-purpose registers and the PC. if ConditionPassed() then EncodingSpecificOperations(); if PSTATE.EL == EL2 then Undefined(); elsif PSTATE.M IN {M32_User,M32_System} then UnpredictableProcedure(); // UNDEFINED or NOP else let length : integer = 4*BitCount(registers) + 4; var address : bits(32) = if increment then R(n) else R(n)-length; if wordhigher then address = address+4; end; var data : bits(32); for i = 0 to 14 do if registers[i] == '1' then if i != n then R(i) = MemS{32}(address); else data = MemS{32}(address); end; address = address + 4; end; end; let new_pc_value : bits(32) = MemS{32}(address); if wback && registers[n] == '1' then R(n) = ARBITRARY : bits(32); end; if wback && registers[n] == '0' then R(n) = if increment then R(n)+length else R(n)-length; end; if !wback && registers[n] == '1' then R(n) = data; end; AArch32_ExceptionReturn(new_pc_value, SPSR_curr()); end; end; PSTATE.M IN {M32_User,M32_System} 2026-03-12 12:23:09 2025-09_rel_asl1