Most of the binary operation instructions are of the form<\/p>\n
op x, y, z x = y op z\r\n<\/pre>\nThey take two source operands, combine them according to some operation, and put the result in the destination register.<\/p>\n
Similarly, most of the unary operation instructions look like<\/p>\n
op x, y ; x = op y\r\n<\/pre>\nThe destination is typically a numbered register or sp<\/var>, and can be a 64-bit register or a 32-bit subregister. If you use a 32-bit subregister, then the result is zero-extended to a 64-bit value.<\/p>\n
Okay, let’s start with addition:<\/p>\n
add Rd\/sp, Rn\/sp, #imm12\r\n add Rd\/sp, Rn\/sp, #imm12, LSL #12\r\n\r\n add Rd\/zr, Rn\/zr, Rm\/zr, LSL #n\r\n add Rd\/zr, Rn\/zr, Rm\/zr, LSR #n\r\n add Rd\/zr, Rn\/zr, Rm\/zr, ASR #n\r\n\r\n add Rd\/sp, Rn\/sp, Rm\/zr, UXTB #n ; 0 \u2264 n \u2264 4\r\n add Rd\/sp, Rn\/sp, Rm\/zr, UXTH #n ; 0 \u2264 n \u2264 4\r\n add Rd\/sp, Rn\/sp, Rm\/zr, UXTW #n ; 0 \u2264 n \u2264 4\r\n add Rd\/sp, Rn\/sp, Rm\/zr, UXTX #n ; 0 \u2264 n \u2264 4\r\n add Rd\/sp, Rn\/sp, Rm\/zr, SXTB #n ; 0 \u2264 n \u2264 4\r\n add Rd\/sp, Rn\/sp, Rm\/zr, SXTH #n ; 0 \u2264 n \u2264 4\r\n add Rd\/sp, Rn\/sp, Rm\/zr, SXTW #n ; 0 \u2264 n \u2264 4\r\n add Rd\/sp, Rn\/sp, Rm\/zr, SXTX #n ; 0 \u2264 n \u2264 4\r\n<\/pre>\nTo ask for flags to be set based on the result, apply an
S<\/code> suffix to the opcode, producingADDS<\/code>.<\/p>\nNote that some of these encodings permit the operand to be
sp<\/code>, but others allowzr<\/code>.<\/p>\nThe first two versions add an immediate. It is either a 12-bit unsigned immediate (0 \u2264 n<\/var> \u2264 4095) or a 12-bit unsigned immediate shifted left by 12. This means that you can express constants of the form
0x00000XXX<\/code> and0x00XXX000<\/code>. The disassembler does theLSL #12<\/code> for you, so you won’t actually see the#imm12, LSL #12<\/code> version disassembled as such. Instead, you’ll see the shifted constant:<\/p>\nadd x0, x1, #0x123000 ; encoded as #0x123, LSL #12\r\n<\/pre>\nThe next block of variants adds a shifted register. You are allowed to shift doublewords by up to 63 positions and words up to 31 positions. You don’t need any larger shifts, because unsigned shifting by an amount greater than or equal to the operand bit size just gives you zero, so you should just have used zr<\/var>. And signed shifting right by an amount greater than or equal to the operand size is the same as shifting right by one less than the operand bit size.<\/p>\n
The last block lets you use the extended registers. You can use all of the extended forms, and the shift amount can be up to four positions. These extended registers with shifts are convenient for calculating array offsets:<\/p>\n
; x0 = x1 + (int32_t)x2 * 16\r\n add x0, x1, x2, SXTW #4\r\n<\/pre>\nIn this case, x1<\/var> is the base of an array where each element is of size 16, and x2<\/var> is a 32-bit signed array index, and we calculate the address of the element into x0<\/var>.<\/p>\n
The ARM uses true carry. This means that for subtraction, the carry is clear when a borrow occurs, and subtract with carry subtracts an additional unit if inbound carry is clear.<\/p>\n
The subtraction instruction has the same available variants as the addition instructions.<\/p>\n
; calculate x = y - z\r\n sub x, y, z ; same options as add\r\n\r\n ; calculate x = y - z, set flags\r\n subs x, y, z ; same options as adds\r\n<\/pre>\nAdding and subtracting with carry have only one encoding option.<\/p>\n
; Rd = Rn + Rm + carry\r\n adc Rd\/zr, Rn\/zr, Rm\/zr\r\n\r\n ; Rd = Rn + Rm + carry, set flags\r\n adcs Rd\/zr, Rn\/zr, Rm\/zr\r\n\r\n ; Rd = Rn - Rm - !carry\r\n sbc Rd\/zr, Rn\/zr, Rm\/zr\r\n\r\n ; Rd = Rn - Rm - !carry, set flags\r\n sbcs Rd\/zr, Rn\/zr, Rm\/zr\r\n<\/pre>\nFrom the addition and subtraction instructions, we can construct these pseudo-instructions, taking advantage of literal zeros and the hard-coded zero register: Reads from the zero register produce zero, and writes to the zero register are discarded.<\/p>\n
; move register to\/from sp\r\n mov sp, Rn ; add sp, Rn, #0\r\n mov Rn, sp ; add Rn, sp, #0\r\n\r\n ; move constant to register\r\n mov Rn, #imm12 ; add Rn, zr, #imm12\r\n mov Rn, #imm12, LSL #12 ; add Rn, zr, #imm12, LSL #12\r\n<\/pre>\nAdding zero gives you the ability to move between sp<\/var> and the general-purpose registers. And adding an immediate to the zero register loads a constant. We’ll see later that other register-to-register moves are encoded with a different pseudo-instruction, and there are plenty of options for loading constants beyond just this one.<\/p>\n
The use of true carry permits the following group of pseudo-instructions for adding or subtracting negative numbers:<\/p>\n
add a, b, #-n ; sub a, b, #n\r\n adds a, b, #-n ; subs a, b, #n\r\n\r\n sub a, b, #-n ; add a, b, #n\r\n subs a, b, #-n ; adds a, b, #n\r\n<\/pre>\nThe immediate operand to the
ADD<\/code> andSUB<\/code> instruction families is treated as unsigned, but you can switch to the opposite instruction to get negative values (provided n<\/var> \u2260 0). Note that this works due to ARM’s use of true carry. (If ARM had used borrow, then this conversion would set the carry bit incorrectly.)<\/p>\ncmp x, y ; subs zr, x, y\r\n cmn x, y ; adds zr, x, y\r\n<\/pre>\n